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

package/dist/cjs/ultramodern-package-source.cjs

@@ -53,7 +53,8 @@ const ULTRAMODERN_WORKSPACE_MODERN_PACKAGES = [
     '@modern-js/plugin-bff',
     '@modern-js/plugin-i18n',
     '@modern-js/plugin-tanstack',
-    '@modern-js/runtime'
+    '@modern-js/runtime',
+    '@modern-js/runtime-extensions'
 ];
 function modernPackageVersion(packageSource) {
     return 'install' === packageSource.strategy ? packageSource.modernPackageVersion : WORKSPACE_PACKAGE_VERSION;

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

@@ -45,6 +45,7 @@ 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 descriptors_cjs_namespaceObject = require("../../../ultramodern-workspace/descriptors.cjs");
 const module_federation_cjs_namespaceObject = require("../../../ultramodern-workspace/module-federation.cjs");
 const external_config_cjs_namespaceObject = require("../../config.cjs");
 const legacyApiMarkerPattern = /export const ultramodernApiMarker\s*=\s*\{[\s\S]*?\}\s+as const;\n?/u;
@@ -84,8 +85,10 @@ function updateGeneratedBuildIdentityModules(io, config) {
     for (const app of (0, external_config_cjs_namespaceObject.allWorkspaceAppsFromToolingConfig)(config)){
         const sharedApiPath = external_node_path_default().join(io.workspaceRoot, app.directory, 'shared/api.ts');
         if (app.api && external_node_fs_default().existsSync(sharedApiPath)) io.write(sharedApiPath, rewriteApiMarkerIdentitySchema(rewriteLegacyApiMarkerBinding(external_node_fs_default().readFileSync(sharedApiPath, 'utf-8'))));
-        io.writeGenerated(external_node_path_default().join(io.workspaceRoot, app.directory, 'src/ultramodern-build.ts'), (0, module_federation_cjs_namespaceObject.createUltramodernBuildReexportModule)());
-        io.writeGenerated(external_node_path_default().join(io.workspaceRoot, app.directory, 'shared/ultramodern-build.ts'), (0, module_federation_cjs_namespaceObject.createUltramodernBuildModule)(config.workspace.packageScope, app));
+        const reexportPath = external_node_path_default().join(io.workspaceRoot, app.directory, 'src/ultramodern-build.ts');
+        const includeUiMarker = (0, descriptors_cjs_namespaceObject.appEmitsBrowserUi)(app) && ('shell' !== app.kind || external_node_fs_default().existsSync(reexportPath));
+        if (external_node_fs_default().existsSync(reexportPath)) io.writeGenerated(reexportPath, (0, module_federation_cjs_namespaceObject.createUltramodernBuildReexportModule)(app, includeUiMarker));
+        io.writeGenerated(external_node_path_default().join(io.workspaceRoot, app.directory, 'shared/ultramodern-build.ts'), (0, module_federation_cjs_namespaceObject.createUltramodernBuildModule)(config.workspace.packageScope, app, includeUiMarker));
         io.write(external_node_path_default().join(io.workspaceRoot, app.directory, 'shared/ultramodern-build.json'), (0, module_federation_cjs_namespaceObject.createUltramodernBuildArtifactJson)(config.workspace.packageScope, app));
     }
 }

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

@@ -160,6 +160,7 @@ function updateGeneratedModernConfigs(io, config) {
             generatedModuleFederationConfig,
             createGeneratedModuleFederationConfig(!enableBridgeRouter)
         ];
+        const ownsUiComposition = !external_node_fs_default().existsSync(moduleFederationConfigPath) || recognizedModuleFederationConfigs.includes(external_node_fs_default().readFileSync(moduleFederationConfigPath, 'utf8'));
         if ((0, descriptors_cjs_namespaceObject.appEmitsBrowserUi)(app)) writeOwnedTypeScriptConfig(io, moduleFederationConfigPath, generatedModuleFederationConfig, recognizedModuleFederationConfigs);
         else removeOwnedTypeScriptConfig(io, moduleFederationConfigPath, recognizedModuleFederationConfigs);
         const backendFederationConfigPath = external_node_path_default().join(io.workspaceRoot, app.directory, 'backend-federation.config.ts');
@@ -170,6 +171,10 @@ function updateGeneratedModernConfigs(io, config) {
         else removeOwnedTypeScriptConfig(io, backendFederationConfigPath, [
             generatedBackendFederationConfig
         ]);
+        if (!ownsUiComposition) {
+            io.log(`${app.directory} preserves its consumer-owned federation composition instead of regenerating routes from unproven metadata.`);
+            continue;
+        }
         if ('shell' === app.kind) {
             const shellUiRemotes = (0, descriptors_cjs_namespaceObject.resolveRemoteRefs)(app, remotes).filter(descriptors_cjs_namespaceObject.appEmitsBrowserUi);
             const componentsPath = external_node_path_default().join(io.workspaceRoot, app.directory, 'src/routes/vertical-components.tsx');

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

@@ -113,6 +113,7 @@ function mergeTypeScriptConfig(generated, existing) {
         ...existingCompilerOptions,
         ...generatedCompilerOptions
     };
+    if (Array.isArray(generatedCompilerOptions.types)) compilerOptions.types = mergeUniqueJsonValues(generatedCompilerOptions.types, existingCompilerOptions.types);
     if (Array.isArray(generatedCompilerOptions.plugins) || Array.isArray(existingCompilerOptions.plugins)) compilerOptions.plugins = mergeTypeScriptPlugins(generatedCompilerOptions.plugins, existingCompilerOptions.plugins);
     const merged = {
         ...existingConfig,

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

@@ -59,13 +59,20 @@ function updateDeclaredDependencies(packageJson, pins) {
     }
     return changed;
 }
-function updateModernDependencies(packageJson, packageSource) {
+function updateModernDependencies(packageJson, packageSource, releaseCohort) {
     let changed = false;
     for (const section of [
         'dependencies',
         'devDependencies'
     ]){
         const dependencies = packageJson[section];
+        if (dependencies && Object.hasOwn(dependencies, '@modern-js/runtime')) {
+            const runtimeExtensions = (0, external_ultramodern_package_source_cjs_namespaceObject.modernPackageSpecifier)('@modern-js/runtime-extensions', packageSource);
+            if (dependencies['@modern-js/runtime-extensions'] !== runtimeExtensions) {
+                dependencies['@modern-js/runtime-extensions'] = runtimeExtensions;
+                changed = true;
+            }
+        }
         if (dependencies && Object.hasOwn(dependencies, '@modern-js/create')) {
             dependencies[external_ultramodern_package_source_cjs_namespaceObject.ULTRAMODERN_CREATE_PACKAGE] = (0, external_ultramodern_package_source_cjs_namespaceObject.modernPackageSpecifier)(external_ultramodern_package_source_cjs_namespaceObject.ULTRAMODERN_CREATE_PACKAGE, packageSource);
             delete dependencies['@modern-js/create'];
@@ -73,11 +80,23 @@ function updateModernDependencies(packageJson, packageSource) {
         }
     }
     return updateDeclaredDependencies(packageJson, new Map([
-        ...modernPackageNames
-    ].map((packageName)=>[
-            packageName,
-            (0, external_ultramodern_package_source_cjs_namespaceObject.modernPackageSpecifier)(packageName, packageSource)
-        ]))) || changed;
+        ...[
+            ...modernPackageNames
+        ].map((packageName)=>[
+                packageName,
+                (0, external_ultramodern_package_source_cjs_namespaceObject.modernPackageSpecifier)(packageName, packageSource)
+            ]),
+        ...(releaseCohort?.packages ?? []).flatMap((item)=>[
+                [
+                    item.sourceName,
+                    (0, external_ultramodern_package_source_cjs_namespaceObject.modernPackageSpecifier)(item.sourceName, packageSource)
+                ],
+                [
+                    item.targetName,
+                    item.version
+                ]
+            ])
+    ])) || changed;
 }
 const generatedToolingDependencyPins = new Map(Object.entries({
     ...policy_cjs_namespaceObject.ULTRAMODERN_PACKAGE_PINS.appDependencies,
@@ -170,6 +189,8 @@ function mergeGeneratedScript(consumer, framework, canRetireLegacyOxfmtCliExclus
     const frameworkSegmentSet = new Set(frameworkSegments);
     const canonicalFrameworkSegment = (segment)=>{
         if (frameworkSegmentSet.has(segment)) return segment;
+        const referenceBuild = segment.replace('--project tsconfig.json', '--build tsconfig.json');
+        if (frameworkSegmentSet.has(referenceBuild)) return referenceBuild;
         const portableEnvironmentSegment = `cross-env ${segment}`;
         if (frameworkSegmentSet.has(portableEnvironmentSegment)) return portableEnvironmentSegment;
         const portableOxfmtSegment = segment.replace(/ '!repos\/\*\*'$/u, '');
@@ -222,12 +243,12 @@ function mergeGeneratedScript(consumer, framework, canRetireLegacyOxfmtCliExclus
         preservedConsumerSegments: consumerExtras.length > 0
     };
 }
-function rewriteMigratedScriptReferences(scripts) {
+function rewriteMigratedScriptReferences(scripts, preservedArtifacts) {
     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');
+        const next = value.replace(pattern, (original, basename)=>preservedArtifacts?.has(`${basename}.mjs`) ? original : `${basename}.mts`);
         if (next !== value) {
             scripts[name] = next;
             changed = true;
@@ -242,7 +263,7 @@ function updateGeneratedPackageScripts(packageJson, options = {}) {
     const apps = options.apps ?? [];
     const app = apps.find((candidate)=>`${candidate.directory}/package.json` === options.relativePackageFile);
     const isRootPackage = 'package.json' === options.relativePackageFile;
-    if (rewriteMigratedScriptReferences(scripts)) changed = true;
+    if (rewriteMigratedScriptReferences(scripts, options.preservedArtifacts)) changed = true;
     if (isRootPackage) {
         for (const [name, [legacy, portable]] of legacyPortableRootScripts)if (true === options.canRetireLegacyOxfmtCliExclusion && scripts[name] === legacy) {
             scripts[name] = portable;

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

@@ -244,11 +244,7 @@ function reconcilePatchedDependencies(document, includeDrizzleOrmPatch) {
             patchKey(patch),
             patch
         ]));
-    const ownedPackageNames = new Set([
-        ...policy.required,
-        ...policy.conditional,
-        ...policy.stale
-    ].map((patch)=>patch.packageName));
+    const ownedPackageNames = new Set(expectedPatches.map((patch)=>patch.packageName));
     const patchedDependencies = ensureMap(document, 'patchedDependencies');
     for (const [selector, patchPath] of Object.entries(patchedDependencies)){
         const stalePatch = stale.get(selector);
@@ -257,15 +253,13 @@ function reconcilePatchedDependencies(document, includeDrizzleOrmPatch) {
             delete patchedDependencies[selector];
             continue;
         }
-        const parts = packageVersionParts(selector);
-        if (parts && ownedPackageNames.has(parts.packageName) && !expected.has(selector)) {
-            const conditionalPatch = policy.conditional.find((patch)=>patchKey(patch) === selector);
-            if (conditionalPatch && !includeDrizzleOrmPatch && patchPath === conditionalPatch.path) {
-                delete patchedDependencies[selector];
-                continue;
-            }
-            throw new Error(`Framework-owned patch selector ${selector} has unknown provenance.`);
+        const conditionalPatch = policy.conditional.find((patch)=>patchKey(patch) === selector);
+        if (conditionalPatch && !includeDrizzleOrmPatch && patchPath === conditionalPatch.path) {
+            delete patchedDependencies[selector];
+            continue;
         }
+        const parts = packageVersionParts(selector);
+        if (parts && ownedPackageNames.has(parts.packageName) && !expected.has(selector)) throw new Error(`Framework-owned patch selector ${selector} has unknown provenance.`);
     }
     for (const [selector, patchPath] of expected)patchedDependencies[selector] = patchPath;
 }
@@ -556,6 +550,8 @@ async function validateGeneratedPnpmLockReleaseAgePolicy(workspaceRoot, packageS
     const firstPartyTargetNames = new Set(releaseCohort?.packages.map((item)=>item.targetName) ?? []);
     const { document: lockfile } = (0, external_pnpm_yaml_cjs_namespaceObject.parsePnpmWorkspaceYaml)(external_node_fs_default().readFileSync(lockfilePath, 'utf-8'), lockfilePath);
     const closure = (0, external_pnpm_yaml_cjs_namespaceObject.discoverReachablePnpmLockReleaseAgeClosure)(lockfile);
+    const firstPartySourceNames = new Set(releaseCohort?.packages.map((item)=>item.sourceName) ?? []);
+    for (const tarball of closure.tarballs)if (firstPartyTargetNames.has(tarball.packageName) || firstPartySourceNames.has(tarball.packageName)) throw new Error(`First-party lock candidate ${tarball.packageName} must resolve through the authenticated release cohort, not a tarball URL.`);
     if (closure.unresolved.length > 0) {
         const unresolved = closure.unresolved.slice(0, 20).map((candidate)=>{
             const packageName = candidate.package ?? 'unknown package';

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

@@ -44,6 +44,11 @@ const integrityPattern = /^sha512-[A-Za-z0-9+/]+={0,2}$/u;
 function isExactSemver(version) {
     return utils_namespaceObject.semver.valid(version) === version;
 }
+function isHttpsTarballLocator(value) {
+    if (!value.startsWith('https://') || /[\s()]/u.test(value) || !URL.canParse(value)) return false;
+    const url = new URL(value);
+    return url.href === value && '' === url.username && '' === url.password && '' === url.hash;
+}
 function isYamlRecord(value) {
     return Boolean(value) && 'object' == typeof value && !Array.isArray(value);
 }
@@ -97,7 +102,7 @@ function splitPeerContext(locator) {
     for (const segment of segments){
         if (/^patch_hash=[a-f0-9]{32,128}$/u.test(segment) || /^[a-f0-9]{32,128}$/u.test(segment)) continue;
         const peer = parsePackageKey(segment);
-        if (!peer) return {
+        if (!peer || isHttpsTarballLocator(peer.version)) return {
             unresolved: locator
         };
         peers.push(peer);
@@ -109,11 +114,12 @@ function splitPeerContext(locator) {
 }
 function parsePackageLocator(rawLocator) {
     const locator = rawLocator.replace(/^\//u, '');
-    const separator = locator.lastIndexOf('@');
+    const tarballSeparator = locator.indexOf('@https://');
+    const separator = tarballSeparator > 0 ? tarballSeparator : locator.lastIndexOf('@');
     if (separator <= 0) return;
     const packageName = locator.slice(0, separator);
     const version = locator.slice(separator + 1);
-    if (!exactPackageNamePattern.test(packageName) || !isExactSemver(version)) return;
+    if (!exactPackageNamePattern.test(packageName) || !isExactSemver(version) && !isHttpsTarballLocator(version)) return;
     return {
         packageName,
         version,
@@ -157,6 +163,11 @@ function dependencyIdentity(dependencyName, rawValue) {
     const peerContext = splitPeerContext(value.startsWith('npm:') ? value.slice(4) : value);
     if ('unresolved' in peerContext) return peerContext;
     const { base, peers } = peerContext;
+    if (isHttpsTarballLocator(base) && exactPackageNamePattern.test(dependencyName)) return {
+        packageName: dependencyName,
+        version: base,
+        peers
+    };
     const full = parsePackageLocator(base);
     if (full) return {
         ...full,
@@ -299,13 +310,11 @@ function discoverReachablePnpmLockReleaseAgeClosure(lockfile) {
         const currentPath = shortestIdentityPaths.get(key);
         if (!currentPath || nodePath.length < currentPath.length) shortestIdentityPaths.set(key, nodePath);
     }
+    const tarballs = [];
     const candidates = [
         ...shortestIdentityPaths.entries()
     ].map(([key, path])=>{
-        const [packageName, version] = [
-            key.slice(0, key.lastIndexOf('@')),
-            key.slice(key.lastIndexOf('@') + 1)
-        ];
+        const { packageName, version } = nodes.get(nodeIdsByIdentity.get(key)[0]).identity;
         const packageRecordsForIdentity = packageRecordsByIdentity.get(key);
         if (!packageRecordsForIdentity?.length) return void recordUnresolved({
             packageName,
@@ -313,12 +322,25 @@ function discoverReachablePnpmLockReleaseAgeClosure(lockfile) {
             peers: []
         }, path, 'missing exact SHA-512 lock integrity');
         let integrity;
+        let tarballVersion;
         for (const [packageKey, packageRecord] of packageRecordsForIdentity){
             const resolution = requiredYamlRecord(requiredYamlRecord(packageRecord, `pnpm lockfile package ${packageKey}`).resolution, `pnpm lockfile package ${packageKey} resolution`);
             if ('string' != typeof resolution.integrity || !integrityPattern.test(resolution.integrity)) throw new Error(`pnpm lockfile package ${packageKey} has uncertain registry integrity.`);
             if (integrity && integrity !== resolution.integrity) throw new Error(`pnpm lockfile has conflicting registry integrity for ${key}.`);
             integrity = resolution.integrity;
+            if (isHttpsTarballLocator(version)) {
+                const metadata = requiredYamlRecord(packageRecord, `pnpm lockfile package ${packageKey}`);
+                if (resolution.tarball !== version || 'string' != typeof metadata.version || !isExactSemver(metadata.version) || void 0 !== tarballVersion && tarballVersion !== metadata.version) throw new Error(`pnpm lockfile package ${packageKey} has uncertain tarball identity.`);
+                tarballVersion = metadata.version;
+            }
         }
+        if (void 0 !== tarballVersion) return void tarballs.push({
+            packageName,
+            version: tarballVersion,
+            url: version,
+            integrity: integrity,
+            path
+        });
         return {
             packageName,
             version,
@@ -333,6 +355,7 @@ function discoverReachablePnpmLockReleaseAgeClosure(lockfile) {
     unresolved.sort((left, right)=>JSON.stringify(left).localeCompare(JSON.stringify(right)));
     return {
         candidates,
+        tarballs,
         unresolved
     };
 }

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/shared-api-infrastructure.cjs

@@ -0,0 +1,99 @@
+"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__, {
+    ensureSharedApiInfrastructure: ()=>ensureSharedApiInfrastructure
+});
+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 fs_io_cjs_namespaceObject = require("../../../ultramodern-workspace/fs-io.cjs");
+const package_json_cjs_namespaceObject = require("../../../ultramodern-workspace/package-json.cjs");
+const external_io_cjs_namespaceObject = require("./io.cjs");
+const directory = 'packages/shared-contracts';
+function record(value, label) {
+    if (null === value || 'object' != typeof value || Array.isArray(value)) throw new Error(`${label} must be an object; resolve it before migration.`);
+    return value;
+}
+function ensureSharedApiInfrastructure(io, scope, packageSource) {
+    for (const relativePath of [
+        'packages',
+        directory,
+        `${directory}/package.json`,
+        `${directory}/src`,
+        `${directory}/src/index.ts`
+    ])if (external_node_fs_default().lstatSync(external_node_path_default().join(io.workspaceRoot, relativePath), {
+        throwIfNoEntry: false
+    })?.isSymbolicLink()) throw new Error(`Shared API migration cannot write through a symbolic link: ${relativePath}`);
+    const manifestPath = external_node_path_default().join(io.workspaceRoot, directory, 'package.json');
+    const defaults = (0, package_json_cjs_namespaceObject.createSharedPackage)(scope, 'shared-contracts', 'Shared workspace contracts', packageSource);
+    const manifest = external_node_fs_default().existsSync(manifestPath) ? record((0, external_io_cjs_namespaceObject.readJsonFile)(manifestPath), `${directory}/package.json`) : defaults;
+    const exports1 = void 0 === manifest.exports ? {} : 'string' == typeof manifest.exports ? {
+        '.': manifest.exports
+    } : record(manifest.exports, `${directory}/package.json exports`);
+    if (Object.keys(exports1).some((key)=>!key.startsWith('.')) || void 0 !== exports1['.'] && './src/index.ts' !== exports1['.']) throw new Error(`${directory}/package.json exports must expose ./src/index.ts at "." before adding shared API infrastructure; consumer exports were not overwritten.`);
+    for (const [subpath, target] of Object.entries(record(defaults.exports, 'Shared contract exports')))if (void 0 !== exports1[subpath] && exports1[subpath] !== target) throw new Error(`${directory}/package.json ${subpath} must expose ${String(target)}; consumer exports were not overwritten.`);
+    const dependencies = record(manifest.dependencies ?? {}, `${directory}/package.json dependencies`);
+    manifest.exports = {
+        ...record(defaults.exports, 'Shared contract exports'),
+        ...exports1
+    };
+    manifest.dependencies = {
+        ...record(defaults.dependencies, 'Shared contract dependencies'),
+        ...dependencies
+    };
+    const writeMissing = (relativePath, content)=>{
+        const filePath = external_node_path_default().join(io.workspaceRoot, directory, relativePath);
+        if (void 0 === external_node_fs_default().lstatSync(filePath, {
+            throwIfNoEntry: false
+        })) io.writeGenerated(filePath, content);
+    };
+    writeMissing('src/effect-bff-runtime.ts', (0, fs_io_cjs_namespaceObject.readFileTemplate)('packages/effect-bff-runtime.ts'));
+    writeMissing('src/microvertical-api-baseline.ts', (0, fs_io_cjs_namespaceObject.readFileTemplate)('packages/microvertical-api-baseline.ts'));
+    writeMissing('tsconfig.json', `${JSON.stringify((0, package_json_cjs_namespaceObject.createSharedPackageTsConfig)(directory), null, 2)}\n`);
+    writeMissing('src/index.ts', (0, fs_io_cjs_namespaceObject.readFileTemplate)('packages/shared-contracts-index.ts'));
+    (0, external_io_cjs_namespaceObject.writeJsonFile)(io, manifestPath, manifest);
+}
+exports.ensureSharedApiInfrastructure = __webpack_exports__.ensureSharedApiInfrastructure;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ensureSharedApiInfrastructure"
+].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/toolchain-pins.cjs

@@ -45,11 +45,16 @@ 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 utils_namespaceObject = require("@modern-js/utils");
 const policy_cjs_namespaceObject = require("../../../ultramodern-workspace/policy.cjs");
 const { toolchain } = policy_cjs_namespaceObject.ULTRAMODERN_WORKSPACE_POLICY;
 const retiredRootToolingDependencies = [
     "@typescript/typescript6"
 ];
+function migrationPnpmVersion(value) {
+    const baseline = toolchain.packageManager.version;
+    return 'string' == typeof value && utils_namespaceObject.semver.valid(value) && utils_namespaceObject.semver.major(value) === utils_namespaceObject.semver.major(baseline) && utils_namespaceObject.semver.gte(value, baseline) ? value : baseline;
+}
 function isRecord(value) {
     return Boolean(value) && 'object' == typeof value && !Array.isArray(value);
 }
@@ -67,22 +72,24 @@ function updateUltramodernConfigToolchain(config) {
     const workspace = ensureRecord(config, 'workspace', 'workspace');
     const packageManager = ensureRecord(workspace, 'packageManager', 'workspace.packageManager');
     packageManager.name = toolchain.packageManager.name;
-    packageManager.version = toolchain.packageManager.version;
+    packageManager.version = migrationPnpmVersion(packageManager.version);
     const node = ensureRecord(workspace, 'node', 'workspace.node');
     node.version = toolchain.node.version;
     node.engineRange = toolchain.node.engineRange;
 }
 function updateRootPackageToolchain(packageJson) {
-    packageJson.packageManager = `${toolchain.packageManager.name}@${toolchain.packageManager.version}`;
+    const currentVersion = 'string' == typeof packageJson.packageManager ? packageJson.packageManager.match(/^pnpm@([^+]+)(?:\+.*)?$/u)?.[1] : void 0;
+    packageJson.packageManager = `${toolchain.packageManager.name}@${migrationPnpmVersion(currentVersion)}`;
     const engines = ensureRecord(packageJson, 'engines', 'package.json engines');
     engines.node = toolchain.node.engineRange;
     engines.pnpm = toolchain.packageManager.engineRange;
     const devDependencies = ensureRecord(packageJson, 'devDependencies', 'package.json devDependencies');
     for (const packageName of retiredRootToolingDependencies)delete devDependencies[packageName];
     devDependencies["@typescript/native"] = policy_cjs_namespaceObject.ULTRAMODERN_PACKAGE_PINS.rootDevDependencies["@typescript/native"];
+    devDependencies['@types/node'] = policy_cjs_namespaceObject.ULTRAMODERN_PACKAGE_PINS.rootDevDependencies["@types/node"];
     devDependencies.miniflare = policy_cjs_namespaceObject.ULTRAMODERN_PACKAGE_PINS.rootDevDependencies.miniflare;
 }
-function updateMiseTools(content) {
+function updateMiseTools(content, pnpmVersion) {
     const lines = content.replace(/\r\n/gu, '\n').split('\n');
     if ('' === lines.at(-1)) lines.pop();
     let toolsStart = lines.findIndex((line)=>/^\s*\[tools\]\s*(?:#.*)?$/u.test(line));
@@ -109,13 +116,15 @@ function updateMiseTools(content) {
         lines[index] = line;
     };
     upsertTool('node', toolchain.node.version);
-    upsertTool('pnpm', toolchain.packageManager.version);
+    upsertTool('pnpm', pnpmVersion);
     return `${lines.join('\n')}\n`;
 }
 function updateGeneratedToolchainFiles(io) {
     const misePath = external_node_path_default().join(io.workspaceRoot, '.mise.toml');
     const miseContent = external_node_fs_default().existsSync(misePath) ? external_node_fs_default().readFileSync(misePath, 'utf-8') : '';
-    io.write(misePath, updateMiseTools(miseContent));
+    const packageJson = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().join(io.workspaceRoot, 'package.json'), 'utf8'));
+    const pnpmVersion = migrationPnpmVersion(packageJson.packageManager?.match(/^pnpm@([^+]+)(?:\+.*)?$/u)?.[1]);
+    io.write(misePath, updateMiseTools(miseContent, pnpmVersion));
     const workflowPath = external_node_path_default().join(io.workspaceRoot, '.github/workflows/ultramodern-workspace-gates.yml');
     if (!external_node_fs_default().existsSync(workflowPath)) return;
     const workflow = external_node_fs_default().readFileSync(workflowPath, 'utf-8');