@bleedingdev/modern-js-app-tools-extensions 3.9.3-ultramodern.1 → 3.9.3-ultramodern.10

package/dist/types/release-identity.d.ts

@@ -8,6 +8,16 @@ export declare const createUltramodernReleaseBuildMarker: ({ generationBuildMark
     unitId: string;
 }) => string;
 export declare const resolveUltramodernSourceRevision: (workspaceRoot?: string, configuredSourceRevision?: string, environment?: Readonly<NodeJS.ProcessEnv>) => string;
+/**
+ * The one release identity of a delivery unit, resolvable before its build.
+ *
+ * For a clean source revision the build marker is a 64-hex digest of the unit
+ * id, its generation marker and the revision. API bundles carry it, and a UI
+ * unit's renderer adopts it as its `buildId`, so contracts, release plans and
+ * Worker names derived from it before the build match the built
+ * `ultramodern-build.json`, `renderer-build.json`, chunk banners and envelope.
+ * A dirty or non-Git checkout yields the non-promotable `workspace` identity.
+ */
 export declare const resolveUltramodernReleaseIdentity: ({ generationBuildMarker, sourceRevision: configuredSourceRevision, unitId, workspaceRoot, environment, }: {
     generationBuildMarker: string;
     sourceRevision?: string;

package/dist/types/renderer-build-identity.d.ts

@@ -10,7 +10,18 @@ export interface RendererBuildIdentityOptions {
     mode: 'development' | 'production';
     /** Delivery-unit app id; defaults to the application package name. */
     appId?: string;
-    /** Externally authenticated source revision (delivery unit or CI). */
+    /**
+     * The declared delivery unit's release identity, resolved before the build
+     * by `resolveUltramodernReleaseIdentity`. A promotable production build
+     * adopts its buildMarker as the buildId, so consumers that resolve the unit
+     * identity before compiling see the marker the built artifacts carry.
+     */
+    deliveryUnit?: {
+        readonly unitId: string;
+        readonly buildMarker: string;
+        readonly sourceRevision: string;
+    };
+    /** Externally authenticated source revision (CI) for an undeclared app. */
     sourceRevision?: string;
     /** Actual final entry ownership, supplied by the selected renderer composition. */
     routerBindings: RendererRouterBindings;

package/package.json

@@ -11,7 +11,7 @@
     "directory": "packages/solutions/app-tools-extensions"
   },
   "license": "MIT",
-  "version": "3.9.3-ultramodern.1",
+  "version": "3.9.3-ultramodern.10",
   "files": [
     "dist",
     "src"
@@ -172,21 +172,21 @@
     }
   },
   "engines": {
-    "node": ">=26.10.0"
+    "node": ">=26.12.0"
   },
   "dependencies": {
-    "@babel/parser": "^8.0.6",
-    "@babel/traverse": "^8.0.6",
-    "@modern-js/backend-federation-contracts": "npm:@bleedingdev/modern-js-backend-federation-contracts@3.9.3-ultramodern.1",
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.3-ultramodern.1",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.3-ultramodern.1",
-    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.9.3-ultramodern.1",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.3-ultramodern.1",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.3-ultramodern.1",
-    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.3-ultramodern.1",
-    "@modern-js/surface-resolution": "npm:@bleedingdev/modern-js-surface-resolution@3.9.3-ultramodern.1",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.3-ultramodern.1",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.3-ultramodern.1",
+    "@babel/parser": "^8.0.7",
+    "@babel/traverse": "^8.0.7",
+    "@modern-js/backend-federation-contracts": "npm:@bleedingdev/modern-js-backend-federation-contracts@3.9.3-ultramodern.10",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.3-ultramodern.10",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.3-ultramodern.10",
+    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.9.3-ultramodern.10",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.3-ultramodern.10",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.3-ultramodern.10",
+    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.3-ultramodern.10",
+    "@modern-js/surface-resolution": "npm:@bleedingdev/modern-js-surface-resolution@3.9.3-ultramodern.10",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.3-ultramodern.10",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.3-ultramodern.10",
     "@swc/helpers": "^0.5.23",
     "@vercel/nft": "^1.11.0",
     "compression-webpack-plugin": "^12.0.0",
@@ -196,9 +196,9 @@
   },
   "peerDependencies": {
     "@loadable/component": "5.16.7",
-    "@modern-js/runtime-renderer-extensions": "3.9.3-ultramodern.1",
-    "@rsbuild/core": "2.2.11",
-    "react": "^19.2.8"
+    "@modern-js/runtime-renderer-extensions": "3.9.3-ultramodern.10",
+    "@rsbuild/core": "2.2.13",
+    "react": "^19.3.1"
   },
   "peerDependenciesMeta": {
     "@loadable/component": {
@@ -213,24 +213,24 @@
   },
   "devDependencies": {
     "@loadable/component": "5.16.7",
-    "@modern-js/bff-effect": "npm:@bleedingdev/modern-js-bff-effect@3.9.3-ultramodern.1",
-    "@modern-js/plugin-bff-extensions": "npm:@bleedingdev/modern-js-plugin-bff-extensions@3.9.3-ultramodern.1",
-    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.9.3-ultramodern.1",
-    "@modern-js/runtime-renderer-extensions": "npm:@bleedingdev/modern-js-runtime-renderer-extensions@3.9.3-ultramodern.1",
+    "@modern-js/bff-effect": "npm:@bleedingdev/modern-js-bff-effect@3.9.3-ultramodern.10",
+    "@modern-js/plugin-bff-extensions": "npm:@bleedingdev/modern-js-plugin-bff-extensions@3.9.3-ultramodern.10",
+    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.9.3-ultramodern.10",
+    "@modern-js/runtime-renderer-extensions": "npm:@bleedingdev/modern-js-runtime-renderer-extensions@3.9.3-ultramodern.10",
     "@module-federation/modern-js-v3": "2.9.2",
     "@module-federation/runtime-tools": "2.9.2",
-    "@rsbuild/core": "2.2.11",
+    "@rsbuild/core": "2.2.13",
     "@rslib/core": "1.0.3",
     "@scripts/rstest-config": "2.66.0",
     "@types/babel__traverse": "7.28.0",
-    "@types/node": "^26.6.3",
+    "@types/node": "^26.6.5",
     "core-js": "^3.50.0",
-    "effect": "4.0.0",
-    "miniflare": "5.20260930.0-alpha",
+    "effect": "4.0.5",
+    "miniflare": "5.20261012.0-beta",
     "ndepe": "^0.1.13",
     "pg": "8.23.1",
-    "react": "^19.3.0",
-    "react-dom": "^19.3.0"
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1"
   },
   "sideEffects": false,
   "publishConfig": {

package/src/build-config/build-environment.ts

@@ -36,12 +36,13 @@ if (typeof owningName !== 'string' || owningName.length === 0) {
 const {
   effectCompilerDiscoveryFailureStage,
   resolveInstalledEffectCompiler,
+  validateConfiguredEffectCompiler,
 }: typeof import('./internal-effect-discovery') = createRequire(
   owningModuleUrl,
 )(`${owningName}/internal-effect-discovery`);
 
 const EFFECT_TSGO_RESOLUTION_ERROR =
-  'Unable to resolve the Effect TS-Go compiler. Install "@effect/tsgo" and a native TypeScript backend for this build config, or set EFFECT_TSGO_BIN.';
+  'Unable to resolve the Effect TS-Go compiler. Install "@effect/tsgo" and a native TypeScript backend for this build config, or set EFFECT_TSGO_BIN. Bundled tsrs requires matching installed tsrs metadata.';
 const executableEffectTsgoCompilers = new Map<string, string>();
 
 function effectTsgoResolutionError(
@@ -58,17 +59,14 @@ function effectTsgoResolutionError(
 }
 
 function resolveExecutableEffectTsgoCompiler(compilerPath: string): string {
-  if (process.platform === 'win32') {
-    return compilerPath;
-  }
-
   const sourcePath = realpathSync(compilerPath);
   const source = lstatSync(sourcePath);
-  if (!source.isFile()) {
+  if (!source.isFile() || source.size === 0) {
     throw new Error(
-      `Effect TS-Go compiler path is not a regular file: ${sourcePath}`,
+      `Effect TS-Go compiler path is not a nonempty regular file: ${sourcePath}`,
     );
   }
+  if (process.platform === 'win32') return compilerPath;
 
   try {
     accessSync(sourcePath, constants.X_OK);
@@ -138,7 +136,9 @@ export type ResolveEffectTsgoCompilerOptions = {
 };
 
 /**
- * Resolves the Effect TS-Go executable used by Module Federation DTS builds.
+ * Resolves the Effect-enabled native executable for checking and DTS builds.
+ * Use metadata-bound tsrs where both tsrs and the Effect provider support it.
+ * Unsupported targets use Effect-Go. Missing supported artifacts remain fatal.
  */
 export function resolveEffectTsgoCompiler(
   options: ResolveEffectTsgoCompilerOptions,
@@ -148,7 +148,9 @@ export function resolveEffectTsgoCompiler(
 
   if (configuredCompiler) {
     try {
-      return resolveExecutableEffectTsgoCompiler(configuredCompiler);
+      const compiler = resolveExecutableEffectTsgoCompiler(configuredCompiler);
+      validateConfiguredEffectCompiler(compiler, options.from);
+      return compiler;
     } catch (cause) {
       throw effectTsgoResolutionError(
         cause,

package/src/build-config/internal-effect-discovery.ts

@@ -1,3 +1,4 @@
+import { execFileSync } from 'node:child_process';
 import { lstatSync, readFileSync, realpathSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join, resolve } from 'node:path';
@@ -6,13 +7,28 @@ import { fileURLToPath, type URL } from 'node:url';
 const EFFECT_TSGO_PACKAGE = '@effect/tsgo';
 const EFFECT_TSGO_BIN = 'effect-tsgo';
 const NATIVE_TYPESCRIPT_PACKAGES = ['typescript', '@typescript/native'];
+// @effect/tsgo@0.59.0 exports no tsrs capability API. Keep this exact contract
+// aligned with its CLI's tsrsReplacementTargets / resolveTsrs, not tsrs's list.
+const EFFECT_TSRS_PROVIDER_VERSION = '0.59.0';
+const EFFECT_TSRS_TARGETS = new Set([
+  '@tsrs/darwin-arm64',
+  '@tsrs/linux-x64-gnu',
+  '@tsrs/linux-arm64-gnu',
+]);
 type PackageJson = {
   name?: string;
   bin?: Record<string, string> | string;
   version?: string;
   gitHead?: string;
+  tsrs?: { typescriptVersion?: string; typescriptCommit?: string };
+  optionalDependencies?: Record<string, string>;
+};
+type TsrsPackageJson = PackageJson & {
+  version: string;
+  tsrs: { typescriptVersion: string; typescriptCommit: string };
 };
 const failureStages = new WeakMap<object, string>();
+const reportedUnsupportedTsrsTargets = new Set<string>();
 export function effectCompilerDiscoveryFailureStage(
   error: unknown,
 ): string | undefined {
@@ -50,7 +66,7 @@ function resolveEffectTsgoPackage(from: string | URL): {
   return { packageJsonPath, packageJson, cliPath };
 }
 
-function isAbsentNativeTypeScriptPackage(
+function isAbsentPackage(
   projectRequire: NodeJS.Require,
   from: string | URL,
   packageName: string,
@@ -98,14 +114,7 @@ function resolveNativeTypeScriptPackage(from: string | URL): string {
     try {
       packageJsonPath = projectRequire.resolve(`${packageName}/package.json`);
     } catch (error) {
-      if (
-        isAbsentNativeTypeScriptPackage(
-          projectRequire,
-          from,
-          packageName,
-          error,
-        )
-      ) {
+      if (isAbsentPackage(projectRequire, from, packageName, error)) {
         continue;
       }
       throw error;
@@ -156,11 +165,215 @@ function readCompilerArtifact(filename: string): string {
   return canonicalPath;
 }
 
-/** Selects the exact native replacement without invoking the provider. */
+function resolveTsrsManifest(from: string | URL): string | undefined {
+  const projectRequire = createRequire(from);
+  try {
+    return projectRequire.resolve('tsrs/package.json');
+  } catch (error) {
+    if (isAbsentPackage(projectRequire, from, 'tsrs', error)) return undefined;
+    throw error;
+  }
+}
+
+function compilerVersion(compiler: string): string {
+  return execFileSync(compiler, ['--version'], {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      TSRS_CHECKER_ASSIGNMENT: process.env.TSRS_CHECKER_ASSIGNMENT || 'go',
+    },
+    timeout: 10_000,
+    maxBuffer: 1024 * 1024,
+  }).trim();
+}
+
+function tsrsPlatform(manifestPath: string): {
+  manifest: TsrsPackageJson;
+  nativeName: string;
+  supported: boolean;
+} {
+  const manifest = JSON.parse(
+    readFileSync(manifestPath, 'utf8'),
+  ) as PackageJson;
+  const { getPlatformPackageName } = createRequire(manifestPath)(
+    join(dirname(manifestPath), 'lib/platform.js'),
+  ) as { getPlatformPackageName: () => string };
+  const nativeName = getPlatformPackageName();
+  const embedded = manifest.tsrs;
+  if (
+    typeof nativeName !== 'string' ||
+    !nativeName ||
+    !manifest.optionalDependencies ||
+    typeof manifest.optionalDependencies !== 'object' ||
+    Array.isArray(manifest.optionalDependencies) ||
+    Object.keys(manifest.optionalDependencies).length === 0
+  ) {
+    throw new Error(`Invalid native tsrs capability metadata: ${manifestPath}`);
+  }
+  if (
+    typeof manifest.name !== 'string' ||
+    !manifest.name ||
+    typeof manifest.version !== 'string' ||
+    !/^\d+\.\d+\.\d+-ts[\w.-]+$/u.test(manifest.version) ||
+    typeof embedded?.typescriptVersion !== 'string' ||
+    !/^7\.\d+\.\d+(?:[-+][\w.-]+)?$/u.test(embedded.typescriptVersion) ||
+    !manifest.version.endsWith(`-ts${embedded.typescriptVersion}`) ||
+    typeof embedded.typescriptCommit !== 'string' ||
+    !/^[a-f\d]{40}$/u.test(embedded.typescriptCommit)
+  ) {
+    throw new Error(`Invalid native tsrs metadata: ${manifestPath}`);
+  }
+  const supported = Object.hasOwn(manifest.optionalDependencies, nativeName);
+  if (
+    supported &&
+    manifest.optionalDependencies[nativeName] !== manifest.version
+  ) {
+    throw new Error(
+      `Native tsrs target version does not match its selected package: ${manifestPath}`,
+    );
+  }
+  return { manifest: manifest as TsrsPackageJson, nativeName, supported };
+}
+
+function resolveTsrsCompiler(
+  manifestPath: string,
+  effect: ReturnType<typeof resolveEffectTsgoPackage>,
+  configuredCompiler?: string,
+  configuredVersion?: string,
+): string {
+  const { manifest } = tsrsPlatform(manifestPath);
+  const embedded = manifest.tsrs;
+  const effectName = `@effect/tsgo-${process.platform}-${process.arch}`;
+  const effectManifest = createRequire(effect.cliPath).resolve(
+    `${effectName}/package.json`,
+  );
+  const platform = JSON.parse(
+    readFileSync(effectManifest, 'utf8'),
+  ) as PackageJson;
+  const metadataPath = join(dirname(effectManifest), 'lib/upstream.json');
+  const metadata = JSON.parse(readFileSync(metadataPath, 'utf8')) as {
+    schemaVersion?: number;
+    components?: {
+      tsrs?: Record<
+        string,
+        {
+          gitHead?: string;
+          typescript?: { version?: string; gitHead?: string };
+        }
+      >;
+    };
+  };
+  const component = metadata.components?.tsrs?.[manifest.version];
+  if (
+    platform.name !== effectName ||
+    platform.version !== effect.packageJson.version ||
+    metadata.schemaVersion !== 5 ||
+    !/^[a-f\d]{40}$/u.test(component?.gitHead ?? '') ||
+    component?.typescript?.version !== embedded.typescriptVersion ||
+    component.typescript.gitHead !== embedded.typescriptCommit
+  ) {
+    throw new Error(
+      `Effect replacement metadata does not match tsrs: ${metadataPath}`,
+    );
+  }
+  // This is the same metadata-bound artifact used by `effect-tsgo tsrs`.
+  // The installed @tsrs binary need not be patched or written to.
+  const compiler = readCompilerArtifact(
+    configuredCompiler ??
+      join(
+        dirname(effectManifest),
+        'artifacts/tsrs',
+        manifest.version,
+        process.platform === 'win32' ? 'tsrs.exe' : 'tsrs',
+      ),
+  );
+  const version = configuredVersion ?? compilerVersion(compiler);
+  // Check the selected executable itself, including TSRS_BINARY and explicit
+  // EFFECT_TSGO_BIN paths. A package name alone cannot prove it was patched.
+  const stamp =
+    /\+effect-tsgo\.([\d.]+)\s+\(tsrs ([^,]+), microsoft\/TypeScript@([a-f\d]+)\)$/u.exec(
+      version,
+    );
+  if (
+    !stamp ||
+    stamp[1] !== effect.packageJson.version ||
+    stamp[2] !== manifest.version ||
+    stamp[3].length < 12 ||
+    !embedded.typescriptCommit.startsWith(stamp[3])
+  ) {
+    throw new Error(
+      `Effect-enabled tsrs matching ${manifest.version} and @effect/tsgo@${effect.packageJson.version} is required: ${compiler}. Install matching packages or select a matching Effect-enabled candidate with EFFECT_TSGO_BIN.`,
+    );
+  }
+  return compiler;
+}
+
+/** Explicit native binaries must still report Effect diagnostics support. */
+export function validateConfiguredEffectCompiler(
+  compiler: string,
+  from: string | URL,
+): void {
+  const version = compilerVersion(compiler);
+  if (
+    !/^Version \d+\.\d+\.\d+[\w.-]*\+effect-tsgo\.\d+\.\d+\.\d+(?:\s|$)/u.test(
+      version,
+    )
+  ) {
+    throw new Error(
+      `EFFECT_TSGO_BIN must select an Effect-enabled native compiler: ${compiler}`,
+    );
+  }
+  if (version.includes('(tsrs ')) {
+    const manifest = resolveTsrsManifest(from);
+    if (!manifest)
+      throw new Error(
+        `Cannot validate tsrs without its installed package metadata for ${String(from)}`,
+      );
+    resolveTsrsCompiler(
+      manifest,
+      resolveEffectTsgoPackage(from),
+      compiler,
+      version,
+    );
+  }
+}
+
+/** Selects the exact native replacement without invoking the provider CLI. */
 export function resolveInstalledEffectCompiler(from: string | URL): string {
   let stage = 'Package CLI resolution';
   try {
     const effect = resolveEffectTsgoPackage(from);
+    stage = 'Native tsrs package resolution';
+    const tsrsManifest = resolveTsrsManifest(from);
+    const tsrsTarget = tsrsManifest ? tsrsPlatform(tsrsManifest) : undefined;
+    if (
+      tsrsTarget &&
+      effect.packageJson.version !== EFFECT_TSRS_PROVIDER_VERSION
+    ) {
+      throw new Error(
+        `Unreviewed Effect tsrs capability contract: ${effect.packageJson.version}`,
+      );
+    }
+    const configuredTsrsCompiler = process.env.TSRS_BINARY || undefined;
+    if (
+      tsrsManifest &&
+      tsrsTarget?.supported &&
+      (configuredTsrsCompiler || EFFECT_TSRS_TARGETS.has(tsrsTarget.nativeName))
+    ) {
+      stage = 'Native tsrs validation';
+      // TSRS_BINARY remains an explicit candidate selection. Automatic
+      // discovery uses the Effect provider's bundled native replacement.
+      return resolveTsrsCompiler(tsrsManifest, effect, configuredTsrsCompiler);
+    }
+    if (
+      tsrsTarget &&
+      !reportedUnsupportedTsrsTargets.has(tsrsTarget.nativeName)
+    ) {
+      reportedUnsupportedTsrsTargets.add(tsrsTarget.nativeName);
+      console.warn(
+        `[UltraModern] ${tsrsTarget.supported ? `@effect/tsgo@${effect.packageJson.version} does not provide a tsrs replacement for ${tsrsTarget.nativeName}` : `tsrs does not declare ${tsrsTarget.nativeName}`}; selecting the Effect-enabled TypeScript-Go compiler.`,
+      );
+    }
     stage = 'Native TypeScript package resolution';
     const typeScriptManifest = resolveNativeTypeScriptManifest(from);
     const typeScript = JSON.parse(
@@ -208,13 +421,16 @@ export function resolveInstalledEffectCompiler(from: string | URL): string {
     const metadataPath = join(dirname(effectManifest), 'lib', 'upstream.json');
     const metadata = JSON.parse(readFileSync(metadataPath, 'utf8')) as {
       schemaVersion?: number;
+      tags?: { typescript?: { latest?: string } };
       components?: {
         typescript?: Record<string, { gitHead?: string; provider?: string }>;
       };
     };
     const component = metadata.components?.typescript?.[native.version];
+    const latestTypeScript = metadata.tags?.typescript?.latest;
     if (
       metadata.schemaVersion !== 5 ||
+      typeof latestTypeScript !== 'string' ||
       component?.provider !== 'typescript-go' ||
       component.gitHead !== native.gitHead
     ) {
@@ -222,15 +438,18 @@ export function resolveInstalledEffectCompiler(from: string | URL): string {
         `Effect replacement metadata does not match the selected native TypeScript backend: ${metadataPath}`,
       );
     }
-    return readCompilerArtifact(
-      join(
-        dirname(effectManifest),
-        'artifacts',
-        'typescript',
-        native.version,
-        binaryName,
-      ),
-    );
+    // Same layout rule as @effect/tsgo's getExePath: the latest TypeScript
+    // replacement ships in lib/, every other version under artifacts/.
+    const compilerDirectory =
+      native.version === latestTypeScript
+        ? join(dirname(effectManifest), 'lib')
+        : join(
+            dirname(effectManifest),
+            'artifacts',
+            'typescript',
+            native.version,
+          );
+    return readCompilerArtifact(join(compilerDirectory, binaryName));
   } catch (error) {
     if (error && typeof error === 'object' && !failureStages.has(error))
       failureStages.set(error, stage);

package/src/cloudflare/worker-manifest.ts

@@ -1,5 +1,8 @@
 import path from 'node:path';
-import type {} from '@modern-js/server-runtime-extensions/server-config';
+import type {
+  BffEffectDataPlatformUserConfig,
+  BffEffectOpenApiUserConfig,
+} from '@modern-js/server-runtime-extensions/server-config';
 import { fs as fse } from '@modern-js/utils';
 import { getCloudflareWorkerRouteDataEntryName } from '../cloudflare-output-contract';
 import { readRouteSpec } from './artifacts';
@@ -71,8 +74,9 @@ const createEffectBffWorkerManifest = (
     },
   };
 
-  const openapi = bff?.effect?.openapi;
-  const dataPlatform = bff?.effect?.dataPlatform;
+  const openapi: BffEffectOpenApiUserConfig | undefined = bff?.effect?.openapi;
+  const dataPlatform: BffEffectDataPlatformUserConfig | undefined =
+    bff?.effect?.dataPlatform;
 
   return {
     ...(openapi === undefined ? {} : { openapi }),

package/src/config.ts

@@ -247,6 +247,10 @@ export interface CloudflareWorkerDeployConfig {
    * `env[binding].fetch(request)`.
    */
   services?: CloudflareWorkerServiceBindingConfig[];
+  /** Native Worker context profiles, registered before federated exposes load. */
+  federation?: {
+    contextProfiles?: readonly string[];
+  };
   /**
    * First-class Workers VPC service bindings to private origins reached
    * through a Cloudflare Tunnel. Modern.js writes these to `wrangler.json`