@octanejs/app-core 0.0.50 → 0.0.51

package/src/server/server-calls.js

@@ -0,0 +1,132 @@
+// @ts-check
+import { createContext, runMiddlewareChain } from './middleware.js';
+
+/**
+ * Snapshot trusted middleware output only after this invocation was authorized.
+ * @param {import('@octanejs/app-core').Context} context
+ * @param {AbortSignal} [signal]
+ * @returns {import('octane/server').ServerCallContext}
+ */
+export function serverCallContext(context, signal = context.request.signal) {
+	return Object.freeze({
+		request: context.request,
+		signal,
+		viewer: context.viewer,
+		...(context.platform === undefined ? {} : { platform: context.platform }),
+	});
+}
+
+/**
+ * Each nested call gets a separate middleware context and async store. Reusing
+ * the parent's mutable `rpc` field would cross-authorize concurrent members.
+ * @param {import('@octanejs/app-core').Context} parent
+ * @param {Pick<import('@octanejs/app-core').RpcRequestOptions, 'asyncContext' | 'middlewares'> & { origin: string }} options
+ * @returns {import('octane/server').ServerCallHost}
+ */
+export function createServerCallHost(parent, options) {
+	return {
+		/**
+		 * @template T
+		 * @param {import('octane/server').ServerFunctionTarget} target
+		 * @param {import('octane/server').ServerCallOptions} callOptions
+		 * @param {(context: import('octane/server').ServerCallContext) => T} execute
+		 * @returns {Promise<Awaited<T>>}
+		 */
+		async invoke(target, callOptions, execute) {
+			const signal =
+				callOptions.signal === undefined
+					? parent.request.signal
+					: AbortSignal.any([parent.request.signal, callOptions.signal]);
+			signal.throwIfAborted();
+			const context = createContext(parent.request, { ...parent.params }, parent.platform);
+			context.state = new Map(parent.state);
+			context.viewer = parent.viewer;
+			context.rpc = Object.freeze({ ...target });
+			const store = {
+				signalRequestContext:
+					options.asyncContext.getStore()?.signalRequestContext ??
+					options.asyncContext.getStore()?.context ??
+					parent,
+				origin: options.origin,
+				context,
+				platform: parent.platform,
+				serverCallHost: createServerCallHost(context, options),
+			};
+			return await options.asyncContext.run(store, async () => {
+				let invoked = false;
+				/** @type {{ value: Awaited<T> } | undefined} */
+				let result;
+				const response = await runMiddlewareChain(
+					context,
+					options.middlewares ?? [],
+					[],
+					async () => {
+						signal.throwIfAborted();
+						invoked = true;
+						result = { value: await execute(serverCallContext(context, signal)) };
+						return new Response(null, { status: 204 });
+					},
+				);
+				if (!invoked || !response.ok || result === undefined) {
+					throw Object.assign(new Error('Server function call was rejected by middleware'), {
+						code: 'OCTANE_SERVER_CALL_REJECTED',
+						status: response.ok ? 403 : response.status,
+						invoked,
+					});
+				}
+				const value = result.value;
+				// Async generators execute on next(), not when their function returns.
+				// Keep those later pulls in this invocation's authorized request store.
+				if (value !== null && typeof value === 'object' && Symbol.asyncIterator in value) {
+					const iterable = /** @type {AsyncIterable<unknown>} */ (value);
+					return /** @type {typeof value} */ ({
+						[Symbol.asyncIterator]() {
+							const iterator = Promise.resolve(
+								options.asyncContext.run(store, () => iterable[Symbol.asyncIterator]()),
+							);
+							let closed = false;
+							const close = () => {
+								if (closed) return Promise.resolve({ done: true, value: undefined });
+								closed = true;
+								signal.removeEventListener('abort', abort);
+								return iterator.then((producer) =>
+									options.asyncContext.run(
+										store,
+										() => producer.return?.() ?? { done: true, value: undefined },
+									),
+								);
+							};
+							const abort = () => {
+								void close().catch(() => {});
+							};
+							signal.addEventListener('abort', abort, { once: true });
+							return {
+								async next() {
+									try {
+										signal.throwIfAborted();
+										if (closed) return { done: true, value: undefined };
+										const producer = await iterator;
+										if (closed) return { done: true, value: undefined };
+										const result = await options.asyncContext.run(store, () => producer.next());
+										signal.throwIfAborted();
+										if (closed) return { done: true, value: undefined };
+										if (result.done) {
+											closed = true;
+											signal.removeEventListener('abort', abort);
+										}
+										return result;
+									} catch (error) {
+										void close().catch(() => {});
+										throw error;
+									}
+								},
+								return: close,
+							};
+						},
+					});
+				}
+				return value;
+			});
+		},
+	};
+}

package/src/server/server-entry.js

@@ -29,7 +29,7 @@
  */
 
 /** @import { Route, RootBoundaryOptions } from '@octanejs/app-core' */
-/** @import { ClientAssetEntry } from '../../types/production.d.ts' */
+/** @import { ClientAssetEntry } from '@octanejs/app-core/production' */
 
 import { get_route_entry_export_name, get_route_entry_path } from '../routes.js';
 
@@ -41,6 +41,10 @@ import { get_route_entry_export_name, get_route_entry_path } from '../routes.js'
  * @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
+ * @property {import('@octanejs/app-core/production').ClientBuildManifest} [clientBuild] - Completed client compilation identity
+ * @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 {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
@@ -65,6 +69,10 @@ export function generateServerEntry(options) {
 		rpcModulePaths = [],
 		clientAssetMap = {},
 		clientAssetMapFile,
+		clientBuild,
+		clientBuildFile,
+		independentHydrationManifest,
+		independentHydrationManifestFile,
 		moduleImports = {},
 		resolveImport,
 		configImportPath,
@@ -168,10 +176,29 @@ export function generateServerEntry(options) {
 			return `\t${JSON.stringify(modulePath)}: ${varName}._$_server_$_,`;
 		})
 		.join('\n');
+	const independentHydrationSource = independentHydrationManifestFile
+		? `(() => {
+	try {
+		return JSON.parse(readFileSync(join(__dirname, ${JSON.stringify(independentHydrationManifestFile)}), 'utf-8'));
+	} catch (error) {
+		if (error && typeof error === 'object' && error.code === 'ENOENT') return null;
+		throw error;
+	}
+})()`
+		: JSON.stringify(independentHydrationManifest ?? null, null, '\t');
+	const clientBuildSource = clientBuildFile
+		? `(() => {
+	const value = JSON.parse(readFileSync(join(__dirname, ${JSON.stringify(clientBuildFile)}), 'utf-8'));
+	if (value == null) throw new Error('[octane] Completed client build metadata is required.');
+	return value;
+})()`
+		: JSON.stringify(clientBuild ?? null, null, '\t');
 
 	if (mode === 'manifest' || mode === 'webworker') {
 		const isWebWorker = mode === 'webworker';
-		const readsAssetFile = !isWebWorker && Boolean(clientAssetMapFile);
+		const readsAssetFile =
+			!isWebWorker &&
+			Boolean(clientAssetMapFile || independentHydrationManifestFile || clientBuildFile);
 		const assetFileImports = readsAssetFile
 			? `import { readFileSync } from 'node:fs';\nimport { fileURLToPath } from 'node:url';\nimport { dirname, join } from 'node:path';\n`
 			: '';
@@ -185,7 +212,9 @@ export function generateServerEntry(options) {
 			? `const __dirname = dirname(fileURLToPath(import.meta.url));\n`
 			: '';
 		const clientAssets = readsAssetFile
-			? `JSON.parse(readFileSync(join(__dirname, ${JSON.stringify(clientAssetMapFile)}), 'utf-8'))`
+			? clientAssetMapFile
+				? `JSON.parse(readFileSync(join(__dirname, ${JSON.stringify(clientAssetMapFile)}), 'utf-8'))`
+				: JSON.stringify(clientAssetMap, null, '\t')
 			: JSON.stringify(clientAssetMap, null, '\t');
 		const runtime = isWebWorker
 			? `const runtime = octaneConfig.adapter?.runtime;
@@ -203,9 +232,15 @@ if (!runtime) {
 };`;
 		const workerFactory = isWebWorker
 			? `
-export function createWebWorkerHandler({ htmlTemplate, clientAssets = manifest.clientAssets }) {
+export function createWebWorkerHandler({
+	htmlTemplate,
+	clientAssets = manifest.clientAssets,
+	clientBuild = manifest.clientBuild,
+	independentHydration = manifest.independentHydration,
+}) {
+	if (!clientBuild) throw new Error('[octane] Completed client build metadata is required.');
 	return createHandler(
-		{ ...manifest, clientAssets },
+		{ ...manifest, clientAssets, clientBuild, independentHydration },
 		{ ...rendererDeps, htmlTemplate },
 	);
 }
@@ -222,6 +257,10 @@ export function createWebWorkerHandler({ htmlTemplate, clientAssets = manifest.c
 ${assetFileImports}${platformImports}import {
 	renderToReadableStream,
 	executeServerFunction,
+	executeServerFunctionStream,
+	executeServerFunctionBatch,
+	installSignalOwnerEnvironment,
+	retireSignalOwnerIdentity,
 	Suspense,
 	ErrorBoundary,
 	createElement,
@@ -270,6 +309,8 @@ ${rpc_entries}
 };
 
 ${assetDirectory}const clientAssets = ${clientAssets};
+const clientBuild = ${isWebWorker && clientBuildFile ? 'null' : clientBuildSource};
+const independentHydration = ${isWebWorker && independentHydrationManifestFile ? 'null' : independentHydrationSource};
 
 export const manifest = {
 	routes: octaneConfig.router.routes,
@@ -285,12 +326,17 @@ export const manifest = {
 	rpcModules,
 	runtime,
 	clientAssets,
+	clientBuild,
+	independentHydration,
 };
 
 export const rendererDeps = {
 	renderToReadableStream,
 	prerender,
 	executeServerFunction,
+	streamServerFunction: executeServerFunctionStream,
+	batchServerFunctions: executeServerFunctionBatch,
+	signalOwners: { install: installSignalOwnerEnvironment, retire: retireSignalOwnerIdentity },
 	Suspense,
 	ErrorBoundary,
 	createElement,
@@ -312,6 +358,10 @@ import { dirname, join, resolve } from 'node:path';
 import {
 	renderToReadableStream,
 	executeServerFunction,
+	executeServerFunctionStream,
+	executeServerFunctionBatch,
+	installSignalOwnerEnvironment,
+	retireSignalOwnerIdentity,
 	Suspense,
 	ErrorBoundary,
 	createElement,
@@ -380,6 +430,8 @@ const clientAssets = ${
 			? `JSON.parse(readFileSync(join(__dirname, ${JSON.stringify(clientAssetMapFile)}), 'utf-8'))`
 			: JSON.stringify(clientAssetMap, null, '\t')
 	};
+const independentHydration = ${independentHydrationSource};
+const clientBuild = ${clientBuildSource};
 
 export const handler = createHandler(
 	{
@@ -396,12 +448,17 @@ export const handler = createHandler(
 		rpcModules,
 		runtime,
 		clientAssets,
+		clientBuild,
+		independentHydration,
 	},
 	{
 		renderToReadableStream,
 		prerender,
 		htmlTemplate,
 		executeServerFunction,
+		streamServerFunction: executeServerFunctionStream,
+		batchServerFunctions: executeServerFunctionBatch,
+		signalOwners: { install: installSignalOwnerEnvironment, retire: retireSignalOwnerIdentity },
 		Suspense,
 		ErrorBoundary,
 		createElement,

package/src/server/signal-owners.js

@@ -0,0 +1,182 @@
+// @ts-check
+/** @typedef {import('@octanejs/app-core').RpcRequestOptions['asyncContext']} RequestStorage */
+/** @typedef {NonNullable<ReturnType<RequestStorage['getStore']>>} RequestStore */
+/** @typedef {import('@octanejs/app-core').SignalRequestHooks} SignalRequestHooks */
+
+/** @type {WeakMap<object, WeakSet<SignalRequestHooks['install']>>} */
+const installed = new WeakMap();
+/** @type {WeakMap<object, import('octane/server').SignalOwner>} */
+const owners = new WeakMap();
+const retired = new WeakSet();
+
+/**
+ * Signal reads are synchronous even though the adapter's broad run() type also
+ * permits an async wrapper. Capture the callback's actual result, and fail
+ * clearly (without invoking delayed work) if the provider defers entry itself.
+ * @template T
+ * @param {RequestStorage} storage
+ * @param {RequestStore} store
+ * @param {() => T} callback
+ * @returns {T}
+ */
+function runSynchronous(storage, store, callback) {
+	/** @type {{ value: T } | { error: unknown } | undefined} */
+	let outcome;
+	let entering = true;
+	try {
+		const pending = storage.run(store, () => {
+			if (!entering) return;
+			try {
+				outcome = { value: callback() };
+			} catch (error) {
+				outcome = { error };
+			}
+		});
+		// Callback exceptions are preserved in outcome; an async context wrapper
+		// must not leave an unobserved promise when synchronous entry is rejected.
+		if (pending !== undefined) void Promise.resolve(pending).catch(() => {});
+	} finally {
+		entering = false;
+	}
+	if (outcome === undefined)
+		throw new Error('Signal owners require synchronous request-context entry');
+	if ('error' in outcome) throw outcome.error;
+	return outcome.value;
+}
+
+/**
+ * @param {RequestStorage} storage
+ * @param {SignalRequestHooks} hooks
+ */
+function install(storage, hooks) {
+	let environments = installed.get(storage);
+	if (environments?.has(hooks.install)) return;
+	if (!environments) {
+		environments = new WeakSet();
+		installed.set(storage, environments);
+	}
+	/** @param {RequestStore | undefined} store */
+	const rootContext = (store) => store?.signalRequestContext ?? store?.context;
+	hooks.install({
+		current() {
+			const store = storage.getStore();
+			const root = rootContext(store);
+			if (root && retired.has(root)) throw new Error('The signal request owner has retired');
+			if (store?.signalOwner !== undefined) return store.signalOwner;
+			if (!root) return null;
+			let owner = owners.get(root);
+			if (!owner) {
+				owner = Object.freeze({ scopeKey: 'octane:document' });
+				owners.set(root, owner);
+			}
+			return owner;
+		},
+		run(owner, callback) {
+			const store = storage.getStore();
+			return runSynchronous(
+				storage,
+				{ ...store, signalOwner: owner, signalRequestContext: rootContext(store) },
+				callback,
+			);
+		},
+		capture(owner) {
+			// Capture the request now, not whichever request later invokes this callback.
+			const store = storage.getStore();
+			return (callback) =>
+				runSynchronous(
+					storage,
+					{ ...store, signalOwner: owner, signalRequestContext: rootContext(store) },
+					callback,
+				);
+		},
+	});
+	environments.add(hooks.install);
+}
+
+/**
+ * Keep one lazy signal identity through middleware, sibling renders, and later
+ * response pulls. Completion retires the subscription owner, never a separately
+ * accepted durable server operation.
+ * @param {RequestStorage} storage
+ * @param {RequestStore} store
+ * @param {SignalRequestHooks | undefined} hooks
+ * @param {() => Promise<Response>} callback
+ * @returns {Promise<Response>}
+ */
+export async function runServerRequest(storage, store, hooks, callback) {
+	if (hooks === undefined) return storage.run(store, callback);
+	install(storage, hooks);
+	const root = store.signalRequestContext ?? store.context;
+	let finished = false;
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		store.context?.request.signal.removeEventListener('abort', abort);
+		if (root) {
+			retired.add(root);
+			const owner = owners.get(root);
+			if (owner) hooks.retire(owner);
+		}
+	};
+	/** @type {ReadableStreamDefaultReader<Uint8Array> | undefined} */
+	let reader;
+	const abort = () => {
+		// Cancel before retirement so iterator finally blocks still have their owner.
+		const pending = storage.run(store, () => reader?.cancel());
+		finish();
+		void Promise.resolve(pending).catch(() => {});
+	};
+	try {
+		const response = await storage.run(store, callback);
+		if (response.body === null) {
+			finish();
+			return response;
+		}
+		reader = response.body.getReader();
+		const bodyReader = reader;
+		store.context?.request.signal.addEventListener('abort', abort, { once: true });
+		if (store.context?.request.signal.aborted) abort();
+		return new Response(
+			new ReadableStream(
+				{
+					pull(controller) {
+						return storage.run(store, async () => {
+							try {
+								const item = await bodyReader.read();
+								if (item.done) {
+									bodyReader.releaseLock();
+									finish();
+									controller.close();
+								} else controller.enqueue(item.value);
+							} catch (error) {
+								finish();
+								controller.error(error);
+							}
+						});
+					},
+					cancel(reason) {
+						return storage.run(store, async () => {
+							try {
+								const pending = bodyReader.cancel(reason);
+								finish();
+								await pending;
+							} finally {
+								bodyReader.releaseLock();
+								finish();
+							}
+						});
+					},
+				},
+				{ highWaterMark: 0 },
+			),
+			{
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers,
+			},
+		);
+	} catch (error) {
+		finish();
+		throw error;
+	}
+}

package/types/codegen.d.ts

@@ -25,9 +25,23 @@ export interface StaticClientEntry {
 	specifier: string;
 }
 
+export interface IndependentClientEntry {
+	/** Opaque module ID written into the independent hydration build manifest. */
+	id: string;
+	/** Bundler-resolvable compiler query whose default export is the activator. */
+	specifier: string;
+}
+
 export interface ClientEntryOptions {
 	configPath?: string;
 	staticEntries?: Array<string | StaticClientEntry>;
+	independentEntries?: IndependentClientEntry[];
+	/** Immutable token embedded before the client bundle is hashed. */
+	clientBuildId?: string;
+	/** Trusted bundler expression (for example Rspack's __webpack_hash__). */
+	clientBuildIdExpression?: string;
+	/** Subscribe to Vite's current-build capability discovery in development. */
+	devClientBuild?: boolean;
 	resolveImport?: (id: string) => string;
 	runtimeModuleId?: string;
 	generatedBy?: string;
@@ -43,6 +57,13 @@ export interface ServerEntryOptions {
 	clientAssetMap?: Record<string, ClientAssetEntry>;
 	/** JSON file resolved beside the built server entry at module evaluation. */
 	clientAssetMapFile?: string;
+	clientBuild?: import('@octanejs/app-core/production').ClientBuildManifest;
+	/** Required completed-client metadata; a missing file is an error. */
+	clientBuildFile?: string;
+	/** Completed client-build metadata for strict independent Hydrate boundaries. */
+	independentHydrationManifest?: import('@octanejs/app-core/production').IndependentHydrationBuildManifest;
+	/** Optional JSON manifest resolved beside the built server entry. */
+	independentHydrationManifestFile?: string;
 	/** Stable application module ID to emitted bundler import specifier. */
 	moduleImports?: Record<string, string>;
 	resolveImport?: (id: string) => string;

package/types/html.d.ts

@@ -5,10 +5,15 @@ export function composeHtmlStream(
 	prefix: string,
 	renderStream: ReadableStream<Uint8Array>,
 	suffix: string,
+	afterShell?: string,
 ): ReadableStream<Uint8Array>;
 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];
+export function prepareStreamingHydrationTemplate(html: string): {
+	html: string;
+	afterShell: string;
+};
 export function applyHydrationNonce(html: string, nonce?: string | null): string;
 export function nonceAttribute(nonce?: string | null): string;
 export function getContextNonce(context: Context): string | null;

package/types/index.d.ts

@@ -97,6 +97,10 @@ export interface ServerRouteOptions {
 // ============================================================================
 
 export interface Context {
+	/** Trusted completed client generation. Browser routing data is not authorization. */
+	readonly clientBuild?: import('./production.js').ClientBuildManifest;
+	/** Production asset identities; development renders retain inline scoped CSS. */
+	readonly clientAssets?: Readonly<Record<string, import('./production.js').ClientAssetEntry>>;
 	/** The incoming Request object */
 	request: Request;
 	/** URL parameters extracted from the route pattern */
@@ -109,6 +113,8 @@ export interface Context {
 	 * renderer inline scripts, hydration data, and the hydrate module script.
 	 */
 	state: Map<string, unknown>;
+	/** Identity established by authorization middleware, never by browser RPC arguments. */
+	viewer?: unknown;
 	/** Request-scoped bindings supplied by the active platform integration. */
 	platform?: unknown;
 	/**
@@ -168,6 +174,11 @@ export function handleServerRoute(
 export function is_rpc_request(pathname: string): boolean;
 
 /** Security policy and execution dependencies for a server-function request. */
+export interface SignalRequestHooks {
+	install: typeof import('octane/server').installSignalOwnerEnvironment;
+	retire: typeof import('octane/server').retireSignalOwnerIdentity;
+}
+
 export interface RpcRequestOptions {
 	resolveFunction: (hash: string) => Function | null | Promise<Function | null>;
 	/**
@@ -177,8 +188,30 @@ export interface RpcRequestOptions {
 	 * mapping, and the middleware chain must not wait on it.
 	 */
 	describeFunction?: (hash: string) => { module: string; export: string } | null;
-	executeServerFunction: (fn: Function, body: string) => Promise<string>;
-	asyncContext: AsyncContext<{ origin?: string; platform?: unknown; context?: Context }>;
+	executeServerFunction: (
+		fn: Function,
+		body: string,
+		context?: import('octane/server').ServerCallContext,
+	) => Promise<string>;
+	streamServerFunction?: (
+		fn: Function,
+		body: string,
+		context: import('octane/server').ServerCallContext,
+		limits?: import('octane/server').ServerResultLimits,
+	) => ReadableStream<Uint8Array> | Promise<ReadableStream<Uint8Array>>;
+	resultLimits?: import('octane/server').ServerResultLimits;
+	batchServerFunctions?: (
+		...args: Parameters<typeof import('octane/server').executeServerFunctionBatch>
+	) => ReadableStream<Uint8Array> | Promise<ReadableStream<Uint8Array>>;
+	asyncContext: AsyncContext<{
+		origin?: string;
+		platform?: unknown;
+		context?: Context;
+		serverCallHost?: import('octane/server').ServerCallHost;
+		signalOwner?: import('octane/server').SignalOwner;
+		signalRequestContext?: Context;
+	}>;
+	signalOwners?: SignalRequestHooks;
 	trustProxy?: boolean;
 	middlewares?: Middleware[];
 	allowedOrigins?: readonly string[];
@@ -189,6 +222,21 @@ export interface RpcRequestOptions {
 /** Apply Octane's security policy and global middleware to a server function. */
 export function handleRpcRequest(request: Request, options: RpcRequestOptions): Promise<Response>;
 
+/** Shared request boundary for dev, production, and host-managed render routes. */
+export function runServerRequest(
+	storage: RpcRequestOptions['asyncContext'],
+	store: NonNullable<ReturnType<RpcRequestOptions['asyncContext']['getStore']>>,
+	hooks: SignalRequestHooks | undefined,
+	callback: () => Promise<Response>,
+): Promise<Response>;
+
+export function createServerCallHost(
+	parent: Context,
+	options: Pick<RpcRequestOptions, 'asyncContext' | 'middlewares'> & { origin: string },
+): import('octane/server').ServerCallHost;
+
+export function setRequestContextSource(storage: RpcRequestOptions['asyncContext']): void;
+
 /**
  * The `Context` for the in-flight request.
  *
@@ -430,6 +478,8 @@ export interface OctaneConfigOptions {
 			allowedOrigins?: string[];
 			/** Maximum encoded request size in bytes. @default 1048576 */
 			maxBodyBytes?: number;
+			/** Budgets for the opt-in streamed response, separate from request size. */
+			resultLimits?: import('octane/server').ServerResultLimits;
 		};
 		/**
 		 * Production SSR mode: 'streaming' (default) flushes the shell at
@@ -477,6 +527,8 @@ export interface ResolvedOctaneConfig {
 			allowedOrigins: string[];
 			/** Maximum encoded request size in bytes. @default 1048576 */
 			maxBodyBytes: number;
+			/** Explicit response-frame, total-byte, and invocation-deadline budgets. */
+			resultLimits?: import('octane/server').ServerResultLimits;
 		};
 		/** @default 'streaming' */
 		render: 'streaming' | 'buffered';