@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/cjs/ultramodern-workspace/workspace-artifact-ownership.cjs

@@ -0,0 +1,183 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    preserveConsumerWorkspaceArtifacts: ()=>preserveConsumerWorkspaceArtifacts,
+    workspaceArtifactCandidates: ()=>workspaceArtifactCandidates,
+    workspaceDevelopmentPorts: ()=>workspaceDevelopmentPorts
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const parser_namespaceObject = require("@babel/parser");
+const workspace_state_cjs_namespaceObject = require("./add-vertical/workspace-state.cjs");
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_fs_io_cjs_namespaceObject = require("./fs-io.cjs");
+const external_module_federation_cjs_namespaceObject = require("./module-federation.cjs");
+const external_tsconfigs_cjs_namespaceObject = require("./tsconfigs.cjs");
+const external_workspace_scripts_cjs_namespaceObject = require("./workspace-scripts.cjs");
+const external_zerops_cjs_namespaceObject = require("./zerops.cjs");
+function workspaceArtifactCandidates(scope, apps, enableTailwind, alternateApps = []) {
+    return [
+        ...(0, external_workspace_scripts_cjs_namespaceObject.createWorkspaceScriptArtifacts)(),
+        {
+            relativePath: 'tsconfig.json',
+            content: `${JSON.stringify((0, external_tsconfigs_cjs_namespaceObject.createRootTsConfig)(apps), null, 2)}\n`
+        },
+        ...[
+            apps,
+            ...alternateApps.length ? [
+                alternateApps
+            ] : []
+        ].flatMap((projection)=>{
+            const verticals = projection.filter((app)=>'vertical' === app.kind);
+            const devPorts = workspaceDevelopmentPorts(projection);
+            return [
+                {
+                    relativePath: 'zerops.yaml',
+                    content: `${(0, external_zerops_cjs_namespaceObject.createZeropsYaml)(scope, projection)}\n`
+                },
+                ...projection.map((app)=>({
+                        relativePath: `${app.directory}/modern.config.ts`,
+                        content: (0, external_module_federation_cjs_namespaceObject.createAppModernConfig)(scope, app, 'shell' === app.kind ? (0, external_descriptors_cjs_namespaceObject.resolveRemoteRefs)(app, verticals) : verticals, enableTailwind, devPorts)
+                    }))
+            ];
+        })
+    ];
+}
+function workspaceDevelopmentPorts(apps, ports = {}) {
+    return apps.filter((app)=>'shell' === app.kind).length > 1 ? (0, workspace_state_cjs_namespaceObject.configuredDevelopmentPorts)({
+        ...ports,
+        ...Object.fromEntries(apps.map((app)=>[
+                app.id,
+                app.port
+            ]))
+    }).toSorted((left, right)=>left - right) : void 0;
+}
+function isLiteralData(node, literalIdentifiers) {
+    if (!node) return false;
+    if ('Identifier' === node.type) return literalIdentifiers?.has(node.name) ?? false;
+    if ([
+        'StringLiteral',
+        'NumericLiteral',
+        'BooleanLiteral',
+        'NullLiteral'
+    ].includes(node.type)) return true;
+    if ('UnaryExpression' === node.type) return '-' === node.operator && 'NumericLiteral' === node.argument.type;
+    if ('ArrayExpression' === node.type) return node.elements.every((element)=>isLiteralData(element, literalIdentifiers));
+    return 'ObjectExpression' === node.type && node.properties.every((property)=>'ObjectProperty' === property.type && !property.computed && !property.shorthand && [
+            'Identifier',
+            'StringLiteral',
+            'NumericLiteral'
+        ].includes(property.key.type) && isLiteralData(property.value, literalIdentifiers));
+}
+function withoutGeneratedData(source, binding) {
+    if (!binding) return source;
+    const parsed = (0, parser_namespaceObject.parse)(source, {
+        sourceType: 'module',
+        plugins: [
+            "typescript"
+        ]
+    });
+    for (const statement of parsed.program.body)if ('VariableDeclaration' === statement.type && 'const' === statement.kind) {
+        for (const declaration of statement.declarations)if ('Identifier' === declaration.id.type && declaration.id.name === binding && declaration.init && isLiteralData(declaration.init)) return source.slice(0, declaration.init.start) + '{}' + source.slice(declaration.init.end);
+    }
+    return source;
+}
+function preserveConsumerWorkspaceArtifacts(workspaceRoot, candidates) {
+    const preservedPaths = new Set();
+    const recognizedPaths = new Map();
+    const physicalRoot = external_node_fs_default().realpathSync(workspaceRoot);
+    const canonicalSources = (0, external_fs_io_cjs_namespaceObject.formatGeneratedSourceCandidates)(candidates.map((candidate, index)=>[
+            `canonical/${index}/${candidate.relativePath}`,
+            withoutGeneratedData(candidate.content, candidate.generatedDataBinding)
+        ]));
+    for (const [index, candidate] of candidates.entries()){
+        const relativePath = candidate.relativePath;
+        const filePath = external_node_path_default().join(workspaceRoot, relativePath);
+        if (!external_node_fs_default().existsSync(filePath)) continue;
+        const physicalRelative = external_node_path_default().relative(physicalRoot, external_node_fs_default().realpathSync(filePath));
+        if ('..' === physicalRelative || physicalRelative.startsWith(`..${external_node_path_default().sep}`) || external_node_path_default().isAbsolute(physicalRelative)) throw new Error(`Refusing to inspect an artifact outside the workspace: ${relativePath}`);
+        const source = external_node_fs_default().readFileSync(filePath, 'utf8');
+        let recognized = source === candidate.content;
+        if (!recognized) try {
+            const normalized = withoutGeneratedData(source, candidate.generatedDataBinding);
+            const canonical = canonicalSources[index];
+            recognized = normalized === canonical || (0, external_fs_io_cjs_namespaceObject.formatGeneratedSourceCandidates)([
+                [
+                    relativePath,
+                    normalized
+                ]
+            ])[0] === canonical;
+        } catch  {}
+        recognizedPaths.set(relativePath, true === recognizedPaths.get(relativePath) || recognized);
+    }
+    for (const [relativePath, recognized] of recognizedPaths)if (!recognized) preservedPaths.add(relativePath);
+    const reported = new Set();
+    const isPreserved = (filePath)=>{
+        const relativePath = external_node_path_default().relative(workspaceRoot, filePath).split(external_node_path_default().sep).join('/');
+        if (!preservedPaths.has(relativePath)) return false;
+        if (!reported.has(relativePath)) {
+            console.warn(`${relativePath} preserved consumer-owned artifact: its canonical generated source does not match.`);
+            reported.add(relativePath);
+        }
+        return true;
+    };
+    return {
+        preservedPaths,
+        io: {
+            write: (filePath, content)=>{
+                if (isPreserved(filePath)) return false;
+                (0, external_fs_io_cjs_namespaceObject.writeFileReplacing)(workspaceRoot, external_node_path_default().relative(workspaceRoot, filePath), content);
+                return true;
+            }
+        }
+    };
+}
+exports.preserveConsumerWorkspaceArtifacts = __webpack_exports__.preserveConsumerWorkspaceArtifacts;
+exports.workspaceArtifactCandidates = __webpack_exports__.workspaceArtifactCandidates;
+exports.workspaceDevelopmentPorts = __webpack_exports__.workspaceDevelopmentPorts;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "preserveConsumerWorkspaceArtifacts",
+    "workspaceArtifactCandidates",
+    "workspaceDevelopmentPorts"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/workspace-script-plan.cjs

@@ -29,6 +29,7 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     GENERATED_POSTINSTALL_SCRIPT: ()=>GENERATED_POSTINSTALL_SCRIPT,
+    WORKSPACE_SCRIPT_SEGMENT_PATTERN: ()=>WORKSPACE_SCRIPT_SEGMENT_PATTERN,
     createStrictTsgoTypecheckCommand: ()=>createStrictTsgoTypecheckCommand,
     createWorkspaceAppPackageScripts: ()=>createWorkspaceAppPackageScripts,
     createWorkspaceRootPackageScripts: ()=>createWorkspaceRootPackageScripts,
@@ -38,29 +39,28 @@ const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
 const external_naming_cjs_namespaceObject = require("./naming.cjs");
 const external_public_surface_cjs_namespaceObject = require("./public-surface.cjs");
 const external_tooling_command_catalog_cjs_namespaceObject = require("./tooling-command-catalog.cjs");
-const GENERATED_POSTINSTALL_SCRIPT = "node ./scripts/bootstrap-agent-skills.mts --postinstall && oxfmt .";
-const toolingWrapperPath = (key)=>external_tooling_command_catalog_cjs_namespaceObject.GENERATED_TOOLING_COMMANDS[key].wrapperPath;
+const GENERATED_POSTINSTALL_SCRIPT = 'ultramodern-create ultramodern skills install --postinstall';
+const WORKSPACE_SCRIPT_SEGMENT_PATTERN = /(?:'[^']*'|"(?:\\[^\r\n]|[^"\\`$]|\$(?![(']))*"|\\[^\r\n]|[^"'\\`&|;()<>\r\n^#$]|\$(?![('"]))+/gu;
+const toolingCommand = (key)=>`ultramodern-create ultramodern ${external_tooling_command_catalog_cjs_namespaceObject.GENERATED_TOOLING_COMMANDS[key].command}`;
 const rootToolingScriptName = (key)=>{
     const rootScript = external_tooling_command_catalog_cjs_namespaceObject.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)=>`${(0, external_naming_cjs_namespaceObject.relativeRootFor)(packageDir)}/${toolingWrapperPath(key)}`;
-const packageToolingWrapperCommand = (packageDir, key)=>`node ${relativeToolingWrapperPath(packageDir, key)}`;
+const rootToolingWrapperCommand = toolingCommand;
+const packageToolingWrapperCommand = (_packageDir, key)=>toolingCommand(key);
 const workspaceRootPackageScriptNames = {
     build: 'build',
     cloudflareBuild: 'cloudflare:build',
     cloudflareDeploy: 'cloudflare:deploy',
     cloudflareProof: rootToolingScriptName('cloudflareProof'),
-    cloudflareSsrProof: 'cloudflare:ssr-proof',
+    cloudflareSsrProof: rootToolingScriptName('cloudflareSsrProof'),
     cloudflareOutputVerify: rootToolingScriptName('cloudflareOutputVerify'),
     backendFederationGenerate: rootToolingScriptName('backendFederationGenerate'),
     nodeProof: rootToolingScriptName('backendFederationProof'),
     mfTypes: rootToolingScriptName('mfTypes'),
     performanceReadiness: rootToolingScriptName('performanceReadiness'),
-    migrateStrictEffect: rootToolingScriptName('migrateStrictEffect'),
-    zeropsMaterialize: 'zerops:materialize',
+    zeropsMaterialize: rootToolingScriptName('zeropsMaterialize'),
     contractCheck: rootToolingScriptName('validate'),
     typecheck: 'typecheck',
     check: 'check'
@@ -84,23 +84,34 @@ const workspaceAppPackageScriptNames = {
     typecheck: 'typecheck'
 };
 const createStrictTsgoTypecheckCommand = (packageDir)=>`${packageToolingWrapperCommand(packageDir, 'typecheck')} --project tsconfig.json`;
+const createRoutesGenerateCommand = (app)=>(0, external_descriptors_cjs_namespaceObject.appEmitsBrowserUi)(app) ? `pnpm --dir ${(0, external_naming_cjs_namespaceObject.relativeRootFor)(app.directory)} exec ${toolingCommand('routesGenerate')} --app ${app.id} --manifest-only` : void 0;
 function createWorkspaceAppScriptPlan(app) {
+    const routesGenerate = createRoutesGenerateCommand(app);
     const buildSteps = [
-        'modern build',
+        routesGenerate,
+        'modern build --deploy-target node',
         (0, external_public_surface_cjs_namespaceObject.createPublicSurfaceGenerationCommand)(app, 'dist'),
-        'cross-env MODERNJS_DEPLOY=node modern deploy --skip-build'
-    ].filter((step)=>Boolean(step));
-    const cloudflareBuildSteps = [
-        'cross-env MODERNJS_DEPLOY=cloudflare modern build',
-        (0, external_public_surface_cjs_namespaceObject.createPublicSurfaceGenerationCommand)(app, 'cloudflare-dist'),
-        'cross-env MODERNJS_DEPLOY=cloudflare modern deploy --skip-build',
-        `${packageToolingWrapperCommand(app.directory, 'cloudflareOutputVerify')} --app ${app.id}`
+        'modern deploy --skip-build --deploy-target node'
     ].filter((step)=>Boolean(step));
+    const cloudflareOutputVerify = `${packageToolingWrapperCommand(app.directory, 'cloudflareOutputVerify')} --app ${app.id}`;
+    const cloudflareBuildSteps = (requirePublicUrls)=>[
+            routesGenerate,
+            'modern build --deploy-target cloudflare',
+            (0, external_public_surface_cjs_namespaceObject.createPublicSurfaceGenerationCommand)(app, 'cloudflare-dist', requirePublicUrls),
+            'modern deploy --skip-build --deploy-target cloudflare',
+            requirePublicUrls ? `${cloudflareOutputVerify} --require-public-urls` : cloudflareOutputVerify
+        ].filter((step)=>Boolean(step));
     return {
-        dev: 'modern dev',
+        dev: [
+            routesGenerate,
+            'modern dev'
+        ].filter((step)=>Boolean(step)).join(' && '),
         build: buildSteps.join(' && '),
-        cloudflareBuild: cloudflareBuildSteps.join(' && '),
-        cloudflareDeploy: 'cross-env ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS=true pnpm run cloudflare:build && wrangler deploy --config .output/wrangler.json',
+        cloudflareBuild: cloudflareBuildSteps(false).join(' && '),
+        cloudflareDeploy: [
+            ...cloudflareBuildSteps(true),
+            'wrangler deploy --config .output/wrangler.json'
+        ].join(' && '),
         cloudflarePreview: 'pnpm run cloudflare:build && wrangler dev --config .output/wrangler.json',
         cloudflareProof: `${packageToolingWrapperCommand(app.directory, 'cloudflareProof')} --app ${app.id}`,
         serve: 'modern serve',
@@ -139,7 +150,6 @@ function createReferencedRemoteDeclarationBuilds(remotes) {
 }
 function createWorkspaceRootScriptPlan(remotes = [], options = {}) {
     const hasRemotes = remotes.length > 0;
-    remotes.some(external_descriptors_cjs_namespaceObject.appHasApi);
     const shells = options.shells && options.shells.length > 0 ? options.shells : [
         external_descriptors_cjs_namespaceObject.shellApp
     ];
@@ -166,17 +176,16 @@ function createWorkspaceRootScriptPlan(remotes = [], options = {}) {
         cloudflareBuild: `${buildPrefix}${remoteCloudflareBuildPrefix}${shellCloudflareBuild} && pnpm ${mfTypesScript} --target cloudflare && pnpm ${cloudflareOutputVerifyScript}${cloudflareSsrProofSuffix}`,
         cloudflareDeploy: `${remoteCloudflareDeployPrefix}${shellCloudflareDeploy}`,
         cloudflareProof: `${rootToolingWrapperCommand('cloudflareProof')} --out .codex/reports/cloudflare-version-proof/public-url-proof.json`,
-        cloudflareSsrProof: "node ./scripts/proof-workerd-ssr.mts",
+        cloudflareSsrProof: rootToolingWrapperCommand('cloudflareSsrProof'),
         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",
+        zeropsMaterialize: rootToolingWrapperCommand('zeropsMaterialize'),
         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}`
+        typecheck: options.typecheck ?? `${rootToolingWrapperCommand('typecheck')} --build tsconfig.json`,
+        check: `pnpm format:check && pnpm lint && pnpm typecheck && pnpm skills:check && pnpm i18n:boundaries && pnpm api:check:files && pnpm contract:check && pnpm performance:readiness${bridgeCheck}`
     };
 }
 function createWorkspaceRootPackageScripts(remotes = [], options = {}) {
@@ -189,12 +198,14 @@ function createWorkspaceRootPackageScripts(remotes = [], options = {}) {
         ]));
 }
 exports.GENERATED_POSTINSTALL_SCRIPT = __webpack_exports__.GENERATED_POSTINSTALL_SCRIPT;
+exports.WORKSPACE_SCRIPT_SEGMENT_PATTERN = __webpack_exports__.WORKSPACE_SCRIPT_SEGMENT_PATTERN;
 exports.createStrictTsgoTypecheckCommand = __webpack_exports__.createStrictTsgoTypecheckCommand;
 exports.createWorkspaceAppPackageScripts = __webpack_exports__.createWorkspaceAppPackageScripts;
 exports.createWorkspaceRootPackageScripts = __webpack_exports__.createWorkspaceRootPackageScripts;
 exports.createWorkspaceRootScriptPlan = __webpack_exports__.createWorkspaceRootScriptPlan;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "GENERATED_POSTINSTALL_SCRIPT",
+    "WORKSPACE_SCRIPT_SEGMENT_PATTERN",
     "createStrictTsgoTypecheckCommand",
     "createWorkspaceAppPackageScripts",
     "createWorkspaceRootPackageScripts",

package/dist/cjs/ultramodern-workspace/workspace-scripts.cjs

@@ -37,223 +37,34 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createWorkspaceValidationScript: ()=>createWorkspaceValidationScript,
-    createZeropsRuntimeMaterializationScript: ()=>createZeropsRuntimeMaterializationScript,
-    migratedWorkspaceScriptArtifacts: ()=>migratedWorkspaceScriptArtifacts,
-    migratedWorkspaceScriptBasenames: ()=>migratedWorkspaceScriptBasenames,
+    createWorkspaceScriptArtifacts: ()=>createWorkspaceScriptArtifacts,
     writeGeneratedWorkspaceScripts: ()=>writeGeneratedWorkspaceScripts
 });
 const external_node_fs_namespaceObject = require("node:fs");
 var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
 const external_fs_io_cjs_namespaceObject = require("./fs-io.cjs");
-const external_tooling_command_catalog_cjs_namespaceObject = require("./tooling-command-catalog.cjs");
-const external_workspace_validation_contract_cjs_namespaceObject = require("./workspace-validation-contract.cjs");
-const singleQuoted = (value)=>`'${value.replace(/'/gu, "\\'")}'`;
-const toolWrapperResultHandling = `
-if (result.error) {
-  const launchTarget = createBin
-    ? process.execPath + ' with ULTRAMODERN_CREATE_BIN=' + createBin
-    : 'ultramodern-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 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';
-import { fileURLToPath } from 'node:url';
-
-const createBin = process.env.ULTRAMODERN_CREATE_BIN;
-const forwardedArgs = process.argv.slice(2);
-const workspaceRoot =
-  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
-  path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const ultramodernArgs = ['ultramodern', ${commandLiteral}, ...${extraArgsLiteral}, ...forwardedArgs];
-const result = createBin
-  ? spawnSync(process.execPath, [createBin, ...ultramodernArgs], {
-      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
-      stdio: 'inherit',
-    })
-  : spawnSync('ultramodern-create', ultramodernArgs, {
-      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
-      shell: process.platform === 'win32',
-      stdio: 'inherit',
-    });
-${toolWrapperResultHandling}`;
-}
-function writeGeneratedToolWrapperScript(targetDir, key) {
-    const command = external_tooling_command_catalog_cjs_namespaceObject.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 external_tooling_command_catalog_cjs_namespaceObject.generatedToolingCommands)if (!(!backendSurface && BACKEND_FEDERATION_WRAPPER_IDS.has(command.id))) writeGeneratedToolWrapperScript(targetDir, command.id);
-}
-function createSkillsToolWrapperScript() {
-    return `#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const createBin = process.env.ULTRAMODERN_CREATE_BIN;
-const forwardedArgs = process.argv.slice(2);
-const workspaceRoot =
-  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
-  path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const checkOnly = forwardedArgs.includes('--check');
-const skillArgs = checkOnly
-  ? ['skills', 'check', ...forwardedArgs.filter(arg => arg !== '--check')]
-  : ['skills', 'install', ...forwardedArgs];
-const ultramodernArgs = ['ultramodern', ...skillArgs];
-const result = createBin
-  ? spawnSync(process.execPath, [createBin, ...ultramodernArgs], {
-      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
-      stdio: 'inherit',
-    })
-  : spawnSync('ultramodern-create', ultramodernArgs, {
-      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
-      shell: process.platform === 'win32',
-      stdio: 'inherit',
-    });
-${toolWrapperResultHandling}`;
-}
-function removeLegacyWorkspaceScript(targetDir, relativePath) {
-    external_node_fs_default().rmSync(external_node_path_default().join(targetDir, relativePath), {
-        force: true
-    });
-}
-function writeWorkspaceOwnedMtsScript(targetDir, name, content) {
-    (0, external_fs_io_cjs_namespaceObject.writeFileReplacing)(targetDir, `scripts/${name}.mts`, content);
-    removeLegacyWorkspaceScript(targetDir, `scripts/${name}.mjs`);
-}
-function migrateCopiedWorkspaceScriptToMts(targetDir, name) {
-    const legacyPath = external_node_path_default().join(targetDir, `scripts/${name}.mjs`);
-    const migratedPath = external_node_path_default().join(targetDir, `scripts/${name}.mts`);
-    if (!external_node_fs_default().existsSync(legacyPath)) return;
-    if (external_node_fs_default().existsSync(migratedPath)) return void external_node_fs_default().rmSync(legacyPath, {
-        force: true
-    });
-    external_node_fs_default().renameSync(legacyPath, migratedPath);
-}
-function createWorkspaceValidationScript(scope, enableTailwind, remotes = [], releaseCohort, additionalShells = [], primaryShell, compactConfigOverride, ownershipOverride, developmentOverlayOverride) {
-    const contract = (0, external_workspace_validation_contract_cjs_namespaceObject.createWorkspaceValidationContract)(scope, enableTailwind, remotes, releaseCohort, additionalShells, primaryShell, compactConfigOverride, ownershipOverride, developmentOverlayOverride);
-    return (0, external_fs_io_cjs_namespaceObject.renderFileTemplate)("workspace-scripts/validate-ultramodern-workspace.mjs", {
-        workspaceValidationContractJson: JSON.stringify(contract, null, 2)
-    });
-}
-function createWorkspaceI18nBoundaryValidationScript() {
-    return (0, external_fs_io_cjs_namespaceObject.readFileTemplate)("workspace-scripts/check-ultramodern-i18n-boundaries.mts");
-}
-function createWorkspaceApiBoundaryValidationScript() {
-    return (0, external_fs_io_cjs_namespaceObject.readFileTemplate)("workspace-scripts/check-ultramodern-api-boundaries.mts");
-}
-function createPerformanceReadinessConfigScript() {
-    return (0, external_fs_io_cjs_namespaceObject.readFileTemplate)("workspace-scripts/ultramodern-performance-readiness.config.mjs");
-}
-function createWorkerdSsrProofScript() {
-    return (0, external_fs_io_cjs_namespaceObject.readFileTemplate)("workspace-scripts/proof-workerd-ssr.mts");
-}
-function createZeropsRuntimeMaterializationScript() {
-    return (0, external_fs_io_cjs_namespaceObject.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(external_descriptors_cjs_namespaceObject.appHasApi);
-    writeWorkspaceOwnedMtsScript(targetDir, 'check-ultramodern-i18n-boundaries', createWorkspaceI18nBoundaryValidationScript());
-    writeWorkspaceOwnedMtsScript(targetDir, 'check-ultramodern-api-boundaries', createWorkspaceApiBoundaryValidationScript());
-    if (!shellOnly) {
-        (0, external_fs_io_cjs_namespaceObject.writeFileReplacing)(targetDir, "scripts/materialize-zerops-runtime.mjs", createZeropsRuntimeMaterializationScript());
-        writeWorkspaceOwnedMtsScript(targetDir, 'proof-workerd-ssr', createWorkerdSsrProofScript());
-    }
-    (0, external_fs_io_cjs_namespaceObject.writeFileReplacing)(targetDir, "scripts/ultramodern-performance-readiness.config.mjs", createPerformanceReadinessConfigScript());
-    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');
-}
-function createAgentReferenceReposSetupScript() {
-    return external_node_fs_default().readFileSync(external_node_path_default().join(external_fs_io_cjs_namespaceObject.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"
-        },
+function createWorkspaceScriptArtifacts() {
+    return [
         {
             relativePath: "scripts/ultramodern-performance-readiness.config.mjs",
-            content: createPerformanceReadinessConfigScript()
-        },
-        {
-            relativePath: "scripts/bootstrap-agent-skills.mts",
-            content: createSkillsToolWrapperScript(),
-            legacyPath: "scripts/bootstrap-agent-skills.mjs"
+            content: (0, external_fs_io_cjs_namespaceObject.readFileTemplate)("workspace-scripts/ultramodern-performance-readiness.config.mjs")
         },
         {
             relativePath: "scripts/setup-agent-reference-repos.mts",
-            content: createAgentReferenceReposSetupScript(),
-            legacyPath: "scripts/setup-agent-reference-repos.mjs"
+            content: external_node_fs_default().readFileSync(external_node_path_default().join(external_fs_io_cjs_namespaceObject.workspaceTemplateDir, "scripts/setup-agent-reference-repos.mjs"), 'utf8')
         }
     ];
-    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 external_tooling_command_catalog_cjs_namespaceObject.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',
-    ...external_tooling_command_catalog_cjs_namespaceObject.generatedToolingCommands.map((command)=>command.wrapperName)
-];
-exports.createWorkspaceValidationScript = __webpack_exports__.createWorkspaceValidationScript;
-exports.createZeropsRuntimeMaterializationScript = __webpack_exports__.createZeropsRuntimeMaterializationScript;
-exports.migratedWorkspaceScriptArtifacts = __webpack_exports__.migratedWorkspaceScriptArtifacts;
-exports.migratedWorkspaceScriptBasenames = __webpack_exports__.migratedWorkspaceScriptBasenames;
+function writeGeneratedWorkspaceScripts(targetDir, options = {}) {
+    for (const artifact of createWorkspaceScriptArtifacts())if (options.io) options.io.writeGenerated(external_node_path_default().join(targetDir, artifact.relativePath), artifact.content);
+    else (0, external_fs_io_cjs_namespaceObject.writeFileReplacing)(targetDir, artifact.relativePath, artifact.content);
+}
+exports.createWorkspaceScriptArtifacts = __webpack_exports__.createWorkspaceScriptArtifacts;
 exports.writeGeneratedWorkspaceScripts = __webpack_exports__.writeGeneratedWorkspaceScripts;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createWorkspaceValidationScript",
-    "createZeropsRuntimeMaterializationScript",
-    "migratedWorkspaceScriptArtifacts",
-    "migratedWorkspaceScriptBasenames",
+    "createWorkspaceScriptArtifacts",
     "writeGeneratedWorkspaceScripts"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {