@octanejs/app-core 0.2.0 → 0.3.0

package/README.md

@@ -8,6 +8,8 @@ Bundler-neutral app primitives shared by Octane's Vite and Rsbuild integrations.
 - `@octanejs/app-core/config-loader` loads TypeScript config files with either an injected development module runner or a neutral esbuild evaluator. `loadOctaneConfigWithMetadata` reports existing and missing dependencies for watch and cache invalidation.
 - `@octanejs/app-core/routes` and `/middleware` provide the router and Fetch API request pipeline.
 - `@octanejs/app-core/html`, `/production`, and `/node` provide streaming HTML composition, the production Fetch handler, and the optional Node HTTP bridge.
+- `@octanejs/app-core/seeds` reads route seeds in the browser (`readRouteSeed`), which the server writes with `routeSeed(context, name, produce)` once a page has rendered. `@octanejs/app-core/data-root` is the `.tsrx` wrapper the config's `data` module renders routes inside.
+- `@octanejs/app-core/server-functions` serves `module server` functions from a Node server an integration does not own, under any bundler: `createServerFunctions({ modules, middlewares })` answers their calls and runs other requests so a server render's calls run in process.
 - `@octanejs/app-core/codegen` generates client hydration entries, template-free server manifests, and production server entries. Runtime module IDs, integration module IDs, generated-file directories, and application import specifiers are explicit inputs so generators remain usable across bundlers and renderer targets.
 
 Development integrations should inject their native module runner into `loadOctaneConfigWithMetadata`. The neutral evaluator is intended for configuration/build discovery: it bundles static JS, TS, and server-compiled TSRX helpers, while preserving dynamic application imports as lazy watched references so config loading never traverses renderer-only asset graphs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octanejs/app-core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -22,6 +22,7 @@
   "files": [
     "src",
     "types",
+    "templates",
     "README.md",
     "LICENSE"
   ],
@@ -72,6 +73,21 @@
       "types": "./types/node.d.ts",
       "import": "./src/server/node-http.js",
       "default": "./src/server/node-http.js"
+    },
+    "./seeds": {
+      "types": "./types/seeds.d.ts",
+      "import": "./src/seeds.js",
+      "default": "./src/seeds.js"
+    },
+    "./data-root": {
+      "types": "./types/data-root.d.ts",
+      "import": "./templates/data-root.tsrx",
+      "default": "./templates/data-root.tsrx"
+    },
+    "./server-functions": {
+      "types": "./types/server-functions.d.ts",
+      "import": "./src/server/server-functions.js",
+      "default": "./src/server/server-functions.js"
     }
   },
   "dependencies": {
@@ -79,10 +95,10 @@
     "esbuild": "^0.28.1"
   },
   "peerDependencies": {
-    "octane": "^0.16.0"
+    "octane": "^0.17.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",
-    "octane": "0.16.0"
+    "octane": "0.17.0"
   }
 }

package/src/codegen.js

@@ -374,7 +374,12 @@ async function bootstrapDocumentLifecycle() {}
  *   - `rootBoundary`: the config names a root pending or catch boundary.
  *   - `independentHydration` / `streamedSignals`: some compiled module has an
  *     independent island / streamed signal state, so its lazy runtime loads.
- *   - `voidRoot: true` hydrates without returned-value reconciliation. Only a
+ *   - `data: true`: the config names a `data` module. The entry waits for the
+ *     whole document, opens the page's store from the server's seed, and
+ *     renders the route inside `DataRoot`, as the server did. Off by default,
+ *     so an app without one never loads `octane/data`.
+ *   - `voidRoot: true` hydrates without returned-value reconciliation. A `data`
+ *     entry ignores it: its root is `DataRoot`, which no build proves void. Only a
  *     build that proved every page and layout it can render is a void `@{}`
  *     body, with no root boundary, may set it (see compiler/void-roots.js).
  *
@@ -393,6 +398,9 @@ async function bootstrapDocumentLifecycle() {}
  *   runtimeModuleId?: string,
  *   generatedBy?: string,
  *   rootBoundary?: boolean,
+ *   data?: boolean,
+ *   dataRootModuleId?: string,
+ *   seedsModuleId?: string,
  *   voidRoot?: boolean,
  *   independentHydration?: boolean,
  *   streamedSignals?: boolean,
@@ -403,15 +411,26 @@ export function create_client_entry_source(options = {}) {
 	const runtimeModuleId =
 		options.runtimeModuleId ?? fileURLToPath(new URL('./client-entry-runtime.js', import.meta.url));
 	const rootBoundary = options.rootBoundary !== false;
+	const data = options.data === true;
+	const dataImports = data
+		? `import { DataRoot } from ${JSON.stringify(
+				options.dataRootModuleId ??
+					fileURLToPath(new URL('../templates/data-root.tsrx', import.meta.url)),
+			)};
+import { readRouteSeed } from ${JSON.stringify(
+				options.seedsModuleId ?? fileURLToPath(new URL('./seeds.js', import.meta.url)),
+			)};`
+		: '';
 	const imports = [
-		options.voidRoot ? '__hydrateVoidRoot as hydrateRoot' : 'hydrateRoot',
+		options.voidRoot && !data ? '__hydrateVoidRoot as hydrateRoot' : 'hydrateRoot',
 		'initializeHydrationEventCapture',
 		...(rootBoundary ? ['Suspense', 'ErrorBoundary', 'createElement'] : []),
 	];
 	return (
 		client_entry_prelude(
 			options,
-			`import { ${imports.join(', ')} } from ${JSON.stringify(runtimeModuleId)};`,
+			`import { ${imports.join(', ')} } from ${JSON.stringify(runtimeModuleId)};` +
+				(dataImports === '' ? '' : '\n' + dataImports),
 		) +
 		`function getComponentExport(module, exportName) {
   // Explicit export name requires an exact match; do NOT fall back, so a
@@ -559,7 +578,26 @@ ${
     Content = withRootBoundary(Content, rootBoundary);
 `
 		: ''
-}
+}${
+			data
+				? `    if (data.data) {
+      // The store's seed follows the page's content, so wait for the whole document.
+      if (document.readyState === 'loading') {
+        await new Promise((ready) => document.addEventListener('DOMContentLoaded', ready, { once: true }));
+      }
+      const dataModule = await importModule(data.data);
+      if (incompatibleBuild) return;
+      if (documentLifecycle && !await documentLifecycle.whenActive()) return;
+      const store = dataModule.default(readRouteSeed('data'), null);
+      const routeContent = Content;
+      Content = (props, scope) => DataRoot({
+        store,
+        children: (_props, childScope) => routeContent(props, childScope),
+      }, scope);
+    }
+`
+				: ''
+		}
     if (incompatibleBuild) return;
     if (documentLifecycle && !await documentLifecycle.whenActive()) return;
     hydrateRoot(target, Content, undefined,

package/src/html.js

@@ -1,4 +1,5 @@
 export { composeHtmlStream } from './server/html-stream.js';
+export { endRoute, routeEnding } from './seeds.js';
 export { serializeRouteData } from './server/route-data.js';
 export {
 	HYDRATION_NONCE_PLACEHOLDER,

package/src/index.js

@@ -25,3 +25,4 @@ export {
 export { runServerRequest } from './server/signal-owners.js';
 export { createServerCallHost } from './server/server-calls.js';
 export { createRpcRegistry } from './server/rpc-registry.js';
+export { routeSeed } from './seeds.js';

package/src/resolve-config.js

@@ -182,6 +182,34 @@ export function resolveOctaneConfig(raw, options = {}) {
 	if (raw.compiler?.strong !== undefined && typeof raw.compiler.strong !== 'boolean') {
 		throw new Error('[octane] compiler.strong must be a boolean when provided.');
 	}
+	const strongDependencies = raw.compiler?.strongDependencies;
+	if (strongDependencies !== undefined) {
+		if (
+			!strongDependencies ||
+			typeof strongDependencies !== 'object' ||
+			Array.isArray(strongDependencies)
+		) {
+			throw new Error('[octane] compiler.strongDependencies must be an object when provided.');
+		}
+		if (
+			strongDependencies.require !== undefined &&
+			typeof strongDependencies.require !== 'boolean'
+		) {
+			throw new Error('[octane] compiler.strongDependencies.require must be a boolean.');
+		}
+		if (
+			strongDependencies.allow !== undefined &&
+			(!Array.isArray(strongDependencies.allow) ||
+				strongDependencies.allow.some((name) => typeof name !== 'string'))
+		) {
+			throw new Error(
+				'[octane] compiler.strongDependencies.allow must be an array of package names.',
+			);
+		}
+		if (strongDependencies.require === true && raw.compiler?.strong !== true) {
+			throw new Error('[octane] compiler.strongDependencies.require needs compiler.strong: true.');
+		}
+	}
 
 	if (raw.router?.routes !== undefined && !Array.isArray(raw.router.routes)) {
 		throw new Error('[octane] router.routes must be an array.');
@@ -203,6 +231,11 @@ export function resolveOctaneConfig(raw, options = {}) {
 
 	validate_root_boundary(raw.rootBoundary);
 
+	if (raw.data !== undefined && (typeof raw.data !== 'string' || !raw.data.startsWith('/'))) {
+		// Both the server and the browser import it, by its project-root ID.
+		throw new Error("[octane] data must be a project-root module ID (e.g. '/src/data.ts').");
+	}
+
 	if (raw.server?.trustProxy !== undefined && typeof raw.server.trustProxy !== 'boolean') {
 		throw new Error('[octane] server.trustProxy must be a boolean when provided.');
 	}
@@ -265,13 +298,21 @@ export function resolveOctaneConfig(raw, options = {}) {
 		adapter: raw.adapter,
 		compiler: {
 			strong: raw.compiler?.strong ?? false,
-			renderers: normalizeRendererConfig(raw.compiler?.renderers),
+			strongDependencies: {
+				require: strongDependencies?.require ?? false,
+				allow: [...(strongDependencies?.allow ?? [])],
+			},
+			// App config declares no Valdi target, so its normalized form has none.
+			renderers: /** @type {ResolvedOctaneConfig['compiler']['renderers']} */ (
+				normalizeRendererConfig(raw.compiler?.renderers)
+			),
 		},
 		router: {
 			routes: raw.router?.routes ?? [],
 			preHydrate: raw.router?.preHydrate,
 		},
 		rootBoundary: raw.rootBoundary ?? {},
+		data: raw.data,
 		middlewares: raw.middlewares ?? [],
 		platform: {
 			env: raw.platform?.env ?? {},

package/src/seeds.js

@@ -0,0 +1,168 @@
+// @ts-check
+/**
+ * Route seeds: text a server render hands to the browser, such as a data
+ * store's loaded values, so the page hydrates from them instead of loading
+ * them again.
+ *
+ * A seed is produced once the render has finished streaming, because the
+ * values it carries load while the page renders. Each one is written as a
+ * JSON script just before `</body>`, after the page's content, so a client
+ * reads it once the document has been parsed. This module has no server
+ * imports: the browser reads seeds through it too.
+ */
+
+const SEED_ID = '__octane_seed:';
+const SEED_NAME = /^[\w.-]+$/;
+
+/**
+ * @typedef {{
+ *   seeds: Map<string, () => unknown>,
+ *   releases: Array<() => void>,
+ *   ended: boolean,
+ *   stream: ReadableStream<Uint8Array> | null,
+ * }} RouteSeeds
+ */
+
+/** @type {WeakMap<object, RouteSeeds>} */
+const routes = new WeakMap();
+
+/** @param {object} context */
+function routeOf(context) {
+	let route = routes.get(context);
+	if (!route) {
+		routes.set(context, (route = { seeds: new Map(), releases: [], ended: false, stream: null }));
+	}
+	return route;
+}
+
+/**
+ * Hand the browser `produce()`'s text under `name`, read there with
+ * `readRouteSeed(name)`. `produce` runs once the page has finished rendering,
+ * and not at all when the render fails.
+ *
+ * @param {import('@octanejs/app-core').Context} context
+ * @param {string} name
+ * @param {() => string | Promise<string>} produce
+ * @returns {void}
+ */
+export function routeSeed(context, name, produce) {
+	if (!SEED_NAME.test(name)) {
+		throw new TypeError(
+			`[octane] A route seed's name may only use letters, digits, "_", "." and "-": ${JSON.stringify(name)}`,
+		);
+	}
+	routeOf(context).seeds.set(name, produce);
+}
+
+/**
+ * The text the server render seeded under `name`, or `null` when there is
+ * none, such as on a page rendered only in the browser. Read it once the
+ * document has been parsed.
+ *
+ * @param {string} name
+ * @returns {string | null}
+ */
+export function readRouteSeed(name) {
+	const script = typeof document === 'undefined' ? null : document.getElementById(SEED_ID + name);
+	return script === null ? null : JSON.parse(script.textContent ?? 'null');
+}
+
+/**
+ * @internal Run `release` once the route's response has ended, however it
+ * ends: completed, cancelled, or failed before it began.
+ * @param {object} context
+ * @param {() => void} release
+ */
+export function onRouteEnd(context, release) {
+	const route = routeOf(context);
+	if (route.ended) release();
+	else route.releases.push(release);
+}
+
+/**
+ * @internal The route's seed scripts, produced now that its render has
+ * finished. A seed that fails to produce is left out, so the browser loads
+ * what it would have carried.
+ * @param {object} context
+ * @param {string} nonceAttribute ` nonce="…"`, or empty
+ * @returns {Promise<string>}
+ */
+export async function routeSeedScripts(context, nonceAttribute) {
+	const route = routes.get(context);
+	if (!route || route.seeds.size === 0) return '';
+	let html = '';
+	for (const [name, produce] of route.seeds) {
+		let text;
+		try {
+			text = String(await produce());
+		} catch (error) {
+			console.error(`[octane] Route seed ${JSON.stringify(name)} failed:`, error);
+			continue;
+		}
+		// A JSON string, escaped so no part of it can close the script element.
+		const json = JSON.stringify(text).replace(/</g, '\\u003c').replace(/>/g, '\\u003e');
+		html += `<script id="${SEED_ID}${name}" type="application/json"${nonceAttribute}>${json}</script>`;
+	}
+	return html;
+}
+
+/**
+ * @internal End a route whose request failed. A response already streaming is
+ * cancelled, which stops its render and ends the route; otherwise the route
+ * ends now.
+ * @param {object} context
+ */
+export function failRoute(context) {
+	const stream = routes.get(context)?.stream;
+	if (stream && !stream.locked) {
+		void stream.cancel().catch(() => {});
+		return;
+	}
+	endRoute(context);
+}
+
+/**
+ * @internal End the route: run each release once.
+ * @param {object} context
+ */
+export function endRoute(context) {
+	const route = routes.get(context);
+	if (!route || route.ended) return;
+	route.ended = true;
+	for (const release of route.releases.splice(0)) {
+		try {
+			release();
+		} catch (error) {
+			console.error('[octane] Releasing a route failed:', error);
+		}
+	}
+}
+
+/**
+ * @internal Put `html` just before the document's last `</body>`, or at its
+ * end when it has none.
+ * @param {string} document
+ * @param {string} html
+ */
+export function beforeBodyEnd(document, html) {
+	if (html === '') return document;
+	const at = document.toLowerCase().lastIndexOf('</body');
+	return at === -1 ? document + html : document.slice(0, at) + html + document.slice(at);
+}
+
+/**
+ * @internal The `composeHtmlStream` ending for a route: its seeds go before
+ * `</body>`, and the route ends with the stream.
+ * @param {object} context
+ * @param {string} nonceAttribute
+ */
+export function routeEnding(context, nonceAttribute) {
+	return {
+		hold: (/** @type {ReadableStream<Uint8Array>} */ stream) => {
+			routeOf(context).stream = stream;
+		},
+		tail: async (/** @type {string} */ suffix) =>
+			beforeBodyEnd(suffix, await routeSeedScripts(context, nonceAttribute)),
+		end: () => endRoute(context),
+	};
+}

package/src/server/data-route.js

@@ -0,0 +1,29 @@
+// @ts-check
+/**
+ * The config's `data` module on the server: open one store per request, render
+ * the route inside it, seed its loaded values for the browser once the render
+ * has finished, and retire it when the response ends.
+ */
+import { onRouteEnd, routeSeed } from '../seeds.js';
+
+/** The seed the browser's store starts from. */
+export const DATA_SEED = 'data';
+
+/**
+ * @param {import('@octanejs/app-core').Context} context
+ * @param {import('@octanejs/app-core/production').RouteDataEntry | null | undefined} data
+ * @param {(props?: any, scope?: any, extra?: any) => any} Root
+ */
+export function provideRouteData(context, data, Root) {
+	if (!data) return Root;
+	const store = data.open(null, context);
+	onRouteEnd(context, () => void store.retire());
+	routeSeed(context, DATA_SEED, () => store.dehydrate());
+	const { Root: DataRoot } = data;
+	return function RouteData(/** @type {any} */ props, /** @type {any} */ scope) {
+		// As a layout's `children`: a body closing over the route's props.
+		const children = (/** @type {any} */ _props, /** @type {any} */ childScope) =>
+			Root(props, childScope, undefined);
+		return DataRoot({ store, children }, scope, undefined);
+	};
+}

package/src/server/html-stream.js

@@ -10,9 +10,12 @@
  * @param {ReadableStream<Uint8Array>} renderStream
  * @param {string} suffix
  * @param {string} [afterShell] Owned bootstrap after the renderer's first complete shell chunk.
+ * @param {{ tail(suffix: string): Promise<string>, end(): void, hold?(stream: ReadableStream<Uint8Array>): void }} [ending]
+ *   Computes the suffix once the render has finished, runs `end` however the stream
+ *   ends, and is handed the stream, so a failed request can cancel it.
  * @returns {ReadableStream<Uint8Array>}
  */
-export function composeHtmlStream(prefix, renderStream, suffix, afterShell = '') {
+export function composeHtmlStream(prefix, renderStream, suffix, afterShell = '', ending) {
 	const encoder = new TextEncoder();
 	const reader = renderStream.getReader();
 	let phase = 0; // 0 prefix, 1 renderer, 2 suffix, 3 closed
@@ -25,7 +28,7 @@ export function composeHtmlStream(prefix, renderStream, suffix, afterShell = '')
 		reader.releaseLock();
 	}
 
-	return new ReadableStream(
+	const stream = new ReadableStream(
 		{
 			async pull(controller) {
 				try {
@@ -56,8 +59,10 @@ export function composeHtmlStream(prefix, renderStream, suffix, afterShell = '')
 
 						if (phase === 2) {
 							phase = 3;
-							if (suffix !== '') controller.enqueue(encoder.encode(suffix));
+							const tail = ending ? await ending.tail(suffix) : suffix;
+							if (tail !== '') controller.enqueue(encoder.encode(tail));
 							controller.close();
+							ending?.end();
 							return;
 						}
 						return;
@@ -66,6 +71,7 @@ export function composeHtmlStream(prefix, renderStream, suffix, afterShell = '')
 					release();
 					phase = 3;
 					controller.error(error);
+					ending?.end();
 				}
 			},
 			async cancel(reason) {
@@ -74,9 +80,12 @@ export function composeHtmlStream(prefix, renderStream, suffix, afterShell = '')
 					await reader.cancel(reason);
 				} finally {
 					release();
+					ending?.end();
 				}
 			},
 		},
 		{ highWaterMark: 0 },
 	);
+	ending?.hold?.(stream);
+	return stream;
 }

package/src/server/production.js

@@ -28,10 +28,12 @@ import { handleRpcRequest } from './rpc.js';
 import { setRequestContextSource } from './request-context.js';
 import { createServerCallHost } from './server-calls.js';
 import { runServerRequest } from './signal-owners.js';
-import { rpcIdCollision } from './rpc-registry.js';
+import { buildRpcDescriptors } from './rpc-registry.js';
 import { handleServerRoute } from './server-route.js';
 import { composeHtmlStream } from './html-stream.js';
 import { serializeRouteData } from './route-data.js';
+import { provideRouteData } from './data-route.js';
+import { beforeBodyEnd, endRoute, failRoute, routeEnding, routeSeedScripts } from '../seeds.js';
 import {
 	applyHydrationNonce,
 	getContextNonce,
@@ -59,6 +61,7 @@ import {
 import { patch_global_fetch, build_rpc_lookup, is_rpc_request } from '@ripple-ts/adapter/rpc';
 
 export { resolveOctaneConfig } from '../resolve-config.js';
+export { provideRouteData } from './data-route.js';
 
 const HEAD_MARKER = '<!--ssr-head-->';
 const BODY_MARKER = '<!--ssr-body-->';
@@ -106,34 +109,6 @@ function getFetchCoordinator(runtime) {
 	return coordinator;
 }
 
-/**
- * Name every server function id, built once per handler.
- *
- * `build_rpc_lookup` keeps only the namespace object and export name, but a
- * middleware policy needs the declaring module before the function is resolved.
- *
- * @param {Record<string, Record<string, Function>>} rpcModules
- * @param {(value: string) => string} hashFn
- * @returns {Map<string, { module: string, export: string }>}
- */
-function buildRpcDescriptors(rpcModules, hashFn) {
-	/** @type {Map<string, { module: string, export: string }>} */
-	const descriptors = new Map();
-	for (const [entryPath, serverObj] of Object.entries(rpcModules)) {
-		for (const funcName of Object.keys(serverObj)) {
-			const id = hashFn(entryPath + '#' + funcName);
-			// Each manifest entry is listed once, so an id already taken here is a
-			// genuine collision. `build_rpc_lookup` would resolve it by overwriting.
-			const existing = descriptors.get(id);
-			if (existing !== undefined) {
-				throw rpcIdCollision(id, existing, { module: entryPath, export: funcName });
-			}
-			descriptors.set(id, { module: entryPath, export: funcName });
-		}
-	}
-	return descriptors;
-}
-
 /**
  * Split the immutable, validated production template around both insertion
  * markers once. Dynamic head content is then concatenated into the prepared
@@ -465,6 +440,7 @@ export function createHandler(manifest, deps) {
 				}
 				return await handleServerRoute(match.route, context, globalMiddlewares);
 			} catch (error) {
+				failRoute(context);
 				console.error('[octane] Request error:', error);
 				return new Response('Internal Server Error', { status: 500 });
 			}
@@ -537,6 +513,7 @@ export function createHandler(manifest, deps) {
 			},
 			deps,
 		);
+		RootComponent = provideRouteData(context, manifest.data, RootComponent);
 
 		// Share payload ordering and script escaping with the dev handler.
 		const streamedSignals =
@@ -554,6 +531,7 @@ export function createHandler(manifest, deps) {
 			params: context.params,
 			url: requestUrl,
 			preHydrate: manifest.preHydrate ?? null,
+			data: manifest.data?.path ?? null,
 			rootBoundary: manifest.rootBoundaryEntries ?? { pending: null, catch: null },
 			clientBuild,
 			streamedSignals,
@@ -617,7 +595,12 @@ export function createHandler(manifest, deps) {
 				},
 			});
 			const [prefix, suffix] = splitAroundBody(head ?? '');
-			return new Response(prefix + css + body + suffix, { status, headers });
+			const seeds = await routeSeedScripts(context, nonceAttribute(nonce));
+			endRoute(context);
+			return new Response(prefix + css + body + beforeBodyEnd(suffix, seeds), {
+				status,
+				headers,
+			});
 		}
 
 		// Streaming (default): shell flushes at first await, suspense segments
@@ -645,7 +628,13 @@ export function createHandler(manifest, deps) {
 		});
 
 		const [prefix, suffix, afterShell] = splitAroundBody(hoistedHead, earlyHydration);
-		const body = composeHtmlStream(prefix, renderStream, suffix, afterShell);
+		const body = composeHtmlStream(
+			prefix,
+			renderStream,
+			suffix,
+			afterShell,
+			routeEnding(context, nonceAttribute(nonce)),
+		);
 
 		return new Response(body, { status, headers });
 	}

package/src/server/route-data.js

@@ -16,6 +16,7 @@ export function serializeRouteData(data) {
 		params: data.params,
 		url: data.url,
 		preHydrate: data.preHydrate ?? null,
+		data: data.data ?? null,
 		rootBoundary: data.rootBoundary ?? { pending: null, catch: null },
 		clientBuild: data.clientBuild,
 		streamedSignals: data.streamedSignals,

package/src/server/rpc-registry.js

@@ -60,3 +60,31 @@ class RpcRegistry extends Map {
 export function createRpcRegistry() {
 	return new RpcRegistry();
 }
+
+/**
+ * Name every server function id, built once per handler or server.
+ *
+ * `build_rpc_lookup` keeps only the namespace object and export name, but a
+ * middleware policy needs the declaring module before the function is resolved.
+ *
+ * @param {Record<string, Record<string, Function>>} rpcModules
+ * @param {(value: string) => string} hashFn
+ * @returns {Map<string, { module: string, export: string }>}
+ */
+export function buildRpcDescriptors(rpcModules, hashFn) {
+	/** @type {Map<string, { module: string, export: string }>} */
+	const descriptors = new Map();
+	for (const [entryPath, serverObj] of Object.entries(rpcModules)) {
+		for (const funcName of Object.keys(serverObj)) {
+			const id = hashFn(entryPath + '#' + funcName);
+			// Each manifest entry is listed once, so an id already taken here is a
+			// genuine collision. `build_rpc_lookup` would resolve it by overwriting.
+			const existing = descriptors.get(id);
+			if (existing !== undefined) {
+				throw rpcIdCollision(id, existing, { module: entryPath, export: funcName });
+			}
+			descriptors.set(id, { module: entryPath, export: funcName });
+		}
+	}
+	return descriptors;
+}

package/src/server/server-entry.js

@@ -38,6 +38,8 @@ import { get_route_entry_export_name, get_route_entry_path } from '../routes.js'
  * @property {Route[]} routes - Route definitions from octane.config.ts
  * @property {string} octaneConfigPath - Absolute path to octane.config.ts
  * @property {RootBoundaryOptions} [rootBoundary] - Importable app-wide boundary entries
+ * @property {string} [data] - The config's `data` module: project-root ID of its store opener
+ * @property {string} [dataRootModuleId] - App-core's `DataRoot` module ID
  * @property {string[]} [rpcModulePaths] - Project-root module IDs containing `module server`
  * @property {Record<string, ClientAssetEntry>} [clientAssetMap] - Route entry path → built client asset paths
  * @property {string} [clientAssetMapFile] - JSON asset map, resolved beside the built server entry at runtime
@@ -67,6 +69,8 @@ export function generateServerEntry(options) {
 		routes,
 		octaneConfigPath,
 		rootBoundary = {},
+		data,
+		dataRootModuleId = '@octanejs/app-core/data-root',
 		rpcModulePaths = [],
 		clientAssetMap = {},
 		clientAssetMapFile,
@@ -150,6 +154,15 @@ export function generateServerEntry(options) {
 			);
 		}
 	}
+	if (data) {
+		import_lines.push(
+			`import * as _data from ${JSON.stringify(import_specifier(data))};`,
+			`import { DataRoot } from ${JSON.stringify(dataRootModuleId)};`,
+		);
+	}
+	const data_entry = data
+		? `{ path: ${JSON.stringify(data)}, open: _data.default, Root: DataRoot }`
+		: 'null';
 
 	// The manifest maps MODULE PATHS to module namespaces; createHandler picks
 	// the export per-route with the same `get_component_export` dev uses.
@@ -325,6 +338,7 @@ export const manifest = {
 	rootBoundary,
 	rootBoundaryEntries,
 	preHydrate: octaneConfig.router.preHydrate ?? null,
+	data: ${data_entry},
 	rpcModules,
 	runtime,
 	clientAssets,
@@ -448,6 +462,7 @@ export const handler = createHandler(
 		rootBoundary,
 		rootBoundaryEntries,
 		preHydrate: octaneConfig.router.preHydrate ?? null,
+		data: ${data_entry},
 		rpcModules,
 		runtime,
 		clientAssets,

package/src/server/server-functions.js

@@ -0,0 +1,91 @@
+// @ts-check
+/**
+ * `module server` functions for a Node server an Octane integration does not
+ * own: one with its own routing, or pages another renderer draws. It applies
+ * the same boundary as `@octanejs/vite-plugin` and `@octanejs/rsbuild-plugin`,
+ * so it works under any bundler that compiles `.tsrx` for the server.
+ */
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createHash } from 'node:crypto';
+import { build_rpc_lookup, is_rpc_request } from '@ripple-ts/adapter/rpc';
+import {
+	executeServerFunction,
+	executeServerFunctionBatch,
+	executeServerFunctionStream,
+} from 'octane/server';
+import { createContext, runMiddlewareChain } from './middleware.js';
+import { buildRpcDescriptors } from './rpc-registry.js';
+import { handleRpcRequest } from './rpc.js';
+import { setRequestContextSource } from './request-context.js';
+import { createServerCallHost } from './server-calls.js';
+import { runServerRequest } from './signal-owners.js';
+
+/** The compiler's function id: SHA-256 hex of `"<module>#<export>"`, 8 characters. */
+const hash = (/** @type {string} */ value) =>
+	createHash('sha256').update(value).digest('hex').slice(0, 8);
+
+/**
+ * @param {import('@octanejs/app-core/server-functions').ServerFunctionsOptions} options
+ * @returns {import('@octanejs/app-core/server-functions').ServerFunctions}
+ */
+export function createServerFunctions(options) {
+	/** @type {Record<string, Record<string, Function>>} */
+	const namespaces = {};
+	for (const [id, module] of Object.entries(options.modules)) {
+		const server = /** @type {Record<string, Function> | undefined} */ (module._$_server_$_);
+		if (server === undefined) {
+			throw new TypeError(`[octane] ${id} has no \`module server\` block in this build`);
+		}
+		namespaces[id] = server;
+	}
+	const lookup = build_rpc_lookup(namespaces, hash);
+	const descriptors = buildRpcDescriptors(namespaces, hash);
+	const middlewares = options.middlewares ?? [];
+	const storage = new AsyncLocalStorage();
+	/** @type {import('@octanejs/app-core').RpcRequestOptions['asyncContext']} */
+	const asyncContext = {
+		run: (store, fn) => storage.run(store, fn),
+		getStore: () => storage.getStore(),
+	};
+
+	return {
+		handle(request, platform) {
+			if (!is_rpc_request(new URL(request.url).pathname)) return null;
+			return handleRpcRequest(request, {
+				resolveFunction(id) {
+					const entry = lookup.get(id);
+					const fn = entry?.serverObj[entry.funcName];
+					return typeof fn === 'function' ? fn : null;
+				},
+				describeFunction: (id) => descriptors.get(id) ?? null,
+				executeServerFunction,
+				streamServerFunction: executeServerFunctionStream,
+				batchServerFunctions: executeServerFunctionBatch,
+				asyncContext,
+				middlewares,
+				trustProxy: options.trustProxy,
+				allowedOrigins: options.allowedOrigins,
+				maxBodyBytes: options.maxBodyBytes,
+				resultLimits: options.resultLimits,
+				platform,
+			});
+		},
+		respond(request, respond, platform) {
+			const context = createContext(request, {}, platform);
+			const origin = context.url.origin;
+			setRequestContextSource(asyncContext);
+			return runServerRequest(
+				asyncContext,
+				{
+					origin,
+					platform,
+					context,
+					serverCallHost: createServerCallHost(context, { asyncContext, middlewares, origin }),
+				},
+				undefined,
+				() => runMiddlewareChain(context, middlewares, [], async () => respond(context)),
+			);
+		},
+	};
+}

package/templates/data-root.tsrx

@@ -0,0 +1,15 @@
+/**
+ * The route's data store around its content. App-core renders it as each
+ * route's outermost component when the config names a `data` module.
+ *
+ * A codegen template, not a module app code imports: the generated server and
+ * client entries import it, so each app compiles it with its own toolchain and
+ * its server markup and browser adoption line up as a layout's do.
+ */
+import type { OctaneNode } from 'octane';
+import type { DataStore } from 'octane/data';
+import { DataProvider } from 'octane/data/octane';
+
+export function DataRoot(props: { store: DataStore; children?: OctaneNode }) @{
+	<DataProvider store={props.store}>{props.children}</DataProvider>
+}

package/types/codegen.d.ts

@@ -45,6 +45,15 @@ export interface ClientEntryOptions {
 	resolveImport?: (id: string) => string;
 	runtimeModuleId?: string;
 	generatedBy?: string;
+	/**
+	 * The config names a `data` module: open the page's store from the server's
+	 * seed and render the route inside `DataRoot`. Off by default.
+	 */
+	data?: boolean;
+	/** App-core's `DataRoot` module, compiled for the client. */
+	dataRootModuleId?: string;
+	/** App-core's browser-safe seeds module. */
+	seedsModuleId?: string;
 }
 
 export function create_client_entry_source(options?: ClientEntryOptions): string;
@@ -55,6 +64,10 @@ export interface ServerEntryOptions {
 	routes: Route[];
 	octaneConfigPath: string;
 	rootBoundary?: RootBoundaryOptions;
+	/** The config's `data` module: project-root ID of its store opener. */
+	data?: string;
+	/** App-core's `DataRoot` module, compiled for the server. */
+	dataRootModuleId?: string;
 	rpcModulePaths?: string[];
 	clientAssetMap?: Record<string, ClientAssetEntry>;
 	/** JSON file resolved beside the built server entry at module evaluation. */

package/types/data-root.d.ts

@@ -0,0 +1,5 @@
+import type { OctaneNode } from 'octane';
+import type { DataStore } from 'octane/data';
+
+/** The route's data store around its content; app-core renders it for the config's `data` module. */
+export function DataRoot(props: { store: DataStore; children?: OctaneNode }): OctaneNode;

package/types/html.d.ts

@@ -10,6 +10,8 @@ export interface RouteHydrationData {
 	params: Record<string, string>;
 	url: string;
 	preHydrate?: string | null;
+	/** The config's `data` module, which the client entry opens the page's store with. */
+	data?: string | null;
 	rootBoundary?: ServerManifest['rootBoundaryEntries'];
 	clientBuild?: ClientBuildManifest;
 	streamedSignals?: { buildId: string; documentId: string };
@@ -23,7 +25,19 @@ export function composeHtmlStream(
 	renderStream: ReadableStream<Uint8Array>,
 	suffix: string,
 	afterShell?: string,
+	ending?: RouteEnding,
 ): ReadableStream<Uint8Array>;
+/** Computes a stream's suffix once its render has finished, and runs `end` however it ends. */
+export interface RouteEnding {
+	tail(suffix: string): Promise<string>;
+	end(): void;
+	/** Handed the composed stream, so a failed request can cancel it. */
+	hold?(stream: ReadableStream<Uint8Array>): void;
+}
+/** A route's seeds go before `</body>`, and the route ends with the stream. */
+export function routeEnding(context: object, nonceAttribute: string): RouteEnding;
+/** End a route whose response failed before streaming: release what it opened. */
+export function endRoute(context: object): void;
 export function validateSsrTemplate(html: string): void;
 export function injectHydrationEntry(html: string, source: string, nonce?: string | null): string;
 export function splitSsrTemplate(html: string): [prefix: string, suffix: string];

package/types/index.d.ts

@@ -457,6 +457,15 @@ export interface OctaneConfigOptions {
 	compiler?: {
 		/** Assert pure immutable-snapshot renders and reject detectable violations. @default false */
 		strong?: boolean;
+		/**
+		 * What Strong application modules may import from other Octane packages.
+		 * With `require: true` (which needs `strong: true`), an import that reaches
+		 * a module in another package compiling without Strong mode, or an
+		 * `octane/react` boundary, fails the build unless `allow` names its package
+		 * (or `'octane/react'`). Packages declare Strong with `"octane": { "strong": true }`
+		 * or a list of paths in their package.json. @default { require: false, allow: [] }
+		 */
+		strongDependencies?: { require?: boolean; allow?: readonly string[] };
 		renderers?: ExperimentalRendererConfigOptions;
 	};
 	router?: {
@@ -474,6 +483,13 @@ export interface OctaneConfigOptions {
 	 * selects a named export.
 	 */
 	rootBoundary?: RootBoundaryOptions;
+	/**
+	 * Project-root module ID (e.g. '/src/data.ts') whose default export is a
+	 * {@link RouteDataOpener}. Every render route then runs inside the store it
+	 * opens: one per request on the server, seeded into the page once it has
+	 * rendered, and one in the browser, started from that seed.
+	 */
+	data?: string;
 	/** Global middlewares applied to all routes */
 	middlewares?: Middleware[];
 	platform?: {
@@ -523,6 +539,7 @@ export interface ResolvedOctaneConfig {
 	compiler: {
 		/** @default false */
 		strong: boolean;
+		strongDependencies: { require: boolean; allow: string[] };
 		renderers: ExperimentalResolvedRendererConfig;
 	};
 	router: {
@@ -530,6 +547,7 @@ export interface ResolvedOctaneConfig {
 		preHydrate?: string;
 	};
 	rootBoundary: RootBoundaryOptions;
+	data?: string;
 	/** @default [] */
 	middlewares: Middleware[];
 	platform: {
@@ -619,3 +637,32 @@ export interface LoadedOctaneConfig {
 	dependencies: string[];
 	missingDependencies: string[];
 }
+
+/**
+ * The default export of the config's `data` module: open a data store, such as
+ * `octane/data`'s, for a route. On the server `seed` is `null` and `context`
+ * is the request's, once its middleware has run; in the browser `seed` is the
+ * server's `dehydrate()` text, or `null` on a page rendered only there, and
+ * `context` is `null`.
+ */
+export type RouteDataOpener = (seed: string | null, context: Context | null) => RouteDataStore;
+
+/** What app-core needs of a route's data store. `octane/data`'s `DataStore` is one. */
+export interface RouteDataStore {
+	/** Its loaded values, for the browser's store to start from. */
+	dehydrate(): string;
+	/** End it on the server once the response is complete. */
+	retire(): unknown;
+}
+
+/**
+ * Hand the browser `produce()`'s text under `name`, read there with
+ * `readRouteSeed(name)` from `@octanejs/app-core/seeds`. `produce` runs once
+ * the page has finished rendering, and not at all when the render fails; the
+ * text is written as a script just before `</body>`.
+ */
+export function routeSeed(
+	context: Context,
+	name: string,
+	produce: () => string | Promise<string>,
+): void;

package/types/production.d.ts

@@ -72,6 +72,8 @@ export interface ServerManifest {
 	};
 	/** config `router.preHydrate`, serialized into #__octane_data for the client entry */
 	preHydrate?: string | null;
+	/** The config's `data` module, opened per request, and the root it renders routes inside. */
+	data?: RouteDataEntry | null;
 	/** Map of entry path → `module server` namespace for RPC support */
 	rpcModules?: Record<string, Record<string, Function>>;
 	/** Platform primitives (adapter's, or the generated entry's Node defaults) */
@@ -142,3 +144,18 @@ export function createRootBoundaryWrapper(
 	boundary: { pending?: Component | null; catch?: Component | null },
 	runtime: { Suspense: Component; ErrorBoundary: Component; createElement: Function },
 ): Component;
+
+export interface RouteDataEntry {
+	/** The module's project-root ID, serialized for the client entry. */
+	path: string;
+	open: import('@octanejs/app-core').RouteDataOpener;
+	/** `DataRoot` from `@octanejs/app-core/data-root`, compiled for the server. */
+	Root: Component<{ store: import('@octanejs/app-core').RouteDataStore; children?: unknown }>;
+}
+
+/** Render a route inside the config's `data` store, opened for this request and seeded once it has rendered. */
+export function provideRouteData(
+	context: import('@octanejs/app-core').Context,
+	data: RouteDataEntry | null | undefined,
+	Root: Component,
+): Component;

package/types/seeds.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The text a server render seeded under `name` with `routeSeed`, or `null`
+ * when there is none, such as on a page rendered only in the browser. Read it
+ * once the document has been parsed.
+ */
+export function readRouteSeed(name: string): string | null;
+export { routeSeed } from '@octanejs/app-core';

package/types/server-functions.d.ts

@@ -0,0 +1,50 @@
+import type { Context, Middleware } from '@octanejs/app-core';
+import type { ServerResultLimits } from 'octane/server';
+
+export interface ServerFunctionsOptions {
+	/**
+	 * The server build of each module that declares a `module server` block,
+	 * keyed by the root-relative path the compiler named it by, such as
+	 * `'/src/data.tsrx'`:
+	 *
+	 * ```ts
+	 * import * as data from './data.tsrx';
+	 * createServerFunctions({ modules: { '/src/data.tsrx': data } });
+	 * ```
+	 */
+	modules: Record<string, Record<string, unknown>>;
+	/** Run before every server function call, in process or over RPC, as app config middleware does. */
+	middlewares?: Middleware[];
+	/** Trust X-Forwarded-Proto/Host when deriving the request origin. */
+	trustProxy?: boolean;
+	/** Origins other than the request's own that may call server functions. */
+	allowedOrigins?: readonly string[];
+	/** The largest request body a call may send. */
+	maxBodyBytes?: number;
+	resultLimits?: ServerResultLimits;
+}
+
+export interface ServerFunctions {
+	/**
+	 * Answer a browser's call to a server function, with the same origin
+	 * checks, body limit and middleware as an Octane app server. Returns `null`
+	 * for any request that is not one.
+	 */
+	handle(request: Request, platform?: unknown): Promise<Response> | null;
+	/**
+	 * Answer any other request through the middleware. A server function that
+	 * `respond` calls, such as one a page's server render reads, runs in process
+	 * under the middleware's context.
+	 */
+	respond(
+		request: Request,
+		respond: (context: Context) => Response | Promise<Response>,
+		platform?: unknown,
+	): Promise<Response>;
+}
+
+/**
+ * Serve `module server` functions from a Node server an Octane integration does
+ * not own, under any bundler that compiles `.tsrx` for the server.
+ */
+export function createServerFunctions(options: ServerFunctionsOptions): ServerFunctions;