@c9up/aurora 0.1.5 → 0.1.6

package/dist/component.js

@@ -18,6 +18,7 @@
  * signals the setup function captures. The compiled template is what
  * actually moves on screen.
  */
+import { setOwner } from "./reactive.js";
 const contextStack = [];
 function activeContext() {
     const ctx = contextStack[contextStack.length - 1];
@@ -41,11 +42,17 @@ export function component(setup) {
             mountHooks: [],
         };
         contextStack.push(ctx);
+        // Own the reactive scope of setup: effects/memos created here register
+        // their disposer into ctx.cleanups and tear down at unmount, instead of
+        // leaking their signal subscriptions. Restored after setup so the outer
+        // scope (or none) resumes. Save/restore handles nested component() calls.
+        const prevOwner = setOwner(ctx.cleanups);
         try {
             const result = setup((props ?? {}));
             return wrapWithLifecycle(result, ctx);
         }
         finally {
+            setOwner(prevOwner);
             contextStack.pop();
         }
     };

package/dist/reactive.d.ts

@@ -28,6 +28,13 @@ export interface Signal<T> {
  * sites need to import this directly.
  */
 export declare const SIGNAL_BRAND: unique symbol;
+/**
+ * @internal Swap the ambient owner, returning the previous one so the
+ * caller can restore it. `component()` uses this to own the effects and
+ * memos a setup function creates, so they dispose at unmount instead of
+ * keeping their signal subscriptions alive forever.
+ */
+export declare function setOwner(owner: Array<() => void> | undefined): Array<() => void> | undefined;
 /**
  * Create a writable signal seeded with `initial`. Reads register the
  * current observer; writes notify every observer that previously read.

package/dist/reactive.js

@@ -23,6 +23,24 @@ const pendingNotifications = new Set();
 function activeObserver() {
     return observerStack[observerStack.length - 1];
 }
+/**
+ * Ambient disposal owner. A non-reactive scope (e.g. a component's setup
+ * run) registers an array here so effects/memos created during its
+ * execution push their disposer into it and are torn down when the scope
+ * ends. `undefined` at top level — no scope, no auto-disposal.
+ */
+let currentOwner;
+/**
+ * @internal Swap the ambient owner, returning the previous one so the
+ * caller can restore it. `component()` uses this to own the effects and
+ * memos a setup function creates, so they dispose at unmount instead of
+ * keeping their signal subscriptions alive forever.
+ */
+export function setOwner(owner) {
+    const prev = currentOwner;
+    currentOwner = owner;
+    return prev;
+}
 /**
  * Create a writable signal seeded with `initial`. Reads register the
  * current observer; writes notify every observer that previously read.
@@ -129,7 +147,13 @@ export function effect(fn) {
         },
     };
     eff.run();
-    return () => eff.dispose();
+    const dispose = () => eff.dispose();
+    // Register with the ambient owner (e.g. a component's setup scope) so the
+    // effect is torn down when that scope ends. `memo()` builds on this — its
+    // internal recompute effect inherits the same ownership, which is what
+    // stops a memo created in component setup from leaking after unmount.
+    currentOwner?.push(dispose);
+    return dispose;
 }
 /**
  * Register a cleanup callback against the currently-running effect.

package/dist/relay.js

@@ -21,7 +21,6 @@ const STATE = {
     sse: null,
     uid: null,
     channels: new Map(),
-    pending: [],
 };
 let CONFIG = {
     sseUrl: "/__relay/events",
@@ -60,17 +59,15 @@ const CLIENT = {
         }
         const adapted = handler;
         handlers.add(adapted);
-        // Subscribe over POST as soon as we have a uid. If the SSE is
-        // still mid-handshake, queue the call and flush on `connected`.
-        const doSubscribe = () => {
+        // Subscribe over POST as soon as we have a uid. Before the first uid (or
+        // during an auto-reconnect) the channel already lives in STATE.channels
+        // and is (re-)subscribed by the `connected` handler — so the server,
+        // which assigns a fresh uid per connection, always learns every channel.
+        if (STATE.uid) {
             postSubscribe(channel).catch((err) => {
                 console.warn(`[aurora/relay] subscribe to ${channel} failed:`, err);
             });
-        };
-        if (STATE.uid)
-            doSubscribe();
-        else
-            STATE.pending.push(doSubscribe);
+        }
         // Detacher — only removes the local listener. The server-side
         // subscription stays open; closing it would interrupt other
         // listeners on the same channel.
@@ -85,7 +82,6 @@ const CLIENT = {
         }
         STATE.uid = null;
         STATE.channels.clear();
-        STATE.pending.length = 0;
     },
 };
 function open() {
@@ -95,9 +91,16 @@ function open() {
         const data = safeJson(ev.data);
         if (data && typeof data.uid === "string") {
             STATE.uid = data.uid;
-            const queue = STATE.pending.splice(0);
-            for (const fn of queue)
-                fn();
+            // Re-apply EVERY active subscription on each (re)connect. The server
+            // assigns a fresh uid per connection and has no memory of prior
+            // subscriptions, so both the first connect AND browser auto-reconnects
+            // must re-POST every live channel — otherwise the client silently
+            // stops receiving after a reconnect.
+            for (const channel of STATE.channels.keys()) {
+                postSubscribe(channel).catch((err) => {
+                    console.warn(`[aurora/relay] re-subscribe to ${channel} failed:`, err);
+                });
+            }
         }
     });
     sse.onmessage = (ev) => {

package/dist/server/renderPage.js

@@ -41,7 +41,7 @@ export async function renderPage(ctx, pages, name, props, options = {}) {
 <head>
 <meta charset="utf-8" />
 <meta name="viewport" content="width=device-width,initial-scale=1" />
-<script type="importmap">${JSON.stringify({ imports: importmap })}</script>
+<script type="importmap">${escapeJsonForScript({ imports: importmap })}</script>
 ${options.headExtra ?? ""}
 </head>
 <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c9up/aurora",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Aurora — reactive UI runtime for the Ream framework. Tagged-template DOM, signal-based state, isomorphic SSR + hydration, zero build step.",
   "license": "MIT",
   "type": "module",

package/src/component.ts

@@ -19,6 +19,7 @@
  * actually moves on screen.
  */
 
+import { setOwner } from "./reactive.js";
 import type { Disposer } from "./render.js";
 import type { EffectCallback, TemplateResult } from "./types.js";
 
@@ -63,10 +64,16 @@ export function component<P = Record<string, never>>(
 			mountHooks: [],
 		};
 		contextStack.push(ctx);
+		// Own the reactive scope of setup: effects/memos created here register
+		// their disposer into ctx.cleanups and tear down at unmount, instead of
+		// leaking their signal subscriptions. Restored after setup so the outer
+		// scope (or none) resumes. Save/restore handles nested component() calls.
+		const prevOwner = setOwner(ctx.cleanups);
 		try {
 			const result = setup((props ?? ({} as P)) as P);
 			return wrapWithLifecycle(result, ctx);
 		} finally {
+			setOwner(prevOwner);
 			contextStack.pop();
 		}
 	};

package/src/reactive.ts

@@ -64,6 +64,28 @@ function activeObserver(): Effect | undefined {
 	return observerStack[observerStack.length - 1];
 }
 
+/**
+ * Ambient disposal owner. A non-reactive scope (e.g. a component's setup
+ * run) registers an array here so effects/memos created during its
+ * execution push their disposer into it and are torn down when the scope
+ * ends. `undefined` at top level — no scope, no auto-disposal.
+ */
+let currentOwner: Array<() => void> | undefined;
+
+/**
+ * @internal Swap the ambient owner, returning the previous one so the
+ * caller can restore it. `component()` uses this to own the effects and
+ * memos a setup function creates, so they dispose at unmount instead of
+ * keeping their signal subscriptions alive forever.
+ */
+export function setOwner(
+	owner: Array<() => void> | undefined,
+): Array<() => void> | undefined {
+	const prev = currentOwner;
+	currentOwner = owner;
+	return prev;
+}
+
 /**
  * Create a writable signal seeded with `initial`. Reads register the
  * current observer; writes notify every observer that previously read.
@@ -178,7 +200,13 @@ export function effect(fn: EffectCallback): () => void {
 		},
 	};
 	eff.run();
-	return () => eff.dispose();
+	const dispose = () => eff.dispose();
+	// Register with the ambient owner (e.g. a component's setup scope) so the
+	// effect is torn down when that scope ends. `memo()` builds on this — its
+	// internal recompute effect inherits the same ownership, which is what
+	// stops a memo created in component setup from leaking after unmount.
+	currentOwner?.push(dispose);
+	return dispose;
 }
 
 /**

package/src/relay.ts

@@ -27,14 +27,12 @@ interface RelayState {
 	sse: EventSource | null;
 	uid: string | null;
 	channels: Map<string, Set<(event: unknown) => void>>;
-	pending: Array<() => void>;
 }
 
 const STATE: RelayState = {
 	sse: null,
 	uid: null,
 	channels: new Map(),
-	pending: [],
 };
 
 export interface RelayOptions {
@@ -87,15 +85,15 @@ const CLIENT: RelayClient = {
 		const adapted = handler as (event: unknown) => void;
 		handlers.add(adapted);
 
-		// Subscribe over POST as soon as we have a uid. If the SSE is
-		// still mid-handshake, queue the call and flush on `connected`.
-		const doSubscribe = () => {
+		// Subscribe over POST as soon as we have a uid. Before the first uid (or
+		// during an auto-reconnect) the channel already lives in STATE.channels
+		// and is (re-)subscribed by the `connected` handler — so the server,
+		// which assigns a fresh uid per connection, always learns every channel.
+		if (STATE.uid) {
 			postSubscribe(channel).catch((err: unknown) => {
 				console.warn(`[aurora/relay] subscribe to ${channel} failed:`, err);
 			});
-		};
-		if (STATE.uid) doSubscribe();
-		else STATE.pending.push(doSubscribe);
+		}
 
 		// Detacher — only removes the local listener. The server-side
 		// subscription stays open; closing it would interrupt other
@@ -112,7 +110,6 @@ const CLIENT: RelayClient = {
 		}
 		STATE.uid = null;
 		STATE.channels.clear();
-		STATE.pending.length = 0;
 	},
 };
 
@@ -124,8 +121,19 @@ function open(): void {
 		const data = safeJson<{ uid?: string }>((ev as MessageEvent).data);
 		if (data && typeof data.uid === "string") {
 			STATE.uid = data.uid;
-			const queue = STATE.pending.splice(0);
-			for (const fn of queue) fn();
+			// Re-apply EVERY active subscription on each (re)connect. The server
+			// assigns a fresh uid per connection and has no memory of prior
+			// subscriptions, so both the first connect AND browser auto-reconnects
+			// must re-POST every live channel — otherwise the client silently
+			// stops receiving after a reconnect.
+			for (const channel of STATE.channels.keys()) {
+				postSubscribe(channel).catch((err: unknown) => {
+					console.warn(
+						`[aurora/relay] re-subscribe to ${channel} failed:`,
+						err,
+					);
+				});
+			}
 		}
 	});
 

package/src/server/renderPage.ts

@@ -90,7 +90,7 @@ export async function renderPage<P>(
 <head>
 <meta charset="utf-8" />
 <meta name="viewport" content="width=device-width,initial-scale=1" />
-<script type="importmap">${JSON.stringify({ imports: importmap })}</script>
+<script type="importmap">${escapeJsonForScript({ imports: importmap })}</script>
 ${options.headExtra ?? ""}
 </head>
 <body>