@bleedingdev/modern-js-create 3.5.0-ultramodern.28 → 3.5.0-ultramodern.29

package/dist/esm-node/ultramodern-workspace/delivery-unit-sync.js

@@ -0,0 +1,109 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "../ultramodern-tooling/config.js";
+import { createBackendFederationContract } from "./backend-federation.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
+import { ULTRAMODERN_CONFIG_PATH } from "./descriptors.js";
+import { createUltramodernBuildModule } from "./module-federation.js";
+const REFERENCE_TOPOLOGY_PATH = 'topology/reference-topology.json';
+function readOption(args, name) {
+    const prefix = `${name}=`;
+    const inline = args.find((arg)=>arg.startsWith(prefix));
+    if (inline) {
+        const value = inline.slice(prefix.length);
+        if (!value) throw new Error(`${name} needs a value.`);
+        return value;
+    }
+    const index = args.indexOf(name);
+    if (-1 === index) return;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) throw new Error(`${name} needs a value.`);
+    return value;
+}
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function writeTextIfChanged(absolutePath, content) {
+    if (node_fs.existsSync(absolutePath) && node_fs.readFileSync(absolutePath, 'utf-8') === content) return false;
+    node_fs.mkdirSync(node_path.dirname(absolutePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(absolutePath, content, 'utf-8');
+    return true;
+}
+function writeJsonIfChanged(absolutePath, value) {
+    return writeTextIfChanged(absolutePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function stampDeliveryUnitIdentity(entry, scope, app) {
+    const block = deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app));
+    entry.deliveryUnit = block;
+    if (isPlainObject(entry.backendFederation)) {
+        entry.backendFederation.deliveryUnit = block;
+        if (!isPlainObject(entry.backendFederation.versionBoundary)) entry.backendFederation.versionBoundary = {};
+        entry.backendFederation.versionBoundary.identityRoot = 'deliveryUnit';
+    } else entry.backendFederation = createBackendFederationContract(scope, app);
+}
+function runSyncDeliveryUnit(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(`Usage:
+  modern-js-create ultramodern sync-delivery-unit [--workspace <dir>]
+
+Backfills the per-vertical delivery-unit identity blocks required by
+\`ultramodern validate\` onto an existing generated workspace, in place and
+through framework tooling only. For each full-stack vertical it writes the
+delivery-unit block into .modernjs/ultramodern.json topology.apps[] and
+topology/reference-topology.json verticals[] (plus backendFederation.deliveryUnit
+and backendFederation.versionBoundary.identityRoot) and regenerates
+verticals/<id>/shared/ultramodern-build.ts. Idempotent: a second run writes
+nothing.
+`);
+        return 0;
+    }
+    const workspaceOverride = readOption(args, '--workspace');
+    const workspaceRoot = workspaceOverride ? node_path.resolve(context.invocationCwd, workspaceOverride) : context.workspaceRoot;
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    if (!node_fs.existsSync(compactPath)) throw new Error(`Missing ${ULTRAMODERN_CONFIG_PATH}. sync-delivery-unit needs the compact UltraModern config; run \`modern-js-create ultramodern migrate-strict-effect\` first.`);
+    const config = readUltramodernConfig(workspaceRoot);
+    const scope = config.workspace.packageScope;
+    const apiApps = workspaceAppsFromToolingConfig(config).filter((app)=>Boolean(app.api));
+    const written = [];
+    const unchanged = [];
+    const track = (relativePath, changed)=>{
+        (changed ? written : unchanged).push(relativePath);
+    };
+    const appById = new Map(apiApps.map((app)=>[
+            app.id,
+            app
+        ]));
+    const compact = JSON.parse(node_fs.readFileSync(compactPath, 'utf-8'));
+    if (isPlainObject(compact) && Array.isArray(compact.topology?.apps)) for (const entry of compact.topology.apps){
+        if (!isPlainObject(entry)) continue;
+        const app = appById.get(String(entry.id));
+        if (app) stampDeliveryUnitIdentity(entry, scope, app);
+    }
+    track(ULTRAMODERN_CONFIG_PATH, writeJsonIfChanged(compactPath, compact));
+    const topologyPath = node_path.join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
+    if (node_fs.existsSync(topologyPath)) {
+        const topology = JSON.parse(node_fs.readFileSync(topologyPath, 'utf-8'));
+        if (isPlainObject(topology) && Array.isArray(topology.verticals)) for (const entry of topology.verticals){
+            if (!isPlainObject(entry)) continue;
+            const app = appById.get(String(entry.id));
+            if (app) stampDeliveryUnitIdentity(entry, scope, app);
+        }
+        track(REFERENCE_TOPOLOGY_PATH, writeJsonIfChanged(topologyPath, topology));
+    }
+    for (const app of apiApps){
+        const relativePath = node_path.join(app.directory, 'shared/ultramodern-build.ts');
+        const changed = writeTextIfChanged(node_path.join(workspaceRoot, relativePath), createUltramodernBuildModule(scope, app));
+        track(relativePath, changed);
+    }
+    if (0 === written.length) process.stdout.write('[ultramodern] sync-delivery-unit: already in sync; no files written.\n');
+    else {
+        process.stdout.write(`[ultramodern] sync-delivery-unit: wrote ${written.length} file(s):\n`);
+        for (const relativePath of written)process.stdout.write(`  wrote    ${relativePath}\n`);
+        for (const relativePath of unchanged)process.stdout.write(`  in-sync  ${relativePath}\n`);
+    }
+    return 0;
+}
+export { runSyncDeliveryUnit };

package/dist/esm-node/ultramodern-workspace/delivery-unit.js

@@ -0,0 +1,32 @@
+import "node:module";
+import node_crypto from "node:crypto";
+import { packageName } from "./naming.js";
+const DELIVERY_UNIT_SCHEMA_VERSION = 1;
+function createBuildMarker(scope, app) {
+    return node_crypto.createHash('sha256').update(`${scope}:${app.packageSuffix}:${app.id}:0.1.0`).digest('hex').slice(0, 16);
+}
+function deliveryUnitContractBlock(record) {
+    return {
+        schemaVersion: record.schemaVersion,
+        kind: record.kind,
+        unitId: record.unitId,
+        packageName: record.packageName,
+        version: record.version,
+        buildMarker: record.buildMarker,
+        sourceRevision: record.sourceRevision
+    };
+}
+function createDeliveryUnitRecord(scope, app) {
+    return {
+        schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
+        kind: 'microvertical-delivery-unit',
+        unitId: `${scope}/${app.domain ?? app.id}`,
+        appId: app.id,
+        packageName: packageName(scope, app.packageSuffix),
+        version: '0.1.0',
+        sourceRevision: 'workspace',
+        buildMarker: createBuildMarker(scope, app),
+        deployProfile: 'cloudflare-ssr-mf-effect-v1'
+    };
+}
+export { DELIVERY_UNIT_SCHEMA_VERSION, createBuildMarker, createDeliveryUnitRecord, deliveryUnitContractBlock };

package/dist/esm-node/ultramodern-workspace/descriptors.js

@@ -113,6 +113,18 @@ function resolveRemoteRefs(app, remotes = []) {
 function createRemoteManifestEnv(remote) {
     return `VERTICAL_${toEnvSegment(remote.domain ?? remote.id)}_MF_MANIFEST`;
 }
+function createBackendFederationManifestEnv(remote) {
+    return `VERTICAL_${toEnvSegment(remote.domain ?? remote.id)}_BACKEND_MF_MANIFEST`;
+}
+function createBackendFederationName(app) {
+    return `${app.mfName}Backend`;
+}
+function createBackendFederationManifestUrl(app) {
+    return `http://localhost:${app.port}/backend-mf-manifest.json`;
+}
+function createBackendFederationContainerEntry(app) {
+    return `http://localhost:${app.port}/backendRemoteEntry.mjs`;
+}
 function createModuleFederationRemoteContracts(app, remotes = []) {
     return resolveRemoteRefs(app, remotes).map((remote)=>({
             id: remote.id,
@@ -131,4 +143,4 @@ function createCloudflarePublicUrlEnv(app) {
 function appI18nNamespace(app) {
     return 'shell' === app.kind ? 'shell' : app.domain ?? app.id;
 }
-export { ULTRAMODERN_CONFIG_PATH, appHasApi, appI18nNamespace, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createModuleFederationRemoteContracts, createNeutralOwnership, createRemoteManifestEnv, createShellHost, createVerticalDescriptor, remoteDependencyAlias, resolveApiPrefix, resolveApiStem, resolveRemoteRefs, sharedPackages, shellApp, verticalApiApps, zephyrRemoteDependency };
+export { ULTRAMODERN_CONFIG_PATH, appHasApi, appI18nNamespace, createBackendFederationContainerEntry, createBackendFederationManifestEnv, createBackendFederationManifestUrl, createBackendFederationName, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createModuleFederationRemoteContracts, createNeutralOwnership, createRemoteManifestEnv, createShellHost, createVerticalDescriptor, remoteDependencyAlias, resolveApiPrefix, resolveApiStem, resolveRemoteRefs, sharedPackages, shellApp, verticalApiApps, zephyrRemoteDependency };

package/dist/esm-node/ultramodern-workspace/module-federation.js

@@ -1,11 +1,12 @@
 import "node:module";
-import node_crypto from "node:crypto";
-import { appHasApi, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createRemoteManifestEnv, remoteDependencyAlias, resolveApiPrefix, resolveRemoteRefs, shellApp } from "./descriptors.js";
-import { createRspackChunkLoadingGlobal, createRspackUniqueName, packageName } from "./naming.js";
+import { createDispatchWorkerNameEnv, createWorkerBindingEnv, createWorkerBindingName } from "./backend-federation.js";
+import { createBuildMarker, createDeliveryUnitRecord } from "./delivery-unit.js";
+import { appHasApi, createBackendFederationName, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createRemoteManifestEnv, remoteDependencyAlias, resolveApiPrefix, resolveRemoteRefs, shellApp } from "./descriptors.js";
+import { createRspackChunkLoadingGlobal, createRspackUniqueName } from "./naming.js";
 import { createCloudflareSecurityContract, formatTsJsonValue } from "./policy.js";
 import { sortJsonValue } from "./types.js";
 import { CLOUDFLARE_COMPATIBILITY_DATE } from "./versions.js";
-function createAppModernConfig(scope, app) {
+function createAppModernConfig(scope, app, remotes = []) {
     const bffImport = appHasApi(app) ? "import { bffPlugin } from '@modern-js/plugin-bff';\n" : '';
     const bffConfig = appHasApi(app) ? `      bff: {
         effect: {
@@ -20,6 +21,19 @@ function createAppModernConfig(scope, app) {
       },
 ` : '';
     const bffPluginEntry = appHasApi(app) ? '        bffPlugin(),\n' : '';
+    const serviceBindings = 'shell' === app.kind ? remotes.filter(appHasApi) : [];
+    const serviceBindingsConfig = serviceBindings.length > 0 ? `          services: [
+${serviceBindings.map((service)=>`            {
+              binding:
+                envValue('${createWorkerBindingEnv(service)}') ??
+                '${createWorkerBindingName(service)}',
+              prefix: '${resolveApiPrefix(service)}',
+              service:
+                envValue('${createDispatchWorkerNameEnv(service)}') ??
+                '${createCloudflareWorkerName(scope, service)}',
+            },`).join('\n')}
+          ],
+` : '';
     const defaultAssetPrefixSource = 'shell' === app.kind ? "const defaultAssetPrefix = '/';" : `const remoteAssetOrigin =
   configuredCloudflareUrl ||
   inferredCloudflareUrl ||
@@ -49,6 +63,13 @@ const zephyrEnabled = process.env['ULTRAMODERN_ZEPHYR'] !== 'false';
 const cloudflareDeployEnabled =
   process.env['MODERNJS_DEPLOY'] === 'cloudflare';
 
+const zephyrWarn = (error: unknown) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(
+    \`[ultramodern] zephyr-rspack-plugin failed; continuing without Zephyr (set ULTRAMODERN_ZEPHYR=false to disable it): \${message}\`,
+  );
+};
+
 const zephyrRspackPlugin = () => ({
   name: 'ultramodern-zephyr-rspack-plugin',
   pre: ['@modern-js/plugin-module-federation-config'],
@@ -62,7 +83,17 @@ const zephyrRspackPlugin = () => ({
     if (!zephyrEnabled) {
       return;
     }
-    api.modifyRspackConfig(config => withZephyrRspack()(config));
+    api.modifyRspackConfig(config => {
+      try {
+        return Promise.resolve(withZephyrRspack()(config)).catch(error => {
+          zephyrWarn(error);
+          return config;
+        });
+      } catch (error) {
+        zephyrWarn(error);
+        return config;
+      }
+    });
   },
 });
 
@@ -123,12 +154,12 @@ ${bffConfig}      ...(cloudflareDeployEnabled
         ? {
             deploy: {
               worker: {
-                compatibilityDate: '${CLOUDFLARE_COMPATIBILITY_DATE}',
-                name: cloudflareWorkerName,
-                security: ${formatTsJsonValue(sortJsonValue(createCloudflareSecurityContract()), 16)},
-                ssr: true,
-              },
+              compatibilityDate: '${CLOUDFLARE_COMPATIBILITY_DATE}',
+              name: cloudflareWorkerName,
+              security: ${formatTsJsonValue(sortJsonValue(createCloudflareSecurityContract()), 16)},
+${serviceBindingsConfig}              ssr: true,
             },
+          },
           }
         : {}),
       dev: {
@@ -347,6 +378,19 @@ ${remoteEntries}
   },
 `;
 }
+function createModuleFederationDtsConfig(hasExposes) {
+    return hasExposes ? `  dts: {
+    displayErrorInTerminal: true,
+    generateTypes: {
+      compilerInstance: 'tsgo',
+    },
+    tsConfigPath: './tsconfig.mf-types.json',
+  },` : `  dts: {
+    consumeTypes: true,
+    generateTypes: false,
+    tsConfigPath: './tsconfig.mf-types.json',
+  },`;
+}
 function createShellModuleFederationConfig(scope, remotes = []) {
     const shellHost = {
         ...shellApp,
@@ -375,13 +419,7 @@ const moduleFederationConfig: Parameters<
   dev: {
     disableDynamicRemoteTypeHints: true,
   },
-  dts: {
-    displayErrorInTerminal: true,
-    generateTypes: {
-      compilerInstance: 'tsgo',
-    },
-    tsConfigPath: './tsconfig.mf-types.json',
-  },
+${createModuleFederationDtsConfig(false)}
   filename: 'remoteEntry.js',
   name: '${shellApp.mfName}',
 ${createModuleFederationRemotesConfig(scope, shellHost, remotes)}${createSharedModuleFederationConfig()},
@@ -391,25 +429,75 @@ ${createModuleFederationRemotesConfig(scope, shellHost, remotes)}${createSharedM
 export default moduleFederationConfig;
 `;
 }
-function createBuildMarker(scope, app) {
-    return node_crypto.createHash('sha256').update(`${scope}:${app.packageSuffix}:${app.id}:0.1.0`).digest('hex').slice(0, 16);
+function createBackendModuleFederationConfig(app) {
+    return `// @effect-diagnostics nodeBuiltinImport:off
+import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+const require = createRequire(import.meta.url);
+const bffVersion = (
+  require('@modern-js/plugin-bff/package.json') as { version: string }
+).version;
+const effectVersion = (
+  require('effect/package.json') as { version: string }
+).version;
+
+const moduleFederationConfig: Parameters<
+  typeof createModuleFederationConfig
+>[0] = createModuleFederationConfig({
+  dts: false,
+  exposes: {
+    './effect-api': './api/effect-api.ts',
+  },
+  filename: 'backendRemoteEntry.mjs',
+  name: '${createBackendFederationName(app)}',
+  shared: {
+    '@modern-js/plugin-bff': {
+      requiredVersion: bffVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@module-federation/runtime': {
+      requiredVersion: dependencies['@module-federation/runtime'],
+      singleton: true,
+      treeShaking: false,
+    },
+    effect: {
+      requiredVersion: effectVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+  },
+  treeShakingSharedExcludePlugins: ['RspackModuleFederationPlugin'],
+});
+
+export default moduleFederationConfig;
+`;
 }
 function createUltramodernBuildModule(scope, app) {
-    return `export const ultramodernVerticalIdentity = {
-  appId: '${app.id}',
-  build: '${createBuildMarker(scope, app)}',
-  deployProfile: 'cloudflare-ssr-mf-effect-v1',
-  packageName: '${packageName(scope, app.packageSuffix)}',
-  version: '0.1.0',
+    const record = createDeliveryUnitRecord(scope, app);
+    return `export const ultramodernDeliveryUnit = {
+  appId: '${record.appId}',
+  build: '${record.buildMarker}',
+  deployProfile: '${record.deployProfile}',
+  kind: '${record.kind}',
+  packageName: '${record.packageName}',
+  schemaVersion: ${record.schemaVersion},
+  sourceRevision: '${record.sourceRevision}',
+  unitId: '${record.unitId}',
+  version: '${record.version}',
 } as const;
 
+export const ultramodernVerticalIdentity = ultramodernDeliveryUnit;
+
 export const ultramodernUiMarker = {
-  ...ultramodernVerticalIdentity,
+  ...ultramodernDeliveryUnit,
   surface: 'ui',
 } as const;
 
 export const ultramodernApiMarker = {
-  ...ultramodernVerticalIdentity,
+  ...ultramodernDeliveryUnit,
   surface: 'api',
 } as const;
 `;
@@ -417,6 +505,7 @@ export const ultramodernApiMarker = {
 function createUltramodernBuildReexportModule() {
     return `export {
   ultramodernApiMarker,
+  ultramodernDeliveryUnit,
   ultramodernUiMarker,
   ultramodernVerticalIdentity,
 } from '../shared/ultramodern-build';
@@ -424,7 +513,9 @@ function createUltramodernBuildReexportModule() {
 }
 function createRemoteModuleFederationConfig(scope, app, remotes = []) {
     const exposes = formatTsObjectLiteral(app.exposes ?? {});
-    return `// @effect-diagnostics nodeBuiltinImport:off
+    const hasExposes = Object.keys(app.exposes ?? {}).length > 0;
+    const hostOnlyMarker = hasExposes ? '' : '\n// ultramodern-mf: no-exposes';
+    return `// @effect-diagnostics nodeBuiltinImport:off${hostOnlyMarker}
 import { createRequire } from 'node:module';
 import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
 import { dependencies } from './package.json';
@@ -446,13 +537,7 @@ const moduleFederationConfig: Parameters<
   dev: {
     disableDynamicRemoteTypeHints: true,
   },
-  dts: {
-    displayErrorInTerminal: true,
-    generateTypes: {
-      compilerInstance: 'tsgo',
-    },
-    tsConfigPath: './tsconfig.mf-types.json',
-  },
+${createModuleFederationDtsConfig(hasExposes)}
   exposes: ${exposes},
   filename: 'remoteEntry.js',
   name: '${app.mfName}',
@@ -463,4 +548,4 @@ ${createModuleFederationRemotesConfig(scope, app, remotes)}${createSharedModuleF
 export default moduleFederationConfig;
 `;
 }
-export { createAppModernConfig, createBuildMarker, createModuleFederationRemoteUrlHelpers, createModuleFederationRemotesConfig, createRemoteModuleFederationConfig, createSharedModuleFederationConfig, createShellModuleFederationConfig, createUltramodernBuildModule, createUltramodernBuildReexportModule, formatTsObjectLiteral };
+export { createAppModernConfig, createBackendModuleFederationConfig, createBuildMarker, createModuleFederationRemoteUrlHelpers, createModuleFederationRemotesConfig, createRemoteModuleFederationConfig, createSharedModuleFederationConfig, createShellModuleFederationConfig, createUltramodernBuildModule, createUltramodernBuildReexportModule, formatTsObjectLiteral };

package/dist/esm-node/ultramodern-workspace/package-json.js

@@ -4,9 +4,8 @@ import { WORKSPACE_PACKAGE_VERSION, modernPackageSpecifier } from "../ultramoder
 import { appHasApi, remoteDependencyAlias, resolveRemoteRefs, sharedPackages, shellApp, verticalApiApps, zephyrRemoteDependency } from "./descriptors.js";
 import { readFileTemplate } from "./fs-io.js";
 import { packageName, relativeRootFor } from "./naming.js";
-import { createPublicSurfaceGenerationCommand } from "./public-surface.js";
 import { EFFECT_TSGO_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, POSTCSS_VERSION, REACT_DOM_VERSION, REACT_ROUTER_VERSION, REACT_VERSION, TAILWIND_POSTCSS_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, TYPESCRIPT_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION } from "./versions.js";
-const createStrictTsgoTypecheckCommand = (packageDir)=>`node ${relativeRootFor(packageDir)}/scripts/ultramodern-typecheck.mts --project tsconfig.json`;
+import { createStrictTsgoTypecheckCommand, createWorkspaceAppPackageScripts, createWorkspaceRootPackageScripts } from "./workspace-script-plan.js";
 const effectDiagnostics = [
     'anyUnknownInErrorContext',
     'classSelfMismatch',
@@ -129,11 +128,6 @@ function appDevDependencies(packageSource, enableTailwind) {
 function createRootPackageJson(scope, packageSource, remotes = [], bridge) {
     const shellFilter = `--filter ${packageName(scope, shellApp.packageSuffix)}`;
     const remoteFilters = remotes.map((remote)=>`--filter ${packageName(scope, remote.packageSuffix)}`);
-    const remoteBuildPrefix = remotes.length > 0 ? 'ULTRAMODERN_ZEPHYR=false pnpm -r --filter "./verticals/*" run build && ' : '';
-    const remoteCloudflareBuildPrefix = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:build && ' : '';
-    const remoteCloudflareDeployPrefix = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:deploy && ' : '';
-    const generatedPackageTypecheck = 'pnpm -r --filter "./apps/*" --filter "./verticals/*" --filter "./packages/*" run typecheck';
-    const typecheck = bridge ? generatedPackageTypecheck : "node ./scripts/ultramodern-typecheck.mts --build tsconfig.json";
     const bridgeScripts = bridge ? {
         ...Object.fromEntries(bridge.gates.map((gate)=>[
                 `bridge:${gate.name}`,
@@ -142,6 +136,11 @@ function createRootPackageJson(scope, packageSource, remotes = [], bridge) {
         'bridge:check': bridge.gates.map((gate)=>`pnpm run bridge:${gate.name}`).join(' && ')
     } : {};
     const bridgeCheck = bridge ? ' && pnpm bridge:check' : '';
+    const bridgeTypecheck = bridge ? 'pnpm -r --filter "./apps/*" --filter "./verticals/*" --filter "./packages/*" run typecheck' : void 0;
+    const rootPackageScripts = createWorkspaceRootPackageScripts(remotes, {
+        bridgeCheck,
+        typecheck: bridgeTypecheck
+    });
     const workspacePackages = [
         'apps/*',
         'verticals/*',
@@ -164,28 +163,19 @@ function createRootPackageJson(scope, packageSource, remotes = [], bridge) {
                     `dev:${remote.packageSuffix}`,
                     `pnpm --filter ${packageName(scope, remote.packageSuffix)} dev`
                 ])),
-            build: `${remoteBuildPrefix}ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm mf:types && pnpm performance:readiness`,
+            ...rootPackageScripts,
             format: "oxfmt . '!repos/**'",
             'format:check': "oxfmt --check . '!repos/**'",
             lint: 'oxlint apps verticals packages',
             'lint:fix': 'oxlint apps verticals packages --fix',
-            typecheck,
-            'cloudflare:build': `${remoteCloudflareBuildPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm mf:types`,
-            'cloudflare:deploy': `${remoteCloudflareDeployPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:deploy`,
-            'cloudflare:proof': "node ./scripts/proof-cloudflare-version.mts --out .codex/reports/cloudflare-version-proof/public-url-proof.json",
             'skills:install': "node ./scripts/bootstrap-agent-skills.mts",
             'skills:check': "node ./scripts/bootstrap-agent-skills.mts --check",
             'agents:refs:install': "node ./scripts/setup-agent-reference-repos.mts",
             'agents:refs:check': "node ./scripts/setup-agent-reference-repos.mts --check",
-            'mf:types': "node ./scripts/assert-mf-types.mts",
-            'performance:readiness': "node ./scripts/ultramodern-performance-readiness.mts",
-            'migrate:strict-effect': "node ./scripts/migrate-strict-effect.mts",
-            'contract:check': "node ./scripts/validate-ultramodern-workspace.mts",
             'api:check': "node ./scripts/check-ultramodern-api-boundaries.mts",
             'i18n:boundaries': "node ./scripts/check-ultramodern-i18n-boundaries.mts",
             ...bridgeScripts,
-            postinstall: "oxfmt . '!repos/**' && node ./scripts/bootstrap-agent-skills.mts --postinstall",
-            check: `pnpm format:check && pnpm lint && pnpm typecheck && pnpm skills:check && pnpm i18n:boundaries && pnpm api:check && pnpm contract:check && pnpm performance:readiness${bridgeCheck}`
+            postinstall: "oxfmt . '!repos/**' && node ./scripts/bootstrap-agent-skills.mts --postinstall"
         },
         engines: {
             node: '>=26',
@@ -206,6 +196,7 @@ function createRootPackageJson(scope, packageSource, remotes = [], bridge) {
             '@effect/tsgo': EFFECT_TSGO_VERSION,
             '@modern-js/code-tools': modernPackageSpecifier('@modern-js/code-tools', packageSource),
             '@modern-js/create': modernPackageSpecifier('@modern-js/create', packageSource),
+            '@modern-js/plugin-bff': modernPackageSpecifier('@modern-js/plugin-bff', packageSource),
             "@typescript/native-preview": TYPESCRIPT_NATIVE_PREVIEW_VERSION,
             lefthook: LEFTHOOK_VERSION,
             oxlint: OXLINT_VERSION,
@@ -355,8 +346,6 @@ function createRootTsConfig(apps = []) {
     };
 }
 function createAppPackage(scope, app, packageSource, enableTailwind, remotes = [], bridge) {
-    const publicSurfaceBuildCommand = createPublicSurfaceGenerationCommand(app, 'dist');
-    const publicSurfaceCloudflareOutputCommand = createPublicSurfaceGenerationCommand(app, 'cloudflare');
     const packageExports = Object.fromEntries(Object.entries(app.exposes ?? {}).map(([expose, source])=>[
             expose,
             source
@@ -365,16 +354,7 @@ function createAppPackage(scope, app, packageSource, enableTailwind, remotes = [
         private: true,
         name: packageName(scope, app.packageSuffix),
         version: '0.1.0',
-        scripts: {
-            dev: 'modern dev',
-            build: app.exposes ? `ULTRAMODERN_ZEPHYR=false modern build && ${publicSurfaceBuildCommand} && node ${relativeRootFor(app.directory)}/scripts/assert-mf-types.mts` : `ULTRAMODERN_ZEPHYR=false modern build && ${publicSurfaceBuildCommand}`,
-            'cloudflare:build': `ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern build && ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy --skip-build && ${publicSurfaceCloudflareOutputCommand}`,
-            'cloudflare:deploy': 'ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS=true pnpm run cloudflare:build && wrangler deploy --config .output/wrangler.json',
-            'cloudflare:preview': 'pnpm run cloudflare:build && wrangler dev --config .output/wrangler.json',
-            'cloudflare:proof': `node ${relativeRootFor(app.directory)}/scripts/proof-cloudflare-version.mts --app ${app.id}`,
-            serve: 'modern serve',
-            typecheck: createStrictTsgoTypecheckCommand(app.directory)
-        },
+        scripts: createWorkspaceAppPackageScripts(app),
         modernjs: {
             preset: 'presetUltramodern',
             role: 'shell' === app.kind ? 'shell' : 'module-federation-remote',
@@ -425,4 +405,4 @@ function createSharedPackage(scope, id, description) {
 function createSharedContractsIndex() {
     return readFileTemplate('packages/shared-contracts-index.ts');
 }
-export { appDependencies, appDevDependencies, createAppMfTypesTsConfig, createAppPackage, createAppTsConfig, createPackageTsConfig, createRootPackageJson, createRootTsConfig, createSharedContractsIndex, createSharedPackage, createSharedPackageTsConfig, createStrictTsgoTypecheckCommand, createTsConfigBase, createZephyrDependencies, effectDiagnostics };
+export { appDependencies, appDevDependencies, createAppMfTypesTsConfig, createAppPackage, createAppTsConfig, createPackageTsConfig, createRootPackageJson, createRootTsConfig, createSharedContractsIndex, createSharedPackage, createSharedPackageTsConfig, createTsConfigBase, createZephyrDependencies, effectDiagnostics };

package/dist/esm-node/ultramodern-workspace/pnpm-workspace-policy-plan.js

@@ -0,0 +1,114 @@
+import "node:module";
+import { DRIZZLE_ORM_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, MODULE_FEDERATION_VERSION } from "./versions.js";
+const strictEffectPackageVersionPolicyExclusions = [
+    `effect@${EFFECT_VERSION}`,
+    `@effect/opentelemetry@${EFFECT_VERSION}`
+];
+const moduleFederationModernJsPatchPath = `patches/@module-federation__modern-js-v3@${MODULE_FEDERATION_VERSION}.patch`;
+const moduleFederationBridgeReactPatchPath = `patches/@module-federation__bridge-react@${MODULE_FEDERATION_VERSION}.patch`;
+const effectDeclarationPatchPath = 'patches/effect-schema-error-type-id.patch';
+const drizzleOrmDeclarationPatchPath = 'patches/drizzle-orm-ts7-strict-declarations.patch';
+function createPnpmWorkspacePolicyPlan(options) {
+    return {
+        yamlActions: [
+            {
+                kind: 'replace-line',
+                pattern: /^ {4}'@effect\/vitest>effect': .+$/mu,
+                replacement: `    '@effect/vitest>effect': '${EFFECT_VERSION}'`
+            },
+            {
+                kind: 'ensure-scalar-map-entry',
+                key: 'overrides',
+                entryKey: "'@effect/opentelemetry'",
+                value: EFFECT_VERSION
+            },
+            {
+                kind: 'ensure-scalar-map-entry',
+                key: 'overrides',
+                entryKey: "'@effect/vitest'",
+                value: EFFECT_VITEST_VERSION
+            },
+            {
+                kind: 'ensure-scalar-map-entry',
+                key: 'overrides',
+                entryKey: 'effect',
+                value: EFFECT_VERSION
+            },
+            {
+                kind: 'ensure-scalar-map-entry',
+                key: 'allowBuilds',
+                entryKey: "'@parcel/watcher'",
+                value: 'true'
+            },
+            ...strictEffectPackageVersionPolicyExclusions.flatMap((item)=>createStrictEffectPackageVersionPolicyActions(item)),
+            {
+                kind: 'ensure-map-entry',
+                key: 'patchedDependencies',
+                entryKey: `effect@${EFFECT_VERSION}`,
+                value: effectDeclarationPatchPath
+            },
+            {
+                kind: 'ensure-map-entry',
+                key: 'patchedDependencies',
+                entryKey: `@module-federation/modern-js-v3@${MODULE_FEDERATION_VERSION}`,
+                value: moduleFederationModernJsPatchPath
+            },
+            {
+                kind: 'ensure-map-entry',
+                key: 'patchedDependencies',
+                entryKey: `@module-federation/bridge-react@${MODULE_FEDERATION_VERSION}`,
+                value: moduleFederationBridgeReactPatchPath
+            },
+            options.usesDrizzleOrm ? {
+                kind: 'ensure-map-entry',
+                key: 'patchedDependencies',
+                entryKey: `drizzle-orm@${DRIZZLE_ORM_VERSION}`,
+                value: drizzleOrmDeclarationPatchPath
+            } : {
+                kind: 'remove-map-entry',
+                entryKey: `drizzle-orm@${DRIZZLE_ORM_VERSION}`
+            }
+        ],
+        declarationPatchActions: [
+            {
+                kind: 'ensure',
+                relativePatchPath: moduleFederationModernJsPatchPath
+            },
+            {
+                kind: 'ensure',
+                relativePatchPath: moduleFederationBridgeReactPatchPath
+            },
+            {
+                kind: 'ensure',
+                relativePatchPath: effectDeclarationPatchPath
+            },
+            {
+                kind: options.usesDrizzleOrm ? 'ensure' : 'remove-if-unchanged',
+                relativePatchPath: drizzleOrmDeclarationPatchPath
+            }
+        ],
+        requiresInstallOnChange: true
+    };
+}
+function createStrictEffectPackageVersionPolicyActions(item) {
+    const packageName = item.slice(0, item.lastIndexOf('@'));
+    const escapedPackageName = packageName.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    return [
+        {
+            kind: 'replace-line',
+            pattern: new RegExp(`^ {2}- '${escapedPackageName}@[^']+'$`, 'gmu'),
+            replacement: `  - '${item}'`
+        },
+        {
+            kind: 'ensure-list-item',
+            key: 'minimumReleaseAgeExclude',
+            item
+        },
+        {
+            kind: 'ensure-list-item',
+            key: 'trustPolicyExclude',
+            item
+        }
+    ];
+}
+export { createPnpmWorkspacePolicyPlan, drizzleOrmDeclarationPatchPath, effectDeclarationPatchPath, moduleFederationBridgeReactPatchPath, moduleFederationModernJsPatchPath, strictEffectPackageVersionPolicyExclusions };