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

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:
+  modern-js-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:
+  modern-js-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,107 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { readJsonFile, writeJsonFile } from "./io.js";
+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 (void 0 !== api.runtime && '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 = {
+        strategy: packageSource.strategy,
+        modernPackageVersion: packageSource.modernPackageVersion,
+        ...packageSource.registry ? {
+            registry: packageSource.registry
+        } : {},
+        ...packageSource.aliasScope ? {
+            aliasScope: packageSource.aliasScope
+        } : {},
+        ...packageSource.aliasPackageNamePrefix ? {
+            aliasPackageNamePrefix: packageSource.aliasPackageNamePrefix
+        } : {}
+    };
+    if (config.generator && 'object' == typeof config.generator && !Array.isArray(config.generator) && 'string' == typeof config.generator.version) config.generator.version = packageSource.modernPackageVersion;
+    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 { updateReferenceTopology, updateUltramodernConfig };

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

@@ -0,0 +1,12 @@
+import "node:module";
+import { ensureGeneratedPatchFile, removeGeneratedPatchFileIfUnchanged } from "./generated-patches.js";
+import { drizzleOrmDeclarationPatchPath, drizzleOrmDeclarationPatchSourcePath, effectDeclarationPatchPath, effectDeclarationPatchSourcePath, moduleFederationBridgeReactPatchPath, moduleFederationBridgeReactPatchSourcePath, moduleFederationModernJsPatchPath, moduleFederationModernJsPatchSourcePath } from "./policy-constants.js";
+function ensureGeneratedDeclarationPatches(io, options) {
+    let changed = false;
+    changed = ensureGeneratedPatchFile(io, moduleFederationModernJsPatchPath, moduleFederationModernJsPatchSourcePath) || changed;
+    changed = ensureGeneratedPatchFile(io, moduleFederationBridgeReactPatchPath, moduleFederationBridgeReactPatchSourcePath) || changed;
+    changed = ensureGeneratedPatchFile(io, effectDeclarationPatchPath, effectDeclarationPatchSourcePath) || 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,39 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+function workspaceUsesDependency(workspaceRoot, packageName) {
+    const packageJsonPaths = [
+        node_path.join(workspaceRoot, 'package.json')
+    ];
+    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);
+        }
+    }
+    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)) return true;
+                for (const specifier of Object.values(dependencies))if ('string' == typeof specifier && specifier.startsWith(`npm:${packageName}@`)) return true;
+            }
+        }
+    }
+    return false;
+}
+export { workspaceUsesDependency };

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

@@ -0,0 +1,11 @@
+import "node:module";
+import node_path from "node:path";
+import { createBackendFederationContractFile } from "../../../ultramodern-workspace/backend-federation.js";
+import { workspaceAppsFromToolingConfig } from "../../config.js";
+import { writeTextIfChanged } from "./io.js";
+function updateGeneratedBackendFederationContractFiles(io, config) {
+    let changed = false;
+    for (const app of workspaceAppsFromToolingConfig(config))if (app.api) changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'api/backend-federation.ts'), createBackendFederationContractFile(app)) || changed;
+    return changed;
+}
+export { updateGeneratedBackendFederationContractFiles };

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

@@ -0,0 +1,15 @@
+import "node:module";
+import node_path from "node:path";
+import { createUltramodernBuildArtifactJson, createUltramodernBuildModule, createUltramodernBuildReexportModule } from "../../../ultramodern-workspace/module-federation.js";
+import { workspaceAppsFromToolingConfig } from "../../config.js";
+import { writeTextIfChanged } from "./io.js";
+function updateGeneratedBuildIdentityModules(io, config) {
+    let changed = false;
+    for (const app of workspaceAppsFromToolingConfig(config)){
+        changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'src/ultramodern-build.ts'), createUltramodernBuildReexportModule()) || changed;
+        changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'shared/ultramodern-build.ts'), createUltramodernBuildModule()) || changed;
+        changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'shared/ultramodern-build.json'), createUltramodernBuildArtifactJson(config.workspace.packageScope, app)) || changed;
+    }
+    return changed;
+}
+export { updateGeneratedBuildIdentityModules };

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

@@ -0,0 +1,13 @@
+import "node:module";
+import node_path from "node:path";
+import { createAppModernConfig } from "../../../ultramodern-workspace/module-federation.js";
+import { workspaceAppsFromToolingConfig } from "../../config.js";
+import { writeTextIfChanged } from "./io.js";
+function updateGeneratedModernConfigs(io, config) {
+    let changed = false;
+    const apps = workspaceAppsFromToolingConfig(config);
+    const remotes = apps.filter((app)=>'shell' !== app.kind);
+    for (const app of apps)changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'modern.config.ts'), createAppModernConfig(config.workspace.packageScope, app, remotes)) || changed;
+    return changed;
+}
+export { updateGeneratedModernConfigs };

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

@@ -0,0 +1,84 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+function ensureGeneratedOxfmtIgnorePatterns(io) {
+    const configPath = node_path.join(io.workspaceRoot, 'oxfmt.config.ts');
+    if (!node_fs.existsSync(configPath)) return false;
+    const source = node_fs.readFileSync(configPath, 'utf-8');
+    const requiredPatterns = [
+        '.modernjs',
+        '.output',
+        '**/modern-tanstack/**',
+        '**/routeTree.gen.*'
+    ];
+    const warnUnparseable = ()=>{
+        const message = `Could not update oxfmt.config.ts ignorePatterns automatically; add these entries manually: ${requiredPatterns.join(', ')}.`;
+        if (io.dryRun) io.log(message);
+        else process.stderr.write(`[ultramodern] ${message}\n`);
+    };
+    const anchor = source.indexOf('ignorePatterns:');
+    if (-1 === anchor) {
+        warnUnparseable();
+        return false;
+    }
+    const openBracket = source.indexOf('[', anchor);
+    if (-1 === openBracket) {
+        warnUnparseable();
+        return false;
+    }
+    let depth = 0;
+    let closeBracket = -1;
+    let stringQuote;
+    for(let index = openBracket; index < source.length; index += 1){
+        const char = source[index];
+        if (stringQuote) {
+            if ('\\' === char) index += 1;
+            else if (char === stringQuote) stringQuote = void 0;
+            continue;
+        }
+        if ("'" === char || '"' === char || '`' === char) stringQuote = char;
+        else if ('[' === char) depth += 1;
+        else if (']' === char) {
+            depth -= 1;
+            if (0 === depth) {
+                closeBracket = index;
+                break;
+            }
+        }
+    }
+    if (-1 === closeBracket) {
+        warnUnparseable();
+        return false;
+    }
+    const body = source.slice(openBracket + 1, closeBracket);
+    if (body.includes('...')) {
+        warnUnparseable();
+        return false;
+    }
+    const literalPattern = /(['"`])((?:\\.|(?!\1).)*)\1/g;
+    const existing = new Set();
+    for (const match of body.matchAll(literalPattern))existing.add(match[2]);
+    const missing = requiredPatterns.filter((pattern)=>!existing.has(pattern));
+    if (0 === missing.length) return false;
+    const bodyLines = body.split('\n');
+    let indent = '  ';
+    let quote = "'";
+    for(let index = bodyLines.length - 1; index >= 0; index -= 1){
+        const literal = bodyLines[index].match(/^(\s*)(['"`])/u);
+        if (literal) {
+            indent = literal[1];
+            quote = literal[2];
+            break;
+        }
+    }
+    const head = source.slice(0, closeBracket);
+    const rest = source.slice(closeBracket);
+    const tailMatch = head.match(/(\r?\n[ \t]*)$/u);
+    const tail = tailMatch ? tailMatch[1] : '\n';
+    let bodyContent = tailMatch ? head.slice(0, head.length - tail.length) : head;
+    if (!/[[,]\s*$/u.test(bodyContent)) bodyContent = `${bodyContent},`;
+    const insertionLines = missing.map((pattern)=>`${indent}${quote}${pattern}${quote},`).join('\n');
+    const nextSource = `${bodyContent}\n${insertionLines}${tail}${rest}`;
+    return io.write(configPath, nextSource);
+}
+export { ensureGeneratedOxfmtIgnorePatterns };

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

@@ -0,0 +1,17 @@
+import "node:module";
+import node_path from "node:path";
+import { workspaceAppsFromToolingConfig } from "../../config.js";
+function removeGeneratedFileIfExists(io, relativePath) {
+    return io.remove(node_path.join(io.workspaceRoot, relativePath));
+}
+function removeStaleBackendFederationArtifacts(io, config) {
+    let changed = false;
+    for (const relativePath of [
+        "scripts/generate-node-backend-federation.mts",
+        "scripts/proof-node-backend-federation.mts",
+        "scripts/verify-cloudflare-output.mts"
+    ])changed = removeGeneratedFileIfExists(io, relativePath) || changed;
+    for (const app of workspaceAppsFromToolingConfig(config))changed = removeGeneratedFileIfExists(io, node_path.join(app.directory, 'api/backend-federation.ts')) || changed;
+    return changed;
+}
+export { removeGeneratedFileIfExists, removeStaleBackendFederationArtifacts };

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

@@ -0,0 +1,45 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { createAppEnvDts } from "../../../ultramodern-workspace/app-files.js";
+import { createAppMfTypesTsConfig, createAppTsConfig, createSharedPackageTsConfig, createTsConfigBase } from "../../../ultramodern-workspace/package-json.js";
+import { workspaceAppsFromToolingConfig } from "../../config.js";
+import { writeJsonIfChanged, writeTextIfChanged } from "./io.js";
+function ensureGeneratedIgnoreRules(io) {
+    const gitignorePath = node_path.join(io.workspaceRoot, '.gitignore');
+    const existing = node_fs.existsSync(gitignorePath) ? node_fs.readFileSync(gitignorePath, 'utf-8') : '';
+    const lines = 0 === existing.trimEnd().length ? [] : existing.trimEnd().split(/\r?\n/u);
+    let changed = false;
+    for (const rule of [
+        '.mf/',
+        '**/.mf/',
+        'dist-cloudflare/',
+        '.output/',
+        '**/.output/',
+        '.modern-js/',
+        '**/.modern-js/'
+    ])if (!lines.includes(rule)) {
+        lines.push(rule);
+        changed = true;
+    }
+    if (!changed) return false;
+    return io.write(gitignorePath, `${lines.join('\n')}\n`);
+}
+function updateGeneratedTypeScriptSurfaces(io, config) {
+    let changed = false;
+    const apps = workspaceAppsFromToolingConfig(config);
+    const remotes = apps.filter((app)=>'shell' !== app.kind);
+    changed = writeJsonIfChanged(io, node_path.join(io.workspaceRoot, 'tsconfig.base.json'), createTsConfigBase()) || changed;
+    changed = ensureGeneratedIgnoreRules(io) || changed;
+    for (const sharedPackage of [
+        'packages/shared-contracts',
+        'packages/shared-design-tokens'
+    ])changed = writeJsonIfChanged(io, node_path.join(io.workspaceRoot, sharedPackage, 'tsconfig.json'), createSharedPackageTsConfig(sharedPackage)) || changed;
+    for (const app of apps){
+        changed = writeJsonIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'tsconfig.json'), createAppTsConfig(app, remotes)) || changed;
+        changed = writeJsonIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'tsconfig.mf-types.json'), createAppMfTypesTsConfig(app)) || changed;
+        changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'src/modern-app-env.d.ts'), createAppEnvDts(app, remotes)) || changed;
+    }
+    return changed;
+}
+export { updateGeneratedTypeScriptSurfaces };

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

@@ -0,0 +1,13 @@
+import "node:module";
+import node_path from "node:path";
+import { createZeropsRuntimeMaterializationScript } from "../../../ultramodern-workspace/workspace-scripts.js";
+import { createZeropsYaml } from "../../../ultramodern-workspace/zerops.js";
+import { workspaceAppsFromToolingConfig } from "../../config.js";
+import { writeTextIfChanged } from "./io.js";
+function updateGeneratedZeropsArtifacts(io, config) {
+    const apps = workspaceAppsFromToolingConfig(config);
+    let changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, 'zerops.yaml'), `${createZeropsYaml(config.workspace.packageScope, apps)}\n`);
+    changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, "scripts/materialize-zerops-runtime.mjs"), createZeropsRuntimeMaterializationScript()) || changed;
+    return changed;
+}
+export { updateGeneratedZeropsArtifacts };

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

@@ -0,0 +1,8 @@
+import "node:module";
+export { updateGeneratedBackendFederationContractFiles } from "./generated-artifacts-backend-federation.js";
+export { updateGeneratedBuildIdentityModules } from "./generated-artifacts-build-identity.js";
+export { updateGeneratedModernConfigs } from "./generated-artifacts-modern-configs.js";
+export { ensureGeneratedOxfmtIgnorePatterns } from "./generated-artifacts-oxfmt.js";
+export { removeGeneratedFileIfExists, removeStaleBackendFederationArtifacts } from "./generated-artifacts-removal.js";
+export { updateGeneratedTypeScriptSurfaces } from "./generated-artifacts-typescript.js";
+export { updateGeneratedZeropsArtifacts } from "./generated-artifacts-zerops.js";

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

@@ -0,0 +1,16 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+function ensureGeneratedPatchFile(io, relativePatchPath, sourcePatchPath) {
+    const targetPath = node_path.join(io.workspaceRoot, relativePatchPath);
+    const patch = node_fs.readFileSync(sourcePatchPath, 'utf-8');
+    return io.write(targetPath, patch);
+}
+function removeGeneratedPatchFileIfUnchanged(io, relativePatchPath, sourcePatchPath) {
+    const targetPath = node_path.join(io.workspaceRoot, relativePatchPath);
+    if (!node_fs.existsSync(targetPath)) return false;
+    const patch = node_fs.readFileSync(sourcePatchPath, 'utf-8');
+    if (node_fs.readFileSync(targetPath, 'utf-8') !== patch) return false;
+    return io.remove(targetPath);
+}
+export { ensureGeneratedPatchFile, removeGeneratedPatchFileIfUnchanged };

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

@@ -0,0 +1,17 @@
+import "node:module";
+const migrateStrictEffectHelp = `Usage:
+  modern-js-create ultramodern migrate-strict-effect --version <version> [--dry-run] [--skip-install]
+
+Updates generated UltraModern package-source metadata, Modern package aliases,
+framework-owned toolchain pins, direct Effect API topology metadata, strict
+Effect pnpm overrides/trust policy, framework-owned TypeScript config
+surfaces, and the pnpm lockfile. Source code still has to pass pnpm api:check
+and pnpm contract:check.
+
+When the compact config is absent but legacy UltraModern 3.2 metadata is
+present, the compact config is synthesized from it first. Shell-only
+workspaces skip the backend-federation and Zerops runtime stages. Pass
+--dry-run to print the planned filesystem changes without writing anything
+(implies --skip-install).
+`;
+export { migrateStrictEffectHelp };

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

@@ -0,0 +1,15 @@
+import "node:module";
+import { spawnSync } from "node:child_process";
+function runPnpmLockfileRefresh(context) {
+    const result = spawnSync('pnpm', [
+        'install',
+        '--lockfile-only',
+        "--ignore-scripts"
+    ], {
+        cwd: context.workspaceRoot,
+        stdio: 'inherit'
+    });
+    if (result.error) throw result.error;
+    return result.status ?? 1;
+}
+export { runPnpmLockfileRefresh };

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

@@ -0,0 +1,70 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+function createMigrationIo(workspaceRoot, dryRun) {
+    const plan = [];
+    const rel = (p)=>(node_path.relative(workspaceRoot, p) || node_path.basename(p)).split(node_path.sep).join('/');
+    return {
+        workspaceRoot,
+        dryRun,
+        plan,
+        write (filePath, content) {
+            if (node_fs.existsSync(filePath) && node_fs.readFileSync(filePath, 'utf-8') === content) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would write ${rel(filePath)}`);
+                return true;
+            }
+            node_fs.mkdirSync(node_path.dirname(filePath), {
+                recursive: true
+            });
+            node_fs.writeFileSync(filePath, content, 'utf-8');
+            return true;
+        },
+        remove (filePath) {
+            if (!node_fs.existsSync(filePath)) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would delete ${rel(filePath)}`);
+                return true;
+            }
+            node_fs.rmSync(filePath);
+            return true;
+        },
+        log (message) {
+            if (dryRun) plan.push(`[dry-run] ${message}`);
+            else process.stdout.write(`[ultramodern] ${message}\n`);
+        }
+    };
+}
+function readJsonFile(filePath) {
+    return JSON.parse(node_fs.readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeJsonIfChanged(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeTextIfChanged(io, filePath, value) {
+    return io.write(filePath, value);
+}
+function listWorkspacePackageFiles(workspaceRoot) {
+    const packageFiles = [
+        'package.json'
+    ];
+    for (const directory of [
+        'apps',
+        'verticals',
+        'packages'
+    ]){
+        const absoluteDirectory = node_path.join(workspaceRoot, directory);
+        if (node_fs.existsSync(absoluteDirectory)) for (const entry of node_fs.readdirSync(absoluteDirectory, {
+            withFileTypes: true
+        })){
+            if (!entry.isDirectory()) continue;
+            const packageFile = `${directory}/${entry.name}/package.json`;
+            if (node_fs.existsSync(node_path.join(workspaceRoot, packageFile))) packageFiles.push(packageFile);
+        }
+    }
+    return packageFiles;
+}
+export { createMigrationIo, listWorkspacePackageFiles, readJsonFile, writeJsonFile, writeJsonIfChanged, writeTextIfChanged };