@bleedingdev/modern-js-create 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

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

@@ -0,0 +1,161 @@
+"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__);
+function replaceYamlLine(source, pattern, replacement) {
+    const updated = source.replace(pattern, replacement);
+    return {
+        source: updated,
+        changed: updated !== source
+    };
+}
+function ensureYamlListItem(source, key, item) {
+    const itemLine = `  - '${item}'`;
+    const headerPattern = new RegExp(`^${key}:\\n(?:(?:  - .+\\n)*)`, 'mu');
+    const header = source.match(headerPattern);
+    if (header) {
+        if (header[0].split('\n').includes(itemLine)) return {
+            source,
+            changed: false
+        };
+        return {
+            source: source.replace(headerPattern, `${header[0]}${itemLine}\n`),
+            changed: true
+        };
+    }
+    const block = `${key}:\n${itemLine}\n`;
+    const afterTrustPolicyIgnore = source.replace(/^(trustPolicyIgnoreAfter: .+\n)/mu, `$1${block}`);
+    if (afterTrustPolicyIgnore !== source) return {
+        source: afterTrustPolicyIgnore,
+        changed: true
+    };
+    return {
+        source: `${source.trimEnd()}\n${block}`,
+        changed: true
+    };
+}
+function yamlEntryPattern(entryKey, scalar = false) {
+    const bareKey = entryKey.replace(/^['"]|['"]$/gu, '');
+    if (scalar) {
+        const esc = bareKey.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+        return new RegExp(`^ {2}(?:'${esc}'|"${esc}"|${esc}): .+$`, 'gmu');
+    }
+    const packageName = bareKey.includes('@') ? bareKey.slice(0, bareKey.lastIndexOf('@')) : bareKey;
+    const esc = packageName.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    return new RegExp(`^ {2}(?:'${esc}@[^']+'|"${esc}@[^"]+"|${esc}@[^:'"\\s]+): .+$`, 'gmu');
+}
+function upsertYamlEntry(source, key, entryLine, pattern) {
+    const linePattern = new RegExp(pattern.source, 'u');
+    const lines = source.split('\n');
+    let seen = false;
+    let changed = false;
+    const out = [];
+    for (const line of lines)if (linePattern.test(line)) {
+        if (seen) {
+            changed = true;
+            continue;
+        }
+        seen = true;
+        if (line !== entryLine) changed = true;
+        out.push(entryLine);
+    } else out.push(line);
+    if (seen) return {
+        source: out.join('\n'),
+        changed
+    };
+    const headerPattern = new RegExp(`^${key}:\\n(?:(?:  .+\\n)*)`, 'mu');
+    const header = source.match(headerPattern);
+    if (header) {
+        if (header[0].split('\n').includes(entryLine)) return {
+            source,
+            changed: false
+        };
+        return {
+            source: source.replace(headerPattern, `${header[0]}${entryLine}\n`),
+            changed: true
+        };
+    }
+    return {
+        source: `${source.trimEnd()}\n${key}:\n${entryLine}\n`,
+        changed: true
+    };
+}
+function ensureYamlMapEntry(source, key, entryKey, value) {
+    return upsertYamlEntry(source, key, `  '${entryKey}': ${value}`, yamlEntryPattern(entryKey));
+}
+function ensureYamlScalarMapEntry(source, key, entryKey, value) {
+    return upsertYamlEntry(source, key, `  ${entryKey}: ${value}`, yamlEntryPattern(entryKey, true));
+}
+function removeYamlMapEntry(source, entryKey) {
+    const linePattern = new RegExp(yamlEntryPattern(entryKey).source, 'u');
+    const lines = source.split('\n');
+    let changed = false;
+    const out = [];
+    for (const line of lines){
+        if (linePattern.test(line)) {
+            changed = true;
+            continue;
+        }
+        out.push(line);
+    }
+    return changed ? {
+        source: out.join('\n'),
+        changed
+    } : {
+        source,
+        changed
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    ensureYamlListItem: ()=>ensureYamlListItem,
+    ensureYamlMapEntry: ()=>ensureYamlMapEntry,
+    ensureYamlScalarMapEntry: ()=>ensureYamlScalarMapEntry,
+    removeYamlMapEntry: ()=>removeYamlMapEntry,
+    replaceYamlLine: ()=>replaceYamlLine,
+    upsertYamlEntry: ()=>upsertYamlEntry,
+    yamlEntryPattern: ()=>yamlEntryPattern
+});
+exports.ensureYamlListItem = __webpack_exports__.ensureYamlListItem;
+exports.ensureYamlMapEntry = __webpack_exports__.ensureYamlMapEntry;
+exports.ensureYamlScalarMapEntry = __webpack_exports__.ensureYamlScalarMapEntry;
+exports.removeYamlMapEntry = __webpack_exports__.removeYamlMapEntry;
+exports.replaceYamlLine = __webpack_exports__.replaceYamlLine;
+exports.upsertYamlEntry = __webpack_exports__.upsertYamlEntry;
+exports.yamlEntryPattern = __webpack_exports__.yamlEntryPattern;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ensureYamlListItem",
+    "ensureYamlMapEntry",
+    "ensureYamlScalarMapEntry",
+    "removeYamlMapEntry",
+    "replaceYamlLine",
+    "upsertYamlEntry",
+    "yamlEntryPattern"
+].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/policy-constants.cjs

@@ -0,0 +1,88 @@
+"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__, {
+    drizzleOrmDeclarationPatchPath: ()=>drizzleOrmDeclarationPatchPath,
+    drizzleOrmDeclarationPatchSourcePath: ()=>drizzleOrmDeclarationPatchSourcePath,
+    effectDeclarationPatchPath: ()=>effectDeclarationPatchPath,
+    effectDeclarationPatchSourcePath: ()=>effectDeclarationPatchSourcePath,
+    moduleFederationBridgeReactPatchPath: ()=>moduleFederationBridgeReactPatchPath,
+    moduleFederationBridgeReactPatchSourcePath: ()=>moduleFederationBridgeReactPatchSourcePath,
+    moduleFederationModernJsPatchPath: ()=>moduleFederationModernJsPatchPath,
+    moduleFederationModernJsPatchSourcePath: ()=>moduleFederationModernJsPatchSourcePath,
+    strictEffectPackageVersionPolicyExclusions: ()=>strictEffectPackageVersionPolicyExclusions
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const versions_cjs_namespaceObject = require("../../../ultramodern-workspace/versions.cjs");
+const external_context_cjs_namespaceObject = require("../context.cjs");
+const strictEffectPackageVersionPolicyExclusions = [
+    `effect@${versions_cjs_namespaceObject.EFFECT_VERSION}`,
+    `@effect/opentelemetry@${versions_cjs_namespaceObject.EFFECT_VERSION}`
+];
+const moduleFederationModernJsPatchPath = `patches/@module-federation__modern-js-v3@${versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION}.patch`;
+const moduleFederationModernJsPatchSourcePath = external_node_path_default().join(external_context_cjs_namespaceObject.createPackageRoot, 'template-workspace', moduleFederationModernJsPatchPath);
+const moduleFederationBridgeReactPatchPath = `patches/@module-federation__bridge-react@${versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION}.patch`;
+const moduleFederationBridgeReactPatchSourcePath = external_node_path_default().join(external_context_cjs_namespaceObject.createPackageRoot, 'template-workspace', moduleFederationBridgeReactPatchPath);
+const effectDeclarationPatchPath = 'patches/effect-schema-error-type-id.patch';
+const effectDeclarationPatchSourcePath = external_node_path_default().join(external_context_cjs_namespaceObject.createPackageRoot, 'template-workspace', effectDeclarationPatchPath);
+const drizzleOrmDeclarationPatchPath = 'patches/drizzle-orm-ts7-strict-declarations.patch';
+const drizzleOrmDeclarationPatchSourcePath = external_node_path_default().join(external_context_cjs_namespaceObject.createPackageRoot, 'template-workspace', drizzleOrmDeclarationPatchPath);
+exports.drizzleOrmDeclarationPatchPath = __webpack_exports__.drizzleOrmDeclarationPatchPath;
+exports.drizzleOrmDeclarationPatchSourcePath = __webpack_exports__.drizzleOrmDeclarationPatchSourcePath;
+exports.effectDeclarationPatchPath = __webpack_exports__.effectDeclarationPatchPath;
+exports.effectDeclarationPatchSourcePath = __webpack_exports__.effectDeclarationPatchSourcePath;
+exports.moduleFederationBridgeReactPatchPath = __webpack_exports__.moduleFederationBridgeReactPatchPath;
+exports.moduleFederationBridgeReactPatchSourcePath = __webpack_exports__.moduleFederationBridgeReactPatchSourcePath;
+exports.moduleFederationModernJsPatchPath = __webpack_exports__.moduleFederationModernJsPatchPath;
+exports.moduleFederationModernJsPatchSourcePath = __webpack_exports__.moduleFederationModernJsPatchSourcePath;
+exports.strictEffectPackageVersionPolicyExclusions = __webpack_exports__.strictEffectPackageVersionPolicyExclusions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "drizzleOrmDeclarationPatchPath",
+    "drizzleOrmDeclarationPatchSourcePath",
+    "effectDeclarationPatchPath",
+    "effectDeclarationPatchSourcePath",
+    "moduleFederationBridgeReactPatchPath",
+    "moduleFederationBridgeReactPatchSourcePath",
+    "moduleFederationModernJsPatchPath",
+    "moduleFederationModernJsPatchSourcePath",
+    "strictEffectPackageVersionPolicyExclusions"
+].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.cjs

@@ -0,0 +1,149 @@
+"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__, {
+    runMigrateStrictEffect: ()=>runMigrateStrictEffect
+});
+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 workspace_scripts_cjs_namespaceObject = require("../../ultramodern-workspace/workspace-scripts.cjs");
+const external_config_cjs_namespaceObject = require("../config.cjs");
+const api_metadata_cjs_namespaceObject = require("./migrate-strict-effect/api-metadata.cjs");
+const generated_artifacts_cjs_namespaceObject = require("./migrate-strict-effect/generated-artifacts.cjs");
+const help_cjs_namespaceObject = require("./migrate-strict-effect/help.cjs");
+const install_cjs_namespaceObject = require("./migrate-strict-effect/install.cjs");
+const io_cjs_namespaceObject = require("./migrate-strict-effect/io.cjs");
+const package_cohort_cjs_namespaceObject = require("./migrate-strict-effect/package-cohort.cjs");
+const package_source_cjs_namespaceObject = require("./migrate-strict-effect/package-source.cjs");
+const pnpm_policy_cjs_namespaceObject = require("./migrate-strict-effect/pnpm-policy.cjs");
+const external_options_cjs_namespaceObject = require("./options.cjs");
+function runMigrateStrictEffect(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(help_cjs_namespaceObject.migrateStrictEffectHelp);
+        return 0;
+    }
+    const dryRun = (0, external_options_cjs_namespaceObject.hasFlag)(args, '--dry-run');
+    const skipInstall = dryRun || (0, external_options_cjs_namespaceObject.hasFlag)(args, '--skip-install');
+    const io = (0, io_cjs_namespaceObject.createMigrationIo)(context.workspaceRoot, dryRun);
+    const compactPath = external_node_path_default().join(io.workspaceRoot, '.modernjs/ultramodern.json');
+    let raw;
+    if (external_node_fs_default().existsSync(compactPath)) raw = (0, io_cjs_namespaceObject.readJsonFile)(compactPath);
+    else {
+        const synthesized = (0, external_config_cjs_namespaceObject.synthesizeCompactUltramodernConfig)(io.workspaceRoot);
+        if (!synthesized) throw new Error("Missing .modernjs/ultramodern.json and no legacy UltraModern metadata (.modernjs/ultramodern-generated-contract.json) was found to synthesize it from.");
+        raw = synthesized.compact;
+        io.write(compactPath, `${JSON.stringify(raw, null, 2)}\n`);
+        io.log(`Synthesized .modernjs/ultramodern.json from legacy metadata: ${synthesized.sources.join(', ')}.`);
+        if (synthesized.missing.length > 0) io.log(`Legacy metadata not found (using defaults): ${synthesized.missing.join(', ')}.`);
+    }
+    const current = (0, external_config_cjs_namespaceObject.normalizeCompactUltramodernConfig)(io.workspaceRoot, raw);
+    const packageSource = (0, package_source_cjs_namespaceObject.createMigrationPackageSource)(args, current);
+    (0, api_metadata_cjs_namespaceObject.updateUltramodernConfig)(io, raw, packageSource);
+    (0, api_metadata_cjs_namespaceObject.updateReferenceTopology)(io);
+    const migrated = (0, external_config_cjs_namespaceObject.normalizeCompactUltramodernConfig)(io.workspaceRoot, raw);
+    const migratedApps = (0, external_config_cjs_namespaceObject.workspaceAppsFromToolingConfig)(migrated);
+    const shellOnly = !migrated.topology.apps.some((app)=>app.api);
+    if (shellOnly) {
+        io.log('Shell-only workspace: skipping backend-federation and Zerops runtime stages.');
+        for (const relativePath of [
+            "scripts/generate-node-backend-federation.mts",
+            "scripts/generate-node-backend-federation.mjs",
+            "scripts/proof-node-backend-federation.mts",
+            "scripts/proof-node-backend-federation.mjs",
+            "scripts/materialize-zerops-runtime.mjs",
+            'zerops.yaml'
+        ])(0, generated_artifacts_cjs_namespaceObject.removeGeneratedFileIfExists)(io, relativePath);
+    } else {
+        (0, generated_artifacts_cjs_namespaceObject.removeStaleBackendFederationArtifacts)(io, migrated);
+        (0, generated_artifacts_cjs_namespaceObject.updateGeneratedZeropsArtifacts)(io, migrated);
+        (0, generated_artifacts_cjs_namespaceObject.updateGeneratedBackendFederationContractFiles)(io, migrated);
+    }
+    for (const artifact of (0, workspace_scripts_cjs_namespaceObject.migratedWorkspaceScriptArtifacts)({
+        shellOnly
+    })){
+        if (artifact.legacyPath) io.remove(external_node_path_default().join(io.workspaceRoot, artifact.legacyPath));
+        io.write(external_node_path_default().join(io.workspaceRoot, artifact.relativePath), artifact.content);
+    }
+    (0, generated_artifacts_cjs_namespaceObject.updateGeneratedBuildIdentityModules)(io, migrated);
+    (0, generated_artifacts_cjs_namespaceObject.updateGeneratedTypeScriptSurfaces)(io, migrated);
+    (0, generated_artifacts_cjs_namespaceObject.updateGeneratedModernConfigs)(io, migrated);
+    for (const relativePackageFile of (0, io_cjs_namespaceObject.listWorkspacePackageFiles)(io.workspaceRoot)){
+        const packageFile = external_node_path_default().join(io.workspaceRoot, relativePackageFile);
+        const packageJson = (0, io_cjs_namespaceObject.readJsonFile)(packageFile);
+        if ('package.json' === relativePackageFile) {
+            packageJson.modernjs ??= {};
+            packageJson.modernjs.packageSource = {
+                strategy: packageSource.strategy,
+                config: './.modernjs/ultramodern.json'
+            };
+        }
+        (0, package_cohort_cjs_namespaceObject.updateModernDependencies)(packageJson, packageSource);
+        (0, package_cohort_cjs_namespaceObject.updateGeneratedToolingDependencies)(packageJson);
+        (0, package_cohort_cjs_namespaceObject.updateGeneratedPackageScripts)(packageJson, {
+            relativePackageFile,
+            apps: migratedApps,
+            shellOnly
+        });
+        (0, io_cjs_namespaceObject.writeJsonFile)(io, packageFile, packageJson);
+    }
+    (0, pnpm_policy_cjs_namespaceObject.updateGeneratedPnpmWorkspacePolicy)(io);
+    (0, pnpm_policy_cjs_namespaceObject.ensureGeneratedDeclarationPatches)(io, {
+        includeDrizzleOrmPatch: (0, pnpm_policy_cjs_namespaceObject.workspaceUsesDependency)(io.workspaceRoot, 'drizzle-orm')
+    });
+    (0, generated_artifacts_cjs_namespaceObject.ensureGeneratedOxfmtIgnorePatterns)(io);
+    if (!skipInstall) {
+        const status = (0, install_cjs_namespaceObject.runPnpmLockfileRefresh)(context);
+        if (0 !== status) return status;
+    }
+    if (dryRun) {
+        for (const line of io.plan)process.stdout.write(`${line}\n`);
+        process.stdout.write(`[dry-run] migrate-strict-effect would migrate UltraModern strict Effect metadata to ${packageSource.modernPackageVersion}.\n`);
+        return 0;
+    }
+    process.stdout.write(`UltraModern strict Effect metadata migrated to ${packageSource.modernPackageVersion}. Run pnpm api:check && pnpm contract:check next.\n`);
+    return 0;
+}
+exports.runMigrateStrictEffect = __webpack_exports__.runMigrateStrictEffect;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runMigrateStrictEffect"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/options.cjs

@@ -0,0 +1,59 @@
+"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__);
+function readOption(args, name) {
+    const prefix = `${name}=`;
+    const inline = args.find((arg)=>arg.startsWith(prefix));
+    if (inline) {
+        const value = inline.slice(prefix.length);
+        if (!value) throw new Error(`${name} needs a value.`);
+        return value;
+    }
+    const index = args.indexOf(name);
+    if (-1 === index) return;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) throw new Error(`${name} needs a value.`);
+    return value;
+}
+function hasFlag(args, name) {
+    return args.includes(name);
+}
+__webpack_require__.d(__webpack_exports__, {
+    hasFlag: ()=>hasFlag,
+    readOption: ()=>readOption
+});
+exports.hasFlag = __webpack_exports__.hasFlag;
+exports.readOption = __webpack_exports__.readOption;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "hasFlag",
+    "readOption"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/routes-generate.cjs

@@ -0,0 +1,122 @@
+"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__, {
+    runRoutesGenerate: ()=>runRoutesGenerate
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_config_cjs_namespaceObject = require("../config.cjs");
+const external_context_cjs_namespaceObject = require("./context.cjs");
+const external_options_cjs_namespaceObject = require("./options.cjs");
+const resolveRoutesGenerateTargets = (args, context)=>{
+    const appId = (0, external_options_cjs_namespaceObject.readOption)(args, '--app');
+    const targets = (0, external_config_cjs_namespaceObject.workspaceAppsFromToolingConfig)((0, external_config_cjs_namespaceObject.readUltramodernConfig)(context.workspaceRoot)).filter((app)=>!appId || app.id === appId).map((app)=>({
+            label: app.id,
+            appDirectory: external_node_path_default().join(context.workspaceRoot, app.directory)
+        }));
+    if (0 === targets.length) throw new Error(`No generated UltraModern app matched ${appId ?? '<any>'}.`);
+    return targets;
+};
+const renderRoutesGenerateModule = ({ workspaceRoot, targets })=>`
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const workspaceRoot = ${JSON.stringify(workspaceRoot)};
+const targets = ${JSON.stringify(targets, null, 2)};
+const appRequire = createRequire(path.join(workspaceRoot, 'package.json'));
+const pluginUrl = pathToFileURL(
+  appRequire.resolve('@modern-js/plugin-tanstack'),
+).href;
+const { generateTanstackRouteArtifacts } = await import(pluginUrl);
+
+let failed = false;
+// Sequential — the app-tools cli singleton is not re-entrant.
+for (const target of targets) {
+  try {
+    await generateTanstackRouteArtifacts({ appDirectory: target.appDirectory });
+    console.log(\`[ultramodern] TanStack route artifacts generated: \${target.label}\`);
+  } catch (error) {
+    failed = true;
+    console.error(\`[ultramodern] TanStack route generation failed: \${target.label}\`);
+    // Print the full underlying failure, including the cause chain. The
+    // route-generate crash is often an opaque node error thrown deep inside
+    // app-tools/plugin (e.g. a path TypeError), so surfacing only
+    // \`error.message\` swallows the stack that points at the real culprit.
+    let current = error;
+    let depth = 0;
+    while (current) {
+      const label = depth === 0 ? '-' : '  caused by:';
+      const detail =
+        current instanceof Error
+          ? current.stack ?? \`\${current.name}: \${current.message}\`
+          : String(current);
+      console.error(\`\${label} \${detail}\`);
+      current = current instanceof Error ? current.cause : undefined;
+      depth += 1;
+    }
+  }
+}
+
+process.exit(failed ? 1 : 0);
+`;
+function runRoutesGenerate(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(`Usage:
+  modern-js-create ultramodern routes-generate [--app <id>]
+
+Regenerates TanStack route artifacts (router.gen.ts, register.gen.d.ts) for
+generated UltraModern apps without running dev or build. Without --app, every
+generated workspace app is regenerated.
+`);
+        return 0;
+    }
+    const source = renderRoutesGenerateModule({
+        workspaceRoot: context.workspaceRoot,
+        targets: resolveRoutesGenerateTargets(args, context)
+    });
+    return (0, external_context_cjs_namespaceObject.runRenderedModule)(source, context);
+}
+exports.runRoutesGenerate = __webpack_exports__.runRoutesGenerate;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runRoutesGenerate"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/skills.cjs

@@ -0,0 +1,49 @@
+"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__, {
+    runSkills: ()=>runSkills
+});
+const external_context_cjs_namespaceObject = require("./context.cjs");
+function runSkills(args, context) {
+    const [subcommand, ...rest] = args;
+    if ('install' === subcommand) return (0, external_context_cjs_namespaceObject.spawnNodeScript)("template-workspace/scripts/bootstrap-agent-skills.mjs", rest, context);
+    if ('check' === subcommand) return (0, external_context_cjs_namespaceObject.spawnNodeScript)("template-workspace/scripts/bootstrap-agent-skills.mjs", [
+        '--check',
+        ...rest
+    ], context);
+    throw new Error('Usage: modern-js-create ultramodern skills <install|check>');
+}
+exports.runSkills = __webpack_exports__.runSkills;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runSkills"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/sync-delivery-unit.cjs

@@ -0,0 +1,40 @@
+"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__, {
+    runSyncDeliveryUnit: ()=>delivery_unit_sync_cjs_namespaceObject.runSyncDeliveryUnit
+});
+const delivery_unit_sync_cjs_namespaceObject = require("../../ultramodern-workspace/delivery-unit-sync.cjs");
+exports.runSyncDeliveryUnit = __webpack_exports__.runSyncDeliveryUnit;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runSyncDeliveryUnit"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});