@bleedingdev/modern-js-renderer-octane 3.9.3-ultramodern.7 → 3.9.3-ultramodern.9

package/src/server.ts

@@ -9,6 +9,9 @@ import {
   type ResponsePolicy,
   untilAborted,
 } from '@modern-js/renderer-core/session';
+import type { WorkerFederationTransport } from '@modern-js/renderer-core/worker-federation';
+import type { AnyRouter } from '@octanejs/tanstack-router';
+import { transformReadableStreamWithRouter } from '@octanejs/tanstack-router/ssr/server';
 import {
   createElement,
   earlySignalBootstrapScript,
@@ -21,6 +24,7 @@ import {
   assertOctaneIdentity,
 } from './bootstrap';
 import { createFederationScope, FederationRoot } from './federation-context';
+import { WorkerFederationRoot } from './worker-federation-context';
 
 export interface OctaneDocumentOptions {
   /** One identity for this response, shared with the client's signal receiver. */
@@ -56,8 +60,12 @@ export interface RenderOctaneApplicationOptions<
   readonly props?: unknown;
   /** Native router serialization, owned by this request's router SSR context. */
   readonly injection?: StreamOptions['injection'];
+  readonly router?: AnyRouter;
+  readonly routerSerializationTimeoutMs?: number;
   /** This server compilation's native Module Federation runtime. */
   readonly federation?: NativeFederationBinding;
+  readonly workerFederation?: WorkerFederationTransport;
+  readonly workerFederationLocale?: string;
 }
 
 function prepareOctaneDocument<Bindings extends object>(
@@ -166,9 +174,12 @@ export async function renderOctaneApplication<Bindings extends object>(
     session.startRendering();
 
     let head = '';
-    const federation = input.federation
-      ? createFederationScope(input.federation, true, document.nonce)
-      : undefined;
+    // Worker SSR and browser activation must own the same provider ranges,
+    // even when only the browser needs a Module Federation loader.
+    const federation =
+      input.federation || input.workerFederation
+        ? createFederationScope(input.federation, true, document.nonce)
+        : undefined;
     const App = federation
       ? () =>
           createElement(FederationRoot, {
@@ -179,7 +190,24 @@ export async function renderOctaneApplication<Bindings extends object>(
                 : input.App,
           })
       : input.App;
-    const nativeStream = await renderToReadableStream(App, input.props, {
+    // Native SSR retries the application while lazy boundaries settle. Keep
+    // their request-owned context identity stable across those render passes.
+    const workerFederation = input.workerFederation
+      ? {
+          transport: input.workerFederation,
+          locale: input.workerFederationLocale ?? 'default',
+          signal: session.signal,
+        }
+      : undefined;
+    const NativeApp = workerFederation
+      ? () =>
+          createElement(WorkerFederationRoot, {
+            scope: workerFederation,
+            children:
+              typeof App === 'function' ? createElement(App, input.props) : App,
+          })
+      : App;
+    const nativeStream = await renderToReadableStream(NativeApp, input.props, {
       signal: session.signal,
       ...(document.nonce === undefined ? {} : { nonce: document.nonce }),
       earlySignalBootstrap: 'external',
@@ -188,6 +216,7 @@ export async function renderOctaneApplication<Bindings extends object>(
         buildId: document.nativeHydrationBuildId,
         documentId: document.documentId,
       },
+      externalSnapshots: { documentId: document.documentId },
       headChannel: 'separate',
       onHeadReady(value) {
         head = value;
@@ -292,7 +321,18 @@ export async function renderOctaneApplication<Bindings extends object>(
       },
       { highWaterMark: 0 },
     );
-    return session.respond(body);
+    return session.respond(
+      input.router
+        ? transformReadableStreamWithRouter(input.router, body, {
+            signal: session.signal,
+            rendererSafePoint: 'script-close',
+            timeoutMs: input.routerSerializationTimeoutMs,
+            onAbort: reason => {
+              void session.fail(reason);
+            },
+          })
+        : body,
+    );
   } catch (error) {
     await session.fail(error);
     throw error;

package/src/worker-federation-context.ts

@@ -0,0 +1,51 @@
+import type { WorkerFederationTransport } from '@modern-js/renderer-core/worker-federation';
+import { createContext, createElement } from 'octane';
+import {
+  FederationApplication,
+  type OctaneFederationScope,
+} from './federation-context';
+
+export interface OctaneWorkerFederationScope {
+  readonly transport: WorkerFederationTransport;
+  /** Compiled entry fallback; localized providers supply their live language. */
+  readonly locale: string;
+  /** Own document disposal; each lazy admission also owns its waiter deadline. */
+  readonly signal?: AbortSignal;
+}
+
+export type OctaneWorkerFederationFactory = (
+  signal: AbortSignal,
+) => OctaneWorkerFederationScope;
+
+/** Each native document owns its transport and captured publisher authorities. */
+export const WorkerFederationContext =
+  createContext<OctaneWorkerFederationScope | null>(null);
+
+export function WorkerFederationRoot(props: {
+  readonly scope: OctaneWorkerFederationScope;
+  readonly children?: unknown;
+}) {
+  return createElement(WorkerFederationContext, {
+    value: props.scope,
+    children: props.children,
+  });
+}
+
+/** Stable native root used for startup and application updates alike. */
+export function WorkerFederationApplication(props: {
+  readonly scope: OctaneWorkerFederationScope;
+  readonly federation?: OctaneFederationScope;
+  readonly application: Parameters<
+    typeof FederationApplication
+  >[0]['application'];
+}) {
+  return createElement(WorkerFederationRoot, {
+    scope: props.scope,
+    children: props.federation
+      ? createElement(FederationApplication, {
+          scope: props.federation,
+          application: props.application,
+        })
+      : createElement(props.application.default, props.application.props),
+  });
+}

package/src/worker-federation-contexts.ts

@@ -0,0 +1,91 @@
+import type { NativeLocationRewrite } from '@modern-js/renderer-core/router';
+import {
+  type Context,
+  type ExternalSnapshotContextCodec,
+  registerExternalSnapshotContext,
+  useContext,
+} from 'octane';
+
+export 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',
+} as const);
+
+type OctaneWorkerContextKey =
+  (typeof OCTANE_WORKER_CONTEXT_KEYS)[keyof typeof OCTANE_WORKER_CONTEXT_KEYS];
+
+export interface OctaneWorkerContextCodec<T>
+  extends ExternalSnapshotContextCodec<T> {
+  readonly key: OctaneWorkerContextKey;
+  readonly dispose?: (value: T) => void | PromiseLike<void>;
+  readonly isProvided: (value: T) => boolean;
+}
+
+const builtinKeys = Object.values(OCTANE_WORKER_CONTEXT_KEYS);
+const contexts = new Map<OctaneWorkerContextKey, () => boolean>();
+
+/** Optional renderer modules register their actual native context identities. */
+export function registerOctaneWorkerContext<T>(
+  context: Context<T>,
+  codec: OctaneWorkerContextCodec<T>,
+): () => void {
+  const { key, isProvided } = codec;
+  if (!builtinKeys.includes(key) || typeof isProvided !== 'function')
+    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);
+  };
+}
+
+/** Read live providers on every render; explicit requirements retain native validation. */
+export function useOctaneWorkerContextKeys(
+  explicit: readonly string[] = [],
+): readonly string[] {
+  const selected: string[] = [];
+  for (const key of builtinKeys) {
+    const hasProvider = contexts.get(key);
+    if (hasProvider?.() && !explicit.includes(key)) selected.push(key);
+  }
+  return [...selected, ...explicit];
+}
+
+export interface OctaneWorkerRouterRewrite {
+  readonly capture: (rewrite: NativeLocationRewrite) => unknown;
+  readonly restore: (descriptor: unknown) => NativeLocationRewrite;
+}
+let routerRewrite: OctaneWorkerRouterRewrite | undefined;
+
+/** The optional i18n owner supplies its own native rewrite provenance. */
+export function registerOctaneWorkerRouterRewrite(
+  codec: OctaneWorkerRouterRewrite,
+): () => void {
+  if (
+    routerRewrite ||
+    typeof codec.capture !== 'function' ||
+    typeof codec.restore !== 'function'
+  )
+    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 = undefined;
+  };
+}
+export function getOctaneWorkerRouterRewrite():
+  | OctaneWorkerRouterRewrite
+  | undefined {
+  return routerRewrite;
+}

package/src/worker-federation.ts

@@ -0,0 +1,120 @@
+import type { NativeWorkerDispatchOptions } from '@modern-js/renderer-core/server';
+import {
+  type AdmitWorkerRendererContract,
+  createWorkerFederationHandler,
+  createWorkerFederationTransport,
+} from '@modern-js/renderer-core/worker-federation';
+import {
+  type ExternalSnapshotRenderOptions,
+  prepareExternalSnapshotRequest,
+  releasePreparedExternalSnapshotRequest,
+  renderExternalSnapshot,
+  type ServerRenderNode,
+  serializeExternalSnapshot,
+} from 'octane/server';
+import { createFederationScope, FederationContext } from './federation-context';
+import { WorkerFederationContext } from './worker-federation-context';
+
+type NativeSnapshotRequest = Awaited<
+  ReturnType<typeof prepareExternalSnapshotRequest>
+>;
+type HandlerOptions = Parameters<
+  typeof createWorkerFederationHandler<NativeSnapshotRequest>
+>[0];
+
+function isNativeWorkerComponent(
+  value: unknown,
+): value is Extract<ServerRenderNode, (props: never) => unknown> {
+  return typeof value === 'function';
+}
+
+/** The compiled registry pins its renderer publication and literal imports. */
+export interface OctaneWorkerFederationRegistry {
+  initialize(
+    options: Omit<HandlerOptions, 'publication' | 'exposes'> & {
+      publication: unknown;
+    },
+  ): (request: Request) => Promise<Response | undefined>;
+}
+
+/** Created per dispatch; no publisher or native snapshot cache crosses documents. */
+export function createNativeWorkerFederationRuntime<Bindings extends object>(
+  options: NativeWorkerDispatchOptions<Bindings>,
+  compiler: {
+    readonly admitRendererContract: AdmitWorkerRendererContract;
+    readonly registry?: OctaneWorkerFederationRegistry;
+  },
+) {
+  const { resources } = options;
+  const bindings = options.bindings;
+  const transport = resources.workerFederationServices?.length
+    ? createWorkerFederationTransport({
+        admitRendererContract: compiler.admitRendererContract,
+        services: resources.workerFederationServices.map(service => {
+          const binding: unknown =
+            bindings && Reflect.get(bindings, service.binding);
+          if (
+            !binding ||
+            (typeof binding !== 'object' && typeof binding !== 'function') ||
+            !('fetch' in binding) ||
+            typeof binding.fetch !== 'function'
+          )
+            throw new Error(
+              `Native Worker federation requires service binding ${service.binding}.`,
+            );
+          return { ...service, fetch: binding.fetch.bind(binding) };
+        }),
+      })
+    : undefined;
+  let handle: ((request: Request) => Promise<Response | undefined>) | undefined;
+  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: ExternalSnapshotRenderOptions['initializeContexts'] =
+          transport
+            ? (provide, request) => {
+                provide(
+                  FederationContext,
+                  createFederationScope(undefined, true, request.nonce),
+                );
+                provide(WorkerFederationContext, {
+                  transport,
+                  locale: admitted.locale,
+                  signal,
+                });
+              }
+            : undefined;
+        return prepareExternalSnapshotRequest(payload, {
+          authority: admitted.coordinate.native,
+          signal,
+          ...(initializeContexts ? { initializeContexts } : {}),
+        });
+      },
+      releaseNativeRequest: releasePreparedExternalSnapshotRequest,
+      async renderNativeSnapshot(module, request, { admitted }) {
+        const component =
+          module && typeof module === 'object' && 'default' in module
+            ? module.default
+            : undefined;
+        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(undefined)),
+  };
+}

package/dist/cjs/router-injection.js

@@ -1,139 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    createOctaneRouterInjection: ()=>createOctaneRouterInjection
-});
-const external_router_server_cleanup_js_namespaceObject = require("./router-server-cleanup.js");
-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();
-            (0, external_router_server_cleanup_js_namespaceObject.cleanupOctaneRouterSSR)(router);
-        });
-    } catch (error) {
-        release();
-        (0, external_router_server_cleanup_js_namespaceObject.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);
-        }
-    };
-}
-exports.createOctaneRouterInjection = __webpack_exports__.createOctaneRouterInjection;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createOctaneRouterInjection"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/esm/router-injection.mjs

@@ -1,101 +0,0 @@
-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/types/router-injection.d.ts

@@ -1,8 +0,0 @@
-import type { RequestSession } from '@modern-js/renderer-core/session';
-import type { AnyRouter } from '@octanejs/tanstack-router';
-import type { StreamInjectionSource } from 'octane/server';
-export interface OctaneRouterInjectionOptions {
-    serializationTimeoutMs?: number;
-}
-/** Couple native router serialization to the response's single stream owner. */
-export declare function createOctaneRouterInjection(router: AnyRouter, session: RequestSession, options?: OctaneRouterInjectionOptions): StreamInjectionSource;