@bleedingdev/modern-js-renderer-octane 0.0.0-bootstrap → 3.9.3-ultramodern.1

package/dist/esm/i18n/index.mjs

@@ -0,0 +1,8 @@
+export { createRequestLanguageRedirect, detectRequestLanguage, languageFromPathname, resolveRequestLanguage } from "@modern-js/i18n-runtime-extensions/request-language";
+export { I18N_SSR_HANDOFF_ELEMENT_ID, createI18nSsrHandoffInlineData, readI18nSsrHandoff } from "@modern-js/i18n-runtime-extensions/ssrLanguageHandoff";
+export { createI18nUrlRewrite } from "@modern-js/i18n-runtime-extensions/urlRewrite";
+export { I18nContext } from "./context.mjs";
+export { I18nProvider } from "./I18nProvider.mjs";
+export { LocalizedLink, useIsLocalizedActive } from "./LocalizedLink.mjs";
+export { useLatestLanguageSync } from "./languageSync.mjs";
+export { useI18n } from "./useI18n.mjs";

package/dist/esm/i18n/languageSync.mjs

@@ -0,0 +1,61 @@
+import { createLatestLanguageSyncBinding } from "@modern-js/i18n-runtime-extensions/language-sync/controller";
+import { hookSlots, useCallback, useEffect, useRef } from "octane";
+const bindingSlot = Symbol(hookSlots(1));
+const callbacksSlot = Symbol(hookSlots(1));
+const activationSlot = Symbol(hookSlots(1));
+const requestSlot = Symbol(hookSlots(1));
+const retrySlot = Symbol(hookSlots(1));
+const requestCallbackSlot = Symbol(hookSlots(1));
+const useLatestLanguageSync = ({ changeLanguage, commitLanguage, desiredLanguage, enabled = true, policy, readLanguage, reportFailure, target })=>{
+    const bindingRef = useRef(null, bindingSlot);
+    if (null === bindingRef.current) bindingRef.current = createLatestLanguageSyncBinding(policy);
+    const binding = bindingRef.current;
+    useEffect(()=>{
+        binding.updateCallbacks({
+            changeLanguage,
+            commitLanguage,
+            readLanguage,
+            reportFailure
+        });
+    }, void 0, callbacksSlot);
+    useEffect(()=>{
+        if (!enabled || !target) return;
+        binding.activate(target);
+        return ()=>binding.deactivate();
+    }, [
+        binding,
+        enabled,
+        target
+    ], activationSlot);
+    useEffect(()=>{
+        if (!enabled || !target || !desiredLanguage) return void binding.clearRequest();
+        binding.request(desiredLanguage);
+    }, [
+        binding,
+        desiredLanguage,
+        enabled,
+        target
+    ], requestSlot);
+    useEffect(()=>{
+        if (!enabled || !target || !desiredLanguage || "u" < typeof window) return;
+        const retryCurrentIntent = ()=>binding.request(desiredLanguage);
+        const retryVisibleIntent = ()=>{
+            if ('visible' === document.visibilityState) retryCurrentIntent();
+        };
+        window.addEventListener('online', retryCurrentIntent);
+        document.addEventListener('visibilitychange', retryVisibleIntent);
+        return ()=>{
+            window.removeEventListener('online', retryCurrentIntent);
+            document.removeEventListener('visibilitychange', retryVisibleIntent);
+        };
+    }, [
+        binding,
+        desiredLanguage,
+        enabled,
+        target
+    ], retrySlot);
+    return useCallback((language)=>binding.request(language), [
+        binding
+    ], requestCallbackSlot);
+};
+export { useLatestLanguageSync };

package/dist/esm/i18n/useI18n.mjs

@@ -0,0 +1,72 @@
+import { configuredLanguage, localizePath } from "@modern-js/i18n-runtime-extensions/paths";
+import { languageFromPathname } from "@modern-js/i18n-runtime-extensions/request-language";
+import { useContext } from "octane";
+import { useRouter } from "../router.mjs";
+import { I18nContext } from "./context.mjs";
+const languageSwitches = new WeakMap();
+function useI18n() {
+    const context = useContext(I18nContext);
+    if (!context) throw new Error('[renderer-octane] useI18n() was called outside of an I18nProvider.');
+    const { instance, languages, localisedUrls, language } = context;
+    const t = (key, options)=>instance.t(key, options);
+    const router = useRouter({
+        warn: false
+    });
+    const changeLanguage = (requested)=>{
+        let nextLanguage;
+        try {
+            nextLanguage = configuredLanguage(requested, languages);
+        } catch (error) {
+            return Promise.reject(error);
+        }
+        const state = languageSwitches.get(instance) ?? {
+            latest: 0,
+            queue: Promise.resolve()
+        };
+        languageSwitches.set(instance, state);
+        const generation = ++state.latest;
+        const run = state.queue.then(async ()=>{
+            if (state.latest !== generation) return;
+            const committed = instance.language;
+            const publicLanguage = ()=>router ? languageFromPathname(new URL(router.state.location.publicHref, 'http://localhost').pathname, languages, router.options.basepath) : void 0;
+            const reconcile = async ()=>{
+                const language = publicLanguage() ?? committed;
+                if (instance.language !== language) await instance.changeLanguage?.(language);
+            };
+            try {
+                await instance.changeLanguage?.(nextLanguage);
+            } catch (error) {
+                await reconcile();
+                throw error;
+            }
+            if (!router) return;
+            const href = localizePath(router.state.location.href, nextLanguage, {
+                languages: [
+                    ...languages
+                ],
+                localisedUrls
+            });
+            try {
+                await router.navigate({
+                    to: '.',
+                    href,
+                    replace: true
+                });
+            } catch (error) {
+                await reconcile();
+                throw error;
+            }
+            if (publicLanguage() !== nextLanguage) await reconcile();
+        });
+        state.queue = run.catch(()=>{});
+        return run;
+    };
+    return {
+        t,
+        language,
+        languages,
+        instance,
+        changeLanguage
+    };
+}
+export { useI18n };

package/dist/esm/index.mjs

@@ -0,0 +1,8 @@
+const OCTANE_RUNTIME_PROFILE = Object.freeze({
+    renderer: 'octane',
+    runtime: '0.7.1+ultramodern.1331985ea3b0',
+    router: '0.1.60+ultramodern.0b9f76ee3003',
+    routerCore: '1.171.15',
+    history: '1.162.0'
+});
+export { OCTANE_RUNTIME_PROFILE };

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.7.1+ultramodern.1331985ea3b0';
+const OCTANE_COMPILER_VERSION = '0.1.55';
+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.matchesId;
+    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-handler.mjs

@@ -0,0 +1,130 @@
+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 redirect = router.stores.redirect.get();
+    if (redirect) appendHeaders(headers, 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 ?? []
+                ]
+            });
+            session.registerCleanup(()=>router.cancelMatches());
+            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(), session.signal);
+            guard.assertActive();
+            const redirect = router.stores.redirect.get();
+            if (redirect) {
+                const resolved = router.resolveRedirect(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(), 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-injection.mjs

@@ -0,0 +1,101 @@
+import { cleanupOctaneRouterSSR } from "./router-server-cleanup.mjs";
+const SERIALIZATION_TIMEOUT_MS = 60000;
+function createOctaneRouterInjection(router, session, options = {}) {
+    const serverSsr = router.serverSsr;
+    if (!serverSsr) throw new Error('Native Octane router.serverSsr is required for streaming');
+    const timeoutMs = options.serializationTimeoutMs ?? SERIALIZATION_TIMEOUT_MS;
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > SERIALIZATION_TIMEOUT_MS) throw new TypeError('Octane router serialization timeout must be 1 to 60000 ms');
+    session.signal.throwIfAborted();
+    let settled = false;
+    let released = false;
+    let renderFinished = false;
+    let timer;
+    let stopSerialization;
+    const subscriptions = new Set();
+    let resolveDone;
+    let rejectDone;
+    const done = new Promise((resolve, reject)=>{
+        resolveDone = resolve;
+        rejectDone = reject;
+    });
+    done.catch(()=>{});
+    const settle = (error)=>{
+        if (settled) return;
+        settled = true;
+        if (void 0 !== timer) clearTimeout(timer);
+        timer = void 0;
+        stopSerialization?.();
+        stopSerialization = void 0;
+        if (void 0 === error) resolveDone();
+        else rejectDone(error);
+    };
+    const release = ()=>{
+        if (released) return;
+        released = true;
+        if (void 0 !== timer) clearTimeout(timer);
+        timer = void 0;
+        stopSerialization?.();
+        stopSerialization = void 0;
+        for (const unsubscribe of subscriptions)unsubscribe();
+        subscriptions.clear();
+        session.signal.removeEventListener('abort', onAbort);
+        if (!settled) settle(session.signal.reason ?? new Error('Octane router serialization was interrupted'));
+    };
+    function onAbort() {
+        settle(session.signal.reason ?? new DOMException('Octane request aborted', 'AbortError'));
+        release();
+    }
+    if (serverSsr.isSerializationFinished()) settle();
+    else stopSerialization = serverSsr.onSerializationFinished(()=>settle());
+    serverSsr.onCleanup(release);
+    session.signal.addEventListener('abort', onAbort, {
+        once: true
+    });
+    try {
+        session.registerCleanup(()=>{
+            release();
+            cleanupOctaneRouterSSR(router);
+        });
+    } catch (error) {
+        release();
+        cleanupOctaneRouterSSR(router);
+        throw error;
+    }
+    return {
+        take () {
+            if (released) return '';
+            serverSsr.liftScriptBarrier();
+            return serverSsr.takeBufferedHtml() ?? '';
+        },
+        subscribe (notify) {
+            if (released) return ()=>{};
+            const stop = serverSsr.onInjectedHtml(notify);
+            let subscribed = true;
+            const unsubscribe = ()=>{
+                if (!subscribed) return;
+                subscribed = false;
+                subscriptions.delete(unsubscribe);
+                stop();
+            };
+            subscriptions.add(unsubscribe);
+            return unsubscribe;
+        },
+        done,
+        cancel (reason) {
+            settle(reason ?? new DOMException('Octane rendering cancelled', 'AbortError'));
+            release();
+            session.abort(reason);
+        },
+        renderComplete () {
+            if (released || renderFinished) return;
+            renderFinished = true;
+            serverSsr.setRenderFinished();
+            if (!serverSsr.isSerializationFinished() && !settled) timer = setTimeout(()=>{
+                const error = new Error('Octane router serialization timed out after app rendering');
+                settle(error);
+                session.fail(error);
+            }, timeoutMs);
+        }
+    };
+}
+export { createOctaneRouterInjection };

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 };