@c9up/aurora 0.1.12 → 0.1.13

package/dist/command.js

@@ -61,19 +61,35 @@ class CommandRunner {
         this.#loading(true);
         this.#error(null);
         try {
-            const result = await this.#task(...args);
+            let result;
+            try {
+                result = await this.#task(...args);
+            }
+            catch (error) {
+                if (id !== this.#runId)
+                    return; // superseded — drop
+                this.#error(error);
+                for (const handler of this.#onFail)
+                    handler(error);
+                return;
+            }
             if (id !== this.#runId)
                 return; // superseded by a newer run — drop
             this.#data(result);
-            for (const handler of this.#onSuccess)
-                handler(result);
-        }
-        catch (error) {
-            if (id !== this.#runId)
-                return; // superseded — drop
-            this.#error(error);
-            for (const handler of this.#onFail)
-                handler(error);
+            // onSuccess runs OUTSIDE the task's failure boundary: success is
+            // decided by the task, never by the callback. A throw here (e.g. a
+            // render error after the data lands) is a handler bug — surfacing it
+            // as a task failure would route to onFail, which on a guarded page
+            // masquerades as a logout. Report it, but never reclassify it.
+            try {
+                for (const handler of this.#onSuccess)
+                    handler(result);
+            }
+            catch (handlerError) {
+                if (typeof console !== "undefined") {
+                    console.error("[aurora] a command onSuccess handler threw — not treated as a task failure:", handlerError);
+                }
+            }
         }
         finally {
             if (id === this.#runId) {

package/dist/hydrate.js

@@ -231,12 +231,49 @@ function hydrateTemplateResult(result, liveNodes, cleanups, mountHooks, markerCu
  * Text-slot paths point to a comment marker that doesn't exist in
  * hydration markup — we tolerate the miss and return null.
  */
+/**
+ * Collapse each top-level `<!--$-->…<!--/$-->` range in `nodes` to a SINGLE
+ * entry (its start marker), dropping the in-range content + end marker from the
+ * count. SSR expands a structured slot (reactive OR a direct nested template)
+ * to a node RANGE, but the parsed client template counts every slot as exactly
+ * ONE comment node — so without this collapse the extra range nodes shift the
+ * childNode index of every FOLLOWING sibling slot (dead bindings / "slot path
+ * not found"). Nested ranges (depth > 0) are skipped wholesale: they belong to
+ * the outer slot's content and are hydrated when we recurse into it.
+ */
+function collapseMarkerRanges(nodes) {
+    const out = [];
+    let depth = 0;
+    for (const n of nodes) {
+        if (n.nodeType === 8 /* Comment */) {
+            const data = n.data;
+            if (data === SLOT_START) {
+                if (depth === 0)
+                    out.push(n); // the whole range counts as one node
+                depth += 1;
+                continue;
+            }
+            if (data === SLOT_END) {
+                if (depth > 0)
+                    depth -= 1;
+                continue;
+            }
+        }
+        if (depth === 0)
+            out.push(n);
+    }
+    return out;
+}
 function resolvePathLive(_root, path, rootNodes) {
     if (path.length === 0)
         return null;
-    let node = rootNodes[path[0]] ?? null;
+    // Collapse marker ranges at EVERY level so the live child list matches the
+    // parsed template's one-node-per-slot shape (see collapseMarkerRanges).
+    let children = collapseMarkerRanges(rootNodes);
+    let node = children[path[0]] ?? null;
     for (let i = 1; node && i < path.length; i++) {
-        node = node.childNodes[path[i]] ?? null;
+        children = collapseMarkerRanges(Array.from(node.childNodes));
+        node = children[path[i]] ?? null;
     }
     return node;
 }
@@ -332,6 +369,23 @@ function hydrateTextSlot(commentMarker, value, cleanups, mountHooks, markerCurso
         return;
     }
     if (isTemplateResult(value)) {
+        // DIRECT nested template (component composition, `${Layout({…})}`). SSR
+        // wrapped it in a boundary-marker pair (same scheme as a reactive
+        // structured slot). Consume the pair in document order and hydrate the
+        // nested template against its captured range — wiring inner bindings to
+        // the SSR nodes and keeping the marker cursor aligned.
+        const pair = markerCursor.pairs[markerCursor.i];
+        if (pair !== undefined) {
+            markerCursor.i += 1;
+            const range = [];
+            for (let n = pair.start.nextSibling; n !== null && n !== pair.end; n = n.nextSibling) {
+                range.push(n);
+            }
+            hydrateTemplateResult(value, range, cleanups, mountHooks, markerCursor);
+            return;
+        }
+        // Legacy markup without markers (older SSR build): best-effort against
+        // the single resolved node.
         hydrateTemplateResult(value, [commentMarker], cleanups, mountHooks, markerCursor);
         return;
     }

package/dist/render.js

@@ -71,6 +71,15 @@ export function mount(result, cleanups, mounted, mountHooks) {
     for (let i = 0; i < tpl.slots.length; i++) {
         const slot = tpl.slots[i];
         const node = resolvePath(fragment, slot.path);
+        if (node === null) {
+            // Path didn't resolve — skip this binding rather than crash (see
+            // resolvePath). Degrades to a dead binding; the surrounding render
+            // (and any command driving it) survives.
+            if (typeof console !== "undefined") {
+                console.warn(`[aurora] render: slot ${i} (${slot.kind}) path ${slot.path.join(".")} did not resolve — skipping binding`);
+            }
+            continue;
+        }
         if (slot.kind === "attr" && slot.staticParts !== undefined) {
             collectMultiAttr(slot, node, result.values[i], multiGroups);
         }
@@ -88,8 +97,19 @@ export function mount(result, cleanups, mounted, mountHooks) {
 }
 function resolvePath(root, path) {
     let node = root;
-    for (const i of path)
-        node = node.childNodes[i];
+    for (const i of path) {
+        const next = node.childNodes[i];
+        // Fail-soft: a path step that runs off the live child list means the
+        // tree diverged from the parsed template (a hydration desync). Return
+        // null so the caller skips the binding instead of dereferencing
+        // `undefined.childNodes` and crashing the whole render — which, when the
+        // render runs inside a command's onSuccess, used to masquerade as a
+        // task failure (and on a guarded page, a logout). Mirrors
+        // `resolvePathLive` in hydrate.ts.
+        if (next === undefined)
+            return null;
+        node = next;
+    }
     return node;
 }
 function applySlot(slot, node, value, cleanups, mounted, mountHooks) {

package/dist/ssr.js

@@ -75,6 +75,19 @@ function stringifyTemplateResult(result) {
                 out += stringifyValue(value, false);
                 out += `<!--${SLOT_END}-->`;
             }
+            else if (!inAttr && isTemplateResult(value)) {
+                // DIRECT (non-reactive) nested template — component composition,
+                // e.g. `${Layout({ children })}` or `${table}`. It renders to a
+                // node RANGE just like a reactive structured slot, so it needs the
+                // SAME boundary markers: the client template counts every slot as
+                // ONE comment node, so without a markable range a multi-node child
+                // shifts the childNode indices of every FOLLOWING sibling slot →
+                // dead bindings / "slot path not found". Hydration collapses the
+                // marked range back to one node so sibling paths stay aligned.
+                out += `<!--${SLOT_START}-->`;
+                out += stringifyValue(value, false);
+                out += `<!--${SLOT_END}-->`;
+            }
             else if (inAttr) {
                 out += stringifyValue(value, true);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c9up/aurora",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "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/command.ts

@@ -91,14 +91,32 @@ class CommandRunner<TArgs extends unknown[], TData>
 		this.#loading(true);
 		this.#error(null);
 		try {
-			const result = await this.#task(...args);
+			let result: TData;
+			try {
+				result = await this.#task(...args);
+			} catch (error) {
+				if (id !== this.#runId) return; // superseded — drop
+				this.#error(error);
+				for (const handler of this.#onFail) handler(error);
+				return;
+			}
 			if (id !== this.#runId) return; // superseded by a newer run — drop
 			this.#data(result);
-			for (const handler of this.#onSuccess) handler(result);
-		} catch (error) {
-			if (id !== this.#runId) return; // superseded — drop
-			this.#error(error);
-			for (const handler of this.#onFail) handler(error);
+			// onSuccess runs OUTSIDE the task's failure boundary: success is
+			// decided by the task, never by the callback. A throw here (e.g. a
+			// render error after the data lands) is a handler bug — surfacing it
+			// as a task failure would route to onFail, which on a guarded page
+			// masquerades as a logout. Report it, but never reclassify it.
+			try {
+				for (const handler of this.#onSuccess) handler(result);
+			} catch (handlerError) {
+				if (typeof console !== "undefined") {
+					console.error(
+						"[aurora] a command onSuccess handler threw — not treated as a task failure:",
+						handlerError,
+					);
+				}
+			}
 		} finally {
 			if (id === this.#runId) {
 				this.#loading(false);

package/src/hydrate.ts

@@ -320,15 +320,50 @@ function hydrateTemplateResult(
  * Text-slot paths point to a comment marker that doesn't exist in
  * hydration markup — we tolerate the miss and return null.
  */
+/**
+ * Collapse each top-level `<!--$-->…<!--/$-->` range in `nodes` to a SINGLE
+ * entry (its start marker), dropping the in-range content + end marker from the
+ * count. SSR expands a structured slot (reactive OR a direct nested template)
+ * to a node RANGE, but the parsed client template counts every slot as exactly
+ * ONE comment node — so without this collapse the extra range nodes shift the
+ * childNode index of every FOLLOWING sibling slot (dead bindings / "slot path
+ * not found"). Nested ranges (depth > 0) are skipped wholesale: they belong to
+ * the outer slot's content and are hydrated when we recurse into it.
+ */
+function collapseMarkerRanges(nodes: ChildNode[]): ChildNode[] {
+	const out: ChildNode[] = [];
+	let depth = 0;
+	for (const n of nodes) {
+		if (n.nodeType === 8 /* Comment */) {
+			const data = (n as Comment).data;
+			if (data === SLOT_START) {
+				if (depth === 0) out.push(n); // the whole range counts as one node
+				depth += 1;
+				continue;
+			}
+			if (data === SLOT_END) {
+				if (depth > 0) depth -= 1;
+				continue;
+			}
+		}
+		if (depth === 0) out.push(n);
+	}
+	return out;
+}
+
 function resolvePathLive(
 	_root: ParentNode,
 	path: NodePath,
 	rootNodes: ChildNode[],
 ): Node | null {
 	if (path.length === 0) return null;
-	let node: Node | null = rootNodes[path[0]] ?? null;
+	// Collapse marker ranges at EVERY level so the live child list matches the
+	// parsed template's one-node-per-slot shape (see collapseMarkerRanges).
+	let children = collapseMarkerRanges(rootNodes);
+	let node: Node | null = children[path[0]] ?? null;
 	for (let i = 1; node && i < path.length; i++) {
-		node = node.childNodes[path[i]] ?? null;
+		children = collapseMarkerRanges(Array.from(node.childNodes));
+		node = children[path[i]] ?? null;
 	}
 	return node;
 }
@@ -451,6 +486,27 @@ function hydrateTextSlot(
 		return;
 	}
 	if (isTemplateResult(value)) {
+		// DIRECT nested template (component composition, `${Layout({…})}`). SSR
+		// wrapped it in a boundary-marker pair (same scheme as a reactive
+		// structured slot). Consume the pair in document order and hydrate the
+		// nested template against its captured range — wiring inner bindings to
+		// the SSR nodes and keeping the marker cursor aligned.
+		const pair = markerCursor.pairs[markerCursor.i];
+		if (pair !== undefined) {
+			markerCursor.i += 1;
+			const range: ChildNode[] = [];
+			for (
+				let n = pair.start.nextSibling;
+				n !== null && n !== pair.end;
+				n = n.nextSibling
+			) {
+				range.push(n as ChildNode);
+			}
+			hydrateTemplateResult(value, range, cleanups, mountHooks, markerCursor);
+			return;
+		}
+		// Legacy markup without markers (older SSR build): best-effort against
+		// the single resolved node.
 		hydrateTemplateResult(
 			value,
 			[commentMarker as ChildNode],

package/src/render.ts

@@ -107,6 +107,17 @@ export function mount(
 	for (let i = 0; i < tpl.slots.length; i++) {
 		const slot = tpl.slots[i];
 		const node = resolvePath(fragment, slot.path);
+		if (node === null) {
+			// Path didn't resolve — skip this binding rather than crash (see
+			// resolvePath). Degrades to a dead binding; the surrounding render
+			// (and any command driving it) survives.
+			if (typeof console !== "undefined") {
+				console.warn(
+					`[aurora] render: slot ${i} (${slot.kind}) path ${slot.path.join(".")} did not resolve — skipping binding`,
+				);
+			}
+			continue;
+		}
 		if (slot.kind === "attr" && slot.staticParts !== undefined) {
 			collectMultiAttr(slot, node as Element, result.values[i], multiGroups);
 		} else {
@@ -124,9 +135,20 @@ export function mount(
 	return fragment;
 }
 
-function resolvePath(root: ParentNode, path: NodePath): Node {
+function resolvePath(root: ParentNode, path: NodePath): Node | null {
 	let node: Node = root;
-	for (const i of path) node = node.childNodes[i];
+	for (const i of path) {
+		const next = node.childNodes[i];
+		// Fail-soft: a path step that runs off the live child list means the
+		// tree diverged from the parsed template (a hydration desync). Return
+		// null so the caller skips the binding instead of dereferencing
+		// `undefined.childNodes` and crashing the whole render — which, when the
+		// render runs inside a command's onSuccess, used to masquerade as a
+		// task failure (and on a guarded page, a logout). Mirrors
+		// `resolvePathLive` in hydrate.ts.
+		if (next === undefined) return null;
+		node = next;
+	}
 	return node;
 }
 

package/src/ssr.ts

@@ -78,6 +78,18 @@ function stringifyTemplateResult(result: TemplateResult): string {
 				out += `<!--${SLOT_START}-->`;
 				out += stringifyValue(value, false);
 				out += `<!--${SLOT_END}-->`;
+			} else if (!inAttr && isTemplateResult(value)) {
+				// DIRECT (non-reactive) nested template — component composition,
+				// e.g. `${Layout({ children })}` or `${table}`. It renders to a
+				// node RANGE just like a reactive structured slot, so it needs the
+				// SAME boundary markers: the client template counts every slot as
+				// ONE comment node, so without a markable range a multi-node child
+				// shifts the childNode indices of every FOLLOWING sibling slot →
+				// dead bindings / "slot path not found". Hydration collapses the
+				// marked range back to one node so sibling paths stay aligned.
+				out += `<!--${SLOT_START}-->`;
+				out += stringifyValue(value, false);
+				out += `<!--${SLOT_END}-->`;
 			} else if (inAttr) {
 				out += stringifyValue(value, true);
 			} else {