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

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";
+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, controller, signal, completion) {
+    completion.catch((error)=>{
+        if (signal.aborted) return;
+        const match = [
+            ...router.stores.pendingMatches.get(),
+            ...router.stores.matches.get(),
+            ...router.stores.cachedMatches.get()
+        ].find((candidate)=>candidate.abortController === controller);
+        if (!match) return;
+        const store = [
+            router.stores.pendingMatchStores.get(match.id),
+            router.stores.matchStores.get(match.id),
+            router.stores.cachedMatchStores.get(match.id)
+        ].find((candidate)=>candidate?.get().abortController === controller);
+        if (!store) return;
+        let subscription;
+        let settled = false;
+        const cleanup = ()=>{
+            subscription?.unsubscribe();
+            signal.removeEventListener('abort', onAbort);
+        };
+        const onAbort = ()=>{
+            settled = true;
+            cleanup();
+        };
+        const publish = ()=>{
+            if (settled) return;
+            const current = store.get();
+            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 {
+                route?.options.onError?.(failure);
+            } catch (onErrorFailure) {
+                failure = onErrorFailure;
+            }
+            if (signal.aborted) return;
+            router.updateMatch(match.id, (previous)=>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, 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
+    });
+    function bind(route, parent, inheritedErrorComponent) {
+        const errorComponent = modules[route.id]?.errorComponent ?? inheritedErrorComponent;
+        const native = createRoute({
+            getParentRoute: ()=>parent,
+            ...nativeRoutePath(route),
+            ...bindings(route, errorComponent)
+        });
+        return native.addChildren(route.children.map((child)=>bind(child, native, errorComponent)));
+    }
+    return root.addChildren(children.map((route)=>bind(route, root, rootErrorComponent)));
+}
+export { RouteDataError, createFileSystemRouteTree, matchApplicationRouteIds, matchApplicationRoutes, routes_resolveRouteData as resolveRouteData, selectApplicationDataRoute };

package/dist/esm/server.mjs

@@ -0,0 +1,183 @@
+import { prepareDocument } from "@modern-js/renderer-core/document";
+import { untilAborted } from "@modern-js/renderer-core/session";
+import { createElement, earlySignalBootstrapScript, renderToReadableStream } from "octane/server";
+import { assertNativeHydrationBuildId, assertOctaneIdentity } from "./bootstrap.mjs";
+import { FederationRoot, createFederationScope } from "./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 ? 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 nativeStream = await renderToReadableStream(App, 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
+            },
+            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(body);
+    } catch (error) {
+        await session.fail(error);
+        throw error;
+    }
+}
+export { renderOctaneApplication, renderOctaneCSRDocument };

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.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-node/plugin/compiler.mjs

@@ -0,0 +1,70 @@
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { OCTANE_COMPILER_VERSION, OCTANE_RUNTIME_VERSION, octaneModuleManifestFileName, validateOctaneModuleManifest } from "../manifest.mjs";
+function pluginSourceDirectory() {
+    let directory = node_path.dirname(fileURLToPath(import.meta.url));
+    while(true){
+        const compiler = node_path.join(directory, 'src/plugin');
+        if (node_fs.existsSync(node_path.join(directory, 'package.json')) && node_fs.existsSync(node_path.join(compiler, 'compiler-manifest.cjs'))) return compiler;
+        const parent = node_path.dirname(directory);
+        if (parent === directory) throw new Error('Cannot locate the UltraModern Octane compiler package.');
+        directory = parent;
+    }
+}
+function createOctaneCompilerPlugin(options) {
+    return {
+        name: 'ultramodern:octane:compiler',
+        setup (api) {
+            const directory = pluginSourceDirectory();
+            const require = createRequire(node_path.join(directory, 'index.cjs'));
+            const { OctaneCompilerManifestPlugin } = require('./compiler-manifest.cjs');
+            const { inferRspackEnvironment, OctaneRspackPlugin } = require('@octanejs/rspack-plugin');
+            api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
+                    source: {
+                        include: [
+                            /[/\\]@octanejs[/\\]/u
+                        ]
+                    }
+                }));
+            api.modifyRspackConfig((config, { environment: rsbuildEnvironment })=>{
+                const environment = rsbuildEnvironment.name === options.workerEnvironmentName ? 'server' : inferRspackEnvironment(config.target);
+                config.resolve ??= {};
+                const extensions = (config.resolve.extensions ?? []).filter((extension)=>'.tsrx' !== extension);
+                extensions.splice(Math.max(extensions.indexOf('.ts'), extensions.indexOf('.tsx')) + 1, 0, '.tsrx');
+                config.resolve.extensions = extensions;
+                config.plugins ??= [];
+                config.plugins.push(new OctaneRspackPlugin({
+                    root: api.context.rootPath,
+                    environment,
+                    transpile: false
+                }));
+                config.plugins.push(new OctaneCompilerManifestPlugin({
+                    emitClientManifest: 'client' === environment,
+                    root: api.context.rootPath,
+                    runtimeVersion: OCTANE_RUNTIME_VERSION,
+                    compilerVersion: OCTANE_COMPILER_VERSION,
+                    rendererIdentities: options.rendererIdentities,
+                    manifestFilename: octaneModuleManifestFileName,
+                    validateManifest: validateOctaneModuleManifest
+                }));
+                config.module ??= {};
+                config.module.rules ??= [];
+                config.module.rules.push({
+                    test: /\.tsrx$/u,
+                    type: "javascript/auto",
+                    use: [
+                        {
+                            loader: 'builtin:swc-loader',
+                            options: {
+                                detectSyntax: 'auto'
+                            }
+                        }
+                    ]
+                });
+            });
+        }
+    };
+}
+export { createOctaneCompilerPlugin, pluginSourceDirectory };