@bleedingdev/modern-js-create 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

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

@@ -0,0 +1,125 @@
+import "node:module";
+import { appHasApi, shellApp } from "./descriptors.js";
+import { relativeRootFor } from "./naming.js";
+import { createPublicSurfaceGenerationCommand } from "./public-surface.js";
+import { GENERATED_TOOLING_COMMANDS } from "./tooling-command-catalog.js";
+const GENERATED_POSTINSTALL_SCRIPT = "node ./scripts/bootstrap-agent-skills.mts --postinstall && oxfmt . '!repos/**'";
+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'),
+    cloudflareSsrProof: 'cloudflare:ssr-proof',
+    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 shellOnlyOmittedRootScriptPlanKeys = new Set([
+    'cloudflareSsrProof',
+    'zeropsMaterialize'
+]);
+const backendSurfaceOmittedRootScriptPlanKeys = new Set([
+    'backendFederationGenerate',
+    'nodeProof'
+]);
+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 buildSteps = [
+        'modern build',
+        createPublicSurfaceGenerationCommand(app, 'dist'),
+        'MODERNJS_DEPLOY=node modern deploy --skip-build'
+    ].filter((step)=>Boolean(step));
+    const cloudflareBuildSteps = [
+        'MODERNJS_DEPLOY=cloudflare modern build',
+        createPublicSurfaceGenerationCommand(app, 'cloudflare-dist'),
+        'MODERNJS_DEPLOY=cloudflare modern deploy --skip-build',
+        `${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;
+    remotes.some(appHasApi);
+    const shells = options.shells && options.shells.length > 0 ? options.shells : [
+        shellApp
+    ];
+    const shellBuild = shells.map((shell)=>`pnpm --filter "./${shell.directory}" run build`).join(' && ');
+    const shellCloudflareBuild = shells.map((shell)=>`pnpm --filter "./${shell.directory}" run cloudflare:build`).join(' && ');
+    const shellCloudflareDeploy = shells.map((shell)=>`pnpm --filter "./${shell.directory}" run cloudflare:deploy`).join(' && ');
+    const mfTypesScript = rootToolingScriptName('mfTypes');
+    const performanceReadinessScript = rootToolingScriptName('performanceReadiness');
+    const cloudflareOutputVerifyScript = rootToolingScriptName('cloudflareOutputVerify');
+    const bridgeCheck = options.bridgeCheck ?? '';
+    const remoteBuildPrefix = hasRemotes ? '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}${shellBuild} && pnpm ${mfTypesScript} && pnpm ${performanceReadinessScript}`,
+        cloudflareBuild: `${remoteCloudflareBuildPrefix}${shellCloudflareBuild} && pnpm ${mfTypesScript} && pnpm ${cloudflareOutputVerifyScript} && pnpm cloudflare:ssr-proof`,
+        cloudflareDeploy: `${remoteCloudflareDeployPrefix}${shellCloudflareDeploy}`,
+        cloudflareProof: `${rootToolingWrapperCommand('cloudflareProof')} --out .codex/reports/cloudflare-version-proof/public-url-proof.json`,
+        cloudflareSsrProof: "node ./scripts/proof-workerd-ssr.mts",
+        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 performance:readiness${bridgeCheck}`
+    };
+}
+function createWorkspaceRootPackageScripts(remotes = [], options = {}) {
+    const plan = createWorkspaceRootScriptPlan(remotes, options);
+    const shellOnly = 0 === remotes.length;
+    const hasBackendSurface = remotes.some(appHasApi);
+    return Object.fromEntries(Object.entries(workspaceRootPackageScriptNames).filter(([planKey])=>!(!hasBackendSurface && backendSurfaceOmittedRootScriptPlanKeys.has(planKey)) && !(shellOnly && shellOnlyOmittedRootScriptPlanKeys.has(planKey))).map(([planKey, packageScriptName])=>[
+            packageScriptName,
+            plan[planKey]
+        ]));
+}
+export { GENERATED_POSTINSTALL_SCRIPT, createStrictTsgoTypecheckCommand, createWorkspaceAppPackageScripts, createWorkspaceRootPackageScripts, createWorkspaceRootScriptPlan };

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

@@ -1,18 +1,32 @@
 import "node:module";
 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, NODE_VERSION, PNPM_VERSION } from "./versions.js";
+import { appHasApi } from "./descriptors.js";
+import { readFileTemplate as external_fs_io_js_readFileTemplate, renderFileTemplate, workspaceTemplateDir, writeFileReplacing } from "./fs-io.js";
+import { GENERATED_TOOLING_COMMANDS, generatedToolingCommands } from "./tooling-command-catalog.js";
+import { createWorkspaceValidationContract } from "./workspace-validation-contract.js";
+const singleQuoted = (value)=>`'${value.replace(/'/gu, "\\'")}'`;
+const toolWrapperResultHandling = `
+if (result.error) {
+  const launchTarget = createBin
+    ? process.execPath + ' with ULTRAMODERN_CREATE_BIN=' + createBin
+    : 'modern-js-create from PATH';
+  console.error(
+    'Failed to launch ' +
+      launchTarget +
+      ' for UltraModern command "' +
+      ultramodernArgs.slice(1).join(' ') +
+      '": ' +
+      result.error.message,
+  );
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);
+`;
 function createToolWrapperScript(command, extraArgs = []) {
-    const commandJson = JSON.stringify(command);
-    const extraArgsJson = JSON.stringify(extraArgs);
+    const commandLiteral = singleQuoted(command);
+    const extraArgsLiteral = `[${extraArgs.map(singleQuoted).join(', ')}]`;
     return `#!/usr/bin/env node
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
@@ -23,7 +37,7 @@ const forwardedArgs = process.argv.slice(2);
 const workspaceRoot =
   process.env.ULTRAMODERN_WORKSPACE_ROOT ??
   path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const ultramodernArgs = ['ultramodern', ${commandJson}, ...${extraArgsJson}, ...forwardedArgs];
+const ultramodernArgs = ['ultramodern', ${commandLiteral}, ...${extraArgsLiteral}, ...forwardedArgs];
 const result = createBin
   ? spawnSync(process.execPath, [createBin, ...ultramodernArgs], {
       env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
@@ -34,14 +48,15 @@ const result = createBin
       shell: process.platform === 'win32',
       stdio: 'inherit',
     });
-
-if (result.error) {
-  console.error(result.error.message);
-  process.exit(1);
+${toolWrapperResultHandling}`;
 }
-
-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, options = {}) {
+    const backendSurface = options.hasBackendSurface ?? !options.shellOnly;
+    for (const command of generatedToolingCommands)if (!(!backendSurface && BACKEND_FEDERATION_WRAPPER_IDS.has(command.id))) writeGeneratedToolWrapperScript(targetDir, command.id);
 }
 function createSkillsToolWrapperScript() {
     return `#!/usr/bin/env node
@@ -69,14 +84,7 @@ const result = createBin
       shell: process.platform === 'win32',
       stdio: 'inherit',
     });
-
-if (result.error) {
-  console.error(result.error.message);
-  process.exit(1);
-}
-
-process.exit(result.status ?? 1);
-`;
+${toolWrapperResultHandling}`;
 }
 function removeLegacyWorkspaceScript(targetDir, relativePath) {
     node_fs.rmSync(node_path.join(targetDir, relativePath), {
@@ -96,76 +104,98 @@ 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();
+function createWorkspaceValidationScript(scope, enableTailwind, remotes = [], releaseCohort, additionalShells = [], primaryShell, compactConfigOverride, ownershipOverride, developmentOverlayOverride) {
+    const contract = createWorkspaceValidationContract(scope, enableTailwind, remotes, releaseCohort, additionalShells, primaryShell, compactConfigOverride, ownershipOverride, developmentOverlayOverride);
     return renderFileTemplate("workspace-scripts/validate-ultramodern-workspace.mjs", {
-        packageScope: scope,
-        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
+        workspaceValidationContractJson: JSON.stringify(contract, null, 2)
     });
 }
 function createWorkspaceI18nBoundaryValidationScript() {
-    return readFileTemplate("workspace-scripts/check-ultramodern-i18n-boundaries.mts");
+    return external_fs_io_js_readFileTemplate("workspace-scripts/check-ultramodern-i18n-boundaries.mts");
 }
 function createWorkspaceApiBoundaryValidationScript() {
-    return readFileTemplate("workspace-scripts/check-ultramodern-api-boundaries.mts");
+    return external_fs_io_js_readFileTemplate("workspace-scripts/check-ultramodern-api-boundaries.mts");
 }
 function createPerformanceReadinessConfigScript() {
-    return readFileTemplate("workspace-scripts/ultramodern-performance-readiness.config.mjs");
+    return external_fs_io_js_readFileTemplate("workspace-scripts/ultramodern-performance-readiness.config.mjs");
+}
+function createWorkerdSsrProofScript() {
+    return external_fs_io_js_readFileTemplate("workspace-scripts/proof-workerd-ssr.mts");
 }
-function writeGeneratedWorkspaceScripts(targetDir, _scope, _enableTailwind, _remotes = []) {
-    writeWorkspaceOwnedMtsScript(targetDir, 'assert-mf-types', createToolWrapperScript('mf-types'));
-    writeWorkspaceOwnedMtsScript(targetDir, 'validate-ultramodern-workspace', createToolWrapperScript('validate'));
+function createZeropsRuntimeMaterializationScript() {
+    return external_fs_io_js_readFileTemplate("workspace-scripts/materialize-zerops-runtime.mjs");
+}
+function writeGeneratedWorkspaceScripts(targetDir, scope, enableTailwind, remotes = [], releaseCohort, additionalShells = [], primaryShell) {
+    const shellOnly = 0 === remotes.length;
+    const hasBackendSurface = remotes.some(appHasApi);
     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'));
+    if (!shellOnly) {
+        writeFileReplacing(targetDir, "scripts/materialize-zerops-runtime.mjs", createZeropsRuntimeMaterializationScript());
+        writeWorkspaceOwnedMtsScript(targetDir, 'proof-workerd-ssr', createWorkerdSsrProofScript());
+    }
     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, {
+        shellOnly,
+        hasBackendSurface
+    });
+    writeWorkspaceOwnedMtsScript(targetDir, 'validate-ultramodern-workspace', createWorkspaceValidationScript(scope, enableTailwind, remotes, releaseCohort, additionalShells, primaryShell));
     writeWorkspaceOwnedMtsScript(targetDir, 'bootstrap-agent-skills', createSkillsToolWrapperScript());
     migrateCopiedWorkspaceScriptToMts(targetDir, 'setup-agent-reference-repos');
 }
-export { createPerformanceReadinessConfigScript, createWorkspaceApiBoundaryValidationScript, createWorkspaceI18nBoundaryValidationScript, createWorkspaceValidationScript, writeGeneratedWorkspaceScripts };
+function createAgentReferenceReposSetupScript() {
+    return node_fs.readFileSync(node_path.join(workspaceTemplateDir, "scripts/setup-agent-reference-repos.mjs"), 'utf-8');
+}
+const BACKEND_FEDERATION_WRAPPER_IDS = new Set([
+    'backendFederationGenerate',
+    'backendFederationProof'
+]);
+function migratedWorkspaceScriptArtifacts(options) {
+    const artifacts = [
+        {
+            relativePath: "scripts/check-ultramodern-i18n-boundaries.mts",
+            content: createWorkspaceI18nBoundaryValidationScript(),
+            legacyPath: "scripts/check-ultramodern-i18n-boundaries.mjs"
+        },
+        {
+            relativePath: "scripts/check-ultramodern-api-boundaries.mts",
+            content: createWorkspaceApiBoundaryValidationScript(),
+            legacyPath: "scripts/check-ultramodern-api-boundaries.mjs"
+        },
+        {
+            relativePath: "scripts/ultramodern-performance-readiness.config.mjs",
+            content: createPerformanceReadinessConfigScript()
+        },
+        {
+            relativePath: "scripts/bootstrap-agent-skills.mts",
+            content: createSkillsToolWrapperScript(),
+            legacyPath: "scripts/bootstrap-agent-skills.mjs"
+        },
+        {
+            relativePath: "scripts/setup-agent-reference-repos.mts",
+            content: createAgentReferenceReposSetupScript(),
+            legacyPath: "scripts/setup-agent-reference-repos.mjs"
+        }
+    ];
+    if (!options.shellOnly) artifacts.push({
+        relativePath: "scripts/proof-workerd-ssr.mts",
+        content: createWorkerdSsrProofScript(),
+        legacyPath: "scripts/proof-workerd-ssr.mjs"
+    });
+    const backendSurface = options.hasBackendSurface ?? !options.shellOnly;
+    for (const command of generatedToolingCommands)if (!(!backendSurface && BACKEND_FEDERATION_WRAPPER_IDS.has(command.id))) artifacts.push({
+        relativePath: command.wrapperPath,
+        content: createToolWrapperScript(command.command),
+        legacyPath: command.wrapperPath.replace(/\.mts$/u, '.mjs')
+    });
+    return artifacts;
+}
+const migratedWorkspaceScriptBasenames = [
+    'check-ultramodern-i18n-boundaries',
+    'check-ultramodern-api-boundaries',
+    'bootstrap-agent-skills',
+    'setup-agent-reference-repos',
+    'proof-workerd-ssr',
+    ...generatedToolingCommands.map((command)=>command.wrapperName)
+];
+export { createWorkspaceValidationScript, createZeropsRuntimeMaterializationScript, migratedWorkspaceScriptArtifacts, migratedWorkspaceScriptBasenames, writeGeneratedWorkspaceScripts };