@farm.js/islx 0.0.1 → 0.0.3

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.0.3
+
+Server layouts as trees.
+
+- A server layout around a client provider renders as a server tree, so a framework no longer
+  ships the layout's module to hydrate it. On the server, `renderServerTree(layout, { outlets,
+  scope })` with `<Outlet />` where the page goes; in the browser, `createServerTreeLayout(source,
+  scope, { load, ServerHtml, onUpdate })` and `layout.render({ children: page })`. Rendering it
+  again with another page keeps the provider's state.
+- A layout's tree names its payload, chunks and server HTML by its scope (`f/chunk name="/:0"`),
+  so it and the page's tree at its outlet never read each other's parts. New tag `L` (outlet).
+
+## 0.0.2
+
+Streaming and hydration fixes.
+
+- Islands inside Suspense content that streams in after the browser entry has run now hydrate.
+  While the document streams, the runtime watches it: an island hydrates once React moves it out
+  of its hidden staging `<div>`, an island React removes (a replaced fallback) is released, and
+  watching stops once the document is parsed and every staged boundary is revealed. React 19.2
+  can reveal boundaries after parsing ends.
+- Islands that share a value decode it once and share the result. Props and values without tags
+  skip decoding, and decoded objects are built with plain assignment (`__proto__` stays data).
+
 ## 0.0.1
 
 The first release: the islx wire format, server actions, React islands, and the Vite plugin.

package/README.md

@@ -13,7 +13,7 @@ islx started as [Farm.js](https://github.com/farming-labs/farm.js)'s islands mod
 replaces React Server Components' Flight payload. On a 300-page docs app it ships 26% less
 JavaScript, and a client navigation sends 2.5 KB instead of 12 KB.
 
-> Status: 0.0.1, the first release. React and Vite are supported; other renderers and framework
+> Status: 0.0.3. React and Vite are supported; other renderers and framework
 > integrations follow. The wire format is in [SPEC.md](./SPEC.md), changes in
 > [CHANGELOG.md](./CHANGELOG.md).
 
@@ -180,6 +180,7 @@ A framework that renders pages itself (Farm does) uses the pieces directly inste
 | Render islands in its own render | wrap the page in `<IslandsProvider held={parseHeldValues(request)}>` |
 | A layout that hydrates as one root | `withinClientRoot(layout)`; its server-HTML page: `isolateIslands(page)` |
 | An async page under such a layout | `renderServerTree(page, { held, payloadOnly })` on the server; `createServerTreeElement(source, { load, ServerHtml })` in the browser |
+| A server layout around a client provider, without shipping the layout | `renderServerTree(<Layout><Outlet /></Layout>, { outlets: { children: page }, scope })` on the server; `createServerTreeLayout(source, scope, { load, ServerHtml, onUpdate })` in the browser, then `layout.render({ children: page })` |
 | Hydrate | `createHydrationRuntime({ load, schedule?, wrap?, report? })`, `createServerHtml(runtime)` |
 | Hold early clicks | inline `PREHYDRATION_SCRIPT` in the page |
 | Actions | `handleAction(request, { allowedOrigins, bodySizeLimit, run, mapError, renderFormState })`; `setActionNavigator({ refresh, navigate })` |

package/SPEC.md

@@ -32,9 +32,9 @@ Anything that writes and reads it, in any language or framework, is a islx imple
 | `<script type="f/props" for>` | An island's props, as JSON. `for` names the island's `props` id. |
 | `<script type="f/value" name>` | A value sent once. `name` is its key. Written before the first island that uses it. |
 | `<f-slot name>` | Server output passed to an island as children. It stays server HTML; the island renders it in place. |
-| `<script type="f/tree" [partial]>` | A page's server tree, so the browser can rebuild the page inside an existing root without its HTML. `partial` marks a navigation that sent only the tree. |
-| `<script type="f/chunk" name>` | A part of a server tree that streamed in after the tree (a resolved Suspense boundary). |
-| `<f-html name>` | Server HTML inside a server tree. |
+| `<script type="f/tree" [name] [partial]>` | A server tree, so the browser can rebuild the page inside an existing root without its HTML. A page's tree has no `name`; a layout's carries its scope and sits at its `children` outlet, or after the layout when it has none. `partial` marks a navigation that sent only the tree. |
+| `<script type="f/chunk" name>` | A part of a server tree that streamed in after the tree (a resolved Suspense boundary). `name` is its number, after `scope:` in a layout's tree. |
+| `<f-html name>` | Server HTML inside a server tree, named like a chunk. |
 
 A value script's and props script's JSON escapes `<`, U+2028 and U+2029.
 
@@ -59,6 +59,7 @@ with any other keys is data.
 | `R` | `RegExp` | `[source, flags]` |
 | `Y` | bytes | `[type, base64]`; type is `ArrayBuffer`, `DataView` or a typed array name |
 | `p` | a Suspense boundary inside a server tree | |
+| `L` | a layout tree's outlet, where the page renders | `n`: the outlet's name, `children` for the page |
 | `F` | a `FormData` action argument | its index among the call's attachments |
 | `K` | a `Blob` or `File` action argument | its index among the call's attachments |
 

package/dist/_chunks/{actions-CA_K-In7.mjs → actions-2sTj0A2T.mjs}

@@ -1,5 +1,5 @@
 import { A as VALUE_SCRIPT_TYPE, N as getTag, O as VALUES_HEADER, j as attachmentField, k as VALUE_KEY_PATTERN, o as BOUND_FIELD, s as CALL_FIELD, t as ACTION_HEADER } from "./wire-CXOodE06.mjs";
-import { a as encode, r as decode } from "./codec-BTDkzzPP.mjs";
+import { a as encode, r as decode, u as setOwn } from "./codec-DqfVYKsx.mjs";
 // src/client/value-store.ts
 /**
 * The browser's store of values sent once. It keeps every value it has read, parses each once,
@@ -21,7 +21,8 @@ function createValueStore() {
 		if (entry.state === "resolving") throw new Error(`islx value ${key} refers to itself`);
 		entry.state = "resolving";
 		try {
-			entry.value = resolve(JSON.parse(entry.json));
+			const parsed = JSON.parse(entry.json);
+			entry.value = entry.json.includes(`"\$"`) ? resolve(parsed) : parsed;
 		} catch (error) {
 			entry.state = "raw";
 			throw error;
@@ -44,12 +45,7 @@ function createValueStore() {
 	};
 	const resolveEntries = (object) => {
 		const resolved = {};
-		for (const key of Object.keys(object)) Object.defineProperty(resolved, key, {
-			value: resolve(object[key]),
-			enumerable: true,
-			writable: true,
-			configurable: true
-		});
+		for (const key of Object.keys(object)) setOwn(resolved, key, resolve(object[key]));
 		return resolved;
 	};
 	return {

package/dist/_chunks/{actions-C4dZ1-XD.mjs → actions-B8dJ8f7L.mjs}

@@ -1,5 +1,5 @@
 import { M as formFieldName, O as VALUES_HEADER, d as FORM_REF_PREFIX, k as VALUE_KEY_PATTERN } from "./wire-CXOodE06.mjs";
-import { a as encode, c as needsObjectTag, o as encodeLeaf, r as decode, t as EncodeError } from "./codec-BTDkzzPP.mjs";
+import { a as encode, c as needsObjectTag, o as encodeLeaf, r as decode, t as EncodeError } from "./codec-DqfVYKsx.mjs";
 import { t as getBuildDefaults } from "./build-COIcs7wm.mjs";
 // src/server/values.ts
 /**

package/dist/_chunks/{codec-BTDkzzPP.mjs → codec-DqfVYKsx.mjs}

@@ -88,13 +88,21 @@ const NOT_A_VALUE = Symbol.for("islx.codec.not-a-value");
 /** A plain object from entries; `defineProperty`, so a "__proto__" key stays an ordinary key. */
 function plainObject(entries) {
 	const object = {};
-	for (const [key, value] of entries) Object.defineProperty(object, key, {
+	for (const [key, value] of entries) setOwn(object, key, value);
+	return object;
+}
+/**
+* Sets an own property. Plain assignment keeps the object fast; only a `"__proto__"` key needs
+* `defineProperty`, which assignment would turn into a prototype change.
+*/
+function setOwn(object, key, value) {
+	if (key === "__proto__") Object.defineProperty(object, key, {
 		value,
 		enumerable: true,
 		writable: true,
 		configurable: true
 	});
-	return object;
+	else object[key] = value;
 }
 /**
 * The value a tagged object stands for, decoding children (a `Map`'s or `Set`'s entries, an `o`
@@ -268,4 +276,4 @@ function decode(value, options = {}) {
 	};
 	return visit(value);
 }
-export { encode as a, needsObjectTag as c, toBase64 as d, decodeTagged as i, plainObject as l, NOT_A_VALUE as n, encodeLeaf as o, decode as r, fromBase64 as s, EncodeError as t, tagged as u };
+export { encode as a, needsObjectTag as c, tagged as d, toBase64 as f, decodeTagged as i, plainObject as l, NOT_A_VALUE as n, encodeLeaf as o, decode as r, fromBase64 as s, EncodeError as t, setOwn as u };

package/dist/_chunks/{tree-fID6sz25.d.mts → tree-B4RMU2UX.d.mts}

@@ -58,6 +58,13 @@ declare function createIsland<P extends object>(Component: React.ComponentType<P
  * page in its layout's React root and never shows its HTML, so the server leaves the HTML out.
  */
 declare const PAYLOAD_ONLY_ATTRIBUTE = "partial";
+/**
+ * Where a layout rendered as a server tree places the page (or another outlet, by `name`). The
+ * tree records the outlet, and the server and the browser render what they are given there.
+ */
+declare function Outlet(_props: {
+  name?: string;
+}): null;
 interface ServerTreeRenderOptions {
   /**
    * Renders a part the resolver cannot represent, as server HTML whose client components are
@@ -71,6 +78,17 @@ interface ServerTreeRenderOptions {
    * streams and the server HTML parts it cannot represent, without the page's rendered HTML.
    */
   payloadOnly?: boolean;
+  /**
+   * A layout rendered as a server tree: what each `<Outlet>` renders, by name. The payload script
+   * then sits at the `children` outlet, inside the layout's markup, so a layout that renders the
+   * whole document keeps it in the body.
+   */
+  outlets?: Record<string, React.ReactNode>;
+  /**
+   * Names this tree's payload, chunks and server HTML parts, so a layout's tree and the trees at
+   * its outlet do not read each other's. A page's tree has none.
+   */
+  scope?: string;
 }
 /**
  * Resolves a server page and returns what renders in its place: the resolved tree and its
@@ -99,4 +117,23 @@ interface ServerTreeElementOptions {
  * navigation), after loading its client modules. Returns null for a page without a tree.
  */
 declare function createServerTreeElement(source: ParentNode | string, options: ServerTreeElementOptions): Promise<React.ReactElement | null>;
-export { renderServerTree as a, IslandRenderState as c, getClientReference as d, isolateIslands as f, createServerTreeElement as i, IslandsProvider as l, withinClientRoot as m, ServerTreeElementOptions as n, updateServerTrees as o, setRenderStateResolver as p, ServerTreeRenderOptions as r, ClientReference as s, PAYLOAD_ONLY_ATTRIBUTE as t, createIsland as u };
+/** A layout rebuilt from its server tree. */
+interface ServerTreeLayout {
+  /** The layout around these outlets: plain elements, the same tree the server rendered. */
+  render(outlets: Record<string, React.ReactNode>): React.ReactNode;
+  /** Stops following hot module updates. */
+  dispose(): void;
+}
+interface ServerTreeLayoutOptions extends Omit<ServerTreeElementOptions, "key"> {
+  /** Runs after a hot update to one of the layout's client modules: render the route again. */
+  onUpdate?(): void;
+}
+/**
+ * Rebuilds a layout the server rendered with `renderServerTree(..., { outlets, scope })`, from
+ * its server HTML or a navigation's HTML. The layout's own module never reaches the browser: its
+ * client components load from the tree, and `render(outlets)` places the page at its outlet.
+ * Rendering it with the same component types at the same place keeps its client state across
+ * navigations. Returns null when `source` has no tree for `scope`.
+ */
+declare function createServerTreeLayout(source: ParentNode | string, scope: string, options: ServerTreeLayoutOptions): Promise<ServerTreeLayout | null>;
+export { setRenderStateResolver as _, ServerTreeLayoutOptions as a, createServerTreeLayout as c, ClientReference as d, IslandRenderState as f, isolateIslands as g, getClientReference as h, ServerTreeLayout as i, renderServerTree as l, createIsland as m, PAYLOAD_ONLY_ATTRIBUTE as n, ServerTreeRenderOptions as o, IslandsProvider as p, ServerTreeElementOptions as r, createServerTreeElement as s, Outlet as t, updateServerTrees as u, withinClientRoot as v };

package/dist/_chunks/{tree-BEV73f_8.mjs → tree-BvYR6-PF.mjs}

@@ -1,6 +1,6 @@
-import { i as decodeTagged, n as NOT_A_VALUE, o as encodeLeaf } from "./codec-BTDkzzPP.mjs";
+import { i as decodeTagged, n as NOT_A_VALUE, o as encodeLeaf } from "./codec-DqfVYKsx.mjs";
 import { A as VALUE_SCRIPT_TYPE, D as TREE_SCRIPT_TYPE, S as SLOT_ELEMENT, c as CHUNK_SCRIPT_TYPE, h as ISLAND_ELEMENT, p as HTML_ELEMENT, y as PROPS_SCRIPT_TYPE } from "./wire-CXOodE06.mjs";
-import { l as getValueStore, t as createServerReference } from "./actions-CA_K-In7.mjs";
+import { l as getValueStore, t as createServerReference } from "./actions-2sTj0A2T.mjs";
 import { t as getBuildDefaults } from "./build-COIcs7wm.mjs";
 import * as React from "react";
 import * as ReactDOM from "react-dom";
@@ -228,6 +228,15 @@ const SERVER_HTML_TAG = HTML_ELEMENT;
 */
 const PAYLOAD_ONLY_ATTRIBUTE = "partial";
 const SERVER_HTML_ATTRIBUTE = "name";
+const OUTLET = Symbol.for("islx.react.outlet");
+/**
+* Where a layout rendered as a server tree places the page (or another outlet, by `name`). The
+* tree records the outlet, and the server and the browser render what they are given there.
+*/
+function Outlet(_props) {
+	return null;
+}
+Outlet[OUTLET] = true;
 const PARSER_SENSITIVE_TAGS = /* @__PURE__ */ new Set([
 	"caption",
 	"colgroup",
@@ -414,6 +423,10 @@ async function resolveElement(state, element, context) {
 				i: id
 			});
 		}
+		if (typeof type === "function" && type[OUTLET]) return withKey({
+			$: "L",
+			n: String(props.name ?? "children")
+		});
 		const clientReference = getClientReference(type);
 		if (clientReference) {
 			const { children, ...rest } = props;
@@ -511,6 +524,7 @@ function createTreeValue(value, resolver) {
 			fallback: createTreeValue(value.f, resolver)
 		}, React.createElement(getChunkComponent(), { chunk: resolver.chunk(value.i) }));
 		case "x": return resolver.serverHtml(value.i, typeof value.k === "string" ? value.k : null);
+		case "L": return resolver.outlet(value.n);
 		case "n": return Number(value.v);
 		case "a": return resolver.action(value.v, typeof value.b === "string" ? value.b : void 0);
 		case "P": return fulfilledThenable(createTreeValue(value.v, resolver));
@@ -571,6 +585,22 @@ async function createPayloadOnlyPage(state, payload, encode, resolver) {
 		return React.createElement(React.Fragment, { key: `c${id}` }, createTreeScript(CHUNK_SCRIPT_TYPE, String(id), chunk.json, chunk.values));
 	}));
 }
+/** The name of a tree part: its number, after the tree's scope. */
+function scopedName(scope, id) {
+	return scope ? `${scope}:${id}` : String(id);
+}
+function hasChildrenOutlet(value) {
+	if (value === null || typeof value !== "object") return false;
+	if (Array.isArray(value)) return value.some(hasChildrenOutlet);
+	if (value.$ === "L") return value.n === "children";
+	return Object.values(value).some(hasChildrenOutlet);
+}
+/** What renders at a layout's outlet: its content, after the layout's payload at `children`. */
+function outletContent(outlets, name, script) {
+	const content = outlets?.[name] ?? null;
+	if (name !== "children" || !script) return content;
+	return React.createElement(React.Fragment, null, script, content);
+}
 /**
 * Resolves a server page and returns what renders in its place: the resolved tree and its
 * payload. Errors from the page's own code (a framework's redirect or not-found) propagate
@@ -588,6 +618,7 @@ async function renderServerTree(element, options = {}) {
 		chunks: /* @__PURE__ */ new Map(),
 		actions: /* @__PURE__ */ new Map()
 	};
+	const scope = options.scope;
 	const tree = await resolveValue(state, element, { parserSensitive: false }, /* @__PURE__ */ new Set());
 	const held = options.held && options.held.size > 0 ? options.held : null;
 	const encode = (payload) => {
@@ -597,6 +628,7 @@ async function renderServerTree(element, options = {}) {
 			values: addressed.values.map((value) => [value.key, hook.escape(value.json)])
 		};
 	};
+	let layoutScript = null;
 	const resolver = {
 		component(reference, exportName) {
 			const Component = state.components.get(`${reference}#${exportName}`);
@@ -610,7 +642,7 @@ async function renderServerTree(element, options = {}) {
 				status: "pending",
 				promise: entry.encoded.then((encoded) => {
 					const payload = encode({ t: encoded });
-					chunk.value = React.createElement(React.Fragment, null, createTreeValue(encoded, resolver), createTreeScript(CHUNK_SCRIPT_TYPE, String(id), payload.json, payload.values));
+					chunk.value = React.createElement(React.Fragment, null, createTreeValue(encoded, resolver), createTreeScript(CHUNK_SCRIPT_TYPE, scopedName(scope, id), payload.json, payload.values));
 					chunk.status = "fulfilled";
 					return chunk.value;
 				}, (error) => {
@@ -626,10 +658,13 @@ async function renderServerTree(element, options = {}) {
 		serverHtml(id, key) {
 			return React.createElement(SERVER_HTML_TAG, {
 				...key === null ? {} : { key },
-				[SERVER_HTML_ATTRIBUTE]: String(id),
+				[SERVER_HTML_ATTRIBUTE]: scopedName(scope, id),
 				style: { display: "contents" }
 			}, isolate(state.serverHtml.get(id)));
 		},
+		outlet(name) {
+			return outletContent(options.outlets, name, layoutScript);
+		},
 		action(id) {
 			return state.actions.get(id);
 		}
@@ -638,6 +673,16 @@ async function renderServerTree(element, options = {}) {
 		v: 1,
 		t: tree
 	});
+	if (options.outlets) {
+		const script = createTreeScript(TREE_SCRIPT_TYPE, scope ?? "", payload.json, payload.values);
+		const atOutlet = hasChildrenOutlet(tree);
+		if (atOutlet) layoutScript = script;
+		const layout = createTreeValue(tree, resolver);
+		const content = atOutlet ? layout : React.createElement(React.Fragment, null, layout, script);
+		return React.createElement(function ServerTreeLayout() {
+			return content;
+		});
+	}
 	const page = options.payloadOnly && await createPayloadOnlyPage(state, payload, encode, resolver) || createTreePage(tree, payload.json, resolver, void 0, payload.values);
 	return React.createElement(function ServerTreePage() {
 		return page;
@@ -673,14 +718,10 @@ function exportOf(module, src, exportName) {
 	if (typeof Component !== "function" && (typeof Component !== "object" || Component === null)) throw new Error(`${src} has no export ${exportName}`);
 	return Component;
 }
-/**
-* Rebuilds a server-tree page in the browser from its server HTML (an element, or the HTML of a
-* navigation), after loading its client modules. Returns null for a page without a tree.
-*/
-async function createServerTreeElement(source, options) {
+/** Reads a tree's payload, chunks and server HTML from `root` and loads its client modules. */
+async function prepareTree(root, scope, options) {
 	const values = options.values ?? getValueStore();
-	const root = typeof source === "string" ? parseHtml(source) : source;
-	const script = root.querySelector(`script[type="${TREE_SCRIPT_TYPE}"]`);
+	const script = Array.from(root.querySelectorAll(`script[type="${TREE_SCRIPT_TYPE}"]`)).find((candidate) => (candidate.getAttribute("name") ?? void 0) === scope);
 	if (!script) return null;
 	const json = script.textContent ?? "";
 	let ingested = false;
@@ -696,10 +737,19 @@ async function createServerTreeElement(source, options) {
 	const payload = parsePayload(json);
 	if (payload.v !== 1) throw new Error("unsupported server tree payload version");
 	const scripts = readTreeValueScripts(script);
+	const partId = (name) => {
+		if (name === null) return null;
+		const prefix = scope === void 0 ? "" : `${scope}:`;
+		if (!name.startsWith(prefix)) return null;
+		const id = name.slice(prefix.length);
+		return /^\d+$/.test(id) ? Number(id) : null;
+	};
 	const chunks = /* @__PURE__ */ new Map();
 	for (const chunkScript of root.querySelectorAll(`script[type="${CHUNK_SCRIPT_TYPE}"]`)) {
+		const id = partId(chunkScript.getAttribute("name"));
+		if (id === null) continue;
 		const chunkJson = chunkScript.textContent ?? "";
-		chunks.set(Number(chunkScript.getAttribute("name")), {
+		chunks.set(id, {
 			tree: parsePayload(chunkJson).t,
 			json: chunkJson,
 			values: readTreeValueScripts(chunkScript)
@@ -715,52 +765,84 @@ async function createServerTreeElement(source, options) {
 		components.set(key, exportOf(await options.load(src), src, key.slice(separator + 1)));
 	}));
 	const serverHtml = /* @__PURE__ */ new Map();
-	for (const container of root.querySelectorAll(`${SERVER_HTML_TAG}[${SERVER_HTML_ATTRIBUTE}]`)) serverHtml.set(Number(container.getAttribute(SERVER_HTML_ATTRIBUTE)), container.innerHTML);
-	const resolver = {
-		component(reference, exportName) {
-			const Component = components.get(`${reference}#${exportName}`);
-			if (!Component) throw new Error(`client reference ${reference}#${exportName} was not loaded`);
-			return Component;
-		},
-		chunk(id) {
-			const chunk = chunks.get(id);
-			if (!chunk) throw new Error(`server tree chunk ${id} was not found`);
-			const value = React.createElement(React.Fragment, null, createTreeValue(chunk.tree, resolver), createTreeScript(CHUNK_SCRIPT_TYPE, String(id), chunk.json, chunk.values));
-			return {
-				status: "fulfilled",
-				value,
-				promise: Promise.resolve(value)
-			};
-		},
-		serverHtml(id, key) {
-			const html = serverHtml.get(id);
-			if (html === void 0) throw new Error(`server HTML ${id} was not found`);
-			return React.createElement(options.ServerHtml, {
-				...key === null ? {} : { key },
-				as: SERVER_HTML_TAG,
-				[SERVER_HTML_ATTRIBUTE]: String(id),
-				style: { display: "contents" },
-				suppressHydrationWarning: true,
-				dangerouslySetInnerHTML: { __html: html }
-			});
-		},
-		action(id, sealed) {
-			return createServerReference(id, sealed);
-		}
+	for (const container of root.querySelectorAll(`${SERVER_HTML_TAG}[${SERVER_HTML_ATTRIBUTE}]`)) {
+		const id = partId(container.getAttribute(SERVER_HTML_ATTRIBUTE));
+		if (id !== null) serverHtml.set(id, container.innerHTML);
+	}
+	const resolver = (outlets, outletScript) => {
+		const treeResolver = {
+			component(reference, exportName) {
+				const Component = components.get(`${reference}#${exportName}`);
+				if (!Component) throw new Error(`client reference ${reference}#${exportName} was not loaded`);
+				return Component;
+			},
+			chunk(id) {
+				const chunk = chunks.get(id);
+				if (!chunk) throw new Error(`server tree chunk ${id} was not found`);
+				const value = React.createElement(React.Fragment, null, createTreeValue(chunk.tree, treeResolver), createTreeScript(CHUNK_SCRIPT_TYPE, scopedName(scope, id), chunk.json, chunk.values));
+				return {
+					status: "fulfilled",
+					value,
+					promise: Promise.resolve(value)
+				};
+			},
+			serverHtml(id, key) {
+				const html = serverHtml.get(id);
+				if (html === void 0) throw new Error(`server HTML ${id} was not found`);
+				return React.createElement(options.ServerHtml, {
+					...key === null ? {} : { key },
+					as: SERVER_HTML_TAG,
+					[SERVER_HTML_ATTRIBUTE]: scopedName(scope, id),
+					style: { display: "contents" },
+					suppressHydrationWarning: true,
+					dangerouslySetInnerHTML: { __html: html }
+				});
+			},
+			outlet(name) {
+				return outletContent(outlets, name, outletScript);
+			},
+			action(id, sealed) {
+				return createServerReference(id, sealed);
+			}
+		};
+		return treeResolver;
 	};
-	const build = () => createTreePage(payload.t, json, resolver, void 0, scripts);
+	return {
+		payload: payload.t,
+		json,
+		values: scripts,
+		components,
+		resolver,
+		hasOutlet: hasChildrenOutlet(payload.t)
+	};
+}
+/** Points a tree's loaded components at a hot-updated module; true when the tree renders it. */
+function updateTreeComponents(components, src, module) {
+	let changed = false;
+	for (const key of components.keys()) {
+		const separator = key.lastIndexOf("#");
+		if (key.slice(0, separator) !== src) continue;
+		components.set(key, exportOf(module, src, key.slice(separator + 1)));
+		changed = true;
+	}
+	return changed;
+}
+/**
+* Rebuilds a server-tree page in the browser from its server HTML (an element, or the HTML of a
+* navigation), after loading its client modules. Returns null for a page without a tree.
+*/
+async function createServerTreeElement(source, options) {
+	const prepared = await prepareTree(typeof source === "string" ? parseHtml(source) : source, void 0, options);
+	if (!prepared) return null;
+	const tree = prepared;
+	const resolver = tree.resolver();
+	const build = () => createTreePage(tree.payload, tree.json, resolver, void 0, tree.values);
 	build();
 	function ServerTreePage() {
 		const [, setVersion] = React.useState(0);
 		React.useEffect(() => {
 			const listener = (src, module) => {
-				let changed = false;
-				for (const key of components.keys()) {
-					const separator = key.lastIndexOf("#");
-					if (key.slice(0, separator) !== src) continue;
-					components.set(key, exportOf(module, src, key.slice(separator + 1)));
-					changed = true;
-				}
+				const changed = updateTreeComponents(tree.components, src, module);
 				if (changed) setVersion((version) => version + 1);
 				return changed;
 			};
@@ -774,4 +856,35 @@ async function createServerTreeElement(source, options) {
 	}
 	return React.createElement(ServerTreePage, options.key === void 0 ? null : { key: options.key });
 }
-export { IslandsProvider as a, getContexts as c, setIslandServerHook as d, setRenderStateResolver as f, updateServerTrees as i, isolateIslands as l, createServerTreeElement as n, createIsland as o, withinClientRoot as p, renderServerTree as r, getClientReference as s, PAYLOAD_ONLY_ATTRIBUTE as t, runtimeTagged as u };
+/**
+* Rebuilds a layout the server rendered with `renderServerTree(..., { outlets, scope })`, from
+* its server HTML or a navigation's HTML. The layout's own module never reaches the browser: its
+* client components load from the tree, and `render(outlets)` places the page at its outlet.
+* Rendering it with the same component types at the same place keeps its client state across
+* navigations. Returns null when `source` has no tree for `scope`.
+*/
+async function createServerTreeLayout(source, scope, options) {
+	const tree = await prepareTree(typeof source === "string" ? parseHtml(source) : source, scope, options);
+	if (!tree) return null;
+	const script = createTreeScript(TREE_SCRIPT_TYPE, scope, tree.json, tree.values);
+	const render = (outlets) => {
+		const resolver = tree.resolver(outlets, tree.hasOutlet ? script : void 0);
+		const layout = createTreeValue(tree.payload, resolver);
+		return tree.hasOutlet ? layout : React.createElement(React.Fragment, null, layout, script);
+	};
+	render({});
+	const listener = (src, module) => {
+		const changed = updateTreeComponents(tree.components, src, module);
+		if (changed) options.onUpdate?.();
+		return changed;
+	};
+	const listeners = treeListeners();
+	listeners.add(listener);
+	return {
+		render,
+		dispose: () => {
+			listeners.delete(listener);
+		}
+	};
+}
+export { renderServerTree as a, createIsland as c, isolateIslands as d, runtimeTagged as f, withinClientRoot as h, createServerTreeLayout as i, getClientReference as l, setRenderStateResolver as m, PAYLOAD_ONLY_ATTRIBUTE as n, updateServerTrees as o, setIslandServerHook as p, createServerTreeElement as r, IslandsProvider as s, Outlet as t, getContexts as u };

package/dist/client.mjs

@@ -1,4 +1,4 @@
-import { a as emit, c as createValueStore, i as defineClientHooks, l as getValueStore, n as decodeActionReference, o as hookEventName, r as setActionNavigator, s as setClientHooks, t as createServerReference, u as valueHeaders } from "./_chunks/actions-CA_K-In7.mjs";
+import { a as emit, c as createValueStore, i as defineClientHooks, l as getValueStore, n as decodeActionReference, o as hookEventName, r as setActionNavigator, s as setClientHooks, t as createServerReference, u as valueHeaders } from "./_chunks/actions-2sTj0A2T.mjs";
 import { F as stripRuntimeFields, P as readPostedAction, x as RENDER_HEADER } from "./_chunks/wire-CXOodE06.mjs";
 import { i as REPLAYABLE_SELECTOR, n as PENDING_INTERACTIONS, r as PREHYDRATION_SCRIPT, t as INTERACTION_EVENT } from "./_chunks/prehydration-B1GLTLdk.mjs";
 // src/client/forms.ts

package/dist/index.mjs

@@ -1,3 +1,3 @@
 import { A as VALUE_SCRIPT_TYPE, C as SLOT_TAG, D as TREE_SCRIPT_TYPE, E as TAG_VALUE, F as stripRuntimeFields, M as formFieldName, N as getTag, O as VALUES_HEADER, P as readPostedAction, S as SLOT_ELEMENT, T as TAG_BOUND, _ as MAX_HELD_VALUES, a as BLOB_TAG, b as REFERENCE_TAG, c as CHUNK_SCRIPT_TYPE, d as FORM_REF_PREFIX, f as FORM_STATE_SCRIPT_TYPE, g as LAYOUTS_HEADER, h as ISLAND_ELEMENT, i as ACTION_TAG, j as attachmentField, k as VALUE_KEY_PATTERN, l as FORM_DATA_TAG, m as HYDRATED_ATTRIBUTE, n as ACTION_KEY_FIELD, o as BOUND_FIELD, p as HTML_ELEMENT, r as ACTION_STALE_HEADER, s as CALL_FIELD, t as ACTION_HEADER, u as FORM_FIELD_PREFIX, v as OBJECT_TAG, w as TAG, x as RENDER_HEADER, y as PROPS_SCRIPT_TYPE } from "./_chunks/wire-CXOodE06.mjs";
-import { a as encode, c as needsObjectTag, d as toBase64, i as decodeTagged, l as plainObject, n as NOT_A_VALUE, o as encodeLeaf, r as decode, s as fromBase64, t as EncodeError, u as tagged } from "./_chunks/codec-BTDkzzPP.mjs";
+import { a as encode, c as needsObjectTag, d as tagged, f as toBase64, i as decodeTagged, l as plainObject, n as NOT_A_VALUE, o as encodeLeaf, r as decode, s as fromBase64, t as EncodeError } from "./_chunks/codec-DqfVYKsx.mjs";
 export { ACTION_HEADER, ACTION_KEY_FIELD, ACTION_STALE_HEADER, ACTION_TAG, BLOB_TAG, BOUND_FIELD, CALL_FIELD, CHUNK_SCRIPT_TYPE, EncodeError, FORM_DATA_TAG, FORM_FIELD_PREFIX, FORM_REF_PREFIX, FORM_STATE_SCRIPT_TYPE, HTML_ELEMENT, HYDRATED_ATTRIBUTE, ISLAND_ELEMENT, LAYOUTS_HEADER, MAX_HELD_VALUES, NOT_A_VALUE, OBJECT_TAG, PROPS_SCRIPT_TYPE, REFERENCE_TAG, RENDER_HEADER, SLOT_ELEMENT, SLOT_TAG, TAG, TAG_BOUND, TAG_VALUE, TREE_SCRIPT_TYPE, VALUES_HEADER, VALUE_KEY_PATTERN, VALUE_SCRIPT_TYPE, attachmentField, decode, decodeTagged, encode, encodeLeaf, formFieldName, fromBase64, getTag, needsObjectTag, plainObject, readPostedAction, stripRuntimeFields, tagged, toBase64 };

package/dist/react/client.d.mts

@@ -1,7 +1,7 @@
 import { a as scheduleHydration, i as isIslandStrategy, n as IslandStrategy, r as ScheduleOptions, t as ISLAND_STRATEGIES } from "../_chunks/schedule-Dw14dW0H.mjs";
 import { m as HYDRATED_ATTRIBUTE } from "../_chunks/wire-C3Rpbwl6.mjs";
 import { t as ValueStore } from "../_chunks/value-store-Dm-7xJ6W.mjs";
-import { f as isolateIslands, i as createServerTreeElement, m as withinClientRoot, n as ServerTreeElementOptions, o as updateServerTrees, t as PAYLOAD_ONLY_ATTRIBUTE } from "../_chunks/tree-fID6sz25.mjs";
+import { a as ServerTreeLayoutOptions, c as createServerTreeLayout, g as isolateIslands, i as ServerTreeLayout, n as PAYLOAD_ONLY_ATTRIBUTE, r as ServerTreeElementOptions, s as createServerTreeElement, u as updateServerTrees, v as withinClientRoot } from "../_chunks/tree-B4RMU2UX.mjs";
 import * as React from "react";
 
 // src/react/hydrate.d.ts
@@ -46,4 +46,4 @@ declare function createServerHtml(runtime: Pick<HydrationRuntime, "hydrate" | "d
 declare function refreshDocument(runtime: HydrationRuntime): Promise<void>;
 /** Puts another page's body in place of this one's, and hydrates its islands. */
 declare function swapDocument(runtime: HydrationRuntime, next: Document): Promise<void>;
-export { HYDRATED_ATTRIBUTE, type HydrationOptions, type HydrationRuntime, ISLAND_STRATEGIES, type IslandStrategy, PAYLOAD_ONLY_ATTRIBUTE, type ScheduleOptions, type ServerTreeElementOptions, createHydrationRuntime, createServerHtml, createServerTreeElement, isIslandStrategy, isolateIslands, refreshDocument, scheduleHydration, swapDocument, updateServerTrees, withinClientRoot };
+export { HYDRATED_ATTRIBUTE, type HydrationOptions, type HydrationRuntime, ISLAND_STRATEGIES, type IslandStrategy, PAYLOAD_ONLY_ATTRIBUTE, type ScheduleOptions, type ServerTreeElementOptions, type ServerTreeLayout, type ServerTreeLayoutOptions, createHydrationRuntime, createServerHtml, createServerTreeElement, createServerTreeLayout, isIslandStrategy, isolateIslands, refreshDocument, scheduleHydration, swapDocument, updateServerTrees, withinClientRoot };

package/dist/react/client.mjs

@@ -1,7 +1,7 @@
-import { a as emit, l as getValueStore, t as createServerReference, u as valueHeaders } from "../_chunks/actions-CA_K-In7.mjs";
-import { i as decodeTagged, n as NOT_A_VALUE, r as decode } from "../_chunks/codec-BTDkzzPP.mjs";
+import { a as emit, l as getValueStore, t as createServerReference, u as valueHeaders } from "../_chunks/actions-2sTj0A2T.mjs";
+import { i as decodeTagged, n as NOT_A_VALUE, r as decode, u as setOwn } from "../_chunks/codec-DqfVYKsx.mjs";
 import { N as getTag, S as SLOT_ELEMENT, f as FORM_STATE_SCRIPT_TYPE, h as ISLAND_ELEMENT, m as HYDRATED_ATTRIBUTE, y as PROPS_SCRIPT_TYPE } from "../_chunks/wire-CXOodE06.mjs";
-import { c as getContexts, i as updateServerTrees, l as isolateIslands, n as createServerTreeElement, p as withinClientRoot, t as PAYLOAD_ONLY_ATTRIBUTE } from "../_chunks/tree-BEV73f_8.mjs";
+import { d as isolateIslands, h as withinClientRoot, i as createServerTreeLayout, n as PAYLOAD_ONLY_ATTRIBUTE, o as updateServerTrees, r as createServerTreeElement, u as getContexts } from "../_chunks/tree-BvYR6-PF.mjs";
 import { n as isIslandStrategy, r as scheduleHydration, t as ISLAND_STRATEGIES } from "../_chunks/schedule-BFoGKRrU.mjs";
 import * as React from "react";
 import { hydrateRoot } from "react-dom/client";
@@ -31,8 +31,26 @@ function readFormState(document) {
 		return;
 	}
 }
+/**
+* Revived values, by the object the value store resolved. Islands that share a value (one sent
+* once for several islands) then share the revived object instead of walking it again. A value
+* with a slot is not kept: a slot's HTML belongs to one island.
+*/
+const revivedValues = /* @__PURE__ */ new WeakMap();
+let slotsRevived = 0;
 /** Turns travelled props back into values: slots keep their server HTML, actions become callable. */
 function revive(value, container) {
+	if (value && typeof value === "object") {
+		const cached = revivedValues.get(value);
+		if (cached !== void 0) return cached;
+		const slotsBefore = slotsRevived;
+		const revived = reviveUncached(value, container);
+		if (slotsRevived === slotsBefore) revivedValues.set(value, revived);
+		return revived;
+	}
+	return value;
+}
+function reviveUncached(value, container) {
 	if (Array.isArray(value)) {
 		let changed = false;
 		const revived = value.map((entry) => {
@@ -42,7 +60,6 @@ function revive(value, container) {
 		});
 		return changed ? revived : value;
 	}
-	if (!value || typeof value !== "object") return value;
 	const object = value;
 	const tag = getTag(object);
 	if (tag === "a" && typeof object["v"] === "string") {
@@ -50,6 +67,7 @@ function revive(value, container) {
 		return createServerReference(object["v"], typeof token === "string" ? token : void 0);
 	}
 	if (tag === "s" && typeof object["v"] === "string") {
+		slotsRevived++;
 		const name = object["v"];
 		let html = "";
 		for (const slot of container.querySelectorAll(SLOT_ELEMENT)) if (slot.getAttribute("name") === name) {
@@ -73,16 +91,16 @@ function revive(value, container) {
 	const revived = {};
 	for (const [key, entry] of Object.entries(object)) {
 		const next = revive(entry, container);
-		Object.defineProperty(revived, key, {
-			value: next,
-			enumerable: true,
-			writable: true,
-			configurable: true
-		});
+		setOwn(revived, key, next);
 		if (next !== entry) changed = true;
 	}
 	return changed ? revived : value;
 }
+/**
+* React streams Suspense content that resolves late into a hidden `<div id="S:n">`, then moves it
+* into place. Its islands hydrate once moved, not while staged.
+*/
+const STREAM_STAGING = "div[hidden][id^=\"S:\"]";
 /** The hydration runtime for one page. */
 function createHydrationRuntime(options) {
 	const roots = /* @__PURE__ */ new Map();
@@ -146,6 +164,7 @@ function createHydrationRuntime(options) {
 		const text = script.textContent || "{}";
 		let parsed = JSON.parse(text);
 		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("props must be an object");
+		if (!text.includes(`"\$"`)) return parsed;
 		if (text.includes(`"\$":"r"`)) {
 			values.ingest(container.ownerDocument);
 			parsed = values.resolve(parsed);
@@ -160,9 +179,10 @@ function createHydrationRuntime(options) {
 			formStateRead = true;
 			formState = readFormState(scope instanceof Document ? scope : scope.ownerDocument ?? document);
 		}
+		if (scope instanceof Document) watchStream(scope);
 		const candidates = Array.from(scope.querySelectorAll(ISLAND_SELECTOR));
 		if (scope instanceof Element && scope.matches(ISLAND_SELECTOR)) candidates.unshift(scope);
-		const islands = candidates.filter((container) => !roots.has(container) && !pending.has(container) && !container.parentElement?.closest(ISLAND_SELECTOR));
+		const islands = candidates.filter((container) => !roots.has(container) && !pending.has(container) && !container.parentElement?.closest(ISLAND_SELECTOR) && !container.closest(STREAM_STAGING));
 		await Promise.all(islands.map(async (container) => {
 			const src = container.getAttribute("src");
 			const id = container.getAttribute("props");
@@ -312,6 +332,39 @@ function createHydrationRuntime(options) {
 		return updated;
 	}
 	/** Unmounts the islands inside `scope`, and stops scheduled ones. */
+	/**
+	* A page still streaming: islands in Suspense content that arrives later hydrate as React puts it
+	* in place, and islands React removes (a replaced fallback) are released. Ends once the document
+	* is parsed and React has revealed every staged boundary (it may batch reveals past parsing).
+	*/
+	let watching = false;
+	function watchStream(document) {
+		if (watching || document.readyState !== "loading" || typeof MutationObserver !== "function") return;
+		watching = true;
+		const removed = /* @__PURE__ */ new Set();
+		let queued = false;
+		const run = () => {
+			queued = false;
+			for (const node of removed) if (!node.isConnected) dispose(node);
+			removed.clear();
+			if (document.readyState !== "loading" && !document.querySelector(STREAM_STAGING)) {
+				observer.disconnect();
+				watching = false;
+			}
+			hydrate(document).catch((error) => report("Hydrating streamed islands failed.", error));
+		};
+		const observer = new MutationObserver((records) => {
+			for (const record of records) for (const node of record.removedNodes) removed.add(node);
+			if (queued) return;
+			queued = true;
+			queueMicrotask(run);
+		});
+		observer.observe(document, {
+			childList: true,
+			subtree: true
+		});
+		document.addEventListener("DOMContentLoaded", run, { once: true });
+	}
 	function dispose(scope) {
 		for (const [container, controller] of pending) if (container === scope || scope.contains(container)) {
 			controller.abort();
@@ -400,4 +453,4 @@ async function swapDocument(runtime, next) {
 	document.body.replaceChildren(...Array.from(body.childNodes));
 	await runtime.hydrate(document);
 }
-export { HYDRATED_ATTRIBUTE, ISLAND_STRATEGIES, PAYLOAD_ONLY_ATTRIBUTE, createHydrationRuntime, createServerHtml, createServerTreeElement, isIslandStrategy, isolateIslands, refreshDocument, scheduleHydration, swapDocument, updateServerTrees, withinClientRoot };
+export { HYDRATED_ATTRIBUTE, ISLAND_STRATEGIES, PAYLOAD_ONLY_ATTRIBUTE, createHydrationRuntime, createServerHtml, createServerTreeElement, createServerTreeLayout, isIslandStrategy, isolateIslands, refreshDocument, scheduleHydration, swapDocument, updateServerTrees, withinClientRoot };

package/dist/react/server.d.mts

@@ -1,5 +1,5 @@
 import { r as ReactFormState } from "../_chunks/handle-C0N9ZyNV.mjs";
-import { a as renderServerTree, c as IslandRenderState, d as getClientReference, f as isolateIslands, l as IslandsProvider, m as withinClientRoot, p as setRenderStateResolver, r as ServerTreeRenderOptions, s as ClientReference, t as PAYLOAD_ONLY_ATTRIBUTE, u as createIsland } from "../_chunks/tree-fID6sz25.mjs";
+import { _ as setRenderStateResolver, d as ClientReference, f as IslandRenderState, g as isolateIslands, h as getClientReference, l as renderServerTree, m as createIsland, n as PAYLOAD_ONLY_ATTRIBUTE, o as ServerTreeRenderOptions, p as IslandsProvider, t as Outlet, v as withinClientRoot } from "../_chunks/tree-B4RMU2UX.mjs";
 import * as React from "react";
 import { RenderToReadableStreamOptions } from "react-dom/server";
 
@@ -48,4 +48,4 @@ declare function renderToStream(element: React.ReactNode, {
 }>;
 /** Whether a response rendered for `request` leaves out values its browser holds. */
 declare function isPersonalized(request: Request): boolean;
-export { type ClientReference, type IslandRenderState, IslandsProvider, PAYLOAD_ONLY_ATTRIBUTE, RenderToStreamOptions, type ServerTreeRenderOptions, createIsland, getClientReference, isPersonalized, isolateIslands, renderServerTree, renderToStream, setRenderStateResolver, withinClientRoot };
+export { type ClientReference, type IslandRenderState, IslandsProvider, Outlet, PAYLOAD_ONLY_ATTRIBUTE, RenderToStreamOptions, type ServerTreeRenderOptions, createIsland, getClientReference, isPersonalized, isolateIslands, renderServerTree, renderToStream, setRenderStateResolver, withinClientRoot };

package/dist/react/server.mjs

@@ -1,9 +1,9 @@
-import { a as encode } from "../_chunks/codec-BTDkzzPP.mjs";
+import { a as encode } from "../_chunks/codec-DqfVYKsx.mjs";
 import { f as FORM_STATE_SCRIPT_TYPE } from "../_chunks/wire-CXOodE06.mjs";
 import { r as PREHYDRATION_SCRIPT } from "../_chunks/prehydration-B1GLTLdk.mjs";
-import { g as escapeScriptJson, h as addressValues, i as encodeActionReference, v as parseHeldValues, y as selectValuesToSend } from "../_chunks/actions-C4dZ1-XD.mjs";
+import { g as escapeScriptJson, h as addressValues, i as encodeActionReference, v as parseHeldValues, y as selectValuesToSend } from "../_chunks/actions-B8dJ8f7L.mjs";
 import { t as getBuildDefaults } from "../_chunks/build-COIcs7wm.mjs";
-import { a as IslandsProvider, c as getContexts, d as setIslandServerHook, f as setRenderStateResolver, l as isolateIslands, o as createIsland, p as withinClientRoot, r as renderServerTree, s as getClientReference, t as PAYLOAD_ONLY_ATTRIBUTE, u as runtimeTagged } from "../_chunks/tree-BEV73f_8.mjs";
+import { a as renderServerTree, c as createIsland, d as isolateIslands, f as runtimeTagged, h as withinClientRoot, l as getClientReference, m as setRenderStateResolver, n as PAYLOAD_ONLY_ATTRIBUTE, p as setIslandServerHook, s as IslandsProvider, t as Outlet, u as getContexts } from "../_chunks/tree-BvYR6-PF.mjs";
 import * as React from "react";
 // src/react/server.ts
 /**
@@ -81,4 +81,4 @@ async function renderToStream(element, { request, formState, bootstrap = true, p
 function isPersonalized(request) {
 	return parseHeldValues(request).size > 0;
 }
-export { IslandsProvider, PAYLOAD_ONLY_ATTRIBUTE, createIsland, getClientReference, isPersonalized, isolateIslands, renderServerTree, renderToStream, setRenderStateResolver, withinClientRoot };
+export { IslandsProvider, Outlet, PAYLOAD_ONLY_ATTRIBUTE, createIsland, getClientReference, isPersonalized, isolateIslands, renderServerTree, renderToStream, setRenderStateResolver, withinClientRoot };

package/dist/react.d.mts

@@ -1,3 +1,3 @@
-import { a as renderServerTree, c as IslandRenderState, f as isolateIslands, l as IslandsProvider, m as withinClientRoot, r as ServerTreeRenderOptions, u as createIsland } from "./_chunks/tree-fID6sz25.mjs";
+import { f as IslandRenderState, g as isolateIslands, l as renderServerTree, m as createIsland, o as ServerTreeRenderOptions, p as IslandsProvider, t as Outlet, v as withinClientRoot } from "./_chunks/tree-B4RMU2UX.mjs";
 import { n as IslandStrategy } from "./_chunks/schedule-Dw14dW0H.mjs";
-export { type IslandRenderState, type IslandStrategy, IslandsProvider, type ServerTreeRenderOptions, createIsland, isolateIslands, renderServerTree, withinClientRoot };
+export { type IslandRenderState, type IslandStrategy, IslandsProvider, Outlet, type ServerTreeRenderOptions, createIsland, isolateIslands, renderServerTree, withinClientRoot };

package/dist/react.mjs

@@ -1 +1 @@
-export { a as IslandsProvider, o as createIsland, l as isolateIslands, r as renderServerTree, p as withinClientRoot } from "./_chunks/tree-BEV73f_8.mjs";
+export { s as IslandsProvider, t as Outlet, c as createIsland, d as isolateIslands, a as renderServerTree, h as withinClientRoot } from "./_chunks/tree-BvYR6-PF.mjs";

package/dist/server.mjs

@@ -1,5 +1,5 @@
-import { _ as hashValue, a as getActionReference, c as resolveAction, d as generateActionKey, f as sealBound, g as escapeScriptJson, h as addressValues, i as encodeActionReference, l as SealError, m as VALUE_MIN_LENGTH, n as configureActionKeys, o as registerInlineAction, p as unsealBound, r as decodeActionReference, s as registerServerReference, t as bindInlineAction, u as createActionKeys, v as parseHeldValues, y as selectValuesToSend } from "./_chunks/actions-C4dZ1-XD.mjs";
-import { a as encode, r as decode } from "./_chunks/codec-BTDkzzPP.mjs";
+import { _ as hashValue, a as getActionReference, c as resolveAction, d as generateActionKey, f as sealBound, g as escapeScriptJson, h as addressValues, i as encodeActionReference, l as SealError, m as VALUE_MIN_LENGTH, n as configureActionKeys, o as registerInlineAction, p as unsealBound, r as decodeActionReference, s as registerServerReference, t as bindInlineAction, u as createActionKeys, v as parseHeldValues, y as selectValuesToSend } from "./_chunks/actions-B8dJ8f7L.mjs";
+import { a as encode, r as decode } from "./_chunks/codec-DqfVYKsx.mjs";
 import { F as stripRuntimeFields, P as readPostedAction, j as attachmentField, n as ACTION_KEY_FIELD, o as BOUND_FIELD, r as ACTION_STALE_HEADER, s as CALL_FIELD, t as ACTION_HEADER } from "./_chunks/wire-CXOodE06.mjs";
 import { n as setBuildDefaults, t as getBuildDefaults } from "./_chunks/build-COIcs7wm.mjs";
 // src/server/hooks.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@farm.js/islx",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "A renderer-agnostic wire format for server-rendered islands: typed props, values sent once, server actions, and partial navigations.",
   "keywords": [
     "islands",