@bleedingdev/modern-js-create 3.5.0-ultramodern.4 → 3.5.0-ultramodern.41

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    ensureGeneratedOxfmtIgnorePatterns: ()=>external_generated_artifacts_oxfmt_cjs_namespaceObject.ensureGeneratedOxfmtIgnorePatterns,
+    removeGeneratedFileIfExists: ()=>external_generated_artifacts_removal_cjs_namespaceObject.removeGeneratedFileIfExists,
+    removeStaleBackendFederationArtifacts: ()=>external_generated_artifacts_removal_cjs_namespaceObject.removeStaleBackendFederationArtifacts,
+    updateGeneratedBackendFederationContractFiles: ()=>external_generated_artifacts_backend_federation_cjs_namespaceObject.updateGeneratedBackendFederationContractFiles,
+    updateGeneratedBuildIdentityModules: ()=>external_generated_artifacts_build_identity_cjs_namespaceObject.updateGeneratedBuildIdentityModules,
+    updateGeneratedModernConfigs: ()=>external_generated_artifacts_modern_configs_cjs_namespaceObject.updateGeneratedModernConfigs,
+    updateGeneratedTypeScriptSurfaces: ()=>external_generated_artifacts_typescript_cjs_namespaceObject.updateGeneratedTypeScriptSurfaces,
+    updateGeneratedZeropsArtifacts: ()=>external_generated_artifacts_zerops_cjs_namespaceObject.updateGeneratedZeropsArtifacts
+});
+const external_generated_artifacts_backend_federation_cjs_namespaceObject = require("./generated-artifacts-backend-federation.cjs");
+const external_generated_artifacts_build_identity_cjs_namespaceObject = require("./generated-artifacts-build-identity.cjs");
+const external_generated_artifacts_modern_configs_cjs_namespaceObject = require("./generated-artifacts-modern-configs.cjs");
+const external_generated_artifacts_oxfmt_cjs_namespaceObject = require("./generated-artifacts-oxfmt.cjs");
+const external_generated_artifacts_removal_cjs_namespaceObject = require("./generated-artifacts-removal.cjs");
+const external_generated_artifacts_typescript_cjs_namespaceObject = require("./generated-artifacts-typescript.cjs");
+const external_generated_artifacts_zerops_cjs_namespaceObject = require("./generated-artifacts-zerops.cjs");
+exports.ensureGeneratedOxfmtIgnorePatterns = __webpack_exports__.ensureGeneratedOxfmtIgnorePatterns;
+exports.removeGeneratedFileIfExists = __webpack_exports__.removeGeneratedFileIfExists;
+exports.removeStaleBackendFederationArtifacts = __webpack_exports__.removeStaleBackendFederationArtifacts;
+exports.updateGeneratedBackendFederationContractFiles = __webpack_exports__.updateGeneratedBackendFederationContractFiles;
+exports.updateGeneratedBuildIdentityModules = __webpack_exports__.updateGeneratedBuildIdentityModules;
+exports.updateGeneratedModernConfigs = __webpack_exports__.updateGeneratedModernConfigs;
+exports.updateGeneratedTypeScriptSurfaces = __webpack_exports__.updateGeneratedTypeScriptSurfaces;
+exports.updateGeneratedZeropsArtifacts = __webpack_exports__.updateGeneratedZeropsArtifacts;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ensureGeneratedOxfmtIgnorePatterns",
+    "removeGeneratedFileIfExists",
+    "removeStaleBackendFederationArtifacts",
+    "updateGeneratedBackendFederationContractFiles",
+    "updateGeneratedBuildIdentityModules",
+    "updateGeneratedModernConfigs",
+    "updateGeneratedTypeScriptSurfaces",
+    "updateGeneratedZeropsArtifacts"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/generated-patches.cjs

@@ -0,0 +1,67 @@
+"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__, {
+    ensureGeneratedPatchFile: ()=>ensureGeneratedPatchFile,
+    removeGeneratedPatchFileIfUnchanged: ()=>removeGeneratedPatchFileIfUnchanged
+});
+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);
+function ensureGeneratedPatchFile(io, relativePatchPath, sourcePatchPath) {
+    const targetPath = external_node_path_default().join(io.workspaceRoot, relativePatchPath);
+    const patch = external_node_fs_default().readFileSync(sourcePatchPath, 'utf-8');
+    return io.write(targetPath, patch);
+}
+function removeGeneratedPatchFileIfUnchanged(io, relativePatchPath, sourcePatchPath) {
+    const targetPath = external_node_path_default().join(io.workspaceRoot, relativePatchPath);
+    if (!external_node_fs_default().existsSync(targetPath)) return false;
+    const patch = external_node_fs_default().readFileSync(sourcePatchPath, 'utf-8');
+    if (external_node_fs_default().readFileSync(targetPath, 'utf-8') !== patch) return false;
+    return io.remove(targetPath);
+}
+exports.ensureGeneratedPatchFile = __webpack_exports__.ensureGeneratedPatchFile;
+exports.removeGeneratedPatchFileIfUnchanged = __webpack_exports__.removeGeneratedPatchFileIfUnchanged;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ensureGeneratedPatchFile",
+    "removeGeneratedPatchFileIfUnchanged"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/help.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+const migrateStrictEffectHelp = `Usage:
+  modern-js-create ultramodern migrate-strict-effect --version <version> [--dry-run] [--skip-install]
+
+Updates generated UltraModern package-source metadata, Modern package aliases,
+framework-owned toolchain pins, direct Effect API topology metadata, strict
+Effect pnpm overrides/trust policy, framework-owned TypeScript config
+surfaces, and the pnpm lockfile. Source code still has to pass pnpm api:check
+and pnpm contract:check.
+
+When the compact config is absent but legacy UltraModern 3.2 metadata is
+present, the compact config is synthesized from it first. Shell-only
+workspaces skip the backend-federation and Zerops runtime stages. Pass
+--dry-run to print the planned filesystem changes without writing anything
+(implies --skip-install).
+`;
+__webpack_require__.d(__webpack_exports__, {}, {
+    migrateStrictEffectHelp: migrateStrictEffectHelp
+});
+exports.migrateStrictEffectHelp = __webpack_exports__.migrateStrictEffectHelp;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "migrateStrictEffectHelp"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/install.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    runPnpmLockfileRefresh: ()=>runPnpmLockfileRefresh
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+function runPnpmLockfileRefresh(context) {
+    const result = (0, external_node_child_process_namespaceObject.spawnSync)('pnpm', [
+        'install',
+        '--lockfile-only',
+        "--ignore-scripts"
+    ], {
+        cwd: context.workspaceRoot,
+        stdio: 'inherit'
+    });
+    if (result.error) throw result.error;
+    return result.status ?? 1;
+}
+exports.runPnpmLockfileRefresh = __webpack_exports__.runPnpmLockfileRefresh;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runPnpmLockfileRefresh"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/io.cjs

@@ -0,0 +1,133 @@
+"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__, {
+    createMigrationIo: ()=>createMigrationIo,
+    listWorkspacePackageFiles: ()=>listWorkspacePackageFiles,
+    readJsonFile: ()=>readJsonFile,
+    writeJsonFile: ()=>writeJsonFile,
+    writeJsonIfChanged: ()=>writeJsonIfChanged,
+    writeTextIfChanged: ()=>writeTextIfChanged
+});
+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);
+function createMigrationIo(workspaceRoot, dryRun) {
+    const plan = [];
+    const rel = (p)=>(external_node_path_default().relative(workspaceRoot, p) || external_node_path_default().basename(p)).split(external_node_path_default().sep).join('/');
+    return {
+        workspaceRoot,
+        dryRun,
+        plan,
+        write (filePath, content) {
+            if (external_node_fs_default().existsSync(filePath) && external_node_fs_default().readFileSync(filePath, 'utf-8') === content) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would write ${rel(filePath)}`);
+                return true;
+            }
+            external_node_fs_default().mkdirSync(external_node_path_default().dirname(filePath), {
+                recursive: true
+            });
+            external_node_fs_default().writeFileSync(filePath, content, 'utf-8');
+            return true;
+        },
+        remove (filePath) {
+            if (!external_node_fs_default().existsSync(filePath)) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would delete ${rel(filePath)}`);
+                return true;
+            }
+            external_node_fs_default().rmSync(filePath);
+            return true;
+        },
+        log (message) {
+            if (dryRun) plan.push(`[dry-run] ${message}`);
+            else process.stdout.write(`[ultramodern] ${message}\n`);
+        }
+    };
+}
+function readJsonFile(filePath) {
+    return JSON.parse(external_node_fs_default().readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeJsonIfChanged(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeTextIfChanged(io, filePath, value) {
+    return io.write(filePath, value);
+}
+function listWorkspacePackageFiles(workspaceRoot) {
+    const packageFiles = [
+        'package.json'
+    ];
+    for (const directory of [
+        'apps',
+        'verticals',
+        'packages'
+    ]){
+        const absoluteDirectory = external_node_path_default().join(workspaceRoot, directory);
+        if (external_node_fs_default().existsSync(absoluteDirectory)) for (const entry of external_node_fs_default().readdirSync(absoluteDirectory, {
+            withFileTypes: true
+        })){
+            if (!entry.isDirectory()) continue;
+            const packageFile = `${directory}/${entry.name}/package.json`;
+            if (external_node_fs_default().existsSync(external_node_path_default().join(workspaceRoot, packageFile))) packageFiles.push(packageFile);
+        }
+    }
+    return packageFiles;
+}
+exports.createMigrationIo = __webpack_exports__.createMigrationIo;
+exports.listWorkspacePackageFiles = __webpack_exports__.listWorkspacePackageFiles;
+exports.readJsonFile = __webpack_exports__.readJsonFile;
+exports.writeJsonFile = __webpack_exports__.writeJsonFile;
+exports.writeJsonIfChanged = __webpack_exports__.writeJsonIfChanged;
+exports.writeTextIfChanged = __webpack_exports__.writeTextIfChanged;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createMigrationIo",
+    "listWorkspacePackageFiles",
+    "readJsonFile",
+    "writeJsonFile",
+    "writeJsonIfChanged",
+    "writeTextIfChanged"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/package-cohort.cjs

@@ -0,0 +1,245 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    updateGeneratedPackageScripts: ()=>updateGeneratedPackageScripts,
+    updateGeneratedToolingDependencies: ()=>updateGeneratedToolingDependencies,
+    updateModernDependencies: ()=>updateModernDependencies
+});
+const external_ultramodern_package_source_cjs_namespaceObject = require("../../../ultramodern-package-source.cjs");
+const versions_cjs_namespaceObject = require("../../../ultramodern-workspace/versions.cjs");
+const workspace_script_plan_cjs_namespaceObject = require("../../../ultramodern-workspace/workspace-script-plan.cjs");
+const workspace_scripts_cjs_namespaceObject = require("../../../ultramodern-workspace/workspace-scripts.cjs");
+const modernPackageNames = new Set([
+    ...external_ultramodern_package_source_cjs_namespaceObject.ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES,
+    ...external_ultramodern_package_source_cjs_namespaceObject.ULTRAMODERN_WORKSPACE_MODERN_PACKAGES
+]);
+function updateModernDependencies(packageJson, packageSource) {
+    let changed = false;
+    for (const section of [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies'
+    ]){
+        const dependencies = packageJson[section];
+        if (!(!dependencies || 'object' != typeof dependencies || Array.isArray(dependencies))) for (const packageName of Object.keys(dependencies)){
+            if (!modernPackageNames.has(packageName)) continue;
+            const nextSpecifier = (0, external_ultramodern_package_source_cjs_namespaceObject.modernPackageSpecifier)(packageName, packageSource);
+            if (dependencies[packageName] !== nextSpecifier) {
+                dependencies[packageName] = nextSpecifier;
+                changed = true;
+            }
+        }
+    }
+    return changed;
+}
+const generatedToolingDependencyPins = new Map([
+    [
+        '@effect/tsgo',
+        versions_cjs_namespaceObject.EFFECT_TSGO_VERSION
+    ],
+    [
+        '@module-federation/bridge-react',
+        versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION
+    ],
+    [
+        '@module-federation/modern-js-v3',
+        versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION
+    ],
+    [
+        '@module-federation/runtime',
+        versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION
+    ],
+    [
+        '@rsbuild/plugin-tailwindcss',
+        versions_cjs_namespaceObject.RSBUILD_PLUGIN_TAILWINDCSS_VERSION
+    ],
+    [
+        '@tanstack/react-router',
+        versions_cjs_namespaceObject.TANSTACK_ROUTER_VERSION
+    ],
+    [
+        "typescript",
+        versions_cjs_namespaceObject.TYPESCRIPT_VERSION
+    ],
+    [
+        'tailwindcss',
+        versions_cjs_namespaceObject.TAILWIND_VERSION
+    ],
+    [
+        'oxfmt',
+        versions_cjs_namespaceObject.OXFMT_VERSION
+    ],
+    [
+        'oxlint',
+        versions_cjs_namespaceObject.OXLINT_VERSION
+    ],
+    [
+        'wrangler',
+        versions_cjs_namespaceObject.WRANGLER_VERSION
+    ],
+    [
+        'zephyr-agent',
+        versions_cjs_namespaceObject.ZEPHYR_AGENT_VERSION
+    ],
+    [
+        'zephyr-rspack-plugin',
+        versions_cjs_namespaceObject.ZEPHYR_RSPACK_PLUGIN_VERSION
+    ]
+]);
+function updateGeneratedToolingDependencies(packageJson) {
+    let changed = false;
+    for (const section of [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies'
+    ]){
+        const dependencies = packageJson[section];
+        if (!(!dependencies || 'object' != typeof dependencies || Array.isArray(dependencies))) {
+            for (const [packageName, version] of generatedToolingDependencyPins)if (Object.prototype.hasOwnProperty.call(dependencies, packageName) && dependencies[packageName] !== version) {
+                dependencies[packageName] = version;
+                changed = true;
+            }
+        }
+    }
+    return changed;
+}
+const cloudflareModernDeployCommand = 'ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy';
+const cloudflareModernDeploySkipBuildCommand = `${cloudflareModernDeployCommand} --skip-build`;
+const cloudflareWranglerDeployCommand = 'wrangler deploy --config .output/wrangler.json';
+const cloudflareWranglerDeployInvalidSkipBuildCommand = `${cloudflareWranglerDeployCommand} --skip-build`;
+function removeStaleBackendFederationCommandSegments(command) {
+    return command.replace(/\s+&&\s+node\s+\S*scripts\/generate-node-backend-federation\.m[ct]s(?:\s+--app\s+\S+)?(?:\s+--target\s+\S+)?(?=\s+&&|$)/gu, '');
+}
+const SHELL_ONLY_OMITTED_ROOT_SCRIPTS = [
+    'node:backend-federation:generate',
+    'node:proof',
+    'zerops:materialize'
+];
+const splitScriptSegments = (command)=>command.split('&&').map((segment)=>segment.trim()).filter((segment)=>segment.length > 0);
+const scriptSegmentTarget = (segment)=>segment.replace(/^pnpm\s+/u, '').split(/\s+/u)[0] ?? segment;
+const FRAMEWORK_CHECK_TARGETS = new Set([
+    'format:check',
+    'lint',
+    'typecheck',
+    'skills:check',
+    'i18n:boundaries',
+    'api:check',
+    'contract:check',
+    'node:backend-federation:generate',
+    'node:proof',
+    'performance:readiness',
+    'bridge:check'
+]);
+function mergeAggregateCheckScript(consumer, framework) {
+    const frameworkSegments = splitScriptSegments(framework);
+    const consumerExtras = splitScriptSegments(consumer).filter((segment)=>!FRAMEWORK_CHECK_TARGETS.has(scriptSegmentTarget(segment)));
+    return [
+        ...consumerExtras,
+        ...frameworkSegments
+    ].join(' && ');
+}
+function rewriteMigratedScriptReferences(scripts) {
+    let changed = false;
+    const pattern = new RegExp(`(scripts/(?:${workspace_scripts_cjs_namespaceObject.migratedWorkspaceScriptBasenames.join('|')}))\\.mjs`, 'gu');
+    for (const [name, value] of Object.entries(scripts)){
+        if ('string' != typeof value) continue;
+        const next = value.replace(pattern, '$1.mts');
+        if (next !== value) {
+            scripts[name] = next;
+            changed = true;
+        }
+    }
+    return changed;
+}
+function updateGeneratedPackageScripts(packageJson, options = {}) {
+    const scripts = packageJson.scripts;
+    if (!scripts || 'object' != typeof scripts || Array.isArray(scripts)) return false;
+    let changed = false;
+    const apps = options.apps ?? [];
+    const shellOnly = options.shellOnly ?? false;
+    const app = apps.find((candidate)=>`${candidate.directory}/package.json` === options.relativePackageFile);
+    const isRootPackage = 'package.json' === options.relativePackageFile;
+    const expectedScripts = isRootPackage ? (0, workspace_script_plan_cjs_namespaceObject.createWorkspaceRootPackageScripts)(apps.filter((candidate)=>'shell' !== candidate.kind)) : app ? (0, workspace_script_plan_cjs_namespaceObject.createWorkspaceAppPackageScripts)(app) : void 0;
+    if (expectedScripts) for (const [name, value] of Object.entries(expectedScripts)){
+        if (isRootPackage && shellOnly && SHELL_ONLY_OMITTED_ROOT_SCRIPTS.includes(name)) {
+            if (name in scripts) {
+                delete scripts[name];
+                changed = true;
+            }
+            continue;
+        }
+        if (void 0 === value) continue;
+        const existingScript = scripts[name];
+        const nextValue = 'check' === name && 'string' == typeof existingScript ? mergeAggregateCheckScript(existingScript, value) : value;
+        if (scripts[name] !== nextValue) {
+            scripts[name] = nextValue;
+            changed = true;
+        }
+    }
+    if (rewriteMigratedScriptReferences(scripts)) changed = true;
+    const build = scripts.build;
+    if ('string' == typeof build) {
+        const nextBuild = removeStaleBackendFederationCommandSegments(build);
+        if (nextBuild !== build) {
+            scripts.build = nextBuild;
+            changed = true;
+        }
+    }
+    const cloudflareBuild = scripts['cloudflare:build'];
+    if ('string' == typeof cloudflareBuild) {
+        let nextCloudflareBuild = removeStaleBackendFederationCommandSegments(cloudflareBuild);
+        if (nextCloudflareBuild.includes(cloudflareModernDeployCommand) && !nextCloudflareBuild.includes(cloudflareModernDeploySkipBuildCommand)) nextCloudflareBuild = nextCloudflareBuild.replace(cloudflareModernDeployCommand, cloudflareModernDeploySkipBuildCommand);
+        nextCloudflareBuild = nextCloudflareBuild.replace(/ && node \S*scripts\/generate-public-surface-assets\.m[ct]s --app [^&]+ --target dist(?= && ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy --skip-build)/u, '');
+        nextCloudflareBuild = nextCloudflareBuild.replace(/ && node \S*scripts\/verify-cloudflare-output\.m[ct]s(?: --app [^&]+)?/u, '');
+        if (nextCloudflareBuild !== cloudflareBuild) {
+            scripts['cloudflare:build'] = nextCloudflareBuild;
+            changed = true;
+        }
+    }
+    const cloudflareDeploy = scripts['cloudflare:deploy'];
+    if ('string' == typeof cloudflareDeploy && cloudflareDeploy.includes(cloudflareWranglerDeployInvalidSkipBuildCommand)) {
+        scripts['cloudflare:deploy'] = cloudflareDeploy.replace(cloudflareWranglerDeployInvalidSkipBuildCommand, cloudflareWranglerDeployCommand);
+        changed = true;
+    }
+    return changed;
+}
+exports.updateGeneratedPackageScripts = __webpack_exports__.updateGeneratedPackageScripts;
+exports.updateGeneratedToolingDependencies = __webpack_exports__.updateGeneratedToolingDependencies;
+exports.updateModernDependencies = __webpack_exports__.updateModernDependencies;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "updateGeneratedPackageScripts",
+    "updateGeneratedToolingDependencies",
+    "updateModernDependencies"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});