From b3a5a0b345822ff50a225a3e4e8db7511e8e9f2e Mon Sep 17 00:00:00 2001
From: Hans Dijkema <hans@dijkewijk.nl>
Date: Sat, 29 Aug 2026 22:25:06 +0200
Subject: [PATCH] refactoring volgens skill

---
 .gitignore                       |   1 +
 ARCHITECTURE.md                  |   7 +-
 README.md                        |  22 +-
 info.rkt                         |   1 +
 main.rkt                         |   2 +-
 player-agent-cli.rkt             | 184 ++++++----
 player-agent.rkt                 |  23 +-
 private/dlna-playback.rkt        |  28 +-
 private/library.rkt              |   6 +-
 private/player-agent-config.rkt  | 117 ++++--
 private/player-agent-core.rkt    | 556 +++++++++++++++-------------
 private/player-agent-gui.rkt     | 610 +++++++++++++++++++------------
 private/player-agent-tray.rkt    |  36 --
 private/player.rkt               |   8 +-
 private/playlists.rkt            |  16 +-
 private/users.rkt                | 133 ++++---
 public/rkt-web-player.png        | Bin 0 -> 61450 bytes
 scribblings/rkt-web-player.scrbl |  16 +-
 set-user.rkt                     |  48 ++-
 skill/racket-skill.md            | 227 ------------
 20 files changed, 1043 insertions(+), 998 deletions(-)
 delete mode 100644 private/player-agent-tray.rkt
 create mode 100644 public/rkt-web-player.png
 delete mode 100644 skill/racket-skill.md

diff --git a/.gitignore b/.gitignore
index a9e5940..746f237 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,3 +25,4 @@ rkt-web-player.ini
 
 # Runtime playlist keystore
 data/*.keystore*
+/.scribble-build
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 5447702..725bf7b 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -386,9 +386,10 @@ random application ID therefore acts as a shared bearer credential, but must
 not be treated as strong authentication when transported over unencrypted HTTP.
 
 The GUI and CLI playback agents share one headless runtime. The GUI only adapts
-configuration and state to widgets. Optional tray integration is loaded
-dynamically through SDL3, so CLI use and the default GUI installation do not
-acquire a mandatory SDL dependency.
+configuration and state to widgets. It uses `racket-tray` directly for its
+native tray icon, symbolic Open/Exit menu and portable hide-on-minimize
+behaviour. The previous SDL3 adapter and its update timer are no longer part of
+the process.
 
 The configured library roots define the intended filesystem boundary. Clients
 operate on opaque indexes instead of sending paths directly. The DLNA backend
diff --git a/README.md b/README.md
index 9e25945..3cb2765 100644
--- a/README.md
+++ b/README.md
@@ -193,22 +193,20 @@ opgeruimd zodra ze niet meer nodig zijn en bij afsluiten van de agent.
 
 ### Systeemvak
 
-De GUI gebruikt optioneel de open-source SDL3-tray-API. Als zowel het Racket-
-pakket `sdl3` als de native SDL3-, SDL3_image- en SDL3_ttf-libraries aanwezig
-zijn, sluit de vensterknop de agent naar het systeemvak. Het menu bevat
-**RKT Web Player Agent openen** en **Afsluiten**. Zonder SDL3 blijft de agent
-gewoon werken en sluit de vensterknop het proces af. Er wordt geen PowerShell-
-proces of externe tray-helper gestart.
+De GUI gebruikt het Racket-pakket `racket-tray`. Minimaliseren en de
+vensterknop verbergen de agent in het systeemvak. Het menu bevat
+**RKT Web Player Agent openen** en **Afsluiten**; openen herstelt ook een
+geminimaliseerd venster. De tray is onderdeel van de normale package-
+dependencies en vereist geen SDL3-pakket of SDL3-libraries meer.
+
+Windows en macOS gebruiken de native systeemvoorzieningen zonder aanvullende
+runtime. Op Linux gebruikt `racket-tray` Ayatana AppIndicator voor GTK3. Op
+Debian en Ubuntu kan die runtime zo worden geïnstalleerd:
 
 ```console
-raco pkg install sdl3
+sudo apt install libayatana-appindicator3-1
 ```
 
-SDL3 is bewust geen verplichte package-dependency: de agent blijft daardoor
-klein voor gebruikers die geen systeemvak nodig hebben. Op Windows moeten de
-bijbehorende native DLL's daarnaast vindbaar zijn, bijvoorbeeld naast het
-gebouwde executable of via `PATH`.
-
 ### CLI playback agent
 
 De headless agent gebruikt exact dezelfde polling-, download-, audio- en
diff --git a/info.rkt b/info.rkt
index 88dfc10..c8acfbe 100644
--- a/info.rkt
+++ b/info.rkt
@@ -18,6 +18,7 @@
     "racket-audio-dlna"
     "racket-mimetypes"
     "racket-sonos"
+    "racket-tray"
     "racket-upnp"
     "simple-ini"
     "simple-log"
diff --git a/main.rkt b/main.rkt
index bebb111..3e66245 100644
--- a/main.rkt
+++ b/main.rkt
@@ -36,7 +36,7 @@
 
 (define (configuration-list value defaults)
   (cond
-    ((list? value) (map (lambda (item) (format "~a" item)) value))
+    ((list? value) (map (λ (item) (format "~a" item)) value))
     ((and (string? value)
           (not (string=? (string-trim value) "")))
      (map string-trim (string-split value ";")))
diff --git a/player-agent-cli.rkt b/player-agent-cli.rkt
index bf913be..d9639f2 100644
--- a/player-agent-cli.rkt
+++ b/player-agent-cli.rkt
@@ -1,6 +1,7 @@
 #lang racket/base
 
 (require racket/cmdline
+         racket/contract
          racket/format
          racket/string
          simple-log
@@ -9,87 +10,120 @@
 
 (provide run-player-agent-cli)
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Supporting functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Produce a concise description of the current agent track.
+; pre    : track is #f or a server-supplied track hash.
+; post   : No state is changed.
+; result : Artist and title when available, otherwise title or filename.
+; internals:
+;          The CLI deliberately uses server metadata and does not reopen the
+;          downloaded media file solely for display purposes.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (define (track-description track)
   (cond
     ((not track) "geen track")
     (else
-     (define title (hash-ref track 'title #f))
-     (define artist (hash-ref track 'artist #f))
-     (define filename (hash-ref track 'filename "onbekend"))
-     (cond
-       ((and artist title (not (string=? artist "")))
-        (format "~a — ~a" artist title))
-       (title title)
-       (else filename)))))
+     (let ((title (hash-ref track 'title #f))
+           (artist (hash-ref track 'artist #f))
+           (filename (hash-ref track 'filename "onbekend")))
+       (cond
+         ((and artist title (not (string=? artist "")))
+          (format "~a — ~a" artist title))
+         (title title)
+         (else filename))))))
 
-(define (run-player-agent-cli #:server-url [server-override #f]
-                              #:name [name-override #f]
-                              #:config-file [config-file #f])
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Provided functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Run the headless polling playback agent.
+; pre    : Overrides are #f or valid strings/paths and the configured server
+;          is reachable for useful operation.
+; post   : Configuration is persisted; runtime resources are released after
+;          interruption or an exception.
+; result : Void after the agent has shut down.
+; internals:
+;          One monitor thread prints only changed playback summaries. The
+;          shared runtime owns polling, downloads, audio and prefetch state.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define/contract (run-player-agent-cli #:server-url [server-override #f]
+                                       #:name [name-override #f]
+                                       #:config-file [config-file #f])
+  (->* ()
+       (#:server-url (or/c string? #f)
+        #:name (or/c string? #f)
+        #:config-file (or/c path-string? #f))
+       void?)
   (sl-log-to-display)
-  (define loaded
-    (if config-file
-        (load-player-agent-config config-file)
-        (load-player-agent-config)))
-  (define server-url
-    (string-trim (or server-override
-                     (player-agent-config-server-url loaded))))
-  (define name
-    (string-trim (or name-override
-                     (player-agent-config-name loaded))))
-  (define config
-    (struct-copy player-agent-config loaded
-                 (server-url server-url)
-                 (name name)))
-  (save-player-agent-config! config)
-
-  (define (write-status message)
-    (printf "[agent] ~a~n" message)
-    (flush-output))
-
-  (define runtime
-    (make-player-agent-runtime
-     server-url
-     name
-     (player-agent-config-app-id config)
-     #:status-callback write-status
-     #:denied-callback
-     (lambda (message)
-       (eprintf "~a~n" message)
-       (flush-output (current-error-port)))))
-
-  (printf "RKT Web Player CLI Agent~n")
-  (printf "Naam:          ~a~n" name)
-  (printf "Server:        ~a~n" server-url)
-  (printf "Applicatie-ID: ~a~n" (player-agent-config-app-id config))
-  (printf "Stoppen:       Ctrl+C~n")
-  (flush-output)
-
-  (define monitor #f)
-  (dynamic-wind
-    (lambda ()
-      ((player-agent-runtime-start! runtime))
-      (set! monitor
-            (thread
-             (lambda ()
-               (let loop ((previous #f))
-                 (define snapshot
-                   ((player-agent-runtime-snapshot runtime)))
-                 (define summary
-                   (cons (hash-ref snapshot 'state "stopped")
-                         (track-description
-                          ((player-agent-runtime-current-track runtime)))))
-                 (unless (equal? summary previous)
-                   (printf "[playback] ~a — ~a~n" (car summary) (cdr summary))
-                   (flush-output))
-                 (sleep 1)
-                 (loop summary))))))
-    (lambda ()
-      (with-handlers ((exn:break? void))
-        (sync never-evt)))
-    (lambda ()
-      (when (and monitor (not (thread-dead? monitor)))
-        (kill-thread monitor))
-      ((player-agent-runtime-shutdown! runtime)))))
+  (let* ((loaded
+          (if config-file
+              (load-player-agent-config config-file)
+              (load-player-agent-config)))
+         (server-url
+          (string-trim (or server-override
+                           (player-agent-config-server-url loaded))))
+         (name
+          (string-trim (or name-override
+                           (player-agent-config-name loaded))))
+         (config
+          (struct-copy player-agent-config loaded
+                       (server-url server-url)
+                       (name name)))
+         (write-status
+          (λ (message)
+            (printf "[agent] ~a~n" message)
+            (flush-output)))
+         (runtime
+          (make-player-agent-runtime
+           server-url
+           name
+           (player-agent-config-app-id config)
+           #:status-callback write-status
+           #:denied-callback
+           (λ (message)
+             (eprintf "~a~n" message)
+             (flush-output (current-error-port)))))
+         (monitor #f))
+    (save-player-agent-config! config)
+    (printf "RKT Web Player CLI Agent~n")
+    (printf "Naam:          ~a~n" name)
+    (printf "Server:        ~a~n" server-url)
+    (printf "Applicatie-ID: ~a~n" (player-agent-config-app-id config))
+    (printf "Stoppen:       Ctrl+C~n")
+    (flush-output)
+    (dynamic-wind
+      (λ ()
+        ((player-agent-runtime-start! runtime))
+        (set! monitor
+              (thread
+               (λ ()
+                 (let loop ((previous #f))
+                   (let* ((snapshot
+                           ((player-agent-runtime-snapshot runtime)))
+                          (summary
+                           (cons
+                            (hash-ref snapshot 'state "stopped")
+                            (track-description
+                             ((player-agent-runtime-current-track runtime))))))
+                     (unless (equal? summary previous)
+                       (printf "[playback] ~a — ~a~n"
+                               (car summary)
+                               (cdr summary))
+                       (flush-output))
+                     (sleep 1)
+                     (loop summary)))))))
+      (λ ()
+        (with-handlers ((exn:break? void))
+          (sync never-evt)))
+      (λ ()
+        (when (and monitor (not (thread-dead? monitor)))
+          (kill-thread monitor))
+        ((player-agent-runtime-shutdown! runtime))))))
 
 (module+ main
   (define server-url #f)
diff --git a/player-agent.rkt b/player-agent.rkt
index 4d15d51..8f466cb 100644
--- a/player-agent.rkt
+++ b/player-agent.rkt
@@ -1,5 +1,8 @@
 #lang racket/base
 
+(require racket/class
+         racket/contract)
+
 (provide run-player-agent
          run-player-agent-cli)
 
@@ -8,8 +11,12 @@
 ; pre    : A graphical desktop is available.
 ; post   : The agent remains active until its window is closed.
 ; result : The GUI frame returned by the implementation.
+; internals:
+;          The GUI module is loaded only when this procedure is called. This
+;          keeps command-line use independent of racket/gui initialization.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (run-player-agent)
+(define/contract (run-player-agent)
+  (-> object?)
   ((dynamic-require "private/player-agent-gui.rkt"
                     'run-player-agent-gui)))
 
@@ -18,10 +25,18 @@
 ; pre    : The configured server is reachable.
 ; post   : The agent remains active until interrupted.
 ; result : Void after the agent has shut down.
+; internals:
+;          Delayed loading keeps the graphical and headless entrypoints
+;          separate while preserving the existing public module API.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (run-player-agent-cli #:server-url [server-url #f]
-                              #:name [name #f]
-                              #:config-file [config-file #f])
+(define/contract (run-player-agent-cli #:server-url [server-url #f]
+                                       #:name [name #f]
+                                       #:config-file [config-file #f])
+  (->* ()
+       (#:server-url (or/c string? #f)
+        #:name (or/c string? #f)
+        #:config-file (or/c path-string? #f))
+       void?)
   ((dynamic-require "player-agent-cli.rkt" 'run-player-agent-cli)
    #:server-url server-url
    #:name name
diff --git a/private/dlna-playback.rkt b/private/dlna-playback.rkt
index 77cd5a8..956c2b8 100644
--- a/private/dlna-playback.rkt
+++ b/private/dlna-playback.rkt
@@ -77,7 +77,7 @@
        (list-ref (current-tracks playback) index)))
 
 (define (normalized-file file)
-  (with-handlers ((exn:fail? (lambda (_) (format "~a" file))))
+  (with-handlers ((exn:fail? (λ (_) (format "~a" file))))
     (path->string (path->complete-path file))))
 
 (define (same-file? first second)
@@ -136,7 +136,7 @@
       ((not (equal? following (dlna-playback-prepared-index playback)))
        (with-handlers
            ((exn:fail?
-             (lambda (exception)
+             (λ (exception)
                (set-dlna-playback-prepared-index! playback #f)
                (warn-web-player-dlna
                 "Could not prepare next DLNA track: ~a"
@@ -155,7 +155,7 @@
      "index" index))
   (with-handlers
       ((exn:fail?
-        (lambda (exception)
+        (λ (exception)
           (report-failure! playback (exn-message exception))
           (raise exception))))
     (dlna-player-play! (dlna-playback-player playback) (track-file item))
@@ -286,11 +286,11 @@
       (when (dlna-playback-running? playback)
         (with-handlers
             ((exn:fail?
-              (lambda (exception)
+              (λ (exception)
                 (warn-web-player-dlna
                  "Could not update DLNA playback state: ~a"
                  (exn-message exception)))))
-          (with-lock playback (lambda () (poll/locked! playback))))
+          (with-lock playback (λ () (poll/locked! playback))))
         (loop)))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -319,26 +319,26 @@
   playback)
 
 (define (dlna-playback-play-index! playback index)
-  (with-lock playback (lambda () (play-index/locked! playback index))))
+  (with-lock playback (λ () (play-index/locked! playback index))))
 
 (define (dlna-playback-pause! playback)
   (with-lock
    playback
-   (lambda ()
+   (λ ()
      (dlna-player-pause! (dlna-playback-player playback))
      (notify! playback 'paused (dlna-player-info (dlna-playback-player playback))))))
 
 (define (dlna-playback-resume! playback)
   (with-lock
    playback
-   (lambda ()
+   (λ ()
      (dlna-player-resume! (dlna-playback-player playback))
      (notify! playback 'playing (dlna-player-info (dlna-playback-player playback))))))
 
 (define (dlna-playback-stop! playback)
   (with-lock
    playback
-   (lambda ()
+   (λ ()
      (set-dlna-playback-stop-requested?! playback #t)
      (set-dlna-playback-playing-seen?! playback #f)
      (set-dlna-playback-progress-seen?! playback #f)
@@ -351,7 +351,7 @@
 (define (dlna-playback-seek-percentage! playback percentage)
   (with-lock
    playback
-   (lambda ()
+   (λ ()
      (dlna-player-seek-percentage! (dlna-playback-player playback) percentage)
      ;; racket-audio-dlna updates its cache synchronously after Seek. Publish
      ;; that value immediately so the web slider does not jump back.
@@ -363,7 +363,7 @@
 (define (dlna-playback-volume! playback percentage)
   (with-lock
    playback
-   (lambda ()
+   (λ ()
      (dlna-player-volume! (dlna-playback-player playback) percentage)
      (define info (dlna-player-info (dlna-playback-player playback)))
      (notify! playback
@@ -373,7 +373,7 @@
 (define (dlna-playback-repeat! playback repeat)
   (with-lock
    playback
-   (lambda ()
+   (λ ()
      (set-dlna-playback-repeat! playback repeat)
      (set-dlna-playback-prepared-index! playback #f)
      (prepare-next! playback))))
@@ -387,7 +387,7 @@
     (set-dlna-playback-monitor! playback #f)
     (with-lock
      playback
-     (lambda ()
+     (λ ()
        (dlna-player-close! (dlna-playback-player playback))))))
 
 (module+ test
@@ -400,7 +400,7 @@
     (track (build-path "music" "02.flac")
            "Second" "Artist" "Album" 60 "audio/flac"))
   (define playback
-    (dlna-playback #f (lambda () (list first second)) void void
+    (dlna-playback #f (λ () (list first second)) void void
                    'off 0 #f #f #f #f #f #f 0 #f #t #f #f
                    (make-semaphore 1)))
 
diff --git a/private/library.rkt b/private/library.rkt
index 35b683d..c1bf338 100644
--- a/private/library.rkt
+++ b/private/library.rkt
@@ -139,12 +139,12 @@
        (file-exists? file)
        (audio-file? file)
        (let ((full-file
-              (with-handlers ((exn:fail? (lambda (_) #f)))
+              (with-handlers ((exn:fail? (λ (_) #f)))
                 (simplify-path (path->complete-path file) #t))))
          (and full-file
               (for/or ((library (in-list libraries)))
                 (define root
-                  (with-handlers ((exn:fail? (lambda (_) #f)))
+                  (with-handlers ((exn:fail? (λ (_) #f)))
                     (simplify-path
                      (path->complete-path (music-library-root library))
                      #t)))
@@ -185,7 +185,7 @@
               (list name
                     (normal-case-path
                      (path->complete-path path)))))
-          (lambda (first second)
+          (λ (first second)
             (equal? (cadr first) (cadr second))))))
     (for/list ((named-root (in-list roots))
                (index (in-naturals)))
diff --git a/private/player-agent-config.rkt b/private/player-agent-config.rkt
index 871a45f..0624a74 100644
--- a/private/player-agent-config.rkt
+++ b/private/player-agent-config.rkt
@@ -1,6 +1,7 @@
 #lang racket/base
 
 (require file/sha1
+         racket/contract
          racket/os
          racket/path
          racket/random
@@ -14,35 +15,75 @@
 
 (struct player-agent-config (file ini app-id server-url name) #:transparent)
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Supporting functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (define (fresh-app-id)
   (bytes->hex-string (crypto-random-bytes 32)))
 
-(define (valid-app-id? value)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Provided functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Recognize a playback-agent application identifier.
+; pre    : value is any Racket value.
+; post   : No state is changed.
+; result : #t only for a 256-bit identifier encoded as 64 hexadecimal digits.
+; internals:
+;          Identifiers are accepted case-insensitively and normalized while
+;          loading configuration.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define/contract (valid-app-id? value)
+  (-> any/c boolean?)
   (and (string? value)
-       (regexp-match? #px"^[0-9a-fA-F]{64}$" value)))
+       (regexp-match? #px"^[0-9a-fA-F]{64}$" value)
+       #t))
 
-(define (load-player-agent-config [file (get-ini-file 'rkt-web-player-agent)])
-  (define ini (file->ini file))
-  (define configured-id (ini-get ini 'agent 'app-id #f))
-  (define value
-    (player-agent-config
-     file
-     ini
-     (if (valid-app-id? configured-id)
-         (string-downcase configured-id)
-         (fresh-app-id))
-     (ini-get ini 'server 'url "http://127.0.0.1:8080")
-     (ini-get ini 'agent 'name
-              (format "~a playback" (gethostname)))))
-  (save-player-agent-config! value)
-  value)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Load the playback-agent INI configuration.
+; pre    : file is a writable path-string understood by simple-ini.
+; post   : Missing defaults and a generated application ID are persisted.
+; result : A player-agent-config value containing normalized settings.
+; internals:
+;          Reusing the stored application ID preserves the server allowlist;
+;          only a missing or malformed identifier is replaced.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define/contract (load-player-agent-config
+                  [file (get-ini-file 'rkt-web-player-agent)])
+  (->* () (path-string?) player-agent-config?)
+  (let* ((ini (file->ini file))
+         (configured-id (ini-get ini 'agent 'app-id #f))
+         (value
+          (player-agent-config
+           file
+           ini
+           (if (valid-app-id? configured-id)
+               (string-downcase configured-id)
+               (fresh-app-id))
+           (ini-get ini 'server 'url "http://127.0.0.1:8080")
+           (ini-get ini 'agent 'name
+                    (format "~a playback" (gethostname))))))
+    (save-player-agent-config! value)
+    value))
 
-(define (save-player-agent-config! value)
-  (define ini (player-agent-config-ini value))
-  (ini-set! ini 'agent 'app-id (player-agent-config-app-id value))
-  (ini-set! ini 'agent 'name (player-agent-config-name value))
-  (ini-set! ini 'server 'url (player-agent-config-server-url value))
-  (ini->file ini (player-agent-config-file value) #:private? #t))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Persist a playback-agent configuration.
+; pre    : value is a player-agent-config with a writable file path.
+; post   : Its ID, name and server URL are stored in a private INI file.
+; result : The result returned by simple-ini's ini->file procedure.
+; internals:
+;          The existing parsed INI value is updated directly so unrelated
+;          settings remain intact.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define/contract (save-player-agent-config! value)
+  (-> player-agent-config? void?)
+  (let ((ini (player-agent-config-ini value)))
+    (ini-set! ini 'agent 'app-id (player-agent-config-app-id value))
+    (ini-set! ini 'agent 'name (player-agent-config-name value))
+    (ini-set! ini 'server 'url (player-agent-config-server-url value))
+    (ini->file ini (player-agent-config-file value) #:private? #t)))
 
 (module+ test
   (require rackunit
@@ -52,18 +93,18 @@
   (define test-file (build-path test-directory "agent.ini"))
   (dynamic-wind
     void
-    (lambda ()
-      (define first (load-player-agent-config test-file))
-      (check-true (valid-app-id? (player-agent-config-app-id first)))
-      (define changed
-        (struct-copy player-agent-config first
-                     (server-url "https://music.example.test")
-                     (name "Test output")))
-      (save-player-agent-config! changed)
-      (define second (load-player-agent-config test-file))
-      (check-equal? (player-agent-config-app-id second)
-                    (player-agent-config-app-id first))
-      (check-equal? (player-agent-config-server-url second)
-                    "https://music.example.test")
-      (check-equal? (player-agent-config-name second) "Test output"))
-    (lambda () (delete-directory/files test-directory))))
+    (λ ()
+      (let* ((first (load-player-agent-config test-file))
+             (changed
+              (struct-copy player-agent-config first
+                           (server-url "https://music.example.test")
+                           (name "Test output"))))
+        (check-true (valid-app-id? (player-agent-config-app-id first)))
+        (save-player-agent-config! changed)
+        (let ((second (load-player-agent-config test-file)))
+          (check-equal? (player-agent-config-app-id second)
+                        (player-agent-config-app-id first))
+          (check-equal? (player-agent-config-server-url second)
+                        "https://music.example.test")
+          (check-equal? (player-agent-config-name second) "Test output"))))
+    (λ () (delete-directory/files test-directory))))
diff --git a/private/player-agent-core.rkt b/private/player-agent-core.rkt
index 8edabcd..df96f74 100644
--- a/private/player-agent-core.rkt
+++ b/private/player-agent-core.rkt
@@ -3,6 +3,7 @@
 (require json
          net/url
          racket-audio
+         racket/contract
          racket/file
          racket/path
          racket/port
@@ -17,6 +18,15 @@
 
 (struct exn:fail:agent-denied exn:fail () #:transparent)
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Expose the small procedure-based interface of a running agent.
+; pre    : Constructor fields are lifecycle/query procedures and a stable ID.
+; post   : Creating or recognizing a value changes no external state.
+; result : player-agent-runtime? recognizes values returned by the factory.
+; internals:
+;          Procedures keep the mutable audio and polling state private without
+;          introducing a class or a second generic backend abstraction.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (struct player-agent-runtime
   (start! reconnect! shutdown! snapshot current-track running? app-id)
   #:transparent)
@@ -29,26 +39,27 @@
   (combine-url/relative (base-url base) path))
 
 (define (post-json base path data)
-  (define input
-    (post-pure-port
-     (endpoint-url base path)
-     (jsexpr->bytes data)
-     (list "Content-Type: application/json"
-           "Cache-Control: no-store")))
-  (dynamic-wind
-    void
-    (lambda ()
-      (define response (read-json input))
-      (when (and (hash? response)
-                 (string? (hash-ref response 'error #f)))
-        (if (equal? (hash-ref response 'code #f) "agent-not-authorized")
-            (raise
-             (exn:fail:agent-denied
-              (hash-ref response 'error)
-              (current-continuation-marks)))
-            (error 'player-agent (hash-ref response 'error))))
-      response)
-    (lambda () (close-input-port input))))
+  (let ((input
+         (post-pure-port
+          (endpoint-url base path)
+          (jsexpr->bytes data)
+          (list "Content-Type: application/json"
+                "Cache-Control: no-store"))))
+    (dynamic-wind
+      void
+      (λ ()
+        (let ((response (read-json input)))
+          (when (and (hash? response)
+                     (string? (hash-ref response 'error #f)))
+            (if (equal? (hash-ref response 'code #f)
+                        "agent-not-authorized")
+                (raise
+                 (exn:fail:agent-denied
+                  (hash-ref response 'error)
+                  (current-continuation-marks)))
+                (error 'player-agent (hash-ref response 'error))))
+          response))
+      (λ () (close-input-port input)))))
 
 (define (normal-state state)
   (cond
@@ -59,49 +70,69 @@
 (define (safe-delete-file file)
   (when (and file (file-exists? file))
     (with-handlers ((exn:fail?
-                     (lambda (exception)
+                     (λ (exception)
                        (warn-player-agent
                         "Could not remove temporary media file ~a: ~a"
                         file
                         (exn-message exception)))))
       (delete-file file))))
 
-(define (make-player-agent-runtime initial-server-url
-                                   initial-name
-                                   app-id
-                                   #:status-callback
-                                   [status-callback void]
-                                   #:denied-callback
-                                   [denied-callback void])
-  (define server-url initial-server-url)
-  (define assigned-name initial-name)
-  (define state-lock (make-semaphore 1))
-  (define worker #f)
-  (define command-worker #f)
-  (define executing-command-id 0)
-  (define running #f)
-  (define authorization-notified? #f)
-  (define audio #f)
-  (define current-media-key #f)
-  (define cached-media (make-hash))
-  (define prefetched-track #f)
-  (define auto-started-key #f)
-  (define pending-auto-music-id #f)
-  (define music-tracks (make-hash))
-  (define current-track-value #f)
-  (define acknowledged-command 0)
-  (define ended-counter 0)
-  (define logical-volume 50)
-  (define agent-state
-    (hasheq 'state "stopped"
-            'position 0
-            'duration 'null
-            'rate 'null
-            'channels 'null
-            'bits 'null
-            'format ""
-            'volume logical-volume
-            'error 'null))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Provided functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Create the headless polling and audio runtime for one agent.
+; pre    : Server URL, display name and application ID are strings; callbacks
+;          accept the status/denial messages supplied to them.
+; post   : Mutable state is initialized but no worker thread or audio backend
+;          is started until the returned start! procedure is called.
+; result : A player-agent-runtime containing its lifecycle/query procedures.
+; internals:
+;          One closure owns the simple mutable state shared by polling,
+;          command and audio callbacks. Keeping these procedures together
+;          makes their synchronization and cleanup order directly visible.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define/contract (make-player-agent-runtime initial-server-url
+                                            initial-name
+                                            app-id
+                                            #:status-callback
+                                            [status-callback void]
+                                            #:denied-callback
+                                            [denied-callback void])
+  (->* (string? string? string?)
+       (#:status-callback (-> string? any/c)
+        #:denied-callback (-> string? any/c))
+       player-agent-runtime?)
+  (let* ((server-url initial-server-url)
+         (assigned-name initial-name)
+         (state-lock (make-semaphore 1))
+         (worker #f)
+         (command-worker #f)
+         (executing-command-id 0)
+         (running #f)
+         (authorization-notified? #f)
+         (audio #f)
+         (current-media-key #f)
+         (cached-media (make-hash))
+         (prefetched-track #f)
+         (auto-started-key #f)
+         (pending-auto-music-id #f)
+         (music-tracks (make-hash))
+         (current-track-value #f)
+         (acknowledged-command 0)
+         (ended-counter 0)
+         (logical-volume 50)
+         (agent-state
+          (hasheq 'state "stopped"
+                  'position 0
+                  'duration 'null
+                  'rate 'null
+                  'channels 'null
+                  'bits 'null
+                  'format ""
+                  'volume logical-volume
+                  'error 'null)))
 
   (define (with-agent-state proc)
     (call-with-semaphore state-lock proc))
@@ -110,98 +141,98 @@
     (if (eq? value #f) fallback value))
 
   (define (snapshot)
-    (with-agent-state (lambda () agent-state)))
+    (with-agent-state (λ () agent-state)))
 
   (define (current-track)
-    (with-agent-state (lambda () current-track-value)))
+    (with-agent-state (λ () current-track-value)))
 
   (define (set-agent-error! message)
     (with-agent-state
-     (lambda ()
+     (λ ()
        (set! agent-state (hash-set agent-state 'error message)))))
 
   (define (clear-agent-error!)
     (with-agent-state
-     (lambda ()
+     (λ ()
        (set! agent-state (hash-set agent-state 'error 'null)))))
 
   (define (update-from-audio! state full-state)
     (with-agent-state
-     (lambda ()
-       (define audible-music-id (hash-ref full-state 'at-music-id #f))
-       (set! agent-state
-             (hasheq
-              'state (normal-state state)
-              'position (state-value (hash-ref full-state 'at-second #f) 0)
-              'duration (state-value (hash-ref full-state 'duration #f) 'null)
-              'rate (state-value (hash-ref full-state 'rate #f) 'null)
-              'channels (state-value (hash-ref full-state 'channels #f) 'null)
-              'bits (state-value (hash-ref full-state 'bits #f) 'null)
-              'format (let ((decoder (hash-ref full-state 'decoder #f)))
-                        (if decoder (format "~a" decoder) ""))
-              'volume logical-volume
-              'error 'null))
-       (when (and pending-auto-music-id
-                  (number? audible-music-id)
-                  (= pending-auto-music-id audible-music-id))
-         (define audible-track
-           (hash-ref music-tracks audible-music-id #f))
-         (when audible-track
-           (set! current-track-value audible-track)
-           (hash-clear! music-tracks)
-           (hash-set! music-tracks audible-music-id audible-track))
-         (set! pending-auto-music-id #f)
-         (set! ended-counter (+ ended-counter 1))))))
+     (λ ()
+       (let ((audible-music-id (hash-ref full-state 'at-music-id #f)))
+         (set! agent-state
+               (hasheq
+                'state (normal-state state)
+                'position (state-value (hash-ref full-state 'at-second #f) 0)
+                'duration (state-value (hash-ref full-state 'duration #f) 'null)
+                'rate (state-value (hash-ref full-state 'rate #f) 'null)
+                'channels (state-value (hash-ref full-state 'channels #f) 'null)
+                'bits (state-value (hash-ref full-state 'bits #f) 'null)
+                'format (let ((decoder (hash-ref full-state 'decoder #f)))
+                          (if decoder (format "~a" decoder) ""))
+                'volume logical-volume
+                'error 'null))
+         (when (and pending-auto-music-id
+                    (number? audible-music-id)
+                    (= pending-auto-music-id audible-music-id))
+           (let ((audible-track
+                  (hash-ref music-tracks audible-music-id #f)))
+             (when audible-track
+               (set! current-track-value audible-track)
+               (hash-clear! music-tracks)
+               (hash-set! music-tracks audible-music-id audible-track)))
+           (set! pending-auto-music-id #f)
+           (set! ended-counter (+ ended-counter 1)))))))
 
   (define (ensure-audio!)
     (unless audio
       (set! audio
             (make-audio-player
-             (lambda (_handle state full-state)
+             (λ (_handle state full-state)
                (update-from-audio! state full-state))
-             (lambda (handle)
+             (λ (handle)
                (advance-at-decoder-eof! handle))))
       (audio-ao-buf-ms! audio 500)
       (audio-buf-seconds! audio 4 10)
-      (define scaled (/ logical-volume 100.0))
-      (audio-volume! audio (* 100.0 scaled scaled)))
+      (let ((scaled (/ logical-volume 100.0)))
+        (audio-volume! audio (* 100.0 scaled scaled))))
     audio)
 
   (define (download-media! token filename)
-    (define extension
-      (or (path-get-extension (string->path filename)) #""))
-    (define target
-      (make-temporary-file
-       (string-append "rkt-player-agent-~a"
-                      (bytes->string/utf-8 extension))))
-    (define path (format "/api/agent/media/~a/~a" app-id token))
-    (define input (get-pure-port (endpoint-url server-url path)))
-    (with-handlers ((exn:fail?
-                     (lambda (exception)
-                       (close-input-port input)
-                       (safe-delete-file target)
-                       (raise exception))))
-      (call-with-output-file
-       target
-       (lambda (output) (copy-port input output))
-       #:exists 'truncate/replace)
-      (close-input-port input)
-      target))
+    (let* ((extension
+            (or (path-get-extension (string->path filename)) #""))
+           (target
+            (make-temporary-file
+             (string-append "rkt-player-agent-~a"
+                            (bytes->string/utf-8 extension))))
+           (path (format "/api/agent/media/~a/~a" app-id token))
+           (input (get-pure-port (endpoint-url server-url path))))
+      (with-handlers ((exn:fail?
+                       (λ (exception)
+                         (close-input-port input)
+                         (safe-delete-file target)
+                         (raise exception))))
+        (call-with-output-file
+         target
+         (λ (output) (copy-port input output))
+         #:exists 'truncate/replace)
+        (close-input-port input)
+        target)))
 
   (define (command-cache-key data)
     (hash-ref data 'cacheKey (hash-ref data 'mediaToken)))
 
   (define (ensure-media-cached! data)
-    (define key (command-cache-key data))
-    (define found (hash-ref cached-media key #f))
-    (if (and found (file-exists? found))
-        found
-        (let ((downloaded
-               (download-media!
-                (hash-ref data 'mediaToken)
-                (hash-ref data 'filename "track"))))
-          (hash-set! cached-media key downloaded)
-          downloaded)))
+    (let* ((key (command-cache-key data))
+           (found (hash-ref cached-media key #f)))
+      (if (and found (file-exists? found))
+          found
+          (let ((downloaded
+                 (download-media!
+                  (hash-ref data 'mediaToken)
+                  (hash-ref data 'filename "track"))))
+            (hash-set! cached-media key downloaded)
+            downloaded))))
 
   (define (discard-unused-media! keep-key)
     (for ((entry (in-list (hash->list cached-media))))
@@ -212,130 +243,134 @@
   ;; Decoder EOF occurs before audible EOF. Queueing the prefetched decoder at
   ;; this point appends it behind racket-audio's remaining output buffer.
   (define (advance-at-decoder-eof! handle)
-    (define prepared
-      (with-agent-state
-       (lambda ()
-         (define value prefetched-track)
-         (set! prefetched-track #f)
-         value)))
-    (cond
-      (prepared
-       (define data (car prepared))
-       (define path (cdr prepared))
-       (define key (command-cache-key data))
-       (with-handlers
-           ((exn:fail?
-             (lambda (exception)
-               (warn-player-agent "Could not start prefetched track: ~a"
-                                  (exn-message exception))
-               (set-agent-error! (exn-message exception))
+    (let ((prepared
+           (with-agent-state
+            (λ ()
+              (let ((value prefetched-track))
+                (set! prefetched-track #f)
+                value)))))
+      (cond
+        (prepared
+         (let* ((data (car prepared))
+                (path (cdr prepared))
+                (key (command-cache-key data)))
+           (with-handlers
+               ((exn:fail?
+                 (λ (exception)
+                   (warn-player-agent "Could not start prefetched track: ~a"
+                                      (exn-message exception))
+                   (set-agent-error! (exn-message exception))
+                   (with-agent-state
+                    (λ () (set! ended-counter (+ ended-counter 1)))))))
+             (let ((music-id (audio-play! handle path)))
+               (info-player-agent "Queued prefetched track ~a as music id ~a"
+                                  (hash-ref data 'filename "track")
+                                  music-id)
+               (set! current-media-key key)
+               (discard-unused-media! key)
                (with-agent-state
-                (lambda () (set! ended-counter (+ ended-counter 1)))))))
-         (define music-id (audio-play! handle path))
-         (info-player-agent "Queued prefetched track ~a as music id ~a"
-                            (hash-ref data 'filename "track")
-                            music-id)
-         (set! current-media-key key)
-         (discard-unused-media! key)
+                (λ ()
+                  (hash-set! music-tracks music-id data)
+                  (set! auto-started-key key)
+                  (set! pending-auto-music-id music-id)))))))
+        (else
+         (warn-player-agent
+          "Decoder reached EOF before the next track was prefetched")
          (with-agent-state
-          (lambda ()
-            (hash-set! music-tracks music-id data)
-            (set! auto-started-key key)
-            (set! pending-auto-music-id music-id)))))
-      (else
-       (warn-player-agent
-        "Decoder reached EOF before the next track was prefetched")
-       (with-agent-state
-        (lambda () (set! ended-counter (+ ended-counter 1)))))))
+          (λ () (set! ended-counter (+ ended-counter 1))))))))
 
   (define (execute-command! command)
-    (define action (hash-ref command 'action ""))
-    (define data (hash-ref command 'data (hasheq)))
-    (info-player-agent "Executing command ~a" action)
-    (cond
-      ((string=? action "play")
-       (define next-key (command-cache-key data))
-       (define already-started?
+    (let ((action (hash-ref command 'action ""))
+          (data (hash-ref command 'data (hasheq))))
+      (info-player-agent "Executing command ~a" action)
+      (cond
+        ((string=? action "play")
+         (let* ((next-key (command-cache-key data))
+                (already-started?
+                 (with-agent-state
+                  (λ ()
+                    (let ((matches?
+                           (and auto-started-key
+                                (equal? auto-started-key next-key))))
+                      (when matches?
+                        (set! auto-started-key #f))
+                      matches?)))))
+           (with-agent-state
+            (λ () (set! current-track-value data)))
+           (unless already-started?
+             (with-agent-state
+              (λ ()
+                (set! prefetched-track #f)
+                (set! auto-started-key #f)
+                (set! pending-auto-music-id #f)
+                (set! agent-state
+                      (hash-set
+                       (hash-set agent-state 'state "starting")
+                       'error 'null))))
+             (let* ((next-media (ensure-media-cached! data))
+                    ;; audio-play! interrupts and closes the previous decoder.
+                    (music-id (audio-play! (ensure-audio!) next-media)))
+               (with-agent-state
+                (λ ()
+                  (hash-clear! music-tracks)
+                  (hash-set! music-tracks music-id data)))
+               (set! current-media-key next-key)
+               (discard-unused-media! next-key)))))
+        ((string=? action "prefetch")
+         (let ((key (command-cache-key data))
+               (path (ensure-media-cached! data)))
+           (with-agent-state
+            (λ () (set! prefetched-track (cons data path))))
+           (info-player-agent "Prefetched ~a"
+                              (hash-ref data 'filename "track"))
+           (for ((entry (in-list (hash->list cached-media))))
+             (unless (or (equal? (car entry) current-media-key)
+                         (equal? (car entry) key))
+               (safe-delete-file (cdr entry))
+               (hash-remove! cached-media (car entry))))))
+        ((string=? action "pause")
+         (audio-pause! (ensure-audio!) #t))
+        ((string=? action "resume")
+         (audio-pause! (ensure-audio!) #f))
+        ((string=? action "stop")
          (with-agent-state
-          (lambda ()
-            (define matches?
-              (and auto-started-key (equal? auto-started-key next-key)))
-            (when matches? (set! auto-started-key #f))
-            matches?)))
-       (with-agent-state
-        (lambda () (set! current-track-value data)))
-       (unless already-started?
-         (with-agent-state
-          (lambda ()
+          (λ ()
             (set! prefetched-track #f)
             (set! auto-started-key #f)
-            (set! pending-auto-music-id #f)
-            (set! agent-state
-                  (hash-set
-                   (hash-set agent-state 'state "starting")
-                   'error 'null))))
-         (define next-media (ensure-media-cached! data))
-         ;; audio-play! interrupts and closes the previous decoder itself.
-         (define music-id (audio-play! (ensure-audio!) next-media))
+            (set! pending-auto-music-id #f)))
+         (when audio
+           (audio-stop! audio)))
+        ((string=? action "seek")
+         (audio-seek! (ensure-audio!) (hash-ref data 'percentage 0)))
+        ((string=? action "volume")
+         (set! logical-volume (min 100 (max 0 (hash-ref data 'value 50))))
+         (let ((scaled (/ logical-volume 100.0)))
+           (audio-volume! (ensure-audio!) (* 100.0 scaled scaled)))
          (with-agent-state
-          (lambda ()
-            (hash-clear! music-tracks)
-            (hash-set! music-tracks music-id data)))
-         (set! current-media-key next-key)
-         (discard-unused-media! next-key)))
-      ((string=? action "prefetch")
-       (define key (command-cache-key data))
-       (define path (ensure-media-cached! data))
-       (with-agent-state
-        (lambda () (set! prefetched-track (cons data path))))
-       (info-player-agent "Prefetched ~a" (hash-ref data 'filename "track"))
-       (for ((entry (in-list (hash->list cached-media))))
-         (unless (or (equal? (car entry) current-media-key)
-                     (equal? (car entry) key))
-           (safe-delete-file (cdr entry))
-           (hash-remove! cached-media (car entry)))))
-      ((string=? action "pause")
-       (audio-pause! (ensure-audio!) #t))
-      ((string=? action "resume")
-       (audio-pause! (ensure-audio!) #f))
-      ((string=? action "stop")
-       (with-agent-state
-        (lambda ()
-          (set! prefetched-track #f)
-          (set! auto-started-key #f)
-          (set! pending-auto-music-id #f)))
-       (when audio (audio-stop! audio)))
-      ((string=? action "seek")
-       (audio-seek! (ensure-audio!) (hash-ref data 'percentage 0)))
-      ((string=? action "volume")
-       (set! logical-volume (min 100 (max 0 (hash-ref data 'value 50))))
-       (define scaled (/ logical-volume 100.0))
-       (audio-volume! (ensure-audio!) (* 100.0 scaled scaled))
-       (with-agent-state
-        (lambda ()
-          (set! agent-state
-                (hash-set agent-state 'volume logical-volume)))))
-      (else
-       (error 'player-agent "unknown command: ~a" action))))
+          (λ ()
+            (set! agent-state
+                  (hash-set agent-state 'volume logical-volume)))))
+        (else
+         (error 'player-agent "unknown command: ~a" action)))))
 
   (define (poll-loop)
     (with-handlers
         ((exn:fail:agent-denied?
-          (lambda (exception)
-            (define message (format (tr 'denied-message) app-id))
-            (warn-player-agent "Agent authorization refused: ~a"
-                               (exn-message exception))
-            (set-agent-error! message)
-            (status-callback
-             (tr 'unauthorized-status))
-            (unless authorization-notified?
-              (set! authorization-notified? #t)
-              (denied-callback message))
-            (when running
-              (sleep 3)
-              (poll-loop))))
+          (λ (exception)
+            (let ((message (format (tr 'denied-message) app-id)))
+              (warn-player-agent "Agent authorization refused: ~a"
+                                 (exn-message exception))
+              (set-agent-error! message)
+              (status-callback
+               (tr 'unauthorized-status))
+              (unless authorization-notified?
+                (set! authorization-notified? #t)
+                (denied-callback message))
+              (when running
+                (sleep 3)
+                (poll-loop)))))
          (exn:fail?
-          (lambda (exception)
+          (λ (exception)
             (warn-player-agent "Connection cycle failed: ~a"
                                (exn-message exception))
             (set-agent-error! (exn-message exception))
@@ -352,34 +387,35 @@
       (info-player-agent "Registered at ~a as ~a" server-url assigned-name)
       (let loop ()
         (when running
-          (define response
-            (post-json
-             server-url
-             "/api/agent/poll"
-             (hasheq 'appId app-id
-                     'name assigned-name
-                     'ack acknowledged-command
-                     'endedCounter ended-counter
-                     'state (snapshot))))
-          (define command (hash-ref response 'command 'null))
-          (when (and (hash? command)
-                     (> (hash-ref command 'id 0) acknowledged-command)
-                     (not (= (hash-ref command 'id 0) executing-command-id)))
-            (set! executing-command-id (hash-ref command 'id))
-            (set! command-worker
-                  (thread
-                   (lambda ()
-                     (with-handlers
-                         ((exn:fail?
-                           (lambda (exception)
-                             (warn-player-agent "Command failed: ~a"
-                                                (exn-message exception))
-                             (set-agent-error! (exn-message exception)))))
-                       (clear-agent-error!)
-                       (execute-command! command))
-                     (set! acknowledged-command (hash-ref command 'id))
-                     (set! executing-command-id 0)
-                     (set! command-worker #f)))))
+          (let* ((response
+                  (post-json
+                   server-url
+                   "/api/agent/poll"
+                   (hasheq 'appId app-id
+                           'name assigned-name
+                           'ack acknowledged-command
+                           'endedCounter ended-counter
+                           'state (snapshot))))
+                 (command (hash-ref response 'command 'null)))
+            (when (and (hash? command)
+                       (> (hash-ref command 'id 0) acknowledged-command)
+                       (not (= (hash-ref command 'id 0)
+                               executing-command-id)))
+              (set! executing-command-id (hash-ref command 'id))
+              (set! command-worker
+                    (thread
+                     (λ ()
+                       (with-handlers
+                           ((exn:fail?
+                             (λ (exception)
+                               (warn-player-agent "Command failed: ~a"
+                                                  (exn-message exception))
+                               (set-agent-error! (exn-message exception)))))
+                         (clear-agent-error!)
+                         (execute-command! command))
+                       (set! acknowledged-command (hash-ref command 'id))
+                       (set! executing-command-id 0)
+                       (set! command-worker #f))))))
           (sleep 1)
           (loop)))))
 
@@ -421,5 +457,5 @@
                         shutdown!
                         snapshot
                         current-track
-                        (lambda () running)
-                        app-id))
+                        (λ () running)
+                        app-id)))
diff --git a/private/player-agent-gui.rkt b/private/player-agent-gui.rkt
index 17555f0..fb64f14 100644
--- a/private/player-agent-gui.rkt
+++ b/private/player-agent-gui.rkt
@@ -1,15 +1,16 @@
 #lang racket/base
 
 (require racket/class
+         racket/contract
          racket/format
          racket/gui/base
          racket/os
-         racket/path
+         racket/runtime-path
          racket/string
+         racket-tray
          simple-log
          "player-agent-config.rkt"
          "player-agent-core.rkt"
-         "player-agent-tray.rkt"
          "translate.rkt")
 
 (provide run-player-agent-gui)
@@ -20,256 +21,393 @@
   (build-path (find-system-path 'pref-dir)
               "rkt-web-player-agent.log"))
 
+(define-runtime-path tray-icon
+  "../public/rkt-web-player.png")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Supporting functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Create a labelled text field with compact editor padding.
+; pre    : label and init-value are strings; panel accepts GUI children.
+; post   : A text field has been added to panel.
+; result : The newly created text-field% object.
+; internals:
+;          Padding is set on the editor because it renders consistently on
+;          the supported desktop platforms.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (define (input-field label init-value panel)
-  (define field
-    (new text-field%
-         (parent panel)
-         (label label)
-         (init-value init-value)))
-  (send (send field get-editor) set-padding 0 2 0 2)
-  field)
+  (let ((field
+         (new text-field%
+              (parent panel)
+              (label label)
+              (init-value init-value))))
+    (send (send field get-editor) set-padding 0 2 0 2)
+    field))
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Format a playback position as hours, minutes and seconds.
+; pre    : value is any Racket value.
+; post   : No state is changed.
+; result : A zero-padded HH:MM:SS string; invalid values are treated as zero.
+; internals:
+;          Fractional seconds are deliberately rounded down so the displayed
+;          position never runs ahead of the audio runtime.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (define (format-time value)
-  (define seconds
-    (if (and (number? value) (>= value 0))
-        (inexact->exact (floor value))
-        0))
-  (define hours (quotient seconds 3600))
-  (define minutes (quotient (remainder seconds 3600) 60))
-  (define remaining (remainder seconds 60))
-  (format "~a:~a:~a"
-          (~r hours #:min-width 2 #:pad-string "0")
-          (~r minutes #:min-width 2 #:pad-string "0")
-          (~r remaining #:min-width 2 #:pad-string "0")))
+  (let* ((seconds
+          (if (and (number? value) (>= value 0))
+              (inexact->exact (floor value))
+              0))
+         (hours (quotient seconds 3600))
+         (minutes (quotient (remainder seconds 3600) 60))
+         (remaining (remainder seconds 60)))
+    (format "~a:~a:~a"
+            (~r hours #:min-width 2 #:pad-string "0")
+            (~r minutes #:min-width 2 #:pad-string "0")
+            (~r remaining #:min-width 2 #:pad-string "0"))))
 
-(define (run-player-agent-gui)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Provided functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Start the graphical polling playback agent.
+; pre    : A graphical desktop and the platform support required by
+;          racket-tray are available.
+; post   : The agent runtime is started, its frame and tray icon are visible,
+;          and closing or minimizing the frame hides it in the system tray.
+; result : The live frame% object belonging to the playback agent.
+; internals:
+;          The GUI owns only widgets, configuration and lifecycle callbacks.
+;          Playback and polling remain in player-agent-core.rkt. racket-tray
+;          owns native tray resources and the portable minimize watcher.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define/contract (run-player-agent-gui)
+  (-> (is-a?/c frame%))
   (sl-log-to-file log-file)
+  (let ((config (load-player-agent-config))
+        (frame #f)
+        (runtime #f)
+        (status-message #f)
+        (playback-message #f)
+        (playback-details #f)
+        (playback-filename #f)
+        (name-field #f)
+        (server-field #f)
+        (connect-button #f)
+        (playback-timer #f)
+        (tray #f)
+        (shutting-down? #f))
 
-  (define config (load-player-agent-config))
-  (define frame #f)
-  (define runtime #f)
-  (define status-message #f)
-  (define playback-message #f)
-  (define playback-details #f)
-  (define playback-filename #f)
-  (define name-field #f)
-  (define server-field #f)
-  (define connect-button #f)
-  (define playback-timer #f)
-  (define tray-timer #f)
-  (define tray #f)
-  (define shutting-down? #f)
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ; goal   : Queue a status-label update in the GUI eventspace.
+    ; pre    : message is a string supplied by the agent runtime.
+    ; post   : The status widget shows message when it has been created.
+    ; result : Unspecified.
+    ; internals:
+    ;          Runtime callbacks can originate outside the GUI eventspace, so
+    ;          widget access is always forwarded with queue-callback.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    (define (show-status! message)
+      (queue-callback
+       (λ ()
+         (when status-message
+           (send status-message set-label message)))
+       #f))
 
-  (define (show-status! message)
-    (queue-callback
-     (lambda ()
-       (when status-message
-         (send status-message set-label message)))
-     #f))
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ; goal   : Show a playback-agent authorization failure.
+    ; pre    : message is a string supplied by the agent runtime.
+    ; post   : A modal error dialog is queued for the agent frame.
+    ; result : Unspecified.
+    ; internals:
+    ;          The callback is eventspace-safe for the same reason as the
+    ;          status callback above.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    (define (show-denial! message)
+      (queue-callback
+       (λ ()
+         (message-box (tr 'denied-title)
+                      message
+                      frame
+                      '(ok stop)))
+       #f))
 
-  (define (show-denial! message)
-    (queue-callback
-     (lambda ()
-       (message-box (tr 'denied-title)
-                    message
-                    frame
-                    '(ok stop)))
-     #f))
+    (set! runtime
+          (make-player-agent-runtime
+           (player-agent-config-server-url config)
+           (player-agent-config-name config)
+           (player-agent-config-app-id config)
+           #:status-callback show-status!
+           #:denied-callback show-denial!))
 
-  (set! runtime
-        (make-player-agent-runtime
-         (player-agent-config-server-url config)
-         (player-agent-config-name config)
-         (player-agent-config-app-id config)
-         #:status-callback show-status!
-         #:denied-callback show-denial!))
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ; goal   : Refresh the visible playback summary from the runtime cache.
+    ; pre    : runtime exists; the widgets may still be uninitialized.
+    ; post   : Initialized playback widgets reflect one coherent cached
+    ;          snapshot and its current track.
+    ; result : Unspecified.
+    ; internals:
+    ;          This procedure never performs network I/O. The timer reads only
+    ;          the cache maintained by player-agent-core.rkt.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    (define (refresh-playback-status!)
+      (when (and playback-message playback-details playback-filename)
+        (let* ((snapshot ((player-agent-runtime-snapshot runtime)))
+               (track ((player-agent-runtime-current-track runtime)))
+               (state (hash-ref snapshot 'state "stopped"))
+               (title (and track (hash-ref track 'title #f)))
+               (artist (and track (hash-ref track 'artist #f)))
+               (filename (and track (hash-ref track 'filename #f)))
+               (track-number (and track (hash-ref track 'trackNumber #f)))
+               (track-label
+                (cond
+                  ((and artist (not (string=? artist "")) title)
+                   (format "~a — ~a" artist title))
+                  (title title)
+                  (else (tr 'no-track-selected))))
+               (prefix
+                (cond
+                  ((string=? state "playing") (tr 'playing))
+                  ((string=? state "paused") (tr 'paused))
+                  ((string=? state "starting") (tr 'loading))
+                  ((string=? state "stopped") (tr 'stopped))
+                  (else state)))
+               (position (hash-ref snapshot 'position 0))
+               (duration (hash-ref snapshot 'duration 'null))
+               (format-name (hash-ref snapshot 'format ""))
+               (rate (hash-ref snapshot 'rate 'null))
+               (bits (hash-ref snapshot 'bits 'null))
+               (channels (hash-ref snapshot 'channels 'null))
+               (details
+                (filter
+                 (λ (value) (not (string=? value "")))
+                 (list
+                  (format "~a / ~a"
+                          (format-time position)
+                          (if (number? duration)
+                              (format-time duration)
+                              "--:--:--"))
+                  (if (number? bits) (format "~a bit" bits) "")
+                  (if (number? rate)
+                      (format "~a kHz"
+                              (~r (/ rate 1000.0) #:precision '(= 1)))
+                      "")
+                  (if (number? channels)
+                      (format "~a ~a"
+                              channels
+                              (tr (if (= channels 1) 'channel 'channels)))
+                      "")
+                  (if (and (string? format-name)
+                           (not (string=? format-name "")))
+                      format-name
+                      "")))))
+          (send playback-message
+                set-label
+                (if track
+                    (format "~a~a: ~a"
+                            prefix
+                            (if (number? track-number)
+                                (format " #~a" track-number)
+                                "")
+                            track-label)
+                    (tr 'no-track)))
+          (send playback-details set-label (string-join details "  ·  "))
+          (send playback-filename
+                set-label
+                (if (and (string? filename)
+                         (not (string=? filename "")))
+                    filename
+                    "—")))))
 
-  (define (refresh-playback-status!)
-    (when (and playback-message playback-details playback-filename)
-      (define snapshot ((player-agent-runtime-snapshot runtime)))
-      (define track ((player-agent-runtime-current-track runtime)))
-      (define state (hash-ref snapshot 'state "stopped"))
-      (define title (and track (hash-ref track 'title #f)))
-      (define artist (and track (hash-ref track 'artist #f)))
-      (define filename (and track (hash-ref track 'filename #f)))
-      (define track-number (and track (hash-ref track 'trackNumber #f)))
-      (define track-label
-        (cond
-          ((and artist (not (string=? artist "")) title)
-           (format "~a — ~a" artist title))
-          (title title)
-          (else (tr 'no-track-selected))))
-      (define prefix
-        (cond
-          ((string=? state "playing") (tr 'playing))
-          ((string=? state "paused") (tr 'paused))
-          ((string=? state "starting") (tr 'loading))
-          ((string=? state "stopped") (tr 'stopped))
-          (else state)))
-      (define position (hash-ref snapshot 'position 0))
-      (define duration (hash-ref snapshot 'duration 'null))
-      (define format-name (hash-ref snapshot 'format ""))
-      (define rate (hash-ref snapshot 'rate 'null))
-      (define bits (hash-ref snapshot 'bits 'null))
-      (define channels (hash-ref snapshot 'channels 'null))
-      (define details
-        (filter
-         (lambda (value) (not (string=? value "")))
-         (list
-          (format "~a / ~a"
-                  (format-time position)
-                  (if (number? duration) (format-time duration) "--:--:--"))
-          (if (number? bits) (format "~a bit" bits) "")
-          (if (number? rate)
-              (format "~a kHz" (~r (/ rate 1000.0) #:precision '(= 1)))
-              "")
-          (if (number? channels)
-              (format "~a ~a" channels
-                      (tr (if (= channels 1) 'channel 'channels)))
-              "")
-          (if (and (string? format-name) (not (string=? format-name "")))
-              format-name
-              ""))))
-      (send playback-message
-            set-label
-            (if track
-                (format "~a~a: ~a"
-                        prefix
-                        (if (number? track-number)
-                            (format " #~a" track-number)
-                            "")
-                        track-label)
-                (tr 'no-track)))
-      (send playback-details set-label (string-join details "  ·  "))
-      (send playback-filename
-            set-label
-            (if (and (string? filename) (not (string=? filename "")))
-                filename
-                "—"))))
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ; goal   : Persist edited connection settings and reconnect the runtime.
+    ; pre    : The name, server and connect widgets have been initialized.
+    ; post   : config and the INI file contain normalized values; the runtime
+    ;          reconnects with them and the button becomes a reconnect button.
+    ; result : Unspecified.
+    ; internals:
+    ;          An empty name receives the same hostname-based default used by
+    ;          initial configuration loading.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    (define (reconnect!)
+      (let* ((next-server (string-trim (send server-field get-value)))
+             (entered-name (string-trim (send name-field get-value)))
+             (next-name
+              (if (string=? entered-name "")
+                  (format "~a playback" (gethostname))
+                  entered-name)))
+        (set! config
+              (struct-copy player-agent-config config
+                           (server-url next-server)
+                           (name next-name)))
+        (save-player-agent-config! config)
+        (send name-field set-value next-name)
+        ((player-agent-runtime-reconnect! runtime) next-server next-name)
+        (send connect-button set-label (tr 'reconnect))))
 
-  (define (reconnect!)
-    (define next-server (string-trim (send server-field get-value)))
-    (define entered-name (string-trim (send name-field get-value)))
-    (define next-name
-      (if (string=? entered-name "")
-          (format "~a playback" (gethostname))
-          entered-name))
-    (set! config
-          (struct-copy player-agent-config config
-                       (server-url next-server)
-                       (name next-name)))
-    (save-player-agent-config! config)
-    (send name-field set-value next-name)
-    ((player-agent-runtime-reconnect! runtime) next-server next-name)
-    (send connect-button set-label (tr 'reconnect)))
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ; goal   : Release resources owned by the GUI agent exactly once.
+    ; pre    : runtime has been created; timer and tray may be #f.
+    ; post   : Playback polling, audio, the GUI timer and native tray resources
+    ;          have stopped; subsequent calls do nothing.
+    ; result : Unspecified.
+    ; internals:
+    ;          The guard makes this procedure safe from both the window close
+    ;          path and the tray Exit action.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    (define (shutdown!)
+      (unless shutting-down?
+        (set! shutting-down? #t)
+        (when playback-timer
+          (send playback-timer stop))
+        ((player-agent-runtime-shutdown! runtime))
+        (when tray
+          (tray-close tray)
+          (set! tray #f))))
 
-  (define (shutdown!)
-    (unless shutting-down?
-      (set! shutting-down? #t)
-      (when playback-timer (send playback-timer stop))
-      (when tray-timer (send tray-timer stop))
-      ((player-agent-runtime-shutdown! runtime))
-      (when tray
-        ((tray-controller-destroy! tray))
-        (set! tray #f))))
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ; goal   : Terminate the graphical agent from its tray menu.
+    ; pre    : frame and runtime have been initialized.
+    ; post   : Resources are released and the frame is hidden.
+    ; result : Unspecified.
+    ; internals:
+    ;          racket-tray invokes actions in the frame eventspace, so no
+    ;          additional GUI callback queue is needed here.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    (define (quit!)
+      (shutdown!)
+      (send frame show #f))
 
-  (define (quit!)
-    (queue-callback
-     (lambda ()
-       (shutdown!)
-       (when frame (send frame show #f)))
-     #f))
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ; goal   : Restore the agent frame from the tray.
+    ; pre    : frame has been initialized and has not been destroyed.
+    ; post   : frame is visible and no longer iconized.
+    ; result : Unspecified.
+    ; internals:
+    ;          De-iconizing is needed because racket-tray hides minimized
+    ;          frames instead of changing their iconized state.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    (define (show-window!)
+      (send frame show #t)
+      (when (send frame is-iconized?)
+        (send frame iconize #f)))
 
-  (define agent-frame%
-    (class frame%
-      (super-new)
-      (define/augment (on-close)
-        (if tray
-            (send this show #f)
-            (begin
-              (shutdown!)
-              (inner (void) on-close))))))
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ; goal   : Dispatch a symbolic racket-tray action.
+    ; pre    : action is installed in the tray menu below.
+    ; post   : 'open restores the frame; 'exit shuts down the agent.
+    ; result : Unspecified.
+    ; internals:
+    ;          One callback handles both direct tray activation and menu
+    ;          selection on every platform.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    (define (tray-action! action)
+      (case action
+        ((open) (show-window!))
+        ((exit) (quit!))))
 
-  (set! frame
-        (new agent-frame%
-             (label (tr 'app-title))
-             (width 560)
-             (height 310)))
-  (define panel
-    (new vertical-panel%
-         (parent frame)
-         (alignment '(left top))))
-  (set! server-field
-        (input-field (tr 'server)
-                     (player-agent-config-server-url config)
-                     panel))
-  (set! name-field
-        (input-field (tr 'name) (player-agent-config-name config) panel))
-  (define id-field
-    (input-field (tr 'application-id)
-                 (player-agent-config-app-id config)
-                 panel))
-  ;; Lock the editor, not the native widget. Disabled Windows controls render
-  ;; their label and text poorly on some display configurations.
-  (send (send id-field get-editor) lock #t)
+    (let* ((agent-frame%
+            (class frame%
+              (super-new)
+              (define/augment (on-close)
+                (if tray
+                    (send this show #f)
+                    (begin
+                      (shutdown!)
+                      (inner (void) on-close))))))
+           (new-frame
+            (new agent-frame%
+                 (label (tr 'app-title))
+                 (width 560)
+                 (height 310))))
+      (set! frame new-frame))
 
-  (define playback-panel
-    (new group-box-panel%
-         (parent panel)
-         (label (tr 'playback))
-         (alignment '(left top))
-         (stretchable-height #f)))
-  (set! playback-message
-        (new message%
-             (parent playback-panel)
-             (label (tr 'no-track))
-             (auto-resize #t)))
-  (set! playback-details
-        (new message%
-             (parent playback-panel)
-             (label "00:00:00 / --:--:--")
-             (auto-resize #t)))
-  (set! playback-filename
-        (new message%
-             (parent playback-panel)
-             (label "—")
-             (auto-resize #t)))
+    (let* ((panel
+            (new vertical-panel%
+                 (parent frame)
+                 (alignment '(left top))))
+           (server
+            (input-field (tr 'server)
+                         (player-agent-config-server-url config)
+                         panel))
+           (name
+            (input-field (tr 'name)
+                         (player-agent-config-name config)
+                         panel))
+           (id-field
+            (input-field (tr 'application-id)
+                         (player-agent-config-app-id config)
+                         panel))
+           (playback-panel
+            (new group-box-panel%
+                 (parent panel)
+                 (label (tr 'playback))
+                 (alignment '(left top))
+                 (stretchable-height #f)))
+           (controls
+            (new horizontal-panel%
+                 (parent panel)
+                 (alignment '(left center)))))
+      (set! server-field server)
+      (set! name-field name)
+      ;; Lock the editor, not the native widget. Disabled Windows controls
+      ;; render their label and text poorly on some display configurations.
+      (send (send id-field get-editor) lock #t)
+      (set! playback-message
+            (new message%
+                 (parent playback-panel)
+                 (label (tr 'no-track))
+                 (auto-resize #t)))
+      (set! playback-details
+            (new message%
+                 (parent playback-panel)
+                 (label "00:00:00 / --:--:--")
+                 (auto-resize #t)))
+      (set! playback-filename
+            (new message%
+                 (parent playback-panel)
+                 (label "—")
+                 (auto-resize #t)))
+      (set! connect-button
+            (new button%
+                 (parent controls)
+                 (label (tr 'save-connect))
+                 (callback (λ (_button _event) (reconnect!)))))
+      (set! status-message
+            (new message%
+                 (parent controls)
+                 (label (tr 'connecting))
+                 (auto-resize #t))))
 
-  (define controls
-    (new horizontal-panel%
-         (parent panel)
-         (alignment '(left center))))
-  (set! connect-button
-        (new button%
-             (parent controls)
-             (label (tr 'save-connect))
-             (callback (lambda (_button _event) (reconnect!)))))
-  (set! status-message
-        (new message%
-             (parent controls)
-             (label (tr 'connecting))
-             (auto-resize #t)))
-
-  (set! playback-timer
-        (new timer%
-             (notify-callback refresh-playback-status!)
-             (interval 500)))
-  (refresh-playback-status!)
-
-  ;; If SDL3 and its native runtime are present, closing the frame hides it in
-  ;; the tray. Otherwise the original close-and-exit behaviour remains.
-  (set! tray
-        (try-make-tray-controller
-         (lambda ()
-           (queue-callback (lambda () (send frame show #t)) #f))
-         quit!))
-  (when tray
-    (set! tray-timer
+    (set! playback-timer
           (new timer%
-               (notify-callback (tray-controller-update! tray))
-               (interval 100))))
+               (notify-callback refresh-playback-status!)
+               (interval 500)))
+    (refresh-playback-status!)
 
-  (send frame show #t)
-  ((player-agent-runtime-start! runtime))
-  (send connect-button set-label (tr 'reconnect))
-  frame)
+    (set! tray
+          (mk-tray frame
+                   tray-icon
+                   (list tray-action! 'open)
+                   #:hide-on-minimize? #t))
+    (tray-set-menu!
+     tray
+     (list
+      (list 'open (tr 'tray-open))
+      'separator
+      (list 'exit (tr 'quit))))
+
+    (send frame show #t)
+    ((player-agent-runtime-start! runtime))
+    (send connect-button set-label (tr 'reconnect))
+    frame))
+
+(module+ test
+  (require rackunit)
+
+  ;; The runtime path must remain valid after package installation; relying on
+  ;; the development working directory would make the tray fail elsewhere.
+  (check-true (file-exists? tray-icon)))
diff --git a/private/player-agent-tray.rkt b/private/player-agent-tray.rkt
deleted file mode 100644
index 62afd84..0000000
--- a/private/player-agent-tray.rkt
+++ /dev/null
@@ -1,36 +0,0 @@
-#lang racket/base
-
-(require "translate.rkt")
-
-;; SDL3 is deliberately loaded dynamically. The GUI agent keeps working
-;; without the optional Racket package and native SDL3 runtime.
-
-(provide (struct-out tray-controller)
-         try-make-tray-controller)
-
-(struct tray-controller (update! destroy!) #:transparent)
-
-(define (try-make-tray-controller show-window! quit!)
-  (with-handlers ((exn:fail? (lambda (_) #f)))
-    (define sdl-init! (dynamic-require 'sdl3 'sdl-init!))
-    (define sdl-quit! (dynamic-require 'sdl3 'sdl-quit!))
-    (define make-tray (dynamic-require 'sdl3 'make-tray))
-    (define make-tray-menu (dynamic-require 'sdl3 'make-tray-menu))
-    (define insert-tray-entry! (dynamic-require 'sdl3 'insert-tray-entry!))
-    (define set-tray-entry-callback!
-      (dynamic-require 'sdl3 'set-tray-entry-callback!))
-    (define update-trays! (dynamic-require 'sdl3 'update-trays!))
-    (define tray-destroy! (dynamic-require 'sdl3 'tray-destroy!))
-    (sdl-init! '(video events))
-    (define tray (make-tray #f (tr 'app-title)))
-    (define menu (make-tray-menu tray))
-    (define show-entry (insert-tray-entry! menu (tr 'tray-open)))
-    (insert-tray-entry! menu #f)
-    (define quit-entry (insert-tray-entry! menu (tr 'quit)))
-    (set-tray-entry-callback! show-entry (lambda (_) (show-window!)))
-    (set-tray-entry-callback! quit-entry (lambda (_) (quit!)))
-    (tray-controller
-     update-trays!
-     (lambda ()
-       (tray-destroy! tray)
-       (sdl-quit!)))))
diff --git a/private/player.rkt b/private/player.rkt
index 2f6abc7..dcb563c 100644
--- a/private/player.rkt
+++ b/private/player.rkt
@@ -278,7 +278,7 @@
   (hash-ref!
    (player-playlist-contexts value)
    normalized
-   (lambda () (new-playlist-context value normalized))))
+   (λ () (new-playlist-context value normalized))))
 
 (define (context-tracks context)
   (playlist-tab-tracks
@@ -324,7 +324,7 @@
     (define context (playlist-context-for! value normalized))
     (with-state-lock
      value
-     (lambda ()
+     (λ ()
        (set-player-tabs! value (playlist-context-tabs context))
        (set-player-current-tab-index!
         value
@@ -1649,7 +1649,7 @@
   (define item
     (call-with-semaphore
      (player-command-lock value)
-     (lambda ()
+     (λ ()
        (define context
          (playlist-context-for!
           value
@@ -1659,7 +1659,7 @@
           (player-tracks value)
           (append-map playlist-tab-tracks
                       (playlist-context-tabs context))))
-       (findf (lambda (candidate)
+       (findf (λ (candidate)
                 (string=? (track-cache-key candidate) artwork-id))
               candidates))))
   (and item (track-artwork item)))
diff --git a/private/playlists.rkt b/private/playlists.rkt
index c0c4e95..72ceba6 100644
--- a/private/playlists.rkt
+++ b/private/playlists.rkt
@@ -69,7 +69,7 @@
                id
                name
                (filter-map
-                (lambda (item) (datum->track item libraries))
+                (λ (item) (datum->track item libraries))
                 tracks))))))
 
 (define (open-playlist-store file)
@@ -82,7 +82,7 @@
   (when store
     (call-with-semaphore
      (playlist-store-lock store)
-     (lambda () (ks-close (playlist-store-keystore store)))))
+     (λ () (ks-close (playlist-store-keystore store)))))
   (void))
 
 (define (load-user-playlists store username libraries)
@@ -90,12 +90,12 @@
       '()
       (call-with-semaphore
        (playlist-store-lock store)
-       (lambda ()
+       (λ ()
          (define ks (playlist-store-keystore store))
          (define ids (ks-get ks (user-playlists-key username) '()))
          (if (list? ids)
              (filter-map
-              (lambda (id)
+              (λ (id)
                 (datum->tab id (ks-get ks id #f) libraries))
               (remove-duplicates (filter uuid-string? ids) string=?))
              '())))))
@@ -104,7 +104,7 @@
   (when store
     (call-with-semaphore
      (playlist-store-lock store)
-     (lambda ()
+     (λ ()
        (define ks (playlist-store-keystore store))
        (define index-key (user-playlists-key username))
        (define old-ids (ks-get ks index-key '()))
@@ -174,13 +174,13 @@
   (define outside (build-path root "outside.flac"))
   (define store-file (build-path root "data" "playlists.keystore"))
   (dynamic-wind
-    (lambda ()
+    (λ ()
       (make-directory music)
       (make-directory music-two)
       (call-with-output-file (build-path music "one.flac") void)
       (call-with-output-file (build-path music-two "two.flac") void)
       (call-with-output-file outside void))
-    (lambda ()
+    (λ ()
       (define libraries (make-music-libraries (list music music-two)))
       (define store (open-playlist-store store-file))
       (define first-id (uuid-string))
@@ -253,4 +253,4 @@
         (car (load-user-playlists store "unsafe" libraries)))
        '())
       (close-playlist-store! store))
-    (lambda () (delete-directory/files root))))
+    (λ () (delete-directory/files root))))
diff --git a/private/users.rkt b/private/users.rkt
index 14ea18b..36c374b 100644
--- a/private/users.rkt
+++ b/private/users.rkt
@@ -3,6 +3,7 @@
 (require crypto
          crypto/argon2
          net/private/ip
+         racket/contract
          racket/list
          racket/random
          racket/string
@@ -58,7 +59,8 @@
 ; post   : No module state is changed.
 ; result : A salted Argon2id hash encoded as a string.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (make-password-hash password)
+(define/contract (make-password-hash password)
+  (-> string? string?)
   (unless (and (string? password)
                (>= (string-length password) 12))
     (raise-argument-error
@@ -75,10 +77,11 @@
 ; post   : No module state is changed.
 ; result : #t only when both values are strings and the password matches.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (password-hash-valid? password encoded)
+(define/contract (password-hash-valid? password encoded)
+  (-> any/c any/c boolean?)
   (and (string? password)
        (string? encoded)
-       (with-handlers ((exn:fail? (lambda (_) #f)))
+       (with-handlers ((exn:fail? (λ (_) #f)))
          (pwhash-verify password-kdf
                         (string->bytes/utf-8 password)
                         encoded))))
@@ -101,7 +104,7 @@
     (raise-argument-error 'make-auth-manager "IP address or CIDR network" value))
   (define address
     (with-handlers ((exn:fail?
-                     (lambda (_)
+                     (λ (_)
                        (raise-argument-error
                         'make-auth-manager
                         "IP address or CIDR network"
@@ -118,7 +121,7 @@
   (ip-network address prefix))
 
 (define (network-contains? network address-string)
-  (with-handlers ((exn:fail? (lambda (_) #f)))
+  (with-handlers ((exn:fail? (λ (_) #f)))
     (define candidate (normal-ip-bytes address-string))
     (define expected (ip-network-address network))
     (and (= (bytes-length candidate) (bytes-length expected))
@@ -140,7 +143,7 @@
          (bytes->string/utf-8 (header-value value)))))
 
 (define (trusted-proxy? manager address)
-  (ormap (lambda (network) (network-contains? network address))
+  (ormap (λ (network) (network-contains? network address))
          (auth-manager-trusted-proxies manager)))
 
 (define (request-address manager request)
@@ -160,7 +163,8 @@
 ; post   : Manager remains unchanged.
 ; result : #t when at least one configured user can log in, otherwise #f.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (auth-enabled? manager)
+(define/contract (auth-enabled? manager)
+  (-> auth-manager? boolean?)
   (positive? (hash-count (auth-manager-users manager))))
 
 (define (request-session-token request)
@@ -183,7 +187,8 @@
 ; result : "anonymous" when authentication is disabled, the normalized
 ;          username for a valid session, or #f when login is required.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (auth-request-user manager request)
+(define/contract (auth-request-user manager request)
+  (-> auth-manager? request? (or/c #f string?))
   (cond
     ((not (auth-enabled? manager)) "anonymous")
     (else
@@ -192,7 +197,7 @@
        (and token
             (call-with-semaphore
              (auth-manager-lock manager)
-             (lambda ()
+             (λ ()
                (prune-sessions! manager now)
                (let ((value (hash-ref (auth-manager-sessions manager)
                                       token
@@ -230,34 +235,39 @@
 ; internals: Unknown users follow the same Argon2id verification path as known
 ;            users to reduce username-dependent timing differences.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (auth-login! manager request username password)
-  (define address (request-address manager request))
-  (define now (current-seconds))
-  (define normalized (string-downcase (string-trim username)))
-  (call-with-semaphore
-   (auth-manager-lock manager)
-   (lambda ()
-     (if (failure-blocked? manager address now)
-         'rate-limited
-         (let* ((stored (hash-ref (auth-manager-users manager)
-                                  normalized
-                                  #f))
-                (valid?
-                 (password-hash-valid?
-                  password
-                  (or stored dummy-password-hash))))
-           (if (and stored valid?)
-               (let ((token
-                      (bytes->hex-string (crypto-random-bytes 32))))
-                 (hash-remove! (auth-manager-failed manager) address)
-                 (prune-sessions! manager now)
-                 (hash-set! (auth-manager-sessions manager)
-                            token
-                            (session normalized now now))
-                 token)
-               (begin
-                 (record-failure! manager address now)
-                 #f)))))))
+(define/contract (auth-login! manager request username password)
+  (-> auth-manager?
+      request?
+      string?
+      string?
+      (or/c #f 'rate-limited string?))
+  (let ((address (request-address manager request))
+        (now (current-seconds))
+        (normalized (string-downcase (string-trim username))))
+    (call-with-semaphore
+     (auth-manager-lock manager)
+     (λ ()
+       (if (failure-blocked? manager address now)
+           'rate-limited
+           (let* ((stored (hash-ref (auth-manager-users manager)
+                                    normalized
+                                    #f))
+                  (valid?
+                   (password-hash-valid?
+                    password
+                    (or stored dummy-password-hash))))
+             (if (and stored valid?)
+                 (let ((token
+                        (bytes->hex-string (crypto-random-bytes 32))))
+                   (hash-remove! (auth-manager-failed manager) address)
+                   (prune-sessions! manager now)
+                   (hash-set! (auth-manager-sessions manager)
+                              token
+                              (session normalized now now))
+                   token)
+                 (begin
+                   (record-failure! manager address now)
+                   #f))))))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; goal   : End the browser session named by the request cookie.
@@ -265,12 +275,13 @@
 ; post   : The matching server-side session is removed when it exists.
 ; result : Void.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (auth-logout! manager request)
+(define/contract (auth-logout! manager request)
+  (-> auth-manager? request? void?)
   (let ((token (request-session-token request)))
     (when token
       (call-with-semaphore
        (auth-manager-lock manager)
-       (lambda ()
+       (λ ()
          (hash-remove! (auth-manager-sessions manager) token))))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -280,7 +291,8 @@
 ; result : A Secure, HttpOnly, SameSite=Strict Set-Cookie value whose Max-Age
 ;          equals the configured session lifetime.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (auth-session-cookie manager token)
+(define/contract (auth-session-cookie manager token)
+  (-> auth-manager? string? bytes?)
   (string->bytes/utf-8
    (format
     "~a=~a; Path=/; Max-Age=~a; Secure; HttpOnly; SameSite=Strict"
@@ -299,7 +311,8 @@
 ;            this half-life threshold prevents the one-second player poll from
 ;            returning Set-Cookie every second.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (auth-renewal-cookie manager request)
+(define/contract (auth-renewal-cookie manager request)
+  (-> auth-manager? request? (or/c #f bytes?))
   (and (auth-enabled? manager)
        (let ((token (request-session-token request))
              (now (current-seconds)))
@@ -308,17 +321,17 @@
                (auth-manager-lock manager)
                (λ ()
                  (prune-sessions! manager now)
-                 (define value
-                   (hash-ref (auth-manager-sessions manager) token #f))
-                 (and value
-                      (>= (- now (session-last-cookie-renewal value))
-                          (max 1
-                               (quotient
-                                (auth-manager-session-seconds manager)
-                                2)))
-                      (begin
-                        (set-session-last-cookie-renewal! value now)
-                        (auth-session-cookie manager token)))))))))
+                 (let ((value
+                        (hash-ref (auth-manager-sessions manager) token #f)))
+                   (and value
+                        (>= (- now (session-last-cookie-renewal value))
+                            (max 1
+                                 (quotient
+                                  (auth-manager-session-seconds manager)
+                                  2)))
+                        (begin
+                          (set-session-last-cookie-renewal! value now)
+                          (auth-session-cookie manager token))))))))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; goal   : Encode deletion of the browser session cookie.
@@ -326,7 +339,8 @@
 ; post   : No module state is changed.
 ; result : A Secure, HttpOnly, SameSite=Strict Set-Cookie value with Max-Age 0.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (auth-expired-cookie)
+(define/contract (auth-expired-cookie)
+  (-> bytes?)
   (string->bytes/utf-8
    (format
     "~a=; Path=/; Max-Age=0; Secure; HttpOnly; SameSite=Strict"
@@ -341,10 +355,15 @@
 ;          empty.
 ; result : A new auth-manager with normalized usernames and parsed networks.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define (make-auth-manager user-pairs
-                           #:trusted-proxies
-                           [trusted-proxy-values '("127.0.0.0/8" "::1/128")]
-                           #:session-seconds [session-seconds 604800])
+(define/contract (make-auth-manager
+                  user-pairs
+                  #:trusted-proxies
+                  [trusted-proxy-values '("127.0.0.0/8" "::1/128")]
+                  #:session-seconds [session-seconds 604800])
+  (->* ((listof (cons/c string? string?)))
+       (#:trusted-proxies (listof string?)
+        #:session-seconds exact-positive-integer?)
+       auth-manager?)
   (unless (exact-positive-integer? session-seconds)
     (raise-argument-error 'make-auth-manager "exact-positive-integer?"
                           session-seconds))
diff --git a/public/rkt-web-player.png b/public/rkt-web-player.png
new file mode 100644
index 0000000000000000000000000000000000000000..429a5ccbe13320ae379d016d342e6575032d8cc0
GIT binary patch
literal 61450
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

literal 0
HcmV?d00001

diff --git a/scribblings/rkt-web-player.scrbl b/scribblings/rkt-web-player.scrbl
index 4f13b1c..df05e7b 100644
--- a/scribblings/rkt-web-player.scrbl
+++ b/scribblings/rkt-web-player.scrbl
@@ -4,6 +4,7 @@
                      racket/contract
                      rkt-web-player
                      rkt-web-player/player-agent
+                     rkt-web-player/set-user
                      rkt-web-player/users))
 
 @title{RKT Web Player}
@@ -77,6 +78,15 @@ Creates a salted Argon2id password hash suitable for a value in the INI
 Checks a password against an encoded Argon2id hash.
 }
 
+@defmodule[rkt-web-player/set-user]
+
+@defproc[(set-user) void?] {
+
+Interactively reads a username and password and writes the corresponding
+Argon2id hash to the @tt{[users]} section of @filepath{rkt-web-player.ini} in
+the current directory. The password must contain at least twelve characters.
+}
+
 @defmodule[rkt-web-player/player-agent]
 
 @defproc[(run-player-agent) any/c] {
@@ -87,8 +97,10 @@ configured RKT Web Player server, downloads assigned tracks over HTTP, and
 plays them with @tt{racket-audio}. Its configured display name is authoritative
 and is followed by the server. Importing the module does not start the GUI; the
 function must be called explicitly.
-The GUI and optional tray support the same ten languages based on the
-operating-system language, with English as fallback.
+The GUI and its @tt{racket-tray} system tray support the same ten languages
+based on the operating-system language, with English as fallback. Closing or
+minimizing the window hides it in the tray. The tray menu restores the window
+or shuts down the agent; no SDL3 runtime is required.
 }
 
 @defproc[(run-player-agent-cli [#:server-url server-url
diff --git a/set-user.rkt b/set-user.rkt
index cefb152..98b1159 100644
--- a/set-user.rkt
+++ b/set-user.rkt
@@ -1,24 +1,36 @@
 #lang racket/base
 
-(require "users.rkt"
-         simple-ini/class)
+(require racket/class
+         racket/contract
+         simple-ini/class
+         "users.rkt")
 
 (provide set-user)
 
-(define (set-user)
-	(displayln "Using rkt-web-player.ini as configuration file")
-	(newline)
-	(display   "Give username: >")
-	(define user (read-line))
-	(display   "Give password: >")
-	(define pwd (read-line))
-
-	(let ((hash (make-password-hash pwd)))
-		(define ini (new ini% [file "rkt-web-player.ini"]))
-		(send ini set! 'users (string->symbol user) hash)
-		)
-	)
-
-
-
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Provided functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; goal   : Interactively add or replace one configured web-player user.
+; pre    : Standard input supplies a username and a password of at least
+;          twelve characters; rkt-web-player.ini is writable.
+; post   : The INI file's [users] section contains an Argon2id hash for the
+;          entered username; the clear-text password is not stored.
+; result : Void after the configuration file has been updated.
+; internals:
+;          The small utility uses simple-ini directly and intentionally owns
+;          no duplicate configuration representation.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define/contract (set-user)
+  (-> void?)
+  (displayln "Using rkt-web-player.ini as configuration file")
+  (newline)
+  (display "Give username: >")
+  (let ((user (read-line)))
+    (display "Give password: >")
+    (let* ((password (read-line))
+           (hash (make-password-hash password))
+           (ini (new ini% (file "rkt-web-player.ini"))))
+      (send ini set! 'users (string->symbol user) hash)
+      (void))))
diff --git a/skill/racket-skill.md b/skill/racket-skill.md
deleted file mode 100644
index 4674b22..0000000
--- a/skill/racket-skill.md
+++ /dev/null
@@ -1,227 +0,0 @@
----
-name: racket-programmeer-skill
-description: Hiermee wordt mijn voorkeur racket programmeerstijl aangegeven.
----
-
----
-name: racket-programmeerstijl
-description: Gebruik deze skill wanneer je Racket-code voor Hans schrijft, wijzigt, refactort of beoordeelt. Pas de bestaande, eenvoudige en procedurele programmeerstijl toe; voorkom over-engineering en onnodige abstracties. Gebruik deze skill niet voor algemene uitleg over Racket waarbij geen code voor zijn projecten wordt gemaakt of aangepast.
----
-
-# Racket-programmeerstijl
-
-Gebruik deze stijl wanneer je Racket-code voor Hans schrijft of aanpast.
-
-## Uitgangspunt
-
-Het *allerbelangrijkste* uitgangspunt is dat je de programmerstijl van aangeleverde code volgt. 
-Als je een zip met een package aangeleverd krijgt via de prompt dan volg je de programmeerstijl die je in de aangeleverde code vindt.
-Wanneer bestaande broncode beschikbaar is, heeft de stijl van die broncode voorrang. Sluit daar zo nauw mogelijk op aan.
-
-Schrijf eenvoudige, directe en goed leesbare Racket-code. 
-Kies de kleinste oplossing die het huidige probleem netjes oplost. 
-Bouw geen abstraheringslaag voor mogelijk toekomstig gebruik.
-En maak geen helpers die alleen maar in de weg staan. 
-
-## Structuur
-
-- Houd modules klein en doelgericht.
-- Splits functionaliteit alleen af naar een private module wanneer die een duidelijk eigen doel heeft.
-- Gebruik voor duidelijke secties bij voorkeur commentaar in deze vorm:
-
-```racket
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Supporting functions
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-```
-
-of, wanneer dat beter bij de module past:
-
-```racket
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Internal state / functions
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-```
-
-Voor publieke functies:
-
-```racket
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Provided functions
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-```
-
-- Houd `provide` en `require` eenvoudig en overzichtelijk.
-- Voeg geen extra framework, wrapperlaag of generieke infrastructuur toe zonder concrete noodzaak.
-
-## pre/postcondities
-
-Geëxporteerde functies/procedures/classes of functies/procedures/classes die daarvoor duidelijk in 
-aanmerking komen, d.w.z. die die provided zijn of naar verwachting zullen worden, moeten gedocumenteerd worden.
-Zowel in een module scribble als in de code zelf. In het engels. 
-
-In de code zelf: minimaal:
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; goal   : <doel>
-; pre    : <preconditie(s)>
-; post   : <postconditie(s)>
-; [result:] <resultaat en onder welke conditie>
-
-Over het algemeen wil je de internals van een functie weten. Hoe werkt het en waarom werkt het zo.
-
-; [internals:]
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-Als een functie/procedure/class overduidelijk in aanmerking komt voor 'provide' en hij staat er nog niet in.
-Verzamel dan de lijst en vraag of je ze moet toevoegen. 
-
-## Procedures en control flow
-
-- Geef de voorkeur aan gewone procedures met een direct leesbare control flow.
-- Gebruik van `let`, `let*`, `letrec`, `if`, `when`, `unless`, `begin` en `cond` heeft de voorkeur.
-- `map`, `filter`, en dat soort constructies gaan boven meer abstracte constructies als `for/or`, etc.
-- Gebruik bij voorkeur geen `define` binnen een procedure, tenzij het echt om een locale
-  functie definitie gaat die een dermate omvang krijgt dat het binnen de closure gerechtvaardigd is. 
-- `let-values` is prima om te gebruiken. 
-- Maak niet voor iedere kleine stap een aparte helperprocedure.
-- Introduceer geen hogere-orde of functionele constructies alleen omdat dat compacter kan.
-- Gebruik recursie of een named `let` wanneer dat de meest directe oplossing is.
-- Gebruik bij `cond` bij voorkeur deze vorm:
-
-```racket
-(cond 
-  ([condition] korte body)
-  ([other-condition]
-   langere body))
-  (else ... alleen als het nodig is)
-```
-
-## Mate van abstractie vs leesbaarheid
-
-Liever concreet dan abstract. 
-
-Geef expliciete, goed leesbare constructies de voorkeur boven compacte abstracte idiomen. 
-
-Bijvoorbeeld combinaties als (filter values (list (and condition 'symbol) ...)). 
-Schrijf dan liever expliciet (filter (lambda (x) x) (list (if condition 'symbol #f) ...)). 
-Vermijd vooral het stapelen van meerdere impliciete idiomen wanneer dat de leesbaarheid vermindert.
-
-## Gebruik lambda.
-
-Geef de voorkeur aan λ boven lambda. 
-
-## Waarden en state
-
-- Gebruik `#f` als normale waarde voor "niet gevonden", "niet beschikbaar" of "nog niet geïnitialiseerd" wanneer dat natuurlijk past.
-- Expliciete vergelijkingen zoals `(eq? value #f)` zijn prima wanneer dat de bedoeling duidelijk maakt.
-- Houd state eenvoudig. Een gewone modulevariabele zoals `cached-git-exe` is prima wanneer daarvoor geen zwaarder mechanisme nodig is.
-- Gebruik geen parameters, structs, classes of objectlagen wanneer een gewone variabele of procedure voldoende is.
-
-## Publieke API
-
-- Gebruik `define/contract` voor publieke procedures wanneer een contract nuttige documentatie en controle geeft.
-- Houd publieke procedures klein en voorspelbaar.
-- Verander een bestaande publieke API niet zonder noodzaak.
-- Voeg geen extra publieke functies toe voor hypothetische toekomstige behoeften.
-
-## Fouten en interactie
-
-- Geef duidelijke en concrete foutmeldingen.
-- Los eenvoudige interactieve invoer lokaal en procedureel op.
-- Maak foutafhandeling niet generieker dan nodig.
-- Als een externe executable of voorziening ontbreekt, meld precies wat ontbreekt en wat de gebruiker kan doen.
-
-## Configuratie
-
-- Bewaar lokale configuratie in een kleine, afzonderlijke private module wanneer dat de hoofdmodule eenvoudiger maakt.
-- Gebruik bestaande projectvoorzieningen, zoals `simple-ini`, rechtstreeks in plaats van er een extra abstractielaag omheen te bouwen.
-- Dupliceer geen configuratie die al door een extern programma zelf wordt beheerd.
-
-## Naamgeving en leesbaarheid
-
-- Kies concrete, korte namen die passen bij de bestaande code.
-- Gebruik Engels voor identifiers en technische namen wanneer de bestaande code dat doet.
-- Schrijf comments alleen wanneer ze iets toevoegen dat niet al vanzelf uit de code blijkt.
-- Geef de voorkeur aan een paar duidelijke regels boven een compacte maar moeilijker leesbare expressie.
-
-## Vermijd
-
-Vermijd zonder concrete noodzaak:
-
-- over-engineering;
-- generieke wrappers;
-- extra abstraheringslagen;
-- dynamische `require`-constructies;
-- classes wanneer procedures volstaan;
-- structs wanneer een eenvoudige waarde volstaat;
-- configuratie-objecten of dependency-injectionpatronen;
-- veel kleine helperprocedures die de control flow versnipperen;
-- refactors die alleen bedoeld zijn om code "slimmer" of abstracter te maken.
-
-## Werkwijze bij aanpassen van bestaande code
-
-1. Lees eerst de omliggende module(s).
-2. Neem naamgeving, inspringing, control-flow-stijl en module-indeling over.
-3. Wijzig alleen wat voor de gevraagde stap nodig is.
-4. Houd bestaande werkende code intact als er geen reden is die te veranderen.
-5. Voeg geen volgende architectuurstappen alvast toe.
-6. Controleer of de oplossing eenvoudiger is dan het probleem; zo niet, vereenvoudig.
-
-## Referentiestijl
-
-Deze vorm is representatief:
-
-```racket
-(define cached-value #f)
-
-(define/contract (get-value)
-  (-> (or/c path? #f))
-  (if (eq? cached-value #f)
-      (let ((value (find-value)))
-        (set! cached-value value)
-        value)
-      cached-value))
-```
-
-Een wat langere maar direct leesbare implementatie heeft de voorkeur boven een kortere oplossing met meerdere nieuwe abstracties.
-
-# Schrijven van testgevallen voor modules/packages
-
-Een test die alleen werkt vanuit de development directory, op het development-OS of met de lokale shell/environment is geen geldige package-test.
-
-## Racket Package Index / build-service tests
-
-Behandel de Racket Package Index/build service als een aparte, strikte
-en onbekende testomgeving.
-
-Bij packagecode en tests gelden daarom altijd de volgende regels:
-
-- Maak nooit aannames over `current-directory` of de directory van waaruit
-  code of tests worden uitgevoerd. Bepaal testdata en paden expliciet en
-  relocatable, bijvoorbeeld met runtime paths en tijdelijke directories.
-
-- Maak nooit impliciete aannames over het besturingssysteem. Vermijd
-  OS-specifieke paden, shells, executables en gedrag, of handel verschillen
-  expliciet per platform af.
-
-- Maak tests onafhankelijk van lokale environment state. Benodigde
-  environment variables moeten expliciet en bij voorkeur geïsoleerd worden
-  ingesteld.
-
-- Een succesvolle test moet stil en ondubbelzinnig succesvol zijn.
-  Laat geen verwachte foutmeldingen naar de echte stdout/stderr lekken,
-  omdat `raco test --drdr` en de Package Index dergelijke output als een
-  mogelijke test failure kunnen classificeren.
-
-- Verwachte foutoutput moet worden gecaptureerd en geassert.
-
-- Tests moeten hun eigen tijdelijke state en testbestanden aanmaken en
-  mogen geen bestanden, processen, environment changes of andere state
-  achterlaten.
-
-- Test packagewijzigingen waar mogelijk ook in een omgeving die lijkt op:
-  `raco setup --check-pkg-deps` en
-  `raco test --drdr --package <package>`.
-
-