@c9up/aurora 0.1.11 → 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/index.d.ts

@@ -9,14 +9,15 @@ export { html, isTemplateResult } from "./html.js";
 export type { HttpClientOptions, HttpRequestOptions, HttpResult, } from "./http.js";
 export { HttpClient, HttpError, http, isAbortError, isHttpError, } from "./http.js";
 export { hydrate } from "./hydrate.js";
+export { type LiveComponentDefinition, type LiveSession, mountLiveSession, type SlotPatch, } from "./live.js";
+export { connectPatches, type LiveStore, liveStore, type RelayBroadcaster, } from "./liveBroadcast.js";
+export { buildLiveTransport, type LiveClientOptions, type LiveClientTransport, type LiveHttpPoster, liveClient, type RelaySubscribeClient, } from "./liveClient.js";
+export { createLiveRegistry, type LiveRegistry, type LiveSessionHandle, } from "./liveRegistry.js";
+export { createLiveRouter, type LiveMount, type LiveRouter, } from "./liveRouter.js";
+export { DEFAULT_LIVE_EVENT_PATH, type LiveHttpContext, type LiveHttpRouter, type WireLiveEventsOptions, wireLiveEvents, } from "./liveServer.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 { createRpcClient, isRpcError, type RpcCall, type RpcClient, type RpcClientOptions, RpcError, type RpcResult, } from "./rpc.js";
 export { renderToString } from "./ssr.js";
-export { type LiveComponentDefinition, type LiveSession, mountLiveSession, type SlotPatch, } from "./live.js";
-export { createLiveRegistry, type LiveRegistry, type LiveSessionHandle, } from "./liveRegistry.js";
-export { connectPatches, type LiveStore, liveStore, type RelayBroadcaster, } from "./liveBroadcast.js";
-export { createLiveRouter, type LiveMount, type LiveRouter, } from "./liveRouter.js";
-export { buildLiveTransport, liveClient, type LiveClientOptions, type LiveClientTransport, type LiveHttpPoster, type RelaySubscribeClient, } from "./liveClient.js";
-export { DEFAULT_LIVE_EVENT_PATH, type LiveHttpContext, type LiveHttpRouter, wireLiveEvents, type WireLiveEventsOptions, } from "./liveServer.js";
 export type { TemplateResult } from "./types.js";

package/dist/index.js

@@ -5,13 +5,14 @@ export { form } from "./form.js";
 export { html, isTemplateResult } from "./html.js";
 export { HttpClient, HttpError, http, isAbortError, isHttpError, } from "./http.js";
 export { hydrate } from "./hydrate.js";
-export { batch, effect, isSignal, memo, onCleanup, signal, untrack, } from "./reactive.js";
-export { render } from "./render.js";
-export { auroraRoute, } from "./route.js";
-export { renderToString } from "./ssr.js";
 export { mountLiveSession, } from "./live.js";
-export { createLiveRegistry, } from "./liveRegistry.js";
 export { connectPatches, liveStore, } from "./liveBroadcast.js";
-export { createLiveRouter, } from "./liveRouter.js";
 export { buildLiveTransport, liveClient, } from "./liveClient.js";
+export { createLiveRegistry, } from "./liveRegistry.js";
+export { createLiveRouter, } from "./liveRouter.js";
 export { DEFAULT_LIVE_EVENT_PATH, wireLiveEvents, } from "./liveServer.js";
+export { batch, effect, isSignal, memo, onCleanup, signal, untrack, } from "./reactive.js";
+export { render } from "./render.js";
+export { auroraRoute, } from "./route.js";
+export { createRpcClient, isRpcError, RpcError, } from "./rpc.js";
+export { renderToString } from "./ssr.js";

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

@@ -0,0 +1,55 @@
+/**
+ * Browser JSON-RPC 2.0 client for Ream's RPC endpoint. `@c9up/ream`'s
+ * RpcProvider mounts `POST /rpc` and speaks JSON-RPC 2.0 (single + batch); this
+ * client builds on aurora's {@link HttpClient}, inheriting its base URL, auth
+ * headers, and timeouts.
+ *
+ *   const rpc = createRpcClient()                          // POST /rpc, same-origin
+ *   const result = await rpc.call('task.validate', { id }) // typed via call<T>()
+ *   const user = await rpc.call('user.find', { id }, isUser) // validated, cast-free
+ *
+ * Pairs with aurora's `command()` for reactive calls:
+ *   const validate = command((p) => rpc.call('task.validate', p))
+ */
+import { HttpClient } from "./http.js";
+export interface RpcClientOptions {
+    /** Endpoint path. Default `/rpc` (matches RpcProvider's default). */
+    url?: string;
+    /** Reuse an existing HttpClient — its baseURL / headers / auth carry over. */
+    http?: HttpClient;
+    /** Default headers — only used when no `http` client is supplied. */
+    headers?: Record<string, string>;
+}
+/** A JSON-RPC 2.0 error returned by the server (code + message + optional data). */
+export declare class RpcError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+/** Type guard for {@link RpcError}. */
+export declare function isRpcError(value: unknown): value is RpcError;
+/** One call in a batch. `parse` optionally validates that call's result (cast-free). */
+export interface RpcCall<T = unknown> {
+    method: string;
+    params?: unknown;
+    parse?: (data: unknown) => T;
+}
+/** A settled batch entry — the result, or the JSON-RPC error for that call. */
+export type RpcResult<T = unknown> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: RpcError;
+};
+export interface RpcClient {
+    /**
+     * Call one method. Returns the result, or throws {@link RpcError} on a
+     * JSON-RPC error. Pass `parse` to validate the result at runtime (and skip
+     * the unchecked `T` assertion).
+     */
+    call<T = unknown>(method: string, params?: unknown, parse?: (data: unknown) => T): Promise<T>;
+    /** Send a JSON-RPC batch. Returns one settled entry per call, in request order. */
+    batch(calls: RpcCall[]): Promise<RpcResult[]>;
+}
+export declare function createRpcClient(options?: RpcClientOptions): RpcClient;

package/dist/rpc.js

@@ -0,0 +1,97 @@
+/**
+ * Browser JSON-RPC 2.0 client for Ream's RPC endpoint. `@c9up/ream`'s
+ * RpcProvider mounts `POST /rpc` and speaks JSON-RPC 2.0 (single + batch); this
+ * client builds on aurora's {@link HttpClient}, inheriting its base URL, auth
+ * headers, and timeouts.
+ *
+ *   const rpc = createRpcClient()                          // POST /rpc, same-origin
+ *   const result = await rpc.call('task.validate', { id }) // typed via call<T>()
+ *   const user = await rpc.call('user.find', { id }, isUser) // validated, cast-free
+ *
+ * Pairs with aurora's `command()` for reactive calls:
+ *   const validate = command((p) => rpc.call('task.validate', p))
+ */
+import { HttpClient } from "./http.js";
+/** A JSON-RPC 2.0 error returned by the server (code + message + optional data). */
+export class RpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.name = "RpcError";
+        this.code = code;
+        this.data = data;
+    }
+}
+/** Type guard for {@link RpcError}. */
+export function isRpcError(value) {
+    return value instanceof RpcError;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+/** Turn a JSON-RPC `error` member into an {@link RpcError}. */
+function toRpcError(error) {
+    if (isObject(error) &&
+        typeof error.code === "number" &&
+        typeof error.message === "string") {
+        return new RpcError(error.code, error.message, error.data);
+    }
+    return new RpcError(-32603, "Malformed JSON-RPC error envelope", error);
+}
+export function createRpcClient(options = {}) {
+    const http = options.http ?? new HttpClient({ headers: options.headers });
+    const url = options.url ?? "/rpc";
+    let nextId = 0;
+    return {
+        async call(method, params, parse) {
+            const id = ++nextId;
+            const res = await http.post(url, {
+                jsonrpc: "2.0",
+                method,
+                params,
+                id,
+            });
+            if (!isObject(res)) {
+                throw new RpcError(-32603, `Malformed JSON-RPC response for "${method}"`);
+            }
+            if (res.error !== undefined)
+                throw toRpcError(res.error);
+            // Result boundary — the same unchecked `T` assertion HttpClient uses,
+            // with `parse` as the cast-free, runtime-validated escape hatch.
+            return parse ? parse(res.result) : res.result;
+        },
+        async batch(calls) {
+            if (calls.length === 0)
+                return [];
+            const requests = calls.map((c, index) => ({
+                jsonrpc: "2.0",
+                method: c.method,
+                params: c.params,
+                id: index, // index = request position; responses are matched back by id
+            }));
+            const res = await http.post(url, requests);
+            if (!Array.isArray(res)) {
+                throw new RpcError(-32603, "Malformed JSON-RPC batch response");
+            }
+            const byId = new Map();
+            for (const item of res)
+                if (isObject(item))
+                    byId.set(item.id, item);
+            return calls.map((c, index) => {
+                const envelope = byId.get(index);
+                if (!envelope) {
+                    return {
+                        ok: false,
+                        error: new RpcError(-32603, `No response for "${c.method}"`),
+                    };
+                }
+                if (envelope.error !== undefined) {
+                    return { ok: false, error: toRpcError(envelope.error) };
+                }
+                const value = c.parse ? c.parse(envelope.result) : envelope.result;
+                return { ok: true, value };
+            });
+        },
+    };
+}

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.11",
+  "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/index.ts

@@ -60,60 +60,69 @@ export {
 	isHttpError,
 } from "./http.js";
 export { hydrate } from "./hydrate.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 { renderToString } from "./ssr.js";
 export {
 	type LiveComponentDefinition,
 	type LiveSession,
 	mountLiveSession,
 	type SlotPatch,
 } from "./live.js";
-export {
-	createLiveRegistry,
-	type LiveRegistry,
-	type LiveSessionHandle,
-} from "./liveRegistry.js";
 export {
 	connectPatches,
 	type LiveStore,
 	liveStore,
 	type RelayBroadcaster,
 } from "./liveBroadcast.js";
-export {
-	createLiveRouter,
-	type LiveMount,
-	type LiveRouter,
-} from "./liveRouter.js";
 export {
 	buildLiveTransport,
-	liveClient,
 	type LiveClientOptions,
 	type LiveClientTransport,
 	type LiveHttpPoster,
+	liveClient,
 	type RelaySubscribeClient,
 } from "./liveClient.js";
+export {
+	createLiveRegistry,
+	type LiveRegistry,
+	type LiveSessionHandle,
+} from "./liveRegistry.js";
+export {
+	createLiveRouter,
+	type LiveMount,
+	type LiveRouter,
+} from "./liveRouter.js";
 export {
 	DEFAULT_LIVE_EVENT_PATH,
 	type LiveHttpContext,
 	type LiveHttpRouter,
-	wireLiveEvents,
 	type WireLiveEventsOptions,
+	wireLiveEvents,
 } from "./liveServer.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 {
+	createRpcClient,
+	isRpcError,
+	type RpcCall,
+	type RpcClient,
+	type RpcClientOptions,
+	RpcError,
+	type RpcResult,
+} from "./rpc.js";
+export { renderToString } from "./ssr.js";
 export type { TemplateResult } from "./types.js";

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

@@ -0,0 +1,145 @@
+/**
+ * Browser JSON-RPC 2.0 client for Ream's RPC endpoint. `@c9up/ream`'s
+ * RpcProvider mounts `POST /rpc` and speaks JSON-RPC 2.0 (single + batch); this
+ * client builds on aurora's {@link HttpClient}, inheriting its base URL, auth
+ * headers, and timeouts.
+ *
+ *   const rpc = createRpcClient()                          // POST /rpc, same-origin
+ *   const result = await rpc.call('task.validate', { id }) // typed via call<T>()
+ *   const user = await rpc.call('user.find', { id }, isUser) // validated, cast-free
+ *
+ * Pairs with aurora's `command()` for reactive calls:
+ *   const validate = command((p) => rpc.call('task.validate', p))
+ */
+import { HttpClient } from "./http.js";
+
+export interface RpcClientOptions {
+	/** Endpoint path. Default `/rpc` (matches RpcProvider's default). */
+	url?: string;
+	/** Reuse an existing HttpClient — its baseURL / headers / auth carry over. */
+	http?: HttpClient;
+	/** Default headers — only used when no `http` client is supplied. */
+	headers?: Record<string, string>;
+}
+
+/** A JSON-RPC 2.0 error returned by the server (code + message + optional data). */
+export class RpcError extends Error {
+	readonly code: number;
+	readonly data?: unknown;
+	constructor(code: number, message: string, data?: unknown) {
+		super(message);
+		this.name = "RpcError";
+		this.code = code;
+		this.data = data;
+	}
+}
+
+/** Type guard for {@link RpcError}. */
+export function isRpcError(value: unknown): value is RpcError {
+	return value instanceof RpcError;
+}
+
+/** One call in a batch. `parse` optionally validates that call's result (cast-free). */
+export interface RpcCall<T = unknown> {
+	method: string;
+	params?: unknown;
+	parse?: (data: unknown) => T;
+}
+
+/** A settled batch entry — the result, or the JSON-RPC error for that call. */
+export type RpcResult<T = unknown> =
+	| { ok: true; value: T }
+	| { ok: false; error: RpcError };
+
+export interface RpcClient {
+	/**
+	 * Call one method. Returns the result, or throws {@link RpcError} on a
+	 * JSON-RPC error. Pass `parse` to validate the result at runtime (and skip
+	 * the unchecked `T` assertion).
+	 */
+	call<T = unknown>(
+		method: string,
+		params?: unknown,
+		parse?: (data: unknown) => T,
+	): Promise<T>;
+	/** Send a JSON-RPC batch. Returns one settled entry per call, in request order. */
+	batch(calls: RpcCall[]): Promise<RpcResult[]>;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+/** Turn a JSON-RPC `error` member into an {@link RpcError}. */
+function toRpcError(error: unknown): RpcError {
+	if (
+		isObject(error) &&
+		typeof error.code === "number" &&
+		typeof error.message === "string"
+	) {
+		return new RpcError(error.code, error.message, error.data);
+	}
+	return new RpcError(-32603, "Malformed JSON-RPC error envelope", error);
+}
+
+export function createRpcClient(options: RpcClientOptions = {}): RpcClient {
+	const http = options.http ?? new HttpClient({ headers: options.headers });
+	const url = options.url ?? "/rpc";
+	let nextId = 0;
+
+	return {
+		async call<T>(
+			method: string,
+			params?: unknown,
+			parse?: (data: unknown) => T,
+		): Promise<T> {
+			const id = ++nextId;
+			const res = await http.post<unknown>(url, {
+				jsonrpc: "2.0",
+				method,
+				params,
+				id,
+			});
+			if (!isObject(res)) {
+				throw new RpcError(
+					-32603,
+					`Malformed JSON-RPC response for "${method}"`,
+				);
+			}
+			if (res.error !== undefined) throw toRpcError(res.error);
+			// Result boundary — the same unchecked `T` assertion HttpClient uses,
+			// with `parse` as the cast-free, runtime-validated escape hatch.
+			return parse ? parse(res.result) : (res.result as T);
+		},
+
+		async batch(calls: RpcCall[]): Promise<RpcResult[]> {
+			if (calls.length === 0) return [];
+			const requests = calls.map((c, index) => ({
+				jsonrpc: "2.0",
+				method: c.method,
+				params: c.params,
+				id: index, // index = request position; responses are matched back by id
+			}));
+			const res = await http.post<unknown>(url, requests);
+			if (!Array.isArray(res)) {
+				throw new RpcError(-32603, "Malformed JSON-RPC batch response");
+			}
+			const byId = new Map<unknown, Record<string, unknown>>();
+			for (const item of res) if (isObject(item)) byId.set(item.id, item);
+			return calls.map((c, index) => {
+				const envelope = byId.get(index);
+				if (!envelope) {
+					return {
+						ok: false,
+						error: new RpcError(-32603, `No response for "${c.method}"`),
+					};
+				}
+				if (envelope.error !== undefined) {
+					return { ok: false, error: toRpcError(envelope.error) };
+				}
+				const value = c.parse ? c.parse(envelope.result) : envelope.result;
+				return { ok: true, value };
+			});
+		},
+	};
+}

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 {