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

package/dist/esm/routes.mjs

@@ -0,0 +1,134 @@
+import { RouteDataError, loadFileSystemRoute, matchApplicationRouteIds, matchApplicationRoutes, nativeRoutePath, resolveRouteData, selectApplicationDataRoute, splitFileSystemRoutes } from "@modern-js/renderer-core/router";
+import { ErrorComponent, HeadContent, Outlet, Scripts, createRootRoute, createRoute, notFound, redirect } from "@octanejs/tanstack-router";
+import { Fragment, createElement } from "octane";
+const fileRouteHeads = new WeakMap();
+function hasUnchangedOctaneFileRouteHead(route) {
+    return fileRouteHeads.get(route) === route.options.head;
+}
+function routes_resolveRouteData(routeId, outcome) {
+    return resolveRouteData({
+        redirect: redirect,
+        notFound: notFound
+    }, routeId, outcome);
+}
+function isReactiveNativeMatch(value) {
+    return 'object' == typeof value && null !== value && 'function' == typeof Reflect.get(value, 'get') && 'function' == typeof Reflect.get(value, 'subscribe');
+}
+function observeRouteCompletion(router, routeId, controller, signal, completion) {
+    completion.catch((error)=>{
+        if (signal.aborted) return;
+        const route = Object.values(router.routesById).find((candidate)=>candidate.options.staticData?.ultramodernRouteId === routeId);
+        if (!route) return;
+        const store = router.stores.getMatchStore(route.id);
+        let subscription;
+        let settled = false;
+        const cleanup = ()=>{
+            subscription?.unsubscribe();
+            signal.removeEventListener('abort', onAbort);
+        };
+        const onAbort = ()=>{
+            settled = true;
+            cleanup();
+        };
+        const publish = async ()=>{
+            if (settled) return;
+            const current = store.get();
+            if (!current) return;
+            if (current.abortController !== controller || signal.aborted || 'pending' !== current.status && 'success' !== current.status) return void onAbort();
+            if ('success' !== current.status || current.isFetching) return;
+            settled = true;
+            cleanup();
+            const route = router.routesById[current.routeId];
+            let failure = error;
+            try {
+                await route?.options.errorComponent?.preload?.();
+                if (signal.aborted || store.get()?.abortController !== controller) return;
+                route?.options.onError?.(failure);
+            } catch (onErrorFailure) {
+                failure = onErrorFailure;
+            }
+            if (signal.aborted) return;
+            router.stores.setMatches(router.stores.matches.get().map((previous)=>previous.routeId !== route.id || previous.abortController !== controller || 'success' !== previous.status || previous.isFetching ? previous : {
+                    ...previous,
+                    error: failure,
+                    status: 'error',
+                    isFetching: false
+                }));
+        };
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        if (isReactiveNativeMatch(store)) subscription = store.subscribe(publish);
+        if (settled) subscription?.unsubscribe();
+        else publish();
+    });
+}
+function createFileSystemRouteTree(routes, modules, options = {}) {
+    const { root: rootDescriptor, children } = splitFileSystemRoutes(routes);
+    function bindings(route, errorComponent) {
+        const needsData = Boolean(route.modules?.data || route.modules?.clientData);
+        if (needsData && !options.loadRoute) throw new Error(`An Octane data route requires its loader: ${route.id}`);
+        const loadRoute = options.loadRoute;
+        const { head, ...module } = modules[route.id] ?? {};
+        return {
+            ...module,
+            ...void 0 !== head ? {
+                head
+            } : {},
+            ...errorComponent ? {
+                errorComponent
+            } : {},
+            component: module.component ?? Outlet,
+            staticData: {
+                ultramodernRouteId: route.id
+            },
+            ...needsData && loadRoute ? {
+                loader: async (match)=>{
+                    const { outcome, signal } = await loadFileSystemRoute(route, loadRoute, options, match);
+                    if ('completion' in outcome && outcome.completion) {
+                        const router = options.getRouter?.();
+                        if (!router) throw new Error('An Octane streamed data route requires its native router');
+                        let failed = false;
+                        let failure;
+                        outcome.completion.catch((error)=>{
+                            failed = true;
+                            failure = error;
+                        });
+                        await Promise.resolve();
+                        signal.throwIfAborted();
+                        if (failed) throw failure;
+                        observeRouteCompletion(router, route.id, match.abortController, signal, outcome.completion);
+                    }
+                    options.onOutcome?.(route.id, outcome);
+                    return routes_resolveRouteData(route.id, outcome);
+                }
+            } : {}
+        };
+    }
+    const rootBindings = rootDescriptor ? bindings(rootDescriptor) : {
+        component: Outlet
+    };
+    const authoredRoot = rootBindings.component;
+    function OctaneDocumentRoot(props) {
+        return createElement(Fragment, null, createElement(HeadContent), createElement(authoredRoot, props), createElement(Scripts));
+    }
+    if (void 0 !== authoredRoot.preload) OctaneDocumentRoot.preload = authoredRoot.preload;
+    const rootErrorComponent = rootDescriptor && modules[rootDescriptor.id]?.errorComponent || ErrorComponent;
+    const root = createRootRoute({
+        ...rootBindings,
+        component: OctaneDocumentRoot
+    });
+    fileRouteHeads.set(root, root.options.head);
+    function bind(route, parent, inheritedErrorComponent) {
+        const errorComponent = modules[route.id]?.errorComponent ?? inheritedErrorComponent;
+        const native = createRoute({
+            getParentRoute: ()=>parent,
+            ...nativeRoutePath(route),
+            ...bindings(route, errorComponent)
+        });
+        fileRouteHeads.set(native, native.options.head);
+        return native.addChildren(route.children.map((child)=>bind(child, native, errorComponent)));
+    }
+    return root.addChildren(children.map((route)=>bind(route, root, rootErrorComponent)));
+}
+export { RouteDataError, createFileSystemRouteTree, hasUnchangedOctaneFileRouteHead, matchApplicationRouteIds, matchApplicationRoutes, routes_resolveRouteData as resolveRouteData, selectApplicationDataRoute };

package/dist/esm/server.mjs

@@ -0,0 +1,204 @@
+import { prepareDocument } from "@modern-js/renderer-core/document";
+import { untilAborted } from "@modern-js/renderer-core/session";
+import { transformReadableStreamWithRouter } from "@octanejs/tanstack-router/ssr/server";
+import { createElement, earlySignalBootstrapScript, renderToReadableStream } from "octane/server";
+import { assertNativeHydrationBuildId, assertOctaneIdentity } from "./bootstrap.mjs";
+import { FederationRoot, createFederationScope } from "./federation-context.mjs";
+import { WorkerFederationRoot } from "./worker-federation-context.mjs";
+function prepareOctaneDocument(session, document, hydrating) {
+    assertOctaneIdentity(session.identity);
+    if ('node' !== session.platform.kind && 'worker' !== session.platform.kind) throw new Error('An Octane document requires a Node or worker request platform.');
+    assertNativeHydrationBuildId(document.nativeHydrationBuildId);
+    const nonce = document.nonce;
+    return prepareDocument({
+        identity: session.identity,
+        documentId: document.documentId,
+        hydrating,
+        nativeHydrationBuildId: document.nativeHydrationBuildId
+    }, {
+        rootId: document.rootId,
+        lang: document.lang,
+        nonce: {
+            script: nonce,
+            style: nonce
+        },
+        assets: document.assets,
+        inlineData: document.inlineData
+    });
+}
+async function resolveDocumentResponse(input) {
+    const { session } = input;
+    if (input.responsePolicy && input.resolveResponse) throw new Error('Choose one blocking Octane response policy resolver.');
+    if (input.resolveResponse) session.resolveResponse(await untilAborted(input.resolveResponse(session), session.signal));
+    else if (input.responsePolicy) session.resolveResponse(input.responsePolicy);
+    else if (!session.responsePolicy) session.resolveResponse({
+        kind: 'document',
+        status: 200,
+        headers: [
+            [
+                'content-type',
+                'text/html; charset=utf-8'
+            ]
+        ],
+        cache: {
+            mode: 'no-store'
+        }
+    });
+}
+async function renderOctaneCSRDocument(input) {
+    const { session } = input;
+    try {
+        const { rootId, lang, bootstrap, headAssets, entryScripts } = prepareOctaneDocument(session, input.document, false);
+        await resolveDocumentResponse(input);
+        if (session.responsePolicy?.kind === 'terminal') return session.respond(null);
+        session.startRendering();
+        const bytes = new TextEncoder().encode(`<!doctype html><html lang="${lang}"><head>${headAssets}</head><body><div id="${rootId}"></div>${bootstrap}${entryScripts}</body></html>`);
+        return session.respond(new ReadableStream({
+            start (controller) {
+                controller.enqueue(bytes);
+                controller.close();
+            }
+        }));
+    } catch (error) {
+        await session.fail(error);
+        throw error;
+    }
+}
+async function renderOctaneApplication(input) {
+    const { session, document } = input;
+    try {
+        const { rootId, lang, bootstrap, headAssets, entryScripts } = prepareOctaneDocument(session, document, true);
+        const earlyBootstrap = earlySignalBootstrapScript(void 0 === document.nonce ? {} : {
+            nonce: document.nonce
+        });
+        await resolveDocumentResponse(input);
+        if (session.responsePolicy?.kind === 'terminal') return session.respond(null);
+        session.startRendering();
+        let head = '';
+        const federation = input.federation || input.workerFederation ? createFederationScope(input.federation, true, document.nonce) : void 0;
+        const App = federation ? ()=>createElement(FederationRoot, {
+                scope: federation,
+                children: 'function' == typeof input.App ? createElement(input.App, input.props) : input.App
+            }) : input.App;
+        const workerFederation = input.workerFederation ? {
+            transport: input.workerFederation,
+            locale: input.workerFederationLocale ?? 'default',
+            signal: session.signal
+        } : void 0;
+        const NativeApp = workerFederation ? ()=>createElement(WorkerFederationRoot, {
+                scope: workerFederation,
+                children: 'function' == typeof App ? createElement(App, input.props) : App
+            }) : App;
+        const nativeStream = await renderToReadableStream(NativeApp, input.props, {
+            signal: session.signal,
+            ...void 0 === document.nonce ? {} : {
+                nonce: document.nonce
+            },
+            earlySignalBootstrap: 'external',
+            ...void 0 === input.injection ? {} : {
+                injection: input.injection
+            },
+            streamedSignals: {
+                buildId: document.nativeHydrationBuildId,
+                documentId: document.documentId
+            },
+            externalSnapshots: {
+                documentId: document.documentId
+            },
+            headChannel: 'separate',
+            onHeadReady (value) {
+                head = value;
+            },
+            onError (error) {
+                if (session.signal.aborted) return;
+                session.markFallback();
+                console.error('Octane render error:', error);
+            }
+        });
+        const ready = nativeStream.allReady.then(()=>({
+                ok: true
+            }), (error)=>({
+                ok: false,
+                error
+            }));
+        const reader = nativeStream.getReader();
+        const encoder = new TextEncoder();
+        const prefix = encoder.encode(`<!doctype html><html lang="${lang}"><head>${head}${headAssets}</head><body>${earlyBootstrap}<div id="${rootId}">`);
+        const shellBootstrap = encoder.encode(`</div>${bootstrap}${entryScripts}`);
+        const suffix = encoder.encode('</body></html>');
+        let phase = 'prefix';
+        let released = false;
+        const release = ()=>{
+            if (released) return;
+            released = true;
+            reader.releaseLock();
+        };
+        let cancellation;
+        const cancelNative = (reason)=>{
+            if (cancellation) return cancellation;
+            if (released) return Promise.resolve();
+            cancellation = reader.cancel(reason).finally(release);
+            return cancellation;
+        };
+        const releaseNative = (reason)=>{
+            cancelNative(reason).catch(()=>{});
+        };
+        try {
+            session.registerCleanup(()=>releaseNative(session.signal.reason));
+        } catch (error) {
+            releaseNative(error);
+            throw error;
+        }
+        const body = new ReadableStream({
+            async pull (controller) {
+                try {
+                    if ('prefix' === phase) {
+                        phase = 'shell';
+                        controller.enqueue(prefix);
+                        return;
+                    }
+                    if ('bootstrap' === phase) {
+                        phase = 'native';
+                        controller.enqueue(shellBootstrap);
+                        return;
+                    }
+                    const next = await reader.read();
+                    if (!next.done) {
+                        if ('shell' === phase) phase = 'bootstrap';
+                        controller.enqueue(next.value);
+                        return;
+                    }
+                    if ('shell' === phase) throw new Error('Octane ended before publishing its initial shell.');
+                    const completion = await ready;
+                    release();
+                    if (!completion.ok) throw completion.error;
+                    phase = 'done';
+                    controller.enqueue(suffix);
+                    controller.close();
+                } catch (error) {
+                    phase = 'done';
+                    releaseNative(error);
+                    controller.error(error);
+                }
+            },
+            cancel (reason) {
+                phase = 'done';
+                releaseNative(reason);
+            }
+        }, {
+            highWaterMark: 0
+        });
+        return session.respond(input.router ? transformReadableStreamWithRouter(input.router, body, {
+            signal: session.signal,
+            rendererSafePoint: "script-close",
+            timeoutMs: input.routerSerializationTimeoutMs,
+            onAbort: (reason)=>{
+                session.fail(reason);
+            }
+        }) : body);
+    } catch (error) {
+        await session.fail(error);
+        throw error;
+    }
+}
+export { renderOctaneApplication, renderOctaneCSRDocument };

package/dist/esm/worker-federation-context.mjs

@@ -0,0 +1,19 @@
+import { createContext, createElement } from "octane";
+import { FederationApplication } from "./federation-context.mjs";
+const WorkerFederationContext = createContext(null);
+function WorkerFederationRoot(props) {
+    return createElement(WorkerFederationContext, {
+        value: props.scope,
+        children: props.children
+    });
+}
+function WorkerFederationApplication(props) {
+    return createElement(WorkerFederationRoot, {
+        scope: props.scope,
+        children: props.federation ? createElement(FederationApplication, {
+            scope: props.federation,
+            application: props.application
+        }) : createElement(props.application.default, props.application.props)
+    });
+}
+export { WorkerFederationApplication, WorkerFederationContext, WorkerFederationRoot };

package/dist/esm/worker-federation-contexts.mjs

@@ -0,0 +1,47 @@
+import { registerExternalSnapshotContext, useContext } from "octane";
+const OCTANE_WORKER_CONTEXT_KEYS = Object.freeze({
+    router: 'ultramodern.octane.router-context.v1',
+    match: 'ultramodern.octane.match-context.v1',
+    i18n: 'ultramodern.octane.i18n-context.v1'
+});
+const builtinKeys = Object.values(OCTANE_WORKER_CONTEXT_KEYS);
+const contexts = new Map();
+function registerOctaneWorkerContext(context, codec) {
+    const { key, isProvided } = codec;
+    if (!builtinKeys.includes(key) || 'function' != typeof isProvided) throw new TypeError('Invalid Octane Worker builtin context codec');
+    const unregister = registerExternalSnapshotContext(context, codec);
+    const hasProvider = ()=>isProvided(useContext(context));
+    contexts.set(key, hasProvider);
+    return ()=>{
+        if (contexts.get(key) !== hasProvider) return;
+        unregister();
+        contexts.delete(key);
+    };
+}
+function useOctaneWorkerContextKeys(explicit = []) {
+    const selected = [];
+    for (const key of builtinKeys){
+        const hasProvider = contexts.get(key);
+        if (hasProvider?.() && !explicit.includes(key)) selected.push(key);
+    }
+    return [
+        ...selected,
+        ...explicit
+    ];
+}
+let routerRewrite;
+function registerOctaneWorkerRouterRewrite(codec) {
+    if (routerRewrite || 'function' != typeof codec.capture || 'function' != typeof codec.restore) throw new TypeError('Invalid or duplicate Octane Worker router rewrite codec');
+    const captured = Object.freeze({
+        capture: codec.capture,
+        restore: codec.restore
+    });
+    routerRewrite = captured;
+    return ()=>{
+        if (routerRewrite === captured) routerRewrite = void 0;
+    };
+}
+function getOctaneWorkerRouterRewrite() {
+    return routerRewrite;
+}
+export { OCTANE_WORKER_CONTEXT_KEYS, getOctaneWorkerRouterRewrite, registerOctaneWorkerContext, registerOctaneWorkerRouterRewrite, useOctaneWorkerContextKeys };

package/dist/esm/worker-federation.mjs

@@ -0,0 +1,59 @@
+import { createWorkerFederationTransport } from "@modern-js/renderer-core/worker-federation";
+import { prepareExternalSnapshotRequest, releasePreparedExternalSnapshotRequest, renderExternalSnapshot, serializeExternalSnapshot } from "octane/server";
+import { FederationContext, createFederationScope } from "./federation-context.mjs";
+import { WorkerFederationContext } from "./worker-federation-context.mjs";
+function isNativeWorkerComponent(value) {
+    return 'function' == typeof value;
+}
+function createNativeWorkerFederationRuntime(options, compiler) {
+    const { resources } = options;
+    const bindings = options.bindings;
+    const transport = resources.workerFederationServices?.length ? createWorkerFederationTransport({
+        admitRendererContract: compiler.admitRendererContract,
+        services: resources.workerFederationServices.map((service)=>{
+            const binding = bindings && Reflect.get(bindings, service.binding);
+            if (!binding || 'object' != typeof binding && 'function' != typeof binding || !('fetch' in binding) || 'function' != typeof binding.fetch) throw new Error(`Native Worker federation requires service binding ${service.binding}.`);
+            return {
+                ...service,
+                fetch: binding.fetch.bind(binding)
+            };
+        })
+    }) : void 0;
+    let handle;
+    if (resources.workerFederation) {
+        if (!compiler.registry || !resources.workerFederationManifestUrl) throw new Error('Native Worker federation requires its compiled expose registry and pinned manifest URL.');
+        handle = compiler.registry.initialize({
+            publication: resources.workerFederation.worker,
+            manifestUrl: resources.workerFederationManifestUrl,
+            admitRendererContract: compiler.admitRendererContract,
+            admitNativeRequest (payload, { admitted, signal }) {
+                const initializeContexts = transport ? (provide, request)=>{
+                    provide(FederationContext, createFederationScope(void 0, true, request.nonce));
+                    provide(WorkerFederationContext, {
+                        transport,
+                        locale: admitted.locale,
+                        signal
+                    });
+                } : void 0;
+                return prepareExternalSnapshotRequest(payload, {
+                    authority: admitted.coordinate.native,
+                    signal,
+                    ...initializeContexts ? {
+                        initializeContexts
+                    } : {}
+                });
+            },
+            releaseNativeRequest: releasePreparedExternalSnapshotRequest,
+            async renderNativeSnapshot (module, request, { admitted }) {
+                const component = module && 'object' == typeof module && 'default' in module ? module.default : void 0;
+                if (!isNativeWorkerComponent(component)) throw new TypeError(`Native Worker expose ${admitted.expose} requires a default Octane component.`);
+                return serializeExternalSnapshot(await renderExternalSnapshot(component, request));
+            }
+        });
+    }
+    return {
+        transport,
+        handleRequest: handle ?? (()=>Promise.resolve(void 0))
+    };
+}
+export { createNativeWorkerFederationRuntime };

package/dist/esm-node/bootstrap.mjs

@@ -0,0 +1,24 @@
+import { readDocumentBootstrap } from "@modern-js/renderer-core/document";
+import { readRendererIdentity } from "@modern-js/renderer-core/identity";
+function assertNativeHydrationBuildId(value) {
+    if ('string' != typeof value || 0 === value.trim().length) throw new Error('An Octane document requires its native client compilation identity.');
+}
+function assertOctaneIdentity(identity) {
+    readRendererIdentity(identity, identity);
+    if ('octane' !== identity.renderer) throw new Error('An Octane application requires an Octane renderer identity.');
+}
+function readOctaneDocumentBootstrap(document, expectedIdentity, expectedNativeHydrationBuildId) {
+    assertOctaneIdentity(expectedIdentity);
+    const { identity, documentId, hydrating, nativeHydrationBuildId } = readDocumentBootstrap(document, expectedIdentity, [
+        'nativeHydrationBuildId'
+    ]);
+    assertNativeHydrationBuildId(nativeHydrationBuildId);
+    if (void 0 !== expectedNativeHydrationBuildId && nativeHydrationBuildId !== expectedNativeHydrationBuildId) throw new Error('Octane hydration bytes belong to a different native client compilation.');
+    return Object.freeze({
+        identity,
+        documentId,
+        hydrating,
+        nativeHydrationBuildId
+    });
+}
+export { assertNativeHydrationBuildId, assertOctaneIdentity, readOctaneDocumentBootstrap };

package/dist/esm-node/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 };