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

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

@@ -1,67 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __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__);
-const migrateStrictEffectHelp = `Usage:
-  ultramodern-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.
-
-Existing Modern configs are treated as consumer-owned unless generated
-ownership can be proven. Package scripts and TypeScript configs are merged at
-their framework-owned boundaries so consumer command segments, includes,
-references, plugins, and diagnostic overrides survive. An ambiguous Module
-Federation config that requires a bridge update is refused before any file is
-written, with the config path and the manual resolution required.
-
-The obsolete react-router dependency is dropped from every generated app that
-does not import React Router in its own source. Each generated Module
-Federation config then declares bridge.enableBridgeRouter from what its app
-still depends on: true where the app declares react-router or react-router-dom,
-the router-free false everywhere else.
-
-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
-(including preserved consumer overlays; implies --skip-install).
-`;
-__webpack_require__.d(__webpack_exports__, {}, {
-    migrateStrictEffectHelp: migrateStrictEffectHelp
-});
-exports.migrateStrictEffectHelp = __webpack_exports__.migrateStrictEffectHelp;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "migrateStrictEffectHelp"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

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

@@ -1,52 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __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__, {
-    runPnpmLockfileRefresh: ()=>runPnpmLockfileRefresh
-});
-const external_node_child_process_namespaceObject = require("node:child_process");
-function runPnpmLockfileRefresh(context) {
-    const result = (0, external_node_child_process_namespaceObject.spawnSync)('pnpm', [
-        'install',
-        '--lockfile-only',
-        "--ignore-scripts"
-    ], {
-        cwd: context.workspaceRoot,
-        stdio: 'inherit'
-    });
-    if (result.error) throw result.error;
-    return result.status ?? 1;
-}
-exports.runPnpmLockfileRefresh = __webpack_exports__.runPnpmLockfileRefresh;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "runPnpmLockfileRefresh"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

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

@@ -1,447 +0,0 @@
-"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__, {
-    createMigrationIo: ()=>createMigrationIo,
-    listWorkspacePackageFiles: ()=>listWorkspacePackageFiles,
-    readJsonFile: ()=>readJsonFile,
-    withStagedDryRunMigrationIo: ()=>withStagedDryRunMigrationIo,
-    writeJsonFile: ()=>writeJsonFile
-});
-const external_node_fs_namespaceObject = require("node:fs");
-var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
-const external_node_os_namespaceObject = require("node:os");
-var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const fs_io_cjs_namespaceObject = require("../../../ultramodern-workspace/fs-io.cjs");
-const 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 external_node_fs_default().lstatSync(filePath);
-    } catch (error) {
-        if ('ENOENT' === error.code) return;
-        throw error;
-    }
-}
-function symlinkTypeForPath(filePath) {
-    return external_node_fs_default().statSync(filePath, {
-        throwIfNoEntry: false
-    })?.isDirectory() ? 'win32' === process.platform ? 'junction' : 'dir' : 'file';
-}
-function isPathInsideRoot(rootPath, targetPath) {
-    const relativePath = external_node_path_default().relative(rootPath, targetPath);
-    return '' === relativePath || !relativePath.startsWith(`..${external_node_path_default().sep}`) && '..' !== relativePath && !external_node_path_default().isAbsolute(relativePath);
-}
-function resolvePotentialRealPath(filePath, visitedSymlinks = new Set()) {
-    const absolutePath = external_node_path_default().resolve(filePath);
-    let existingAncestor = absolutePath;
-    while(!lstatIfExists(existingAncestor)){
-        const parentPath = external_node_path_default().dirname(existingAncestor);
-        if (parentPath === existingAncestor) return absolutePath;
-        existingAncestor = parentPath;
-    }
-    let realAncestor;
-    try {
-        realAncestor = external_node_fs_default().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(external_node_path_default().resolve(external_node_path_default().dirname(existingAncestor), external_node_fs_default().readlinkSync(existingAncestor)), visitedSymlinks);
-    }
-    return external_node_path_default().resolve(realAncestor, external_node_path_default().relative(existingAncestor, absolutePath));
-}
-function capturePath(filePath) {
-    const stat = lstatIfExists(filePath);
-    if (!stat) return;
-    const mode = 4095 & stat.mode;
-    if (stat.isFile()) return {
-        content: external_node_fs_default().readFileSync(filePath),
-        mode,
-        type: 'file'
-    };
-    if (stat.isDirectory()) {
-        const entries = new Map();
-        for (const entry of external_node_fs_default().readdirSync(filePath).sort((left, right)=>left.localeCompare(right))){
-            const snapshot = capturePath(external_node_path_default().join(filePath, entry));
-            if (snapshot) entries.set(entry, snapshot);
-        }
-        return {
-            entries,
-            mode,
-            type: 'directory'
-        };
-    }
-    if (stat.isSymbolicLink()) return {
-        linkType: symlinkTypeForPath(filePath),
-        mode,
-        target: external_node_fs_default().readlinkSync(filePath),
-        type: 'symlink'
-    };
-    throw new Error(`Unsupported migration transaction path: ${filePath}`);
-}
-function removePath(filePath) {
-    external_node_fs_default().rmSync(filePath, {
-        force: true,
-        recursive: true
-    });
-}
-function chmodSymlinkIfSupported(filePath, mode) {
-    if ('function' == typeof external_node_fs_default().lchmodSync) external_node_fs_default().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);
-            external_node_fs_default().mkdirSync(external_node_path_default().dirname(filePath), {
-                recursive: true
-            });
-        }
-        external_node_fs_default().writeFileSync(filePath, snapshot.content);
-        external_node_fs_default().chmodSync(filePath, snapshot.mode);
-        return;
-    }
-    if ('symlink' === snapshot.type) {
-        if (!current?.isSymbolicLink() || external_node_fs_default().readlinkSync(filePath) !== snapshot.target || symlinkTypeForPath(filePath) !== snapshot.linkType) {
-            removePath(filePath);
-            external_node_fs_default().mkdirSync(external_node_path_default().dirname(filePath), {
-                recursive: true
-            });
-            external_node_fs_default().symlinkSync(snapshot.target, filePath, snapshot.linkType);
-        }
-        chmodSymlinkIfSupported(filePath, snapshot.mode);
-        return;
-    }
-    if (!current?.isDirectory() || current.isSymbolicLink()) {
-        removePath(filePath);
-        external_node_fs_default().mkdirSync(filePath, {
-            recursive: true
-        });
-    }
-    for (const entry of external_node_fs_default().readdirSync(filePath))if (!snapshot.entries.has(entry)) removePath(external_node_path_default().join(filePath, entry));
-    for (const [entry, childSnapshot] of snapshot.entries)restorePath(external_node_path_default().join(filePath, entry), childSnapshot);
-    external_node_fs_default().chmodSync(filePath, snapshot.mode);
-}
-function copyWorkspaceEntry(sourcePath, destinationPath, sourceWorkspaceRoot, stagedWorkspaceRoot, sourceWorkspaceAliases) {
-    const stat = external_node_fs_default().lstatSync(sourcePath);
-    if (stat.isDirectory()) {
-        external_node_fs_default().mkdirSync(destinationPath, {
-            mode: 4095 & stat.mode
-        });
-        const relativeSourcePath = external_node_path_default().relative(sourceWorkspaceRoot, sourcePath);
-        for (const entry of external_node_fs_default().readdirSync(sourcePath)){
-            const isNamedWorkspacePackage = stagingWorkspacePackageDirectories.has(relativeSourcePath) && stagingGeneratedOutputEntries.has(entry);
-            if (!stagingExcludedEntries.has(entry) || isNamedWorkspacePackage) copyWorkspaceEntry(external_node_path_default().join(sourcePath, entry), external_node_path_default().join(destinationPath, entry), sourceWorkspaceRoot, stagedWorkspaceRoot, sourceWorkspaceAliases);
-        }
-        external_node_fs_default().chmodSync(destinationPath, 4095 & stat.mode);
-        return;
-    }
-    if (stat.isFile()) {
-        external_node_fs_default().copyFileSync(sourcePath, destinationPath, external_node_fs_default().constants.COPYFILE_FICLONE);
-        external_node_fs_default().chmodSync(destinationPath, 4095 & stat.mode);
-        return;
-    }
-    if (stat.isSymbolicLink()) {
-        const target = external_node_fs_default().readlinkSync(sourcePath);
-        const stagedTarget = external_node_path_default().isAbsolute(target) ? relocateWorkspacePath(sourceWorkspaceAliases, stagedWorkspaceRoot, target) : target;
-        external_node_fs_default().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 = external_node_path_default().relative(sourceWorkspaceRoot, sourcePath);
-        if (isPathInsideRoot(sourceWorkspaceRoot, sourcePath)) return external_node_path_default().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 = external_node_path_default().resolve(workspaceRoot);
-    const realWorkspaceRoot = resolvePotentialRealPath(absoluteWorkspaceRoot);
-    const plan = [];
-    let activeTransaction;
-    const rel = (p)=>(external_node_path_default().relative(absoluteWorkspaceRoot, p) || external_node_path_default().basename(p)).split(external_node_path_default().sep).join('/');
-    const assertRealWorkspacePath = (absolutePath, displayedPath, followFinalSymlink = true)=>{
-        const pathToResolve = followFinalSymlink ? absolutePath : external_node_path_default().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 = external_node_path_default().resolve(filePath);
-        const relativePath = external_node_path_default().relative(absoluteWorkspaceRoot, absolutePath);
-        if ('' === relativePath || '..' === relativePath || relativePath.startsWith(`..${external_node_path_default().sep}`) || external_node_path_default().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 = external_node_path_default().dirname(filePath);
-        while(current !== absoluteWorkspaceRoot && !lstatIfExists(current)){
-            missing.push(current);
-            current = external_node_path_default().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)=>external_node_path_default().relative(absoluteWorkspaceRoot, filePath)).sort((left, right)=>left.localeCompare(right));
-        const formattedSources = (0, fs_io_cjs_namespaceObject.formatGeneratedSourceCandidates)(relativePaths.map((relativePath)=>[
-                relativePath,
-                external_node_fs_default().readFileSync(external_node_path_default().join(absoluteWorkspaceRoot, relativePath), 'utf-8')
-            ]));
-        for (const [index, relativePath] of relativePaths.entries())io.write(external_node_path_default().join(absoluteWorkspaceRoot, relativePath), formattedSources[index]);
-    };
-    const io = {
-        workspaceRoot: absoluteWorkspaceRoot,
-        dryRun,
-        plan,
-        write (filePath, content) {
-            const absolutePath = assertWorkspacePath(filePath);
-            if (external_node_fs_default().existsSync(absolutePath) && external_node_fs_default().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 = external_node_path_default().resolve(external_node_path_default().dirname(absolutePath), external_node_fs_default().readlinkSync(absolutePath));
-                let targetPath = linkedPath;
-                try {
-                    targetPath = external_node_fs_default().realpathSync.native(absolutePath);
-                } catch  {}
-                const absoluteTargetPath = external_node_path_default().resolve(targetPath);
-                assertRealWorkspacePath(absoluteTargetPath, filePath);
-                captureMissingParents(absoluteTargetPath);
-                captureForRollback(absoluteTargetPath);
-            }
-            assertRealWorkspacePath(absolutePath, filePath);
-            external_node_fs_default().mkdirSync(external_node_path_default().dirname(absolutePath), {
-                recursive: true
-            });
-            external_node_fs_default().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);
-            external_node_fs_default().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 = external_node_fs_default().mkdtempSync(external_node_path_default().join(external_node_os_default().tmpdir(), 'ultramodern-migration-'));
-            const stagedWorkspaceRoot = external_node_path_default().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(()=>{
-                    external_node_fs_default().rmSync(temporaryRoot, {
-                        force: true,
-                        recursive: true
-                    });
-                });
-                external_node_fs_default().rmSync(temporaryRoot, {
-                    force: true,
-                    recursive: true
-                });
-                return result;
-            } catch (error) {
-                external_node_fs_default().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(external_node_fs_default().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 = external_node_path_default().join(workspaceRoot, directory);
-        if (external_node_fs_default().existsSync(absoluteDirectory)) for (const entry of external_node_fs_default().readdirSync(absoluteDirectory, {
-            withFileTypes: true
-        })){
-            if (!entry.isDirectory()) continue;
-            const packageFile = `${directory}/${entry.name}/package.json`;
-            if (external_node_fs_default().existsSync(external_node_path_default().join(workspaceRoot, packageFile))) packageFiles.push(packageFile);
-        }
-    }
-    return packageFiles;
-}
-exports.createMigrationIo = __webpack_exports__.createMigrationIo;
-exports.listWorkspacePackageFiles = __webpack_exports__.listWorkspacePackageFiles;
-exports.readJsonFile = __webpack_exports__.readJsonFile;
-exports.withStagedDryRunMigrationIo = __webpack_exports__.withStagedDryRunMigrationIo;
-exports.writeJsonFile = __webpack_exports__.writeJsonFile;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createMigrationIo",
-    "listWorkspacePackageFiles",
-    "readJsonFile",
-    "withStagedDryRunMigrationIo",
-    "writeJsonFile"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});