@bleedingdev/modern-js-renderer-octane 0.0.0-stage → 3.9.3-ultramodern.10

package/dist/esm/manifest.mjs

@@ -0,0 +1,117 @@
+import { nativeModuleManifestFilename, readRendererIdentity } from "@modern-js/renderer-core/identity";
+import { assertNativeHydrationBuildId, assertOctaneIdentity } from "./bootstrap.mjs";
+const OCTANE_RUNTIME_VERSION = '0.13.8';
+const OCTANE_COMPILER_VERSION = '0.2.4';
+function octaneModuleManifestFileName(entryName) {
+    return nativeModuleManifestFilename('octane', entryName);
+}
+function record(value, fields) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) throw new Error('Malformed Octane compiler manifest object.');
+    if (Object.keys(value).some((key)=>!fields.includes(key))) throw new Error('Octane compiler manifest contains an unknown field.');
+    return value;
+}
+function digest(value) {
+    return 'string' == typeof value && /^[a-f\d]{64}$/u.test(value);
+}
+function nonempty(value) {
+    return 'string' == typeof value && value.trim().length > 0 && !value.includes('\0');
+}
+function assetPath(value) {
+    return nonempty(value) && value.endsWith('.js') && !value.startsWith('/') && !value.includes('\\') && !value.split('/').some((part)=>'..' === part || '.' === part || !part);
+}
+const validatedManifests = new WeakMap();
+function validateOctaneModuleManifest(value, expectedIdentity, expectedNativeHydrationBuildId) {
+    assertOctaneIdentity(expectedIdentity);
+    const cached = value && 'object' == typeof value ? validatedManifests.get(value) : void 0;
+    const manifest = cached ?? readOctaneModuleManifest(value);
+    readRendererIdentity(manifest.rendererIdentity, expectedIdentity);
+    if (void 0 !== expectedNativeHydrationBuildId) {
+        assertNativeHydrationBuildId(expectedNativeHydrationBuildId);
+        if (manifest.nativeHydrationBuildId !== expectedNativeHydrationBuildId) throw new Error('Octane native hydration build differs from the compiled client.');
+    }
+    if (!cached) {
+        validatedManifests.set(value, manifest);
+        validatedManifests.set(manifest, manifest);
+    }
+    return manifest;
+}
+function readOctaneModuleManifest(value) {
+    const manifest = record(value, [
+        'schemaVersion',
+        'renderer',
+        'runtimeVersion',
+        'compilerVersion',
+        'rendererIdentity',
+        'nativeHydrationBuildId',
+        'sourceModules',
+        'assets'
+    ]);
+    if (1 !== manifest.schemaVersion || 'octane' !== manifest.renderer || manifest.runtimeVersion !== OCTANE_RUNTIME_VERSION || manifest.compilerVersion !== OCTANE_COMPILER_VERSION) throw new Error('Octane compiler manifest ABI conflicts with the application.');
+    const rendererIdentity = readRendererIdentity(manifest.rendererIdentity, manifest.rendererIdentity);
+    const nativeHydrationBuildId = manifest.nativeHydrationBuildId;
+    assertNativeHydrationBuildId(nativeHydrationBuildId);
+    if (!Array.isArray(manifest.assets) || !manifest.assets.length) throw new Error('Octane compiler manifest has no emitted JavaScript closure.');
+    const assetNames = new Set();
+    const assets = manifest.assets.map((value)=>{
+        const asset = record(value, [
+            'file',
+            'sha256'
+        ]);
+        if (!assetPath(asset.file) || !digest(asset.sha256) || assetNames.has(asset.file)) throw new Error('Invalid Octane emitted asset digest.');
+        assetNames.add(asset.file);
+        return Object.freeze({
+            file: asset.file,
+            sha256: asset.sha256
+        });
+    });
+    if (!Array.isArray(manifest.sourceModules) || !manifest.sourceModules.length) throw new Error('Octane compiler manifest has no authenticated native sources.');
+    const resources = new Set();
+    const sourceModules = manifest.sourceModules.map((value)=>{
+        const source = record(value, [
+            'resource',
+            'canonicalId',
+            'moduleId',
+            'transformKind',
+            'emittedSourceSha256',
+            'assets'
+        ]);
+        if (!nonempty(source.resource) || source.resource.startsWith('/') || source.resource.includes('\\') || !nonempty(source.canonicalId) || !('string' == typeof source.moduleId && nonempty(source.moduleId) || 'number' == typeof source.moduleId && Number.isFinite(source.moduleId)) || !('compile' === source.transformKind || 'slots' === source.transformKind || 'client-only-stub' === source.transformKind) || !digest(source.emittedSourceSha256) || !Array.isArray(source.assets) || !source.assets.length || source.assets.some((file)=>'string' != typeof file || !assetNames.has(file)) || new Set(source.assets).size !== source.assets.length || resources.has(source.resource)) throw new Error('Invalid Octane native source-to-asset provenance.');
+        resources.add(source.resource);
+        return Object.freeze({
+            resource: source.resource,
+            canonicalId: source.canonicalId,
+            moduleId: source.moduleId,
+            transformKind: source.transformKind,
+            emittedSourceSha256: source.emittedSourceSha256,
+            assets: Object.freeze([
+                ...source.assets
+            ])
+        });
+    });
+    return Object.freeze({
+        schemaVersion: 1,
+        renderer: 'octane',
+        runtimeVersion: OCTANE_RUNTIME_VERSION,
+        compilerVersion: OCTANE_COMPILER_VERSION,
+        rendererIdentity,
+        nativeHydrationBuildId,
+        sourceModules: Object.freeze(sourceModules),
+        assets: Object.freeze(assets)
+    });
+}
+const compilerArtifacts = {
+    clientManifestFile: octaneModuleManifestFileName,
+    async validateClientManifest (value, identity, context) {
+        const hydrationBuildId = context.compilationHash ?? context.hydrationBuildId;
+        if (context.development && ('string' != typeof hydrationBuildId || !hydrationBuildId.trim())) throw new Error('Octane development snapshot has no native hydration build.');
+        const nativeManifest = validateOctaneModuleManifest(value, identity, hydrationBuildId);
+        return {
+            nativeManifest,
+            hydrationBuildId: nativeManifest.nativeHydrationBuildId
+        };
+    },
+    isMutableDevelopmentAsset (filename, entryNames) {
+        return 'octane-client-build.json' === filename || entryNames.some((entry)=>filename === octaneModuleManifestFileName(entry));
+    }
+};
+export { OCTANE_COMPILER_VERSION, OCTANE_RUNTIME_VERSION, compilerArtifacts, octaneModuleManifestFileName, validateOctaneModuleManifest };

package/dist/esm/router-client.mjs

@@ -0,0 +1,98 @@
+import { RouterProvider } from "@octanejs/tanstack-router";
+import { hydrate } from "@octanejs/tanstack-router/ssr/client";
+import { createElement, hookSlots, initializeHydrationEventCapture, useEffect } from "octane";
+import { octaneRouterSnapshotAdapter } from "./router-snapshot.mjs";
+const hydration = new WeakMap();
+function abortReason(signal) {
+    return void 0 === signal.reason ? new DOMException('Octane router hydration aborted', 'AbortError') : signal.reason;
+}
+function awaitHydration(promise, signal) {
+    if (!signal) return promise;
+    signal.throwIfAborted();
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        const finish = (success, error)=>{
+            if (settled) return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            if (success) resolve();
+            else reject(error);
+        };
+        const onAbort = ()=>finish(false, abortReason(signal));
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        promise.then(()=>finish(true), (error)=>finish(false, error));
+        if (signal.aborted) onAbort();
+    });
+}
+function isReactiveMatchIds(value) {
+    return 'object' == typeof value && null !== value && 'function' == typeof Reflect.get(value, 'get') && 'function' == typeof Reflect.get(value, 'subscribe');
+}
+function waitForCommittedMatches(router, signal) {
+    signal?.throwIfAborted();
+    const matchesId = router.stores.ids;
+    if (matchesId.get().length > 0) return Promise.resolve();
+    if (!isReactiveMatchIds(matchesId)) throw new Error('Octane router hydration requires its native reactive match store');
+    return new Promise((resolve, reject)=>{
+        let subscription;
+        let settled = false;
+        const cleanup = ()=>{
+            subscription?.unsubscribe();
+            signal?.removeEventListener('abort', onAbort);
+        };
+        const finish = ()=>{
+            if (settled || 0 === matchesId.get().length) return;
+            settled = true;
+            cleanup();
+            resolve();
+        };
+        const onAbort = ()=>{
+            if (settled) return;
+            settled = true;
+            cleanup();
+            if (signal) reject(abortReason(signal));
+        };
+        signal?.addEventListener('abort', onAbort, {
+            once: true
+        });
+        if (signal?.aborted) return void onAbort();
+        subscription = matchesId.subscribe(finish);
+        if (settled) subscription.unsubscribe();
+        else finish();
+    });
+}
+async function prepareOctaneRouterHydration(router, options = {}) {
+    initializeHydrationEventCapture();
+    options.signal?.throwIfAborted();
+    const adapters = router.options.serializationAdapters ?? [];
+    if (!adapters.includes(octaneRouterSnapshotAdapter)) {
+        const nativeOptions = {
+            ...router.options,
+            serializationAdapters: [
+                octaneRouterSnapshotAdapter,
+                ...adapters
+            ]
+        };
+        router.update(nativeOptions);
+    }
+    let pending = hydration.get(router);
+    if (!pending) {
+        pending = Promise.resolve(hydrate(router)).then(()=>{});
+        pending.catch(()=>{});
+        hydration.set(router, pending);
+    }
+    await awaitHydration(pending, options.signal);
+    await waitForCommittedMatches(router, options.signal);
+    options.signal?.throwIfAborted();
+}
+const routerHydrationEffectSlot = Symbol(hookSlots(1));
+function OctaneRouterRoot({ router }) {
+    useEffect(()=>{
+        window.$_TSR?.h();
+    }, [], routerHydrationEffectSlot);
+    return createElement(RouterProvider, {
+        router
+    });
+}
+export { OctaneRouterRoot, prepareOctaneRouterHydration };

package/dist/esm/router-external-snapshot.mjs

@@ -0,0 +1,244 @@
+import { associateRouterRenderProfile, captureRouterRenderSnapshot, createRouterRenderRouteTree, defaultParseSearch, defaultStringifySearch, disposeRouterRenderSnapshot, getRouterRenderProfile, matchContext, registerRouterRenderProfile, restoreRouterRenderSnapshot, routerContext } from "@octanejs/tanstack-router";
+import { hasUnchangedOctaneFileRouteHead } from "./routes.mjs";
+import { OCTANE_WORKER_CONTEXT_KEYS, getOctaneWorkerRouterRewrite, registerOctaneWorkerContext } from "./worker-federation-contexts.mjs";
+const OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE = Object.freeze({
+    key: 'ultramodern.file-routes',
+    version: '1'
+});
+const origins = new WeakMap();
+let profileRegistered = false;
+function plainRecord(value) {
+    return null !== value && 'object' == typeof value && [
+        Object.prototype,
+        null
+    ].includes(Object.getPrototypeOf(value));
+}
+function record(value, fields) {
+    if (!plainRecord(value)) throw new TypeError('Worker router context requires a plain record');
+    for (const key of Reflect.ownKeys(value)){
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if ('string' != typeof key || fields && !fields.includes(key) || !descriptor || !descriptor.enumerable || !('value' in descriptor)) throw new TypeError('Unknown Worker router context field or accessor');
+    }
+    return value;
+}
+function nonempty(value) {
+    if ('string' != typeof value || !value.trim() || value.length > 1024) throw new TypeError('Invalid Worker router identity');
+    return value;
+}
+function publicContext(value) {
+    const context = record(value, [
+        'ultramodern'
+    ]);
+    const metadata = record(context.ultramodern, [
+        'rendererIdentity'
+    ]);
+    const identity = record(metadata.rendererIdentity, [
+        'renderer',
+        'appId',
+        'entryName',
+        'protocolVersion',
+        'buildId'
+    ]);
+    if ('octane' !== identity.renderer || 1 !== identity.protocolVersion) throw new TypeError('Unsupported Worker router identity');
+    return Object.freeze({
+        ultramodern: Object.freeze({
+            rendererIdentity: Object.freeze({
+                renderer: 'octane',
+                appId: nonempty(identity.appId),
+                entryName: nonempty(identity.entryName),
+                protocolVersion: 1,
+                buildId: nonempty(identity.buildId)
+            })
+        })
+    });
+}
+function localizedUrls(value) {
+    if (void 0 === value || 'boolean' == typeof value) return value;
+    const input = record(value);
+    const result = {};
+    for (const [path, translations] of Object.entries(input)){
+        const names = {};
+        for (const [language, target] of Object.entries(record(translations)))names[nonempty(language)] = nonempty(target);
+        result[path] = names;
+    }
+    return result;
+}
+function rewriteDescriptor(value) {
+    if (void 0 === value) return;
+    const input = record(value, [
+        'language',
+        'languages',
+        'localisedUrls'
+    ]);
+    if (!Array.isArray(input.languages) || !input.languages.length || input.languages.length > 64) throw new TypeError('Invalid Worker router i18n languages');
+    const languages = input.languages.map(nonempty);
+    const language = nonempty(input.language);
+    if (new Set(languages).size !== languages.length || !languages.includes(language)) throw new TypeError('Invalid Worker router i18n language');
+    const urls = localizedUrls(input.localisedUrls);
+    return {
+        language,
+        languages,
+        ...void 0 === urls ? {} : {
+            localisedUrls: urls
+        }
+    };
+}
+function nativeRewriteDescriptor(router) {
+    if (!router.options.rewrite) return;
+    const known = getOctaneWorkerRouterRewrite()?.capture(router.options.rewrite);
+    if (!known) throw new TypeError('Custom router rewrite requires an exact Worker profile');
+    const descriptor = rewriteDescriptor(known);
+    if (!descriptor) throw new TypeError('Missing native router rewrite provenance');
+    return {
+        language: descriptor.language,
+        languages: [
+            ...descriptor.languages
+        ],
+        ...void 0 === descriptor.localisedUrls ? {} : {
+            localisedUrls: descriptor.localisedUrls
+        }
+    };
+}
+function validateDefaultSnapshot(snapshot) {
+    publicContext(snapshot.publicContext);
+    rewriteDescriptor(snapshot.i18n);
+}
+function assertFileRouteRenderHost(router, allowRewrite) {
+    if (router.options.parseSearch !== defaultParseSearch || router.options.stringifySearch !== defaultStringifySearch || !allowRewrite && router.options.rewrite || router.options.routeMasks?.length) throw new TypeError('Router render snapshot: authored router behavior requires an exact local profile');
+    const authoredRouting = [
+        'caseSensitive',
+        'validateSearch',
+        'loaderDeps',
+        'beforeLoad',
+        'context',
+        'onEnter',
+        'onStay',
+        'onLeave',
+        'lazyFn',
+        "scripts",
+        'headers',
+        'onError',
+        'parseParams',
+        'stringifyParams'
+    ];
+    const seen = new Set();
+    const visit = (route, depth)=>{
+        if (seen.has(route) || seen.size >= 4096 || depth > 64) throw new TypeError('Router render snapshot: route geometry must be bounded and acyclic');
+        seen.add(route);
+        if (authoredRouting.some((key)=>void 0 !== Reflect.get(route.options, key)) || route.options.params?.parse || route.options.params?.stringify || route.options.search?.middlewares?.length || route.lazyFn || 'path' in route.options && 'id' in route.options || !hasUnchangedOctaneFileRouteHead(route)) throw new TypeError('Router render snapshot: authored route behavior requires an exact local profile');
+        for (const child of route.children ?? [])visit(child, depth + 1);
+    };
+    visit(router.options.routeTree, 0);
+}
+function ensureDefaultProfile() {
+    if (profileRegistered) return;
+    registerRouterRenderProfile({
+        id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+        assertHost: (router, snapshot)=>{
+            const origin = origins.get(router);
+            if (!origin || origin.rewrite !== router.options.rewrite || JSON.stringify(publicContext(router.options.context)) !== JSON.stringify(origin.publicContext)) throw new TypeError('Generated Worker router origin changed');
+            assertFileRouteRenderHost(router, void 0 !== snapshot.i18n);
+            validateDefaultSnapshot(snapshot);
+            if (JSON.stringify(nativeRewriteDescriptor(router)) !== JSON.stringify(snapshot.i18n)) throw new TypeError('Worker router rewrite differs from its native provenance');
+        },
+        createRoutingTree: (snapshot)=>{
+            validateDefaultSnapshot(snapshot);
+            return createRouterRenderRouteTree(snapshot.routes);
+        },
+        routingOptions: (snapshot)=>{
+            const defaults = {
+                parseSearch: defaultParseSearch,
+                stringifySearch: defaultStringifySearch
+            };
+            const i18n = rewriteDescriptor(snapshot.i18n);
+            if (!i18n) return defaults;
+            const codec = getOctaneWorkerRouterRewrite();
+            if (!codec) throw new TypeError('Missing owning Worker router i18n codec');
+            return {
+                ...defaults,
+                rewrite: codec.restore(i18n)
+            };
+        }
+    });
+    profileRegistered = true;
+}
+function associateOctaneFileRouteSnapshot(router) {
+    ensureDefaultProfile();
+    const context = publicContext(router.options.context);
+    origins.set(router, {
+        publicContext: context,
+        rewrite: router.options.rewrite
+    });
+    associateRouterRenderProfile(router, {
+        id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+        publicContext: context
+    });
+}
+function captureOctaneRouterSnapshot(router) {
+    const origin = origins.get(router);
+    const declared = getRouterRenderProfile(router);
+    if (origin && declared?.key === OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE.key && declared.version === OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE.version) {
+        const i18n = nativeRewriteDescriptor(router);
+        associateRouterRenderProfile(router, {
+            id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+            publicContext: origin.publicContext,
+            ...void 0 === i18n ? {} : {
+                i18n
+            }
+        });
+    }
+    return captureRouterRenderSnapshot(router);
+}
+let registrations = 0;
+let releaseContexts;
+function registerOctaneRouterWorkerContexts() {
+    ensureDefaultProfile();
+    if (!releaseContexts) {
+        const releaseRouter = registerOctaneWorkerContext(routerContext, {
+            key: OCTANE_WORKER_CONTEXT_KEYS.router,
+            encode: (value)=>{
+                if (!value) throw new TypeError('Missing native router provider');
+                return captureOctaneRouterSnapshot(value);
+            },
+            decode: (value, signal)=>restoreRouterRenderSnapshot(value, {
+                    signal
+                }),
+            dispose: (value)=>{
+                if (value) disposeRouterRenderSnapshot(value);
+            },
+            isProvided: (value)=>void 0 !== value
+        });
+        try {
+            const releaseMatch = registerOctaneWorkerContext(matchContext, {
+                key: OCTANE_WORKER_CONTEXT_KEYS.match,
+                encode: nonempty,
+                decode: nonempty,
+                validate: (value, readContext)=>{
+                    const selected = readContext(routerContext);
+                    const router = selected.present ? selected.value : void 0;
+                    const current = router?.state.matches.find((match)=>match.routeId === value);
+                    if (!router || !current || 'string' != typeof value || router.stores.getMatchStore(value).get() !== current) throw new TypeError('Worker match context requires its selected native router and a current match');
+                },
+                isProvided: (value)=>void 0 !== value
+            });
+            releaseContexts = ()=>{
+                releaseMatch();
+                releaseRouter();
+            };
+        } catch (error) {
+            releaseRouter();
+            throw error;
+        }
+    }
+    registrations++;
+    let released = false;
+    return ()=>{
+        if (released) return;
+        released = true;
+        if (0 === --registrations) {
+            releaseContexts?.();
+            releaseContexts = void 0;
+        }
+    };
+}
+export { OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE, associateOctaneFileRouteSnapshot, captureOctaneRouterSnapshot, registerOctaneRouterWorkerContexts };

package/dist/esm/router-handler.mjs

@@ -0,0 +1,133 @@
+import { createMemoryHistory } from "@octanejs/tanstack-router";
+import { attachRouterServerSsrUtils, getNormalizedURL, getOrigin, normalizeSsrResponse } from "@octanejs/tanstack-router/ssr/server";
+import { cleanupOctaneRouterSSR } from "./router-server-cleanup.mjs";
+import { prepareOctaneRouterSerialization } from "./router-server-snapshot.mjs";
+function withAbort(pending, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        const finish = (success, value)=>{
+            if (settled) return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            if (success) resolve(value);
+            else reject(value);
+        };
+        const onAbort = ()=>finish(false, signal.reason);
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        pending.then((value)=>finish(true, value), (error)=>finish(false, error));
+        if (signal.aborted) onAbort();
+    });
+}
+const CSP_HEADERS = new Set([
+    'content-security-policy',
+    'content-security-policy-report-only',
+    'link',
+    'server-timing'
+]);
+function appendHeaders(destination, value) {
+    if (null == value) return;
+    const source = value instanceof Headers ? value : new Headers(value);
+    for (const [key, item] of Headers.prototype.entries.call(source))if ('set-cookie' !== key) if (CSP_HEADERS.has(key)) destination.append(key, item);
+    else if ('vary' === key) {
+        const fields = new Map();
+        for (const field of `${destination.get('vary') ?? ''},${item}`.split(',')){
+            const name = field.trim();
+            if (name && !fields.has(name.toLowerCase())) fields.set(name.toLowerCase(), name);
+        }
+        destination.set('vary', [
+            ...fields.values()
+        ].join(', '));
+    } else destination.set(key, item);
+    for (const cookie of Headers.prototype.getSetCookie.call(source))destination.append('set-cookie', cookie);
+}
+function requestHeaders(router) {
+    const headers = new Headers({
+        'content-type': 'text/html; charset=utf-8'
+    });
+    for (const match of router.stores.matches.get()){
+        const field = Object.getOwnPropertyDescriptor(match, 'headers');
+        if (field?.get || field?.set) throw new TypeError('Native Octane response headers must be owned values');
+        appendHeaders(headers, field?.value);
+    }
+    const result = router._serverResult;
+    if (result?.type === 'redirect') appendHeaders(headers, result.redirect.headers);
+    return headers;
+}
+function createOctaneRequestHandler({ createRouter, request, session, getRouterManifest, serialization }) {
+    return async (callback)=>{
+        session.signal.throwIfAborted();
+        const router = createRouter();
+        let responseOwnsCleanup = false;
+        try {
+            const manifest = getRouterManifest ? await withAbort(Promise.resolve(getRouterManifest()), session.signal) : void 0;
+            attachRouterServerSsrUtils({
+                router,
+                manifest
+            });
+            const guard = prepareOctaneRouterSerialization(router, session, {
+                ...serialization,
+                forbiddenValues: [
+                    request,
+                    ...serialization?.forbiddenValues ?? []
+                ]
+            });
+            const { url } = getNormalizedURL(request.url, 'http://localhost');
+            const href = url.href.replace(url.origin, '');
+            router.update({
+                ...router.options,
+                history: createMemoryHistory({
+                    initialEntries: [
+                        href
+                    ]
+                }),
+                origin: router.options.origin ?? getOrigin(request)
+            });
+            await withAbort(router.load({
+                _signal: session.signal
+            }), session.signal);
+            guard.assertActive();
+            const loadResult = router._serverResult;
+            if (loadResult?.type === 'redirect') {
+                const resolved = loadResult.redirect;
+                const headers = requestHeaders(router);
+                return new Response(null, {
+                    status: resolved.status,
+                    statusText: resolved.statusText,
+                    headers
+                });
+            }
+            guard.assertMatches();
+            const serverSsr = router.serverSsr;
+            if (!serverSsr) throw new Error('Native Octane router SSR state is required');
+            await withAbort(serverSsr.dehydrate({
+                signal: session.signal
+            }), session.signal);
+            guard.assertActive();
+            const responseHeaders = requestHeaders(router);
+            const rendered = Promise.resolve(callback({
+                request,
+                router,
+                responseHeaders
+            }));
+            const result = normalizeSsrResponse(await withAbort(rendered, session.signal).catch((error)=>{
+                if (session.signal.aborted) rendered.then((late)=>{
+                    try {
+                        normalizeSsrResponse(late).response.body?.cancel().catch(()=>{});
+                    } catch  {}
+                }, ()=>{});
+                throw error;
+            }));
+            responseOwnsCleanup = 'stream' === result.serverSsrCleanup;
+            return result.response;
+        } catch (error) {
+            session.fail(error);
+            throw error;
+        } finally{
+            if (!responseOwnsCleanup) cleanupOctaneRouterSSR(router);
+        }
+    };
+}
+export { createOctaneRequestHandler };

package/dist/esm/router-server-cleanup.mjs

@@ -0,0 +1,8 @@
+const released = new WeakSet();
+function cleanupOctaneRouterSSR(router) {
+    const serverSsr = router.serverSsr;
+    if (!serverSsr || released.has(serverSsr)) return;
+    released.add(serverSsr);
+    serverSsr.cleanup();
+}
+export { cleanupOctaneRouterSSR };