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

package/src/plugin/compiler-manifest.cjs

@@ -107,6 +107,29 @@ class OctaneCompilerManifestPlugin {
           sources.sort((left, right) =>
             left.resource.localeCompare(right.resource),
           );
+          // Module Federation publishes exposed native modules through a
+          // separate container entry in this same compilation. Its browser
+          // closure belongs to this application's publication, even when the
+          // document itself never imports an exposed component.
+          const containerChunks = new Set();
+          for (const [entryName, entry] of compilation.entries) {
+            if (
+              !entry.dependencies.some(
+                dependency => dependency.type === 'container entry',
+              )
+            )
+              continue;
+            const container = compilation.entrypoints.get(entryName);
+            if (!container)
+              throw new Error(
+                `Octane compiler has no federation container entry for ${entryName}.`,
+              );
+            for (const chunk of container.chunks) {
+              containerChunks.add(chunk);
+              for (const referenced of chunk.getAllReferencedChunks())
+                containerChunks.add(referenced);
+            }
+          }
           const identities = this.options.rendererIdentities();
           if (!identities || !Object.keys(identities).length) {
             throw new Error(
@@ -129,7 +152,10 @@ class OctaneCompilerManifestPlugin {
               throw new Error(
                 `Octane compiler has no client entry for ${entryName}.`,
               );
-            const entryChunks = new Set(entrypoint.chunks);
+            const entryChunks = new Set([
+              ...entrypoint.chunks,
+              ...containerChunks,
+            ]);
             for (const chunk of entrypoint.chunks) {
               for (const referenced of chunk.getAllReferencedChunks())
                 entryChunks.add(referenced);

package/src/plugin/index.ts

@@ -81,7 +81,7 @@ export const rendererAdapter: NativeRendererAdapter<'octane'> =
     artifacts: compilerArtifacts,
     assertSupportedSource: assertOctaneEntrySource,
     create: {
-      templates: { federation: true, workers: false },
+      templates: { federation: true, workers: true },
       dependencies: (profile, { typescriptVersion }) => ({
         frameworkDependencies: [
           '@modern-js/renderer-core',

package/src/plugin/profile.ts

@@ -21,18 +21,20 @@ export const octaneProfile: RendererBuildProfile<'octane'> = {
     name: '@octanejs/tanstack-router',
     version: '0.2.10',
     coreName: '@tanstack/router-core',
-    coreVersion: '1.171.34',
+    coreVersion: '1.171.38',
   },
   sourceExtensions: ['.tsx', '.tsrx', '.ts', '.js'],
   jsxImportSource: 'octane',
   dependencies: {
     '@tsrx/oxc': '0.20.0',
     octane:
-      'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-d5988dd93614/octane-0.13.8.tgz',
+      'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-0bf2313bbdfb/octane-0.13.8.tgz',
     '@octanejs/tanstack-router':
-      'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-d5988dd93614/octanejs-tanstack-router-0.2.10.tgz',
+      'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-0bf2313bbdfb/octanejs-tanstack-router-0.2.10.tgz',
     '@octanejs/rspack-plugin':
-      'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-d5988dd93614/octanejs-rspack-plugin-0.2.4.tgz',
+      'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-0bf2313bbdfb/octanejs-rspack-plugin-0.2.4.tgz',
+    '@tanstack/router-core':
+      'https://github.com/BleedingDev/router/releases/download/ultramodern-router-core-585d3233f7f5/tanstack-router-core-1.171.38.tgz',
     '@modern-js/renderer-octane': '3.8.3',
     seroval: '1.6.9',
     'seroval-plugins': '1.6.9',

package/src/router-external-snapshot.ts

@@ -0,0 +1,306 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+import {
+  type AnyRouter,
+  assertDefaultRouterRenderHost,
+  associateRouterRenderProfile,
+  captureRouterRenderSnapshot,
+  createRouterRenderRouteTree,
+  defaultParseSearch,
+  defaultStringifySearch,
+  disposeRouterRenderSnapshot,
+  getRouterRenderProfile,
+  matchContext,
+  type RouterRenderJsonRecord,
+  type RouterRenderSnapshot,
+  registerRouterRenderProfile,
+  restoreRouterRenderSnapshot,
+  routerContext,
+} from '@octanejs/tanstack-router';
+import {
+  getOctaneWorkerRouterRewrite,
+  OCTANE_WORKER_CONTEXT_KEYS,
+  registerOctaneWorkerContext,
+} from './worker-federation-contexts';
+
+export const OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE = Object.freeze({
+  key: 'ultramodern.file-routes',
+  version: '1',
+});
+
+interface GeneratedRouterOrigin {
+  readonly publicContext: RouterRenderJsonRecord;
+  readonly rewrite: AnyRouter['options']['rewrite'];
+}
+const origins = new WeakMap<AnyRouter, GeneratedRouterOrigin>();
+let profileRegistered = false;
+
+function plainRecord(value: unknown): value is Record<string, unknown> {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    [Object.prototype, null].includes(Object.getPrototypeOf(value))
+  );
+}
+
+function record(
+  value: unknown,
+  fields?: readonly string[],
+): Record<string, unknown> {
+  if (!plainRecord(value))
+    throw new TypeError('Worker router context requires a plain record');
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (
+      typeof key !== 'string' ||
+      (fields && !fields.includes(key)) ||
+      !descriptor ||
+      !descriptor.enumerable ||
+      !('value' in descriptor)
+    )
+      throw new TypeError('Unknown Worker router context field or accessor');
+  }
+  return value;
+}
+
+function nonempty(value: unknown): string {
+  if (typeof value !== 'string' || !value.trim() || value.length > 1024)
+    throw new TypeError('Invalid Worker router identity');
+  return value;
+}
+
+/** Only the host entry's public logical identity crosses the Worker boundary. */
+function publicContext(value: unknown): RouterRenderJsonRecord {
+  const context = record(value, ['ultramodern']);
+  const metadata = record(context.ultramodern, ['rendererIdentity']);
+  const identity = record(metadata.rendererIdentity, [
+    'renderer',
+    'appId',
+    'entryName',
+    'protocolVersion',
+    'buildId',
+  ]);
+  if (identity.renderer !== 'octane' || identity.protocolVersion !== 1)
+    throw new TypeError('Unsupported Worker router identity');
+  return Object.freeze({
+    ultramodern: Object.freeze({
+      rendererIdentity: Object.freeze({
+        renderer: 'octane',
+        appId: nonempty(identity.appId),
+        entryName: nonempty(identity.entryName),
+        protocolVersion: 1,
+        buildId: nonempty(identity.buildId),
+      }),
+    }),
+  });
+}
+
+function localizedUrls(value: unknown): LocalisedUrlsOption | undefined {
+  if (value === undefined || typeof value === 'boolean') return value;
+  const input = record(value);
+  const result: Exclude<LocalisedUrlsOption, boolean> = {};
+  for (const [path, translations] of Object.entries(input)) {
+    const names: Record<string, string> = {};
+    for (const [language, target] of Object.entries(record(translations)))
+      names[nonempty(language)] = nonempty(target);
+    result[path] = names;
+  }
+  return result;
+}
+
+function rewriteDescriptor(value: unknown):
+  | {
+      readonly language: string;
+      readonly languages: readonly string[];
+      readonly localisedUrls?: LocalisedUrlsOption;
+    }
+  | undefined {
+  if (value === undefined) return undefined;
+  const input = record(value, ['language', 'languages', 'localisedUrls']);
+  if (
+    !Array.isArray(input.languages) ||
+    !input.languages.length ||
+    input.languages.length > 64
+  )
+    throw new TypeError('Invalid Worker router i18n languages');
+  const languages = input.languages.map(nonempty);
+  const language = nonempty(input.language);
+  if (
+    new Set(languages).size !== languages.length ||
+    !languages.includes(language)
+  )
+    throw new TypeError('Invalid Worker router i18n language');
+  const urls = localizedUrls(input.localisedUrls);
+  return {
+    language,
+    languages,
+    ...(urls === undefined ? {} : { localisedUrls: urls }),
+  };
+}
+
+function nativeRewriteDescriptor(
+  router: AnyRouter,
+): RouterRenderJsonRecord | undefined {
+  if (!router.options.rewrite) return undefined;
+  const known = getOctaneWorkerRouterRewrite()?.capture(router.options.rewrite);
+  if (!known)
+    throw new TypeError(
+      'Custom router rewrite requires an exact Worker profile',
+    );
+  const descriptor = rewriteDescriptor(known);
+  if (!descriptor)
+    throw new TypeError('Missing native router rewrite provenance');
+  return {
+    language: descriptor.language,
+    languages: [...descriptor.languages],
+    ...(descriptor.localisedUrls === undefined
+      ? {}
+      : { localisedUrls: descriptor.localisedUrls }),
+  };
+}
+
+function validateDefaultSnapshot(snapshot: RouterRenderSnapshot): void {
+  publicContext(snapshot.publicContext);
+  rewriteDescriptor(snapshot.i18n);
+}
+
+function ensureDefaultProfile(): void {
+  if (profileRegistered) return;
+  registerRouterRenderProfile({
+    id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+    assertHost: (router, snapshot) => {
+      const origin = origins.get(router);
+      if (
+        !origin ||
+        origin.rewrite !== router.options.rewrite ||
+        JSON.stringify(publicContext(router.options.context)) !==
+          JSON.stringify(origin.publicContext)
+      )
+        throw new TypeError('Generated Worker router origin changed');
+      assertDefaultRouterRenderHost(router, snapshot.i18n !== undefined);
+      validateDefaultSnapshot(snapshot);
+      if (
+        JSON.stringify(nativeRewriteDescriptor(router)) !==
+        JSON.stringify(snapshot.i18n)
+      )
+        throw new TypeError(
+          'Worker router rewrite differs from its native provenance',
+        );
+    },
+    createRoutingTree: snapshot => {
+      validateDefaultSnapshot(snapshot);
+      return createRouterRenderRouteTree(snapshot.routes);
+    },
+    routingOptions: snapshot => {
+      const defaults = {
+        parseSearch: defaultParseSearch,
+        stringifySearch: defaultStringifySearch,
+      };
+      const i18n = rewriteDescriptor(snapshot.i18n);
+      if (!i18n) return defaults;
+      const codec = getOctaneWorkerRouterRewrite();
+      if (!codec)
+        throw new TypeError('Missing owning Worker router i18n codec');
+      return { ...defaults, rewrite: codec.restore(i18n) };
+    },
+  });
+  profileRegistered = true;
+}
+
+/** Associate the genuine router produced by the generated file-route factory. */
+export function associateOctaneFileRouteSnapshot(router: AnyRouter): void {
+  ensureDefaultProfile();
+  const context = publicContext(router.options.context);
+  origins.set(router, {
+    publicContext: context,
+    rewrite: router.options.rewrite,
+  });
+  associateRouterRenderProfile(router, {
+    id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+    publicContext: context,
+  });
+}
+
+export function captureOctaneRouterSnapshot(
+  router: AnyRouter,
+): RouterRenderSnapshot {
+  const origin = origins.get(router);
+  const declared = getRouterRenderProfile(router);
+  if (
+    origin &&
+    declared?.key === OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE.key &&
+    declared.version === OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE.version
+  ) {
+    const i18n = nativeRewriteDescriptor(router);
+    associateRouterRenderProfile(router, {
+      id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+      publicContext: origin.publicContext,
+      ...(i18n === undefined ? {} : { i18n }),
+    });
+  }
+  return captureRouterRenderSnapshot(router);
+}
+
+let registrations = 0;
+let releaseContexts: (() => void) | undefined;
+
+/** Startup registration uses the actual physical native router/match Contexts. */
+export function registerOctaneRouterWorkerContexts(): () => void {
+  ensureDefaultProfile();
+  if (!releaseContexts) {
+    const releaseRouter = registerOctaneWorkerContext(routerContext, {
+      key: OCTANE_WORKER_CONTEXT_KEYS.router,
+      encode: value => {
+        if (!value) throw new TypeError('Missing native router provider');
+        return captureOctaneRouterSnapshot(value);
+      },
+      decode: (value, signal) => restoreRouterRenderSnapshot(value, { signal }),
+      dispose: value => {
+        if (value) disposeRouterRenderSnapshot(value);
+      },
+      isProvided: value => value !== undefined,
+    });
+    try {
+      const releaseMatch = registerOctaneWorkerContext(matchContext, {
+        key: OCTANE_WORKER_CONTEXT_KEYS.match,
+        encode: nonempty,
+        decode: nonempty,
+        validate: (value, readContext) => {
+          const selected = readContext(routerContext);
+          const router = selected.present ? selected.value : undefined;
+          // Native Match and useMatch share the active route store key, not
+          // the location-specific match identity (which includes parameters).
+          const current = router?.state.matches.find(
+            match => match.routeId === value,
+          );
+          if (
+            !router ||
+            !current ||
+            typeof value !== 'string' ||
+            router.stores.getMatchStore(value).get() !== current
+          )
+            throw new TypeError(
+              'Worker match context requires its selected native router and a current match',
+            );
+        },
+        isProvided: value => value !== undefined,
+      });
+      releaseContexts = () => {
+        releaseMatch();
+        releaseRouter();
+      };
+    } catch (error) {
+      releaseRouter();
+      throw error;
+    }
+  }
+  registrations++;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    if (--registrations === 0) {
+      releaseContexts?.();
+      releaseContexts = undefined;
+    }
+  };
+}

package/src/server.ts

@@ -9,6 +9,7 @@ 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 {
@@ -23,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. */
@@ -62,6 +64,8 @@ export interface RenderOctaneApplicationOptions<
   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>(
@@ -170,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, {
@@ -183,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',
@@ -192,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;

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