@hominis/fireforge 0.54.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 && options.scanFilesManifest === undefined) {
-        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 patches from the manifest.')
-        .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. 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>;