@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/re-export-preflight.d.ts

@@ -1,23 +0,0 @@
-import type { ReExportOptions } from '../types/commands/index.js';
-/**
- * Reads a path list file: one engine-relative path per line, blank lines
- * and `#` comment lines ignored. Backs `--expect-from`, which exists because
- * a list held in one shell variable reaches the CLI as one argument under
- * zsh, and splitting it by hand left every path after the first as a
- * positional patch name.
- *
- * @param file - The list file, relative to the working directory
- * @param flag - Flag name for error messages
- */
-export declare function readPathListFile(file: string, flag: string): Promise<string[]>;
-/**
- * Runs every lock-free argument check: empty or unknown patch names
- * (naming an engine file passed by mistake), option combinations, path
- * flag values that are flags, and path flag values that name no changed
- * file. Throws the refusal the locked run would have thrown, only sooner.
- *
- * @param projectRoot - Project root
- * @param patches - Positional patch arguments as given
- * @param options - Options as the command layer builds them
- */
-export declare function preflightReExportArguments(projectRoot: string, patches: readonly string[], options: ReExportOptions): Promise<void>;

package/dist/src/commands/re-export-preflight.js

@@ -1,159 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Argument checks `fireforge re-export` runs before it queues for the
- * engine session lock.
- *
- * Under contention the lock wait runs to many minutes, and an argument the
- * run was always going to refuse (an empty patch name from an unquoted
- * `"$@"`, a changed-file path passed as a positional, a path flag that
- * swallowed the next flag) is reported before that wait: these checks read the manifest and a path-scoped `git status` without the lock.
- * The command repeats its own resolution under the lock, so a manifest that
- * changes in between is still read fresh there.
- */
-import { readFile } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { getProjectPaths } from '../core/config.js';
-import { isGitRepository } from '../core/git.js';
-import { chunkPathspecs } from '../core/git-base.js';
-import { getDirtyFiles } from '../core/git-status.js';
-import { formatPatchNotFoundError } from '../core/patch-identifier-suggest.js';
-import { loadPatchesManifest, resolvePatchIdentifier } from '../core/patch-manifest.js';
-import { InvalidArgumentError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
-import { pathExists } from '../utils/fs.js';
-import { normalizeReExportFilesPositionals, validateReExportOptionCombinations, } from './re-export-options.js';
-import { normalizeEngineRelativeInput } from './re-export-scan.js';
-import { splitScanFileOwner } from './re-export-scan-owner.js';
-/**
- * Reads a path list file: one engine-relative path per line, blank lines
- * and `#` comment lines ignored. Backs `--expect-from`, which exists because
- * a list held in one shell variable reaches the CLI as one argument under
- * zsh, and splitting it by hand left every path after the first as a
- * positional patch name.
- *
- * @param file - The list file, relative to the working directory
- * @param flag - Flag name for error messages
- */
-export async function readPathListFile(file, flag) {
-    let text;
-    try {
-        text = await readFile(resolve(file), 'utf8');
-    }
-    catch (error) {
-        throw new InvalidArgumentError(`${flag} could not read ${file}: ${toError(error).message}`, flag);
-    }
-    const paths = text
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0 && !line.startsWith('#'));
-    if (paths.length === 0) {
-        throw new InvalidArgumentError(`${flag} file ${file} lists no paths. An empty list is usually a generation step that ` +
-            `failed; write one engine-relative path per line, or drop ${flag}.`, flag);
-    }
-    return paths;
-}
-/** Engine-relative form of a positional, or undefined when it cannot be one. */
-function asEnginePath(value) {
-    try {
-        return normalizeEngineRelativeInput(value, 'patch');
-    }
-    catch {
-        return undefined;
-    }
-}
-async function resolvePositionals(engineDir, patches, manifest) {
-    for (const identifier of patches) {
-        if (resolvePatchIdentifier(identifier, manifest.patches))
-            continue;
-        const enginePath = asEnginePath(identifier);
-        if (enginePath !== undefined && (await pathExists(join(engineDir, enginePath)))) {
-            throw new InvalidArgumentError(`"${identifier}" is a file in engine/, not a patch. re-export takes patch identifiers ` +
-                `as positionals. To name a file whose drift this run expects, pass --expect ` +
-                `${enginePath} (one --expect per path), or list the paths one per line in a file ` +
-                'and pass --expect-from <file>.', identifier);
-        }
-        throw new InvalidArgumentError(formatPatchNotFoundError(identifier, manifest.patches), identifier);
-    }
-}
-/**
- * Refuses a path flag value that names no changed file in engine/. Every
- * one of these flags is about a changed file (drift to expect, an unmanaged
- * file to admit, a file to adopt), so a clean or absent path is a typo or a
- * swallowed argument, and the run would otherwise treat it as a no-op.
- */
-async function assertFlagPathsInStatus(engineDir, options, manifest) {
-    const normalize = (flag, values) => [
-        flag,
-        (values ?? []).map((value) => normalizeEngineRelativeInput(value, flag)),
-    ];
-    const expectNew = normalize('--expect-new', options.expectNew);
-    const byFlag = [
-        normalize('--expect', options.expect),
-        normalize('--expect-unmanaged', options.expectUnmanaged),
-        expectNew,
-        normalize('--scan-file', options.scanFiles?.map((value) => splitScanFileOwner(value).path)),
-    ];
-    const all = [...new Set(byFlag.flatMap(([, values]) => values))];
-    if (all.length === 0 || !(await isGitRepository(engineDir)))
-        return;
-    const changed = new Set();
-    try {
-        for (const chunk of chunkPathspecs(all)) {
-            for (const file of await getDirtyFiles(engineDir, chunk))
-                changed.add(file);
-        }
-    }
-    catch {
-        // An engine git cannot answer for (no HEAD yet, a broken checkout) is
-        // the locked run's engine precondition to report, with its own remedy.
-        return;
-    }
-    for (const [flag, values] of byFlag) {
-        const absent = values.filter((value) => !changed.has(value));
-        if (absent.length > 0) {
-            throw new InvalidArgumentError(`${flag} names no changed file in engine/: ${absent.join(', ')}. Each value must be a ` +
-                'path git status lists (modified, deleted or untracked); a clean or missing path is a ' +
-                'typo or a list that ended early, and the run would have ignored it.', flag);
-        }
-    }
-    const owners = new Map();
-    for (const patch of manifest.patches) {
-        for (const file of patch.filesAffected)
-            owners.set(file, patch.filename);
-    }
-    const owned = expectNew[1].filter((file) => owners.has(file));
-    if (owned.length > 0) {
-        throw new InvalidArgumentError(`--expect-new names a file a patch already owns: ` +
-            `${owned.map((file) => `${file} (${owners.get(file) ?? ''})`).join(', ')}. ` +
-            '--expect-new is for files no patch owns yet; drop it for these.', '--expect-new');
-    }
-}
-/**
- * Runs every lock-free argument check: empty or unknown patch names
- * (naming an engine file passed by mistake), option combinations, path
- * flag values that are flags, and path flag values that name no changed
- * file. Throws the refusal the locked run would have thrown, only sooner.
- *
- * @param projectRoot - Project root
- * @param patches - Positional patch arguments as given
- * @param options - Options as the command layer builds them
- */
-export async function preflightReExportArguments(projectRoot, patches, options) {
-    const empty = patches.filter((patch) => patch.trim().length === 0).length;
-    if (empty > 0) {
-        throw new InvalidArgumentError(`re-export was given ${empty} empty patch argument(s). An empty argument is usually a ` +
-            'shell expansion that produced nothing (an unquoted "$@" in a heredoc, an unset ' +
-            'variable); pass patch identifiers, or --all.', 'patches');
-    }
-    const normalized = normalizeReExportFilesPositionals(patches, options);
-    validateReExportOptionCombinations(normalized.patches, normalized.options);
-    const paths = getProjectPaths(projectRoot);
-    const manifest = await loadPatchesManifest(paths.patches);
-    // No manifest: the locked run reports that with its own remedy.
-    if (!manifest || manifest.patches.length === 0)
-        return;
-    if (options.all !== true) {
-        await resolvePositionals(paths.engine, normalized.patches, manifest);
-    }
-    await assertFlagPathsInStatus(paths.engine, normalized.options, manifest);
-}

package/dist/src/commands/re-export-purity-scope.d.ts

@@ -1,18 +0,0 @@
-import type { PatchMetadata } from '../types/commands/index.js';
-/** What a scoped dry run could touch: the patches it was asked about. */
-export interface DryRunPurityScope {
-    /** The selected patches. */
-    patches: readonly PatchMetadata[];
-}
-/**
- * Fingerprints exactly the state a scoped `re-export --dry-run` could
- * disturb. Every key names what it covers, so a violation reads as the
- * path that moved.
- */
-export declare function fingerprintScopedDryRunState(engineDir: string, patchesDir: string, scope: DryRunPurityScope): Promise<Map<string, string>>;
-/**
- * Names whoever else wrote during the dry run: history records from other
- * invocations since it started, and a live holder of the engine-session
- * lock (which a dry run does not take). Empty when there is no evidence.
- */
-export declare function describeForeignWriters(patchesDir: string, sinceMs: number): Promise<string[]>;

package/dist/src/commands/re-export-purity-scope.js

@@ -1,137 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The scoped half of the `re-export --dry-run` purity guard.
- *
- * A dry run takes no engine-session lock, so peers keep writing while it
- * runs. A whole-tree fingerprint would report every peer's write as
- * "invariant violated … This is a FireForge bug". The scoped fingerprint covers only what the
- * dry run could touch: the selected patches' bodies and manifest rows, the
- * engine files they own, the engine HEAD and the engine index. A mismatch
- * that remains is attributed to a foreign writer when the history log or
- * the engine lock shows one in the window.
- */
-import { readFile } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-import { readEngineSessionLockStatus } from '../core/engine-session-lock.js';
-import { git } from '../core/git-base.js';
-import { historyRecordIdentity, resolveHistoryLogPath } from '../core/history-log-file.js';
-import { PATCHES_MANIFEST } from '../core/patch-manifest-io.js';
-import { canonicalizePatchRow } from '../core/patch-manifest-key-order.js';
-import { GeneralError } from '../errors/base.js';
-import { getNodeErrorCode, toError } from '../utils/errors.js';
-import { sha256Hex } from '../utils/hash.js';
-import { isArray, isObject } from '../utils/validation.js';
-/** Reads a file's bytes as a hash, `absent` when it does not exist. */
-async function hashOrAbsent(path, label) {
-    try {
-        return sha256Hex(await readFile(path));
-    }
-    catch (error) {
-        const code = getNodeErrorCode(error);
-        if (code === 'ENOENT' || code === 'ENOTDIR')
-            return 'absent';
-        throw new GeneralError(`[dry-run] cannot fingerprint ${label} for the purity guard: ${toError(error).message}`, error);
-    }
-}
-/**
- * The selected rows of `patches.json`, so a peer's write to another row is
- * not a violation. Rows are hashed in canonical key order: a peer's write
- * that only canonicalizes a selected row's key order changes no content.
- */
-async function selectedRowsFingerprint(patchesDir, filenames) {
-    let raw;
-    try {
-        raw = await readFile(join(patchesDir, PATCHES_MANIFEST), 'utf8');
-    }
-    catch (error) {
-        if (getNodeErrorCode(error) === 'ENOENT')
-            return 'absent';
-        throw error;
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        const rows = isObject(parsed) && isArray(parsed['patches']) ? parsed['patches'] : [];
-        const selected = rows
-            .filter((row) => isObject(row) && typeof row['filename'] === 'string' && filenames.has(row['filename']))
-            .map((row) => (isObject(row) ? canonicalizePatchRow(row) : row));
-        return sha256Hex(JSON.stringify(selected));
-    }
-    catch {
-        // A manifest that no longer parses changed, whoever wrote it.
-        return sha256Hex(raw);
-    }
-}
-/**
- * Fingerprints exactly the state a scoped `re-export --dry-run` could
- * disturb. Every key names what it covers, so a violation reads as the
- * path that moved.
- */
-export async function fingerprintScopedDryRunState(engineDir, patchesDir, scope) {
-    const fingerprint = new Map();
-    try {
-        fingerprint.set('engine HEAD', (await git(['rev-parse', 'HEAD'], engineDir)).trim());
-        // The index as a whole: the historic purity defect was a transient
-        // `--intent-to-add` entry, which may land on any path a scan reads.
-        fingerprint.set('the engine index', sha256Hex(await git(['ls-files', '--stage', '-z'], engineDir)));
-    }
-    catch (error) {
-        throw new GeneralError(`[dry-run] cannot fingerprint the engine for the purity guard: ${toError(error).message}`, error);
-    }
-    const filenames = new Set(scope.patches.map((patch) => patch.filename));
-    fingerprint.set(`${PATCHES_MANIFEST} rows of ${[...filenames].sort().join(', ')}`, await selectedRowsFingerprint(patchesDir, filenames));
-    for (const filename of [...filenames].sort()) {
-        fingerprint.set(`patches/${filename}`, await hashOrAbsent(join(patchesDir, filename), `patches/${filename}`));
-    }
-    const owned = [...new Set(scope.patches.flatMap((patch) => patch.filesAffected))].sort();
-    for (const file of owned) {
-        fingerprint.set(`engine/${file}`, await hashOrAbsent(join(engineDir, file), `engine/${file}`));
-    }
-    return fingerprint;
-}
-/** History records another invocation wrote at or after `sinceMs`. */
-async function foreignHistoryRecords(projectRoot, sinceMs) {
-    let text;
-    try {
-        text = await readFile(await resolveHistoryLogPath(projectRoot), 'utf8');
-    }
-    catch {
-        return [];
-    }
-    const own = historyRecordIdentity().invocationId;
-    const writers = [];
-    for (const line of text.split('\n').slice(-500)) {
-        let record;
-        try {
-            record = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        const ts = typeof record.ts === 'string' ? Date.parse(record.ts) : Number.NaN;
-        if (!(ts >= sinceMs) || record.invocationId === own)
-            continue;
-        const session = typeof record.sessionId === 'string' ? `, session ${record.sessionId}` : '';
-        writers.push(`${String(record.operation)} (PID ${String(record.pid)}${session})`);
-    }
-    return writers;
-}
-/**
- * Names whoever else wrote during the dry run: history records from other
- * invocations since it started, and a live holder of the engine-session
- * lock (which a dry run does not take). Empty when there is no evidence.
- */
-export async function describeForeignWriters(patchesDir, sinceMs) {
-    const projectRoot = dirname(resolve(patchesDir));
-    const writers = await foreignHistoryRecords(projectRoot, sinceMs);
-    try {
-        const lock = await readEngineSessionLockStatus(projectRoot);
-        if (lock.held && lock.holder !== undefined && lock.holder.pid !== process.pid) {
-            const detail = lock.holder.metadata.length > 0 ? ` (${lock.holder.metadata.join(', ')})` : '';
-            writers.push(`the engine-session lock holder, PID ${lock.holder.pid}${detail}`);
-        }
-    }
-    catch {
-        // Attribution is best effort; the violation is reported either way.
-    }
-    return writers;
-}

package/dist/src/commands/re-export-register.d.ts

@@ -1,12 +0,0 @@
-/**
- * CLI registration for `fireforge re-export`.
- *
- * Split out of `re-export.ts`, which was otherwise over the per-file line
- * cap. The split direction matches the existing `re-export-scan.ts` /
- * `re-export-options.ts` boundary. Folding `re-export-files.ts` back into
- * the orchestrator would go the wrong way.
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-/** Registers the re-export command on the CLI program. */
-export declare function registerReExport(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/re-export-register.js

@@ -1,99 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * CLI registration for `fireforge re-export`.
- *
- * Split out of `re-export.ts`, which was otherwise over the per-file line
- * cap. The split direction matches the existing `re-export-scan.ts` /
- * `re-export-options.ts` boundary. Folding `re-export-files.ts` back into
- * the orchestrator would go the wrong way.
- */
-import { Command, Option } from 'commander';
-import { getProjectPaths } from '../core/config.js';
-import { withEngineSessionLock } from '../core/engine-session-lock.js';
-import { withPrivateGitIndex } from '../core/git-readonly-index.js';
-import { addWaitLockOption, pickDefined, resolveWaitLockSeconds, stringListOption, } from '../utils/options.js';
-import { reExportCommand } from './re-export.js';
-import { preflightReExportArguments, readPathListFile } from './re-export-preflight.js';
-/** Registers the re-export command on the CLI program. */
-export function registerReExport(program, { getProjectRoot, withErrorHandling }) {
-    const reExport = program
-        .command('re-export [patches...]')
-        .description('Refresh existing patch bodies (and filesAffected with --scan) from the current engine ' +
-        'state. Does NOT change sourceVersion/sourceProduct by default — use --stamp or run ' +
-        'rebase for source metadata stamping.')
-        .option('-a, --all', 'Re-export all patches')
-        .option('-s, --scan', 'Scan directories for new/removed files and update filesAffected')
-        .option('--scan-file <path>', 'With --scan, add this explicit engine-relative file without collecting adjacent files. Prefix the owning patch (<patch>:<path>, required with several target patches) to adopt into one of them; selected patches without a --scan-file refresh scan-less. Repeatable.', ...stringListOption())
-        .option('--scan-files <manifest>', 'With --scan, bulk-assign generated files from a JSON manifest: {"assignments":[{"patch":"002-name.patch","files":["path"]}]}. Selects the patches the manifest names, plus any positional patches (a positional the manifest does not name refreshes scan-less).')
-        .option('--files <paths>', 'Restrict the re-exported filesAffected to this comma-separated list (single target patch only)', (value) => value
-        .split(',')
-        .map((v) => v.trim())
-        .filter((v) => v.length > 0))
-        .option('--refuse-adjacent-unmanaged', 'Refuse a re-export (non-zero exit, patch not written) when unmanaged files exist adjacent to the patch ownership, instead of warning. Adjacent means the same directory as an owned file (not a sibling or nested directory), or named by a registration line the patch adds. Beside --scan it judges the files the scan did not adopt. Mutually exclusive with --files.')
-        .option('--refuse-foreign-drift', "Refuse a re-export (non-zero exit, patch not written) when the refreshed body would add or drop lines, in a file the patch already owns, that the old patch body did not carry — protects multi-session checkouts from silently capturing another session's uncommitted edits. Beside --scan it guards each patch's existing files (adopted files count as expected). Mutually exclusive with --files.")
-        .option('--expect <path>', "With --refuse-foreign-drift, name an engine-relative file whose drift is this session's intended edit: drift confined to --expect files proceeds, drift anywhere else still refuses. Repeatable, and the whitelist applies across EVERY patch in this invocation, not per patch — so pass all the patches and all their --expect paths in one call rather than looping one patch at a time.", ...stringListOption())
-        .option('--expect-unmanaged <path>', 'With --refuse-adjacent-unmanaged, name an engine-relative file that is a REVIEWED, recorded exception to the adjacency refusal: an approved unmanaged path is still listed, but no longer refuses. Repeatable, and the carve-out applies across EVERY patch in this invocation, not per patch. Use it to keep the belt armed for everything else instead of dropping --refuse-adjacent-unmanaged entirely.', ...stringListOption())
-        .option('--expect-from <file>', 'Read --expect paths from a file, one engine-relative path per line (blank lines and # comments ignored). Adds to any --expect flags.')
-        .option('--expect-new <path>', 'With --refuse-adjacent-unmanaged, name a file this session created and will adopt with its next export (or --scan-file): it passes the belt and is reported, while every other adjacent file still refuses. Must be changed in engine/ and owned by no patch. Repeatable.', ...stringListOption())
-        .option('--adjacent-ignore <path|glob>', 'With --refuse-adjacent-unmanaged, a reviewed ignore-list entry: an engine-relative path, or a glob whose * stays within one path segment (** is refused). Matches are reported, never refused. Repeatable.', ...stringListOption())
-        .option('--expect-removed <path>', 'Retire a file from the selected patch while keeping scan-less refusals armed: an absent file the patch created, or a patch-modified upstream file whose engine copy is back at HEAD. Repeatable.', ...stringListOption())
-        .option('--dry-run', 'Show what would change without writing')
-        .option('--skip-lint', 'Skip patch lint checks (downgrade errors to warnings)')
-        .option('--no-cache', 'Bypass per-patch lint result cache reads and writes for this re-export')
-        .option('--allow-stale-furnace', 'Export the deployed engine copy even when the components/ source changed since the last furnace apply')
-        .option('--allow-shrink', 'Allow --files to remove paths currently owned by the patch. Required before --yes can bypass the shrink confirmation.')
-        .option('--declarations-out <path>', 'Where a refused --scan adoption writes its one --from-ready staged-declaration report (default: .fireforge/declarations/<timestamp>.json).')
-        .option('--hunks-from <diff>', "Export each file the diff names as the patch's current body plus only the diff's hunks, so another session's edits in the same file stay out. Takes git diff or plain diff -u output; for a file the patch creates, diff against `fireforge patch body <patch> <file>`. One explicit patch; not with --scan, --files or --all.")
-        .option('--exclude-hunks <diff>', "Export each file the diff names as the working tree minus the diff's hunks. One explicit patch; not with --scan, --files or --all.")
-        .option('-y, --yes', 'Skip confirmation prompts (required for non-TTY destructive writes)')
-        .option('--force-unsafe', 'Bypass cross-patch lint refusal when --files shrinks a patch')
-        .option('--stamp', "After every selected patch refreshes cleanly, stamp each re-exported patch's sourceVersion/sourceProduct in patches.json to firefox.version/firefox.product from fireforge.json. No effect on a partial run.")
-        .addOption(new Option('--tier <tier>', 'Force a tier override on the selected patch (only "branding" recognised). Mutually exclusive with --all.').choices(['branding']))
-        .option('--lint-ignore <check-id>', 'Append a lint check ID to the patch\'s PatchMetadata.lintIgnore (union, de-duped, repeatable). Mutually exclusive with --all. Use "fireforge patch lint-ignore" for --remove / --clear.', ...stringListOption());
-    addWaitLockOption(reExport).action(withErrorHandling(async (patches, options) => {
-        const projectRoot = getProjectRoot();
-        const reExportOptions = await toReExportOptions(options);
-        // Refuse what the locked run would refuse before queueing for the
-        // lock, which can be a long wait under contention.
-        await preflightReExportArguments(projectRoot, patches, reExportOptions);
-        // A dry run writes nothing, so it does not queue behind peers' builds
-        // and test runs for the engine lock. Its git plumbing runs on a
-        // private index, so not even git's stat-cache refresh reaches the
-        // shared `.git/index`; dry runs still serialize among themselves.
-        if (reExportOptions.dryRun === true) {
-            const engineDir = getProjectPaths(projectRoot).engine;
-            await withPrivateGitIndex(engineDir, () => reExportCommand(projectRoot, patches, reExportOptions));
-            return;
-        }
-        await withEngineSessionLock(projectRoot, 're-export', () => reExportCommand(projectRoot, patches, reExportOptions), { waitLockSeconds: resolveWaitLockSeconds(options.waitLock) });
-    }));
-}
-/**
- * Maps commander's option names onto {@link ReExportOptions}, reading the
- * `--expect-from` list into `expect` and dropping empty repeatables.
- */
-async function toReExportOptions(options) {
-    const { tier, lintIgnore, scanFile, scanFiles, cache, expect: expectFlags, expectFrom, expectUnmanaged, expectNew, adjacentIgnore, ...rest } = options;
-    const expect = [
-        ...(expectFlags ?? []),
-        ...(expectFrom !== undefined ? await readPathListFile(expectFrom, '--expect-from') : []),
-    ];
-    return {
-        ...pickDefined({
-            ...rest,
-            scanFiles: nonEmpty(scanFile),
-            scanFilesManifest: scanFiles,
-            tier: tier,
-            lintIgnore: nonEmpty(lintIgnore),
-            expect: nonEmpty(expect),
-            expectUnmanaged: nonEmpty(expectUnmanaged),
-            expectNew: nonEmpty(expectNew),
-            adjacentIgnore: nonEmpty(adjacentIgnore),
-        }),
-        ...(cache === false ? { noCache: true } : {}),
-    };
-}
-/** The list when it has entries, else undefined (which `pickDefined` drops). */
-function nonEmpty(values) {
-    return values !== undefined && values.length > 0 ? values : undefined;
-}

package/dist/src/commands/re-export-removed.d.ts

@@ -1,15 +0,0 @@
-import type { PatchMetadata, ReExportOptions } from '../types/commands/index.js';
-import type { ProjectPaths } from '../types/config.js';
-/**
- * Validates every retirement before any patch is written; typos never
- * silently grant a carve-out. Two shapes retire a file from its one
- * selected owner:
- *
- *  - a file the patch created (`new file mode` section), now absent from
- *    disk and untracked in engine HEAD;
- *  - an upstream file the patch modified or deleted, whose engine copy is
- *    back at HEAD (present, tracked, no diff). A scan-less re-export keeps
- *    `filesAffected` as it is, so without this the stale entry would stay
- *    in the manifest and in the reserved-range policy check.
- */
-export declare function validateExpectedRemovals(paths: ProjectPaths, patches: PatchMetadata[], options: ReExportOptions, queue?: readonly PatchMetadata[]): Promise<string[]>;

package/dist/src/commands/re-export-removed.js

@@ -1,94 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { lstat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { listTrackedInHead } from '../core/git-file-ops.js';
-import { getDirtyFiles } from '../core/git-status.js';
-import { parseDiffSections } from '../core/patch-parse.js';
-import { InvalidArgumentError } from '../errors/base.js';
-import { getNodeErrorCode } from '../utils/errors.js';
-import { readText } from '../utils/fs.js';
-import { normalizeEngineRelativeInput } from './re-export-scan.js';
-/**
- * Validates every retirement before any patch is written; typos never
- * silently grant a carve-out. Two shapes retire a file from its one
- * selected owner:
- *
- *  - a file the patch created (`new file mode` section), now absent from
- *    disk and untracked in engine HEAD;
- *  - an upstream file the patch modified or deleted, whose engine copy is
- *    back at HEAD (present, tracked, no diff). A scan-less re-export keeps
- *    `filesAffected` as it is, so without this the stale entry would stay
- *    in the manifest and in the reserved-range policy check.
- */
-export async function validateExpectedRemovals(paths, patches, options, queue = patches) {
-    const removed = [
-        ...new Set((options.expectRemoved ?? []).map((file) => normalizeEngineRelativeInput(file, '--expect-removed'))),
-    ];
-    if (removed.length === 0)
-        return removed;
-    const tracked = await listTrackedInHead(paths.engine, removed);
-    const dirty = new Set(await getDirtyFiles(paths.engine, [...tracked]));
-    for (const file of removed) {
-        const owners = patches.filter((patch) => patch.filesAffected.includes(file));
-        const owner = owners[0];
-        if (owners.length !== 1 || owner === undefined) {
-            throw new InvalidArgumentError(`--expect-removed ${file} must be owned by exactly one selected patch.` +
-                unselectedOwnerHint(file, patches, queue), '--expect-removed');
-        }
-        const section = parseDiffSections(await readText(join(paths.patches, owner.filename))).find((candidate) => candidate.targetPath === file);
-        if (tracked.has(file)) {
-            assertUpstreamFileBackAtHead(file, owner, section !== undefined && !section.isNewFile, dirty);
-        }
-        else {
-            await assertCreatedFileAbsent(paths, file, owner, section?.isNewFile === true);
-        }
-        if (owner.filesAffected.every((path) => removed.includes(path))) {
-            throw new InvalidArgumentError('Retiring every file would empty the patch; use patch delete instead.', '--expect-removed');
-        }
-    }
-    return removed;
-}
-/**
- * Each path retires from its own owner, so one run may retire paths from
- * several selected patches. A path whose owner was left out of the
- * selection names that owner, since adding it is the usual fix.
- */
-function unselectedOwnerHint(file, selected, queue) {
-    const selectedNames = new Set(selected.map((patch) => patch.filename));
-    const outside = queue
-        .filter((patch) => !selectedNames.has(patch.filename) && patch.filesAffected.includes(file))
-        .map((patch) => patch.filename);
-    if (outside.length === 0)
-        return '';
-    return ` It is owned by ${outside.join(', ')}, which this run did not select; add it to the selection to retire both in one run.`;
-}
-async function assertCreatedFileAbsent(paths, file, owner, createdByOwner) {
-    if (await removalPathPresent(join(paths.engine, file))) {
-        throw new InvalidArgumentError(`--expect-removed ${file} is untracked in engine HEAD and still present on disk; ` +
-            'a patch-created file can be retired only once it is deleted.', '--expect-removed');
-    }
-    if (!createdByOwner) {
-        throw new InvalidArgumentError(`--expect-removed ${file} was not created by its selected patch ${owner.filename}.`, '--expect-removed');
-    }
-}
-function assertUpstreamFileBackAtHead(file, owner, changedByOwner, dirty) {
-    if (dirty.has(file)) {
-        throw new InvalidArgumentError(`--expect-removed ${file} is tracked in engine HEAD, but its engine copy still differs ` +
-            'from HEAD. Restore the HEAD copy first, then retire it.', '--expect-removed');
-    }
-    if (!changedByOwner) {
-        throw new InvalidArgumentError(`--expect-removed ${file} is not changed by its selected patch ${owner.filename}.`, '--expect-removed');
-    }
-}
-/** A dangling symlink is still an existing owned path, not an approved absence. */
-async function removalPathPresent(path) {
-    try {
-        await lstat(path);
-        return true;
-    }
-    catch (error) {
-        if (getNodeErrorCode(error) === 'ENOENT')
-            return false;
-        throw error;
-    }
-}

package/dist/src/commands/re-export-retired-declarations.d.ts

@@ -1,22 +0,0 @@
-import type { PatchesManifest, PatchMetadata, ReExportOptions } from '../types/commands/index.js';
-import type { ProjectPaths } from '../types/config.js';
-/** What {@link dropRetiredPathDeclarations} needs from the run. */
-export interface RetiredPathDeclarationsArgs {
-    /** Resolved project paths. */
-    paths: ProjectPaths;
-    /** The queue as the run loaded it (judged in a dry run). */
-    manifest: PatchesManifest;
-    /** The run's options; `expectRemoved` holds the validated paths. */
-    options: ReExportOptions;
-    /** The run's selected patches. */
-    selectedPatches: readonly PatchMetadata[];
-    /** Name the drops without writing. */
-    isDryRun: boolean;
-}
-/**
- * Drops (or, in a dry run, names) every staged declaration whose `creates`
- * path this run retired. Runs after the selected patches are written, so a
- * path whose owner failed to re-export is still owned and its declarations
- * stay.
- */
-export declare function dropRetiredPathDeclarations(args: RetiredPathDeclarationsArgs): Promise<void>;