Fix signal-add-sub! losing subscribers after remove, fix build pipeline

signal-add-sub! used (append! subscribers f) which returns a new list
for immutable List but discards the result — after signal-remove-sub!
replaces the subscribers list via dict-set!, re-adding subscribers
silently fails. Counter island only worked once (0→1 then stuck).

Fix: use (dict-set! s "subscribers" (append ...)) to explicitly update
the dict field, matching signal-remove-sub!'s pattern.

Build pipeline fixes:
- sx-build-all.sh now bundles spec→dist and recompiles .sxbc bytecode
- compile-modules.js syncs .sx source files alongside .sxbc to wasm/sx/
- Per-file cache busting: wasm, platform JS, and sxbc each get own hash
- bundle.sh adds cssx.sx to dist

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

shared/static/wasm/sx-platform-2.js

@@ -180,8 +180,12 @@
 
   var _baseUrl = "";
 
-  // Detect base URL from current script
+  // Detect base URL and cache-bust params from current script tag.
+  // _cacheBust comes from the script's own ?v= query string (used for .sx source fallback).
+  // _sxbcCacheBust comes from data-sxbc-hash attribute — a separate content hash
+  // covering all .sxbc files so each file gets its own correct cache buster.
   var _cacheBust = "";
+  var _sxbcCacheBust = "";
   (function() {
     if (typeof document !== "undefined") {
       var scripts = document.getElementsByTagName("script");
@@ -191,6 +195,8 @@
           _baseUrl = src.substring(0, src.lastIndexOf("/") + 1);
           var qi = src.indexOf("?");
           if (qi !== -1) _cacheBust = src.substring(qi);
+          var sxbcHash = scripts[i].getAttribute("data-sxbc-hash");
+          if (sxbcHash) _sxbcCacheBust = "?v=" + sxbcHash;
           break;
         }
       }
@@ -239,7 +245,7 @@
 
     // Try .sxbc (SX s-expression format, loaded via load-sxbc primitive)
     var sxbcPath = path.replace(/\.sx$/, '.sxbc');
-    var sxbcUrl = _baseUrl + sxbcPath + _cacheBust;
+    var sxbcUrl = _baseUrl + sxbcPath + _sxbcCacheBust;
     try {
       var xhr2 = new XMLHttpRequest();
       xhr2.open("GET", sxbcUrl, false);

shared/static/wasm/sx/core-signals.sx

@@ -1,4 +1,8 @@
-(define make-signal (fn (value) (dict "__signal" true "value" value "subscribers" (list) "deps" (list))))
+(define
+  make-signal
+  (fn
+    (value)
+    (dict "__signal" true "value" value "subscribers" (list) "deps" (list))))
 
 (define signal? (fn (x) (and (dict? x) (has-key? x "__signal"))))
 
@@ -8,38 +12,184 @@
 
 (define signal-subscribers (fn (s) (get s "subscribers")))
 
-(define signal-add-sub! (fn (s f) (when (not (contains? (get s "subscribers") f)) (append! (get s "subscribers") f))))
+(define
+  signal-add-sub!
+  (fn
+    (s f)
+    (when
+      (not (contains? (get s "subscribers") f))
+      (dict-set! s "subscribers" (append (get s "subscribers") (list f))))))
 
-(define signal-remove-sub! (fn (s f) (dict-set! s "subscribers" (filter (fn (sub) (not (identical? sub f))) (get s "subscribers")))))
+(define
+  signal-remove-sub!
+  (fn
+    (s f)
+    (dict-set!
+      s
+      "subscribers"
+      (filter (fn (sub) (not (identical? sub f))) (get s "subscribers")))))
 
 (define signal-deps (fn (s) (get s "deps")))
 
 (define signal-set-deps! (fn (s deps) (dict-set! s "deps" deps)))
 
-(define signal :effects () (fn ((initial-value :as any)) (make-signal initial-value)))
+(define
+  signal
+  :effects ()
+  (fn ((initial-value :as any)) (make-signal initial-value)))
 
-(define deref :effects () (fn ((s :as any)) (if (not (signal? s)) s (let ((ctx (context "sx-reactive" nil))) (when ctx (let ((dep-list (get ctx "deps")) (notify-fn (get ctx "notify"))) (when (not (contains? dep-list s)) (append! dep-list s) (signal-add-sub! s notify-fn)))) (signal-value s)))))
+(define
+  deref
+  :effects ()
+  (fn
+    ((s :as any))
+    (if
+      (not (signal? s))
+      s
+      (let
+        ((ctx (context "sx-reactive" nil)))
+        (when
+          ctx
+          (let
+            ((dep-list (get ctx "deps")) (notify-fn (get ctx "notify")))
+            (when
+              (not (contains? dep-list s))
+              (append! dep-list s)
+              (signal-add-sub! s notify-fn))))
+        (signal-value s)))))
 
-(define reset! :effects (mutation) (fn ((s :as signal) value) (when (signal? s) (let ((old (signal-value s))) (when (not (identical? old value)) (signal-set-value! s value) (notify-subscribers s))))))
+(define
+  reset!
+  :effects (mutation)
+  (fn
+    ((s :as signal) value)
+    (when
+      (signal? s)
+      (let
+        ((old (signal-value s)))
+        (when
+          (not (identical? old value))
+          (signal-set-value! s value)
+          (notify-subscribers s))))))
 
-(define swap! :effects (mutation) (fn ((s :as signal) (f :as lambda) &rest args) (when (signal? s) (let ((old (signal-value s)) (new-val (trampoline (apply f (cons old args))))) (when (not (identical? old new-val)) (signal-set-value! s new-val) (notify-subscribers s))))))
+(define
+  swap!
+  :effects (mutation)
+  (fn
+    ((s :as signal) (f :as lambda) &rest args)
+    (when
+      (signal? s)
+      (let
+        ((old (signal-value s))
+          (new-val (trampoline (apply f (cons old args)))))
+        (when
+          (not (identical? old new-val))
+          (signal-set-value! s new-val)
+          (notify-subscribers s))))))
 
-(define computed :effects (mutation) (fn ((compute-fn :as lambda)) (let ((s (make-signal nil)) (deps (list)) (compute-ctx nil)) (let ((recompute (fn () (for-each (fn ((dep :as signal)) (signal-remove-sub! dep recompute)) (signal-deps s)) (signal-set-deps! s (list)) (let ((ctx (dict "deps" (list) "notify" recompute))) (scope-push! "sx-reactive" ctx) (let ((new-val (cek-call compute-fn nil))) (scope-pop! "sx-reactive") (signal-set-deps! s (get ctx "deps")) (let ((old (signal-value s))) (signal-set-value! s new-val) (when (not (identical? old new-val)) (notify-subscribers s)))))))) (recompute) (register-in-scope (fn () (dispose-computed s))) s))))
+(define
+  computed
+  :effects (mutation)
+  (fn
+    ((compute-fn :as lambda))
+    (let
+      ((s (make-signal nil)) (deps (list)) (compute-ctx nil))
+      (let
+        ((recompute (fn () (for-each (fn ((dep :as signal)) (signal-remove-sub! dep recompute)) (signal-deps s)) (signal-set-deps! s (list)) (let ((ctx (dict "deps" (list) "notify" recompute))) (scope-push! "sx-reactive" ctx) (let ((new-val (cek-call compute-fn nil))) (scope-pop! "sx-reactive") (signal-set-deps! s (get ctx "deps")) (let ((old (signal-value s))) (signal-set-value! s new-val) (when (not (identical? old new-val)) (notify-subscribers s))))))))
+        (recompute)
+        (register-in-scope (fn () (dispose-computed s)))
+        s))))
 
-(define effect :effects (mutation) (fn ((effect-fn :as lambda)) (let ((deps (list)) (disposed false) (cleanup-fn nil)) (let ((run-effect (fn () (when (not disposed) (when cleanup-fn (cek-call cleanup-fn nil)) (for-each (fn ((dep :as signal)) (signal-remove-sub! dep run-effect)) deps) (set! deps (list)) (let ((ctx (dict "deps" (list) "notify" run-effect))) (scope-push! "sx-reactive" ctx) (let ((result (cek-call effect-fn nil))) (scope-pop! "sx-reactive") (set! deps (get ctx "deps")) (when (callable? result) (set! cleanup-fn result)))))))) (run-effect) (let ((dispose-fn (fn () (set! disposed true) (when cleanup-fn (cek-call cleanup-fn nil)) (for-each (fn ((dep :as signal)) (signal-remove-sub! dep run-effect)) deps) (set! deps (list))))) (register-in-scope dispose-fn) dispose-fn)))))
+(define
+  effect
+  :effects (mutation)
+  (fn
+    ((effect-fn :as lambda))
+    (let
+      ((deps (list)) (disposed false) (cleanup-fn nil))
+      (let
+        ((run-effect (fn () (when (not disposed) (when cleanup-fn (cek-call cleanup-fn nil)) (for-each (fn ((dep :as signal)) (signal-remove-sub! dep run-effect)) deps) (set! deps (list)) (let ((ctx (dict "deps" (list) "notify" run-effect))) (scope-push! "sx-reactive" ctx) (let ((result (cek-call effect-fn nil))) (scope-pop! "sx-reactive") (set! deps (get ctx "deps")) (when (callable? result) (set! cleanup-fn result))))))))
+        (run-effect)
+        (let
+          ((dispose-fn (fn () (set! disposed true) (when cleanup-fn (cek-call cleanup-fn nil)) (for-each (fn ((dep :as signal)) (signal-remove-sub! dep run-effect)) deps) (set! deps (list)))))
+          (register-in-scope dispose-fn)
+          dispose-fn)))))
 
 (define *batch-depth* 0)
 
 (define *batch-queue* (list))
 
-(define batch :effects (mutation) (fn ((thunk :as lambda)) (set! *batch-depth* (+ *batch-depth* 1)) (cek-call thunk nil) (set! *batch-depth* (- *batch-depth* 1)) (when (= *batch-depth* 0) (let ((queue *batch-queue*)) (set! *batch-queue* (list)) (let ((seen (list)) (pending (list))) (for-each (fn ((s :as signal)) (for-each (fn ((sub :as lambda)) (when (not (contains? seen sub)) (append! seen sub) (append! pending sub))) (signal-subscribers s))) queue) (for-each (fn ((sub :as lambda)) (sub)) pending))))))
+(define
+  batch
+  :effects (mutation)
+  (fn
+    ((thunk :as lambda))
+    (set! *batch-depth* (+ *batch-depth* 1))
+    (cek-call thunk nil)
+    (set! *batch-depth* (- *batch-depth* 1))
+    (when
+      (= *batch-depth* 0)
+      (let
+        ((queue *batch-queue*))
+        (set! *batch-queue* (list))
+        (let
+          ((seen (list)) (pending (list)))
+          (for-each
+            (fn
+              ((s :as signal))
+              (for-each
+                (fn
+                  ((sub :as lambda))
+                  (when
+                    (not (contains? seen sub))
+                    (append! seen sub)
+                    (append! pending sub)))
+                (signal-subscribers s)))
+            queue)
+          (for-each (fn ((sub :as lambda)) (sub)) pending))))))
 
-(define notify-subscribers :effects (mutation) (fn ((s :as signal)) (if (> *batch-depth* 0) (when (not (contains? *batch-queue* s)) (append! *batch-queue* s)) (flush-subscribers s))))
+(define
+  notify-subscribers
+  :effects (mutation)
+  (fn
+    ((s :as signal))
+    (if
+      (> *batch-depth* 0)
+      (when (not (contains? *batch-queue* s)) (append! *batch-queue* s))
+      (flush-subscribers s))))
 
-(define flush-subscribers :effects (mutation) (fn ((s :as signal)) (for-each (fn ((sub :as lambda)) (sub)) (signal-subscribers s))))
+(define
+  flush-subscribers
+  :effects (mutation)
+  (fn
+    ((s :as dict))
+    (for-each (fn ((sub :as lambda)) (sub)) (signal-subscribers s))))
 
-(define dispose-computed :effects (mutation) (fn ((s :as signal)) (when (signal? s) (for-each (fn ((dep :as signal)) (signal-remove-sub! dep nil)) (signal-deps s)) (signal-set-deps! s (list)))))
+(define
+  dispose-computed
+  :effects (mutation)
+  (fn
+    ((s :as signal))
+    (when
+      (signal? s)
+      (for-each
+        (fn ((dep :as signal)) (signal-remove-sub! dep nil))
+        (signal-deps s))
+      (signal-set-deps! s (list)))))
 
-(define with-island-scope :effects (mutation) (fn ((scope-fn :as lambda) (body-fn :as lambda)) (scope-push! "sx-island-scope" scope-fn) (let ((result (body-fn))) (scope-pop! "sx-island-scope") result)))
+(define
+  with-island-scope
+  :effects (mutation)
+  (fn
+    ((scope-fn :as lambda) (body-fn :as lambda))
+    (scope-push! "sx-island-scope" scope-fn)
+    (let ((result (body-fn))) (scope-pop! "sx-island-scope") result)))
 
-(define register-in-scope :effects (mutation) (fn ((disposable :as lambda)) (let ((collector (scope-peek "sx-island-scope"))) (when collector (cek-call collector (list disposable))))))
+(define
+  register-in-scope
+  :effects (mutation)
+  (fn
+    ((disposable :as lambda))
+    (let
+      ((collector (scope-peek "sx-island-scope")))
+      (when collector (cek-call collector (list disposable))))))