@hominis/fireforge 0.52.0 → 0.54.0

package/dist/src/commands/patch/split-plan.js

@@ -21,6 +21,22 @@ import { warn } from '../../utils/logger.js';
 import {} from '../export-flow.js';
 import { projectEntryBody } from './entry-projection.js';
 import { describeStagedMaintenance, findDeclarationsMadeUnused, keptRelocatedDeclarations, relocatedSourceDeclarations, rewriteSplitOwners, withoutRelocatedDeclarations, } from './split-staged.js';
+/**
+ * The `reason` a move records on a forward declaration it writes, so the
+ * declaration explains itself in `patches.json` and `staged-dependency
+ * --add --from` accepts it without a hand-written `--reason`.
+ *
+ * @param source - Patch the files left
+ * @param destination - Patch the files moved into
+ * @param operation - The command that moved them
+ */
+export function moveDeclarationReason(source, destination, operation) {
+    return `${source} → ${destination} by ${operation}`;
+}
+/** The {@link moveDeclarationReason} of a split plan. */
+export function splitDeclarationReason(plan) {
+    return moveDeclarationReason(plan.source.filename, plan.placement.newFilename, plan.operation ?? 'patch split');
+}
 /**
  * Refuses the split unless the source patch currently owns every requested
  * file. Splitting out a file the source does not own would produce a new patch
@@ -118,7 +134,7 @@ function buildProjectedSplitEntries(baseCtx, plan) {
  * them once declared. Auto-declaring keeps the two in lock-step and lets a
  * sound split read as sound.
  */
-function computeSplitStagedDependencyAdditions(projectedEntries, newFilename) {
+function computeSplitStagedDependencyAdditions(projectedEntries, newFilename, reason) {
     const additions = new Map();
     for (const edge of collectForwardImportEdges({ entries: projectedEntries })) {
         if (edge.owner !== newFilename)
@@ -128,6 +144,7 @@ function computeSplitStagedDependencyAdditions(projectedEntries, newFilename) {
             specifier: edge.specifier,
             creates: edge.creates,
             owner: newFilename,
+            reason,
         };
         const list = additions.get(edge.entry) ?? [];
         const dup = list.some((d) => d.file === decl.file &&
@@ -179,15 +196,14 @@ export function runProjectedSplitLint(plan, baseCtx) {
     const projectedEntries = buildProjectedSplitEntries(baseCtx, plan);
     // Discover and auto-declare the forward edges this split introduces into
     // the new patch, then inject them before linting so they resolve.
-    const stagedDependencyAdditions = computeSplitStagedDependencyAdditions(projectedEntries, plan.placement.newFilename);
+    const stagedDependencyAdditions = computeSplitStagedDependencyAdditions(projectedEntries, plan.placement.newFilename, splitDeclarationReason(plan));
     injectStagedDependencyAdditions(projectedEntries, stagedDependencyAdditions);
     const baselineAll = lintPatchQueue(baseCtx);
-    const projectedAll = lintPatchQueue({
-        entries: projectedEntries,
-        // Keep the projection patch-policy-aware whenever the baseline is, so
-        // computeProjectedLintRegressions compares symmetric rule sets.
-        ...(baseCtx.patchPolicy ? { patchPolicy: baseCtx.patchPolicy } : {}),
-    });
+    // Keep every queue-wide lint setting of the baseline (patch policy,
+    // forward-registration scope, token scales), so
+    // computeProjectedLintRegressions compares symmetric rule sets and a
+    // test-manifest suite entry is projected as the committed gate sees it.
+    const projectedAll = lintPatchQueue({ ...baseCtx, entries: projectedEntries });
     const baselineIssues = baselineAll.filter((i) => i.severity === 'error');
     const projectedIssues = projectedAll.filter((i) => i.severity === 'error');
     const oldNameByNew = new Map([...plan.placement.renameMap].map(([oldName, entry]) => [entry.newFilename, oldName]));
@@ -257,6 +273,12 @@ export function buildSplitSummary(plan) {
     const summary = [
         `split ${plan.source.filename}`,
         `moved files (${plan.movedFiles.length}): ${plan.movedFiles.join(', ')}`,
+        ...(plan.adoptedFiles?.length
+            ? [
+                `of which adopted from the worktree (no patch owned them) (${plan.adoptedFiles.length}): ` +
+                    plan.adoptedFiles.join(', '),
+            ]
+            : []),
         `source keeps (${plan.remainingFiles.length}): ${plan.remainingFiles.join(', ')}`,
         `new patch: ${plan.placement.newFilename} (order ${plan.placement.insertionOrder})`,
     ];
@@ -274,9 +296,11 @@ export function buildSplitSummary(plan) {
 }
 /**
  * Maps a declaration the split projection proposes back onto the queue as
- * it stands: renumbered patches take their current names, and an owner
- * that is the patch the split would create is dropped (it does not exist
- * until the split runs).
+ * it stands: renumbered patches take their current names. An owner that is
+ * the patch the split would create keeps the planned filename, so the
+ * report declares the owner the rerun creates (`staged-dependency --add`
+ * accepts an owner the queue does not hold yet, and the move then lands
+ * with the declaration already right).
  */
 export function splitDeclarationRenamer(plan) {
     const oldNameByNew = new Map([...plan.placement.renameMap].map(([oldName, entry]) => [entry.newFilename, oldName]));
@@ -284,6 +308,6 @@ export function splitDeclarationRenamer(plan) {
     return ({ owner, ...declaration }) => ({
         ...declaration,
         patch: current(declaration.patch),
-        ...(owner !== plan.placement.newFilename ? { owner: current(owner) } : {}),
+        owner: owner === plan.placement.newFilename ? owner : current(owner),
     });
 }

package/dist/src/commands/patch/split-staged.d.ts

@@ -14,8 +14,8 @@
  *    the imported file landed in one patch) is dropped
  *    ({@link findDeclarationsMadeUnused}).
  *
- * Without this the move wrote the bodies and left the queue audit and the
- * per-patch lint to report `queue-dependency-creates-unowned` and
+ * Without this the move would write the bodies and leave the queue audit
+ * and the per-patch lint to report `queue-dependency-creates-unowned` and
  * `staged-dependency-unused` afterwards, one `--remove`/`--add` pair per
  * entry to repair by hand.
  */

package/dist/src/commands/patch/split-staged.js

@@ -15,8 +15,8 @@
  *    the imported file landed in one patch) is dropped
  *    ({@link findDeclarationsMadeUnused}).
  *
- * Without this the move wrote the bodies and left the queue audit and the
- * per-patch lint to report `queue-dependency-creates-unowned` and
+ * Without this the move would write the bodies and leave the queue audit
+ * and the per-patch lint to report `queue-dependency-creates-unowned` and
  * `staged-dependency-unused` afterwards, one `--remove`/`--add` pair per
  * entry to repair by hand.
  */

package/dist/src/commands/patch/split.js

@@ -36,8 +36,10 @@ import { normalizePatchDisplayName, parsePositiveIntegerFlag } from '../../utils
 import { withDeclarationsReport } from '../declarations-report.js';
 import { proceedAfterDecision } from '../destructive-decision.js';
 import { placementPlansEqual, resolvePlacementPlan } from '../export-flow.js';
-import { runPatchLint } from '../export-shared.js';
-import { assertSourceOwnsFiles, buildNewPatchMetadata, buildSplitDiff, buildSplitSummary, mergeStagedForwardImports, projectSplitManifest, runProjectedSplitLint, splitDeclarationRenamer, } from './split-plan.js';
+import { writeRenameMapFile } from '../patch-rename-map.js';
+import { assertAdoptedStillUnowned } from './move-files-adopt.js';
+import { runMoveSideLint } from './move-size-tier.js';
+import { assertSourceOwnsFiles, buildNewPatchMetadata, buildSplitDiff, buildSplitSummary, mergeStagedForwardImports, projectSplitManifest, runProjectedSplitLint, splitDeclarationReason, splitDeclarationRenamer, } from './split-plan.js';
 import { describeStagedMaintenance, emptyStagedMaintenance, findOwnerRewriteHolders, rewriteSplitOwners, withoutDroppedDeclarations, withoutRelocatedDeclarations, } from './split-staged.js';
 /**
  * History payload for the declarations a split re-homed or dropped, omitted
@@ -79,6 +81,7 @@ export async function commitPatchSplit(patchesDir, plan, newMetadata, options, c
         if (!current || current.filesAffected.join('\n') !== plan.source.filesAffected.join('\n')) {
             throw new InvalidArgumentError('Patch queue changed while waiting for split confirmation. Re-run the command.', 'patch split');
         }
+        assertAdoptedStillUnowned(manifest.patches, plan.adoptedFiles, 'patch split');
         const currentPlacement = await resolvePlacementPlan(patchesDir, plan.placementOptions, plan.category, plan.name, config);
         if (!placementPlansEqual(currentPlacement, plan.placement)) {
             throw new InvalidArgumentError('Patch queue changed while waiting for split confirmation. Re-run the command.', 'patch split');
@@ -266,9 +269,11 @@ export async function patchSplitCommand(projectRoot, sourceId, options) {
     // instead of linting each projected body blind.
     const patchQueueCtx = await buildPatchQueueContext(paths.patches, config);
     const ignoreChecks = buildLintIgnoreChecks(source.lintIgnore);
-    await runPatchLint({
+    await runMoveSideLint({
         engineDir: paths.engine,
         filesAffected: remainingFiles,
+        filesBefore: source.filesAffected,
+        role: 'source',
         diffContent: remainingDiff,
         config,
         skipLint: options.skipLint,
@@ -276,9 +281,10 @@ export async function patchSplitCommand(projectRoot, sourceId, options) {
         ignoreChecks,
         patchTier: source.tier,
     });
-    await runPatchLint({
+    await runMoveSideLint({
         engineDir: paths.engine,
         filesAffected: movedFiles,
+        role: 'new patch',
         diffContent: movedDiff,
         config,
         skipLint: options.skipLint,
@@ -294,6 +300,7 @@ export async function patchSplitCommand(projectRoot, sourceId, options) {
         regressions: projected.regressions,
         out: options.declarationsOut,
         rename: splitDeclarationRenamer(plan),
+        reason: splitDeclarationReason(plan),
     });
     const newMetadata = buildNewPatchMetadata(plan, config);
     const decision = await confirmDestructive({
@@ -308,6 +315,10 @@ export async function patchSplitCommand(projectRoot, sourceId, options) {
     if (!proceedAfterDecision(decision, 'Split cancelled'))
         return;
     await commitPatchSplit(paths.patches, plan, newMetadata, options, config);
+    if (options.mapOut !== undefined) {
+        const written = await writeRenameMapFile(options.mapOut, plan.placement.renameMap);
+        info(`Wrote the old-to-new filename map (${plan.placement.renameMap.size} rename(s)) to ${written}`);
+    }
     success(`Split ${source.filename}: ${placement.newFilename} now owns ${plan.movedFiles.length} file(s)`);
     reportSplitStagedChanges(plan);
     outro('Split complete');
@@ -331,7 +342,8 @@ export function registerPatchSplit(parent, context) {
         .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
         .option('--force-unsafe', 'Bypass projected-lint refusals')
         .option('--skip-lint', 'Skip per-patch lint of the projected bodies')
-        .option('--declarations-out <path>', 'Where a refusal writes its one --from-ready staged-declaration report (default: .fireforge/declarations/<timestamp>.json)');
+        .option('--declarations-out <path>', 'Where a refusal writes its one --from-ready staged-declaration report (default: .fireforge/declarations/<timestamp>.json)')
+        .option('--map-out <file>', 'Write the old-to-new filename map of the patches the split renumbers as JSON');
     addWaitLockOption(command).action(withErrorHandling(async (sourceId, options) => {
         await patchSplitCommand(getProjectRoot(), sourceId, {
             files: options.files,
@@ -347,6 +359,7 @@ export function registerPatchSplit(parent, context) {
                 forceUnsafe: options.forceUnsafe,
                 skipLint: options.skipLint,
                 declarationsOut: options.declarationsOut,
+                mapOut: options.mapOut,
                 waitLock: options.waitLock,
             }),
         });

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

@@ -29,8 +29,16 @@ export declare function registrationView(dependency: PatchStagedRegistration): S
 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.
+ * 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

@@ -32,7 +32,10 @@ function matchesTarget(view, target) {
 }
 /**
  * Applies one add/remove/clear to a declaration list: `add` appends unless
- * an entry with the same file, matcher, creates and owner exists.
+ * 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')
@@ -41,10 +44,35 @@ export function applyMode(existing, mode, target, toView, addition) {
         return [...existing];
     if (mode === 'remove')
         return existing.filter((entry) => !matchesTarget(toView(entry), target));
-    const seen = new Set(existing.map((entry) => dependencyKey(toView(entry))));
-    if (seen.has(dependencyKey(target)) || addition === undefined)
+    if (addition === undefined)
         return [...existing];
-    return [...existing, addition];
+    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) {

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

@@ -12,7 +12,7 @@ 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, countStagedEntries, importView, registrationView, } from './staged-dependency-entries.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 = [
@@ -23,7 +23,10 @@ const SINGLE_DECLARATION_FLAGS = [
     ['--creates', 'creates'],
     ['--owner', 'owner'],
 ];
-/** Adds every `--from` declaration not already present, keyed like a single `--add`. */
+/**
+ * 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) {
@@ -68,13 +71,16 @@ export async function runBatchAdd(projectRoot, identifier, mode, options) {
         return;
     }
     const existing = targetPatch.stagedDependencies;
-    const projectedCount = countStagedEntries(mergeBatch(existing, batch));
-    const describe = (beforeCount, afterCount) => `added ${afterCount - beforeCount} of ${supplied} staged declaration(s) from ${from}` +
-        (supplied > afterCount - beforeCount
-            ? ` (${supplied - (afterCount - beforeCount)} already present or repeated)`
-            : '');
+    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(countStagedEntries(existing), projectedCount)}.`);
+        info(`[dry-run] ${targetPatch.filename}: ${describe(existing, mergeBatch(existing, batch))}.`);
         outro('Dry run complete — no changes made');
         return;
     }
@@ -92,7 +98,7 @@ export async function runBatchAdd(projectRoot, identifier, mode, options) {
     }
     const before = result.before.stagedDependencies;
     const after = result.after.stagedDependencies;
-    info(`${targetPatch.filename}: ${describe(countStagedEntries(before), countStagedEntries(after))}.`);
+    info(`${targetPatch.filename}: ${describe(before, after)}.`);
     await appendHistoryBestEffort(paths.patches, {
         operation: 'patch-staged-dependency',
         args: {

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

@@ -4,7 +4,10 @@
  *
  * 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. Registration lines compare whitespace-
+ * `--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
@@ -12,6 +15,24 @@
  */
 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
@@ -20,12 +41,13 @@ import { type StagedDependencyKind, type StagedEntryView } from './staged-depend
  * - `--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.
+ * - `--creates` alone selects every declaration for that created path, of
+ *   every kind searched.
  *
- * @param kind - Declaration kind (`--kind`)
+ * @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(kind: StagedDependencyKind, options: PatchStagedDependencyOptions, staged: PatchStagedDependencies | undefined): StagedEntryView[];
+export declare function selectRemovalEntries(kinds: readonly StagedDependencyKind[], options: PatchStagedDependencyOptions, staged: PatchStagedDependencies | undefined): KindedEntryView[];

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

@@ -5,7 +5,10 @@
  *
  * 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. Registration lines compare whitespace-
+ * `--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
@@ -18,10 +21,38 @@ import { dependencyLabel, importView, registrationView, } from './staged-depende
 function normalizeRegistrationLine(line) {
     return line.trim().replace(/\s+/g, ' ');
 }
-function stagedViews(kind, staged) {
-    return kind === 'import'
-        ? (staged?.forwardImports ?? []).map(importView)
-        : (staged?.registrations ?? []).map(registrationView);
+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
@@ -31,47 +62,53 @@ function stagedViews(kind, staged) {
  * - `--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.
+ * - `--creates` alone selects every declaration for that created path, of
+ *   every kind searched.
  *
- * @param kind - Declaration kind (`--kind`)
+ * @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(kind, options, staged) {
-    const matcherFlag = kind === 'import' ? '--specifier' : '--line';
-    const matcher = kind === 'import' ? options.specifier : options.line;
+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${kind === 'registration' ? ' --kind registration' : ''} requires --creates, ` +
+        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 wanted = matcher === undefined ? undefined : comparableMatcher(kind, matcher);
-    const views = stagedViews(kind, staged);
-    const candidates = views.filter((view) => (!options.file || view.file === options.file) &&
-        (wanted === undefined || comparableMatcher(kind, view.matcher) === wanted) &&
+    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 = kind === 'import' ? 'staged forward-import' : 'staged registration';
+        const noun = declarationNoun(kinds);
         const existing = views.length === 0
             ? `This patch has no ${noun}s.`
-            : `This patch's ${noun}s:\n${views.map((view) => `  - ${dependencyLabel(kind, view)}`).join('\n')}`;
+            : `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) {
-        const list = candidates.map((view) => `  - ${dependencyLabel(kind, view)}`).join('\n');
-        const noun = kind === 'import' ? 'staged forward-imports' : 'staged registrations';
-        throw new GeneralError(`--remove matches ${candidates.length} ${noun} on this patch; pass --creates to pick one:\n${list}`);
+        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 single = candidates.length === 1 ? candidates[0] : undefined;
-    if (single !== undefined && !options.creates) {
-        info(`Inferred --creates ${single.creates} from the single matching staged entry.`);
+    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;
 }