@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

package/dist/esm-node/ultramodern-release-cohort.js

@@ -0,0 +1,134 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { createPackageRoot, writeFile } from "./ultramodern-workspace/fs-io.js";
+const RELEASE_COHORT_PROJECTION_PATH = '.modernjs/release-cohort.json';
+const RELEASE_COHORT_PROJECTION_SCHEMA = 'bleedingdev.ultramodern.release-cohort';
+const RELEASE_COHORT_PROJECTION_SCHEMA_VERSION = 1;
+function assert(condition, message) {
+    if (!condition) throw new Error(message);
+}
+function isRecord(value) {
+    return Boolean(value) && 'object' == typeof value && !Array.isArray(value);
+}
+function assertExactKeys(value, expectedKeys, label) {
+    assert(isRecord(value), `${label} must be a JSON object.`);
+    const actualKeys = Object.keys(value).sort();
+    const expected = [
+        ...expectedKeys
+    ].sort();
+    assert(JSON.stringify(actualKeys) === JSON.stringify(expected), `${label} has unknown or missing fields: expected ${expected.join(', ')}; found ${actualKeys.join(', ')}.`);
+}
+function assertNonEmptyString(value, label) {
+    assert('string' == typeof value && value.length > 0 && value.trim() === value, `${label} must be a non-empty trimmed string.`);
+}
+function sourcePackageSuffix(sourceName) {
+    assert(sourceName.startsWith('@modern-js/') && sourceName.lastIndexOf('/') > 0, `Release cohort sourceName must be an @modern-js package: ${sourceName}.`);
+    return sourceName.slice(sourceName.lastIndexOf('/') + 1);
+}
+function targetAliasProfile(sourceName, targetName) {
+    const match = /^@([^/]+)\/([^/]+)$/u.exec(targetName);
+    assert(match, `Release cohort targetName is invalid: ${targetName}.`);
+    const [, aliasScope, targetPackageName] = match;
+    const suffix = sourcePackageSuffix(sourceName);
+    assert(targetPackageName.endsWith(suffix), `Release cohort alias ${sourceName} -> ${targetName} does not preserve the source package suffix.`);
+    return {
+        aliasPackageNamePrefix: targetPackageName.slice(0, targetPackageName.length - suffix.length),
+        aliasScope
+    };
+}
+function parseUltramodernReleaseCohort(value) {
+    assertExactKeys(value, [
+        'aliases',
+        'packages',
+        'release',
+        'schema',
+        'schemaVersion',
+        'source'
+    ], 'Release cohort projection');
+    const cohort = value;
+    assert(cohort.schema === RELEASE_COHORT_PROJECTION_SCHEMA && cohort.schemaVersion === RELEASE_COHORT_PROJECTION_SCHEMA_VERSION, `Unknown release cohort projection schema ${String(cohort.schema)}@${String(cohort.schemaVersion)}.`);
+    assertExactKeys(cohort.source, [
+        'commit',
+        'repository'
+    ], 'Release cohort source');
+    assertNonEmptyString(cohort.source.commit, 'Release cohort source.commit');
+    assertNonEmptyString(cohort.source.repository, 'Release cohort source.repository');
+    assertExactKeys(cohort.release, [
+        'tag',
+        'version'
+    ], 'Release cohort release');
+    assertNonEmptyString(cohort.release.tag, 'Release cohort release.tag');
+    assertNonEmptyString(cohort.release.version, 'Release cohort release.version');
+    assert(isRecord(cohort.aliases), 'Release cohort aliases must be an object.');
+    assert(Array.isArray(cohort.packages), 'Release cohort packages must be an array.');
+    const aliasNames = Object.keys(cohort.aliases).sort();
+    assert(aliasNames.length > 0, 'Release cohort aliases must not be empty.');
+    const packageSourceNames = [];
+    const packageTargetNames = new Set();
+    for (const [index, item] of cohort.packages.entries()){
+        assertExactKeys(item, [
+            'sourceName',
+            'targetName',
+            'version'
+        ], `Release cohort packages[${index}]`);
+        assertNonEmptyString(item.sourceName, `Release cohort packages[${index}].sourceName`);
+        assertNonEmptyString(item.targetName, `Release cohort packages[${index}].targetName`);
+        assertNonEmptyString(item.version, `Release cohort packages[${index}].version`);
+        sourcePackageSuffix(item.sourceName);
+        assert(cohort.aliases[item.sourceName] === item.targetName, `Release cohort packages[${index}] targetName does not match aliases for ${item.sourceName}.`);
+        assert(item.version === cohort.release.version, `Release cohort packages[${index}] version does not match release.version.`);
+        packageSourceNames.push(item.sourceName);
+        assert(!packageTargetNames.has(item.targetName), `Release cohort packages contains duplicate targetName ${item.targetName}.`);
+        packageTargetNames.add(item.targetName);
+    }
+    assert(JSON.stringify(packageSourceNames) === JSON.stringify(aliasNames), 'Release cohort packages must exactly match aliases in source-name order.');
+    return cohort;
+}
+function readCohortFile(filePath) {
+    const stat = node_fs.lstatSync(filePath, {
+        throwIfNoEntry: false
+    });
+    assert(stat?.isFile() && !stat.isSymbolicLink(), `Authenticated release cohort projection is missing or unsafe: ${filePath}.`);
+    let value;
+    try {
+        value = JSON.parse(node_fs.readFileSync(filePath, 'utf8'));
+    } catch (error) {
+        throw new Error(`Authenticated release cohort projection is invalid JSON: ${error instanceof Error ? error.message : String(error)}.`);
+    }
+    return parseUltramodernReleaseCohort(value);
+}
+function readCreateReleaseCohort() {
+    return readCohortFile(node_path.join(createPackageRoot, 'template-workspace', RELEASE_COHORT_PROJECTION_PATH));
+}
+function hasCreateReleaseCohort() {
+    return node_fs.existsSync(node_path.join(createPackageRoot, 'template-workspace', RELEASE_COHORT_PROJECTION_PATH));
+}
+function isCreatePackageSourceCheckout() {
+    return node_fs.existsSync(node_path.join(createPackageRoot, 'src'));
+}
+function readWorkspaceReleaseCohort(workspaceRoot) {
+    return readCohortFile(node_path.join(workspaceRoot, RELEASE_COHORT_PROJECTION_PATH));
+}
+function copyCreateReleaseCohort(workspaceRoot) {
+    const sourcePath = node_path.join(createPackageRoot, 'template-workspace', RELEASE_COHORT_PROJECTION_PATH);
+    const cohort = readCohortFile(sourcePath);
+    writeFile(workspaceRoot, RELEASE_COHORT_PROJECTION_PATH, node_fs.readFileSync(sourcePath, 'utf8'));
+    return cohort;
+}
+function assertReleaseCohortPackageSource(cohort, packageSource) {
+    if ('install' !== packageSource.strategy) return;
+    assert(packageSource.modernPackageVersion === cohort.release.version, `Package source release ${packageSource.modernPackageVersion} does not match authenticated release cohort ${cohort.release.version}.`);
+    let expectedProfile;
+    for (const item of cohort.packages){
+        const profile = targetAliasProfile(item.sourceName, item.targetName);
+        expectedProfile ??= profile;
+        assert(profile.aliasScope === expectedProfile.aliasScope && profile.aliasPackageNamePrefix === expectedProfile.aliasPackageNamePrefix, 'Authenticated release cohort aliases cannot be represented by one package-source profile.');
+    }
+    assert(packageSource.aliasScope?.replace(/^@/u, '') === expectedProfile?.aliasScope && (packageSource.aliasPackageNamePrefix ?? '') === expectedProfile?.aliasPackageNamePrefix, 'Package source aliases rebind the authenticated release cohort.');
+    return cohort;
+}
+function releaseCohortSelectors(cohort) {
+    return cohort.packages.map((item)=>`${item.targetName}@${item.version}`).sort();
+}
+export { RELEASE_COHORT_PROJECTION_PATH, assertReleaseCohortPackageSource, copyCreateReleaseCohort, hasCreateReleaseCohort, isCreatePackageSourceCheckout, parseUltramodernReleaseCohort, readCreateReleaseCohort, readWorkspaceReleaseCohort, releaseCohortSelectors };

package/dist/esm-node/ultramodern-tooling/commands/cloudflare-output-verify.js

@@ -0,0 +1,85 @@
+import "node:module";
+import node_path from "node:path";
+import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "../config.js";
+import { runRenderedModule } from "./context.js";
+import { readOption } from "./options.js";
+const resolveCloudflareOutputVerifyTargets = (args, context)=>{
+    const outputDirectory = readOption(args, '--output');
+    const appId = readOption(args, '--app');
+    if (outputDirectory && appId) throw new Error('Use either --app or --output, not both.');
+    const targets = outputDirectory ? [
+        {
+            label: outputDirectory,
+            outputDirectory: node_path.resolve(context.invocationCwd, outputDirectory)
+        }
+    ] : workspaceAppsFromToolingConfig(readUltramodernConfig(context.workspaceRoot)).filter((app)=>!appId || app.id === appId).map((app)=>({
+            label: app.id,
+            outputDirectory: node_path.join(context.workspaceRoot, app.directory, '.output')
+        }));
+    if (0 === targets.length) throw new Error(`No generated UltraModern app matched ${appId}.`);
+    return targets;
+};
+const renderCloudflareOutputVerifyModule = ({ workspaceRoot, targets, excludePaths })=>`
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+const workspaceRoot = ${JSON.stringify(workspaceRoot)};
+const targets = ${JSON.stringify(targets, null, 2)};
+const scanRoots = [workspaceRoot];
+const excludePaths = ${JSON.stringify(excludePaths)};
+const verifierRequire = createRequire(path.join(workspaceRoot, 'package.json'));
+const {
+  verifyCloudflareOutput,
+  verifyCloudflareOutputMutationPolicy,
+} = verifierRequire('@modern-js/app-tools/cloudflare-output-verifier');
+
+let failed = false;
+for (const target of targets) {
+  const result = await verifyCloudflareOutput({
+    outputDirectory: target.outputDirectory,
+    importWorker: true,
+  });
+  if (result.ok) {
+    console.log(\`[ultramodern] Cloudflare output verified: \${target.label}\`);
+  } else {
+    failed = true;
+    console.error(\`[ultramodern] Cloudflare output failed: \${target.label}\`);
+    for (const issue of result.issues) {
+      console.error(\`- \${issue.code}: \${issue.message}\${issue.path ? \` (\${issue.path})\` : ''}\`);
+    }
+  }
+}
+
+if (scanRoots.length > 0) {
+  const policyResult = await verifyCloudflareOutputMutationPolicy({ scanRoots, excludePaths });
+  if (!policyResult.ok) {
+    failed = true;
+    console.error('[ultramodern] generated-output mutation policy failed');
+    for (const issue of policyResult.issues) {
+      console.error(\`- \${issue.code}: \${issue.message}\${issue.path ? \` (\${issue.path})\` : ''}\`);
+    }
+  }
+}
+
+process.exit(failed ? 1 : 0);
+`;
+function runCloudflareOutputVerify(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(`Usage:
+  ultramodern-create ultramodern cloudflare-output-verify [--app <id> | --output <dir>]
+
+Verifies generated Cloudflare output against the UltraModern worker contract.
+Without --app or --output, every generated workspace app is verified.
+`);
+        return 0;
+    }
+    const source = renderCloudflareOutputVerifyModule({
+        workspaceRoot: context.workspaceRoot,
+        targets: resolveCloudflareOutputVerifyTargets(args, context),
+        excludePaths: [
+            node_path.join(context.workspaceRoot, "scripts", 'validate-ultramodern-workspace.mts')
+        ]
+    });
+    return runRenderedModule(source, context);
+}
+export { runCloudflareOutputVerify };

package/dist/esm-node/ultramodern-tooling/commands/context.js

@@ -0,0 +1,67 @@
+import "node:module";
+import { spawnSync } from "node:child_process";
+import node_fs from "node:fs";
+import node_os from "node:os";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveCreatePackageRoot } from "../../create-package-root.js";
+import { generatedToolingCommandList, generatedToolingCommands } from "../../ultramodern-workspace/tooling-command-catalog.js";
+const context_dirname = node_path.dirname(fileURLToPath(import.meta.url));
+const createPackageRoot = resolveCreatePackageRoot(context_dirname);
+function printHelp() {
+    const commands = [
+        ...generatedToolingCommandList().map((command)=>`  ${command}`),
+        '  skills install',
+        '  skills check'
+    ].join('\n');
+    process.stdout.write(`Usage:
+  ultramodern-create ultramodern <command> [args]
+
+Commands:
+${commands}
+`);
+}
+function spawnNodeScript(relativeScriptPath, args, context, options = {}) {
+    const scriptPath = node_path.join(createPackageRoot, relativeScriptPath);
+    const result = spawnSync(process.execPath, [
+        scriptPath,
+        ...args
+    ], {
+        cwd: options.cwd ?? context.workspaceRoot,
+        env: {
+            ...process.env,
+            ULTRAMODERN_WORKSPACE_ROOT: context.workspaceRoot
+        },
+        stdio: 'inherit'
+    });
+    if (result.error) throw result.error;
+    return result.status ?? 1;
+}
+function runTemplateBackedToolingCommand(command, args, context) {
+    const toolingCommand = generatedToolingCommands.find((candidate)=>candidate.command === command);
+    if (!toolingCommand?.templatePath) return;
+    return spawnNodeScript(toolingCommand.templatePath, args, context, {
+        cwd: 'invocation' === toolingCommand.cwd ? context.invocationCwd : context.workspaceRoot
+    });
+}
+function runRenderedModule(source, context) {
+    const tempDir = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'ultramodern-tool-'));
+    const tempFile = node_path.join(tempDir, 'command.mjs');
+    try {
+        node_fs.writeFileSync(tempFile, source, 'utf-8');
+        const result = spawnSync(process.execPath, [
+            tempFile
+        ], {
+            cwd: context.workspaceRoot,
+            stdio: 'inherit'
+        });
+        if (result.error) throw result.error;
+        return result.status ?? 1;
+    } finally{
+        node_fs.rmSync(tempDir, {
+            force: true,
+            recursive: true
+        });
+    }
+}
+export { createPackageRoot, printHelp, runRenderedModule, runTemplateBackedToolingCommand, spawnNodeScript };

package/dist/esm-node/ultramodern-tooling/commands/mf-types.js

@@ -0,0 +1,18 @@
+import "node:module";
+import { validateModuleFederationTypes } from "../../ultramodern-workspace/mf-validation.js";
+function runMfTypes(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(`Usage:
+  ultramodern-create ultramodern mf-types [app-dir...]
+
+Checks real Module Federation config files and DTS archives for exposed apps.
+`);
+        return 0;
+    }
+    validateModuleFederationTypes({
+        workspaceRoot: context.workspaceRoot,
+        appDirs: args.length > 0 ? args : void 0
+    });
+    return 0;
+}
+export { runMfTypes };

package/dist/esm-node/ultramodern-tooling/commands/migrate-strict-effect/api-metadata.js

@@ -0,0 +1,155 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { readJsonFile, writeJsonFile } from "./io.js";
+import { updateUltramodernConfigToolchain } from "./toolchain-pins.js";
+const packageSourceOwnedKeys = [
+    'strategy',
+    'modernPackageVersion',
+    'registry',
+    'aliasScope',
+    'aliasPackageNamePrefix'
+];
+const retiredPackageSourceKeys = [
+    'generatedWorkspacePackages',
+    'metadata',
+    'modernPackages'
+];
+function requireObject(value, label) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) throw new Error(`${label} must be an object.`);
+    return value;
+}
+function reconcilePackageSourceMetadata(value, { canonical, label, ownedKeys }) {
+    const existing = void 0 === value ? {} : requireObject(value, label);
+    const frameworkOwnedKeys = new Set([
+        ...ownedKeys,
+        ...retiredPackageSourceKeys
+    ]);
+    for (const key of Object.keys(canonical))if (!frameworkOwnedKeys.has(key)) throw new Error(`${label} canonical key ${key} is not framework-owned.`);
+    const extensionEntries = Object.entries(existing).filter(([key])=>!frameworkOwnedKeys.has(key));
+    const next = Object.fromEntries(extensionEntries);
+    Object.assign(next, canonical);
+    const expectedKeys = [
+        ...extensionEntries.map(([key])=>key),
+        ...Object.keys(canonical)
+    ];
+    const actualKeys = Object.keys(next);
+    if (actualKeys.length !== expectedKeys.length || actualKeys.some((key, index)=>key !== expectedKeys[index])) throw new Error(`${label} could not establish exact package-source keys.`);
+    for (const [key, extensionValue] of extensionEntries)if (!Object.is(next[key], extensionValue)) throw new Error(`${label} could not preserve extension key ${key}.`);
+    for (const key of frameworkOwnedKeys){
+        const shouldExist = Object.hasOwn(canonical, key);
+        if (Object.hasOwn(next, key) !== shouldExist || shouldExist && !Object.is(next[key], canonical[key])) throw new Error(`${label} could not establish exact postcondition for ${key}.`);
+    }
+    return next;
+}
+function reconcileCompactPackageSourceMetadata(value, packageSource) {
+    return reconcilePackageSourceMetadata(value, {
+        canonical: {
+            strategy: packageSource.strategy,
+            modernPackageVersion: packageSource.modernPackageVersion,
+            ...packageSource.registry ? {
+                registry: packageSource.registry
+            } : {},
+            ...packageSource.aliasScope ? {
+                aliasScope: packageSource.aliasScope
+            } : {},
+            ...packageSource.aliasPackageNamePrefix ? {
+                aliasPackageNamePrefix: packageSource.aliasPackageNamePrefix
+            } : {}
+        },
+        label: 'packageSource',
+        ownedKeys: packageSourceOwnedKeys
+    });
+}
+function normalizeStrictEffectApiMetadata(value) {
+    let changed = false;
+    const backendFederation = value.backendFederation;
+    if (backendFederation && 'object' == typeof backendFederation && !Array.isArray(backendFederation) && Object.hasOwn(backendFederation, 'entry')) {
+        delete backendFederation.entry;
+        changed = true;
+    }
+    const api = value.api;
+    if (!api || 'object' != typeof api || Array.isArray(api)) return changed;
+    if (void 0 !== api.backendFederation) {
+        delete api.backendFederation;
+        changed = true;
+    }
+    const oldEffect = api.effect;
+    if (oldEffect && 'object' == typeof oldEffect && !Array.isArray(oldEffect)) {
+        if (void 0 === api.stem && 'string' == typeof oldEffect.stem) {
+            api.stem = oldEffect.stem;
+            changed = true;
+        }
+        if (void 0 === api.prefix && 'string' == typeof oldEffect.prefix) {
+            api.prefix = oldEffect.prefix;
+            changed = true;
+        }
+        if (void 0 === api.consumedBy && Array.isArray(oldEffect.consumedBy)) {
+            api.consumedBy = oldEffect.consumedBy;
+            changed = true;
+        }
+        delete api.effect;
+        changed = true;
+    }
+    if ('effect' !== api.runtime) {
+        api.runtime = 'effect';
+        changed = true;
+    }
+    if (api.bff && 'object' == typeof api.bff && !Array.isArray(api.bff)) {
+        if (true !== api.bff.strictEffectApproach) {
+            api.bff.strictEffectApproach = true;
+            changed = true;
+        }
+    }
+    if ('string' == typeof value.path) {
+        const directServerEntry = `${value.path}/api/index.ts`;
+        if ('string' == typeof api.serverEntry && /\/api\/effect\/index\.[cm]?[jt]sx?$/u.test(api.serverEntry)) {
+            api.serverEntry = directServerEntry;
+            changed = true;
+        }
+        if (api.contract && 'object' == typeof api.contract && !Array.isArray(api.contract)) {
+            if ('./shared/effect/api' === api.contract.export) {
+                api.contract.export = './api';
+                changed = true;
+            }
+            if ('string' == typeof api.contract.path && /\/shared\/effect\/api\.[cm]?[jt]sx?$/u.test(api.contract.path)) {
+                api.contract.path = `${value.path}/shared/api.ts`;
+                changed = true;
+            }
+        }
+        if (api.client && 'object' == typeof api.client && !Array.isArray(api.client)) {
+            if ('./effect/client' === api.client.export) {
+                api.client.export = './api/client';
+                changed = true;
+            }
+            if ('string' == typeof api.client.path && /\/src\/effect\/[^/]+-client\.[cm]?ts$/u.test(api.client.path)) {
+                const basename = node_path.basename(api.client.path);
+                api.client.path = `${value.path}/src/api/${basename}`;
+                changed = true;
+            }
+        }
+        if (void 0 === api.serverEntry && 'effect' === api.runtime) {
+            api.serverEntry = directServerEntry;
+            changed = true;
+        }
+    }
+    return changed;
+}
+function updateUltramodernConfig(io, config, packageSource) {
+    const configPath = node_path.join(io.workspaceRoot, '.modernjs/ultramodern.json');
+    config.packageSource = reconcileCompactPackageSourceMetadata(config.packageSource, packageSource);
+    if (config.generator && 'object' == typeof config.generator && !Array.isArray(config.generator) && 'string' == typeof config.generator.version) config.generator.version = packageSource.modernPackageVersion;
+    updateUltramodernConfigToolchain(config);
+    for (const app of config.topology?.apps ?? [])if (app && 'object' == typeof app && !Array.isArray(app)) normalizeStrictEffectApiMetadata(app);
+    writeJsonFile(io, configPath, config);
+}
+function updateReferenceTopology(io) {
+    const topologyPath = node_path.join(io.workspaceRoot, 'topology/reference-topology.json');
+    if (!node_fs.existsSync(topologyPath)) return false;
+    const topology = readJsonFile(topologyPath);
+    let changed = false;
+    for (const vertical of topology.verticals ?? [])if (vertical && 'object' == typeof vertical && !Array.isArray(vertical)) changed = normalizeStrictEffectApiMetadata(vertical) || changed;
+    if (changed) writeJsonFile(io, topologyPath, topology);
+    return changed;
+}
+export { reconcileCompactPackageSourceMetadata, reconcilePackageSourceMetadata, updateReferenceTopology, updateUltramodernConfig };

package/dist/esm-node/ultramodern-tooling/commands/migrate-strict-effect/declaration-patches.js

@@ -0,0 +1,10 @@
+import "node:module";
+import { ensureGeneratedPatchFile, removeGeneratedPatchFileIfUnchanged } from "./generated-patches.js";
+import { drizzleOrmDeclarationPatchPath, drizzleOrmDeclarationPatchSourcePath, requiredGeneratedPatches } from "./policy-constants.js";
+function ensureGeneratedDeclarationPatches(io, options) {
+    let changed = false;
+    for (const patch of requiredGeneratedPatches)changed = ensureGeneratedPatchFile(io, patch.path, patch.sourcePath) || changed;
+    changed = options.includeDrizzleOrmPatch ? ensureGeneratedPatchFile(io, drizzleOrmDeclarationPatchPath, drizzleOrmDeclarationPatchSourcePath) || changed : removeGeneratedPatchFileIfUnchanged(io, drizzleOrmDeclarationPatchPath, drizzleOrmDeclarationPatchSourcePath) || changed;
+    return changed;
+}
+export { ensureGeneratedDeclarationPatches };

package/dist/esm-node/ultramodern-tooling/commands/migrate-strict-effect/dependency-usage.js

@@ -0,0 +1,64 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { semver } from "@modern-js/utils";
+import * as __rspack_external__pnpm_yaml_js_177b7343 from "./pnpm-yaml.js";
+function workspaceUsesDependency(workspaceRoot, packageName, exactVersion) {
+    const packageJsonPaths = [
+        node_path.join(workspaceRoot, 'package.json')
+    ];
+    let compatibleRangeDeclared = false;
+    for (const workspaceDir of [
+        'apps',
+        'verticals',
+        'packages'
+    ]){
+        const absoluteWorkspaceDir = node_path.join(workspaceRoot, workspaceDir);
+        if (node_fs.existsSync(absoluteWorkspaceDir)) for (const entry of node_fs.readdirSync(absoluteWorkspaceDir, {
+            withFileTypes: true
+        })){
+            if (!entry.isDirectory()) continue;
+            const packageJsonPath = node_path.join(absoluteWorkspaceDir, entry.name, 'package.json');
+            if (node_fs.existsSync(packageJsonPath)) packageJsonPaths.push(packageJsonPath);
+        }
+    }
+    const aliasPrefix = `npm:${packageName}@`;
+    for (const packageJsonPath of packageJsonPaths){
+        const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf-8'));
+        for (const field of [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies'
+        ]){
+            const dependencies = packageJson[field];
+            if (dependencies && 'object' == typeof dependencies) {
+                if (Object.prototype.hasOwnProperty.call(dependencies, packageName)) {
+                    const specifier = dependencies[packageName];
+                    if (void 0 === exactVersion || specifier === exactVersion || specifier === `${aliasPrefix}${exactVersion}`) return true;
+                    if ('string' == typeof specifier && semver.satisfies(exactVersion, specifier, {
+                        includePrerelease: true
+                    })) compatibleRangeDeclared = true;
+                }
+                for (const specifier of Object.values(dependencies)){
+                    if ('string' != typeof specifier || !specifier.startsWith(aliasPrefix)) continue;
+                    const aliasedVersion = specifier.slice(aliasPrefix.length);
+                    if (void 0 === exactVersion || aliasedVersion === exactVersion) return true;
+                    if (semver.satisfies(exactVersion, aliasedVersion, {
+                        includePrerelease: true
+                    })) compatibleRangeDeclared = true;
+                }
+            }
+        }
+    }
+    if (!exactVersion || !compatibleRangeDeclared) return false;
+    const lockfilePath = node_path.join(workspaceRoot, 'pnpm-lock.yaml');
+    if (!node_fs.existsSync(lockfilePath)) return true;
+    try {
+        const closure = __rspack_external__pnpm_yaml_js_177b7343.discoverReachablePnpmLockReleaseAgeClosure(__rspack_external__pnpm_yaml_js_177b7343.parsePnpmWorkspaceYaml(node_fs.readFileSync(lockfilePath, 'utf-8'), lockfilePath).document);
+        return closure.unresolved.length > 0 || closure.candidates.some((candidate)=>candidate.packageName === packageName && candidate.version === exactVersion);
+    } catch  {
+        return true;
+    }
+}
+export { workspaceUsesDependency };

package/dist/esm-node/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-backend-federation.js

@@ -0,0 +1,8 @@
+import "node:module";
+import node_path from "node:path";
+import { createBackendFederationContractFile } from "../../../ultramodern-workspace/backend-federation.js";
+import { allWorkspaceAppsFromToolingConfig } from "../../config.js";
+function updateGeneratedBackendFederationContractFiles(io, config) {
+    for (const app of allWorkspaceAppsFromToolingConfig(config))if (app.api) io.writeGenerated(node_path.join(io.workspaceRoot, app.directory, 'api/backend-federation.ts'), createBackendFederationContractFile(app));
+}
+export { updateGeneratedBackendFederationContractFiles };

package/dist/esm-node/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-build-identity.js

@@ -0,0 +1,48 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { createUltramodernBuildArtifactJson, createUltramodernBuildModule, createUltramodernBuildReexportModule } from "../../../ultramodern-workspace/module-federation.js";
+import { allWorkspaceAppsFromToolingConfig } from "../../config.js";
+const legacyApiMarkerPattern = /export const ultramodernApiMarker\s*=\s*\{[\s\S]*?\}\s+as const;\n?/u;
+const markerSchemaPattern = /(export const [A-Za-z_$][\w$]*MarkerSchema(?:\s*:[^=]+)?\s*=\s*Schema\.Struct\(\{\n)([\s\S]*?)(\n\}\);)/u;
+function rewriteLegacyApiMarkerBinding(source) {
+    return source.replace(legacyApiMarkerPattern, "export { ultramodernApiMarker } from './ultramodern-build.ts';\n");
+}
+function rewriteApiMarkerIdentitySchema(source) {
+    const match = source.match(markerSchemaPattern);
+    if (!match) return source;
+    let body = match[2];
+    if (![
+        'appId',
+        'build',
+        'deployProfile',
+        'packageName',
+        'surface',
+        'version'
+    ].every((field)=>new RegExp(`^\\s+${field}: Schema\\.String,\\s*$`, 'mu').test(body))) return source;
+    for (const [anchor, field] of [
+        [
+            'build',
+            'buildMarker'
+        ],
+        [
+            'packageName',
+            'sourceRevision'
+        ],
+        [
+            'surface',
+            'unitId'
+        ]
+    ])if (!new RegExp(`^\\s+${field}: Schema\\.String,\\s*$`, 'mu').test(body)) body = body.replace(new RegExp(`^(\\s+)${anchor}: Schema\\.String,\\s*$`, 'mu'), `$&\n$1${field}: Schema.String,`);
+    return source.replace(markerSchemaPattern, (_full, prefix, _body, suffix)=>`${prefix}${body}${suffix}`);
+}
+function updateGeneratedBuildIdentityModules(io, config) {
+    for (const app of allWorkspaceAppsFromToolingConfig(config)){
+        const sharedApiPath = node_path.join(io.workspaceRoot, app.directory, 'shared/api.ts');
+        if (app.api && node_fs.existsSync(sharedApiPath)) io.write(sharedApiPath, rewriteApiMarkerIdentitySchema(rewriteLegacyApiMarkerBinding(node_fs.readFileSync(sharedApiPath, 'utf-8'))));
+        io.writeGenerated(node_path.join(io.workspaceRoot, app.directory, 'src/ultramodern-build.ts'), createUltramodernBuildReexportModule());
+        io.writeGenerated(node_path.join(io.workspaceRoot, app.directory, 'shared/ultramodern-build.ts'), createUltramodernBuildModule(config.workspace.packageScope, app));
+        io.write(node_path.join(io.workspaceRoot, app.directory, 'shared/ultramodern-build.json'), createUltramodernBuildArtifactJson(config.workspace.packageScope, app));
+    }
+}
+export { rewriteApiMarkerIdentitySchema, rewriteLegacyApiMarkerBinding, updateGeneratedBuildIdentityModules };