@farm.js/islx 0.0.0-stage → 0.0.2

package/dist/react/client.d.mts

@@ -0,0 +1,49 @@
+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 * as React from "react";
+
+// src/react/hydrate.d.ts
+
+interface HydrationOptions {
+  /** Imports an island's module: `(src) => import(src)` with the bundler's URL. */
+  load(src: string): Promise<Record<string, unknown>>;
+  /** Wraps each island's element, as for providers every island needs. */
+  wrap?(element: React.ReactElement): React.ReactNode;
+  /** Reports an island that failed. Default `console.error`. */
+  report?(message: string, error?: unknown): void;
+  /** The value store. Default: the page's. */
+  values?: ValueStore;
+  /**
+   * When each island hydrates: `scheduleHydration` (its strategy), or the framework's own. Required,
+   * so a framework with its own scheduler ships none of islx's.
+   */
+  schedule: typeof scheduleHydration;
+}
+/** The hydration runtime for one page. */
+declare function createHydrationRuntime(options: HydrationOptions): {
+  hydrate: (scope?: ParentNode, signal?: AbortSignal) => Promise<void>;
+  carryOver: (current: ParentNode, next: ParentNode) => number;
+  update: (src: string, module: Record<string, unknown>) => number;
+  dispose: (scope: Node) => void;
+  rootCount: () => number;
+};
+type HydrationRuntime = ReturnType<typeof createHydrationRuntime>;
+/**
+ * A page a hydrating layout keeps as server HTML (and a server tree's `<f-html>` part). React owns
+ * only the wrapper, so the islands inside start after React commits that HTML and stop when it is
+ * replaced or the layout unmounts. The islands are captured when they start, because React has
+ * already swapped the HTML by the time the cleanup runs.
+ */
+declare function createServerHtml(runtime: Pick<HydrationRuntime, "hydrate" | "dispose">): React.ComponentType<Record<string, unknown> & {
+  as?: string;
+  dangerouslySetInnerHTML: {
+    __html: string;
+  };
+}>;
+/** Fetches the current page and puts its new content in place, keeping island state. */
+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 };

package/dist/react/client.mjs

@@ -0,0 +1,456 @@
+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-BDB5VEao.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";
+// src/react/hydrate.ts
+/**
+* @farm.js/islx/react/client: hydrating a page's islands. Each island is its own React root,
+* started when its strategy says. A root that fails restores the island's server HTML, so a broken
+* component never blanks the page.
+*/
+const ISLAND_SELECTOR = `${ISLAND_ELEMENT}[src]`;
+function isEarlyUpdate(error) {
+	return error instanceof Error && (error.message.startsWith("This root received an early update") || error.message.startsWith("Minified React error #424;"));
+}
+function findPropsScript(container, id) {
+	const sibling = container.nextElementSibling;
+	if (sibling instanceof HTMLScriptElement && sibling.type === "f/props" && sibling.getAttribute("for") === id) return sibling;
+	for (const script of container.ownerDocument.querySelectorAll(`script[type="${PROPS_SCRIPT_TYPE}"]`)) if (script.getAttribute("for") === id) return script;
+	return null;
+}
+/** React's form state after a `useActionState` form post, if the page carries one. */
+function readFormState(document) {
+	const script = document.querySelector(`script[type="${FORM_STATE_SCRIPT_TYPE}"]`);
+	if (!script) return void 0;
+	try {
+		return decode(JSON.parse(script.textContent || "null"));
+	} catch {
+		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) => {
+			const next = revive(entry, container);
+			if (next !== entry) changed = true;
+			return next;
+		});
+		return changed ? revived : value;
+	}
+	const object = value;
+	const tag = getTag(object);
+	if (tag === "a" && typeof object["v"] === "string") {
+		const token = object["b"];
+		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) {
+			html = slot.innerHTML;
+			break;
+		}
+		return React.createElement(SLOT_ELEMENT, {
+			key: name,
+			name,
+			style: { display: "contents" },
+			suppressHydrationWarning: true,
+			dangerouslySetInnerHTML: { __html: html }
+		});
+	}
+	if (tag === "r") throw new Error(`islx value ${String(object["v"])} was not resolved`);
+	if (tag !== void 0) {
+		const decoded = decodeTagged(object, (child) => revive(child, container));
+		if (decoded !== NOT_A_VALUE) return decoded;
+	}
+	let changed = false;
+	const revived = {};
+	for (const [key, entry] of Object.entries(object)) {
+		const next = revive(entry, container);
+		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();
+	const pending = /* @__PURE__ */ new Map();
+	const values = options.values ?? getValueStore();
+	const schedule = options.schedule;
+	const report = options.report ?? ((message, error) => console.error(`[islx] ${message}`, error));
+	let formState;
+	let formStateRead = false;
+	const fail = (container, src, exportName, serverHTML, error) => {
+		report(`Could not hydrate ${exportName} (${src}). Its server HTML was restored.`, error);
+		emit("islandError", {
+			element: container,
+			src,
+			export: exportName,
+			error
+		});
+		queueMicrotask(() => {
+			try {
+				roots.get(container)?.root.unmount();
+			} catch {}
+			roots.delete(container);
+			container.removeAttribute(HYDRATED_ATTRIBUTE);
+			container.innerHTML = serverHTML;
+		});
+	};
+	class Boundary extends React.Component {
+		state = { failed: false };
+		static getDerivedStateFromError() {
+			return { failed: true };
+		}
+		componentDidCatch(error) {
+			this.props.onError(error);
+		}
+		render() {
+			return this.state.failed ? null : this.props.children;
+		}
+	}
+	/** Calls `onCommit` once, when React first commits the island: it is interactive then. */
+	function Committed({ onCommit, children }) {
+		const called = React.useRef(false);
+		React.useLayoutEffect(() => {
+			if (called.current || !onCommit) return;
+			called.current = true;
+			onCommit();
+		}, [onCommit]);
+		return children;
+	}
+	const element = (Component, props, restore, onCommit) => {
+		const { graph } = getContexts();
+		const inner = React.createElement(Component, props);
+		return React.createElement(graph.Provider, { value: true }, React.createElement(Boundary, { onError: restore }, React.createElement(Committed, {
+			onCommit,
+			children: options.wrap ? options.wrap(inner) : inner
+		})));
+	};
+	/** An island's props, with values, slots and actions revived. */
+	function readProps(container, id) {
+		const script = findPropsScript(container, id);
+		if (!script) throw new Error(`props ${id} were not found`);
+		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);
+		}
+		return revive(parsed, container);
+	}
+	const topLevel = (scope) => Array.from(scope.querySelectorAll(ISLAND_SELECTOR)).filter((container) => !container.parentElement?.closest(ISLAND_SELECTOR));
+	const keyOf = (container) => `${container.getAttribute("src")}#${container.getAttribute("export") || "default"}`;
+	/** Hydrates the islands under `scope` that are not hydrated or scheduled yet. */
+	async function hydrate(scope = document, signal) {
+		if (!formStateRead) {
+			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) && !container.closest(STREAM_STAGING));
+		await Promise.all(islands.map(async (container) => {
+			const src = container.getAttribute("src");
+			const id = container.getAttribute("props");
+			const exportName = container.getAttribute("export") || "default";
+			const strategy = container.getAttribute("strategy") ?? "load";
+			if (!src || !id) {
+				report("An island is missing its src or props id.");
+				return;
+			}
+			const controller = new AbortController();
+			pending.set(container, controller);
+			const release = () => {
+				if (pending.get(container) === controller) pending.delete(container);
+			};
+			controller.signal.addEventListener("abort", release, { once: true });
+			const abort = () => controller.abort();
+			if (signal?.aborted) abort();
+			else signal?.addEventListener("abort", abort, { once: true });
+			const cleanup = () => {
+				signal?.removeEventListener("abort", abort);
+				release();
+			};
+			let scheduled;
+			try {
+				const scheduledAt = performance.now();
+				scheduled = schedule({
+					container,
+					strategy,
+					signal: controller.signal,
+					hydrate: async () => {
+						if (controller.signal.aborted || !container.isConnected) return;
+						const serverHTML = container.innerHTML;
+						try {
+							const module = await options.load(src);
+							if (controller.signal.aborted || !container.isConnected) return;
+							const Component = module[exportName];
+							if (typeof Component !== "function" && (typeof Component !== "object" || Component === null)) throw new Error(`${src} has no export ${exportName}`);
+							const props = readProps(container, id);
+							let failure;
+							const restore = (error) => {
+								if (failure !== void 0) return;
+								failure = error;
+								fail(container, src, exportName, serverHTML, error);
+								controller.abort();
+							};
+							let disposing = false;
+							const onCommit = () => emit("hydrate", {
+								element: container,
+								src,
+								export: exportName,
+								strategy,
+								duration: performance.now() - scheduledAt
+							});
+							const root = hydrateRoot(container, element(Component, props, restore, onCommit), {
+								formState,
+								onUncaughtError: restore,
+								onRecoverableError(error) {
+									if (disposing && isEarlyUpdate(error)) return;
+									if (typeof globalThis.reportError === "function") globalThis.reportError(error);
+									else console.error(error);
+								}
+							});
+							roots.set(container, {
+								root,
+								Component,
+								src,
+								exportName,
+								props,
+								serverHTML,
+								restore,
+								dispose() {
+									disposing = true;
+									try {
+										root.unmount();
+									} finally {
+										disposing = false;
+									}
+								}
+							});
+						} catch (error) {
+							if (controller.signal.aborted) return;
+							fail(container, src, exportName, serverHTML, error);
+							controller.abort();
+						}
+					}
+				});
+			} catch (error) {
+				fail(container, src, exportName, container.innerHTML, error);
+				controller.abort();
+				cleanup();
+				return;
+			}
+			const tracked = Promise.resolve(scheduled).catch((error) => {
+				if (!controller.signal.aborted) {
+					fail(container, src, exportName, container.innerHTML, error);
+					controller.abort();
+				}
+			}).finally(cleanup);
+			if (strategy === "load") await tracked;
+		}));
+	}
+	/**
+	* Keeps the live islands of `current` when the same page renders again (after an action, or
+	* a refresh): each island of `next` that renders the same component at the same position takes
+	* over the live root with its new props, so its state survives. Call it before replacing
+	* `current`; islands it does not carry over hydrate from `next` as usual.
+	*/
+	function carryOver(current, next) {
+		const live = /* @__PURE__ */ new Map();
+		for (const container of topLevel(current)) {
+			if (!roots.has(container)) continue;
+			const key = keyOf(container);
+			live.set(key, [...live.get(key) ?? [], container]);
+		}
+		let carried = 0;
+		for (const container of topLevel(next)) {
+			const previous = live.get(keyOf(container))?.shift();
+			const record = previous && roots.get(previous);
+			const id = container.getAttribute("props");
+			if (!previous || !record || !id) continue;
+			try {
+				const props = readProps(container, id);
+				record.root.render(element(record.Component, props, record.restore));
+				record.props = props;
+				container.replaceWith(previous);
+				carried++;
+			} catch (error) {
+				report(`Could not keep ${keyOf(container)} across the refresh.`, error);
+			}
+		}
+		return carried;
+	}
+	/** Re-renders the islands and server trees of a module that changed (hot module replacement). */
+	function update(src, module) {
+		let updated = updateServerTrees(src, module);
+		for (const [container, record] of roots) {
+			if (record.src !== src) continue;
+			const Component = module[record.exportName];
+			if (typeof Component !== "function" && (typeof Component !== "object" || Component === null)) {
+				fail(container, record.src, record.exportName, record.serverHTML, /* @__PURE__ */ new Error("the updated module lost the export"));
+				continue;
+			}
+			record.Component = Component;
+			record.root.render(element(record.Component, record.props, record.restore));
+			updated++;
+		}
+		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();
+			pending.delete(container);
+		}
+		for (const [container, record] of roots) if (container === scope || scope.contains(container)) {
+			try {
+				record.dispose();
+			} catch {}
+			roots.delete(container);
+			container.removeAttribute(HYDRATED_ATTRIBUTE);
+		}
+	}
+	return {
+		hydrate,
+		carryOver,
+		update,
+		dispose,
+		rootCount: () => roots.size
+	};
+}
+/**
+* A page a hydrating layout keeps as server HTML (and a server tree's `<f-html>` part). React owns
+* only the wrapper, so the islands inside start after React commits that HTML and stop when it is
+* replaced or the layout unmounts. The islands are captured when they start, because React has
+* already swapped the HTML by the time the cleanup runs.
+*/
+function createServerHtml(runtime) {
+	return function ServerHtml({ as = "div", ...props }) {
+		const ref = React.useRef(null);
+		const html = props.dangerouslySetInnerHTML.__html;
+		React.useLayoutEffect(() => {
+			const page = ref.current;
+			if (!page) return;
+			const islands = Array.from(page.querySelectorAll(ISLAND_SELECTOR));
+			if (islands.length === 0) return;
+			const controller = new AbortController();
+			runtime.hydrate(page, controller.signal).catch((error) => {
+				console.error("[islx] Could not hydrate the islands in this part of the page:", error);
+			});
+			return () => {
+				controller.abort();
+				queueMicrotask(() => {
+					for (const island of islands) runtime.dispose(island);
+				});
+			};
+		}, [html]);
+		return React.createElement(as, {
+			...props,
+			ref
+		});
+	};
+}
+// src/react/document.ts
+/**
+* Putting a fetched page in place without a router. After an action, the current page renders
+* again and its live islands keep their state; after a navigation, the next page's islands
+* start fresh, as a page change does. The runtime, its loaded code and its values stay in both.
+* Frameworks with a router do this through it instead.
+*/
+/** Fetches the current page and puts its new content in place, keeping island state. */
+async function refreshDocument(runtime) {
+	const response = await fetch(location.href, {
+		headers: {
+			accept: "text/html",
+			...valueHeaders()
+		},
+		credentials: "same-origin"
+	});
+	if (!response.ok || !response.headers.get("content-type")?.includes("text/html")) {
+		location.reload();
+		return;
+	}
+	const next = new DOMParser().parseFromString(await response.text(), "text/html");
+	if (next.title) document.title = next.title;
+	const body = document.importNode(next.body, true);
+	runtime.carryOver(document.body, body);
+	runtime.dispose(document.body);
+	document.body.replaceChildren(...Array.from(body.childNodes));
+	await runtime.hydrate(document);
+}
+/** Puts another page's body in place of this one's, and hydrates its islands. */
+async function swapDocument(runtime, next) {
+	const body = document.importNode(next.body, true);
+	runtime.dispose(document.body);
+	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 };

package/dist/react/server.d.mts

@@ -0,0 +1,51 @@
+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 React from "react";
+import { RenderToReadableStreamOptions } from "react-dom/server";
+
+// src/react/server.d.ts
+
+interface RenderToStreamOptions extends Omit<RenderToReadableStreamOptions, "formState"> {
+  /**
+   * The request being answered: its `F-Values` header names the values the browser holds, and
+   * the page leaves them out. Leave it out for a response that may be shared (a CDN, a static
+   * page): every value is sent.
+   */
+  request?: Request;
+  /**
+   * The form state `handleAction` passed to `renderFormState`, after a form posted from a
+   * `useActionState` hook. The page shows the action's result, and so do its islands once they
+   * hydrate.
+   */
+  formState?: ReactFormState | null;
+  /**
+   * Adds the browser entry that hydrates islands (from the bundler plugin) to the page. Default
+   * true; a framework that adds its own scripts turns it off.
+   */
+  bootstrap?: boolean;
+  /**
+   * Adds the inline script that holds a click or a submit on an island before the browser entry
+   * has run, to replay it once the island hydrates. Default: with the browser entry.
+   */
+  prehydration?: boolean;
+}
+/**
+ * Renders a page whose client components are islands. A response rendered with a `request` whose
+ * browser holds values is that browser's alone: send it `private` and never share it.
+ *
+ * A navigation (`F-Render` on the request) gets the whole page in one piece: the browser puts it
+ * in place with DOM methods, which run no scripts, so the page cannot stream in with React's
+ * inline scripts. Every Suspense boundary has resolved before the first byte.
+ */
+declare function renderToStream(element: React.ReactNode, {
+  request,
+  formState,
+  bootstrap,
+  prehydration,
+  ...options
+}?: RenderToStreamOptions): Promise<ReadableStream<Uint8Array> & {
+  allReady: Promise<void>;
+}>;
+/** 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 };

package/dist/react/server.mjs

@@ -0,0 +1,84 @@
+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-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-BDB5VEao.mjs";
+import * as React from "react";
+// src/react/server.ts
+/**
+* @farm.js/islx/react/server: rendering a React page with islands. Importing it gives islands the
+* server code they need (values, action references); `renderToStream` renders a page.
+*/
+setIslandServerHook({
+	encode(props, held) {
+		const addressed = addressValues(props, { encodeSpecial: (value) => {
+			if (value && typeof value === "object" && runtimeTagged.has(value)) return value;
+			if (typeof value === "function") {
+				const reference = encodeActionReference(value);
+				if (reference) return reference;
+				const name = value.name;
+				throw new TypeError(`functions are not serializable${name ? ` (${name})` : ""}: pass a server action, or move the function into the client component`);
+			}
+		} });
+		return {
+			json: addressed.json,
+			values: selectValuesToSend(addressed, held).map(({ key, json }) => ({
+				key,
+				json
+			}))
+		};
+	},
+	escape: escapeScriptJson,
+	address(payload, skip) {
+		const addressed = addressValues(payload, { encoded: true });
+		return {
+			json: addressed.json,
+			values: selectValuesToSend(addressed, skip).map(({ key, json }) => ({
+				key,
+				json
+			}))
+		};
+	},
+	action: (value) => encodeActionReference(value)
+});
+/** The script carrying a form post's state to the browser, for `hydrateRoot`. */
+function FormStateScript({ formState }) {
+	return React.createElement("script", {
+		type: FORM_STATE_SCRIPT_TYPE,
+		dangerouslySetInnerHTML: { __html: escapeScriptJson(JSON.stringify(encode(formState))) }
+	});
+}
+/**
+* Renders a page whose client components are islands. A response rendered with a `request` whose
+* browser holds values is that browser's alone: send it `private` and never share it.
+*
+* A navigation (`F-Render` on the request) gets the whole page in one piece: the browser puts it
+* in place with DOM methods, which run no scripts, so the page cannot stream in with React's
+* inline scripts. Every Suspense boundary has resolved before the first byte.
+*/
+async function renderToStream(element, { request, formState, bootstrap = true, prehydration, ...options } = {}) {
+	const held = request ? parseHeldValues(request) : null;
+	const { render } = getContexts();
+	const tree = React.createElement(render.Provider, { value: {
+		held: held && held.size > 0 ? held : null,
+		sent: /* @__PURE__ */ new Set()
+	} }, element, formState ? React.createElement(FormStateScript, { formState }) : null);
+	const entry = bootstrap ? getBuildDefaults().entry : void 0;
+	const bootstrapModules = entry ? [...options.bootstrapModules ?? [], entry] : options.bootstrapModules;
+	const bootstrapScriptContent = prehydration ?? entry !== void 0 ? `${PREHYDRATION_SCRIPT}${options.bootstrapScriptContent ?? ""}` : options.bootstrapScriptContent;
+	const { renderToReadableStream } = await import("react-dom/server");
+	const stream = await renderToReadableStream(tree, {
+		...options,
+		bootstrapModules,
+		bootstrapScriptContent,
+		formState
+	});
+	if (request?.headers.has("F-Render")) await stream.allReady;
+	return stream;
+}
+/** Whether a response rendered for `request` leaves out values its browser holds. */
+function isPersonalized(request) {
+	return parseHeldValues(request).size > 0;
+}
+export { IslandsProvider, PAYLOAD_ONLY_ATTRIBUTE, createIsland, getClientReference, isPersonalized, isolateIslands, renderServerTree, renderToStream, setRenderStateResolver, withinClientRoot };

package/dist/react.d.mts

@@ -0,0 +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 { n as IslandStrategy } from "./_chunks/schedule-Dw14dW0H.mjs";
+export { type IslandRenderState, type IslandStrategy, IslandsProvider, type ServerTreeRenderOptions, createIsland, isolateIslands, renderServerTree, withinClientRoot };

package/dist/react.mjs

@@ -0,0 +1 @@
+export { a as IslandsProvider, o as createIsland, l as isolateIslands, r as renderServerTree, p as withinClientRoot } from "./_chunks/tree-BDB5VEao.mjs";