@hominis/fireforge 0.45.0 → 0.46.1

package/dist/src/commands/import.js

@@ -20,9 +20,9 @@ import { pickDefined } from '../utils/options.js';
 /**
  * Errno codes for filesystem-level failures against the working file.
  * These are safe to fall through as "unmanaged" because they describe the
- * *state of the engine directory*, not the integrity of the patch stack.
- * Manifest / patch-parse / PatchError failures do NOT match this set and
- * are re-thrown so the root cause surfaces instead of being silently
+ * state of the engine directory rather than the integrity of the patch
+ * stack. Manifest / patch-parse / PatchError failures do not match this set
+ * and are re-thrown so the root cause surfaces instead of being silently
  * reclassified as a spurious dirty file.
  */
 const SAFE_IO_FALLBACK_CODES = new Set(['ENOENT', 'EACCES', 'EPERM', 'EISDIR', 'EBUSY']);
@@ -48,7 +48,7 @@ async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
         }
         catch (error) {
             // PatchError, manifest corruption, and patch-parse failures are
-            // *structural* problems with the patch stack — masking them as
+            // structural problems with the patch stack. Masking them as an
             // "unmanaged dirty file" would let the user `--force` past a real
             // root cause (e.g. "patch 003 missing from manifest") and compound
             // the corruption. Only swallow the pure-IO fallback cases where
@@ -91,7 +91,7 @@ async function checkUncommittedPatchFiles(engineDir, patchesDir, forceImport) {
                 // already carries the patch's effects. The import below still
                 // re-applies each patch (a no-op for files whose contents already
                 // match), so phrase the line as "no resync needed" rather than
-                // "patches already applied" — the latter contradicts the "Applied N
+                // "patches already applied". The latter contradicts the "Applied N
                 // patch(es)" summary `applyPatchesWithContinue` prints next.
                 info('Patch-touched files already match the stored patch stack — no engine resync needed before re-applying.');
             }
@@ -160,7 +160,7 @@ async function checkEngineDrift(engineDir, baseCommit, forceImport, acceptPrompt
     const currentHead = await getHead(engineDir);
     if (currentHead === baseCommit)
         return true;
-    // `--yes` and `--force` both answer this prompt; only `--force` also
+    // `--yes` and `--force` both answer this prompt. Only `--force` also
     // waives the patch-integrity gate further down.
     const promptAnswered = forceImport || acceptPrompts;
     if (!stdioIsInteractive()) {
@@ -193,7 +193,7 @@ async function checkEngineDrift(engineDir, baseCommit, forceImport, acceptPrompt
  * without the `.patch` suffix (matching `applyPatchesWithContinue`'s
  * `untilFilename` resolver).
  *
- * Returns an empty set when no match is found — the caller treats that as
+ * Returns an empty set when no match is found. The caller treats that as
  * "no scope filter applies" so the import behaves identically to an
  * unrecognised `--until` target (which `applyPatchesWithContinue` will
  * later surface as a normal error).
@@ -202,11 +202,11 @@ function buildUntilFilenameSet(patches, until) {
     const set = new Set();
     if (until === undefined)
         return set;
-    // Resolve the identifier with the SAME matcher the apply loop uses
-    // (`matchesUntilFilename` accepts filenames, extension-less names, AND
+    // Resolve the identifier with the same matcher the apply loop uses
+    // (`matchesUntilFilename` accepts filenames, extension-less names, and
     // bare ordinals). A filename-only match makes `import --until 5` produce
-    // an EMPTY scope set — the UI previews "0 patches", the integrity gates
-    // filter every in-range issue away — and the apply loop then applies
+    // an empty scope set: the UI previews "0 patches", the integrity gates
+    // filter every in-range issue away, and the apply loop then applies
     // patches 1..5 anyway.
     const target = patches.find((p) => matchesUntilFilename(p.filename, until));
     if (!target)
@@ -228,8 +228,8 @@ async function assertScopedManifestConsistency(patchesDir, untilFilenameSet, unt
     const manifestConsistencyIssues = await validatePatchesManifestConsistency(patchesDir);
     const scopedManifestIssues = until !== undefined
         ? manifestConsistencyIssues.filter((issue) => 
-        // Global (manifest-level) issues have no specific filename to scope
-        // against — a missing or unparseable patches.json blocks any
+        // Global (manifest-level) issues have no specific filename to
+        // scope against: a missing or unparseable patches.json blocks any
         // import. Per-patch issues only block when the patch is in scope.
         issue.code === 'manifest-missing' ||
             issue.code === 'manifest-invalid' ||
@@ -249,7 +249,7 @@ async function assertScopedManifestConsistency(patchesDir, untilFilenameSet, unt
 /**
  * Prints advisory version-compatibility warnings for every in-scope patch
  * whose recorded source version differs meaningfully from the configured
- * Firefox version. Advisory only — never blocks the import.
+ * Firefox version. Advisory only. Never blocks the import.
  */
 async function warnVersionCompatibility(projectRoot, manifest, untilFilenameSet, until) {
     if (!manifest)
@@ -269,7 +269,7 @@ async function warnVersionCompatibility(projectRoot, manifest, untilFilenameSet,
 }
 /**
  * Patch-integrity gate: surfaces orphaned-modification issues scoped to
- * the `--until` range and decides whether the import may proceed —
+ * the `--until` range and decides whether the import may proceed.
  * `--force` continues with a warning, non-TTY refuses loudly, and an
  * interactive operator is prompted. Returns false when the import should
  * stop (the cancel outro has been printed).
@@ -413,8 +413,8 @@ export async function importCommand(projectRoot, options = {}) {
             success(`  ${result.patch.filename}${suffix}`);
         }
         // The re-applied queue may have moved components.conf away from what
-        // the last full build compiled in — surface that now instead of at the
-        // next test refusal.
+        // the last full build compiled in, so surface that now instead of at
+        // the next test refusal.
         await warnIfStaticComponentsStale(projectRoot, paths.engine);
         outro('All patches applied successfully!');
     }
@@ -432,21 +432,14 @@ export function registerImport(program, { getProjectRoot, withErrorHandling }) {
         .description('Apply patches from the patches directory')
         .option('--continue', 'Continue applying patches even if one fails')
         .option('-f, --force', 'Proceed despite engine drift and overwrite unmanaged changes in patch-touched files')
-        // NOT an alias of --force. `--force` waives two orthogonal things: the
-        // drift prompt AND the patch-integrity gate. `--yes` waives only the
+        // Not an alias of --force. `--force` waives two orthogonal things: the
+        // drift prompt and the patch-integrity gate. `--yes` waives only the
         // prompt, so a scripted import can run unattended while the integrity
-        // refusal stays armed — which is the guard you actually want in CI.
+        // refusal stays armed, which is the guard you want in CI.
         .option('-y, --yes', 'Answer the drift prompt non-interactively. Unlike --force, this does NOT waive the patch-integrity gate.')
-        .option('--until <patch>', 'Apply patches only up to and including this patch (alias: --stop-at)')
-        .option('--stop-at <patch>', 'Alias for --until')
+        .option('--until <patch>', 'Apply patches only up to and including this patch')
         .option('--dry-run', 'Preview which patches would be applied without modifying the engine')
         .action(withErrorHandling(async (options) => {
-        // Accept both spellings; --until wins when both are passed.
-        const merged = { ...options };
-        if (merged.until === undefined && merged.stopAt !== undefined) {
-            merged.until = merged.stopAt;
-        }
-        delete merged.stopAt;
-        await importCommand(getProjectRoot(), pickDefined(merged));
+        await importCommand(getProjectRoot(), pickDefined(options));
     }));
 }

package/dist/src/commands/lint-per-patch.d.ts

@@ -1,5 +1,5 @@
-import { getProjectPaths } from '../core/config.js';
 import type { LintCommandOptions } from '../types/commands/index.js';
+import type { ProjectPaths } from '../types/config.js';
 /**
  * Lints each patch in the queue as its own isolated diff, honouring
  * per-patch `lintIgnore` entries. Cross-patch rules still run once over
@@ -7,4 +7,4 @@ import type { LintCommandOptions } from '../types/commands/index.js';
  * With `options.patches` set, only the named subset is linted (and the
  * queue-level findings are scoped to files those patches touch).
  */
-export declare function lintPerPatch(projectRoot: string, paths: ReturnType<typeof getProjectPaths>, options?: LintCommandOptions): Promise<void>;
+export declare function lintPerPatch(projectRoot: string, paths: ProjectPaths, options?: LintCommandOptions): Promise<void>;

package/dist/src/commands/lint-per-patch.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
-import { getProjectPaths, loadConfig } from '../core/config.js';
+import { loadConfig } from '../core/config.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { withPrivateGitIndex } from '../core/git-readonly-index.js';
 import { buildPatchQueueContext, countNonBinaryDiffLines, formatPatchLintIssue, lintExportedPatch, lintPatchQueue, resolvePatchSizeTier, } from '../core/patch-lint.js';
@@ -28,7 +28,7 @@ function emitTierNotice(filename, files, tier) {
 /**
  * Lints one queued patch against its own isolated diff, reusing the cache entry
  * when the cache key matches. Returns the outcome and the patch's (unprefixed)
- * issues without touching shared state — the orchestrator applies the tier
+ * issues without touching shared state. The orchestrator applies the tier
  * notice, issue prefixing, and cache write in patch order after the pool
  * drains, so the bounded concurrency cannot reorder output. Returns `skipped`
  * (no files present / empty diff), `cached`, or `linted`.
@@ -135,8 +135,8 @@ const SUPPRESSED_SIZE_CHECKS = new Set([
  * Applies the per-patch results in patch order so the bounded concurrency
  * cannot reorder output: emits each tier notice, the once-only run-level
  * checkJs errors (before the first freshly linted patch's issues), the
- * filename-prefixed issue rows, and the cache writes — all in the same sequence
- * a serial run produced. Returns the run tallies.
+ * filename-prefixed issue rows, and the cache writes, all in the same
+ * sequence a serial run produced. Returns the run tallies.
  */
 async function applyPerPatchResults(subset, results, issues, checkJs, cache) {
     const totals = {
@@ -158,8 +158,8 @@ async function applyPerPatchResults(subset, results, issues, checkJs, cache) {
         }
         emitTierNotice(patch.filename, result.existingFiles, patch.tier);
         // Run-level checkJs errors are emitted once, before the first
-        // non-skipped patch's own issues — matching the serial emit point.
-        // Deliberately NOT gated on `result.usedCheckJs`: global findings are
+        // non-skipped patch's own issues, matching the serial emit point.
+        // Not gated on `result.usedCheckJs`: global findings are
         // run-level and never cached, so gating drops them entirely on an
         // all-cache-hit run and lets a warm run report fewer errors than a cold
         // one. PerRunCheckJs builds its program lazily, so the cost only
@@ -169,13 +169,21 @@ async function applyPerPatchResults(subset, results, issues, checkJs, cache) {
             issues.push(...(await checkJs.getGlobal()));
         }
         if (result.cacheWrite && cache) {
-            setCachedPerPatchLintIssues(cache, patch.filename, result.cacheWrite.key, result.rawIssues, result.suppressedIssues, result.lineCount, result.cacheWrite.lintIgnore);
+            setCachedPerPatchLintIssues({
+                cache,
+                patchFilename: patch.filename,
+                key: result.cacheWrite.key,
+                issues: result.rawIssues,
+                suppressed: result.suppressedIssues,
+                lineCount: result.lineCount,
+                lintIgnore: result.cacheWrite.lintIgnore,
+            });
             totals.cacheDirty = true;
         }
         for (const issue of result.rawIssues) {
             issues.push({ ...issue, file: `${patch.filename} :: ${issue.file}` });
         }
-        // A waived size finding still reports its MEASUREMENT: the finding stays
+        // A waived size finding still reports its measurement: the finding stays
         // suppressed (no exit-code / --max-warnings effect) but the current count
         // is readable from the tool that enforces it, so a waiver's cited size
         // can be calibrated without hand-measuring.
@@ -267,7 +275,7 @@ function reportPerPatchOutcome(issues, linted, skipped, options) {
 /**
  * Resolves the `--patches <name…>` subset filter against the manifest,
  * matching each requested name tolerantly (exact filename, filename ±
- * `.patch`, or the manifest `name` field). Throws listing the available
+ * `.patch`, the bare order number, or the manifest `name` field). Throws listing the available
  * patches when a requested name matches none, so a typo fails loud rather
  * than silently linting nothing.
  */
@@ -278,7 +286,14 @@ function selectPatchSubset(manifest, requested) {
         .filter((entry) => entry.length > 0);
     const patchAliases = (p) => {
         const aliases = new Set([p.filename, p.filename.replace(/\.patch$/, ''), p.name]);
+        // The bare order number, both as the manifest records it and as the
+        // filename spells it (`2` and `002`). The refusal message offers stems,
+        // and an operator reading `102-ui-canvas-tiles.patch` in a lint finding
+        // reaches for `102` first.
+        aliases.add(String(p.order));
         const match = /^(\d+)-([a-z]+)-(.+)\.patch$/.exec(p.filename);
+        if (match?.[1])
+            aliases.add(match[1]);
         if (match?.[2] && match[3]) {
             aliases.add(`${match[2]}-${match[3]}`);
             aliases.add(match[3]);
@@ -296,7 +311,7 @@ function selectPatchSubset(manifest, requested) {
         if (found.length === 0) {
             const available = manifest.patches.map((p) => p.filename).join(', ');
             throw new GeneralError(`No patch in the queue matches "${name}". In --per-patch mode, positional arguments ` +
-                `and --patches select patches (filename, stem, manifest name, or slug) — not engine ` +
+                `and --patches select patches (filename, stem, order number, manifest name, or slug) — not engine ` +
                 `files; drop --per-patch to lint engine paths. Available patches: ${available}`);
         }
         for (const p of found) {
@@ -316,7 +331,7 @@ function selectPatchSubset(manifest, requested) {
  * queue-level findings are scoped to files those patches touch).
  */
 export async function lintPerPatch(projectRoot, paths, options = {}) {
-    // Read-only to the operator, an index WRITER to git: the per-patch diffs
+    // Read-only to the operator, but an index writer to git: the per-patch diffs
     // run `git diff HEAD` (and, for untracked binaries, a real stage/unstage
     // pair) against the primary checkout. A private index absorbs all of it
     // so a concurrent `fireforge test` still gets an evidential verdict.
@@ -364,7 +379,7 @@ async function lintPerPatchInner(projectRoot, paths, options = {}) {
         });
     }
     // With `--patches`, the checkJs program roots at only the subset's owned
-    // files — the full queue stays resolvable, so a cold subset run costs the
+    // files. The full queue stays resolvable, so a cold subset run costs the
     // subset's import closure instead of the whole queue.
     const checkJs = buildPerRunCheckJs(projectRoot, paths, config, ctx, isSubset ? subsetNames : undefined);
     // Lint patches concurrently, then apply every side effect in patch order so

package/dist/src/commands/lint-per-run-checkjs.d.ts

@@ -3,27 +3,26 @@
  * `re-export`.
  *
  * The dominant fixed cost of patch lint is one `ts.createProgram` over the
- * queue's patch-owned `.sys.mjs` files — tens of seconds on a large queue.
- * This controller builds that program at most ONCE per command invocation
+ * queue's patch-owned `.sys.mjs` files, tens of seconds on a large queue.
+ * This controller builds that program at most once per command invocation
  * (lazily, promise-memoised) and lets callers slice per-patch findings out of
  * the grouped result. Three levers keep the cost paid only when it buys
  * something:
  *
- * - **Lazy build**: nothing is built until the first cache miss asks.
- * - **Root scoping** (`rootScopePatches`): with `--patches <subset>` the
- *   program's roots are only the subset's owned files; the full queue stays
+ * - Lazy build: nothing is built until the first cache miss asks.
+ * - Root scoping (`rootScopePatches`): with `--patches <subset>` the
+ *   program's roots are only the subset's owned files. The full queue stays
  *   resolvable, so cross-patch imports type-check identically while
  *   unrelated files are never parsed.
- * - **Warm-run probe**: run-level ("global") checkJs findings come only from
- *   a missing `typescript` package or an unreadable shim — never from the
- *   built program — so an all-cache-hit run satisfies "warm never reports
- *   less than cold" via `probeCheckJsGlobalIssues` instead of building
- *   anything.
+ * - Warm-run probe: run-level ("global") checkJs findings come only from a
+ *   missing `typescript` package or an unreadable shim, never from the built
+ *   program, so an all-cache-hit run satisfies "warm never reports less than
+ *   cold" via `probeCheckJsGlobalIssues` instead of building anything.
  */
-import type { getProjectPaths, loadConfig } from '../core/config.js';
 import { type GroupedCheckJsResult } from '../core/patch-lint-checkjs.js';
 import type { PatchQueueContext } from '../core/patch-lint-cross.js';
 import type { PatchLintIssue } from '../types/commands/index.js';
+import type { FireForgeConfig, ProjectPaths } from '../types/config.js';
 /**
  * Queue-wide checkJs program built once per run and sliced per patch, so a
  * single type regression surfaces once against its owning patch instead of
@@ -32,7 +31,7 @@ import type { PatchLintIssue } from '../types/commands/index.js';
 export interface PerRunCheckJs {
     /** Patch filename → the checkJs-relevant files that patch creates. */
     ownedByPatch: Map<string, Set<string>>;
-    /** Every checkJs-relevant file in the queue (sys + test scripts) — the
+    /** Every checkJs-relevant file in the queue (sys + test scripts), the
      *  resolution universe the program can see. Callers use it to detect
      *  files the hoisted program has never heard of (fresh `--scan`
      *  adoptions) and fall back to a per-patch build. */
@@ -43,10 +42,10 @@ export interface PerRunCheckJs {
     getGrouped: () => Promise<GroupedCheckJsResult>;
     /** Run-level checkJs errors (e.g. TypeScript missing). When the program
      *  was never built (all-warm run) this probes the two global failure
-     * sources directly instead of building it holds because the
+     *  sources directly instead of building it, which is safe because the
      *  built program never contributes globals of its own. */
     getGlobal: () => Promise<PatchLintIssue[]>;
-    /** The byFile slices for `files` (globals deliberately EXCLUDED — they
+    /** The byFile slices for `files` (globals are excluded because they
      *  are run-level, never cached, and emitted once per invocation via
      *  `getGlobal`). Feed to `LintExportedPatchOptions.precomputedCheckJs`. */
     sliceFor: (files: ReadonlySet<string>) => Promise<PatchLintIssue[]>;
@@ -61,4 +60,4 @@ export interface PerRunCheckJs {
  * subset's owned files and the test-file pass runs only the subset's own
  * scripts (head.js discovery still spans the queue).
  */
-export declare function buildPerRunCheckJs(projectRoot: string, paths: ReturnType<typeof getProjectPaths>, config: Awaited<ReturnType<typeof loadConfig>>, ctx: PatchQueueContext, rootScopePatches?: ReadonlySet<string>): PerRunCheckJs | undefined;
+export declare function buildPerRunCheckJs(projectRoot: string, paths: ProjectPaths, config: FireForgeConfig, ctx: PatchQueueContext, rootScopePatches?: ReadonlySet<string>): PerRunCheckJs | undefined;

package/dist/src/commands/lint-per-run-checkjs.js

@@ -4,22 +4,21 @@
  * `re-export`.
  *
  * The dominant fixed cost of patch lint is one `ts.createProgram` over the
- * queue's patch-owned `.sys.mjs` files — tens of seconds on a large queue.
- * This controller builds that program at most ONCE per command invocation
+ * queue's patch-owned `.sys.mjs` files, tens of seconds on a large queue.
+ * This controller builds that program at most once per command invocation
  * (lazily, promise-memoised) and lets callers slice per-patch findings out of
  * the grouped result. Three levers keep the cost paid only when it buys
  * something:
  *
- * - **Lazy build**: nothing is built until the first cache miss asks.
- * - **Root scoping** (`rootScopePatches`): with `--patches <subset>` the
- *   program's roots are only the subset's owned files; the full queue stays
+ * - Lazy build: nothing is built until the first cache miss asks.
+ * - Root scoping (`rootScopePatches`): with `--patches <subset>` the
+ *   program's roots are only the subset's owned files. The full queue stays
  *   resolvable, so cross-patch imports type-check identically while
  *   unrelated files are never parsed.
- * - **Warm-run probe**: run-level ("global") checkJs findings come only from
- *   a missing `typescript` package or an unreadable shim — never from the
- *   built program — so an all-cache-hit run satisfies "warm never reports
- *   less than cold" via `probeCheckJsGlobalIssues` instead of building
- *   anything.
+ * - Warm-run probe: run-level ("global") checkJs findings come only from a
+ *   missing `typescript` package or an unreadable shim, never from the built
+ *   program, so an all-cache-hit run satisfies "warm never reports less than
+ *   cold" via `probeCheckJsGlobalIssues` instead of building anything.
  */
 import { invokePatchLintCheckJsGrouped, probeCheckJsGlobalIssues, runCheckJsTestFilesGrouped, } from '../core/patch-lint-checkjs.js';
 import { isTestScriptFile, resolvePatchOwnedSysMjs, resolvePatchOwnedTestScripts, } from '../core/patch-lint-ownership.js';
@@ -52,7 +51,7 @@ export function buildPerRunCheckJs(projectRoot, paths, config, ctx, rootScopePat
         for (const f of files)
             resolutionSet.add(f);
     }
-    // The subset's owned files, split by program kind; undefined = full queue.
+    // The subset's owned files, split by program kind. Undefined = full queue.
     let scopedRoots;
     if (rootScopePatches !== undefined) {
         scopedRoots = new Set();
@@ -63,9 +62,9 @@ export function buildPerRunCheckJs(projectRoot, paths, config, ctx, rootScopePat
                 scopedRoots.add(f);
         }
     }
-    // One build for the whole run: the queue-wide `.sys.mjs` program plus —
-    // when `patchLint.checkJsTestFiles` is on — one small
-    // script-scope program per patch-owned test file, merged by file.
+    // One build for the whole run: the queue-wide `.sys.mjs` program, plus
+    // (when `patchLint.checkJsTestFiles` is on) one small script-scope
+    // program per patch-owned test file, merged by file.
     const buildAll = async () => {
         const sys = await invokePatchLintCheckJsGrouped(paths.engine, resolvePatchOwnedSysMjs(new Set(), ctx), patchLint, projectRoot, scopedRoots);
         if (!testFilesEnabled)
@@ -77,7 +76,7 @@ export function buildPerRunCheckJs(projectRoot, paths, config, ctx, rootScopePat
         }
         return { byFile, global: [...sys.global, ...tests.global] };
     };
-    // Memoise the *promise*, not the resolved value: under the bounded pool
+    // Memoise the promise rather than the resolved value: under the bounded pool
     // several patches can reach `getGrouped` before the first build resolves, and
     // `??=` on the promise (a synchronous expression) guarantees a single build.
     let groupedPromise;

package/dist/src/commands/lint-report.d.ts

@@ -1,7 +1,7 @@
 import type { PatchLintIssue, PatchMetadata } from '../types/commands/index.js';
 /**
  * Structural view of one per-patch lint outcome. Mirrors the relevant
- * fields of lint-per-patch's QueuedPatchResult without importing it —
+ * fields of lint-per-patch's QueuedPatchResult without importing it:
  * that module imports this one, and a type back-edge would trip the
  * dpdm cycle gate.
  */
@@ -14,8 +14,8 @@ export interface PerPatchReportResult {
 }
 /**
  * Writes the per-patch lint report JSON. Called after the per-patch
- * results are assembled in patch order; queue-level and policy findings
+ * results are assembled in patch order. Queue-level and policy findings
  * are patch-attributed by their `file`/`filename` fields upstream and
- * are NOT duplicated here — the report is the per-patch view.
+ * are not duplicated here. The report is the per-patch view.
  */
 export declare function writePerPatchLintReport(reportPath: string, subset: readonly PatchMetadata[], results: readonly PerPatchReportResult[]): Promise<void>;

package/dist/src/commands/lint-report.js

@@ -2,11 +2,11 @@
 /**
  * Machine-readable per-patch lint report (`lint --per-patch --report
  * <path>`). One mechanism serves two observability gaps: consumers get each
- * patch's size metrics against the SAME thresholds the size rules fire on,
+ * patch's size metrics against the same thresholds the size rules fire on,
  * instead of mirroring `countNonBinaryDiffLines`, and lintIgnore-suppressed
  * issues stay visible with their measurements rather than vanishing.
  *
- * Helper module consumed by lint-per-patch.ts; no registrar is exported and
+ * Helper module consumed by lint-per-patch.ts. No registrar is exported and
  * none is wanted.
  */
 import { getPatchSizeThresholds, resolvePatchSizeTier, } from '../core/patch-lint.js';
@@ -15,9 +15,9 @@ import { info } from '../utils/logger.js';
 const LINT_REPORT_SCHEMA_VERSION = 1;
 /**
  * Writes the per-patch lint report JSON. Called after the per-patch
- * results are assembled in patch order; queue-level and policy findings
+ * results are assembled in patch order. Queue-level and policy findings
  * are patch-attributed by their `file`/`filename` fields upstream and
- * are NOT duplicated here — the report is the per-patch view.
+ * are not duplicated here. The report is the per-patch view.
  */
 export async function writePerPatchLintReport(reportPath, subset, results) {
     const patches = [];

package/dist/src/commands/lint.d.ts

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
+import { type PatchQueueContext } from '../core/patch-lint.js';
 import type { CommandContext } from '../types/cli.js';
 import type { LintCommandOptions, PatchLintIssue } from '../types/commands/index.js';
 /**
@@ -26,15 +27,15 @@ export interface AggregateLintIgnoreResult {
  * attribute via `issue.file`, which is the offending site and is owned by
  * some patch.
  *
- * Multiple owners: an issue is dropped if **any** owning patch waived the
- * rule. Conservative — never adds new findings, only drops already-waived
- * ones.
+ * Multiple owners: an issue is dropped if any owning patch waived the
+ * rule. This is conservative: it never adds new findings, only drops
+ * already-waived ones.
  *
  * @param issues - Issues collected from the aggregate lint run.
  * @param ctx - Patch queue context used to attribute file → patch.
  * @returns Filtered issue list and the count of dropped findings.
  */
-export declare function applyAggregateLintIgnoreSuppression(issues: PatchLintIssue[], ctx: import('../core/patch-lint.js').PatchQueueContext): AggregateLintIgnoreResult;
+export declare function applyAggregateLintIgnoreSuppression(issues: PatchLintIssue[], ctx: PatchQueueContext): AggregateLintIgnoreResult;
 /**
  * Runs the lint command to check engine changes against patch quality rules.
  * @param projectRoot - Root directory of the project