@c9up/aurora 0.1.4 → 0.1.6

package/dist/browser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Browser DX helpers — navigation + a typed `localStorage` wrapper.
+ *
+ * All are SSR-safe: on the server (no `window` / `localStorage`) navigation is
+ * a no-op and storage reads return `null`, so the same code runs during SSR
+ * without `typeof window` guards at every call site. Node-free — part of the
+ * client barrel.
+ */
+/** Navigate to `url` with a full page load. No-op during SSR. */
+export declare function redirect(url: string): void;
+/**
+ * Navigate to `url`, replacing the current history entry (no back-button trap —
+ * use after a login/logout so "back" doesn't return to the form). No-op on SSR.
+ */
+export declare function replace(url: string): void;
+/** Reload the current page. No-op during SSR. */
+export declare function reload(): void;
+/**
+ * Typed, SSR-safe `localStorage` wrapper. Values are JSON-serialised; reads
+ * return `null` on the server, on a missing key, or on malformed JSON. Writes
+ * swallow quota / private-mode errors so a full storage never crashes the app.
+ */
+export declare const storage: {
+    get<T>(key: string): T | null;
+    set(key: string, value: unknown): void;
+    remove(key: string): void;
+    clear(): void;
+};

package/dist/browser.js

@@ -0,0 +1,69 @@
+/**
+ * Browser DX helpers — navigation + a typed `localStorage` wrapper.
+ *
+ * All are SSR-safe: on the server (no `window` / `localStorage`) navigation is
+ * a no-op and storage reads return `null`, so the same code runs during SSR
+ * without `typeof window` guards at every call site. Node-free — part of the
+ * client barrel.
+ */
+/** Navigate to `url` with a full page load. No-op during SSR. */
+export function redirect(url) {
+    if (typeof window !== "undefined") {
+        window.location.href = url;
+    }
+}
+/**
+ * Navigate to `url`, replacing the current history entry (no back-button trap —
+ * use after a login/logout so "back" doesn't return to the form). No-op on SSR.
+ */
+export function replace(url) {
+    if (typeof window !== "undefined") {
+        window.location.replace(url);
+    }
+}
+/** Reload the current page. No-op during SSR. */
+export function reload() {
+    if (typeof window !== "undefined") {
+        window.location.reload();
+    }
+}
+/**
+ * Typed, SSR-safe `localStorage` wrapper. Values are JSON-serialised; reads
+ * return `null` on the server, on a missing key, or on malformed JSON. Writes
+ * swallow quota / private-mode errors so a full storage never crashes the app.
+ */
+export const storage = {
+    get(key) {
+        if (typeof localStorage === "undefined")
+            return null;
+        const raw = localStorage.getItem(key);
+        if (raw === null)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    },
+    set(key, value) {
+        if (typeof localStorage === "undefined")
+            return;
+        try {
+            localStorage.setItem(key, JSON.stringify(value));
+        }
+        catch {
+            // QuotaExceededError / Safari private mode — best-effort write.
+        }
+    },
+    remove(key) {
+        if (typeof localStorage !== "undefined") {
+            localStorage.removeItem(key);
+        }
+    },
+    clear() {
+        if (typeof localStorage !== "undefined") {
+            localStorage.clear();
+        }
+    },
+};

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/hydrate.js

@@ -307,11 +307,21 @@ function hydrateTextSlot(commentMarker, value, cleanups, mountHooks, markerCurso
             }
             return;
         }
-        const textNode = commentMarker.nodeType === 3 /* TEXT */
+        let textNode = commentMarker.nodeType === 3 /* TEXT */
             ? commentMarker
             : commentMarker.previousSibling?.nodeType === 3
                 ? commentMarker.previousSibling
                 : null;
+        if (!textNode &&
+            commentMarker.nodeType === 8 /* Comment */ &&
+            commentMarker.parentNode) {
+            // Empty SSR text slot: a `<!---->` placeholder holds the position
+            // (see ssr.ts). Materialize the reactive text node there — node
+            // count stays 1, so sibling slot paths remain aligned.
+            const fresh = (commentMarker.ownerDocument ?? document).createTextNode("");
+            commentMarker.parentNode.replaceChild(fresh, commentMarker);
+            textNode = fresh;
+        }
         if (!textNode)
             return;
         const dispose = effect(() => {

package/dist/index.d.ts

@@ -1,12 +1,9 @@
-export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
+export { redirect, reload, replace, storage } from "./browser.js";
 export { component, onMount, onUnmount } from "./component.js";
 export { html, isTemplateResult } from "./html.js";
 export { hydrate } from "./hydrate.js";
-export { type PageFactory, Pages, type PagesConfig, } from "./Pages.js";
 export { batch, effect, isSignal, memo, onCleanup, type ReadSignal, type Signal, signal, untrack, } from "./reactive.js";
 export { type Disposer, render } from "./render.js";
 export { type AuroraHttpContext, type AuroraResponse, type AuroraRouteConfig, auroraRoute, } from "./route.js";
-export { type RenderHttpContext, type RenderPageOptions, type RenderResponse, renderPage, } from "./server/renderPage.js";
-export { type AssetsHttpContext, type AssetsRequest, type AssetsResponse, type ServeAssetsOptions, serveAssets, } from "./server/serveAssets.js";
 export { renderToString } from "./ssr.js";
 export type { TemplateResult } from "./types.js";

package/dist/index.js

@@ -1,12 +1,14 @@
-// ─── Inertia-shape server surface ─────────────────────────────────
-export { AuroraManager } from "./AuroraManager.js";
+// ─── Client surface (node-free — safe to bundle for the browser) ──────
+//
+// Server-only exports (AuroraManager, Pages, renderPage, serveAssets) that pull
+// node:fs / node:path / node:url live in `@c9up/aurora/server`. Keeping them off
+// this barrel is what lets a browser bundle import the client primitives without
+// the bundler dragging Node built-ins through the import graph.
+export { redirect, reload, replace, storage } from "./browser.js";
 export { component, onMount, onUnmount } from "./component.js";
 export { html, isTemplateResult } from "./html.js";
 export { hydrate } from "./hydrate.js";
-export { Pages, } from "./Pages.js";
 export { batch, effect, isSignal, memo, onCleanup, signal, untrack, } from "./reactive.js";
 export { render } from "./render.js";
 export { auroraRoute, } from "./route.js";
-export { renderPage, } from "./server/renderPage.js";
-export { serveAssets, } from "./server/serveAssets.js";
 export { renderToString } from "./ssr.js";

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/dist/server.d.ts

@@ -0,0 +1,4 @@
+export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
+export { type PageFactory, Pages, type PagesConfig } from "./Pages.js";
+export { type RenderHttpContext, type RenderPageOptions, type RenderResponse, renderPage, } from "./server/renderPage.js";
+export { type AssetsHttpContext, type AssetsRequest, type AssetsResponse, type ServeAssetsOptions, serveAssets, } from "./server/serveAssets.js";

package/dist/server.js

@@ -0,0 +1,10 @@
+// ─── Server-only surface (imports node:fs / node:path / node:url) ─────
+//
+// Kept OUT of the package's main barrel (`@c9up/aurora`) so a browser bundle
+// importing client primitives (component/html/hydrate/render) never pulls the
+// Node built-ins through the import graph. Server code imports from
+// `@c9up/aurora/server`; the client `.` entry stays node-free.
+export { AuroraManager } from "./AuroraManager.js";
+export { Pages } from "./Pages.js";
+export { renderPage, } from "./server/renderPage.js";
+export { serveAssets, } from "./server/serveAssets.js";

package/dist/ssr.js

@@ -75,8 +75,18 @@ function stringifyTemplateResult(result) {
                 out += stringifyValue(value, false);
                 out += `<!--${SLOT_END}-->`;
             }
+            else if (inAttr) {
+                out += stringifyValue(value, true);
+            }
             else {
-                out += stringifyValue(value, inAttr);
+                // Text-region scalar slot. An empty result (e.g. `cond ? x : ''`)
+                // would emit NO node and desync the path-based hydration of the
+                // following sibling slots (their @input/@submit bindings break).
+                // Emit an empty-comment placeholder so the position is preserved
+                // — lit-html / Solid do the same; hydration materializes the text
+                // node there.
+                const text = stringifyValue(value, false);
+                out += text === "" ? "<!---->" : text;
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c9up/aurora",
-  "version": "0.1.4",
+  "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",
@@ -30,6 +30,10 @@
     "./hydrate": {
       "types": "./dist/hydrate.d.ts",
       "import": "./dist/hydrate.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
     }
   },
   "peerDependencies": {

package/src/browser.ts

@@ -0,0 +1,68 @@
+/**
+ * Browser DX helpers — navigation + a typed `localStorage` wrapper.
+ *
+ * All are SSR-safe: on the server (no `window` / `localStorage`) navigation is
+ * a no-op and storage reads return `null`, so the same code runs during SSR
+ * without `typeof window` guards at every call site. Node-free — part of the
+ * client barrel.
+ */
+
+/** Navigate to `url` with a full page load. No-op during SSR. */
+export function redirect(url: string): void {
+	if (typeof window !== "undefined") {
+		window.location.href = url;
+	}
+}
+
+/**
+ * Navigate to `url`, replacing the current history entry (no back-button trap —
+ * use after a login/logout so "back" doesn't return to the form). No-op on SSR.
+ */
+export function replace(url: string): void {
+	if (typeof window !== "undefined") {
+		window.location.replace(url);
+	}
+}
+
+/** Reload the current page. No-op during SSR. */
+export function reload(): void {
+	if (typeof window !== "undefined") {
+		window.location.reload();
+	}
+}
+
+/**
+ * Typed, SSR-safe `localStorage` wrapper. Values are JSON-serialised; reads
+ * return `null` on the server, on a missing key, or on malformed JSON. Writes
+ * swallow quota / private-mode errors so a full storage never crashes the app.
+ */
+export const storage = {
+	get<T>(key: string): T | null {
+		if (typeof localStorage === "undefined") return null;
+		const raw = localStorage.getItem(key);
+		if (raw === null) return null;
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	},
+	set(key: string, value: unknown): void {
+		if (typeof localStorage === "undefined") return;
+		try {
+			localStorage.setItem(key, JSON.stringify(value));
+		} catch {
+			// QuotaExceededError / Safari private mode — best-effort write.
+		}
+	},
+	remove(key: string): void {
+		if (typeof localStorage !== "undefined") {
+			localStorage.removeItem(key);
+		}
+	},
+	clear(): void {
+		if (typeof localStorage !== "undefined") {
+			localStorage.clear();
+		}
+	},
+};

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/hydrate.ts

@@ -422,12 +422,26 @@ function hydrateTextSlot(
 			}
 			return;
 		}
-		const textNode =
+		let textNode =
 			commentMarker.nodeType === 3 /* TEXT */
 				? (commentMarker as Text)
 				: commentMarker.previousSibling?.nodeType === 3
 					? (commentMarker.previousSibling as Text)
 					: null;
+		if (
+			!textNode &&
+			commentMarker.nodeType === 8 /* Comment */ &&
+			commentMarker.parentNode
+		) {
+			// Empty SSR text slot: a `<!---->` placeholder holds the position
+			// (see ssr.ts). Materialize the reactive text node there — node
+			// count stays 1, so sibling slot paths remain aligned.
+			const fresh = (commentMarker.ownerDocument ?? document).createTextNode(
+				"",
+			);
+			commentMarker.parentNode.replaceChild(fresh, commentMarker);
+			textNode = fresh;
+		}
 		if (!textNode) return;
 		const dispose = effect(() => {
 			const v = fn();

package/src/index.ts

@@ -1,13 +1,13 @@
-// ─── Inertia-shape server surface ─────────────────────────────────
-export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
+// ─── Client surface (node-free — safe to bundle for the browser) ──────
+//
+// Server-only exports (AuroraManager, Pages, renderPage, serveAssets) that pull
+// node:fs / node:path / node:url live in `@c9up/aurora/server`. Keeping them off
+// this barrel is what lets a browser bundle import the client primitives without
+// the bundler dragging Node built-ins through the import graph.
+export { redirect, reload, replace, storage } from "./browser.js";
 export { component, onMount, onUnmount } from "./component.js";
 export { html, isTemplateResult } from "./html.js";
 export { hydrate } from "./hydrate.js";
-export {
-	type PageFactory,
-	Pages,
-	type PagesConfig,
-} from "./Pages.js";
 export {
 	batch,
 	effect,
@@ -26,18 +26,5 @@ export {
 	type AuroraRouteConfig,
 	auroraRoute,
 } from "./route.js";
-export {
-	type RenderHttpContext,
-	type RenderPageOptions,
-	type RenderResponse,
-	renderPage,
-} from "./server/renderPage.js";
-export {
-	type AssetsHttpContext,
-	type AssetsRequest,
-	type AssetsResponse,
-	type ServeAssetsOptions,
-	serveAssets,
-} from "./server/serveAssets.js";
 export { renderToString } from "./ssr.js";
 export type { TemplateResult } from "./types.js";

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>

package/src/server.ts

@@ -0,0 +1,22 @@
+// ─── Server-only surface (imports node:fs / node:path / node:url) ─────
+//
+// Kept OUT of the package's main barrel (`@c9up/aurora`) so a browser bundle
+// importing client primitives (component/html/hydrate/render) never pulls the
+// Node built-ins through the import graph. Server code imports from
+// `@c9up/aurora/server`; the client `.` entry stays node-free.
+
+export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
+export { type PageFactory, Pages, type PagesConfig } from "./Pages.js";
+export {
+	type RenderHttpContext,
+	type RenderPageOptions,
+	type RenderResponse,
+	renderPage,
+} from "./server/renderPage.js";
+export {
+	type AssetsHttpContext,
+	type AssetsRequest,
+	type AssetsResponse,
+	type ServeAssetsOptions,
+	serveAssets,
+} from "./server/serveAssets.js";

package/src/ssr.ts

@@ -78,8 +78,17 @@ function stringifyTemplateResult(result: TemplateResult): string {
 				out += `<!--${SLOT_START}-->`;
 				out += stringifyValue(value, false);
 				out += `<!--${SLOT_END}-->`;
+			} else if (inAttr) {
+				out += stringifyValue(value, true);
 			} else {
-				out += stringifyValue(value, inAttr);
+				// Text-region scalar slot. An empty result (e.g. `cond ? x : ''`)
+				// would emit NO node and desync the path-based hydration of the
+				// following sibling slots (their @input/@submit bindings break).
+				// Emit an empty-comment placeholder so the position is preserved
+				// — lit-html / Solid do the same; hydration materializes the text
+				// node there.
+				const text = stringifyValue(value, false);
+				out += text === "" ? "<!---->" : text;
 			}
 		}
 	}