@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/commands/patch/staged-dependency-batch.js

@@ -1,176 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Batch input and history delta for `patch staged-dependency`.
- *
- * `--from <json-file>` lets one `--add` call declare many edges under one
- * lock hold. Turning on `patchLint.forwardRegistration: "extended"` on a real
- * queue surfaced hundreds of undeclared registrations, each printed with its
- * own command, and one call per edge was the only way to declare them. The
- * file is either a `lint --per-patch --report` JSON (its findings carry the
- * `stagedDeclarations` that discharge them) or a plain array of
- * declarations.
- *
- * The history record of every call holds only the delta (`added` /
- * `removed`). Recording the patch's whole list before and after grew the
- * log quadratically with the list: 849 single-edge calls took one consumer's
- * log from 36 MB to 184 MB.
- */
-import { InvalidArgumentError } from '../../errors/base.js';
-import { toError } from '../../utils/errors.js';
-import { readJson } from '../../utils/fs.js';
-import { isArray, isObject } from '../../utils/validation.js';
-function optionalString(record, key, label) {
-    const value = record[key];
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== 'string' || value.length === 0) {
-        throw new InvalidArgumentError(`${label}.${key} must be a non-empty string.`, '--from');
-    }
-    return value;
-}
-function requiredString(record, key, label) {
-    const value = optionalString(record, key, label);
-    if (value === undefined) {
-        throw new InvalidArgumentError(`${label} is missing "${key}".`, '--from');
-    }
-    return value;
-}
-/**
- * Collects the declaration records a parsed file holds: a lint report's
- * `stagedDeclarations` (from `queueIssues` and every patch's `issues`), or
- * the elements of a plain array.
- */
-function collectRecords(data) {
-    if (isArray(data)) {
-        return data.map((entry, index) => {
-            if (!isObject(entry)) {
-                throw new InvalidArgumentError(`--from entry [${index}] must be an object.`, '--from');
-            }
-            return { record: entry, label: `--from entry [${index}]` };
-        });
-    }
-    if (!isObject(data)) {
-        throw new InvalidArgumentError('--from must hold a JSON array of declarations or a "lint --per-patch --report" document.', '--from');
-    }
-    const issues = [];
-    if (isArray(data['queueIssues']))
-        issues.push(...data['queueIssues']);
-    if (isArray(data['patches'])) {
-        for (const patch of data['patches']) {
-            if (isObject(patch) && isArray(patch['issues']))
-                issues.push(...patch['issues']);
-        }
-    }
-    const records = [];
-    for (const issue of issues) {
-        if (!isObject(issue) || !isArray(issue['stagedDeclarations']))
-            continue;
-        for (const declaration of issue['stagedDeclarations']) {
-            if (isObject(declaration)) {
-                records.push({
-                    record: declaration,
-                    label: `stagedDeclarations of [${String(issue['check'])}] ${String(issue['file'])}`,
-                });
-            }
-        }
-    }
-    return records;
-}
-/**
- * Reads the declarations a `--from` file supplies for `targetFilename`.
- *
- * Every entry takes `file`, `creates`, optional `owner` and `reason`, and
- * either `specifier` (an import) or `line` (a registration); `kind` may
- * name the shape explicitly. An entry with a `patch` field naming another
- * patch is skipped and counted, so one report can be applied patch by
- * patch. `defaultReason` (the `--reason` flag) fills entries without one.
- *
- * @param path - The JSON file
- * @param targetFilename - Filename of the patch being edited
- * @param defaultReason - Reason for entries that carry none
- */
-export async function readStagedDependencyBatch(path, targetFilename, defaultReason) {
-    let data;
-    try {
-        data = await readJson(path);
-    }
-    catch (error) {
-        throw new InvalidArgumentError(`--from ${path} could not be read as JSON: ${toError(error).message}`, '--from');
-    }
-    const batch = {
-        forwardImports: [],
-        registrations: [],
-        skippedForOtherPatches: 0,
-    };
-    for (const { record, label } of collectRecords(data)) {
-        const patch = optionalString(record, 'patch', label);
-        if (patch !== undefined && patch !== targetFilename) {
-            batch.skippedForOtherPatches += 1;
-            continue;
-        }
-        const specifier = optionalString(record, 'specifier', label);
-        const line = optionalString(record, 'line', label);
-        const kind = record['kind'] ?? (line !== undefined ? 'registration' : 'import');
-        if (kind !== 'import' && kind !== 'registration') {
-            throw new InvalidArgumentError(`${label}.kind must be "import" or "registration".`, '--from');
-        }
-        const file = requiredString(record, 'file', label);
-        const creates = requiredString(record, 'creates', label);
-        const owner = optionalString(record, 'owner', label);
-        const reason = optionalString(record, 'reason', label) ?? defaultReason;
-        const extras = {
-            ...(owner !== undefined ? { owner } : {}),
-            ...(reason !== undefined ? { reason } : {}),
-        };
-        if (kind === 'import') {
-            if (specifier === undefined || line !== undefined) {
-                throw new InvalidArgumentError(`${label} is an import declaration and needs "specifier" (not "line").`, '--from');
-            }
-            batch.forwardImports.push({ file, specifier, creates, ...extras });
-        }
-        else {
-            if (line === undefined || specifier !== undefined) {
-                throw new InvalidArgumentError(`${label} is a registration declaration and needs "line" (not "specifier").`, '--from');
-            }
-            batch.registrations.push({ file, line, creates, ...extras });
-        }
-    }
-    return batch;
-}
-function entryKey(entry) {
-    return JSON.stringify(entry);
-}
-function difference(left, right) {
-    const keys = new Set((right ?? []).map(entryKey));
-    return (left ?? []).filter((entry) => !keys.has(entryKey(entry)));
-}
-function nonEmpty(staged) {
-    const forwardImports = staged.forwardImports ?? [];
-    const registrations = staged.registrations ?? [];
-    if (forwardImports.length === 0 && registrations.length === 0)
-        return undefined;
-    return {
-        ...(forwardImports.length > 0 ? { forwardImports } : {}),
-        ...(registrations.length > 0 ? { registrations } : {}),
-    };
-}
-/**
- * The history delta between two committed `stagedDependencies` values:
- * the declarations the call added and the ones it removed. Each side is
- * omitted when empty. Older log records carry `before`/`after` instead;
- * a reader should accept either.
- */
-export function stagedDependencyDelta(before, after) {
-    const added = nonEmpty({
-        forwardImports: difference(after?.forwardImports, before?.forwardImports),
-        registrations: difference(after?.registrations, before?.registrations),
-    });
-    const removed = nonEmpty({
-        forwardImports: difference(before?.forwardImports, after?.forwardImports),
-        registrations: difference(before?.registrations, after?.registrations),
-    });
-    return {
-        ...(added !== undefined ? { added } : {}),
-        ...(removed !== undefined ? { removed } : {}),
-    };
-}

package/dist/src/commands/patch/staged-dependency-entries.d.ts

@@ -1,44 +0,0 @@
-/**
- * Kind-neutral views and list operations over staged-dependency
- * declarations, shared by `patch staged-dependency` and its `--from` batch
- * path. Split out of `staged-dependency.ts` for the per-file line budget.
- */
-import type { PatchStagedDependencies, PatchStagedForwardImport, PatchStagedRegistration } from '../../types/commands/index.js';
-/** The command's mutation mode. */
-export type StagedDependencyMode = 'add' | 'remove' | 'clear';
-/** The declaration shape (`--kind`). */
-export type StagedDependencyKind = 'import' | 'registration';
-/**
- * One staged-dependency entry of either kind. The `matcher` field is the
- * kind-specific middle term: the import specifier for import entries, the
- * registration line for registration entries. Key/removal/label logic is
- * shared across kinds through this shape.
- */
-export interface StagedEntryView {
-    file: string;
-    matcher: string;
-    creates: string;
-    owner?: string;
-    reason?: string;
-}
-/** View of an import declaration. */
-export declare function importView(dependency: PatchStagedForwardImport): StagedEntryView;
-/** View of a registration declaration. */
-export declare function registrationView(dependency: PatchStagedRegistration): StagedEntryView;
-/** One-line operator label for a declaration. */
-export declare function dependencyLabel(kind: StagedDependencyKind, view: StagedEntryView): string;
-/**
- * Applies one add/remove/clear to a declaration list: `add` appends unless
- * an entry with the same file, matcher, creates and owner exists. A
- * matching entry whose `reason` differs from the addition's takes
- * the new reason in place, keeping its position in the list; an addition
- * without a reason leaves the existing one alone.
- */
-export declare function applyMode<T>(existing: readonly T[], mode: StagedDependencyMode, target: StagedEntryView | undefined, toView: (entry: T) => StagedEntryView, addition: T | undefined): T[];
-/**
- * Number of declarations in `after` whose key matches one in `before` but
- * whose `reason` differs: the in-place reason updates of an `--add`.
- */
-export declare function countReasonUpdates(before: PatchStagedDependencies | undefined, after: PatchStagedDependencies | undefined): number;
-/** Number of declarations of both kinds. */
-export declare function countStagedEntries(staged: PatchStagedDependencies | undefined): number;

package/dist/src/commands/patch/staged-dependency-entries.js

@@ -1,80 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Kind-neutral views and list operations over staged-dependency
- * declarations, shared by `patch staged-dependency` and its `--from` batch
- * path. Split out of `staged-dependency.ts` for the per-file line budget.
- */
-/** View of an import declaration. */
-export function importView(dependency) {
-    return { ...dependency, matcher: dependency.specifier };
-}
-/** View of a registration declaration. */
-export function registrationView(dependency) {
-    return { ...dependency, matcher: dependency.line };
-}
-function dependencyKey(view) {
-    return [view.file, view.matcher, view.creates, view.owner ?? ''].join('\0');
-}
-/** One-line operator label for a declaration. */
-export function dependencyLabel(kind, view) {
-    const owner = view.owner ? ` owner=${view.owner}` : '';
-    const reason = view.reason ? ` reason="${view.reason}"` : '';
-    if (kind === 'import') {
-        return `${view.file} imports "${view.matcher}" from ${view.creates}${owner}${reason}`;
-    }
-    return `${view.file} registers "${view.matcher}" for ${view.creates}${owner}${reason}`;
-}
-function matchesTarget(view, target) {
-    return (view.file === target.file &&
-        view.matcher === target.matcher &&
-        view.creates === target.creates &&
-        (target.owner === undefined || view.owner === target.owner));
-}
-/**
- * Applies one add/remove/clear to a declaration list: `add` appends unless
- * an entry with the same file, matcher, creates and owner exists. A
- * matching entry whose `reason` differs from the addition's takes
- * the new reason in place, keeping its position in the list; an addition
- * without a reason leaves the existing one alone.
- */
-export function applyMode(existing, mode, target, toView, addition) {
-    if (mode === 'clear')
-        return [];
-    if (!target)
-        return [...existing];
-    if (mode === 'remove')
-        return existing.filter((entry) => !matchesTarget(toView(entry), target));
-    if (addition === undefined)
-        return [...existing];
-    const key = dependencyKey(target);
-    const index = existing.findIndex((entry) => dependencyKey(toView(entry)) === key);
-    if (index === -1)
-        return [...existing, addition];
-    const current = existing[index];
-    if (target.reason === undefined || toView(current).reason === target.reason) {
-        return [...existing];
-    }
-    const next = [...existing];
-    next[index] = addition;
-    return next;
-}
-/**
- * Number of declarations in `after` whose key matches one in `before` but
- * whose `reason` differs: the in-place reason updates of an `--add`.
- */
-export function countReasonUpdates(before, after) {
-    const updates = (left, right, toView) => {
-        const reasons = new Map((left ?? []).map((entry) => [dependencyKey(toView(entry)), toView(entry).reason]));
-        return (right ?? []).filter((entry) => {
-            const view = toView(entry);
-            const key = dependencyKey(view);
-            return reasons.has(key) && reasons.get(key) !== view.reason;
-        }).length;
-    };
-    return (updates(before?.forwardImports, after?.forwardImports, importView) +
-        updates(before?.registrations, after?.registrations, registrationView));
-}
-/** Number of declarations of both kinds. */
-export function countStagedEntries(staged) {
-    return (staged?.forwardImports?.length ?? 0) + (staged?.registrations?.length ?? 0);
-}

package/dist/src/commands/patch/staged-dependency-from.d.ts

@@ -1,14 +0,0 @@
-/**
- * `patch staged-dependency --add --from <json-file>`: adds every
- * declaration a file supplies for one patch in a single manifest update
- * under one lock hold. The file format and the history delta live in
- * `staged-dependency-batch.ts`.
- */
-import type { PatchStagedDependencyOptions } from '../../types/commands/index.js';
-import { type StagedDependencyMode } from './staged-dependency-entries.js';
-/**
- * `--add --from <json-file>`: every declaration the file supplies for the
- * target patch, validated up front and written in one manifest update
- * under one lock hold, with one delta history record.
- */
-export declare function runBatchAdd(projectRoot: string, identifier: string, mode: StagedDependencyMode, options: PatchStagedDependencyOptions): Promise<void>;

package/dist/src/commands/patch/staged-dependency-from.js

@@ -1,114 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `patch staged-dependency --add --from <json-file>`: adds every
- * declaration a file supplies for one patch in a single manifest update
- * under one lock hold. The file format and the history delta live in
- * `staged-dependency-batch.ts`.
- */
-import { appendHistoryBestEffort } from '../../core/history-log.js';
-import { mutatePatchMetadata } from '../../core/patch-export.js';
-import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { info, outro } from '../../utils/logger.js';
-import { resolveWaitLockSeconds } from '../../utils/options.js';
-import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
-import { readStagedDependencyBatch, stagedDependencyDelta, } from './staged-dependency-batch.js';
-import { applyMode, countReasonUpdates, countStagedEntries, importView, registrationView, } from './staged-dependency-entries.js';
-import { validateStagedDependencyAdd } from './staged-dependency-validate.js';
-/** Flags that describe one declaration and so cannot combine with `--from`. */
-const SINGLE_DECLARATION_FLAGS = [
-    ['--kind', 'kind'],
-    ['--file', 'file'],
-    ['--specifier', 'specifier'],
-    ['--line', 'line'],
-    ['--creates', 'creates'],
-    ['--owner', 'owner'],
-];
-/**
- * Adds every `--from` declaration not already present, keyed like a single
- * `--add`; a present one whose `reason` differs takes the new reason in place.
- */
-function mergeBatch(staged, batch) {
-    let forwardImports = [...(staged?.forwardImports ?? [])];
-    for (const entry of batch.forwardImports) {
-        forwardImports = applyMode(forwardImports, 'add', importView(entry), importView, entry);
-    }
-    let registrations = [...(staged?.registrations ?? [])];
-    for (const entry of batch.registrations) {
-        registrations = applyMode(registrations, 'add', registrationView(entry), registrationView, entry);
-    }
-    return {
-        ...(forwardImports.length > 0 ? { forwardImports } : {}),
-        ...(registrations.length > 0 ? { registrations } : {}),
-    };
-}
-/**
- * `--add --from <json-file>`: every declaration the file supplies for the
- * target patch, validated up front and written in one manifest update
- * under one lock hold, with one delta history record.
- */
-export async function runBatchAdd(projectRoot, identifier, mode, options) {
-    const from = options.from ?? '';
-    if (mode !== 'add') {
-        throw new InvalidArgumentError('--from only applies to --add.', '--from');
-    }
-    const clashing = SINGLE_DECLARATION_FLAGS.filter(([, key]) => options[key] !== undefined);
-    if (clashing.length > 0) {
-        throw new InvalidArgumentError(`--from supplies the declarations itself; drop ${clashing.map(([flag]) => flag).join(', ')}.`, '--from');
-    }
-    const { paths, manifest } = await requirePatchQueue(projectRoot);
-    const targetPatch = requirePatchTarget(identifier, manifest.patches);
-    const batch = await readStagedDependencyBatch(from, targetPatch.filename, options.reason);
-    for (const entry of [...batch.forwardImports, ...batch.registrations]) {
-        validateStagedDependencyAdd(entry, manifest.patches);
-    }
-    const supplied = batch.forwardImports.length + batch.registrations.length;
-    if (batch.skippedForOtherPatches > 0) {
-        info(`Skipped ${batch.skippedForOtherPatches} declaration(s) in ${from} that name another patch.`);
-    }
-    if (supplied === 0) {
-        info(`${from} holds no declarations for ${targetPatch.filename}; nothing to add.`);
-        outro('Patch staged-dependency complete');
-        return;
-    }
-    const existing = targetPatch.stagedDependencies;
-    const describe = (before, after) => {
-        const added = countStagedEntries(after) - countStagedEntries(before);
-        const updated = countReasonUpdates(before, after);
-        const unchanged = supplied - added - updated;
-        return (`added ${added} of ${supplied} staged declaration(s) from ${from}` +
-            (updated > 0 ? `, updated the reason of ${updated}` : '') +
-            (unchanged > 0 ? ` (${unchanged} already present or repeated)` : ''));
-    };
-    if (options.dryRun === true) {
-        info(`[dry-run] ${targetPatch.filename}: ${describe(existing, mergeBatch(existing, batch))}.`);
-        outro('Dry run complete — no changes made');
-        return;
-    }
-    const result = await mutatePatchMetadata(paths.patches, targetPatch.filename, (current) => {
-        const after = mergeBatch(current.stagedDependencies, batch);
-        if (countStagedEntries(after) === 0)
-            return { unset: ['stagedDependencies'] };
-        return { set: { stagedDependencies: after } };
-    }, {
-        waitLockSeconds: resolveWaitLockSeconds(options.waitLock),
-        command: 'patch staged-dependency',
-    });
-    if (!result) {
-        throw new GeneralError(`Patch ${targetPatch.filename} disappeared from the manifest during the update. Re-run after investigating.`);
-    }
-    const before = result.before.stagedDependencies;
-    const after = result.after.stagedDependencies;
-    info(`${targetPatch.filename}: ${describe(before, after)}.`);
-    await appendHistoryBestEffort(paths.patches, {
-        operation: 'patch-staged-dependency',
-        args: {
-            filename: targetPatch.filename,
-            mode,
-            from,
-            ...stagedDependencyDelta(before, after),
-        },
-        ...(options.yes === true ? { yes: true } : {}),
-        result: 'ok',
-    }, `patch staged-dependency committed (${targetPatch.filename})`);
-    outro('Patch staged-dependency complete');
-}

package/dist/src/commands/patch/staged-dependency-remove.d.ts

@@ -1,53 +0,0 @@
-/**
- * `--remove` target selection for `patch staged-dependency`. Split out of
- * `staged-dependency.ts` for the per-file line budget.
- *
- * A removal names its entries by any of `--file`, `--specifier`/`--line`,
- * `--creates` and `--owner`, and must give at least `--creates` or the
- * `--file` + matcher pair. Without `--kind` the matcher picks the kind
- * (`--specifier` an import, `--line` a registration), and a selection with
- * neither searches both kinds, so `--creates` alone removes every
- * declaration for that path. Registration lines compare whitespace-
- * insensitively (runs of whitespace collapse, ends trimmed), the way the
- * lint compares them, so a line copied from a patch hunk matches the stored
- * one whatever its padding. A selection that matches nothing is refused
- * rather than reported as a no-op.
- */
-import type { PatchStagedDependencies, PatchStagedDependencyOptions } from '../../types/commands/index.js';
-import { type StagedDependencyKind, type StagedEntryView } from './staged-dependency-entries.js';
-/** One stored declaration together with its kind. */
-export interface KindedEntryView {
-    kind: StagedDependencyKind;
-    view: StagedEntryView;
-}
-/** Singular noun for a declaration of the given kinds. */
-export declare function declarationNoun(kinds: readonly StagedDependencyKind[]): string;
-/**
- * The kinds a `--remove` searches. `--kind` wins when given (and is
- * validated by the caller); otherwise `--specifier` selects imports,
- * `--line` registrations, and a selection with neither matcher searches
- * both kinds.
- *
- * @param options - Command options
- * @returns The kinds to search, or undefined when `--kind` was given
- * @throws InvalidArgumentError when `--specifier` and `--line` are both given without `--kind`
- */
-export declare function inferRemovalKinds(options: PatchStagedDependencyOptions): readonly StagedDependencyKind[] | undefined;
-/**
- * Resolves the staged entries a `--remove` invocation names. The returned
- * views are the stored entries themselves, so the removal matches them
- * exactly.
- *
- * - `--file` + matcher identifying one entry infers `--creates`.
- * - `--file` + matcher identifying several entries without `--creates`
- *   refuses with the candidate list.
- * - `--creates` alone selects every declaration for that created path, of
- *   every kind searched.
- *
- * @param kinds - Declaration kinds to search
- * @param options - Command options
- * @param staged - The target patch's current staged dependencies
- * @returns The matching stored entries (never empty)
- * @throws InvalidArgumentError when the selectors are insufficient or match nothing
- */
-export declare function selectRemovalEntries(kinds: readonly StagedDependencyKind[], options: PatchStagedDependencyOptions, staged: PatchStagedDependencies | undefined): KindedEntryView[];

package/dist/src/commands/patch/staged-dependency-remove.js

@@ -1,117 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `--remove` target selection for `patch staged-dependency`. Split out of
- * `staged-dependency.ts` for the per-file line budget.
- *
- * A removal names its entries by any of `--file`, `--specifier`/`--line`,
- * `--creates` and `--owner`, and must give at least `--creates` or the
- * `--file` + matcher pair. Without `--kind` the matcher picks the kind
- * (`--specifier` an import, `--line` a registration), and a selection with
- * neither searches both kinds, so `--creates` alone removes every
- * declaration for that path. Registration lines compare whitespace-
- * insensitively (runs of whitespace collapse, ends trimmed), the way the
- * lint compares them, so a line copied from a patch hunk matches the stored
- * one whatever its padding. A selection that matches nothing is refused
- * rather than reported as a no-op.
- */
-import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { info } from '../../utils/logger.js';
-import { dependencyLabel, importView, registrationView, } from './staged-dependency-entries.js';
-/** Collapses whitespace runs and trims, for registration-line comparison. */
-function normalizeRegistrationLine(line) {
-    return line.trim().replace(/\s+/g, ' ');
-}
-function stagedViews(kinds, staged) {
-    return kinds.flatMap((kind) => kind === 'import'
-        ? (staged?.forwardImports ?? []).map((entry) => ({ kind, view: importView(entry) }))
-        : (staged?.registrations ?? []).map((entry) => ({ kind, view: registrationView(entry) })));
-}
-/** Singular noun for a declaration of the given kinds. */
-export function declarationNoun(kinds) {
-    if (kinds.length !== 1)
-        return 'staged declaration';
-    return kinds[0] === 'import' ? 'staged forward-import' : 'staged registration';
-}
-/**
- * The kinds a `--remove` searches. `--kind` wins when given (and is
- * validated by the caller); otherwise `--specifier` selects imports,
- * `--line` registrations, and a selection with neither matcher searches
- * both kinds.
- *
- * @param options - Command options
- * @returns The kinds to search, or undefined when `--kind` was given
- * @throws InvalidArgumentError when `--specifier` and `--line` are both given without `--kind`
- */
-export function inferRemovalKinds(options) {
-    if (options.kind !== undefined)
-        return undefined;
-    if (options.specifier !== undefined && options.line !== undefined) {
-        throw new InvalidArgumentError('--specifier names an import and --line a registration; pass one of them, or --kind.', '--specifier/--line');
-    }
-    if (options.specifier !== undefined)
-        return ['import'];
-    if (options.line !== undefined)
-        return ['registration'];
-    return ['import', 'registration'];
-}
-/**
- * Resolves the staged entries a `--remove` invocation names. The returned
- * views are the stored entries themselves, so the removal matches them
- * exactly.
- *
- * - `--file` + matcher identifying one entry infers `--creates`.
- * - `--file` + matcher identifying several entries without `--creates`
- *   refuses with the candidate list.
- * - `--creates` alone selects every declaration for that created path, of
- *   every kind searched.
- *
- * @param kinds - Declaration kinds to search
- * @param options - Command options
- * @param staged - The target patch's current staged dependencies
- * @returns The matching stored entries (never empty)
- * @throws InvalidArgumentError when the selectors are insufficient or match nothing
- */
-export function selectRemovalEntries(kinds, options, staged) {
-    const single = kinds.length === 1 ? kinds[0] : undefined;
-    const matcherFlag = single === 'import'
-        ? '--specifier'
-        : single === 'registration'
-            ? '--line'
-            : '--specifier or --line';
-    const matcher = single === 'import' ? options.specifier : single === 'registration' ? options.line : undefined;
-    const hasPair = Boolean(options.file) && Boolean(matcher);
-    if (!options.creates && !hasPair) {
-        throw new InvalidArgumentError(`--remove${options.kind === 'registration' ? ' --kind registration' : ''} requires --creates, ` +
-            `or --file with ${matcherFlag}; --creates alone removes every declaration for that path.`, matcher && !options.file
-            ? '--file'
-            : options.file && !matcher
-                ? matcherFlag
-                : `--creates or --file + ${matcherFlag}`);
-    }
-    const views = stagedViews(kinds, staged);
-    const candidates = views.filter(({ kind, view }) => (!options.file || view.file === options.file) &&
-        (matcher === undefined ||
-            comparableMatcher(kind, view.matcher) === comparableMatcher(kind, matcher)) &&
-        (!options.creates || view.creates === options.creates) &&
-        (options.owner === undefined || view.owner === options.owner));
-    const label = ({ kind, view }) => `  - ${dependencyLabel(kind, view)}`;
-    if (candidates.length === 0) {
-        const noun = declarationNoun(kinds);
-        const existing = views.length === 0
-            ? `This patch has no ${noun}s.`
-            : `This patch's ${noun}s:\n${views.map(label).join('\n')}`;
-        throw new InvalidArgumentError(`--remove matched no ${noun}. ${existing}`, '--remove');
-    }
-    if (candidates.length > 1 && !options.creates) {
-        throw new GeneralError(`--remove matches ${candidates.length} ${declarationNoun(kinds)}s on this patch; ` +
-            `pass --creates to pick one:\n${candidates.map(label).join('\n')}`);
-    }
-    const only = candidates.length === 1 ? candidates[0] : undefined;
-    if (only !== undefined && !options.creates) {
-        info(`Inferred --creates ${only.view.creates} from the single matching staged entry.`);
-    }
-    return candidates;
-}
-function comparableMatcher(kind, matcher) {
-    return kind === 'registration' ? normalizeRegistrationLine(matcher) : matcher;
-}

package/dist/src/commands/patch/staged-dependency-validate.d.ts

@@ -1,15 +0,0 @@
-import type { PatchMetadata } from '../../types/commands/index.js';
-/** The declaration fields common to both staged-dependency kinds. */
-interface StagedDependencyShape {
-    file: string;
-    creates: string;
-    owner?: string;
-}
-/**
- * Validates the `--add` declaration fields against the loaded queue.
- * Throws on a clear flag mixup. Warns (only) when `--owner` is
- * well-formed but absent from the queue, because the owner may
- * legitimately be exported moments later and renumbering rewrites owners.
- */
-export declare function validateStagedDependencyAdd(dependency: StagedDependencyShape, queuePatches: readonly PatchMetadata[]): void;
-export {};

package/dist/src/commands/patch/staged-dependency-validate.js

@@ -1,49 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Shape validation for `patch staged-dependency --add`.
- *
- * `--creates`/`--file` take engine-relative file paths, while `--owner`
- * takes a patch filename. Accepting all three as arbitrary strings lets a
- * `--creates <patch-name>` mixup produce a declaration nothing can ever
- * discharge, surfacing only later as a `staged-dependency-unused` warning.
- * Refusals here fire only on a clear patch-name shape (slash-free values
- * that end in `.patch` or match a queue patch filename/stem): legitimate
- * engine paths always contain a `/`, so deep paths can never
- * false-positive.
- */
-import { InvalidArgumentError } from '../../errors/base.js';
-import { warn } from '../../utils/logger.js';
-function matchQueuePatch(value, queuePatches) {
-    return queuePatches.find((patch) => patch.filename === value || patch.filename === `${value}.patch`)?.filename;
-}
-function refusePatchShapedPath(flag, value, role, queuePatches) {
-    if (value.includes('/'))
-        return;
-    const matched = matchQueuePatch(value, queuePatches);
-    if (matched === undefined && !value.endsWith('.patch'))
-        return;
-    const evidence = matched !== undefined ? `matches patch ${matched} in the queue` : 'looks like a patch filename';
-    throw new InvalidArgumentError(`${flag} takes ${role} (e.g. browser/components/foo/Foo.sys.mjs), not a patch name — ` +
-        `"${value}" ${evidence}. If you meant to name the owning patch, pass it with --owner.`, flag);
-}
-/**
- * Validates the `--add` declaration fields against the loaded queue.
- * Throws on a clear flag mixup. Warns (only) when `--owner` is
- * well-formed but absent from the queue, because the owner may
- * legitimately be exported moments later and renumbering rewrites owners.
- */
-export function validateStagedDependencyAdd(dependency, queuePatches) {
-    refusePatchShapedPath('--creates', dependency.creates, 'the engine-relative path of the file a later patch creates', queuePatches);
-    refusePatchShapedPath('--file', dependency.file, 'the engine-relative file containing the declaring site inside this patch', queuePatches);
-    const owner = dependency.owner;
-    if (owner === undefined)
-        return;
-    if (owner.includes('/') || !owner.endsWith('.patch')) {
-        throw new InvalidArgumentError(`--owner names the owning patch artifact (e.g. 012-infra-foo.patch); ` +
-            `"${owner}" does not look like a patch filename. The created file path goes in --creates.`, '--owner');
-    }
-    if (!queuePatches.some((patch) => patch.filename === owner)) {
-        warn(`--owner ${owner} matches no patch currently in the queue. The declaration only ` +
-            'discharges once a patch with exactly this filename creates the --creates path.');
-    }
-}