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

package/src/index.ts

@@ -3,8 +3,8 @@ export type { OctaneDocumentBootstrap } from './bootstrap';
 
 export const OCTANE_RUNTIME_PROFILE = Object.freeze({
   renderer: 'octane',
-  runtime: '0.7.1+ultramodern.1331985ea3b0',
-  router: '0.1.60+ultramodern.0b9f76ee3003',
-  routerCore: '1.171.15',
-  history: '1.162.0',
+  runtime: '0.13.8',
+  router: '0.2.10',
+  routerCore: '1.171.34',
+  history: '1.162.4',
 });

package/src/manifest.ts

@@ -9,8 +9,8 @@ import {
   assertOctaneIdentity,
 } from './bootstrap';
 
-export const OCTANE_RUNTIME_VERSION = '0.7.1+ultramodern.1331985ea3b0';
-export const OCTANE_COMPILER_VERSION = '0.1.55';
+export const OCTANE_RUNTIME_VERSION = '0.13.8';
+export const OCTANE_COMPILER_VERSION = '0.2.4';
 
 export interface OctaneCompiledSource {
   readonly resource: string;

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/compiler.ts

@@ -41,10 +41,15 @@ export function createOctaneCompilerPlugin(
       } = require('./compiler-manifest.cjs');
       // The application installs the Octane compiler; resolve it lazily so
       // descriptor readers never load it.
+      const appRequire = createRequire(
+        path.join(api.context.rootPath, 'package.json'),
+      );
       const {
         inferRspackEnvironment,
         OctaneRspackPlugin,
-      }: typeof import('@octanejs/rspack-plugin') = require('@octanejs/rspack-plugin');
+      }: typeof import('@octanejs/rspack-plugin') = appRequire(
+        '@octanejs/rspack-plugin',
+      );
       api.modifyRsbuildConfig((config, { mergeRsbuildConfig }) =>
         mergeRsbuildConfig(config, {
           source: {
@@ -60,19 +65,6 @@ export function createOctaneCompilerPlugin(
           rsbuildEnvironment.name === options.workerEnvironmentName
             ? 'server'
             : inferRspackEnvironment(config.target);
-        // Octane prepends '.tsrx' only when it is absent. Keep TypeScript
-        // modules first so an extensionless './link' cannot select a
-        // case-colliding Link.tsrx on case-insensitive file systems.
-        config.resolve ??= {};
-        const extensions = (config.resolve.extensions ?? []).filter(
-          extension => extension !== '.tsrx',
-        );
-        extensions.splice(
-          Math.max(extensions.indexOf('.ts'), extensions.indexOf('.tsx')) + 1,
-          0,
-          '.tsrx',
-        );
-        config.resolve.extensions = extensions;
         config.plugins ??= [];
         config.plugins.push(
           new OctaneRspackPlugin({

package/src/plugin/create.ts

@@ -60,7 +60,7 @@ export function generateOctaneAppSources(
       {
         path: 'src/routes/layout.tsx',
         content: `import { Link, Outlet } from '@modern-js/renderer-octane/router';
-import Stable from '../components/Stable';
+import Stable from '../components/stable';
 import './index.css';
 
 const appTitle = ${title};
@@ -91,7 +91,7 @@ ${options.capabilities.federation ? '          <Link to="/remotes">Federated app
   useOctaneRouteAction,
 } from '@modern-js/renderer-octane/router';
 import { useActionState } from 'octane';
-import Counter from '../components/Counter';
+import Counter from '../components/counter';
 
 const appId = ${appId};
 const appTitle = ${title};
@@ -162,7 +162,7 @@ export const head: NonNullable<FileSystemRouteModule['head']> = () => ({
 `,
       },
       {
-        path: 'src/components/Counter.tsx',
+        path: 'src/components/counter.tsx',
         content: `import { useState } from 'octane';
 
 export default function Counter() {
@@ -180,7 +180,7 @@ export default function Counter() {
 `,
       },
       {
-        path: 'src/components/Stable.tsx',
+        path: 'src/components/stable.tsx',
         content: `import { useState } from 'octane';
 
 export default function Stable() {
@@ -207,34 +207,35 @@ export function loader({ request }: DataHandlerInput) {
   if (url.searchParams.get('case') === 'error')
     throw new Error('Native loader failure');
   if (url.searchParams.get('case') === 'redirect')
-    return new Response(null, { status: 302, headers: { location: '/about' } });
+    return new Response(null, { headers: { location: '/about' }, status: 302 });
   return {
     message: 'Native loader value',
     privateValue: request.headers.get('x-conformance-private'),
   };
 }
 
-export async function action({ request }: DataHandlerInput) {
-  const form = await request.formData();
-  const name = form.get('name');
-  if (typeof name !== 'string' || !name.trim())
-    return Response.json(
-      { fieldErrors: { name: 'Name required' } },
-      { status: 422 },
-    );
-  if (form.get('intent') === 'redirect')
-    return new Response(null, {
-      status: 303,
-      headers: {
-        location: '/about',
-        'set-cookie': 'conformance-saved=1; Path=/; SameSite=Lax',
-      },
-    });
-  if (form.get('intent') === 'throw') throw new Error('Native action failure');
-  return {
-    saved: name,
-    privateValue: request.headers.get('x-conformance-private'),
-  };
+export function action({ request }: DataHandlerInput) {
+  return request.formData().then(form => {
+    const name = form.get('name');
+    if (typeof name !== 'string' || name.trim().length === 0)
+      return Response.json(
+        { fieldErrors: { name: 'Name required' } },
+        { status: 422 },
+      );
+    if (form.get('intent') === 'redirect')
+      return new Response(null, {
+        headers: {
+          location: '/about',
+          'set-cookie': 'conformance-saved=1; Path=/; SameSite=Lax',
+        },
+        status: 303,
+      });
+    if (form.get('intent') === 'throw') throw new Error('Native action failure');
+    return {
+      saved: name,
+      privateValue: request.headers.get('x-conformance-private'),
+    };
+  });
 }
 `,
       },

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',
@@ -89,7 +89,9 @@ export const rendererAdapter: NativeRendererAdapter<'octane'> =
         ],
         dependencies: nativeRendererDependencies(profile),
         devDependencies: {
-          [profile.compiler.name]: profile.compiler.version,
+          [profile.compiler.name]:
+            profile.dependencies[profile.compiler.name] ??
+            profile.compiler.version,
           typescript: typescriptVersion,
         },
         typecheckCommand: 'octane-tsc --noEmit --project tsconfig.json',

package/src/plugin/profile.ts

@@ -4,7 +4,7 @@ export const octaneProfile: RendererBuildProfile<'octane'> = {
   renderer: 'octane',
   status: 'preview',
   protocolVersion: 1,
-  minimumNode: '26.10.0',
+  minimumNode: '26.12.0',
   hmr: {
     editedBoundary: 'may-reset',
     unaffectedComponents: 'preserved',
@@ -12,28 +12,32 @@ export const octaneProfile: RendererBuildProfile<'octane'> = {
     roots: 'single',
     cleanup: 'exactly-once',
   },
-  compiler: { name: '@octanejs/rspack-plugin', version: '0.1.55' },
+  compiler: { name: '@octanejs/rspack-plugin', version: '0.2.4' },
   hydration: {
     name: 'octane',
-    version: '0.7.1+ultramodern.1331985ea3b0',
+    version: '0.13.8',
   },
   router: {
     name: '@octanejs/tanstack-router',
-    version: '0.1.60+ultramodern.0b9f76ee3003',
+    version: '0.2.10',
     coreName: '@tanstack/router-core',
-    coreVersion: '1.171.15',
+    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/octane%400.7.1%2Bultramodern.1331985ea3b0/octane-0.7.1%2Bultramodern.1331985ea3b0.tgz',
+      'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-2383d2ab1e70/octane-0.13.8.tgz',
     '@octanejs/tanstack-router':
-      'https://github.com/bleedingdev/octane/releases/download/%40octanejs%2Ftanstack-router%400.1.60%2Bultramodern.0b9f76ee3003/octanejs-tanstack-router-0.1.60%2Bultramodern.0b9f76ee3003.tgz',
-    '@octanejs/rspack-plugin': '0.1.55',
+      'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-2383d2ab1e70/octanejs-tanstack-router-0.2.10.tgz',
+    '@octanejs/rspack-plugin':
+      'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-2383d2ab1e70/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.8',
-    'seroval-plugins': '1.6.8',
+    seroval: '1.6.9',
+    'seroval-plugins': '1.6.9',
   },
   capabilities: {
     worker: true,

package/src/router-client.ts

@@ -64,7 +64,7 @@ function waitForCommittedMatches(
   signal?: AbortSignal,
 ): Promise<void> {
   signal?.throwIfAborted();
-  const matchesId = router.stores.matchesId;
+  const matchesId = router.stores.ids;
   if (matchesId.get().length > 0) return Promise.resolve();
   if (!isReactiveMatchIds(matchesId)) {
     throw new Error(

package/src/router-external-snapshot.ts

@@ -0,0 +1,363 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+import {
+  type AnyRoute,
+  type AnyRouter,
+  associateRouterRenderProfile,
+  captureRouterRenderSnapshot,
+  createRouterRenderRouteTree,
+  defaultParseSearch,
+  defaultStringifySearch,
+  disposeRouterRenderSnapshot,
+  getRouterRenderProfile,
+  matchContext,
+  type RouterRenderJsonRecord,
+  type RouterRenderSnapshot,
+  registerRouterRenderProfile,
+  restoreRouterRenderSnapshot,
+  routerContext,
+} from '@octanejs/tanstack-router';
+import { hasUnchangedOctaneFileRouteHead } from './routes';
+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);
+}
+
+/** File-route heads are host presentation work, like the already settled loaders. */
+function assertFileRouteRenderHost(
+  router: AnyRouter,
+  allowRewrite: boolean,
+): void {
+  if (
+    router.options.parseSearch !== defaultParseSearch ||
+    router.options.stringifySearch !== defaultStringifySearch ||
+    (!allowRewrite && router.options.rewrite) ||
+    router.options.routeMasks?.length
+  )
+    throw new TypeError(
+      'Router render snapshot: authored router behavior requires an exact local profile',
+    );
+  const authoredRouting = [
+    'caseSensitive',
+    'validateSearch',
+    'loaderDeps',
+    'beforeLoad',
+    'context',
+    'onEnter',
+    'onStay',
+    'onLeave',
+    'lazyFn',
+    'scripts',
+    'headers',
+    'onError',
+    'parseParams',
+    'stringifyParams',
+  ];
+  const seen = new Set<AnyRoute>();
+  const visit = (route: AnyRoute, depth: number) => {
+    if (seen.has(route) || seen.size >= 4096 || depth > 64)
+      throw new TypeError(
+        'Router render snapshot: route geometry must be bounded and acyclic',
+      );
+    seen.add(route);
+    if (
+      authoredRouting.some(
+        key => Reflect.get(route.options, key) !== undefined,
+      ) ||
+      route.options.params?.parse ||
+      route.options.params?.stringify ||
+      route.options.search?.middlewares?.length ||
+      route.lazyFn ||
+      ('path' in route.options && 'id' in route.options) ||
+      !hasUnchangedOctaneFileRouteHead(route)
+    )
+      throw new TypeError(
+        'Router render snapshot: authored route behavior requires an exact local profile',
+      );
+    for (const child of route.children ?? []) visit(child, depth + 1);
+  };
+  visit(router.options.routeTree, 0);
+}
+
+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');
+      assertFileRouteRenderHost(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;
+    }
+  };
+}