@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.3 → 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/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,
@@ -224,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;
@@ -244,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/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,13 +72,14 @@ 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;
@@ -83,7 +89,7 @@ function updateRootPackageToolchain(packageJson) {
     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));
@@ -110,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');

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/workspace-artifact-ownership.cjs

@@ -0,0 +1,215 @@
+"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
+});
+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 fs_io_cjs_namespaceObject = require("../../../ultramodern-workspace/fs-io.cjs");
+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 staticPropertyValue(node, name) {
+    if (node?.type !== 'ObjectExpression') return;
+    const keys = new Set();
+    let value;
+    for (const property of node.properties){
+        if ('ObjectProperty' !== property.type || property.computed || property.shorthand || ![
+            'Identifier',
+            'StringLiteral'
+        ].includes(property.key.type)) return;
+        const key = property.key.name ?? property.key.value;
+        if (keys.has(key)) return;
+        keys.add(key);
+        if (key === name) value = property.value;
+    }
+    return value;
+}
+function refreshValidatorReleaseCohort(source, releaseCohort) {
+    try {
+        const parsed = (0, parser_namespaceObject.parse)(source, {
+            sourceType: 'module',
+            plugins: [
+                "typescript"
+            ],
+            tokens: true
+        });
+        const constants = parsed.program.body.flatMap((statement)=>'VariableDeclaration' === statement.type && 'const' === statement.kind ? statement.declarations : []);
+        const matches = [];
+        for (const statement of parsed.program.body)if ('VariableDeclaration' === statement.type && 'const' === statement.kind) for (const declaration of statement.declarations){
+            const kind = staticPropertyValue(declaration.init, 'kind');
+            if (kind?.type !== 'StringLiteral' || 'modernjs.ultramodern-workspace-validation-contract' !== kind.value) continue;
+            const cohort = staticPropertyValue(staticPropertyValue(declaration.init, 'cohort'), 'releaseCohort');
+            const schema = staticPropertyValue(cohort, 'schema');
+            const schemaVersion = staticPropertyValue(cohort, 'schemaVersion');
+            const version = staticPropertyValue(staticPropertyValue(cohort, 'release'), 'version');
+            const versionConstant = version?.type === 'Identifier' ? constants.find((declaration)=>'Identifier' === declaration.id.type && declaration.id.name === version.name && declaration.init?.type === 'StringLiteral') : void 0;
+            if (schema?.type === 'StringLiteral' && 'bleedingdev.ultramodern.release-cohort' === schema.value && schemaVersion?.type === 'NumericLiteral' && 1 === schemaVersion.value && isLiteralData(cohort, versionConstant ? new Set([
+                version.name
+            ]) : void 0)) matches.push({
+                cohort,
+                version,
+                versionConstant
+            });
+        }
+        if (1 !== matches.length) return source;
+        const { cohort, version, versionConstant } = matches[0];
+        let content = JSON.stringify(releaseCohort, null, 2);
+        const edits = [];
+        if (versionConstant && !parsed.tokens?.some((token)=>'name' === token.type.label && token.value === version.name && token.start !== versionConstant.id.start && (token.start < cohort.start || token.end > cohort.end))) {
+            content = content.replaceAll(`"version": ${JSON.stringify(releaseCohort.release.version)}`, `"version": ${version.name}`);
+            edits.push({
+                start: versionConstant.init.start,
+                end: versionConstant.init.end,
+                content: JSON.stringify(releaseCohort.release.version)
+            });
+        }
+        edits.push({
+            start: cohort.start,
+            end: cohort.end,
+            content
+        });
+        for (const edit of edits.toSorted((left, right)=>right.start - left.start))source = source.slice(0, edit.start) + edit.content + source.slice(edit.end);
+        return source;
+    } catch  {
+        return source;
+    }
+}
+function preserveConsumerWorkspaceArtifacts(io, candidates) {
+    const preservedPaths = new Set();
+    const physicalRoot = external_node_fs_default().realpathSync(io.workspaceRoot);
+    const canonicalSources = (0, 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 paths = [
+            candidate.relativePath,
+            candidate.legacyPath
+        ].filter((value)=>void 0 !== value);
+        for (const relativePath of paths){
+            const filePath = external_node_path_default().join(io.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, fs_io_cjs_namespaceObject.formatGeneratedSourceCandidates)([
+                    [
+                        relativePath,
+                        normalized
+                    ]
+                ])[0] === canonical;
+            } catch  {}
+            if (!recognized) for (const pairedPath of paths)preservedPaths.add(pairedPath);
+        }
+    }
+    const reported = new Set();
+    const isPreserved = (filePath)=>{
+        const relativePath = external_node_path_default().relative(io.workspaceRoot, filePath).split(external_node_path_default().sep).join('/');
+        if (!preservedPaths.has(relativePath)) return false;
+        if (!reported.has(relativePath)) {
+            io.log(`${relativePath} preserved consumer-owned artifact: its canonical generated source does not match.`);
+            reported.add(relativePath);
+        }
+        return true;
+    };
+    return {
+        preservedPaths,
+        refreshReleaseCohort (releaseCohort) {
+            if (!releaseCohort) return;
+            for (const candidate of candidates)if ('workspaceValidationContract' === candidate.generatedDataBinding) for (const relativePath of [
+                candidate.relativePath,
+                candidate.legacyPath
+            ]){
+                if (!relativePath || !preservedPaths.has(relativePath)) continue;
+                const filePath = external_node_path_default().join(io.workspaceRoot, relativePath);
+                if (!external_node_fs_default().existsSync(filePath)) continue;
+                const source = external_node_fs_default().readFileSync(filePath, 'utf8');
+                io.write(filePath, refreshValidatorReleaseCohort(source, releaseCohort));
+            }
+        },
+        io: {
+            ...io,
+            write: (filePath, content)=>isPreserved(filePath) ? false : io.write(filePath, content),
+            writeGenerated: (filePath, content)=>isPreserved(filePath) ? false : io.writeGenerated(filePath, content),
+            remove: (filePath)=>isPreserved(filePath) ? false : io.remove(filePath)
+        }
+    };
+}
+exports.preserveConsumerWorkspaceArtifacts = __webpack_exports__.preserveConsumerWorkspaceArtifacts;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "preserveConsumerWorkspaceArtifacts"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});