@hominis/fireforge 0.53.0 → 0.54.0

package/CHANGELOG.md

@@ -1,6 +1,25 @@
 # Changelog
 
-## 0.53.0
+## 0.54.0
+
+### Test harness
+
+- The browser and port checks that follow work a `fireforge test` already did under the lock wait out `--wait-browser` and `--wait-port` again, instead of probing once: the checks after a `--build` run's pre-test build, and those of every later run of a `--repeat` or `--negative-control` sequence. The pre-lock pass spent the budgets and the in-lock checks only probed, so a peer's browser that started during the build ended the run `reason=preflight note=browser-busy` (`control=inconclusive` for a control) and threw the build away.
+- A negative-control diff that names one file in more than one section (a generator that writes one section per edit) is applied as one section with its hunks in file order, instead of being refused. Sections whose hunks overlap are still refused, naming both hunks and the one-section remedy.
+- Windows: the `stale-compiled` refusal names the linked binary with forward slashes (`engine/obj-x/dist/bin/libxul.so`), not with mixed separators.
+
+### Patch queue
+
+- `patch staged-dependency --remove` without `--kind` takes the kind from its matcher: `--specifier` selects imports and `--line` registrations. A selection with neither, such as `--creates` alone, searches both kinds, as the flag's help says. It used to search imports only, so removing a stale registration by `--creates` was refused until `--kind registration` was added. A miss lists the patch's declarations of every kind it searched.
+- `re-export --expect-removed` combines with `--scan`, so one call can retire a widget's files from one patch while `--scan-file` adopts a new module into another. The retired path leaves its owner's file list before the scan, which cannot adopt it back. `--files`, `--all` and an implicit selection are still refused.
+
+### Run
+
+- `fireforge run` passes the arguments after `--` to the browser, after the profile ones: `fireforge run --profile <dir> -- -marionette -remote-allow-system-access` drives a headed session on a kept profile, with `-purgecaches`, from chrome-context Marionette.
+
+### Other
+
+- Tests: the `git diff --no-index` negative-control test no longer fails when the temp root's random suffix ends in `b`, which its fixture rewrite matched inside the old side's absolute path. The `application.ini` path test compares native paths on Windows.
 
 ### Test harness
 

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "version": "0.53.0",
-  "commit": "2f2367bfe9c2b8a834cbf09f9b19b02d8dbd6b66",
-  "shortCommit": "2f2367bfe9c2",
+  "version": "0.54.0",
+  "commit": "2bf7356bab0d77849cb1ab136f0160995dabf41e",
+  "shortCommit": "2bf7356bab0d",
   "dirty": false,
   "dirtyHash": null,
-  "buildTime": "2026-10-22T20:59:15.472Z"
+  "buildTime": "2026-10-24T18:17:09.937Z"
 }

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;
 }

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

@@ -13,7 +13,7 @@ import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 import { stagedDependencyDelta } from './staged-dependency-batch.js';
 import { applyMode, countReasonUpdates, countStagedEntries, dependencyLabel, importView, registrationView, } from './staged-dependency-entries.js';
 import { runBatchAdd } from './staged-dependency-from.js';
-import { selectRemovalEntries } from './staged-dependency-remove.js';
+import { declarationNoun, inferRemovalKinds, selectRemovalEntries, } from './staged-dependency-remove.js';
 import { validateStagedDependencyAdd } from './staged-dependency-validate.js';
 /** Joins the names of the missing flags for error attribution. */
 function missingFlagList(pairs) {
@@ -89,16 +89,17 @@ function requireRegistrationOptions(options) {
 /**
  * Renders a one-line summary of a staged-dependency metadata change.
  */
-function describeStagedDependencyChange(before, after, mode, kind, targets) {
+function describeStagedDependencyChange(before, after, mode, kinds, targets) {
     const beforeCount = countStagedEntries(before);
     const afterCount = countStagedEntries(after);
-    const noun = kind === 'import' ? 'staged forward-import' : 'staged registration';
+    const targetKinds = [...new Set(targets.map((target) => target.kind))];
+    const noun = declarationNoun(targetKinds.length > 0 ? targetKinds : kinds);
     if (mode === 'clear') {
         return beforeCount === 0
             ? 'stagedDependencies was already empty — no change'
             : `cleared ${beforeCount} staged dependency declaration(s)`;
     }
-    const label = targets.map((target) => dependencyLabel(kind, target)).join('; ');
+    const label = targets.map(({ kind, view }) => dependencyLabel(kind, view)).join('; ');
     if (targets.length === 0)
         return 'stagedDependencies unchanged';
     if (mode === 'add') {
@@ -127,7 +128,11 @@ export async function patchStagedDependencyCommand(projectRoot, identifier, opti
         await runBatchAdd(projectRoot, identifier, mode, options);
         return;
     }
-    const kind = kindFromOptions(options);
+    // Without --kind, --remove searches the kind its matcher names, or both.
+    const kinds = (mode === 'remove' ? inferRemovalKinds(options) : undefined) ?? [
+        kindFromOptions(options),
+    ];
+    const kind = kinds.length === 1 ? kinds[0] : undefined;
     // The patch queue loads before the declaration fields resolve so
     // `--remove` can infer `--creates` from the target patch's staged
     // entries.
@@ -143,24 +148,25 @@ export async function patchStagedDependencyCommand(projectRoot, identifier, opti
         validateStagedDependencyAdd(added, manifest.patches);
     }
     const targets = mode === 'remove'
-        ? selectRemovalEntries(kind, options, targetPatch.stagedDependencies)
+        ? selectRemovalEntries(kinds, options, targetPatch.stagedDependencies)
         : importDependency !== undefined
-            ? [importView(importDependency)]
+            ? [{ kind: 'import', view: importView(importDependency) }]
             : registrationDependency !== undefined
-                ? [registrationView(registrationDependency)]
+                ? [{ kind: 'registration', view: registrationView(registrationDependency) }]
                 : [];
-    const applyKind = (entries, own, toView, addition) => {
-        if (!own)
+    const applyKind = (entries, entryKind, toView, addition) => {
+        if (!kinds.includes(entryKind))
             return [...entries];
+        const own = targets.filter((target) => target.kind === entryKind).map(({ view }) => view);
         if (mode !== 'remove')
-            return applyMode(entries, mode, targets[0], toView, addition);
-        return targets.reduce((remaining, target) => applyMode(remaining, 'remove', target, toView, undefined), [...entries]);
+            return applyMode(entries, mode, own[0], toView, addition);
+        return own.reduce((remaining, target) => applyMode(remaining, 'remove', target, toView, undefined), [...entries]);
     };
     const applyToStaged = (staged) => {
         if (mode === 'clear')
             return {};
-        const forwardImports = applyKind(staged?.forwardImports ?? [], kind === 'import', importView, importDependency);
-        const registrations = applyKind(staged?.registrations ?? [], kind === 'registration', registrationView, registrationDependency);
+        const forwardImports = applyKind(staged?.forwardImports ?? [], 'import', importView, importDependency);
+        const registrations = applyKind(staged?.registrations ?? [], 'registration', registrationView, registrationDependency);
         return {
             ...(forwardImports.length > 0 ? { forwardImports } : {}),
             ...(registrations.length > 0 ? { registrations } : {}),
@@ -168,7 +174,7 @@ export async function patchStagedDependencyCommand(projectRoot, identifier, opti
     };
     const existing = targetPatch.stagedDependencies;
     const projected = applyToStaged(existing);
-    const summary = describeStagedDependencyChange(existing, projected, mode, kind, targets);
+    const summary = describeStagedDependencyChange(existing, projected, mode, kinds, targets);
     if (isDryRun) {
         info(`[dry-run] ${targetPatch.filename}: ${summary}.`);
         outro('Dry run complete — no changes made');
@@ -188,7 +194,7 @@ export async function patchStagedDependencyCommand(projectRoot, identifier, opti
     }
     const before = result.before.stagedDependencies;
     const after = result.after.stagedDependencies;
-    info(`${targetPatch.filename}: ${describeStagedDependencyChange(before, after, mode, kind, targets)}.`);
+    info(`${targetPatch.filename}: ${describeStagedDependencyChange(before, after, mode, kinds, targets)}.`);
     if (mode === 'remove' && countStagedEntries(after) === countStagedEntries(before)) {
         // The selection matched when the queue was read; a peer removed the
         // entries before the locked write. Still a miss, so still a refusal.
@@ -201,7 +207,8 @@ export async function patchStagedDependencyCommand(projectRoot, identifier, opti
         args: {
             filename: targetPatch.filename,
             mode,
-            kind,
+            // A kind-less --remove searched both kinds; the delta names which.
+            ...(kind !== undefined ? { kind } : {}),
             ...stagedDependencyDelta(before, after),
         },
         ...(options.yes === true ? { yes: true } : {}),
@@ -223,7 +230,7 @@ export function registerPatchStagedDependency(parent, context) {
         .option('--add', 'Add a staged dependency declaration')
         .option('--remove', 'Remove matching staged dependency declaration(s); a selection that matches nothing exits 8')
         .option('--clear', 'Drop the stagedDependencies field entirely')
-        .option('--kind <kind>', 'Declaration shape: "import" (forward import, the default) or "registration" (jar.mn packaging line, customElements or actor registration)')
+        .option('--kind <kind>', 'Declaration shape: "import" (forward import, the default) or "registration" (jar.mn packaging line, customElements or actor registration); --remove without it takes the kind --specifier or --line names, or both kinds')
         .option('--file <path>', 'Declaring file path relative to engine/')
         .option('--specifier <specifier>', 'Exact import specifier as it appears in source (--kind import)')
         .option('--line <text>', 'Registration/packaging line as the patch adds it, compared whitespace-insensitively (--kind registration)')

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

@@ -97,10 +97,16 @@ function validatePathFlagValues(options) {
         }
     }
 }
+/**
+ * A retirement names its owner among explicitly selected patches. It
+ * combines with `--scan`: the retired path leaves the scan's base first,
+ * and the scan cannot adopt it back, since a retired created file is absent
+ * and a retired upstream file is clean at HEAD.
+ */
 function validateExpectedRemovalUsage(patches, options) {
     if (options.expectRemoved?.length &&
-        (options.scan || options.all || options.files !== undefined || patches.length === 0)) {
-        throw new InvalidArgumentError('--expect-removed requires explicit selected patches and the scan-less path (no --scan, --files, or --all).', '--expect-removed');
+        (options.all || options.files !== undefined || patches.length === 0)) {
+        throw new InvalidArgumentError('--expect-removed requires explicit selected patches and cannot combine with --files or --all.', '--expect-removed');
     }
 }
 /**

package/dist/src/commands/run.js

@@ -130,6 +130,7 @@ async function runInteractive(engineDir, options, profile) {
     const exitCode = await run(engineDir, [
         ...(options.headless ? ['--headless'] : []),
         ...profile.args,
+        ...(options.args ?? []),
     ]);
     // Exit-code whitelist:
     //   0:   clean shutdown
@@ -234,7 +235,12 @@ async function runSmokeExit(engineDir, options, profile) {
     const startedAt = Date.now();
     let result;
     try {
-        const machArgs = ['run', ...(options.headless ? ['--headless'] : []), ...profile.args];
+        const machArgs = [
+            'run',
+            ...(options.headless ? ['--headless'] : []),
+            ...profile.args,
+            ...(options.args ?? []),
+        ];
         result = await runMachSmoke(machArgs, engineDir, {
             smokeTimeoutMs,
             onStdoutLine: (line) => {
@@ -394,6 +400,7 @@ export function registerRun(program, { getProjectRoot, withErrorHandling }) {
     program
         .command('run')
         .description('Launch the built browser')
+        .argument('[args...]', 'Arguments passed to the browser after the profile ones, given after "--" (e.g. -- -marionette -remote-allow-system-access)')
         .option('--smoke-exit <seconds>', 'Smoke-run mode (POSIX only): launch, capture console, SIGTERM the process group after <seconds>. Exit 0 on a clean window, 12 on unallowed errors, 13 on launch failure.', commanderArgParser((value) => {
         const parsed = Number.parseInt(value, 10);
         if (!Number.isFinite(parsed) || parsed < 1 || String(parsed) !== value.trim()) {
@@ -410,8 +417,8 @@ export function registerRun(program, { getProjectRoot, withErrorHandling }) {
         .option('--temp-profile', 'Launch with a fresh temporary profile that is removed when the run ends. The default for --smoke-exit.')
         .action(withErrorHandling(
     // `args` is the variadic positional, not a Commander flag, so it
-    // never appears in this object.
-    async (options) => {
-        await runCommand(getProjectRoot(), pickDefined(options));
+    // arrives apart from the options object.
+    async (args, options) => {
+        await runCommand(getProjectRoot(), pickDefined({ ...options, ...(args.length > 0 ? { args } : {}) }));
     }));
 }

package/dist/src/commands/test-orchestrate.js

@@ -27,6 +27,7 @@ import { stripEnginePrefix } from '../utils/paths.js';
 import { controlBuildRecorded, runControlRestoreBuild } from './test-control-restore.js';
 import { classifyTestHarnesses } from './test-modes.js';
 import { deriveControlOutcome, describeControlOutcome, formatAggregateBody, formatRunLine, parseCapturedVerdict, worstRun, } from './test-multi-verdict.js';
+import { rearmSpentWaits } from './test-prelock.js';
 import { emitAggregateVerdict, emitFailVerdict, setVerdictCapture, setVerdictRunAttribute, verdictEmitted, } from './test-verdict.js';
 function assertMultiRunUsage(testPaths, options) {
     const flag = options.negativeControl !== undefined ? '--negative-control' : '--repeat';
@@ -58,7 +59,9 @@ async function splitHarnesses(engineDir, testPaths, options) {
 }
 /** Options for every run after the first: the build and doctor run once. */
 function laterRunOptions(options) {
-    const later = { ...options };
+    // A later run follows the earlier runs' work under the same lock hold, so
+    // its browser and port checks wait out the budgets again.
+    const later = { ...rearmSpentWaits(options) };
     delete later.build;
     delete later.extendCoverage;
     delete later.refuseUnexportedDrift;

package/dist/src/commands/test-prelock.d.ts

@@ -48,3 +48,14 @@ export declare const TEST_BUILD_PREFLIGHT: {
  * @param options - Parsed test options
  */
 export declare function runTestPreLockPreflight(projectRoot: string, testPaths: string[], options: TestOptions): Promise<TestOptions>;
+/**
+ * `options` with the wait budgets the pre-lock pass spent put back, for a
+ * browser or port check that follows work this invocation already did
+ * under the lock: its pre-test build, or an earlier run of a sequence. A
+ * busy browser there is a peer that started after the lock was taken, and
+ * refusing would throw the build away, so it is waited out like the first
+ * check's.
+ *
+ * @param options - In-lock run options
+ */
+export declare function rearmSpentWaits(options: TestOptions): TestOptions;

package/dist/src/commands/test-prelock.js

@@ -219,15 +219,40 @@ async function refuseStalePackagingBeforeLock(projectRoot, engineDir, options, r
             'against a fresh build of the requested paths.', error.note);
     }
 }
-/** `options` without one wait budget, which this pass already spent. */
+/**
+ * `options` without one wait budget, which this pass already spent. The
+ * budget moves to `spentWaits`, for {@link rearmSpentWaits}.
+ */
 function withoutOption(options, key) {
-    const rest = { ...options };
+    const rest = { ...options, spentWaits: { ...options.spentWaits, [key]: options[key] } };
     if (key === 'waitBrowser')
         delete rest.waitBrowser;
     else
         delete rest.waitPort;
     return rest;
 }
+/**
+ * `options` with the wait budgets the pre-lock pass spent put back, for a
+ * browser or port check that follows work this invocation already did
+ * under the lock: its pre-test build, or an earlier run of a sequence. A
+ * busy browser there is a peer that started after the lock was taken, and
+ * refusing would throw the build away, so it is waited out like the first
+ * check's.
+ *
+ * @param options - In-lock run options
+ */
+export function rearmSpentWaits(options) {
+    const spent = options.spentWaits;
+    if (spent === undefined)
+        return options;
+    const rearmed = { ...options };
+    if (spent.waitBrowser !== undefined)
+        rearmed.waitBrowser = spent.waitBrowser;
+    if (spent.waitPort !== undefined)
+        rearmed.waitPort = spent.waitPort;
+    delete rearmed.spentWaits;
+    return rearmed;
+}
 /**
  * Spends `--wait-browser` and `--wait-port` before the lock, mirroring
  * which in-lock checks would apply to this run, and strips each budget it

package/dist/src/commands/test-register.js

@@ -86,7 +86,8 @@ const TEST_HELP_TEXT = [
     'launchable binary (with the build that left it missing, when one is',
     'recorded), the named-file checkJs pass of --build, and the',
     '--wait-browser/--wait-port budgets. Each is re-checked once under the',
-    'lock.',
+    'lock; the checks after a pre-test build or an earlier run of the',
+    'sequence wait the budgets out again.',
 ].join('\n');
 function registerTestMultiRunOptions(test) {
     return test

package/dist/src/commands/test.js

@@ -25,7 +25,7 @@ import { buildPerfSampleEnv, mergeHarnessEnv, resolveShuffleSeed } from './test-
 import { removePgidFile, setActivePgidFile } from './test-harness-teardown.js';
 import { assertPathlessTestMode, assertTestModeCombinations, canaryTimeoutSeconds, classifyBeforeDispatch, resolveCanaryPath, restartBetweenTestsArgs, } from './test-modes.js';
 import { orchestrateTestRuns } from './test-orchestrate.js';
-import { resolveLaunchablePathForTests, runTestPreLockPreflight, TEST_BUILD_PREFLIGHT, } from './test-prelock.js';
+import { rearmSpentWaits, resolveLaunchablePathForTests, runTestPreLockPreflight, TEST_BUILD_PREFLIGHT, } from './test-prelock.js';
 import { resetTestResults, withRawLogDir, writeTestResults } from './test-results.js';
 import { DEFAULT_HARNESS_RETRIES } from './test-run.js';
 import { emitFailVerdict, resetVerdictEmission, setVerdictRunAttribute, verdictEmitted, } from './test-verdict.js';
@@ -362,7 +362,9 @@ async function runTestCommandBody(projectRoot, testPaths, options = {}, profileE
         if (buildId !== undefined)
             setVerdictRunAttribute('build-id', buildId);
     }
-    const { forwardedPort, effectivePort } = await ensureTestBrowserEnvironment(paths.engine, launchablePath, xpcshellOnly, projectConfig, options, buildCheck.objDir);
+    // After a pre-test build, a busy browser or port is a peer that started
+    // during it; waiting it out keeps the build this run just paid for.
+    const { forwardedPort, effectivePort } = await ensureTestBrowserEnvironment(paths.engine, launchablePath, xpcshellOnly, projectConfig, options.build === true ? rearmSpentWaits(options) : options, buildCheck.objDir);
     if (options.doctor) {
         const doctorOutcome = await runDoctorPreflight({
             engineDir: paths.engine,

package/dist/src/core/negative-control-diff.js

@@ -70,8 +70,8 @@ export function parseControlDiff(content, options = {}) {
         refuse('no diff sections found. Write the control with git, e.g. ' +
             '`git -C engine diff -- <file> > control.diff` after making the edit, then revert the edit.');
     }
-    const seen = new Set();
-    return sections.map((section) => {
+    const files = new Map();
+    for (const section of sections) {
         let path = normalizePathSlashes(section.targetPath);
         if (section.isBinary)
             refuse(`${path} is a binary section.`);
@@ -90,11 +90,36 @@ export function parseControlDiff(content, options = {}) {
         }
         if (section.hunks.length === 0)
             refuse(`${path} has no hunks.`);
-        if (seen.has(path))
-            refuse(`${path} appears in more than one section.`);
-        seen.add(path);
-        return { path, hunks: section.hunks };
+        const existing = files.get(path);
+        if (existing === undefined) {
+            files.set(path, { path, hunks: [...section.hunks], sections: 1 });
+        }
+        else {
+            existing.hunks.push(...section.hunks);
+            existing.sections += 1;
+        }
+    }
+    return [...files.values()].map(({ path, hunks, sections: count }) => ({
+        path,
+        hunks: count === 1 ? hunks : mergeSectionHunks(path, hunks),
+    }));
+}
+/**
+ * Orders the hunks of a file that several sections name (a generator that
+ * writes one section per edit) as one section's would be. Hunks that
+ * overlap cannot be applied one after another, so they are refused.
+ */
+function mergeSectionHunks(path, hunks) {
+    const ordered = [...hunks].sort((left, right) => left.oldStart - right.oldStart);
+    ordered.forEach((hunk, index) => {
+        const previous = ordered[index - 1];
+        if (previous !== undefined && previous.oldStart + previous.oldCount > hunk.oldStart) {
+            refuse(`${path} appears in more than one section, and hunks from them overlap ` +
+                `(@@ -${previous.oldStart},${previous.oldCount} @@ and @@ -${hunk.oldStart},${hunk.oldCount} @@). ` +
+                'Make every edit to the file, then write one section for it with `git -C engine diff -- <file>`.');
+        }
     });
+    return ordered;
 }
 function hunkSides(hunk, label, index) {
     const oldLines = [];

package/dist/src/core/test-stale-check.js

@@ -139,7 +139,7 @@ export async function findCompiledSourcesNewerThanBinary(engineDir, baseline, la
     }
     return {
         paths: paths.sort(),
-        linkedPath: relative(engineDir, linked.path),
+        linkedPath: normalizePathSlashes(relative(engineDir, linked.path)),
         linkedAt: new Date(linked.mtimeMs),
     };
 }

package/dist/src/types/commands/options.d.ts

@@ -648,6 +648,18 @@ export interface TestOptions extends EngineLockWaitable {
     waitBrowser?: number | boolean;
     /** Queue behind the mochitest/Marionette port holder. */
     waitPort?: number | boolean;
+    /**
+     * The `--wait-browser`/`--wait-port` budgets the pre-lock pass already
+     * spent (and stripped from `waitBrowser`/`waitPort`). The first in-lock
+     * check probes once; a check that follows work this invocation did under
+     * the lock (its pre-test build, or an earlier run of a `--repeat` or
+     * `--negative-control` sequence) waits them out again, because refusing
+     * there throws that work away.
+     */
+    spentWaits?: {
+        waitBrowser?: number | boolean;
+        waitPort?: number | boolean;
+    };
     /** Also write the run log here, outside `.fireforge/logs/` retention. */
     keepLog?: string;
     /** Forward mochitest's `--restart-between-tests` (mochitest dispatch only). */

package/docs/configuration.md

@@ -656,6 +656,13 @@ owning process is gone.
   every run, and a temporary profile starts without one.
 - `--temp-profile` gives a plain `run` the same fresh, removed-afterwards
   profile.
+- Arguments after `--` go to the browser, after the profile ones. A headed
+  session on a kept profile that a chrome-context Marionette client drives
+  is `fireforge run --profile <dir> -- -marionette -remote-allow-system-access`,
+  with `marionette.port` set in the profile's `user.js` so peers' harnesses
+  keep 2828. The objdir app launched directly gets neither `-purgecaches`
+  nor the startup-cache cleanup, so it can serve a widget script an earlier
+  launch cached.
 
 A smoke run whose browser exits with a clean status before the window
 elapses, without printing any console output, fails with exit 13.

package/docs/patch-workflow.md

@@ -169,7 +169,7 @@ list rather than the subset left after filtering, so nothing dropped upstream
 can pass as a silent success.
 
 A file can be retired from a selected patch with repeatable
-`--expect-removed <path>` on scan-less re-export. This works for an absent
+`--expect-removed <path>`. This works for an absent
 file the patch created, and for an upstream file the patch modified or
 deleted whose engine copy is back at HEAD:
 
@@ -190,7 +190,10 @@ validated before writes, in dry-run too. Other paths keep
 both refusal checks; retirement grants no unmanaged or foreign-drift
 exception. Removing every file would empty the patch and requires `patch
 delete` (or `patch retire`, which keeps the order number) instead.
-`--expect-removed` cannot combine with `--scan`, `--files` or `--all`.
+`--expect-removed` cannot combine with `--files` or `--all`. It combines
+with `--scan`, so one call can retire a widget's files from one patch while
+`--scan-file` adopts a new module into another: the retired path leaves the
+owner's file list before its scan, which cannot adopt it back.
 
 The same run drops every staged declaration, registration or forward
 import, in any patch of the queue, whose `creates` path it retired and no
@@ -386,11 +389,14 @@ hash-object` and `git update-index`. A collision (two rows at one order) or
   copy and the index do not differ on key order alone.
 - `patch staged-dependency <name> --remove` names the entries to remove by
   any of `--file`, `--specifier`/`--line`, `--creates` and `--owner`. It needs
-  `--creates`, or `--file` with the matcher. `--creates` alone removes every
-  declaration for that created path, which is the cleanup after a merge
-  deletes it. Registration lines compare whitespace-insensitively, as the
-  lint does. A selection that matches nothing is refused with exit 8, on a
-  dry run too.
+  `--creates`, or `--file` with the matcher. Without `--kind`, `--specifier`
+  selects imports, `--line` selects registrations, and a selection with
+  neither searches both kinds, so `--creates` alone removes every
+  declaration for that created path, imports and registrations alike, which
+  is the cleanup after a merge deletes it. Registration lines compare
+  whitespace-insensitively, as the lint does. A selection that matches
+  nothing is refused with exit 8, on a dry run too, and the refusal lists
+  the patch's declarations of every kind it searched.
 - `patch staged-dependency <name> --add --from <json-file>` adds many
   declarations in one call under one lock hold. The file is a `lint
 --per-patch --report` document (its findings' `stagedDeclarations` for

package/docs/testing.md

@@ -83,7 +83,10 @@ Furnace deployed it to, since that is what the run reads; the component
 source itself is never touched. Only modifications of existing text files
 are accepted: a created, deleted, renamed or binary file, or a symlinked
 target, is refused. Hunks must match exactly; the only tolerance is a line
-offset, as in `git apply`, never fuzz.
+offset, as in `git apply`, never fuzz. A file named by more than one
+section (a generator that writes one section per edit) is applied as one
+section with every hunk in file order; sections whose hunks overlap are
+refused, with the advice to write one section for the file.
 
 The verdict says how the control came out with `control=`:
 
@@ -329,7 +332,11 @@ engine session lock is requested, so a run waiting out a browser or a port
 does not hold every peer's build, test and re-export behind it. The run then
 joins the lock queue and re-checks once under the lock; the normal preflight
 refusal and its remedy apply if the resource is busy again (or still busy)
-there. With `--kill-stale-marionette` a reapable stale browser counts as
+there. A check that follows work the run already did under the lock waits
+the budgets out again instead: the browser and port checks after a
+`--build` run's pre-test build, and those of every later run of a `--repeat`
+or `--negative-control` sequence, so a peer's browser that started during
+the build does not throw the build away. With `--kill-stale-marionette` a reapable stale browser counts as
 clear before the lock, and the port waits stay under the lock, where the
 stale listener can be reaped.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.53.0",
+  "version": "0.54.0",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",