@octanejs/app-core 0.0.58 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octanejs/app-core",
-  "version": "0.0.58",
+  "version": "0.1.1",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -79,10 +79,10 @@
     "esbuild": "^0.28.1"
   },
   "peerDependencies": {
-    "octane": "^0.7.0"
+    "octane": "^0.9.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",
-    "octane": "0.7.0"
+    "octane": "0.9.0"
   }
 }

package/src/codegen.js

@@ -87,65 +87,20 @@ export function write_project_generated_file(options, name, source) {
 }
 
 /**
- * Generate the client hydration entry (served at virtual:octane-hydrate).
- *
- * CONFIG-FREE: it does NOT import octane.config.ts. Importing the config into
- * the browser would drag the plugin (and the server adapter) — with their
- * `node:fs` imports — into the client graph and throw at module-eval. Instead
- * the server serializes everything needed into #__octane_data ({ entry,
- * exportName, layout, params, url, preHydrate }), and this entry
- * dynamic-imports the page/layout from there.
- *
- * `staticEntries` (production builds) lists every module path the server can
- * name in #__octane_data — page entries, layouts, and the preHydrate hook.
- * Each becomes a STATIC `() => import('/src/…')` in a lookup map, so Rollup
- * sees, chunks, and hashes them; the runtime falls back to a native dynamic
- * import only for paths outside the map (the dev case, where the map is empty
- * and the integration serves any module by URL). The fallback resolves the
- * project-root ID against the browsing context's real location. Project IDs
- * are root-absolute, so this has the same URL semantics as importing from this
- * generated module while remaining immune to an authored `<base>` element.
- * (Rspack rewrites `import.meta.url` to `document.baseURI` in classic output,
- * so it cannot be used directly here.) Vite serves `.tsrx` modules through its
- * canonical `?import` URL but leaves ordinary JavaScript/TypeScript URLs
- * unchanged, while Rspack honors its ignore hint. Keeping the import native
- * avoids requiring `unsafe-eval` under a nonce-based Content Security Policy.
- *
- * octane specifics:
- *   - `initializeHydrationEventCapture()` runs before any async route work so
- *     interaction boundaries can preserve intent that precedes `hydrateRoot()`.
- *   - `import { hydrateRoot } from 'octane'` (NO `mount`).
- *   - `hydrateRoot(container, body, props)` signature (container FIRST, React-18
- *     shape) — no `{ target, props }` wrapper.
- *   - The layout `children` is a props-first ComponentBody whose closure calls
- *     `Page({ params, url }, scope, extra)`, NOT a 0-arg thunk: octane's
- *     `childSlot` invokes a bare function child with `{}` props, so page data
- *     rides the closure — mirroring the server `createLayoutWrapper`.
- *   - hydrateRoot() itself locates/consumes the <script data-octane-suspense>
- *     seed inside #root, so the entry does nothing special for suspense.
- *   - `preHydrate` (config `router.preHydrate`, a project-root module ID) is
- *     imported and its default export awaited BEFORE hydrateRoot — the hook an
- *     app-level client router uses to commit its match tree so the first
- *     hydration pass adopts the same resolved tree the server rendered.
- *
- * `getComponentExport` mirrors routes.js `get_component_export` (route named
- * export > default > first PascalCase) so server and client pick the SAME
- * component.
+ * Everything both generated entries share: build identity, intent capture,
+ * the static import maps, independent island and document lifecycle bootstrap.
+ * Only the runtime import and the final activation differ.
  *
- * @param {{
- *   configPath?: string,
- *   staticEntries?: Array<string | { id: string, specifier: string }>,
- *   independentEntries?: Array<{ id: string, specifier: string }>,
- *   clientBuildId?: string,
- *   clientBuildIdExpression?: string,
- *   devClientBuild?: boolean,
- *   resolveImport?: (id: string) => string,
- *   runtimeModuleId?: string,
- *   generatedBy?: string,
- * }} [options]
+ * @param {Parameters<typeof create_client_entry_source>[0] & {}} options
+ * @param {string} runtimeImport
+ * @param {string} [hydrationModule] Expression for the module providing bootstrapIndependentHydration.
  * @returns {string}
  */
-export function create_client_entry_source(options = {}) {
+function client_entry_prelude(
+	options,
+	runtimeImport,
+	hydrationModule = "import('octane/hydration')",
+) {
 	if (options.clientBuildId !== undefined && options.clientBuildIdExpression !== undefined) {
 		throw new TypeError('Provide one executing client build identity, not both forms.');
 	}
@@ -159,7 +114,6 @@ export function create_client_entry_source(options = {}) {
 			typeof entry === 'string' ? (options.resolveImport?.(id) ?? id) : entry.specifier;
 		staticEntries.set(id, specifier);
 	}
-	const runtimeModuleId = options.runtimeModuleId ?? 'octane';
 	const generatedBy = options.generatedBy ?? '@octanejs/app-core';
 	const static_map_lines = [...staticEntries]
 		.map(
@@ -175,7 +129,7 @@ export function create_client_entry_source(options = {}) {
 	return `// Auto-generated by ${generatedBy}.
 // This file is written to the active integration's project cache.
 
-import { hydrateRoot, initializeHydrationEventCapture, Suspense, ErrorBoundary, createElement } from ${JSON.stringify(runtimeModuleId)};
+${runtimeImport}
 
 // Capture once: an HMR runtime hash may change, this document's authority must not.
 const clientBuildId = ${options.clientBuildIdExpression ?? JSON.stringify(options.clientBuildId ?? null)};
@@ -309,7 +263,7 @@ async function bootstrapIndependentIslands(target) {
   await bootstrapDocumentLifecycle();
   if (documentLifecycle && !await documentLifecycle.whenActive()) return;
   if (independentBootstrap) return independentBootstrap;
-  independentBootstrap = import('octane/hydration').then(async ({ bootstrapIndependentHydration }) => {
+  independentBootstrap = ${hydrationModule}.then(async ({ bootstrapIndependentHydration }) => {
     if (incompatibleBuild) return;
     if (documentLifecycle && !await documentLifecycle.whenActive()) return;
     disposeIndependentHydration = bootstrapIndependentHydration(target, {
@@ -344,7 +298,76 @@ async function bootstrapDocumentLifecycle() {
   return lifecycleBootstrap;
 }
 
-function getComponentExport(module, exportName) {
+`;
+}
+
+/**
+ * Generate the client hydration entry (served at virtual:octane-hydrate).
+ *
+ * CONFIG-FREE: it does NOT import octane.config.ts. Importing the config into
+ * the browser would drag the plugin (and the server adapter) — with their
+ * `node:fs` imports — into the client graph and throw at module-eval. Instead
+ * the server serializes everything needed into #__octane_data ({ entry,
+ * exportName, layout, params, url, preHydrate }), and this entry
+ * dynamic-imports the page/layout from there.
+ *
+ * `staticEntries` (production builds) lists every module path the server can
+ * name in #__octane_data — page entries, layouts, and the preHydrate hook.
+ * Each becomes a STATIC `() => import('/src/…')` in a lookup map, so Rollup
+ * sees, chunks, and hashes them; the runtime falls back to a native dynamic
+ * import only for paths outside the map (the dev case, where the map is empty
+ * and the integration serves any module by URL). The fallback resolves the
+ * project-root ID against the browsing context's real location. Project IDs
+ * are root-absolute, so this has the same URL semantics as importing from this
+ * generated module while remaining immune to an authored `<base>` element.
+ * (Rspack rewrites `import.meta.url` to `document.baseURI` in classic output,
+ * so it cannot be used directly here.) Vite serves `.tsrx` modules through its
+ * canonical `?import` URL but leaves ordinary JavaScript/TypeScript URLs
+ * unchanged, while Rspack honors its ignore hint. Keeping the import native
+ * avoids requiring `unsafe-eval` under a nonce-based Content Security Policy.
+ *
+ * octane specifics:
+ *   - `initializeHydrationEventCapture()` runs before any async route work so
+ *     interaction boundaries can preserve intent that precedes `hydrateRoot()`.
+ *   - `import { hydrateRoot } from 'octane'` (NO `mount`).
+ *   - `hydrateRoot(container, body, props)` signature (container FIRST, React-18
+ *     shape) — no `{ target, props }` wrapper.
+ *   - The layout `children` is a props-first ComponentBody whose closure calls
+ *     `Page({ params, url }, scope, extra)`, NOT a 0-arg thunk: octane's
+ *     `childSlot` invokes a bare function child with `{}` props, so page data
+ *     rides the closure — mirroring the server `createLayoutWrapper`.
+ *   - hydrateRoot() itself locates/consumes the <script data-octane-suspense>
+ *     seed inside #root, so the entry does nothing special for suspense.
+ *   - `preHydrate` (config `router.preHydrate`, a project-root module ID) is
+ *     imported and its default export awaited BEFORE hydrateRoot — the hook an
+ *     app-level client router uses to commit its match tree so the first
+ *     hydration pass adopts the same resolved tree the server rendered.
+ *
+ * `getComponentExport` mirrors routes.js `get_component_export` (route named
+ * export > default > first PascalCase) so server and client pick the SAME
+ * component.
+ *
+ * @param {{
+ *   configPath?: string,
+ *   staticEntries?: Array<string | { id: string, specifier: string }>,
+ *   independentEntries?: Array<{ id: string, specifier: string }>,
+ *   clientBuildId?: string,
+ *   clientBuildIdExpression?: string,
+ *   devClientBuild?: boolean,
+ *   resolveImport?: (id: string) => string,
+ *   runtimeModuleId?: string,
+ *   generatedBy?: string,
+ * }} [options]
+ * @returns {string}
+ */
+export function create_client_entry_source(options = {}) {
+	const runtimeModuleId = options.runtimeModuleId ?? 'octane';
+	return (
+		client_entry_prelude(
+			options,
+			`import { hydrateRoot, initializeHydrationEventCapture, Suspense, ErrorBoundary, createElement } from ${JSON.stringify(runtimeModuleId)};`,
+		) +
+		`function getComponentExport(module, exportName) {
   // Explicit export name requires an exact match; do NOT fall back, so a
   // typo'd route renders nothing rather than the wrong component.
   if (exportName) return typeof module[exportName] === 'function' ? module[exportName] : undefined;
@@ -486,7 +509,83 @@ function withRootBoundary(content, boundary) {
     console.error('[octane] Failed to bootstrap client hydration.', error);
   }
 })();
-`;
+`
+	);
+}
+
+/**
+ * Generate the islands-only client entry (served at virtual:octane-islands).
+ *
+ * A route with `hydrate: 'islands'` keeps its server-rendered shell inert: this
+ * entry never imports the renderer, the route module, its layout, or a root
+ * boundary. It shares the full entry's build checks, intent capture, streamed
+ * signal and document lifecycle bootstrap, and independent island registry, in
+ * the same order, then runs the optional preHydrate hook. `staticEntries` needs
+ * only that hook.
+ *
+ * @param {Parameters<typeof create_client_entry_source>[0]} [options]
+ * @returns {string}
+ */
+export function create_islands_entry_source(options = {}) {
+	return (
+		client_entry_prelude(
+			options,
+			`import { bootstrapIndependentHydration, initializeHydrationEventCapture } from 'octane/hydration';`,
+			// Islands always register, so a static import lets the bundler keep
+			// only the bootstrap rather than the whole hydration namespace.
+			'Promise.resolve({ bootstrapIndependentHydration })',
+		) +
+		`(async () => {
+  try {
+    const el = document.getElementById('__octane_data');
+    const target = document.getElementById('root');
+    if (!el || !target) {
+      console.error('[octane] Unable to activate islands: missing #__octane_data or #root.');
+      return;
+    }
+    const data = JSON.parse(el.textContent || '{}');
+    documentData = data;
+    if (incompatibleBuild) return;
+    if (clientBuildId !== null || data.clientBuild != null) {
+      if (
+        typeof clientBuildId !== 'string' || !clientBuildId ||
+        data.clientBuild?.version !== 1 || data.clientBuild.buildId !== clientBuildId ||
+        !['production', 'development'].includes(data.clientBuild.mode) ||
+        typeof data.clientBuild.capabilities?.independentHydration !== 'boolean'
+      ) throw new Error('[octane] Client build identity does not match the server document.');
+      independentCapability ||= data.clientBuild.capabilities.independentHydration;
+    }
+    if (data.streamedSignals !== undefined && (
+      !data.clientBuild || data.streamedSignals?.buildId !== clientBuildId ||
+      typeof data.streamedSignals.documentId !== 'string' || !data.streamedSignals.documentId
+    )) throw new Error('[octane] Invalid streamed signal document identity.');
+    if (globalThis.__octaneStreamedSignalSelections !== undefined) {
+      if (!data.streamedSignals) throw new Error('[octane] Missing streamed signal document identity.');
+      signalHydrationModule = await import('octane/hydration/streamed-signals');
+      if (incompatibleBuild) return;
+      streamedHydration = signalHydrationModule.bootstrapStreamedSignalHydration(data.streamedSignals);
+      signalOwner = streamedHydration.signalOwner;
+      await bootstrapDocumentLifecycle();
+    }
+
+    // The shell stays server-owned: only its independent islands activate.
+    await bootstrapIndependentIslands(target);
+    if (incompatibleBuild) return;
+    if (documentLifecycle && !await documentLifecycle.whenActive()) return;
+
+    if (data.preHydrate) {
+      const preMod = await importModule(data.preHydrate);
+      if (incompatibleBuild) return;
+      if (documentLifecycle && !await documentLifecycle.whenActive()) return;
+      const hook = preMod.default;
+      if (typeof hook === 'function') await hook({ url: data.url, params: data.params });
+    }
+  } catch (error) {
+    console.error('[octane] Failed to bootstrap independent islands.', error);
+  }
+})();
+`
+	);
 }
 
 /**

package/src/resolve-config.js

@@ -77,6 +77,11 @@ function validate_render_route(route) {
 	if (status !== undefined && (typeof status !== 'number' || !Number.isInteger(status))) {
 		throw new Error('[octane] RenderRoute `status` must be an integer.');
 	}
+
+	const hydrate = /** @type {{ hydrate?: unknown }} */ (route).hydrate;
+	if (hydrate !== undefined && hydrate !== 'full' && hydrate !== 'islands') {
+		throw new Error("[octane] RenderRoute `hydrate` must be 'full' or 'islands'.");
+	}
 }
 
 /**

package/src/routes.js

@@ -82,6 +82,9 @@ export class RenderRoute {
 	/** @type {number | undefined} */
 	status;
 
+	/** @type {'full' | 'islands'} */
+	hydrate;
+
 	/**
 	 * @param {RenderRouteOptions} options
 	 */
@@ -95,6 +98,7 @@ export class RenderRoute {
 		this.layout = options.layout;
 		this.before = options.before ?? [];
 		this.status = options.status;
+		this.hydrate = options.hydrate ?? 'full';
 	}
 }
 

package/src/server/html-template.js

@@ -62,6 +62,28 @@ export function injectHydrationEntry(html, source, nonce) {
 	return html.replace(/<\/body\s*>/i, `${marker}${script}\n</body>`);
 }
 
+/**
+ * Point the template's one hydration bootstrap at another built entry. An
+ * islands-only route serves the same document with the renderer-free entry.
+ * @param {string} html
+ * @param {string} source
+ */
+export function replaceHydrationEntrySource(html, source) {
+	let replaced = 0;
+	const result = html.replace(/<script\b[^>]*>/gi, (tag) => {
+		if (!/\sdata-octane-hydrate(?:\s|=|>)/i.test(tag)) return tag;
+		replaced++;
+		return tag.replace(
+			/(\ssrc\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s>]+)/i,
+			(_match, prefix) => `${prefix}"${escapeAttribute(source)}"`,
+		);
+	});
+	if (replaced !== 1 || result === html) {
+		throw new Error('[octane] Islands-only routes require one external hydration bootstrap entry.');
+	}
+	return result;
+}
+
 /**
  * Split a validated template around its one SSR body marker.
  * @param {string} html

package/src/server/production.js

@@ -37,6 +37,7 @@ import {
 	getContextNonce,
 	nonceAttribute,
 	prepareStreamingHydrationTemplate,
+	replaceHydrationEntrySource,
 	splitSsrTemplate,
 	validateSsrTemplate,
 } from './html-template.js';
@@ -286,6 +287,21 @@ function prepareClientBuild(manifest) {
 	});
 }
 
+/**
+ * The normalized no-nonce template and its prepared splits, for one bootstrap.
+ * @param {string} template
+ */
+function createTemplateSet(template) {
+	const normalized = applyHydrationNonce(template, null);
+	/** @type {ReturnType<typeof prepareSsrTemplate> | undefined} */
+	let early;
+	return {
+		template,
+		split: prepareSsrTemplate(normalized),
+		early: () => (early ??= prepareSsrTemplate(normalized, true)),
+	};
+}
+
 /**
  * @param {ServerManifest} manifest
  * @param {RenderRoute} route
@@ -315,7 +331,9 @@ function prepareRouteAssetHead(manifest, route, entryPath) {
 	}
 	// Only the page chunk was already eager; do not promote layout, fallback,
 	// or island JavaScript while making their server-rendered CSS available.
-	const entryAssets = entryPath ? clientAssets?.[entryPath] : undefined;
+	// An islands-only route never loads its page chunk at all.
+	const entryAssets =
+		entryPath && route.hydrate !== 'islands' ? clientAssets?.[entryPath] : undefined;
 	if (entryAssets?.js) {
 		tags.push(`<link rel="modulepreload" href="/${entryAssets.js}">`);
 	}
@@ -351,10 +369,24 @@ export function createHandler(manifest, deps) {
 	// the integration's HTML transform and survives source hashing. Prepare the
 	// normalized no-nonce template once: this is the common request path, and its
 	// static fragments are identical for every request handled by this manifest.
-	const normalizedTemplate = applyHydrationNonce(htmlTemplate, null);
-	const splitHydrationTemplate = prepareSsrTemplate(normalizedTemplate);
-	/** @type {ReturnType<typeof prepareSsrTemplate> | undefined} */
-	let splitEarlyHydrationTemplate;
+	const fullTemplate = createTemplateSet(htmlTemplate);
+	// An islands-only route serves the same document with the renderer-free
+	// entry, so its shell's JavaScript is never requested.
+	const islandsTemplate = manifest.routes.some(
+		(route) => route.type === 'render' && route.hydrate === 'islands',
+	)
+		? createTemplateSet(
+				replaceHydrationEntrySource(
+					htmlTemplate,
+					manifest.islandsEntry ??
+						(() => {
+							throw new Error(
+								"[octane] RenderRoute hydrate: 'islands' requires a client build with an islands entry.",
+							);
+						})(),
+				),
+			)
+		: null;
 
 	// RPC lookup for statically imported `module server` functions
 	// (compiler hash → server function).
@@ -538,7 +570,9 @@ export function createHandler(manifest, deps) {
 			if (preparedRoute) preparedRoute.assetHead = assetHead;
 		}
 		const headContent = assetHead === '' ? dataScript : assetHead + '\n' + dataScript;
-		const noncedTemplate = nonce === null ? null : applyHydrationNonce(htmlTemplate, nonce);
+		const templates =
+			route.hydrate === 'islands' ? (islandsTemplate ?? fullTemplate) : fullTemplate;
+		const noncedTemplate = nonce === null ? null : applyHydrationNonce(templates.template, nonce);
 
 		const status = route.status ?? 200;
 		const headers = { 'Content-Type': 'text/html; charset=utf-8' };
@@ -560,9 +594,7 @@ export function createHandler(manifest, deps) {
 			const completeHead = headContent + hoistedHead;
 			if (noncedTemplate !== null)
 				return prepareSsrTemplate(noncedTemplate, earlyHydration)(completeHead);
-			if (!earlyHydration) return splitHydrationTemplate(completeHead);
-			splitEarlyHydrationTemplate ??= prepareSsrTemplate(normalizedTemplate, true);
-			return splitEarlyHydrationTemplate(completeHead);
+			return (earlyHydration ? templates.early() : templates.split)(completeHead);
 		};
 
 		if (manifest.render === 'buffered') {

package/src/server/rpc.js

@@ -80,7 +80,7 @@ function withRpcCors(response, origin) {
 
 	const headers = new Headers(response.headers);
 	headers.set('Access-Control-Allow-Origin', origin);
-	headers.set('Access-Control-Expose-Headers', 'Octane-RPC-Outcome');
+	headers.append('Access-Control-Expose-Headers', 'Octane-RPC-Outcome');
 	headers.append('Vary', 'Origin');
 	return new Response(response.body, {
 		status: response.status,

package/src/server/server-entry.js

@@ -45,6 +45,7 @@ import { get_route_entry_export_name, get_route_entry_path } from '../routes.js'
  * @property {string} [clientBuildFile] - Required completed client metadata, resolved beside the server entry
  * @property {Record<string, unknown>} [independentHydrationManifest] - Completed client-build independent Hydrate manifest
  * @property {string} [independentHydrationManifestFile] - Optional JSON manifest resolved beside the built server entry
+ * @property {string | null} [islandsEntry] - Template URL of the renderer-free bootstrap for `hydrate: 'islands'` routes
  * @property {Record<string, string>} [moduleImports] - Stable module ID → bundler import specifier
  * @property {((id: string) => string)} [resolveImport] - Fallback module-specifier mapper
  * @property {string} [configImportPath] - Bundler import specifier for octane.config.ts
@@ -73,6 +74,7 @@ export function generateServerEntry(options) {
 		clientBuildFile,
 		independentHydrationManifest,
 		independentHydrationManifestFile,
+		islandsEntry = null,
 		moduleImports = {},
 		resolveImport,
 		configImportPath,
@@ -328,6 +330,7 @@ export const manifest = {
 	clientAssets,
 	clientBuild,
 	independentHydration,
+	islandsEntry: ${JSON.stringify(islandsEntry)},
 };
 
 export const rendererDeps = {
@@ -450,6 +453,7 @@ export const handler = createHandler(
 		clientAssets,
 		clientBuild,
 		independentHydration,
+		islandsEntry: ${JSON.stringify(islandsEntry)},
 	},
 	{
 		renderToReadableStream,

package/types/codegen.d.ts

@@ -48,6 +48,8 @@ export interface ClientEntryOptions {
 }
 
 export function create_client_entry_source(options?: ClientEntryOptions): string;
+/** The renderer-free entry for `hydrate: 'islands'` routes; it never imports `octane`. */
+export function create_islands_entry_source(options?: ClientEntryOptions): string;
 
 export interface ServerEntryOptions {
 	routes: Route[];
@@ -64,6 +66,8 @@ export interface ServerEntryOptions {
 	independentHydrationManifest?: import('@octanejs/app-core/production').IndependentHydrationBuildManifest;
 	/** Optional JSON manifest resolved beside the built server entry. */
 	independentHydrationManifestFile?: string;
+	/** Template URL of the renderer-free bootstrap for `hydrate: 'islands'` routes. */
+	islandsEntry?: string | null;
 	/** Stable application module ID to emitted bundler import specifier. */
 	moduleImports?: Record<string, string>;
 	resolveImport?: (id: string) => string;

package/types/index.d.ts

@@ -26,9 +26,17 @@ export class RenderRoute {
 	layout?: string;
 	before: Middleware[];
 	status?: number;
+	hydrate: RenderRouteHydration;
 	constructor(options: RenderRouteOptions);
 }
 
+/**
+ * `'full'` hydrates the route's component tree. `'islands'` ships only the
+ * independent `<Hydrate>` islands: the shell stays server-rendered HTML and its
+ * JavaScript never loads.
+ */
+export type RenderRouteHydration = 'full' | 'islands';
+
 export class ServerRoute {
 	readonly type: 'server';
 	path: string;
@@ -77,6 +85,12 @@ export interface RenderRouteOptions {
 	 * catch-all route so the SSR'd not-found page reports its real status.
 	 */
 	status?: number;
+	/**
+	 * `'islands'` serves an immutable server-rendered shell and activates only its
+	 * independent `<Hydrate>` islands. The build rejects a shell with client work.
+	 * Defaults to `'full'`.
+	 */
+	hydrate?: RenderRouteHydration;
 }
 
 export interface ServerRouteOptions {

package/types/production.d.ts

@@ -82,6 +82,11 @@ export interface ServerManifest {
 	clientBuild?: ClientBuildManifest | null;
 	/** Client-build records used to complete strict independent Hydrate sidecars. */
 	independentHydration?: IndependentHydrationBuildManifest | null;
+	/**
+	 * Template URL of the renderer-free bootstrap that replaces the hydration entry
+	 * for `hydrate: 'islands'` routes. Required when any route opts in.
+	 */
+	islandsEntry?: string | null;
 }
 
 export interface HandlerOptions {

package/types/routes.d.ts

@@ -9,6 +9,7 @@ export {
 } from '@octanejs/app-core';
 export type {
 	RenderRouteEntry,
+	RenderRouteHydration,
 	RenderRouteOptions,
 	Route,
 	RouteMatch,