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

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

@@ -1,386 +0,0 @@
-import "node:module";
-import node_fs from "node:fs";
-import node_os from "node:os";
-import node_path from "node:path";
-import { formatGeneratedSourceCandidates } from "../../../ultramodern-workspace/fs-io.js";
-const stagingExcludedEntries = new Set([
-    '.git',
-    '.nx',
-    '.output',
-    'coverage',
-    'dist',
-    'node_modules'
-]);
-const stagingGeneratedOutputEntries = new Set([
-    'coverage',
-    'dist'
-]);
-const stagingWorkspacePackageDirectories = new Set([
-    'apps',
-    'packages',
-    'verticals'
-]);
-function lstatIfExists(filePath) {
-    try {
-        return node_fs.lstatSync(filePath);
-    } catch (error) {
-        if ('ENOENT' === error.code) return;
-        throw error;
-    }
-}
-function symlinkTypeForPath(filePath) {
-    return node_fs.statSync(filePath, {
-        throwIfNoEntry: false
-    })?.isDirectory() ? 'win32' === process.platform ? 'junction' : 'dir' : 'file';
-}
-function isPathInsideRoot(rootPath, targetPath) {
-    const relativePath = node_path.relative(rootPath, targetPath);
-    return '' === relativePath || !relativePath.startsWith(`..${node_path.sep}`) && '..' !== relativePath && !node_path.isAbsolute(relativePath);
-}
-function resolvePotentialRealPath(filePath, visitedSymlinks = new Set()) {
-    const absolutePath = node_path.resolve(filePath);
-    let existingAncestor = absolutePath;
-    while(!lstatIfExists(existingAncestor)){
-        const parentPath = node_path.dirname(existingAncestor);
-        if (parentPath === existingAncestor) return absolutePath;
-        existingAncestor = parentPath;
-    }
-    let realAncestor;
-    try {
-        realAncestor = node_fs.realpathSync.native(existingAncestor);
-    } catch (error) {
-        const ancestorStat = lstatIfExists(existingAncestor);
-        if (!ancestorStat?.isSymbolicLink()) throw error;
-        if (visitedSymlinks.has(existingAncestor)) throw new Error(`Refusing to follow cyclic migration symlink: ${existingAncestor}`);
-        visitedSymlinks.add(existingAncestor);
-        realAncestor = resolvePotentialRealPath(node_path.resolve(node_path.dirname(existingAncestor), node_fs.readlinkSync(existingAncestor)), visitedSymlinks);
-    }
-    return node_path.resolve(realAncestor, node_path.relative(existingAncestor, absolutePath));
-}
-function capturePath(filePath) {
-    const stat = lstatIfExists(filePath);
-    if (!stat) return;
-    const mode = 4095 & stat.mode;
-    if (stat.isFile()) return {
-        content: node_fs.readFileSync(filePath),
-        mode,
-        type: 'file'
-    };
-    if (stat.isDirectory()) {
-        const entries = new Map();
-        for (const entry of node_fs.readdirSync(filePath).sort((left, right)=>left.localeCompare(right))){
-            const snapshot = capturePath(node_path.join(filePath, entry));
-            if (snapshot) entries.set(entry, snapshot);
-        }
-        return {
-            entries,
-            mode,
-            type: 'directory'
-        };
-    }
-    if (stat.isSymbolicLink()) return {
-        linkType: symlinkTypeForPath(filePath),
-        mode,
-        target: node_fs.readlinkSync(filePath),
-        type: 'symlink'
-    };
-    throw new Error(`Unsupported migration transaction path: ${filePath}`);
-}
-function removePath(filePath) {
-    node_fs.rmSync(filePath, {
-        force: true,
-        recursive: true
-    });
-}
-function chmodSymlinkIfSupported(filePath, mode) {
-    if ('function' == typeof node_fs.lchmodSync) node_fs.lchmodSync(filePath, mode);
-}
-function restorePath(filePath, snapshot) {
-    if (!snapshot) return void removePath(filePath);
-    const current = lstatIfExists(filePath);
-    if ('file' === snapshot.type) {
-        if (!current?.isFile() || current.isSymbolicLink()) {
-            removePath(filePath);
-            node_fs.mkdirSync(node_path.dirname(filePath), {
-                recursive: true
-            });
-        }
-        node_fs.writeFileSync(filePath, snapshot.content);
-        node_fs.chmodSync(filePath, snapshot.mode);
-        return;
-    }
-    if ('symlink' === snapshot.type) {
-        if (!current?.isSymbolicLink() || node_fs.readlinkSync(filePath) !== snapshot.target || symlinkTypeForPath(filePath) !== snapshot.linkType) {
-            removePath(filePath);
-            node_fs.mkdirSync(node_path.dirname(filePath), {
-                recursive: true
-            });
-            node_fs.symlinkSync(snapshot.target, filePath, snapshot.linkType);
-        }
-        chmodSymlinkIfSupported(filePath, snapshot.mode);
-        return;
-    }
-    if (!current?.isDirectory() || current.isSymbolicLink()) {
-        removePath(filePath);
-        node_fs.mkdirSync(filePath, {
-            recursive: true
-        });
-    }
-    for (const entry of node_fs.readdirSync(filePath))if (!snapshot.entries.has(entry)) removePath(node_path.join(filePath, entry));
-    for (const [entry, childSnapshot] of snapshot.entries)restorePath(node_path.join(filePath, entry), childSnapshot);
-    node_fs.chmodSync(filePath, snapshot.mode);
-}
-function copyWorkspaceEntry(sourcePath, destinationPath, sourceWorkspaceRoot, stagedWorkspaceRoot, sourceWorkspaceAliases) {
-    const stat = node_fs.lstatSync(sourcePath);
-    if (stat.isDirectory()) {
-        node_fs.mkdirSync(destinationPath, {
-            mode: 4095 & stat.mode
-        });
-        const relativeSourcePath = node_path.relative(sourceWorkspaceRoot, sourcePath);
-        for (const entry of node_fs.readdirSync(sourcePath)){
-            const isNamedWorkspacePackage = stagingWorkspacePackageDirectories.has(relativeSourcePath) && stagingGeneratedOutputEntries.has(entry);
-            if (!stagingExcludedEntries.has(entry) || isNamedWorkspacePackage) copyWorkspaceEntry(node_path.join(sourcePath, entry), node_path.join(destinationPath, entry), sourceWorkspaceRoot, stagedWorkspaceRoot, sourceWorkspaceAliases);
-        }
-        node_fs.chmodSync(destinationPath, 4095 & stat.mode);
-        return;
-    }
-    if (stat.isFile()) {
-        node_fs.copyFileSync(sourcePath, destinationPath, node_fs.constants.COPYFILE_FICLONE);
-        node_fs.chmodSync(destinationPath, 4095 & stat.mode);
-        return;
-    }
-    if (stat.isSymbolicLink()) {
-        const target = node_fs.readlinkSync(sourcePath);
-        const stagedTarget = node_path.isAbsolute(target) ? relocateWorkspacePath(sourceWorkspaceAliases, stagedWorkspaceRoot, target) : target;
-        node_fs.symlinkSync(stagedTarget, destinationPath, symlinkTypeForPath(sourcePath));
-        chmodSymlinkIfSupported(destinationPath, 4095 & stat.mode);
-        return;
-    }
-    throw new Error(`Unsupported migration staging path: ${sourcePath}`);
-}
-function relocateWorkspacePath(sourceWorkspaceRoots, stagedWorkspaceRoot, sourcePath) {
-    for (const sourceWorkspaceRoot of sourceWorkspaceRoots){
-        const relativePath = node_path.relative(sourceWorkspaceRoot, sourcePath);
-        if (isPathInsideRoot(sourceWorkspaceRoot, sourcePath)) return node_path.join(stagedWorkspaceRoot, relativePath);
-    }
-    return sourcePath;
-}
-function isPromiseLike(value) {
-    return ('object' == typeof value || 'function' == typeof value) && null !== value && 'function' == typeof value.then;
-}
-function createMigrationIoWithBehavior(workspaceRoot, dryRun, behavior) {
-    const absoluteWorkspaceRoot = node_path.resolve(workspaceRoot);
-    const realWorkspaceRoot = resolvePotentialRealPath(absoluteWorkspaceRoot);
-    const plan = [];
-    let activeTransaction;
-    const rel = (p)=>(node_path.relative(absoluteWorkspaceRoot, p) || node_path.basename(p)).split(node_path.sep).join('/');
-    const assertRealWorkspacePath = (absolutePath, displayedPath, followFinalSymlink = true)=>{
-        const pathToResolve = followFinalSymlink ? absolutePath : node_path.dirname(absolutePath);
-        const realPath = resolvePotentialRealPath(pathToResolve);
-        if (!isPathInsideRoot(realWorkspaceRoot, realPath)) throw new Error(`Refusing to mutate outside workspace: ${displayedPath}`);
-    };
-    const assertWorkspacePath = (filePath, followFinalSymlink = true)=>{
-        const absolutePath = node_path.resolve(filePath);
-        const relativePath = node_path.relative(absoluteWorkspaceRoot, absolutePath);
-        if ('' === relativePath || '..' === relativePath || relativePath.startsWith(`..${node_path.sep}`) || node_path.isAbsolute(relativePath)) throw new Error(`Refusing to mutate outside workspace: ${filePath}`);
-        assertRealWorkspacePath(absolutePath, filePath, followFinalSymlink);
-        return absolutePath;
-    };
-    const captureForRollback = (filePath)=>{
-        if (!activeTransaction || activeTransaction.snapshots.has(filePath)) return;
-        activeTransaction.snapshots.set(filePath, capturePath(filePath));
-        activeTransaction.order.push(filePath);
-    };
-    const captureMissingParents = (filePath)=>{
-        const missing = [];
-        let current = node_path.dirname(filePath);
-        while(current !== absoluteWorkspaceRoot && !lstatIfExists(current)){
-            missing.push(current);
-            current = node_path.dirname(current);
-        }
-        for (const missingDirectory of missing.reverse())captureForRollback(missingDirectory);
-    };
-    const rollback = (transaction)=>{
-        for (const filePath of [
-            ...transaction.order
-        ].reverse())restorePath(filePath, transaction.snapshots.get(filePath));
-    };
-    const finishWithError = (transaction, error)=>{
-        try {
-            rollback(transaction);
-        } catch (rollbackError) {
-            throw new Error(`Migration failed (${String(error)}) and rollback failed (${String(rollbackError)}).`);
-        } finally{
-            activeTransaction = void 0;
-        }
-        throw error;
-    };
-    const formatGeneratedWrites = (generatedPaths)=>{
-        if (0 === generatedPaths.size) return;
-        const relativePaths = [
-            ...generatedPaths
-        ].map((filePath)=>node_path.relative(absoluteWorkspaceRoot, filePath)).sort((left, right)=>left.localeCompare(right));
-        const formattedSources = formatGeneratedSourceCandidates(relativePaths.map((relativePath)=>[
-                relativePath,
-                node_fs.readFileSync(node_path.join(absoluteWorkspaceRoot, relativePath), 'utf-8')
-            ]));
-        for (const [index, relativePath] of relativePaths.entries())io.write(node_path.join(absoluteWorkspaceRoot, relativePath), formattedSources[index]);
-    };
-    const io = {
-        workspaceRoot: absoluteWorkspaceRoot,
-        dryRun,
-        plan,
-        write (filePath, content) {
-            const absolutePath = assertWorkspacePath(filePath);
-            if (node_fs.existsSync(absolutePath) && node_fs.readFileSync(absolutePath, 'utf-8') === content) return false;
-            if (dryRun) {
-                plan.push(`[dry-run] would write ${rel(absolutePath)}`);
-                if (!behavior.materializeDryRun) return true;
-            }
-            captureMissingParents(absolutePath);
-            captureForRollback(absolutePath);
-            const current = lstatIfExists(absolutePath);
-            if (current?.isSymbolicLink()) {
-                const linkedPath = node_path.resolve(node_path.dirname(absolutePath), node_fs.readlinkSync(absolutePath));
-                let targetPath = linkedPath;
-                try {
-                    targetPath = node_fs.realpathSync.native(absolutePath);
-                } catch  {}
-                const absoluteTargetPath = node_path.resolve(targetPath);
-                assertRealWorkspacePath(absoluteTargetPath, filePath);
-                captureMissingParents(absoluteTargetPath);
-                captureForRollback(absoluteTargetPath);
-            }
-            assertRealWorkspacePath(absolutePath, filePath);
-            node_fs.mkdirSync(node_path.dirname(absolutePath), {
-                recursive: true
-            });
-            node_fs.writeFileSync(absolutePath, content, 'utf-8');
-            return true;
-        },
-        writeGenerated (filePath, content) {
-            const absolutePath = assertWorkspacePath(filePath);
-            const changed = io.write(absolutePath, content);
-            if (dryRun && !behavior.materializeDryRun) return changed;
-            if (activeTransaction) activeTransaction.generatedPaths.add(absolutePath);
-            else formatGeneratedWrites(new Set([
-                absolutePath
-            ]));
-            return changed;
-        },
-        remove (filePath) {
-            const absolutePath = assertWorkspacePath(filePath, false);
-            if (!lstatIfExists(absolutePath)) return false;
-            if (dryRun) {
-                plan.push(`[dry-run] would delete ${rel(absolutePath)}`);
-                if (!behavior.materializeDryRun) return true;
-            }
-            activeTransaction?.generatedPaths.delete(absolutePath);
-            captureForRollback(absolutePath);
-            assertRealWorkspacePath(absolutePath, filePath, false);
-            node_fs.rmSync(absolutePath);
-            return true;
-        },
-        log (message) {
-            if (dryRun) plan.push(`[dry-run] ${message}`);
-            else process.stdout.write(`[ultramodern] ${message}\n`);
-        },
-        transaction (operation, options) {
-            if (activeTransaction) throw new Error('Nested migration transactions are not supported.');
-            const transaction = {
-                generatedPaths: new Set(),
-                order: [],
-                snapshots: new Map()
-            };
-            activeTransaction = transaction;
-            const finish = (result)=>{
-                try {
-                    if (options?.commitWhen && !options.commitWhen(result)) rollback(transaction);
-                    else formatGeneratedWrites(transaction.generatedPaths);
-                    return result;
-                } catch (error) {
-                    return finishWithError(transaction, error);
-                } finally{
-                    activeTransaction = void 0;
-                }
-            };
-            try {
-                const result = operation();
-                if (isPromiseLike(result)) return Promise.resolve(result).then((value)=>finish(value), (error)=>finishWithError(transaction, error));
-                return finish(result);
-            } catch (error) {
-                return finishWithError(transaction, error);
-            }
-        },
-        withStagedWorkspace (operation) {
-            const temporaryRoot = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'ultramodern-migration-'));
-            const stagedWorkspaceRoot = node_path.join(temporaryRoot, 'workspace');
-            const sourceWorkspaceAliases = [
-                ...new Set([
-                    absoluteWorkspaceRoot,
-                    realWorkspaceRoot
-                ])
-            ];
-            try {
-                copyWorkspaceEntry(realWorkspaceRoot, stagedWorkspaceRoot, realWorkspaceRoot, stagedWorkspaceRoot, sourceWorkspaceAliases);
-                const result = operation(stagedWorkspaceRoot);
-                if (isPromiseLike(result)) return Promise.resolve(result).finally(()=>{
-                    node_fs.rmSync(temporaryRoot, {
-                        force: true,
-                        recursive: true
-                    });
-                });
-                node_fs.rmSync(temporaryRoot, {
-                    force: true,
-                    recursive: true
-                });
-                return result;
-            } catch (error) {
-                node_fs.rmSync(temporaryRoot, {
-                    force: true,
-                    recursive: true
-                });
-                throw error;
-            }
-        }
-    };
-    return io;
-}
-function createMigrationIo(workspaceRoot, dryRun) {
-    return createMigrationIoWithBehavior(workspaceRoot, dryRun, {
-        materializeDryRun: false
-    });
-}
-function withStagedDryRunMigrationIo(workspaceRoot, operation) {
-    const ownerIo = createMigrationIo(workspaceRoot, true);
-    return ownerIo.withStagedWorkspace((stagedWorkspaceRoot)=>operation(createMigrationIoWithBehavior(stagedWorkspaceRoot, true, {
-            materializeDryRun: true
-        })));
-}
-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 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, withStagedDryRunMigrationIo, writeJsonFile };

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

@@ -1,277 +0,0 @@
-import "node:module";
-import { ULTRAMODERN_CREATE_PACKAGE, ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES, ULTRAMODERN_WORKSPACE_MODERN_PACKAGES, modernPackageSpecifier } from "../../../ultramodern-package-source.js";
-import { ULTRAMODERN_PACKAGE_PINS } from "../../../ultramodern-workspace/policy.js";
-import { GENERATED_POSTINSTALL_SCRIPT, createWorkspaceAppPackageScripts, createWorkspaceRootPackageScripts } from "../../../ultramodern-workspace/workspace-script-plan.js";
-import { migratedWorkspaceScriptBasenames } from "../../../ultramodern-workspace/workspace-scripts.js";
-const modernPackageNames = new Set([
-    ...ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES,
-    ...ULTRAMODERN_WORKSPACE_MODERN_PACKAGES
-]);
-function updateDeclaredDependencies(packageJson, pins) {
-    let changed = false;
-    for (const section of [
-        'dependencies',
-        'devDependencies',
-        'peerDependencies',
-        'optionalDependencies'
-    ]){
-        const dependencies = packageJson[section];
-        if (!(!dependencies || 'object' != typeof dependencies || Array.isArray(dependencies))) {
-            for (const [packageName, version] of pins)if (Object.hasOwn(dependencies, packageName) && dependencies[packageName] !== version) {
-                dependencies[packageName] = version;
-                changed = true;
-            }
-        }
-    }
-    return changed;
-}
-function updateModernDependencies(packageJson, packageSource) {
-    let changed = false;
-    for (const section of [
-        'dependencies',
-        'devDependencies'
-    ]){
-        const dependencies = packageJson[section];
-        if (dependencies && Object.hasOwn(dependencies, '@modern-js/create')) {
-            dependencies[ULTRAMODERN_CREATE_PACKAGE] = modernPackageSpecifier(ULTRAMODERN_CREATE_PACKAGE, packageSource);
-            delete dependencies['@modern-js/create'];
-            changed = true;
-        }
-    }
-    return updateDeclaredDependencies(packageJson, new Map([
-        ...modernPackageNames
-    ].map((packageName)=>[
-            packageName,
-            modernPackageSpecifier(packageName, packageSource)
-        ]))) || changed;
-}
-const generatedToolingDependencyPins = new Map(Object.entries({
-    ...ULTRAMODERN_PACKAGE_PINS.appDependencies,
-    ...ULTRAMODERN_PACKAGE_PINS.appDevDependencies,
-    ...ULTRAMODERN_PACKAGE_PINS.rootDevDependencies,
-    "@typescript/native-preview": ULTRAMODERN_PACKAGE_PINS.transitiveDependencies["@typescript/native-preview"]
-}));
-function updateGeneratedToolingDependencies(packageJson, options = {}) {
-    let changed = updateDeclaredDependencies(packageJson, generatedToolingDependencyPins);
-    if (options.ownsGeneratedScripts) {
-        const devDependencies = packageJson.devDependencies && 'object' == typeof packageJson.devDependencies && !Array.isArray(packageJson.devDependencies) ? packageJson.devDependencies : packageJson.devDependencies = {};
-        const crossEnvVersion = ULTRAMODERN_PACKAGE_PINS.rootDevDependencies["cross-env"];
-        if (devDependencies['cross-env'] !== crossEnvVersion) {
-            devDependencies['cross-env'] = crossEnvVersion;
-            changed = true;
-        }
-    }
-    return changed;
-}
-function ensureBffEffectDependencies(packageJson) {
-    let changed = false;
-    for (const section of [
-        'dependencies',
-        'devDependencies'
-    ]){
-        const dependencies = packageJson[section];
-        if (!(!dependencies || 'object' != typeof dependencies || Array.isArray(dependencies)) && Object.hasOwn(dependencies, '@modern-js/plugin-bff')) {
-            for (const [packageName, version] of Object.entries(ULTRAMODERN_PACKAGE_PINS.bffEffectDependencies))if (dependencies[packageName] !== version) {
-                dependencies[packageName] = version;
-                changed = true;
-            }
-        }
-    }
-    return changed;
-}
-const cloudflareModernDeployCommand = 'MODERNJS_DEPLOY=cloudflare modern deploy';
-const cloudflareModernDeploySkipBuildCommand = `${cloudflareModernDeployCommand} --skip-build`;
-const cloudflareWranglerDeployCommand = 'wrangler deploy --config .output/wrangler.json';
-const cloudflareWranglerDeployInvalidSkipBuildCommand = `${cloudflareWranglerDeployCommand} --skip-build`;
-function removeStaleBackendFederationCommandSegments(command) {
-    return command.replace(/\s+&&\s+node\s+\S*scripts\/generate-node-backend-federation\.m[ct]s(?:\s+--app\s+\S+)?(?:\s+--target\s+\S+)?(?=\s+&&|$)/gu, '');
-}
-const CONDITIONAL_FRAMEWORK_ROOT_SCRIPTS = [
-    'node:backend-federation:generate',
-    'node:proof',
-    'zerops:materialize'
-];
-const legacyPortableRootScripts = new Map([
-    [
-        'format',
-        [
-            "oxfmt . '!repos/**'",
-            'oxfmt .'
-        ]
-    ],
-    [
-        'format:check',
-        [
-            "oxfmt --check . '!repos/**'",
-            'oxfmt --check .'
-        ]
-    ]
-]);
-const splitScriptSegments = (command)=>command.split('&&').map((segment)=>segment.trim()).filter((segment)=>segment.length > 0);
-const scriptSegmentTarget = (segment)=>segment.replace(/^pnpm\s+/u, '').split(/\s+/u)[0] ?? segment;
-const FRAMEWORK_CHECK_TARGETS = new Set([
-    'format:check',
-    'lint',
-    'typecheck',
-    'skills:check',
-    'i18n:boundaries',
-    'api:check',
-    'contract:check',
-    'node:backend-federation:generate',
-    'node:proof',
-    'performance:readiness',
-    'bridge:check'
-]);
-function mergeAggregateCheckScript(consumer, framework) {
-    const frameworkSegments = splitScriptSegments(framework);
-    const consumerExtras = splitScriptSegments(consumer).filter((segment)=>!FRAMEWORK_CHECK_TARGETS.has(scriptSegmentTarget(segment)));
-    return [
-        ...consumerExtras,
-        ...frameworkSegments
-    ].join(' && ');
-}
-function mergeGeneratedScript(consumer, framework, canRetireLegacyOxfmtCliExclusion = false) {
-    const consumerSegments = splitScriptSegments(consumer);
-    const frameworkSegments = splitScriptSegments(framework);
-    const frameworkSegmentSet = new Set(frameworkSegments);
-    const canonicalFrameworkSegment = (segment)=>{
-        if (frameworkSegmentSet.has(segment)) return segment;
-        const portableEnvironmentSegment = `cross-env ${segment}`;
-        if (frameworkSegmentSet.has(portableEnvironmentSegment)) return portableEnvironmentSegment;
-        const portableOxfmtSegment = segment.replace(/ '!repos\/\*\*'$/u, '');
-        if (canRetireLegacyOxfmtCliExclusion && frameworkSegmentSet.has(portableOxfmtSegment)) return portableOxfmtSegment;
-        const emittingDeclarationSegment = segment.replace(/(\bultramodern-typecheck\.m[ct]s\s+)--project\s+/u, '$1--emit --project ');
-        if (emittingDeclarationSegment !== segment && frameworkSegmentSet.has(emittingDeclarationSegment)) return emittingDeclarationSegment;
-        if ((frameworkSegmentSet.has(`${segment} --skip-build`) || frameworkSegmentSet.has(`${portableEnvironmentSegment} --skip-build`)) && /\bmodern deploy$/u.test(segment)) return frameworkSegmentSet.has(`${segment} --skip-build`) ? `${segment} --skip-build` : `${portableEnvironmentSegment} --skip-build`;
-        if (segment === cloudflareWranglerDeployInvalidSkipBuildCommand && frameworkSegmentSet.has(cloudflareWranglerDeployCommand)) return cloudflareWranglerDeployCommand;
-        if (/\bnode\s+\S*scripts\/verify-cloudflare-output\.m[ct]s\s+--app\s+\S+$/u.test(segment) && frameworkSegments.find((candidate)=>candidate.includes('ultramodern-tooling.mts cloudflare-output-verify'))) return frameworkSegments.find((candidate)=>candidate.includes('ultramodern-tooling.mts cloudflare-output-verify'));
-    };
-    const frameworkIndexes = consumerSegments.flatMap((segment, index)=>canonicalFrameworkSegment(segment) ? [
-            index
-        ] : []);
-    if (0 === frameworkIndexes.length) return {
-        command: consumer,
-        preservedConsumerSegments: true
-    };
-    const firstFrameworkIndex = frameworkIndexes[0];
-    const lastFrameworkIndex = frameworkIndexes.at(-1);
-    const consumerPrefix = consumerSegments.slice(0, firstFrameworkIndex).filter((segment)=>void 0 === canonicalFrameworkSegment(segment));
-    const consumerExtrasAfter = new Map();
-    let precedingFrameworkSegment;
-    for (const segment of consumerSegments.slice(firstFrameworkIndex, lastFrameworkIndex + 1)){
-        const canonicalSegment = canonicalFrameworkSegment(segment);
-        if (void 0 !== canonicalSegment) precedingFrameworkSegment = canonicalSegment;
-        else if (void 0 !== precedingFrameworkSegment) {
-            const extras = consumerExtrasAfter.get(precedingFrameworkSegment) ?? [];
-            extras.push(segment);
-            consumerExtrasAfter.set(precedingFrameworkSegment, extras);
-        }
-    }
-    const consumerSuffix = consumerSegments.slice(lastFrameworkIndex + 1).filter((segment)=>void 0 === canonicalFrameworkSegment(segment));
-    const consumerMiddle = [
-        ...consumerExtrasAfter.values()
-    ].flat();
-    const consumerExtras = [
-        ...consumerPrefix,
-        ...consumerMiddle,
-        ...consumerSuffix
-    ];
-    return {
-        command: [
-            ...consumerPrefix,
-            ...frameworkSegments.flatMap((segment)=>[
-                    segment,
-                    ...consumerExtrasAfter.get(segment) ?? []
-                ]),
-            ...consumerSuffix
-        ].join(' && '),
-        preservedConsumerSegments: consumerExtras.length > 0
-    };
-}
-function rewriteMigratedScriptReferences(scripts) {
-    let changed = false;
-    const pattern = new RegExp(`(scripts/(?:${migratedWorkspaceScriptBasenames.join('|')}))\\.mjs`, 'gu');
-    for (const [name, value] of Object.entries(scripts)){
-        if ('string' != typeof value) continue;
-        const next = value.replace(pattern, '$1.mts');
-        if (next !== value) {
-            scripts[name] = next;
-            changed = true;
-        }
-    }
-    return changed;
-}
-function updateGeneratedPackageScripts(packageJson, options = {}) {
-    const scripts = packageJson.scripts;
-    if (!scripts || 'object' != typeof scripts || Array.isArray(scripts)) return false;
-    let changed = false;
-    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 (isRootPackage) {
-        for (const [name, [legacy, portable]] of legacyPortableRootScripts)if (true === options.canRetireLegacyOxfmtCliExclusion && scripts[name] === legacy) {
-            scripts[name] = portable;
-            changed = true;
-        }
-        const existingPostinstall = scripts.postinstall;
-        const mergedPostinstall = 'string' == typeof existingPostinstall ? mergeGeneratedScript(existingPostinstall, GENERATED_POSTINSTALL_SCRIPT, options.canRetireLegacyOxfmtCliExclusion) : {
-            command: GENERATED_POSTINSTALL_SCRIPT,
-            preservedConsumerSegments: false
-        };
-        if (mergedPostinstall.preservedConsumerSegments) options.onPreserveScript?.('postinstall');
-        if (scripts.postinstall !== mergedPostinstall.command) {
-            scripts.postinstall = mergedPostinstall.command;
-            changed = true;
-        }
-    }
-    const expectedScripts = isRootPackage ? createWorkspaceRootPackageScripts(apps.filter((candidate)=>'shell' !== candidate.kind), {
-        shells: apps.filter((candidate)=>'shell' === candidate.kind)
-    }) : app ? createWorkspaceAppPackageScripts(app) : void 0;
-    if (expectedScripts) {
-        if (isRootPackage) {
-            for (const name of CONDITIONAL_FRAMEWORK_ROOT_SCRIPTS)if (!(name in expectedScripts) && name in scripts) {
-                delete scripts[name];
-                changed = true;
-            }
-        }
-        for (const [name, value] of Object.entries(expectedScripts)){
-            if (void 0 === value) continue;
-            const existingScript = scripts[name];
-            const mergedScript = 'string' == typeof existingScript ? mergeGeneratedScript(existingScript, value, options.canRetireLegacyOxfmtCliExclusion) : {
-                command: value,
-                preservedConsumerSegments: false
-            };
-            const nextValue = 'check' === name && 'string' == typeof existingScript ? mergeAggregateCheckScript(existingScript, value) : mergedScript.command;
-            if ('check' !== name && mergedScript.preservedConsumerSegments) options.onPreserveScript?.(name);
-            if (scripts[name] !== nextValue) {
-                scripts[name] = nextValue;
-                changed = true;
-            }
-        }
-    }
-    const build = scripts.build;
-    if ('string' == typeof build) {
-        const nextBuild = removeStaleBackendFederationCommandSegments(build);
-        if (nextBuild !== build) {
-            scripts.build = nextBuild;
-            changed = true;
-        }
-    }
-    const cloudflareBuild = scripts['cloudflare:build'];
-    if ('string' == typeof cloudflareBuild) {
-        let nextCloudflareBuild = removeStaleBackendFederationCommandSegments(cloudflareBuild);
-        if (nextCloudflareBuild.includes(cloudflareModernDeployCommand) && !nextCloudflareBuild.includes(cloudflareModernDeploySkipBuildCommand)) nextCloudflareBuild = nextCloudflareBuild.replace(cloudflareModernDeployCommand, cloudflareModernDeploySkipBuildCommand);
-        if (nextCloudflareBuild !== cloudflareBuild) {
-            scripts['cloudflare:build'] = nextCloudflareBuild;
-            changed = true;
-        }
-    }
-    const cloudflareDeploy = scripts['cloudflare:deploy'];
-    if ('string' == typeof cloudflareDeploy && cloudflareDeploy.includes(cloudflareWranglerDeployInvalidSkipBuildCommand)) {
-        scripts['cloudflare:deploy'] = cloudflareDeploy.replace(cloudflareWranglerDeployInvalidSkipBuildCommand, cloudflareWranglerDeployCommand);
-        changed = true;
-    }
-    return changed;
-}
-export { ensureBffEffectDependencies, updateGeneratedPackageScripts, updateGeneratedToolingDependencies, updateModernDependencies };