@farm.js/islx 0.0.3 → 0.0.5

package/dist/_chunks/vite-DG7hBn8A.mjs

@@ -0,0 +1,503 @@
+import { i as transformActions, r as hasModuleDirective, t as ActionCompileError } from "./actions-Eutk6UzT.mjs";
+import { t as ISLAND_STRATEGIES } from "./schedule-CjoybS3b.mjs";
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+import { walk } from "estree-walker";
+import MagicString from "magic-string";
+import { analyze } from "periscopic";
+import { readFile, readdir, writeFile } from "node:fs/promises";
+// src/compiler/client.ts
+/**
+* The `"use client"` compiler. In the server build, every component a `"use client"` module
+* exports renders as an island: its server HTML, and its props for the browser. The browser build
+* keeps the module as it is.
+*
+* A component is an export named in PascalCase (`Chart`, not `COLORS` or `useChart`) that is not
+* a literal value, or the default export. Other exports (hooks, constants, helpers) stay as they
+* are on both sides.
+*
+* When an island hydrates comes from the module's `hydrate` export:
+*
+*   export const hydrate = "visible";                        // every component in the file
+*   export const hydrate = { Chart: "visible", Legend: "idle" };  // per component; others "load"
+*/
+const FUNCTION_TYPES = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+function isComponentName(name) {
+	return /^[A-Z]/.test(name) && /[a-z]/.test(name);
+}
+const VALUE_TYPES = /* @__PURE__ */ new Set([
+	"Literal",
+	"ArrayExpression",
+	"ObjectExpression",
+	"TemplateLiteral",
+	"UnaryExpression",
+	"BinaryExpression"
+]);
+/** Reads the `hydrate` export: a strategy for every component, or one per component. */
+function readStrategies(program, fail) {
+	const byName = /* @__PURE__ */ new Map();
+	const check = (value, node) => {
+		if (typeof value !== "string" || !ISLAND_STRATEGIES.includes(value)) fail(`hydrate must be one of ${ISLAND_STRATEGIES.map((s) => `"${s}"`).join(", ")}`, node);
+		return value;
+	};
+	for (const node of program.body ?? []) {
+		if (node.type !== "ExportNamedDeclaration" || node.declaration?.type !== "VariableDeclaration") continue;
+		for (const declarator of node.declaration.declarations ?? []) {
+			if (declarator.id?.type !== "Identifier" || declarator.id.name !== "hydrate") continue;
+			let init = declarator.init;
+			while (init && (init.type === "TSAsExpression" || init.type === "TSSatisfiesExpression")) init = init.expression;
+			if (init?.type === "Literal") return {
+				all: check(init.value, init),
+				byName
+			};
+			if (init?.type === "ObjectExpression") {
+				for (const property of init.properties ?? []) {
+					const key = property.key?.type === "Identifier" ? property.key.name : property.key?.value;
+					if (property.type !== "Property" || property.computed || typeof key !== "string" || property.value?.type !== "Literal") fail("hydrate must be a string, or an object of strings: { Chart: \"visible\" }", property);
+					byName.set(key, check(property.value.value, property.value));
+				}
+				return { byName };
+			}
+			fail("hydrate must be written as a literal: \"visible\", or { Chart: \"visible\" }", declarator);
+		}
+	}
+	return { byName };
+}
+/** Wraps a `"use client"` module's components as islands, or returns null for any other module. */
+function transformClientModule(options) {
+	const { code, id, root } = options;
+	if (!hasModuleDirective(code, options.directive ?? "use client")) return null;
+	const file = id.split("?", 1)[0];
+	const relative = path.relative(root, file).split(path.sep).join("/");
+	const program = options.parse(code);
+	const fail = (message, node) => {
+		throw new ActionCompileError(message, file, code, node.start);
+	};
+	const strategies = readStrategies(program, fail);
+	const strategyOf = (name) => {
+		const configured = options.strategy?.(name);
+		if (configured !== void 0 && !ISLAND_STRATEGIES.includes(configured)) throw new Error(`islx: strategy for ${name} must be one of ${ISLAND_STRATEGIES.join(", ")}`);
+		return configured ?? strategies.byName.get(name) ?? strategies.all ?? "load";
+	};
+	const output = new MagicString(code);
+	const wrapped = [];
+	for (const node of program.body ?? []) if (node.type === "ExportNamedDeclaration" && !node.source && node.exportKind !== "type") {
+		const declaration = node.declaration;
+		if (declaration) {
+			const names = declaration.type === "VariableDeclaration" ? declaration.declarations.flatMap((d) => d.id?.type === "Identifier" && !(d.init && VALUE_TYPES.has(d.init.type)) ? [d.id.name] : []) : declaration.id?.name ? [declaration.id.name] : [];
+			const declared = declaration.type === "VariableDeclaration" ? declaration.declarations.length : names.length;
+			const components = names.filter(isComponentName);
+			if (components.length === 0 || String(declaration.type).startsWith("TS")) continue;
+			if (components.length !== declared) fail("Export components and other values in separate statements", declaration);
+			output.remove(node.start, declaration.start);
+			for (const name of components) wrapped.push({
+				local: name,
+				exportName: name
+			});
+			continue;
+		}
+		const kept = [];
+		for (const specifier of node.specifiers ?? []) {
+			const exported = specifier.exported?.name ?? specifier.exported?.value;
+			const local = specifier.local?.name ?? specifier.local?.value;
+			if (specifier.exportKind !== "type" && (isComponentName(exported) || exported === "default")) wrapped.push({
+				local,
+				exportName: exported
+			});
+			else kept.push(output.slice(specifier.start, specifier.end));
+		}
+		output.overwrite(node.start, node.end, kept.length > 0 ? `export { ${kept.join(", ")} };` : "");
+	} else if (node.type === "ExportDefaultDeclaration") {
+		const declaration = node.declaration;
+		if (FUNCTION_TYPES.has(declaration.type) || declaration.type === "ClassDeclaration" || declaration.type === "ClassExpression") {
+			if (declaration.id?.name) {
+				output.remove(node.start, declaration.start);
+				wrapped.push({
+					local: declaration.id.name,
+					exportName: "default"
+				});
+			} else {
+				output.overwrite(node.start, declaration.start, "const $$islx_default = ");
+				wrapped.push({
+					local: "$$islx_default",
+					exportName: "default"
+				});
+			}
+		} else if (declaration.type === "Identifier" || declaration.type.endsWith("Expression")) {
+			output.overwrite(node.start, declaration.start, "const $$islx_default = ");
+			if (!code.slice(declaration.end, node.end).includes(";")) output.appendLeft(declaration.end, ";");
+			wrapped.push({
+				local: "$$islx_default",
+				exportName: "default"
+			});
+		}
+	}
+	if (wrapped.length === 0) return null;
+	const runtime = options.runtime ?? "@farm.js/islx/react";
+	const src = options.reference(relative);
+	const lines = [...wrapped.map(({ local, exportName }, index) => {
+		return `const $$islx_island_${index} = $$islx_island(${local}, ${src}, ${JSON.stringify(exportName)}, ${JSON.stringify(strategyOf(exportName === "default" ? "default" : exportName))});`;
+	}), `export { ${wrapped.map(({ exportName }, index) => `$$islx_island_${index} as ${exportName}`).join(", ")} };`];
+	const imports = [`import { createIsland as $$islx_island } from ${JSON.stringify(runtime)};`, ...(options.sideEffects ?? []).map((module) => `import ${JSON.stringify(module)};`)];
+	output.prepend(`${imports.join("\n")}\n`);
+	output.append(`\n${lines.join("\n")}\n`);
+	return {
+		code: output.toString(),
+		map: output.generateMap({
+			hires: true,
+			source: file
+		}),
+		islands: wrapped.map(({ exportName }) => ({
+			exportName,
+			strategy: strategyOf(exportName)
+		}))
+	};
+}
+// src/vite.ts
+/**
+* @farm.js/islx/vite: islx for Vite 6 and later (the Environment API).
+*
+*   import react from "@vitejs/plugin-react";
+*   import { islx } from "@farm.js/islx/vite";
+*   export default defineConfig({ plugins: [react(), islx()] });
+*
+* - Server environments: `"use client"` components render as islands, `"use server"` exports
+*   and inline actions register.
+* - The client environment: `"use server"` modules become references; inline actions are
+*   refused; the browser entry hydrates islands.
+* - `vite build` builds the server first, which finds the client components pages use, then the
+*   browser with exactly those (plus `clientComponents.include`), each in a chunk of its own that
+*   the browser entry imports when an island needs it. An island names its module by its path
+*   from the root; the server build learns the entry's URL once the browser build has named it.
+*/
+const RUNTIME_ID = "virtual:islx/runtime";
+/** @internal The browser entry, for a framework whose own entry imports it. */
+const ENTRY_ID = "virtual:islx/client-entry";
+const CLIENT_HOOKS_ID = "virtual:islx/hooks-client";
+const SERVER_HOOKS_ID = "virtual:islx/hooks-server";
+const BROWSER_GLOBALS = /* @__PURE__ */ new Set([
+	"window",
+	"document",
+	"location",
+	"history",
+	"navigator",
+	"screen",
+	"localStorage",
+	"sessionStorage",
+	"alert",
+	"confirm",
+	"prompt",
+	"requestAnimationFrame",
+	"cancelAnimationFrame",
+	"requestIdleCallback",
+	"cancelIdleCallback",
+	"IntersectionObserver",
+	"MutationObserver",
+	"ResizeObserver",
+	"HTMLElement",
+	"Element",
+	"Node",
+	"CustomEvent",
+	"Event",
+	"matchMedia",
+	"getComputedStyle",
+	"innerWidth",
+	"innerHeight",
+	"scrollX",
+	"scrollY",
+	"self"
+]);
+/**
+* The source of a hooks module made from callbacks. Each callback is copied as written, so it
+* must not use anything from where it was written: an outside variable, an import.
+*/
+function serializeHooks(hooks, where, parse) {
+	const entries = [];
+	for (const [name, value] of Object.entries(hooks)) {
+		if (value === void 0) continue;
+		if (typeof value !== "function") throw new Error(`islx: hooks.${where}.${name} must be a function`);
+		const source = Function.prototype.toString.call(value);
+		if (source.includes("[native code]")) throw new Error(`islx: hooks.${where}.${name} must be written in the config, not a built-in or bound function`);
+		const expression = parse("hook.js", `(${source});`).errors.length === 0;
+		entries.push(expression ? `${JSON.stringify(name)}: ${source}` : source);
+	}
+	const code = `export default {\n${entries.join(",\n")}\n};\n`;
+	const program = parse("hooks.js", code);
+	const { globals } = analyze(program);
+	const outside = [...globals.keys()].filter((name) => where === "client" ? !(name in globalThis) && !BROWSER_GLOBALS.has(name) : BROWSER_GLOBALS.has(name) || !(name in globalThis));
+	let imports = false;
+	walk(program, { enter(node) {
+		if (node.type === "ImportExpression") imports = true;
+	} });
+	if (outside.length > 0 || imports) {
+		const what = imports ? "`import()`" : outside.map((name) => `\`${name}\``).join(", ");
+		throw new Error(`islx: hooks.${where} uses ${what}, which does not exist where the hook runs: hooks written in the config are copied into the ${where === "client" ? "browser" : "server"} build as source. Use a global${where === "client" ? " (window.analytics)" : ""}, or put the hooks in a module and pass its path: hooks: { ${where}: "./src/islx.${where}.ts" }.`);
+	}
+	return code;
+}
+/** Stand for the browser entry's URL, and the files each client module needs, in the server
+* build until the browser build names them. */
+const ENTRY_PLACEHOLDER = "__islx_client_entry_url__";
+const MODULES_PLACEHOLDER = "__islx_client_modules__";
+const SCRIPT = /\.[cm]?[jt]sx?$/;
+async function createParser() {
+	const withErrors = (result) => Object.assign(result.program, { errors: result.errors ?? [] });
+	const vite = await import("vite");
+	if (typeof vite.parseSync === "function") return (file, code) => withErrors(vite.parseSync(file, code));
+	try {
+		const oxc = await import("oxc-parser");
+		return (file, code) => withErrors(oxc.parseSync(file, code));
+	} catch {
+		throw new Error("@farm.js/islx/vite needs Vite 8, or oxc-parser installed with an older Vite");
+	}
+}
+/** A tiny glob matcher: `**`, `*` and `?`, on paths from the root. */
+function globToRegExp(glob) {
+	let pattern = "";
+	for (let index = 0; index < glob.length; index++) {
+		const char = glob[index];
+		if (char === "*" && glob[index + 1] === "*") {
+			pattern += glob[index + 2] === "/" ? "(?:.*/)?" : ".*";
+			index += glob[index + 2] === "/" ? 2 : 1;
+		} else if (char === "*") pattern += "[^/]*";
+		else if (char === "?") pattern += "[^/]";
+		else pattern += char.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+	}
+	return new RegExp(`^${pattern.replace(/^\.\//, "")}$`);
+}
+async function listFiles(root, directory = root) {
+	const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+	const files = [];
+	for (const entry of entries) {
+		if (entry.name === "node_modules" || entry.name.startsWith(".") || entry.name === "dist") continue;
+		const full = path.join(directory, entry.name);
+		if (entry.isDirectory()) files.push(...await listFiles(root, full));
+		else if (SCRIPT.test(entry.name)) files.push(full);
+	}
+	return files;
+}
+async function listOutput(directory) {
+	const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+	const files = [];
+	for (const entry of entries) {
+		const full = path.join(directory, entry.name);
+		if (entry.isDirectory()) files.push(...await listOutput(full));
+		else if (/\.[cm]?js$/.test(entry.name)) files.push(full);
+	}
+	return files;
+}
+const toPosix = (value) => value.split(path.sep).join("/");
+const RESERVED_DIRECTIVES = /* @__PURE__ */ new Set(["use strict", "use asm"]);
+/** The directives to use, refusing ones that would make a file mean two things. */
+function resolveDirectives(directives = {}) {
+	const client = directives.client ?? "use client";
+	const server = directives.server ?? "use server";
+	for (const [kind, value] of [["client", client], ["server", server]]) if (typeof value !== "string" || !/^[\w-]+( [\w-]+)*$/.test(value) || RESERVED_DIRECTIVES.has(value)) throw new Error(`islx: directives.${kind} must be a plain directive such as "use island", not ${JSON.stringify(value)}`);
+	if (client === server) throw new Error(`islx: directives.client and directives.server are both ${JSON.stringify(client)}`);
+	return {
+		client,
+		server
+	};
+}
+function islx(options = {}, host = {}) {
+	const directives = resolveDirectives(options.directives);
+	let config;
+	let parse;
+	let preamble = false;
+	const include = (options.clientComponents?.include ?? []).map(globToRegExp);
+	const exclude = (options.clientComponents?.exclude ?? []).map(globToRegExp);
+	/** Client modules the server build rendered, by path from the root. */
+	const discovered = /* @__PURE__ */ new Set();
+	/** The browser entry's URL, once the browser build named it. */
+	let entryUrl;
+	/** The files each client module needs, once the browser build named them. */
+	const moduleFiles = {};
+	/** Whether the browser build ran first (a framework that orders the build). */
+	let clientBuilt = false;
+	const buildKey = randomBytes(32).toString("base64url");
+	const isServer = (name) => options.serverEnvironments ? options.serverEnvironments.includes(name) : name !== "client";
+	const relativeOf = (id) => toPosix(path.relative(config.root, id.split("?", 1)[0]));
+	const excluded = (relative) => exclude.some((pattern) => pattern.test(relative));
+	const isBuild = () => config.command === "build";
+	const clientInputs = async () => {
+		const inputs = new Set(discovered);
+		if (include.length > 0) for (const file of await listFiles(config.root)) {
+			const relative = relativeOf(file);
+			if (!include.some((pattern) => pattern.test(relative)) || excluded(relative)) continue;
+			if ((await readFile(file, "utf8")).includes("use client")) inputs.add(relative);
+		}
+		return [...inputs].sort();
+	};
+	return [
+		{
+			name: "islx",
+			enforce: "pre",
+			sharedDuringBuild: true,
+			config(user) {
+				const clientBuild = user.environments?.client?.build;
+				const input = clientBuild?.rollupOptions?.input;
+				return {
+					builder: user.builder ?? {},
+					environments: { client: {
+						optimizeDeps: { include: [
+							"react",
+							"react/jsx-runtime",
+							"react/jsx-dev-runtime",
+							"react-dom",
+							"react-dom/client"
+						] },
+						build: {
+							outDir: clientBuild?.outDir ?? "dist/client",
+							rollupOptions: { input: host.frameworkEntry ? input : {
+								...typeof input === "string" ? { index: input } : Array.isArray(input) ? Object.fromEntries(input.map((entry, index) => [`input${index}`, entry])) : input,
+								"islx-entry": ENTRY_ID
+							} }
+						}
+					} }
+				};
+			},
+			async configResolved(resolved) {
+				config = resolved;
+				parse = await createParser();
+				preamble = resolved.plugins.some((plugin) => plugin.name === "vite:react-virtual-preamble");
+			},
+			resolveId(id) {
+				if (id === RUNTIME_ID || id === "virtual:islx/client-entry" || id === CLIENT_HOOKS_ID || id === SERVER_HOOKS_ID) return `\0${id}`;
+			},
+			async load(id) {
+				if (id === `\0${RUNTIME_ID}`) {
+					const entry = host.frameworkEntry ? void 0 : !isBuild() ? `${config.base}@id/__x00__${ENTRY_ID}` : clientBuilt ? entryUrl : ENTRY_PLACEHOLDER;
+					const modules = !isBuild() ? "{}" : clientBuilt ? JSON.stringify(moduleFiles) : `JSON.parse(${JSON.stringify(MODULES_PLACEHOLDER)})`;
+					return [
+						...host.frameworkRender ? [`import "@farm.js/islx/react/server";`] : [],
+						`import { setBuildDefaults, setServerHooks } from "@farm.js/islx/server";`,
+						`import hooks from ${JSON.stringify(SERVER_HOOKS_ID)};`,
+						`setBuildDefaults({ entry: ${JSON.stringify(entry)}, key: ${JSON.stringify(buildKey)}, modules: ${modules} });`,
+						`setServerHooks(hooks);`
+					].join("\n");
+				}
+				if (id === `\0${CLIENT_HOOKS_ID}` || id === `\0${SERVER_HOOKS_ID}`) {
+					const where = id === `\0${CLIENT_HOOKS_ID}` ? "client" : "server";
+					const hooks = options.hooks?.[where];
+					if (hooks === void 0) return "export default undefined;";
+					if (typeof hooks === "string") return `export { default } from ${JSON.stringify(path.resolve(config.root, hooks))};`;
+					return serializeHooks(hooks, where, parse);
+				}
+				if (id === `\0virtual:islx/client-entry`) {
+					const load = isBuild() ? `const modules = {\n${(await clientInputs()).map((relative) => `  ${JSON.stringify(relative)}: () => import(${JSON.stringify(path.resolve(config.root, relative))}),`).join("\n")}\n};\nconst load = (src) => modules[src] ? modules[src]() : Promise.reject(new Error("islx: no client module " + src));` : `const root = new URL(${JSON.stringify(`file://${toPosix(config.root)}/`)});\nconst load = (src) => import(/* @vite-ignore */ src.startsWith("../") ? "/@fs" + new URL(src, root).pathname : ${JSON.stringify(config.base)} + src);`;
+					return [
+						...preamble && !isBuild() ? [`import "@vitejs/plugin-react/preamble";`] : [],
+						`import { createHydrationRuntime, refreshDocument, scheduleHydration, swapDocument } from "@farm.js/islx/react/client";`,
+						`import { enhanceForms, setActionNavigator, setClientHooks, startNavigation, navigate } from "@farm.js/islx/client";`,
+						`import hooks from ${JSON.stringify(CLIENT_HOOKS_ID)};`,
+						`setClientHooks(hooks);`,
+						load,
+						`const runtime = createHydrationRuntime({ load, schedule: scheduleHydration });`,
+						`setActionNavigator({ refresh: () => refreshDocument(runtime), navigate: (href) => navigate(href) });`,
+						`enhanceForms();`,
+						...options.navigation === false ? [] : [`startNavigation({ swap: (next) => swapDocument(runtime, next), viewTransition: ${typeof options.navigation === "object" && options.navigation.viewTransition === true} });`],
+						`runtime.hydrate(document);`,
+						`export { runtime };`
+					].join("\n");
+				}
+			},
+			transform(code, id) {
+				if (id.startsWith("\0") || !SCRIPT.test(id.split("?", 1)[0])) return null;
+				const library = id.includes("/node_modules/");
+				const clientDirective = library ? "use client" : directives.client;
+				if (!code.includes(clientDirective) && (library || !code.includes(directives.server))) return null;
+				const file = id.split("?", 1)[0];
+				const server = isServer(this.environment.name);
+				const relative = relativeOf(file);
+				const parseFile = (source) => parse(file, source);
+				if (server && !excluded(relative)) {
+					const island = transformClientModule({
+						code,
+						id: file,
+						root: config.root,
+						parse: parseFile,
+						reference: (relative) => {
+							discovered.add(relative);
+							return JSON.stringify(relative);
+						},
+						sideEffects: [RUNTIME_ID],
+						directive: clientDirective
+					});
+					if (island) {
+						if (!library) transformActions({
+							code,
+							id: file,
+							root: config.root,
+							environment: "client",
+							parse: parseFile,
+							directive: directives.server
+						});
+						return {
+							code: island.code,
+							map: island.map
+						};
+					}
+				}
+				if (library) return null;
+				const actions = transformActions({
+					code,
+					id: file,
+					root: config.root,
+					environment: server ? "server" : "client",
+					parse: parseFile,
+					directive: directives.server
+				});
+				if (!actions) return null;
+				return {
+					code: server ? `import ${JSON.stringify(RUNTIME_ID)};\n${actions.code}` : actions.code,
+					map: server ? null : actions.map
+				};
+			}
+		},
+		{
+			name: "islx:reload",
+			apply: "serve",
+			hotUpdate({ file, modules, server }) {
+				if (!isServer(this.environment.name) || modules.length === 0) return;
+				const client = server.environments.client;
+				if (client?.moduleGraph.getModulesByFile(file)?.size) return;
+				client?.hot.send({ type: "full-reload" });
+			}
+		},
+		{
+			name: "islx:build",
+			sharedDuringBuild: true,
+			async buildApp(builder) {
+				if (host.frameworkBuild) return;
+				const servers = Object.values(builder.environments).filter((environment) => isServer(environment.name));
+				for (const environment of servers) await builder.build(environment);
+				await builder.build(builder.environments.client);
+				if (!entryUrl) throw new Error("islx: the browser build did not emit the islx entry");
+				for (const environment of servers) {
+					const outDir = path.resolve(config.root, environment.config.build.outDir);
+					for (const file of await listOutput(outDir)) {
+						const source = await readFile(file, "utf8");
+						if (!source.includes(ENTRY_PLACEHOLDER) && !source.includes(MODULES_PLACEHOLDER)) continue;
+						const modules = JSON.stringify(JSON.stringify(moduleFiles)).slice(1, -1);
+						await writeFile(file, source.replaceAll(ENTRY_PLACEHOLDER, entryUrl).replaceAll(MODULES_PLACEHOLDER, modules));
+					}
+				}
+			},
+			generateBundle(_options, bundle) {
+				if (this.environment.name !== "client") return;
+				const url = (fileName) => `${config.base}${fileName}`;
+				for (const chunk of Object.values(bundle)) {
+					if (chunk.type !== "chunk" || !chunk.facadeModuleId) continue;
+					if (chunk.isEntry && chunk.facadeModuleId === `\0virtual:islx/client-entry`) entryUrl = url(chunk.fileName);
+					else if (chunk.isDynamicEntry && !chunk.facadeModuleId.startsWith("\0")) moduleFiles[relativeOf(chunk.facadeModuleId)] = [chunk.fileName, ...chunk.imports].map(url);
+				}
+				clientBuilt = true;
+			}
+		}
+	];
+}
+export { serializeHooks as i, islx as n, resolveDirectives as r, ENTRY_ID as t };

package/dist/_chunks/{wire-C3Rpbwl6.d.mts → wire-Dipqh-EB.d.mts}

@@ -24,6 +24,11 @@ declare const TREE_SCRIPT_TYPE = "f/tree";
 declare const CHUNK_SCRIPT_TYPE = "f/chunk";
 /** The element around server HTML inside a server tree. */
 declare const HTML_ELEMENT = "f-html";
+/**
+ * The script type of a promise's outcome, written when it settles: `{"v":value}`, or `{"e":1}` for
+ * a rejection. Its `name` attribute names the promise.
+ */
+declare const PROMISE_SCRIPT_TYPE = "f/promise";
 /** The script type of React's form state after a `useActionState` form post, for hydration. */
 declare const FORM_STATE_SCRIPT_TYPE = "f/form-state";
 /** The reserved JSON key whose value is a tag. */
@@ -38,6 +43,11 @@ declare const REFERENCE_TAG = "r";
 declare const SLOT_TAG = "s";
 /** `{"$":"a","v":id}` or `{"$":"a","v":id,"b":sealed}`: a server action. */
 declare const ACTION_TAG = "a";
+/**
+ * `{"$":"T","v":name}`: a promise an island receives, settled by the `f/promise` script `name`.
+ * (Inside a server tree, `{"$":"P","v":value}` is a promise that resolved already.)
+ */
+declare const PROMISE_TAG = "T";
 /** `{"$":"o","v":{…}}`: app data that has its own `$` key. */
 declare const OBJECT_TAG = "o";
 /** `{"$":"F","v":n}`: a `FormData` argument, sent as fields of a multipart call. */
@@ -95,4 +105,4 @@ declare const MAX_HELD_VALUES = 128;
  * `{"$":"a","v":id,"b":sealed}`), or undefined for anything else.
  */
 declare function getTag(value: unknown): string | undefined;
-export { VALUE_SCRIPT_TYPE as A, SLOT_TAG as C, TREE_SCRIPT_TYPE as D, TAG_VALUE as E, stripRuntimeFields as F, formFieldName as M, getTag as N, VALUES_HEADER as O, readPostedAction as P, SLOT_ELEMENT as S, TAG_BOUND as T, MAX_HELD_VALUES as _, BLOB_TAG as a, REFERENCE_TAG as b, CHUNK_SCRIPT_TYPE as c, FORM_REF_PREFIX as d, FORM_STATE_SCRIPT_TYPE as f, LAYOUTS_HEADER as g, ISLAND_ELEMENT as h, ACTION_TAG as i, attachmentField as j, VALUE_KEY_PATTERN as k, FORM_DATA_TAG as l, HYDRATED_ATTRIBUTE as m, ACTION_KEY_FIELD as n, BOUND_FIELD as o, HTML_ELEMENT as p, ACTION_STALE_HEADER as r, CALL_FIELD as s, ACTION_HEADER as t, FORM_FIELD_PREFIX as u, OBJECT_TAG as v, TAG as w, RENDER_HEADER as x, PROPS_SCRIPT_TYPE as y };
+export { VALUES_HEADER as A, RENDER_HEADER as C, TAG_BOUND as D, TAG as E, getTag as F, readPostedAction as I, stripRuntimeFields as L, VALUE_SCRIPT_TYPE as M, attachmentField as N, TAG_VALUE as O, formFieldName as P, REFERENCE_TAG as S, SLOT_TAG as T, MAX_HELD_VALUES as _, BLOB_TAG as a, PROMISE_TAG as b, CHUNK_SCRIPT_TYPE as c, FORM_REF_PREFIX as d, FORM_STATE_SCRIPT_TYPE as f, LAYOUTS_HEADER as g, ISLAND_ELEMENT as h, ACTION_TAG as i, VALUE_KEY_PATTERN as j, TREE_SCRIPT_TYPE as k, FORM_DATA_TAG as l, HYDRATED_ATTRIBUTE as m, ACTION_KEY_FIELD as n, BOUND_FIELD as o, HTML_ELEMENT as p, ACTION_STALE_HEADER as r, CALL_FIELD as s, ACTION_HEADER as t, FORM_FIELD_PREFIX as u, OBJECT_TAG as v, SLOT_ELEMENT as w, PROPS_SCRIPT_TYPE as x, PROMISE_SCRIPT_TYPE as y };

package/dist/_chunks/{wire-CXOodE06.mjs → wire-QEQWBr5s.mjs}

@@ -25,6 +25,11 @@ const TREE_SCRIPT_TYPE = "f/tree";
 const CHUNK_SCRIPT_TYPE = "f/chunk";
 /** The element around server HTML inside a server tree. */
 const HTML_ELEMENT = "f-html";
+/**
+* The script type of a promise's outcome, written when it settles: `{"v":value}`, or `{"e":1}` for
+* a rejection. Its `name` attribute names the promise.
+*/
+const PROMISE_SCRIPT_TYPE = "f/promise";
 /** The script type of React's form state after a `useActionState` form post, for hydration. */
 const FORM_STATE_SCRIPT_TYPE = "f/form-state";
 /** The reserved JSON key whose value is a tag. */
@@ -39,6 +44,11 @@ const REFERENCE_TAG = "r";
 const SLOT_TAG = "s";
 /** `{"$":"a","v":id}` or `{"$":"a","v":id,"b":sealed}`: a server action. */
 const ACTION_TAG = "a";
+/**
+* `{"$":"T","v":name}`: a promise an island receives, settled by the `f/promise` script `name`.
+* (Inside a server tree, `{"$":"P","v":value}` is a promise that resolved already.)
+*/
+const PROMISE_TAG = "T";
 /** `{"$":"o","v":{…}}`: app data that has its own `$` key. */
 const OBJECT_TAG = "o";
 /** `{"$":"F","v":n}`: a `FormData` argument, sent as fields of a multipart call. */
@@ -118,4 +128,4 @@ function getTag(value) {
 	if (keys.length === 2 && "v" in value) return tag;
 	if (keys.length === 3 && tag === "a" && "v" in value && "b" in value) return tag;
 }
-export { VALUE_SCRIPT_TYPE as A, SLOT_TAG as C, TREE_SCRIPT_TYPE as D, TAG_VALUE as E, stripRuntimeFields as F, formFieldName as M, getTag as N, VALUES_HEADER as O, readPostedAction as P, SLOT_ELEMENT as S, TAG_BOUND as T, MAX_HELD_VALUES as _, BLOB_TAG as a, REFERENCE_TAG as b, CHUNK_SCRIPT_TYPE as c, FORM_REF_PREFIX as d, FORM_STATE_SCRIPT_TYPE as f, LAYOUTS_HEADER as g, ISLAND_ELEMENT as h, ACTION_TAG as i, attachmentField as j, VALUE_KEY_PATTERN as k, FORM_DATA_TAG as l, HYDRATED_ATTRIBUTE as m, ACTION_KEY_FIELD as n, BOUND_FIELD as o, HTML_ELEMENT as p, ACTION_STALE_HEADER as r, CALL_FIELD as s, ACTION_HEADER as t, FORM_FIELD_PREFIX as u, OBJECT_TAG as v, TAG as w, RENDER_HEADER as x, PROPS_SCRIPT_TYPE as y };
+export { VALUES_HEADER as A, RENDER_HEADER as C, TAG_BOUND as D, TAG as E, getTag as F, readPostedAction as I, stripRuntimeFields as L, VALUE_SCRIPT_TYPE as M, attachmentField as N, TAG_VALUE as O, formFieldName as P, REFERENCE_TAG as S, SLOT_TAG as T, MAX_HELD_VALUES as _, BLOB_TAG as a, PROMISE_TAG as b, CHUNK_SCRIPT_TYPE as c, FORM_REF_PREFIX as d, FORM_STATE_SCRIPT_TYPE as f, LAYOUTS_HEADER as g, ISLAND_ELEMENT as h, ACTION_TAG as i, VALUE_KEY_PATTERN as j, TREE_SCRIPT_TYPE as k, FORM_DATA_TAG as l, HYDRATED_ATTRIBUTE as m, ACTION_KEY_FIELD as n, BOUND_FIELD as o, HTML_ELEMENT as p, ACTION_STALE_HEADER as r, CALL_FIELD as s, ACTION_HEADER as t, FORM_FIELD_PREFIX as u, OBJECT_TAG as v, SLOT_ELEMENT as w, PROPS_SCRIPT_TYPE as x, PROMISE_SCRIPT_TYPE as y };

package/dist/client.mjs

@@ -1,5 +1,5 @@
-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 { 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-8RQfrM-p.mjs";
+import { C as RENDER_HEADER, I as readPostedAction, L as stripRuntimeFields } from "./_chunks/wire-QEQWBr5s.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.d.mts

@@ -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-C3Rpbwl6.mjs";
+import { A as VALUES_HEADER, C as RENDER_HEADER, D as TAG_BOUND, E as TAG, F as getTag, I as readPostedAction, L as stripRuntimeFields, M as VALUE_SCRIPT_TYPE, N as attachmentField, O as TAG_VALUE, P as formFieldName, S as REFERENCE_TAG, T as SLOT_TAG, _ as MAX_HELD_VALUES, a as BLOB_TAG, b as PROMISE_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 VALUE_KEY_PATTERN, k as TREE_SCRIPT_TYPE, 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 SLOT_ELEMENT, x as PROPS_SCRIPT_TYPE, y as PROMISE_SCRIPT_TYPE } from "./_chunks/wire-Dipqh-EB.mjs";
 import { a as decode, c as encodeLeaf, d as plainObject, f as tagged, i as NOT_A_VALUE, l as fromBase64, n as EncodeError, o as decodeTagged, p as toBase64, r as EncodeOptions, s as encode, t as DecodeOptions, u as needsObjectTag } from "./_chunks/codec-CK8kZp4u.mjs";
-export { ACTION_HEADER, ACTION_KEY_FIELD, ACTION_STALE_HEADER, ACTION_TAG, BLOB_TAG, BOUND_FIELD, CALL_FIELD, CHUNK_SCRIPT_TYPE, type DecodeOptions, EncodeError, type EncodeOptions, 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 };
+export { ACTION_HEADER, ACTION_KEY_FIELD, ACTION_STALE_HEADER, ACTION_TAG, BLOB_TAG, BOUND_FIELD, CALL_FIELD, CHUNK_SCRIPT_TYPE, type DecodeOptions, EncodeError, type EncodeOptions, 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, PROMISE_SCRIPT_TYPE, PROMISE_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/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 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 };
+import { A as VALUES_HEADER, C as RENDER_HEADER, D as TAG_BOUND, E as TAG, F as getTag, I as readPostedAction, L as stripRuntimeFields, M as VALUE_SCRIPT_TYPE, N as attachmentField, O as TAG_VALUE, P as formFieldName, S as REFERENCE_TAG, T as SLOT_TAG, _ as MAX_HELD_VALUES, a as BLOB_TAG, b as PROMISE_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 VALUE_KEY_PATTERN, k as TREE_SCRIPT_TYPE, 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 SLOT_ELEMENT, x as PROPS_SCRIPT_TYPE, y as PROMISE_SCRIPT_TYPE } from "./_chunks/wire-QEQWBr5s.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-C8to-RQW.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, PROMISE_SCRIPT_TYPE, PROMISE_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,5 +1,5 @@
 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 { m as HYDRATED_ATTRIBUTE } from "../_chunks/wire-Dipqh-EB.mjs";
 import { t as ValueStore } from "../_chunks/value-store-Dm-7xJ6W.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";
@@ -21,6 +21,12 @@ interface HydrationOptions {
    */
   schedule: typeof scheduleHydration;
 }
+/**
+ * Marks the Suspense boundaries under `root` that still wait once their stream has ended (the
+ * connection dropped) as rendered in the browser, as React does when it finds one: the next
+ * `hydrate()` pass starts their islands. Call it when a stream that filled `root` ends.
+ */
+declare function endStreamedContent(root: ParentNode): void;
 /** The hydration runtime for one page. */
 declare function createHydrationRuntime(options: HydrationOptions): {
   hydrate: (scope?: ParentNode, signal?: AbortSignal) => Promise<void>;
@@ -46,4 +52,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, type ServerTreeLayout, type ServerTreeLayoutOptions, createHydrationRuntime, createServerHtml, createServerTreeElement, createServerTreeLayout, 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, endStreamedContent, isIslandStrategy, isolateIslands, refreshDocument, scheduleHydration, swapDocument, updateServerTrees, withinClientRoot };