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

package/dist/esm/ultramodern-workspace/tooling-command-catalog.js

@@ -0,0 +1,100 @@
+const defineToolingCommand = (command)=>({
+        ...command,
+        wrapperPath: `scripts/${command.wrapperName}.mts`
+    });
+const generatedToolingCommands = [
+    defineToolingCommand({
+        id: 'validate',
+        command: 'validate',
+        wrapperName: 'validate-ultramodern-workspace',
+        contractKey: 'validate',
+        rootScript: 'contract:check'
+    }),
+    defineToolingCommand({
+        id: 'typecheck',
+        command: 'typecheck',
+        wrapperName: 'ultramodern-typecheck',
+        contractKey: 'typecheck',
+        rootScript: 'typecheck',
+        templatePath: "templates/workspace-scripts/ultramodern-typecheck.mjs",
+        cwd: 'invocation'
+    }),
+    defineToolingCommand({
+        id: 'mfTypes',
+        command: 'mf-types',
+        wrapperName: 'assert-mf-types',
+        contractKey: 'mfTypes',
+        rootScript: 'mf:types'
+    }),
+    defineToolingCommand({
+        id: 'publicSurface',
+        command: 'public-surface',
+        wrapperName: 'generate-public-surface-assets',
+        contractKey: 'publicSurface',
+        templatePath: "templates/workspace-scripts/generate-public-surface-assets.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationGenerate',
+        command: 'backend-federation-generate',
+        wrapperName: 'generate-node-backend-federation',
+        contractKey: 'backendFederationGenerate',
+        rootScript: 'node:backend-federation:generate',
+        templatePath: "templates/workspace-scripts/generate-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationProof',
+        command: 'backend-federation-proof',
+        wrapperName: 'proof-node-backend-federation',
+        contractKey: 'backendFederationProof',
+        rootScript: 'node:proof',
+        templatePath: "templates/workspace-scripts/proof-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareProof',
+        command: 'cloudflare-proof',
+        wrapperName: 'proof-cloudflare-version',
+        contractKey: 'cloudflareProof',
+        rootScript: 'cloudflare:proof',
+        templatePath: "templates/workspace-scripts/proof-cloudflare-version.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareOutputVerify',
+        command: 'cloudflare-output-verify',
+        wrapperName: 'verify-cloudflare-output',
+        contractKey: 'cloudflareOutputVerify',
+        rootScript: 'cloudflare-output:verify'
+    }),
+    defineToolingCommand({
+        id: 'performanceReadiness',
+        command: 'performance-readiness',
+        wrapperName: 'ultramodern-performance-readiness',
+        contractKey: 'performanceReadiness',
+        rootScript: 'performance:readiness',
+        templatePath: "templates/workspace-scripts/ultramodern-performance-readiness.mjs"
+    }),
+    defineToolingCommand({
+        id: 'migrateStrictEffect',
+        command: 'migrate-strict-effect',
+        wrapperName: 'migrate-strict-effect',
+        contractKey: 'migrateStrictEffect',
+        rootScript: 'migrate:strict-effect'
+    }),
+    defineToolingCommand({
+        id: 'routesGenerate',
+        command: 'routes-generate',
+        wrapperName: 'generate-tanstack-routes',
+        contractKey: 'routesGenerate'
+    })
+];
+const toolingCommandById = Object.fromEntries(generatedToolingCommands.map((command)=>[
+        command.id,
+        command
+    ]));
+const GENERATED_TOOLING_COMMANDS = toolingCommandById;
+const generatedToolingCommandList = ()=>generatedToolingCommands.map((command)=>command.command);
+const createToolingWrapperContract = ()=>Object.fromEntries(generatedToolingCommands.map((command)=>[
+            command.contractKey,
+            command.wrapperPath
+        ]));
+const createGeneratedToolingWrapperMap = createToolingWrapperContract;
+export { GENERATED_TOOLING_COMMANDS, createGeneratedToolingWrapperMap, createToolingWrapperContract, generatedToolingCommandList, generatedToolingCommands, toolingCommandById };

package/dist/esm/ultramodern-workspace/workspace-script-plan.js

@@ -0,0 +1,110 @@
+import { appHasApi } from "./descriptors.js";
+import { relativeRootFor } from "./naming.js";
+import { createPublicSurfaceGenerationCommand } from "./public-surface.js";
+import { GENERATED_TOOLING_COMMANDS } from "./tooling-command-catalog.js";
+const toolingWrapperPath = (key)=>GENERATED_TOOLING_COMMANDS[key].wrapperPath;
+const rootToolingScriptName = (key)=>{
+    const rootScript = GENERATED_TOOLING_COMMANDS[key].rootScript;
+    if (!rootScript) throw new Error(`Generated tooling command ${key} does not define a root package script.`);
+    return rootScript;
+};
+const rootToolingWrapperCommand = (key)=>`node ./${toolingWrapperPath(key)}`;
+const relativeToolingWrapperPath = (packageDir, key)=>`${relativeRootFor(packageDir)}/${toolingWrapperPath(key)}`;
+const packageToolingWrapperCommand = (packageDir, key)=>`node ${relativeToolingWrapperPath(packageDir, key)}`;
+const workspaceRootPackageScriptNames = {
+    build: 'build',
+    cloudflareBuild: 'cloudflare:build',
+    cloudflareDeploy: 'cloudflare:deploy',
+    cloudflareProof: rootToolingScriptName('cloudflareProof'),
+    cloudflareOutputVerify: rootToolingScriptName('cloudflareOutputVerify'),
+    backendFederationGenerate: rootToolingScriptName('backendFederationGenerate'),
+    nodeProof: rootToolingScriptName('backendFederationProof'),
+    mfTypes: rootToolingScriptName('mfTypes'),
+    performanceReadiness: rootToolingScriptName('performanceReadiness'),
+    migrateStrictEffect: rootToolingScriptName('migrateStrictEffect'),
+    zeropsMaterialize: 'zerops:materialize',
+    contractCheck: rootToolingScriptName('validate'),
+    typecheck: 'typecheck',
+    check: 'check'
+};
+const workspaceAppPackageScriptNames = {
+    dev: 'dev',
+    build: 'build',
+    cloudflareBuild: 'cloudflare:build',
+    cloudflareDeploy: 'cloudflare:deploy',
+    cloudflarePreview: 'cloudflare:preview',
+    cloudflareProof: 'cloudflare:proof',
+    serve: 'serve',
+    typecheck: 'typecheck'
+};
+const createStrictTsgoTypecheckCommand = (packageDir)=>`${packageToolingWrapperCommand(packageDir, 'typecheck')} --project tsconfig.json`;
+function createWorkspaceAppScriptPlan(app) {
+    const backendFederationBuildCommand = appHasApi(app) ? `${packageToolingWrapperCommand(app.directory, 'backendFederationGenerate')} --app ${app.id}` : void 0;
+    const backendFederationCloudflareBuildCommand = backendFederationBuildCommand ? `${backendFederationBuildCommand} --target dist-cloudflare` : void 0;
+    const buildSteps = [
+        'ULTRAMODERN_ZEPHYR=false modern build',
+        backendFederationBuildCommand,
+        createPublicSurfaceGenerationCommand(app, 'dist'),
+        app.exposes ? packageToolingWrapperCommand(app.directory, 'mfTypes') : void 0
+    ].filter((step)=>Boolean(step));
+    const cloudflareBuildSteps = [
+        'ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern build',
+        backendFederationCloudflareBuildCommand,
+        'ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy --skip-build',
+        createPublicSurfaceGenerationCommand(app, 'cloudflare'),
+        `${packageToolingWrapperCommand(app.directory, 'cloudflareOutputVerify')} --app ${app.id}`
+    ].filter((step)=>Boolean(step));
+    return {
+        dev: 'modern dev',
+        build: buildSteps.join(' && '),
+        cloudflareBuild: cloudflareBuildSteps.join(' && '),
+        cloudflareDeploy: 'ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS=true pnpm run cloudflare:build && wrangler deploy --config .output/wrangler.json',
+        cloudflarePreview: 'pnpm run cloudflare:build && wrangler dev --config .output/wrangler.json',
+        cloudflareProof: `${packageToolingWrapperCommand(app.directory, 'cloudflareProof')} --app ${app.id}`,
+        serve: 'modern serve',
+        typecheck: createStrictTsgoTypecheckCommand(app.directory)
+    };
+}
+function createWorkspaceAppPackageScripts(app) {
+    const plan = createWorkspaceAppScriptPlan(app);
+    return Object.fromEntries(Object.entries(workspaceAppPackageScriptNames).map(([planKey, packageScriptName])=>[
+            packageScriptName,
+            plan[planKey]
+        ]));
+}
+function createWorkspaceRootScriptPlan(remotes = [], options = {}) {
+    const hasRemotes = remotes.length > 0;
+    const mfTypesScript = rootToolingScriptName('mfTypes');
+    const performanceReadinessScript = rootToolingScriptName('performanceReadiness');
+    const cloudflareOutputVerifyScript = rootToolingScriptName('cloudflareOutputVerify');
+    const backendFederationGenerateScript = rootToolingScriptName('backendFederationGenerate');
+    const nodeProofScript = rootToolingScriptName('backendFederationProof');
+    const bridgeCheck = options.bridgeCheck ?? '';
+    const remoteBuildPrefix = hasRemotes ? 'ULTRAMODERN_ZEPHYR=false pnpm -r --filter "./verticals/*" run build && ' : '';
+    const remoteCloudflareBuildPrefix = hasRemotes ? 'pnpm -r --filter "./verticals/*" run cloudflare:build && ' : '';
+    const remoteCloudflareDeployPrefix = hasRemotes ? 'pnpm -r --filter "./verticals/*" run cloudflare:deploy && ' : '';
+    return {
+        build: `${remoteBuildPrefix}ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm ${mfTypesScript} && pnpm ${performanceReadinessScript}`,
+        cloudflareBuild: `${remoteCloudflareBuildPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm ${mfTypesScript} && pnpm ${cloudflareOutputVerifyScript}`,
+        cloudflareDeploy: `${remoteCloudflareDeployPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:deploy`,
+        cloudflareProof: `${rootToolingWrapperCommand('cloudflareProof')} --out .codex/reports/cloudflare-version-proof/public-url-proof.json`,
+        cloudflareOutputVerify: rootToolingWrapperCommand('cloudflareOutputVerify'),
+        backendFederationGenerate: rootToolingWrapperCommand('backendFederationGenerate'),
+        nodeProof: rootToolingWrapperCommand('backendFederationProof'),
+        mfTypes: rootToolingWrapperCommand('mfTypes'),
+        performanceReadiness: rootToolingWrapperCommand('performanceReadiness'),
+        migrateStrictEffect: rootToolingWrapperCommand('migrateStrictEffect'),
+        zeropsMaterialize: "node ./scripts/materialize-zerops-runtime.mjs",
+        contractCheck: rootToolingWrapperCommand('validate'),
+        typecheck: options.typecheck ?? `${rootToolingWrapperCommand('typecheck')} --project tsconfig.json`,
+        check: `pnpm format:check && pnpm lint && pnpm typecheck && pnpm skills:check && pnpm i18n:boundaries && pnpm api:check && pnpm contract:check && pnpm ${backendFederationGenerateScript} && pnpm ${nodeProofScript} && pnpm performance:readiness${bridgeCheck}`
+    };
+}
+function createWorkspaceRootPackageScripts(remotes = [], options = {}) {
+    const plan = createWorkspaceRootScriptPlan(remotes, options);
+    return Object.fromEntries(Object.entries(workspaceRootPackageScriptNames).map(([planKey, packageScriptName])=>[
+            packageScriptName,
+            plan[planKey]
+        ]));
+}
+export { createStrictTsgoTypecheckCommand, createWorkspaceAppPackageScripts, createWorkspaceAppScriptPlan, createWorkspaceRootPackageScripts, createWorkspaceRootScriptPlan, packageToolingWrapperCommand, rootToolingScriptName, rootToolingWrapperCommand, workspaceAppPackageScriptNames, workspaceRootPackageScriptNames };

package/dist/esm/ultramodern-workspace/workspace-scripts.js

@@ -1,14 +1,8 @@
 import node_fs from "node:fs";
 import node_path from "node:path";
-import { verticalApiGroupName } from "./api.js";
-import { remoteComponentOutputPath } from "./demo-components.js";
-import { appHasApi, appI18nNamespace, remoteDependencyAlias, shellApp } from "./descriptors.js";
 import { readFileTemplate, renderFileTemplate, writeFileReplacing } from "./fs-io.js";
-import { packageName, tailwindPrefixForApp } from "./naming.js";
-import { createCloudflareSecurityContract } from "./policy.js";
-import { publicSurfaceManagedSourceAssetPaths } from "./public-surface.js";
-import { createLocalisedUrlsMap, createRouteMetaFilePath, createRouteOwnedI18nPaths, createRoutePageFilePath } from "./routes.js";
-import { CLOUDFLARE_COMPATIBILITY_DATE, EFFECT_VERSION, MODULE_FEDERATION_VERSION, NODE_VERSION, PNPM_VERSION } from "./versions.js";
+import { GENERATED_TOOLING_COMMANDS, generatedToolingCommands } from "./tooling-command-catalog.js";
+import { createWorkspaceValidationContract } from "./workspace-validation-contract.js";
 function createToolWrapperScript(command, extraArgs = []) {
     const commandJson = JSON.stringify(command);
     const extraArgsJson = JSON.stringify(extraArgs);
@@ -42,6 +36,13 @@ if (result.error) {
 process.exit(result.status ?? 1);
 `;
 }
+function writeGeneratedToolWrapperScript(targetDir, key) {
+    const command = GENERATED_TOOLING_COMMANDS[key];
+    writeWorkspaceOwnedMtsScript(targetDir, command.wrapperName, createToolWrapperScript(command.command));
+}
+function writeGeneratedToolWrapperScripts(targetDir) {
+    for (const command of generatedToolingCommands)writeGeneratedToolWrapperScript(targetDir, command.id);
+}
 function createSkillsToolWrapperScript() {
     return `#!/usr/bin/env node
 import { spawnSync } from 'node:child_process';
@@ -96,54 +97,24 @@ function migrateCopiedWorkspaceScriptToMts(targetDir, name) {
     node_fs.renameSync(legacyPath, migratedPath);
 }
 function createWorkspaceValidationScript(scope, enableTailwind, remotes = []) {
-    const verticals = remotes.filter(appHasApi).map((remote)=>({
-            id: remote.id,
-            domain: remote.domain,
-            stem: remote.api.stem,
-            group: verticalApiGroupName(remote),
-            path: remote.directory,
-            port: remote.port,
-            mfName: remote.mfName,
-            apiPrefix: remote.api.prefix,
-            tailwindPrefix: tailwindPrefixForApp(remote),
-            zephyrAlias: remoteDependencyAlias(remote),
-            packageName: packageName(scope, remote.packageSuffix),
-            exposes: Object.keys(remote.exposes ?? {}),
-            componentPaths: Object.keys(remote.exposes ?? {}).map((expose)=>remoteComponentOutputPath(remote, expose)).filter((componentPath)=>Boolean(componentPath)),
-            namespace: appI18nNamespace(remote),
-            routePagePaths: createRouteOwnedI18nPaths(remote).filter((route)=>'/' !== route.canonicalPath).map((route)=>createRoutePageFilePath(remote, route.canonicalPath)),
-            routeMetaPaths: createRouteOwnedI18nPaths(remote).map((route)=>createRouteMetaFilePath(remote, route.canonicalPath)),
-            localisedUrls: createLocalisedUrlsMap(remote),
-            verticalRefs: remote.verticalRefs ?? []
-        }));
-    const shellRouteMetaPaths = createRouteOwnedI18nPaths(shellApp).map((route)=>createRouteMetaFilePath(shellApp, route.canonicalPath));
-    const shellNamespace = appI18nNamespace(shellApp);
-    const oldRemotePaths = [
-        'apps/remotes'
-    ];
-    const expectedBuildScript = remotes.length > 0 ? 'ULTRAMODERN_ZEPHYR=false pnpm -r --filter "./verticals/*" run build && ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm mf:types && pnpm performance:readiness' : 'ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm mf:types && pnpm performance:readiness';
-    const expectedCloudflareBuildScript = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:build && pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm mf:types' : 'pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm mf:types';
-    const expectedCloudflareDeployScript = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:deploy && pnpm --filter "./apps/shell-super-app" run cloudflare:deploy' : 'pnpm --filter "./apps/shell-super-app" run cloudflare:deploy';
-    const expectedCloudflareSecurity = createCloudflareSecurityContract();
+    const contract = createWorkspaceValidationContract(scope, enableTailwind, remotes);
     return renderFileTemplate("workspace-scripts/validate-ultramodern-workspace.mjs", {
-        packageScope: scope,
-        effectVersion: EFFECT_VERSION,
-        moduleFederationVersion: MODULE_FEDERATION_VERSION,
-        nodeVersion: NODE_VERSION,
-        pnpmVersion: PNPM_VERSION,
-        tailwindEnabledJson: JSON.stringify(enableTailwind),
-        fullStackVerticalsJson: JSON.stringify(verticals, null, 2),
-        shellNamespaceJson: JSON.stringify(shellNamespace),
-        oldRemotePathsJson: JSON.stringify(oldRemotePaths, null, 2),
-        expectedBuildScriptJson: JSON.stringify(expectedBuildScript),
-        expectedCloudflareBuildScriptJson: JSON.stringify(expectedCloudflareBuildScript),
-        expectedCloudflareDeployScriptJson: JSON.stringify(expectedCloudflareDeployScript),
-        expectedCloudflareSecurityJson: JSON.stringify(expectedCloudflareSecurity, null, 2),
-        publicSurfaceManagedSourceAssetPathsJson: JSON.stringify([
-            ...publicSurfaceManagedSourceAssetPaths
-        ], null, 2),
-        shellRouteMetaPathsJson: JSON.stringify(shellRouteMetaPaths, null, 2),
-        cloudflareCompatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+        packageScope: contract.packageScope,
+        nodeVersion: contract.versions.node,
+        tailwindEnabledJson: JSON.stringify(contract.tailwindEnabled),
+        fullStackVerticalsJson: JSON.stringify(contract.fullStackVerticals, null, 2),
+        shellNamespaceJson: JSON.stringify(contract.shellNamespace),
+        oldRemotePathsJson: JSON.stringify(contract.oldRemotePaths),
+        expectedBuildScriptJson: JSON.stringify(contract.scripts.build),
+        expectedCloudflareBuildScriptJson: JSON.stringify(contract.scripts.cloudflareBuild),
+        expectedCloudflareDeployScriptJson: JSON.stringify(contract.scripts.cloudflareDeploy),
+        expectedCloudflareSecurityJson: JSON.stringify(contract.cloudflareSecurity, null, 2),
+        workspaceValidationContractJson: JSON.stringify(contract, null, 2),
+        publicSurfaceManagedSourceAssetPathsJson: JSON.stringify(contract.publicSurfaceManagedSourceAssetPaths, null, 2),
+        shellRouteMetaPathsJson: JSON.stringify(contract.shellRouteMetaPaths, null, 2),
+        effectVersion: contract.versions.effect,
+        moduleFederationVersion: contract.versions.moduleFederation,
+        cloudflareCompatibilityDate: contract.versions.cloudflareCompatibilityDate
     });
 }
 function createWorkspaceI18nBoundaryValidationScript() {
@@ -155,18 +126,19 @@ function createWorkspaceApiBoundaryValidationScript() {
 function createPerformanceReadinessConfigScript() {
     return readFileTemplate("workspace-scripts/ultramodern-performance-readiness.config.mjs");
 }
+function createNodeBackendFederationProofScript() {
+    return readFileTemplate("workspace-scripts/proof-node-backend-federation.mjs");
+}
+function createZeropsRuntimeMaterializationScript() {
+    return readFileTemplate("workspace-scripts/materialize-zerops-runtime.mjs");
+}
 function writeGeneratedWorkspaceScripts(targetDir, _scope, _enableTailwind, _remotes = []) {
-    writeWorkspaceOwnedMtsScript(targetDir, 'assert-mf-types', createToolWrapperScript('mf-types'));
-    writeWorkspaceOwnedMtsScript(targetDir, 'validate-ultramodern-workspace', createToolWrapperScript('validate'));
     writeWorkspaceOwnedMtsScript(targetDir, 'check-ultramodern-i18n-boundaries', createWorkspaceI18nBoundaryValidationScript());
     writeWorkspaceOwnedMtsScript(targetDir, 'check-ultramodern-api-boundaries', createWorkspaceApiBoundaryValidationScript());
-    writeWorkspaceOwnedMtsScript(targetDir, 'generate-public-surface-assets', createToolWrapperScript('public-surface'));
-    writeWorkspaceOwnedMtsScript(targetDir, 'proof-cloudflare-version', createToolWrapperScript('cloudflare-proof'));
+    writeFileReplacing(targetDir, "scripts/materialize-zerops-runtime.mjs", createZeropsRuntimeMaterializationScript());
     writeFileReplacing(targetDir, "scripts/ultramodern-performance-readiness.config.mjs", createPerformanceReadinessConfigScript());
-    writeWorkspaceOwnedMtsScript(targetDir, 'ultramodern-performance-readiness', createToolWrapperScript('performance-readiness'));
-    writeWorkspaceOwnedMtsScript(targetDir, 'migrate-strict-effect', createToolWrapperScript('migrate-strict-effect'));
-    writeWorkspaceOwnedMtsScript(targetDir, 'ultramodern-typecheck', createToolWrapperScript('typecheck'));
+    writeGeneratedToolWrapperScripts(targetDir);
     writeWorkspaceOwnedMtsScript(targetDir, 'bootstrap-agent-skills', createSkillsToolWrapperScript());
     migrateCopiedWorkspaceScriptToMts(targetDir, 'setup-agent-reference-repos');
 }
-export { createPerformanceReadinessConfigScript, createWorkspaceApiBoundaryValidationScript, createWorkspaceI18nBoundaryValidationScript, createWorkspaceValidationScript, writeGeneratedWorkspaceScripts };
+export { createNodeBackendFederationProofScript, createPerformanceReadinessConfigScript, createWorkspaceApiBoundaryValidationScript, createWorkspaceI18nBoundaryValidationScript, createWorkspaceValidationScript, createZeropsRuntimeMaterializationScript, writeGeneratedToolWrapperScripts, writeGeneratedWorkspaceScripts };

package/dist/esm/ultramodern-workspace/workspace-validation-contract.js

@@ -0,0 +1,59 @@
+import { verticalApiGroupName } from "./api.js";
+import { createBackendFederationMetadata } from "./backend-federation.js";
+import { createDeliveryUnitRecord } from "./delivery-unit.js";
+import { remoteComponentOutputPath } from "./demo-components.js";
+import { appHasApi, appI18nNamespace, remoteDependencyAlias, shellApp } from "./descriptors.js";
+import { packageName, tailwindPrefixForApp } from "./naming.js";
+import { createCloudflareSecurityContract } from "./policy.js";
+import { publicSurfaceManagedSourceAssetPaths } from "./public-surface.js";
+import { createLocalisedUrlsMap, createRouteMetaFilePath, createRouteOwnedI18nPaths, createRoutePageFilePath } from "./routes.js";
+import { CLOUDFLARE_COMPATIBILITY_DATE, EFFECT_VERSION, MODULE_FEDERATION_VERSION, NODE_VERSION, PNPM_VERSION } from "./versions.js";
+import { createWorkspaceRootPackageScripts, createWorkspaceRootScriptPlan } from "./workspace-script-plan.js";
+function createWorkspaceValidationContract(scope, enableTailwind, remotes = []) {
+    const fullStackVerticals = remotes.filter(appHasApi).map((remote)=>({
+            id: remote.id,
+            domain: remote.domain,
+            stem: remote.api.stem,
+            group: verticalApiGroupName(remote),
+            path: remote.directory,
+            port: remote.port,
+            mfName: remote.mfName,
+            apiPrefix: remote.api.prefix,
+            tailwindPrefix: tailwindPrefixForApp(remote),
+            zephyrAlias: remoteDependencyAlias(remote),
+            packageName: packageName(scope, remote.packageSuffix),
+            backendFederation: createBackendFederationMetadata(scope, remote),
+            deliveryUnit: createDeliveryUnitRecord(scope, remote),
+            exposes: Object.keys(remote.exposes ?? {}),
+            componentPaths: Object.keys(remote.exposes ?? {}).map((expose)=>remoteComponentOutputPath(remote, expose)).filter((componentPath)=>Boolean(componentPath)),
+            namespace: appI18nNamespace(remote),
+            routePagePaths: createRouteOwnedI18nPaths(remote).filter((route)=>'/' !== route.canonicalPath).map((route)=>createRoutePageFilePath(remote, route.canonicalPath)),
+            routeMetaPaths: createRouteOwnedI18nPaths(remote).map((route)=>createRouteMetaFilePath(remote, route.canonicalPath)),
+            localisedUrls: createLocalisedUrlsMap(remote),
+            verticalRefs: remote.verticalRefs ?? []
+        }));
+    return {
+        packageScope: scope,
+        versions: {
+            cloudflareCompatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE,
+            effect: EFFECT_VERSION,
+            moduleFederation: MODULE_FEDERATION_VERSION,
+            node: NODE_VERSION,
+            pnpm: PNPM_VERSION
+        },
+        tailwindEnabled: enableTailwind,
+        fullStackVerticals,
+        shellNamespace: appI18nNamespace(shellApp),
+        oldRemotePaths: [
+            'apps/remotes'
+        ],
+        scripts: createWorkspaceRootScriptPlan(remotes),
+        packageScripts: createWorkspaceRootPackageScripts(remotes),
+        cloudflareSecurity: createCloudflareSecurityContract(),
+        publicSurfaceManagedSourceAssetPaths: [
+            ...publicSurfaceManagedSourceAssetPaths
+        ],
+        shellRouteMetaPaths: createRouteOwnedI18nPaths(shellApp).map((route)=>createRouteMetaFilePath(shellApp, route.canonicalPath))
+    };
+}
+export { createWorkspaceValidationContract };

package/dist/esm/ultramodern-workspace/write-workspace.js

@@ -1,6 +1,7 @@
 import node_fs from "node:fs";
-import { createApiClient, createApiServiceEntry, createSharedApi, createShellApiClient } from "./api.js";
+import { createApiClient, createApiServiceEntry, createBackendEffectApiExpose, createSharedApi, createShellApiClient } from "./api.js";
 import { createAppEnvDts, createAppRuntimeConfig, createAppStyles, createPostcssConfig, createSharedDesignTokensCss, createShellFrameComponent, createTailwindConfig } from "./app-files.js";
+import { createBackendFederationContractFile } from "./backend-federation.js";
 import { normalizeUltramodernBridgeConfig } from "./bridge-config.js";
 import { createDevelopmentOverlay, createOwnership, createTopology, createUltramodernConfig } from "./contracts.js";
 import { createLayout, createRemoteEntry, createRemoteExposeComponent, createRemotePage, createShellPage, createShellRemoteComponents, remoteComponentOutputPath } from "./demo-components.js";
@@ -8,7 +9,7 @@ import { ULTRAMODERN_CONFIG_PATH, appHasApi, appI18nNamespace, createShellHost,
 import { copyRootTemplate, formatGeneratedWorkspaceFiles, writeFile, writeFileReplacing, writeJson } from "./fs-io.js";
 import { createFileSnapshot, createGenerationResult, diffFileSnapshots } from "./generation-result.js";
 import { createAppPublicLocaleMessages } from "./locales.js";
-import { createAppModernConfig, createRemoteModuleFederationConfig, createShellModuleFederationConfig, createUltramodernBuildModule, createUltramodernBuildReexportModule } from "./module-federation.js";
+import { createAppModernConfig, createBackendModuleFederationConfig, createRemoteModuleFederationConfig, createShellModuleFederationConfig, createUltramodernBuildModule, createUltramodernBuildReexportModule } from "./module-federation.js";
 import { assertUniqueTailwindPrefixes, toPackageScope } from "./naming.js";
 import { runCodeSmithOverlays } from "./overlays.js";
 import { createAppMfTypesTsConfig, createAppPackage, createAppTsConfig, createRootPackageJson, createRootTsConfig, createSharedContractsIndex, createSharedPackage, createSharedPackageTsConfig, createTsConfigBase } from "./package-json.js";
@@ -16,6 +17,7 @@ import { resolvePackageSource } from "./package-source.js";
 import { createPublicWebAppArtifacts } from "./public-surface.js";
 import { DRIZZLE_ORM_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, NODE_VERSION, PNPM_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_VERSION } from "./versions.js";
 import { writeGeneratedWorkspaceScripts } from "./workspace-scripts.js";
+import { createZeropsYaml } from "./zerops.js";
 function writeApp(targetDir, scope, app, packageSource, enableTailwind, remotes = [], bridge) {
     const resolvedApp = 'shell' === app.kind ? createShellHost(remotes) : app;
     const publicWeb = createPublicWebAppArtifacts(resolvedApp);
@@ -31,7 +33,7 @@ function writeApp(targetDir, scope, app, packageSource, enableTailwind, remotes
     writeFile(targetDir, publicWeb.jsonLdHelperFile.path, publicWeb.jsonLdHelperFile.content);
     writeFile(targetDir, publicWeb.routeMetadataFile.path, publicWeb.routeMetadataFile.content);
     writeFile(targetDir, publicWeb.routeHeadFile.path, publicWeb.routeHeadFile.content);
-    writeFile(targetDir, `${resolvedApp.directory}/modern.config.ts`, createAppModernConfig(scope, resolvedApp));
+    writeFile(targetDir, `${resolvedApp.directory}/modern.config.ts`, createAppModernConfig(scope, resolvedApp, remotes));
     writeFile(targetDir, `${resolvedApp.directory}/src/modern.runtime.ts`, createAppRuntimeConfig(resolvedApp, scope, remotes));
     writeJson(targetDir, `${resolvedApp.directory}/locales/en/translation.json`, createAppPublicLocaleMessages(resolvedApp, 'en', remotes));
     writeJson(targetDir, `${resolvedApp.directory}/locales/en/${appI18nNamespace(resolvedApp)}.json`, createAppPublicLocaleMessages(resolvedApp, 'en', remotes));
@@ -43,6 +45,7 @@ function writeApp(targetDir, scope, app, packageSource, enableTailwind, remotes
         writeFile(targetDir, `${resolvedApp.directory}/tailwind.config.ts`, createTailwindConfig());
     }
     writeFile(targetDir, `${resolvedApp.directory}/module-federation.config.ts`, 'shell' === resolvedApp.kind ? createShellModuleFederationConfig(scope, remotes) : createRemoteModuleFederationConfig(scope, resolvedApp, remotes));
+    if (appHasApi(resolvedApp)) writeFile(targetDir, `${resolvedApp.directory}/backend-federation.config.ts`, createBackendModuleFederationConfig(resolvedApp));
     writeAppFile('src/routes/layout.tsx', createLayout(resolvedApp.id));
     writeAppFile('src/routes/[lang]/page.tsx', 'shell' === resolvedApp.kind ? createShellPage(remotes) : createRemotePage(resolvedApp));
     for (const generatedFile of publicWeb.routeMetaFiles)writeFile(targetDir, generatedFile.path, generatedFile.content);
@@ -55,6 +58,8 @@ function writeApp(targetDir, scope, app, packageSource, enableTailwind, remotes
     if (appHasApi(resolvedApp)) {
         writeFile(targetDir, `${resolvedApp.directory}/shared/api.ts`, createSharedApi(resolvedApp));
         writeFile(targetDir, `${resolvedApp.directory}/api/index.ts`, createApiServiceEntry(resolvedApp, '../shared/api.ts'));
+        writeFile(targetDir, `${resolvedApp.directory}/api/backend-federation.ts`, createBackendFederationContractFile(resolvedApp));
+        writeFile(targetDir, `${resolvedApp.directory}/api/effect-api.ts`, createBackendEffectApiExpose(scope, resolvedApp));
         writeFile(targetDir, `${resolvedApp.directory}/src/api/${resolvedApp.api.stem}-client.ts`, createApiClient(resolvedApp, '../../shared/api'));
     }
     if ('vertical' === resolvedApp.kind) {
@@ -104,7 +109,7 @@ function writePnpmWorkspacePackages(targetDir, bridge) {
         ...bridge.workspacePackages.map((entry)=>entry.pattern)
     ];
     const renderedPackages = packages.map((pattern)=>`  - ${pattern}`).join('\n');
-    writeFileReplacing(targetDir, 'pnpm-workspace.yaml', pnpmWorkspace.replace(/^packages:\n(?: {2}- .+\n)+/u, `packages:\n${renderedPackages}\n`));
+    writeFileReplacing(targetDir, 'pnpm-workspace.yaml', pnpmWorkspace.replace(/^packages:\r?\n(?: {2}- .+\r?\n)+/u, `packages:\n${renderedPackages}\n`));
 }
 function generateUltramodernWorkspace(options) {
     const beforeFiles = createFileSnapshot(options.targetDir);
@@ -141,11 +146,12 @@ function generateUltramodernWorkspace(options) {
     });
     writePnpmWorkspacePackages(options.targetDir, bridge);
     writeJson(options.targetDir, 'package.json', createCompactRootPackageJson(scope, packageSource, initialVerticals, bridge));
+    writeFile(options.targetDir, 'zerops.yaml', `${createZeropsYaml(scope, createdApps)}\n`);
     writeJson(options.targetDir, 'tsconfig.base.json', createTsConfigBase());
     writeJson(options.targetDir, 'tsconfig.json', createRootTsConfig(createdApps));
     writeJson(options.targetDir, 'topology/reference-topology.json', createTopology(scope, initialVerticals));
     writeJson(options.targetDir, 'topology/ownership.json', createOwnership(scope, initialVerticals));
-    writeJson(options.targetDir, 'topology/local-overlays/development.json', createDevelopmentOverlay(initialVerticals));
+    writeJson(options.targetDir, 'topology/local-overlays/development.json', createDevelopmentOverlay(scope, initialVerticals));
     writeJson(options.targetDir, ULTRAMODERN_CONFIG_PATH, createCompactUltramodernConfig(scope, options.modernVersion, packageSource, createdApps, enableTailwind, bridge));
     writeApp(options.targetDir, scope, shellApp, packageSource, enableTailwind, initialVerticals, bridge);
     for (const remote of initialVerticals)writeApp(options.targetDir, scope, remote, packageSource, enableTailwind, initialVerticals, bridge);

package/dist/esm/ultramodern-workspace/zerops.js

@@ -0,0 +1,62 @@
+import { appHasApi, resolveApiPrefix, resolveApiStem } from "./descriptors.js";
+import { packageName } from "./naming.js";
+import { NODE_VERSION } from "./versions.js";
+const zeropsNodeRuntime = `nodejs@${NODE_VERSION.split('.')[0]}`;
+function quoteYamlString(value) {
+    return `'${value.replace(/'/gu, "''")}'`;
+}
+function readinessPath(app) {
+    if (!appHasApi(app)) return '/';
+    return `${resolveApiPrefix(app)}/${resolveApiStem(app)}/readiness`;
+}
+function createZeropsService(scope, app) {
+    const runtimeDirectory = `.zerops/runtime/${app.id}`;
+    const appPackageName = packageName(scope, app.packageSuffix);
+    const commands = [
+        'curl https://mise.run | sh',
+        '~/.local/bin/mise install',
+        '~/.local/bin/mise exec -- pnpm install --frozen-lockfile',
+        `~/.local/bin/mise exec -- pnpm --filter ${appPackageName} run build`,
+        `~/.local/bin/mise exec -- pnpm run zerops:materialize -- --app ${app.id} --package ${appPackageName} --package-dir ${app.directory}`,
+        `cp topology/reference-topology.json ${runtimeDirectory}/topology.json`,
+        `cp topology/local-overlays/development.json ${runtimeDirectory}/local-overlay.json`
+    ];
+    return [
+        `  - setup: ${app.id}`,
+        '    build:',
+        `      base: ${zeropsNodeRuntime}`,
+        '      buildCommands:',
+        '        - |',
+        ...commands.map((command)=>`          ${command}`),
+        '      deployFiles:',
+        `        - ${runtimeDirectory}`,
+        '    deploy:',
+        '      temporaryShutdown: false',
+        '      readinessCheck:',
+        '        httpGet:',
+        `          port: ${app.port}`,
+        `          path: ${readinessPath(app)}`,
+        '        failureTimeout: 120',
+        '        retryPeriod: 10',
+        '    run:',
+        `      base: ${zeropsNodeRuntime}`,
+        '      ports:',
+        `        - port: ${app.port}`,
+        '          protocol: TCP',
+        '          httpSupport: true',
+        '      envVariables:',
+        '        NODE_ENV: production',
+        `        ${app.portEnv}: ${quoteYamlString(String(app.port))}`,
+        `        ULTRAMODERN_ZEROPS_SERVICE: ${quoteYamlString(app.id)}`,
+        `      start: cd ${runtimeDirectory} && npm run serve`
+    ].join('\n');
+}
+function createZeropsYaml(scope, apps) {
+    return [
+        '# Generated by Modern.js UltraModern workspace tooling.',
+        '# Zerops runs each full-stack MicroVertical as a package-owned Node service.',
+        'zerops:',
+        ...apps.map((app)=>createZeropsService(scope, app))
+    ].join('\n\n');
+}
+export { createZeropsYaml };