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

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/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.