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

package/src/router-handler.ts

@@ -91,8 +91,9 @@ function requestHeaders(router: AnyRouter): Headers {
       );
     appendHeaders(headers, field?.value);
   }
-  const redirect = router.stores.redirect.get();
-  if (redirect) appendHeaders(headers, redirect.headers);
+  const result = router._serverResult;
+  if (result?.type === 'redirect')
+    appendHeaders(headers, result.redirect.headers);
   return headers;
 }
 
@@ -117,7 +118,6 @@ export function createOctaneRequestHandler<TRouter extends AnyRouter>({
         ...serialization,
         forbiddenValues: [request, ...(serialization?.forbiddenValues ?? [])],
       });
-      session.registerCleanup(() => router.cancelMatches());
 
       const { url } = getNormalizedURL(request.url, 'http://localhost');
       const href = url.href.replace(url.origin, '');
@@ -126,14 +126,14 @@ export function createOctaneRequestHandler<TRouter extends AnyRouter>({
         history: createMemoryHistory({ initialEntries: [href] }),
         origin: router.options.origin ?? getOrigin(request),
       });
-      await withAbort(router.load(), session.signal);
+      await withAbort(router.load({ _signal: session.signal }), session.signal);
       guard.assertActive();
 
       // A native redirect is a terminal HTTP Response. It must never enter
       // the public serializer as a match error or document payload.
-      const redirect = router.stores.redirect.get();
-      if (redirect) {
-        const resolved = router.resolveRedirect(redirect);
+      const loadResult = router._serverResult;
+      if (loadResult?.type === 'redirect') {
+        const resolved = loadResult.redirect;
         const headers = requestHeaders(router);
         return new Response(null, {
           status: resolved.status,
@@ -146,7 +146,10 @@ export function createOctaneRequestHandler<TRouter extends AnyRouter>({
       const serverSsr = router.serverSsr;
       if (!serverSsr)
         throw new Error('Native Octane router SSR state is required');
-      await withAbort(serverSsr.dehydrate(), session.signal);
+      await withAbort(
+        serverSsr.dehydrate({ signal: session.signal }),
+        session.signal,
+      );
       guard.assertActive();
       const responseHeaders = requestHeaders(router);
       // A callback that ignores cancellation must not hold the router SSR

package/src/router-server.ts

@@ -5,8 +5,6 @@ import { createElement, type ServerRenderNode } from 'octane/server';
 export * from '@octanejs/tanstack-router/ssr/server';
 export type { OctaneRequestHandlerOptions } from './router-handler';
 export { createOctaneRequestHandler } from './router-handler';
-export type { OctaneRouterInjectionOptions } from './router-injection';
-export { createOctaneRouterInjection } from './router-injection';
 export type {
   OctaneRouterSerializationGuard,
   OctaneRouterSerializationOptions,

package/src/router.ts

@@ -9,7 +9,7 @@ import {
   useMatch,
   useRouter,
 } from '@octanejs/tanstack-router';
-import { createSubSlot, useCallback, useEffect, useRef } from 'octane';
+import { createSubSlot, useCallback, useLayoutEffect, useRef } from 'octane';
 import { assertOctaneIdentity } from './bootstrap';
 import { resolveRouteData } from './routes';
 
@@ -161,7 +161,7 @@ export function useOctaneRouteAction(...args: unknown[]) {
   const identity = useApplicationIdentity();
   const routeId = useApplicationRouteId();
   const owner = useRef<AbortController | null>(null, actionSlot(slot, 'owner'));
-  useEffect(
+  useLayoutEffect(
     () => {
       const controller = new AbortController();
       owner.current = controller;

package/src/routes.ts

@@ -29,6 +29,13 @@ import {
 } from '@octanejs/tanstack-router';
 import { createElement, Fragment } from 'octane';
 
+const fileRouteHeads = new WeakMap<AnyRoute, AnyRoute['options']['head']>();
+
+/** Head callbacks execute on the host; only the factory's original binding is admitted. */
+export function hasUnchangedOctaneFileRouteHead(route: AnyRoute): boolean {
+  return fileRouteHeads.get(route) === route.options.head;
+}
+
 export type {
   FileSystemDataModule,
   FileSystemRouteOptions,
@@ -59,7 +66,7 @@ export function resolveRouteData(
 }
 
 interface ReactiveNativeMatch {
-  get(): AnyRouteMatch;
+  get(): AnyRouteMatch | undefined;
   subscribe(callback: () => void): { unsubscribe(): void };
 }
 
@@ -75,24 +82,18 @@ function isReactiveNativeMatch(value: unknown): value is ReactiveNativeMatch {
 /** A transport failure belongs to the native generation that fetched it. */
 function observeRouteCompletion(
   router: AnyRouter,
+  routeId: string,
   controller: AbortController,
   signal: AbortSignal,
   completion: Promise<void>,
 ) {
   void 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;
+    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: { unsubscribe(): void } | undefined;
     let settled = false;
     const cleanup = () => {
@@ -103,9 +104,10 @@ function observeRouteCompletion(
       settled = true;
       cleanup();
     };
-    const publish = () => {
+    const publish = async () => {
       if (settled) return;
       const current = store.get();
+      if (!current) return;
       if (
         current.abortController !== controller ||
         signal.aborted ||
@@ -121,23 +123,29 @@ function observeRouteCompletion(
       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;
       }
-      // Native successful loads have already preloaded their route components.
+      // The error component is ready before publishing a late transport failure.
       if (signal.aborted) return;
-      router.updateMatch(match.id, previous =>
-        previous.abortController === controller &&
-        previous.status === 'success' &&
-        !previous.isFetching
-          ? {
-              ...previous,
-              error: failure,
-              status: 'error',
-              isFetching: false,
-            }
-          : previous,
+      router.stores.setMatches(
+        router.stores.matches.get().map(previous =>
+          previous.routeId === route.id &&
+          previous.abortController === controller &&
+          previous.status === 'success' &&
+          !previous.isFetching
+            ? {
+                ...previous,
+                error: failure,
+                status: 'error',
+                isFetching: false,
+              }
+            : previous,
+        ),
       );
     };
     signal.addEventListener('abort', onAbort, { once: true });
@@ -203,6 +211,7 @@ export function createFileSystemRouteTree<Context = unknown>(
                 if (failed) throw failure;
                 observeRouteCompletion(
                   router,
+                  route.id,
                   match.abortController,
                   signal,
                   outcome.completion,
@@ -239,6 +248,7 @@ export function createFileSystemRouteTree<Context = unknown>(
     ...rootBindings,
     component: OctaneDocumentRoot,
   });
+  fileRouteHeads.set(root, root.options.head);
 
   function bind(
     route: FileSystemRouteIR,
@@ -252,6 +262,7 @@ export function createFileSystemRouteTree<Context = unknown>(
       ...nativeRoutePath(route),
       ...bindings(route, errorComponent),
     });
+    fileRouteHeads.set(native, native.options.head);
     return native.addChildren(
       route.children.map(child => bind(child, native, errorComponent)),
     );

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)),
+  };
+}