rman 1.0.12 → 1.2.1

package/services/clean.service.d.ts

@@ -1,42 +0,0 @@
-import type { Repository } from '../core/repository.js';
-import { type LogLevel } from '../utils/logger.js';
-import { type PackageFilterOptions } from '../utils/package-filter.js';
-export declare namespace CleanService {
-    interface Options extends PackageFilterOptions {
-        /** Show the live progress panel. Default true; auto-disabled when stdout isn't a TTY. */
-        progress?: boolean;
-        /** Report what would be removed without actually removing anything. Default false. */
-        dryRun?: boolean;
-        /** Clean the whole repository even when the current directory is inside a single package
-         *  (which otherwise scopes cleaning to just that package - see `Repository.currentPackage`).
-         *  Has no effect when already at the repository root, or outside any known package. */
-        root?: boolean;
-        /** Verbosity of the classic per-item log (only applies when the live panel is off). Falls back
-         *  to the root's `.rmanrc logLevel`, then 'info' - see `resolveRootLogLevel`. */
-        logLevel?: LogLevel;
-    }
-    /**
-     * `clean`: removes build output across every package (root included) - the built-in replacement
-     * for `ts-cleanup`, plus whatever else `.rmanrc clean.include`/`clean.exclude` says to remove.
-     *
-     * For every package not opted out via its own (cascaded) `clean.skip: true`:
-     *  - deletes compiled `.js`/`.js.map`/`.d.ts` files under its `src`/`test` (see `cleanTsArtifacts`);
-     *  - deletes any `*.tsbuildinfo` incremental-build cache file anywhere in it;
-     *  - deletes anything matching its own (cascaded) `clean.include` glob(s), minus `clean.exclude`.
-     *
-     * `include`/`exclude` are resolved relative to *that* package's own directory - a root-level
-     * `.rmanrc` pattern like `packages/*\/build` is naturally evaluated from the repository root
-     * (spanning every package in one pass), while a package's own override in its own `.rmanrc`
-     * (e.g. `include: ./cache`) only ever reaches that one package, since a package normally
-     * overrides rather than merges with the root's value for the same key.
-     *
-     * Never touches `node_modules` - that's `ci`'s job, not this one.
-     *
-     * Run from inside a single package's own directory, it only cleans that package unless
-     * `options.root` says otherwise (see `Repository.currentPackage`).
-     *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) - unlike
-     * `ci`, cleaning genuinely is independent per-package work, so the final per-package tally stays.
-     */
-    function clean(repository: Repository, options?: Options): Promise<void>;
-}

package/services/clean.service.js

@@ -1,226 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import colors from 'ansi-colors';
-import fg from 'fast-glob';
-import { Logger, resolveRootLogLevel } from '../utils/logger.js';
-import { filterPackages } from '../utils/package-filter.js';
-import { ProgressPanel } from '../utils/progress-panel.js';
-export var CleanService;
-(function (CleanService) {
-    /**
-     * `clean`: removes build output across every package (root included) - the built-in replacement
-     * for `ts-cleanup`, plus whatever else `.rmanrc clean.include`/`clean.exclude` says to remove.
-     *
-     * For every package not opted out via its own (cascaded) `clean.skip: true`:
-     *  - deletes compiled `.js`/`.js.map`/`.d.ts` files under its `src`/`test` (see `cleanTsArtifacts`);
-     *  - deletes any `*.tsbuildinfo` incremental-build cache file anywhere in it;
-     *  - deletes anything matching its own (cascaded) `clean.include` glob(s), minus `clean.exclude`.
-     *
-     * `include`/`exclude` are resolved relative to *that* package's own directory - a root-level
-     * `.rmanrc` pattern like `packages/*\/build` is naturally evaluated from the repository root
-     * (spanning every package in one pass), while a package's own override in its own `.rmanrc`
-     * (e.g. `include: ./cache`) only ever reaches that one package, since a package normally
-     * overrides rather than merges with the root's value for the same key.
-     *
-     * Never touches `node_modules` - that's `ci`'s job, not this one.
-     *
-     * Run from inside a single package's own directory, it only cleans that package unless
-     * `options.root` says otherwise (see `Repository.currentPackage`).
-     *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) - unlike
-     * `ci`, cleaning genuinely is independent per-package work, so the final per-package tally stays.
-     */
-    async function clean(repository, options = {}) {
-        /** Standing inside a single package's own directory scopes cleaning to just that package
-         *  (root's own artifacts included) unless `--root` asks for the whole repository anyway - a
-         *  no-op when already at the root, or outside any known package. */
-        const cwdScope = options.root ? undefined : repository.currentPackage;
-        const packages = repository.getPackages().filter(p => p !== repository.rootPackage);
-        const allTargets = cwdScope ? [cwdScope] : [repository.rootPackage, ...packages];
-        const targets = filterPackages(allTargets, options).filter(pkg => !cleanConfig(pkg).skip);
-        const dryRun = options.dryRun ?? false;
-        const progress = options.progress ?? true;
-        const logger = new Logger(options.logLevel ?? resolveRootLogLevel(repository));
-        const panel = new ProgressPanel(dryRun ? 'CLEAN (dry-run)' : 'CLEAN', !!process.stdout.isTTY && progress);
-        panel.start();
-        let failed = false;
-        try {
-            const results = await Promise.allSettled(targets.map(pkg => {
-                const label = pkg === repository.rootPackage ? 'root' : pkg.name;
-                return cleanPackage(pkg, panel.addItem(label), panel.enabled, dryRun, logger);
-            }));
-            if (results.some(r => r.status === 'rejected'))
-                failed = true;
-        }
-        finally {
-            panel.stop();
-        }
-        panel.printSummary();
-        if (failed) {
-            const err = new Error('"clean" failed');
-            err.logged = true;
-            throw err;
-        }
-    }
-    CleanService.clean = clean;
-})(CleanService || (CleanService = {}));
-/** Directories a package's TypeScript output gets cleaned from, mirroring `ts-cleanup -s src`
- *  and `-s test` (the only way it was ever actually invoked in this project's own scripts). */
-const TS_SOURCE_DIRS = ['src', 'test'];
-/** A package's (cascaded) `.rmanrc clean.include`/`clean.exclude`/`clean.skip` - a package that
- *  declares its own `clean` block replaces the root's entirely for itself (same as any other
- *  rman config key), rather than combining with it. `include`/`exclude` accept a single glob
- *  string or an array of them. */
-function cleanConfig(pkg) {
-    const cfg = pkg.config?.clean;
-    const normalize = (v) => {
-        if (Array.isArray(v))
-            return v.map(String);
-        return typeof v === 'string' && v ? [v] : [];
-    };
-    return { include: normalize(cfg?.include), exclude: normalize(cfg?.exclude), skip: cfg?.skip === true };
-}
-/** Deletes `file`, unless `dryRun` - either way the caller treats it as removed for reporting. */
-async function remove(file, dryRun) {
-    if (!dryRun)
-        await fs.promises.rm(file, { force: true });
-}
-/** Removes now-empty directories under `dir`, deepest first (so a parent left empty once its
- *  only child is removed gets caught in the same pass). Also removes `dir` itself once empty
- *  when `includeSelf` is set - used when `dir` is itself something the user asked to delete
- *  (e.g. an `include: build` match), as opposed to a source root like `src`/`test` that should
- *  stay even if everything inside it was cleaned out. No-op in dry-run mode: nothing was actually
- *  deleted, so there's nothing that could have been left empty. */
-function pruneEmptyDirs(dir, includeSelf, dryRun) {
-    if (dryRun || !fs.existsSync(dir))
-        return;
-    const entries = fg.sync('**', { cwd: dir, onlyDirectories: true, dot: true });
-    entries.sort((a, b) => b.split(path.sep).length - a.split(path.sep).length);
-    for (const rel of entries) {
-        const abs = path.join(dir, rel);
-        if (fs.existsSync(abs) && fs.readdirSync(abs).length === 0)
-            fs.rmdirSync(abs);
-    }
-    if (includeSelf && fs.readdirSync(dir).length === 0)
-        fs.rmdirSync(dir);
-}
-/**
- * Deletes every path matched by `include` (minus `exclude`) under `dirname` - files and
- * directories alike, gulp-`src()`-style. Returns what was actually removed (or, in dry-run mode,
- * what *would* be), relative to `dirname`, so the caller only logs what really happened.
- *
- * `exclude` protects at two levels: a pattern matching a whole `include` result directly (e.g.
- * `packages/pkg1/*` against a matched `packages/pkg1/build` directory) drops that result before
- * anything under it is touched; a finer pattern (e.g. `build/*.json`) instead protects just the
- * matching files *inside* an otherwise-deleted directory, leaving the rest of it gone and the
- * protected files (and their now non-empty parent) in place.
- */
-async function cleanGlobs(dirname, include, exclude, dryRun) {
-    if (!include.length)
-        return [];
-    const matches = await fg(include, { cwd: dirname, ignore: exclude, onlyFiles: false, dot: true, absolute: true });
-    const protectedFiles = exclude.length
-        ? new Set(await fg(exclude, { cwd: dirname, onlyFiles: true, dot: true, absolute: true }))
-        : new Set();
-    const removed = [];
-    for (const m of matches) {
-        const stat = await fs.promises.stat(m).catch(() => undefined);
-        if (!stat)
-            continue;
-        if (stat.isDirectory()) {
-            const filesInside = await fg('**', { cwd: m, onlyFiles: true, dot: true, absolute: true });
-            for (const f of filesInside) {
-                if (protectedFiles.has(f))
-                    continue;
-                await remove(f, dryRun);
-                removed.push(path.relative(dirname, f));
-            }
-            pruneEmptyDirs(m, true, dryRun);
-        }
-        else if (!protectedFiles.has(m)) {
-            await remove(m, dryRun);
-            removed.push(path.relative(dirname, m));
-        }
-    }
-    return removed;
-}
-/**
- * Removes compiled TypeScript output (`.js`, `.js.map`, `.d.ts`) sitting next to its `.ts`
- * source under `src`/`test` - the same job `ts-cleanup -s <dir> --all` did (the only mode this
- * project ever actually used it in). A `.d.ts` with no matching `.ts`/`.tsx` is left alone - it's
- * presumably a hand-written declaration file, not build output. Prunes directories left empty
- * afterward.
- */
-async function cleanTsArtifacts(dirname, dryRun) {
-    const removed = [];
-    for (const sub of TS_SOURCE_DIRS) {
-        const dir = path.join(dirname, sub);
-        if (!fs.existsSync(dir))
-            continue;
-        const files = await fg('**/*.{js,js.map,d.ts}', { cwd: dir, onlyFiles: true, dot: true, absolute: true });
-        for (const f of files) {
-            if (f.endsWith('.d.ts')) {
-                const base = f.slice(0, -'.d.ts'.length);
-                if (!fs.existsSync(base + '.ts') && !fs.existsSync(base + '.tsx'))
-                    continue;
-            }
-            await remove(f, dryRun);
-            removed.push(path.relative(dirname, f));
-        }
-        pruneEmptyDirs(dir, false, dryRun);
-    }
-    return removed;
-}
-/**
- * Removes TypeScript's incremental-build cache files (`*.tsbuildinfo`) anywhere under `dirname` -
- * `tsc --build`/`composite`/`incremental` output that `ts-cleanup` never touched, but which can
- * leave a project in a stale state if a clean rebuild is expected to start from nothing. Skips
- * `node_modules` (dependencies may ship their own, irrelevant to this package's own build).
- */
-async function cleanTsBuildInfo(dirname, dryRun) {
-    const files = await fg('**/*.tsbuildinfo', {
-        cwd: dirname,
-        ignore: ['**/node_modules/**'],
-        onlyFiles: true,
-        dot: true,
-        absolute: true,
-    });
-    for (const f of files)
-        await remove(f, dryRun);
-    return files.map(f => path.relative(dirname, f));
-}
-async function cleanPackage(pkg, item, panelEnabled, dryRun, logger) {
-    item.status = 'running';
-    item.startedAt = Date.now();
-    try {
-        item.currentStep = 'ts';
-        const tsRemoved = await cleanTsArtifacts(pkg.dirname, dryRun);
-        const buildInfoRemoved = await cleanTsBuildInfo(pkg.dirname, dryRun);
-        item.currentStep = 'glob';
-        const { include, exclude } = cleanConfig(pkg);
-        const globRemoved = await cleanGlobs(pkg.dirname, include, exclude, dryRun);
-        const removed = [...tsRemoved, ...buildInfoRemoved, ...globRemoved];
-        const verb = dryRun ? 'would rm' : 'rm';
-        if (panelEnabled) {
-            item.lastLine = removed.length
-                ? `${dryRun ? 'would remove' : 'removed'} ${removed.length} item(s)`
-                : 'already clean';
-        }
-        else if (removed.length) {
-            for (const r of removed)
-                logger.info(colors.yellow(verb), colors.cyan(item.name), r);
-        }
-        else {
-            logger.info(colors.gray('clean'), colors.cyan(item.name));
-        }
-        item.status = 'success';
-    }
-    catch (e) {
-        item.status = 'failed';
-        item.log.push(e?.message ?? String(e));
-        throw e;
-    }
-    finally {
-        item.finishedAt = Date.now();
-    }
-}

package/services/publish.service.d.ts

@@ -1,79 +0,0 @@
-import type { Package } from '../core/package.js';
-import type { Repository } from '../core/repository.js';
-import { type PackageFilterOptions } from '../utils/package-filter.js';
-import { CiService } from './ci.service.js';
-export declare namespace PublishService {
-    /** Injectable registry lookup - mainly for tests, so they don't depend on network access or a
-     *  real published package. Same shape as `detectChangeHash`'s own `npmViewVersion`. */
-    interface Deps {
-        npmViewVersion?: (name: string, cwd: string) => Promise<string | undefined>;
-    }
-    interface Options extends PackageFilterOptions {
-        /** A package with uncommitted local changes is excluded (status `'skip'`) instead of aborting
-         *  the whole plan (status `'error'`) - same as `version`'s own option. Default false. */
-        ignoreDirty?: boolean;
-        /** Registry to check against (and, in `applyPlan`, publish to) - `.npmrc`'s own configured
-         *  registry is used when omitted. */
-        registry?: string;
-        /** Path to a custom `.npmrc`, for both the registry check and the actual publish. */
-        userconfig?: string;
-    }
-    interface ApplyOptions extends Options {
-        packageManager?: CiService.PackageManager;
-        /** `npm publish --access <access>` - required by the registry for a *new* scoped package. */
-        access?: 'public' | 'restricted';
-        /** `npm publish --tag <tag>` - the dist-tag this version is published under (default `latest`). */
-        tag?: string;
-        /** `npm publish --otp <otp>` - a 2FA one-time password, for registries that require it. */
-        otp?: string;
-        /** Subdirectory to publish from, relative to the package's own directory - only consulted when
-         *  the package doesn't already declare its own `package.json` `publishConfig.directory` (npm's
-         *  native mechanism for this, which always wins when present). */
-        contents?: string;
-    }
-    /** One package's outcome in a publish plan - see `getPlan`. */
-    interface Entry {
-        package: Package;
-        version: string;
-        status: 'publish' | 'skip' | 'up-to-date' | 'error';
-        /** What's currently on the registry, if anything - only set once a registry check actually ran. */
-        registryVersion?: string;
-        reason?: string;
-    }
-    /**
-     * Computes what `publish` *would* do, across every non-private package (topological order,
-     * dependencies before dependents) - never touches the registry to publish anything, just
-     * queries it to decide, so it's safe to call any time, including as the plan a bare `rman
-     * publish` shows before asking for confirmation.
-     *
-     * A `private: true` package is always `'skip'`ped outright. A package with uncommitted local
-     * changes is `'error'` (aborts the whole plan) unless `options.ignoreDirty` downgrades it to
-     * `'skip'` instead - same rule `version` uses, since publishing untracked local edits is worse
-     * than a bad commit. Otherwise, its currently-published registry version (via `npm view`,
-     * queried concurrently across every remaining package) decides the rest: identical to the local
-     * `package.json` version is `'up-to-date'`; anything else (including never having been
-     * published at all) is `'publish'`.
-     *
-     * Deliberately decoupled from `version`: this only ever looks at what's *currently* on disk and
-     * on the registry, never at whether `version` was just run - so it works equally well right
-     * after a version bump, or standing alone in a release pipeline that bumped days earlier.
-     *
-     * A monorepo's root package is never a candidate at all - `repository.getPackages()` already
-     * excludes it for a real monorepo (it only doubles as "the" package in a single-package repo,
-     * where it's a normal candidate like any other).
-     */
-    function getPlan(repository: Repository, options?: Options, deps?: Deps): Promise<Entry[]>;
-    /**
-     * Publishes every `'publish'` entry in `plan`, topological order (already `plan`'s own order -
-     * see `getPlan`), via the configured `packageManager`'s own `publish` command. Sequential, not
-     * concurrent: unlike `run`/`build`, a package genuinely needs its own dependencies to have
-     * landed on the registry first, and publishing is rare enough (once per release) that the
-     * simplicity is worth more than the parallelism `run` gets from `power-tasks`.
-     *
-     * If a package fails, every other still-pending entry depending on it (transitively) is marked
-     * `'error'` too and never attempted - publishing a package whose own new dependency range points
-     * at a version that never actually reached the registry would hand consumers a broken install.
-     * A package's own failure doesn't stop unrelated packages elsewhere in the plan, though.
-     */
-    function applyPlan(repository: Repository, plan: Entry[], options?: ApplyOptions): Promise<Entry[]>;
-}

package/services/publish.service.js

@@ -1,273 +0,0 @@
-/**
- * Prepares the `package.json` that `npm publish` will actually read, and returns a function that
- * undoes it - always call that from a `finally`, so a failed publish leaves nothing behind.
- *
- * Which file that is depends on where the output lives:
- *
- * - **Publishing the package directory itself** - its own `package.json` is the manifest, rewritten
- *   in place: every `"workspace:"` range becomes a real, registry-consumable one (the same
- *   substitution pnpm/yarn's own publish performs - see `resolveWorkspaceRange`), since `npm
- *   publish` reads what is on disk rather than packing from a staging tarball.
- * - **Publishing a build directory** - there is no manifest there until something writes one, and
- *   that something is this: see `derivePublishManifest`.
- *
- * Returns `undefined` when there is nothing to do at all (the package directory, with no
- * `"workspace:"` range in it) - no disk write, nothing to restore.
- */
-import { execFile } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { promisify } from 'node:util';
-import { exec } from '../utils/exec.js';
-import { GitHelper } from '../utils/git.js';
-import { filterPackages } from '../utils/package-filter.js';
-import { parseWorkspaceRange, resolveWorkspaceRange } from '../utils/workspace-range.js';
-import { CiService } from './ci.service.js';
-import { DEPENDENCY_KEYS } from './version.service.js';
-function preparePublishManifest(pkg, publishDir, packagesByName) {
-    if (path.resolve(publishDir) !== path.resolve(pkg.dirname)) {
-        const file = path.join(publishDir, 'package.json');
-        const previous = fs.existsSync(file) ? fs.readFileSync(file, 'utf-8') : undefined;
-        fs.mkdirSync(publishDir, { recursive: true });
-        fs.writeFileSync(file, JSON.stringify(derivePublishManifest(pkg, packagesByName), undefined, 2) + '\n', 'utf-8');
-        return () => {
-            if (previous === undefined)
-                fs.rmSync(file, { force: true });
-            else
-                fs.writeFileSync(file, previous, 'utf-8');
-        };
-    }
-    const hasWorkspaceRange = DEPENDENCY_KEYS.some(depKey => {
-        const deps = pkg.json[depKey];
-        return deps && Object.values(deps).some(v => parseWorkspaceRange(v));
-    });
-    if (!hasWorkspaceRange)
-        return undefined;
-    const original = fs.readFileSync(pkg.jsonFileName, 'utf-8');
-    resolveWorkspaceRanges(pkg.json, packagesByName);
-    pkg.writeJson();
-    return () => {
-        fs.writeFileSync(pkg.jsonFileName, original, 'utf-8');
-        pkg.reloadJson();
-    };
-}
-/**
- * The manifest to publish from a build directory, derived from the package's own - generated here
- * rather than by a build script, and deliberately with nothing to configure.
- *
- * Generated at *publish* time, which is the whole point: a build script writes it when the build
- * runs, so bumping the version afterwards (or building before a bump) publishes a manifest that
- * disagrees with the package - and the `"workspace:"` rewrite above, which only ever touched the
- * package's own file, never reached the copy at all.
- *
- * What comes out is the package's `package.json` minus what a consumer of the tarball can neither
- * see nor use:
- *
- * - `devDependencies` - npm never installs a dependency's own, so they are pure noise.
- * - `scripts`, **except** `preinstall`/`install`/`postinstall`. Those three are the only ones a
- *   consumer's install actually runs, and dropping them would silently break every package that
- *   builds a native module on install. The rest (`build`, `test`, `prepare`, ...) never reach the
- *   consumer - `prepare` runs for a git dependency, which builds from the repository, not from this
- *   tarball.
- * - `private` - rman refuses to publish a private package in the first place, so carrying the flag
- *   into a manifest that is being published can only be wrong.
- * - `publishConfig.directory` - it pointed *here*; kept, it would point one level deeper again.
- */
-function derivePublishManifest(pkg, packagesByName) {
-    const json = structuredClone(pkg.json);
-    resolveWorkspaceRanges(json, packagesByName);
-    delete json.devDependencies;
-    delete json.private;
-    if (json.scripts) {
-        const kept = Object.fromEntries(Object.entries(json.scripts).filter(([name]) => CONSUMER_SCRIPTS.has(name)));
-        if (Object.keys(kept).length)
-            json.scripts = kept;
-        else
-            delete json.scripts;
-    }
-    if (json.publishConfig) {
-        delete json.publishConfig.directory;
-        if (!Object.keys(json.publishConfig).length)
-            delete json.publishConfig;
-    }
-    return json;
-}
-/** The only lifecycle scripts a consumer's `npm install` of this package runs - see
- *  https://docs.npmjs.com/cli/using-npm/scripts. */
-const CONSUMER_SCRIPTS = new Set(['preinstall', 'install', 'postinstall']);
-/** Rewrites `json`'s `"workspace:"` ranges in place, resolving each against the in-repo package it
- *  names. Shared by both manifest paths, so they can never disagree about the substitution. */
-function resolveWorkspaceRanges(json, packagesByName) {
-    for (const depKey of DEPENDENCY_KEYS) {
-        const deps = json[depKey];
-        if (!deps)
-            continue;
-        for (const depName of Object.keys(deps)) {
-            const parsed = parseWorkspaceRange(deps[depName]);
-            if (!parsed)
-                continue;
-            const depPkg = packagesByName.get(depName);
-            if (depPkg)
-                deps[depName] = resolveWorkspaceRange(parsed, depPkg.version);
-        }
-    }
-}
-export var PublishService;
-(function (PublishService) {
-    /**
-     * Computes what `publish` *would* do, across every non-private package (topological order,
-     * dependencies before dependents) - never touches the registry to publish anything, just
-     * queries it to decide, so it's safe to call any time, including as the plan a bare `rman
-     * publish` shows before asking for confirmation.
-     *
-     * A `private: true` package is always `'skip'`ped outright. A package with uncommitted local
-     * changes is `'error'` (aborts the whole plan) unless `options.ignoreDirty` downgrades it to
-     * `'skip'` instead - same rule `version` uses, since publishing untracked local edits is worse
-     * than a bad commit. Otherwise, its currently-published registry version (via `npm view`,
-     * queried concurrently across every remaining package) decides the rest: identical to the local
-     * `package.json` version is `'up-to-date'`; anything else (including never having been
-     * published at all) is `'publish'`.
-     *
-     * Deliberately decoupled from `version`: this only ever looks at what's *currently* on disk and
-     * on the registry, never at whether `version` was just run - so it works equally well right
-     * after a version bump, or standing alone in a release pipeline that bumped days earlier.
-     *
-     * A monorepo's root package is never a candidate at all - `repository.getPackages()` already
-     * excludes it for a real monorepo (it only doubles as "the" package in a single-package repo,
-     * where it's a normal candidate like any other).
-     */
-    async function getPlan(repository, options = {}, deps = {}) {
-        const git = new GitHelper({ cwd: repository.dirname });
-        const packages = filterPackages(repository.getPackages({ toposort: true }), options);
-        const dirtyFiles = await git.listDirtyFiles({ absolute: true });
-        const isDirty = (pkg) => dirtyFiles.some(f => !path.relative(pkg.dirname, f).startsWith('..'));
-        const npmViewVersion = deps.npmViewVersion ?? ((name, cwd) => defaultNpmViewVersion(name, cwd, options));
-        const entries = new Map();
-        const toCheck = [];
-        for (const pkg of packages) {
-            if (pkg.config.publish?.skip) {
-                entries.set(pkg.name, {
-                    package: pkg,
-                    version: pkg.version,
-                    status: 'skip',
-                    reason: 'excluded via .rmanrc "publish.skip"',
-                });
-            }
-            else if (pkg.isPrivate) {
-                entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: 'private package' });
-            }
-            else if (isDirty(pkg)) {
-                entries.set(pkg.name, {
-                    package: pkg,
-                    version: pkg.version,
-                    status: options.ignoreDirty ? 'skip' : 'error',
-                    reason: 'uncommitted local changes',
-                });
-            }
-            else {
-                toCheck.push(pkg);
-            }
-        }
-        await Promise.all(toCheck.map(async (pkg) => {
-            const registryVersion = await npmViewVersion(pkg.name, pkg.dirname);
-            entries.set(pkg.name, {
-                package: pkg,
-                version: pkg.version,
-                registryVersion,
-                status: registryVersion === pkg.version ? 'up-to-date' : 'publish',
-                reason: registryVersion ? `registry has ${registryVersion}` : 'never published',
-            });
-        }));
-        return packages.map(pkg => entries.get(pkg.name));
-    }
-    PublishService.getPlan = getPlan;
-    /**
-     * Publishes every `'publish'` entry in `plan`, topological order (already `plan`'s own order -
-     * see `getPlan`), via the configured `packageManager`'s own `publish` command. Sequential, not
-     * concurrent: unlike `run`/`build`, a package genuinely needs its own dependencies to have
-     * landed on the registry first, and publishing is rare enough (once per release) that the
-     * simplicity is worth more than the parallelism `run` gets from `power-tasks`.
-     *
-     * If a package fails, every other still-pending entry depending on it (transitively) is marked
-     * `'error'` too and never attempted - publishing a package whose own new dependency range points
-     * at a version that never actually reached the registry would hand consumers a broken install.
-     * A package's own failure doesn't stop unrelated packages elsewhere in the plan, though.
-     */
-    async function applyPlan(repository, plan, options = {}) {
-        const packageManager = CiService.resolvePackageManager(repository, options.packageManager);
-        const failed = new Set();
-        const result = [];
-        const packagesByName = new Map(repository.getPackages().map(p => [p.name, p]));
-        for (const entry of plan) {
-            if (entry.status !== 'publish') {
-                result.push(entry);
-                continue;
-            }
-            const pkg = entry.package;
-            const blocker = pkg.dependencies.find(d => failed.has(d));
-            if (blocker) {
-                failed.add(pkg.name);
-                result.push({ ...entry, status: 'error', reason: `dependency "${blocker}" failed to publish` });
-                continue;
-            }
-            const publishDir = resolvePublishDir(pkg, options.contents);
-            const restore = preparePublishManifest(pkg, publishDir, packagesByName);
-            try {
-                await exec(buildPublishCommand(packageManager, options), { cwd: publishDir, stdio: 'inherit' });
-                result.push(entry);
-            }
-            catch (e) {
-                failed.add(pkg.name);
-                result.push({ ...entry, status: 'error', reason: e.message });
-            }
-            finally {
-                restore?.();
-            }
-        }
-        return result;
-    }
-    PublishService.applyPlan = applyPlan;
-})(PublishService || (PublishService = {}));
-const execFileAsync = promisify(execFile);
-/** `npm view <name> version`, optionally against a custom registry/`.npmrc` - `undefined` for any
- *  failure (never published, no network, private/restricted with no access, ...), same
- *  catch-everything shape as `change-hash.ts`'s own `defaultNpmViewVersion` (kept separate here
- *  since this one also needs `--registry`/`--userconfig`, which that one has no use for). */
-async function defaultNpmViewVersion(name, cwd, options) {
-    const argv = ['view', name, 'version'];
-    if (options.registry)
-        argv.push('--registry', options.registry);
-    if (options.userconfig)
-        argv.push('--userconfig', options.userconfig);
-    try {
-        const { stdout } = await execFileAsync('npm', argv, { cwd });
-        return stdout.trim() || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Where the publishable output lives, most specific statement first: the package's own
- *  `publishConfig.directory` (npm/pnpm's native spelling, and a statement about that one package),
- *  then `.rmanrc "publish.directory"` (which a `"[*]"` block can say once for a whole repository
- *  instead of repeating in every `package.json`), then `--contents` for a single run. */
-function resolvePublishDir(pkg, contentsOverride) {
-    const native = pkg.json.publishConfig?.directory;
-    const configured = pkg.config?.publish?.directory;
-    const rel = (typeof native === 'string' && native) || configured || contentsOverride;
-    return rel ? path.resolve(pkg.dirname, rel) : pkg.dirname;
-}
-function buildPublishCommand(packageManager, options) {
-    const args = ['publish'];
-    if (options.access)
-        args.push('--access', options.access);
-    if (options.tag)
-        args.push('--tag', options.tag);
-    if (options.otp)
-        args.push('--otp', options.otp);
-    if (options.registry)
-        args.push('--registry', options.registry);
-    if (options.userconfig)
-        args.push('--userconfig', options.userconfig);
-    return `${packageManager} ${args.join(' ')}`;
-}