@hominis/fireforge 0.46.0 → 0.46.2

package/dist/src/core/patch-lint-creators.js

@@ -7,8 +7,8 @@
  *
  * Memoised per context object: ownership resolution and cache-key
  * fingerprints call this 2-3× per linted patch, and each call otherwise
- * re-runs `detectNewFilesInDiff` over EVERY queue entry's diff. Keyed weakly
- * so a discarded context frees its map; a caller that mutates a context
+ * re-runs `detectNewFilesInDiff` over every queue entry's diff. Keyed weakly
+ * so a discarded context frees its map. A caller that mutates a context
  * entry in place must call {@link invalidateNewFileCreatorsCache}.
  */
 import { detectNewFilesInDiff } from './patch-lint-diff.js';
@@ -22,7 +22,7 @@ export function invalidateNewFileCreatorsCache(ctx) {
  * mode` by at least one patch in the queue. Paths created by only one
  * patch are also included so callers can distinguish "no creator" from
  * "exactly one creator" without re-scanning the diffs. The returned map
- * is memoised and shared — treat it as read-only.
+ * is memoised and shared, so treat it as read-only.
  */
 export function collectNewFileCreatorsByPath(ctx) {
     const memoised = newFileCreatorsMemo.get(ctx);

package/dist/src/core/patch-lint-cross.d.ts

@@ -35,13 +35,13 @@ export interface PatchQueueEntry {
      */
     newFiles: Map<string, string>;
     /**
-     * Every path this patch CREATES, whatever the body kind — text, a
+     * Every path this patch creates, whatever the body kind: text, a
      * reconstructable `GIT binary patch`, or a payload-less
      * `Binary files … differ` stub. `newFiles` is text-only by design (a
      * binary authors no imports, so the import rules gain nothing from it and
      * `extractNewFileContent` correctly refuses to decode one), but "does a
      * later patch create this path" is a question about existence after apply,
-     * not about content — and answering it from `newFiles` made every binary
+     * not about content, and answering it from `newFiles` made every binary
      * creation invisible to the staged-registration rules.
      */
     createdFiles: Set<string>;
@@ -51,7 +51,7 @@ export interface PatchQueueEntry {
      * patch *modifies* (i.e. paths that show up in the diff without a
      * `new file mode` marker). The forward-import rule and `patch delete`
      * dependency scan use this to detect imports added into pre-existing
-     * files — a failure mode the newFiles map cannot represent because it
+     * files, a failure mode the newFiles map cannot represent because it
      * only tracks creations.
      */
     modifiedFileAdditions: Map<string, string>;
@@ -60,7 +60,7 @@ export interface PatchQueueEntry {
  * Queue-wide context passed to cross-patch lint rules.
  *
  * "Projected" means rules receive a potentially hypothetical view of the
- * queue — the caller may have already applied a planned delete, reorder, or
+ * queue: the caller may have already applied a planned delete, reorder, or
  * re-export to the entries before calling the rule. This lets
  * `patch reorder`, `patch delete`, `export --order`, and `re-export --files`
  * run the same cross-patch checks they would hit on a real run, without
@@ -84,7 +84,7 @@ export interface PatchQueueContext {
  * Reads manifest metadata best-effort: if the manifest is missing or a patch
  * file has no metadata entry, the context still populates the entry from the
  * filename prefix so cross-patch rules can operate on a drift state. (A
- * separate consistency check — see `patches verify` — is responsible for
+ * separate consistency check, see `patches verify`, is responsible for
  * reporting the drift as its own error.)
  *
  * @param patchesDir - Path to the patches directory
@@ -111,13 +111,13 @@ export declare function isForwardImportableFile(path: string): boolean;
  *
  * Intentionally conservative. Catches:
  * - `import ... from "specifier"`   (ES module static imports)
- * - `import "specifier"`            (side-effect imports — the `from`
+ * - `import "specifier"`            (side-effect imports, where the `from`
  *                                   clause is optional in the regex)
  * - `import("specifier")`           (dynamic imports)
  * - ChromeUtils.importESModule("specifier")
  * - ChromeUtils.defineESModuleGetters(obj, { Name: "specifier", ... })
  *
- * Returns the raw specifier strings — callers should take the leaf basename
+ * Returns the raw specifier strings. Callers should take the leaf basename
  * to match against the newFileIndex, because we do not resolve `resource://`
  * URLs to engine file paths.
  *
@@ -162,19 +162,19 @@ export declare function findForwardImportIgnoreLines(source: string): Set<number
  * Cross-patch lint rule: a patch imports a module that a later patch is
  * responsible for creating.
  *
- * Deliberately conservative — `resource://` URLs are not resolved to engine
+ * Conservative by design: `resource://` URLs are not resolved to engine
  * file paths. Instead a cross-queue index of newly-created files is built,
  * keyed by basename, and imports whose leaf matches an entry owned by a
  * later-ordered patch are flagged. False positives from unrelated basename
- * collisions (two directories both creating `Helper.sys.mjs`) are possible;
- * the README documents the limitation and the inline ignore marker above is
+ * collisions (two directories both creating `Helper.sys.mjs`) are possible.
+ * The README documents the limitation and the inline ignore marker above is
  * the escape hatch.
  *
  * Rules out:
  * - Imports whose leaf matches a newly-created file in the *same* or an
  *   *earlier* patch (legitimate use).
  * - Imports whose leaf is not in the new-file index at all (pre-existing
- *   engine file — not our concern).
+ *   engine file, not our concern).
  * - Imports on a line suppressed by the ignore marker.
  */
 /** One discovered forward-import edge: a site importing a later-created file. */
@@ -204,8 +204,8 @@ export declare function collectForwardImportEdges(ctx: PatchQueueContext): Forwa
  * Cross-patch lint rule: flag imports of a module a later-ordered patch is
  * responsible for creating, unless the patch declares an exact staged
  * forward-import for it. Also warns on staged-dependency declarations that
- * never matched (stale). Matching is conservative — by basename, not by
- * resolving `resource://`/`chrome://` URLs — with an inline ignore marker as
+ * never matched (stale). Matching is conservative: by basename, not by
+ * resolving `resource://`/`chrome://` URLs, with an inline ignore marker as
  * an escape hatch for unrelated basename collisions.
  */
 export declare function lintPatchQueueForwardImports(ctx: PatchQueueContext): PatchLintIssue[];

package/dist/src/core/patch-lint-cross.js

@@ -32,7 +32,7 @@ import { extractNewFileContent } from './patch-transform.js';
  * Reads manifest metadata best-effort: if the manifest is missing or a patch
  * file has no metadata entry, the context still populates the entry from the
  * filename prefix so cross-patch rules can operate on a drift state. (A
- * separate consistency check — see `patches verify` — is responsible for
+ * separate consistency check, see `patches verify`, is responsible for
  * reporting the drift as its own error.)
  *
  * @param patchesDir - Path to the patches directory
@@ -63,7 +63,7 @@ export async function buildPatchQueueContext(patchesDir, config) {
         // Added-line content for every file the patch modifies but does not
         // create. Fed to the forward-import rule so imports introduced into
         // pre-existing files are checked too, not only imports in brand-new
-        // files. We deliberately skip paths in newFilePaths — those are
+        // files. Paths in newFilePaths are skipped on purpose: they are
         // already covered by the newFiles map, which carries full content
         // rather than only the added lines.
         const addedLinesByFile = extractAddedLinesPerFile(diff);
@@ -91,7 +91,7 @@ export async function buildPatchQueueContext(patchesDir, config) {
 }
 // The creators map (split out of `lintPatchQueueDuplicateCreations` so
 // `status --ownership` can consume the structured data) lives in
-// `patch-lint-creators.ts` with its per-context memoisation;
+// `patch-lint-creators.ts` with its per-context memoisation. It is
 // re-exported here so callers keep importing from `patch-lint.ts`.
 export { collectNewFileCreatorsByPath, invalidateNewFileCreatorsCache, } from './patch-lint-creators.js';
 /**
@@ -168,7 +168,7 @@ function collectGetterSpecifiers(stripped, results, offsetToLine) {
         const openParen = stripped.indexOf('(', match.index);
         if (openParen === -1)
             continue;
-        // Walk to the first top-level `{` inside the call — the start of
+        // Walk to the first top-level `{` inside the call, the start of
         // the getter-map object literal. Bail if we reach the closing `)`
         // first (no object literal argument given).
         let depthParen = 1;
@@ -230,7 +230,7 @@ export function extractImportSpecifiersWithLines(source) {
     // length, preserving character offsets. That lets us match against
     // the stripped source (so we do not match `import` tokens inside
     // block comments or string literals) while still reporting line
-    // numbers based on the ORIGINAL source, which is what the
+    // numbers based on the original source, which is what the
     // ignore-marker scan walks.
     const stripped = stripJsComments(source);
     const results = [];
@@ -247,7 +247,7 @@ export function extractImportSpecifiersWithLines(source) {
         if (match[1])
             results.push({ specifier: match[1], line: offsetToLine(match.index) });
     }
-    // ChromeUtils.importESModule("resource://...") — Firefox single-module import
+    // ChromeUtils.importESModule("resource://...") is a Firefox single-module import
     const chromeUtilsPattern = /ChromeUtils\.importESModule\s*\(\s*["']([^"']+)["']/g;
     while ((match = chromeUtilsPattern.exec(stripped)) !== null) {
         if (match[1])
@@ -257,14 +257,14 @@ export function extractImportSpecifiersWithLines(source) {
     return results;
 }
 /**
- * Bare `Name: "url"` property lines added inside a PRE-EXISTING
- * `defineESModuleGetters` (or `XPCOMUtils` lazy-getter) map. Applied ONLY to
+ * Bare `Name: "url"` property lines added inside a pre-existing
+ * `defineESModuleGetters` (or `XPCOMUtils` lazy-getter) map. Applied only to
  * `modifiedFileAdditions`: a patch that inserts one property into an
  * existing getter object never carries the `defineESModuleGetters(` opener
  * in its added lines, so the balanced-brace walk in
  * {@link extractImportSpecifiersWithLines} cannot see it. The
  * URL-scheme restriction keeps ordinary object literals
- * (`label: "Foo.sys.mjs"`) out; the leaf-extension filter downstream does
+ * (`label: "Foo.sys.mjs"`) out. The leaf-extension filter downstream does
  * the rest.
  */
 const BARE_GETTER_PROPERTY_LINE = /^\s*(?:["'])?[A-Za-z_$][\w$]*(?:["'])?\s*:\s*["']((?:resource|chrome|moz-src):\/\/[^"']+)["']\s*,?\s*$/;
@@ -353,7 +353,7 @@ function buildCreatorIndex(ctx, pathsOf) {
 /**
  * Basename → later-creators index for the forward-IMPORT scan.
  *
- * Keyed on `newFiles` deliberately: this index answers "which patch creates
+ * Keyed on `newFiles`: this index answers "which patch creates
  * the module this specifier resolves to", and a binary is not a module.
  */
 function buildNewFileIndex(ctx) {
@@ -364,11 +364,11 @@ function buildNewFileIndex(ctx) {
  *
  * Keyed on `createdFiles`, which includes binary creations. A registration
  * (`support-files`, a jar.mn line, an actor entry) points at a file that
- * must EXIST after apply; whether its body was text or a `GIT binary patch`
+ * must exist after apply. Whether its body was text or a `GIT binary patch`
  * has nothing to do with it. Resolving this from `newFiles` made a declared
  * dependency on a binary fixture report `creates-unresolved`, so the
  * declaration read as stale on every lint run and removing it changed
- * nothing either — the failure was symmetric and therefore invisible.
+ * nothing either. The failure was symmetric and therefore invisible.
  */
 function buildCreatedFileIndex(ctx) {
     return buildCreatorIndex(ctx, (entry) => entry.createdFiles);
@@ -378,7 +378,7 @@ function buildCreatedFileIndex(ctx) {
  * later-ordered patch). Shared by {@link lintPatchQueueForwardImports} (which
  * resolves/reports each) and {@link collectForwardImportEdges} (which returns
  * them structurally). We scan a created file's full body and a modified
- * file's added lines only — flagging imports *this patch introduces*, not
+ * file's added lines only, so it flags imports *this patch introduces*, not
  * pre-existing HEAD imports that happen to collide with a later-created file.
  */
 function eachForwardImportSite(ctx, newFileIndex, visit) {
@@ -389,7 +389,7 @@ function eachForwardImportSite(ctx, newFileIndex, visit) {
         if (includeBareGetterLines) {
             // Dedupe by (specifier, line): a patch that adds the whole getter
             // call carries both the opener (found by the balanced walk) and the
-            // property line (found here) — report each site once.
+            // property line (found here), so report each site once.
             const seen = new Set(sites.map((site) => `${site.specifier}|${site.line}`));
             for (const extra of extractBareGetterSpecifiers(content)) {
                 if (!seen.has(`${extra.specifier}|${extra.line}`))
@@ -448,8 +448,8 @@ export function collectForwardImportEdges(ctx) {
  * Cross-patch lint rule: flag imports of a module a later-ordered patch is
  * responsible for creating, unless the patch declares an exact staged
  * forward-import for it. Also warns on staged-dependency declarations that
- * never matched (stale). Matching is conservative — by basename, not by
- * resolving `resource://`/`chrome://` URLs — with an inline ignore marker as
+ * never matched (stale). Matching is conservative: by basename, not by
+ * resolving `resource://`/`chrome://` URLs, with an inline ignore marker as
  * an escape hatch for unrelated basename collisions.
  */
 export function lintPatchQueueForwardImports(ctx) {
@@ -470,11 +470,11 @@ export function lintPatchQueueForwardImports(ctx) {
             .map((o) => `${o.filename}:${o.fullPath}`)
             .sort((a, b) => a.localeCompare(b))
             .join(',');
-        // Lowest ordinal that lands AFTER every later-ordered creator —
+        // Lowest ordinal that lands after every later-ordered creator. It
         // turns the operator's "guess and re-run" loop into a single shot
         // when the only fix is reordering. When patchPolicy is available and
         // that ordinal falls outside the importing patch's category range,
-        // `patch reorder` would refuse it — suppress the hint and point at
+        // `patch reorder` would refuse it, so suppress the hint and point at
         // the staged-dependency remedy instead.
         const suggestedOrder = Math.max(...laterOwners.map((o) => o.order)) + 1;
         const category = entry.metadata?.category ?? /^\d+-([a-z]+)-/.exec(entry.filename)?.[1];
@@ -526,11 +526,11 @@ export function lintPatchQueueForwardImports(ctx) {
         }
         // Registration-kind declarations: a jar.mn packaging line,
         // customElements registration, or actor registration referencing a
-        // later-created file. There is no import specifier to match — the
+        // later-created file. There is no import specifier to match. The
         // declaration is "used" when the declared line (whitespace-trimmed)
-        // appears among the lines this patch adds to the declaring file AND its
+        // appears among the lines this patch adds to the declaring file and its
         // `creates` resolves to a file a later-ordered patch actually creates
-        // (with `owner`, when set, naming that patch) — mirroring
+        // (with `owner`, when set, naming that patch), mirroring
         // findMatchingStagedDependency for the import kind.
         for (const registration of entry.metadata?.stagedDependencies?.registrations ?? []) {
             const failure = findStagedRegistrationFailure(entry, registration, createdFileIndex);

package/dist/src/core/patch-lint-css.d.ts

@@ -3,7 +3,7 @@
  * custom-property references.
  *
  * Split out of `patch-lint.ts` so each rule family stays within the
- * per-file line budget; `patch-lint.ts` re-exports `lintPatchedCss` so
+ * per-file line budget. `patch-lint.ts` re-exports `lintPatchedCss` so
  * existing callers keep importing from the single module.
  */
 import type { PatchLintIssue } from '../types/commands/index.js';

package/dist/src/core/patch-lint-css.js

@@ -4,7 +4,7 @@
  * custom-property references.
  *
  * Split out of `patch-lint.ts` so each rule family stays within the
- * per-file line budget; `patch-lint.ts` re-exports `lintPatchedCss` so
+ * per-file line budget. `patch-lint.ts` re-exports `lintPatchedCss` so
  * existing callers keep importing from the single module.
  */
 import { join } from 'node:path';
@@ -15,7 +15,7 @@ import { hasRawCssColors } from '../utils/regex.js';
 import { loadFurnaceConfig } from './furnace-config.js';
 import { extractAddedLineNumbersPerFile, extractAddedLinesPerFile } from './patch-lint-diff.js';
 /**
- * Loads the furnace token-prefix lint inputs gracefully — returns
+ * Loads the furnace token-prefix lint inputs gracefully. Returns
  * undefined (skipping the token-prefix check) when furnace.json cannot
  * be loaded or no tokenPrefix is configured.
  */
@@ -38,7 +38,7 @@ async function loadCssTokenContext(repoDir) {
 }
 /**
  * Masks CSS block comments with spaces, preserving newlines so line
- * numbers stay stable. An unclosed trailing `/*` is masked to EOF —
+ * numbers stay stable. An unclosed trailing `/*` is masked to EOF,
  * matching how a CSS parser treats it.
  */
 function maskCssComments(source) {
@@ -60,7 +60,7 @@ const RAW_COLOR_IGNORE_MARKER = 'fireforge-ignore: raw-color-value';
  * comment spanning the context/added boundary suppresses its hex, then
  * only the patch's added line numbers are scanned. Returns undefined
  * when any added line number falls outside the on-disk file (patch not
- * applied / drifted) — the caller then falls back to the legacy
+ * applied / drifted). The caller then falls back to the legacy
  * joined-added-lines scan rather than misattributing lines.
  */
 function buildAddedLinesScanSource(rawCss, addedNumbers) {
@@ -77,7 +77,7 @@ function checkRawColorValues(input) {
     const { file, rawCss, addedLinesByFile, addedLineNumbersByFile, config, issues } = input;
     // Check only introduced raw color values when diff context is available.
     // Skip files on the raw-color allowlist (exact path or basename match) and
-    // auto-exempt files under `browser/branding/` — those are the fork's
+    // auto-exempt files under `browser/branding/`: those are the fork's
     // visual identity assets (app-about dialogs, installer pages, branded CSS
     // copied from Firefox's `unofficial` template) and belong to the
     // design-decision layer the design-token system does not govern. Without

package/dist/src/core/patch-lint-diff-tag.d.ts

@@ -12,7 +12,7 @@ import type { PatchLintIssue } from '../types/commands/index.js';
 /**
  * Collects engine-relative paths that changed between `rev` and `HEAD`,
  * plus any workdir modifications and untracked files. An empty set means
- * "no diff we can prove" — downstream treats every issue as `cumulative`
+ * "no diff we can prove". Downstream treats every issue as `cumulative`
  * in that case (operator ran `lint --since HEAD` with no pending work).
  * @param engineDir Path to the engine git repository.
  * @param rev Git revision to diff against (e.g. `HEAD`, a branch, a SHA).
@@ -28,10 +28,10 @@ export declare const AGGREGATE_PATCH_FILE = "(patch)";
 /**
  * Annotates a list of lint issues with `introduced` / `cumulative` tags
  * based on whether the issue's file is part of the supplied diff set.
- * Mutates each issue in place AND returns the list for chaining.
+ * Mutates each issue in place and returns the list for chaining.
  *
- * Issues with no file (`issue.file === ''`) — e.g. cross-patch rules that
- * describe queue-wide state — are always `cumulative` under `--since`
+ * Issues with no file (`issue.file === ''`), for example cross-patch rules
+ * that describe queue-wide state, are always `cumulative` under `--since`
  * because they describe drift accumulated across many commits, not a single
  * current-task edit.
  *
@@ -39,7 +39,7 @@ export declare const AGGREGATE_PATCH_FILE = "(patch)";
  * synthetic placeholder that can never appear in a real `diffFiles` set.
  * Without special-casing, `large-patch-files` / `large-patch-lines` are
  * always tagged `[cumulative]` under `--only-introduced` even when the diff
- * IS the aggregate the rules measured, which reads as "this pre-existed" to
+ * is the aggregate the rules measured, which reads as "this pre-existed" to
  * an operator asking "what did this diff introduce?". The aggregate tag is
  * therefore promoted to `introduced` whenever the diff set has any content:
  * a non-empty `diffFiles` means the operator asked about a specific diff

package/dist/src/core/patch-lint-diff-tag.js

@@ -17,7 +17,7 @@ import { getUntrackedFiles } from './git-status.js';
 /**
  * Collects engine-relative paths that changed between `rev` and `HEAD`,
  * plus any workdir modifications and untracked files. An empty set means
- * "no diff we can prove" — downstream treats every issue as `cumulative`
+ * "no diff we can prove". Downstream treats every issue as `cumulative`
  * in that case (operator ran `lint --since HEAD` with no pending work).
  * @param engineDir Path to the engine git repository.
  * @param rev Git revision to diff against (e.g. `HEAD`, a branch, a SHA).
@@ -68,10 +68,10 @@ export const AGGREGATE_PATCH_FILE = '(patch)';
 /**
  * Annotates a list of lint issues with `introduced` / `cumulative` tags
  * based on whether the issue's file is part of the supplied diff set.
- * Mutates each issue in place AND returns the list for chaining.
+ * Mutates each issue in place and returns the list for chaining.
  *
- * Issues with no file (`issue.file === ''`) — e.g. cross-patch rules that
- * describe queue-wide state — are always `cumulative` under `--since`
+ * Issues with no file (`issue.file === ''`), for example cross-patch rules
+ * that describe queue-wide state, are always `cumulative` under `--since`
  * because they describe drift accumulated across many commits, not a single
  * current-task edit.
  *
@@ -79,7 +79,7 @@ export const AGGREGATE_PATCH_FILE = '(patch)';
  * synthetic placeholder that can never appear in a real `diffFiles` set.
  * Without special-casing, `large-patch-files` / `large-patch-lines` are
  * always tagged `[cumulative]` under `--only-introduced` even when the diff
- * IS the aggregate the rules measured, which reads as "this pre-existed" to
+ * is the aggregate the rules measured, which reads as "this pre-existed" to
  * an operator asking "what did this diff introduce?". The aggregate tag is
  * therefore promoted to `introduced` whenever the diff set has any content:
  * a non-empty `diffFiles` means the operator asked about a specific diff

package/dist/src/core/patch-lint-diff.d.ts

@@ -5,7 +5,7 @@
  * Factored out of `patch-lint.ts` so the per-patch lint body and
  * cross-patch lint body (in `patch-lint-cross.ts`) can both depend on
  * the same diff walkers without inducing a circular import. Callers
- * should keep importing these through `patch-lint.ts` — this file is
+ * should keep importing these through `patch-lint.ts`. This file is
  * an implementation detail. The actual line-walking lives in
  * `parseDiffSections` (patch-parse.ts), the codebase's single diff walker.
  */
@@ -22,8 +22,8 @@ export declare function extractAddedLinesPerFile(diffContent: string): Map<strin
  * Extracts 1-based post-patch line numbers of added lines per file from a
  * unified diff. Walking each hunk with a new-file line counter (`+` and
  * context lines advance it, `-` lines do not) lets rules that need
- * full-file context — e.g. comment masking across the context/added
- * boundary — map the patch's additions onto the applied file.
+ * full-file context (e.g. comment masking across the context/added
+ * boundary) map the patch's additions onto the applied file.
  */
 export declare function extractAddedLineNumbersPerFile(diffContent: string): Map<string, number[]>;
 /**
@@ -34,7 +34,7 @@ export declare function extractAddedLineNumbersPerFile(diffContent: string): Map
  * `buildPatchQueueContext`.
  *
  * Matches buildPatchQueueContext's algorithm exactly: skip paths that are
- * created by the diff — those are already covered by the `newFiles` map,
+ * created by the diff, since those are already covered by the `newFiles` map,
  * which carries full content rather than only the added lines.
  *
  * @param diff - Unified diff content

package/dist/src/core/patch-lint-diff.js

@@ -6,7 +6,7 @@
  * Factored out of `patch-lint.ts` so the per-patch lint body and
  * cross-patch lint body (in `patch-lint-cross.ts`) can both depend on
  * the same diff walkers without inducing a circular import. Callers
- * should keep importing these through `patch-lint.ts` — this file is
+ * should keep importing these through `patch-lint.ts`. This file is
  * an implementation detail. The actual line-walking lives in
  * `parseDiffSections` (patch-parse.ts), the codebase's single diff walker.
  */
@@ -49,8 +49,8 @@ export function extractAddedLinesPerFile(diffContent) {
  * Extracts 1-based post-patch line numbers of added lines per file from a
  * unified diff. Walking each hunk with a new-file line counter (`+` and
  * context lines advance it, `-` lines do not) lets rules that need
- * full-file context — e.g. comment masking across the context/added
- * boundary — map the patch's additions onto the applied file.
+ * full-file context (e.g. comment masking across the context/added
+ * boundary) map the patch's additions onto the applied file.
  */
 export function extractAddedLineNumbersPerFile(diffContent) {
     const result = new Map();
@@ -84,7 +84,7 @@ export function extractAddedLineNumbersPerFile(diffContent) {
  * `buildPatchQueueContext`.
  *
  * Matches buildPatchQueueContext's algorithm exactly: skip paths that are
- * created by the diff — those are already covered by the `newFiles` map,
+ * created by the diff, since those are already covered by the `newFiles` map,
  * which carries full content rather than only the added lines.
  *
  * @param diff - Unified diff content

package/dist/src/core/patch-lint-file-size.d.ts

@@ -1,7 +1,7 @@
 /**
  * The `file-too-large` thresholds and their rendered message.
  *
- * Its own module for two reasons: the config validator needs the DEFAULTS
+ * Its own module for two reasons: the config validator needs the defaults
  * to validate an override triple against the merged result, and importing
  * `patch-lint.ts` from `config-validate.ts` for a constant would draw an
  * import edge (and a cycle) between the rule bodies and config parsing.
@@ -9,9 +9,9 @@
  * On the vocabulary: the bands were `notice` / `warning` / `error` with the
  * middle one described as a "soft limit". That description is false under
  * the posture FireForge itself recommends for a release gate,
- * `--max-warnings 0`, where a warning is a hard failure — so a file at 751
+ * `--max-warnings 0`, where a warning is a hard failure, so a file at 751
  * lines failed a gate with a message calling 750 soft. The message below
- * says what the band IS (a warning) and what a zero-warning gate does with
+ * says what the band is (a warning) and what a zero-warning gate does with
  * it, and the thresholds are now tunable, so a project whose file-size
  * policy differs has a dial instead of an argument.
  */

package/dist/src/core/patch-lint-file-size.js

@@ -2,7 +2,7 @@
 /**
  * The `file-too-large` thresholds and their rendered message.
  *
- * Its own module for two reasons: the config validator needs the DEFAULTS
+ * Its own module for two reasons: the config validator needs the defaults
  * to validate an override triple against the merged result, and importing
  * `patch-lint.ts` from `config-validate.ts` for a constant would draw an
  * import edge (and a cycle) between the rule bodies and config parsing.
@@ -10,9 +10,9 @@
  * On the vocabulary: the bands were `notice` / `warning` / `error` with the
  * middle one described as a "soft limit". That description is false under
  * the posture FireForge itself recommends for a release gate,
- * `--max-warnings 0`, where a warning is a hard failure — so a file at 751
+ * `--max-warnings 0`, where a warning is a hard failure, so a file at 751
  * lines failed a gate with a message calling 750 soft. The message below
- * says what the band IS (a warning) and what a zero-warning gate does with
+ * says what the band is (a warning) and what a zero-warning gate does with
  * it, and the thresholds are now tunable, so a project whose file-size
  * policy differs has a dial instead of an argument.
  */

package/dist/src/core/patch-lint-forward-registration.d.ts

@@ -5,7 +5,7 @@ import type { PatchQueueForwardRegistrationEntry, PatchQueueView } from './patch
  *
  * The entry alone is not enough for the discharge command the rule prints:
  * `--line` is compared, whitespace-trimmed, against the lines the patch
- * ADDS, and a synthesised `support-files = ["<entry>"]` only ever matches a
+ * adds, and a synthesised `support-files = ["<entry>"]` only ever matches a
  * manifest whose array is single-line and single-entry. Carrying the source
  * line keeps the remedy and the validation talking about the same text.
  */
@@ -26,8 +26,8 @@ export interface SupportFileEntry {
  * with the manifest line it is written on.
  *
  * Handles the TOML array on one line and spread over several, and the
- * whitespace-separated `.ini` spelling. Anything else — a computed value, a
- * shape this does not recognise — yields nothing, because a rule that
+ * whitespace-separated `.ini` spelling. Anything else (a computed value, a
+ * shape this does not recognise) yields nothing, because a rule that
  * guesses at a manifest it cannot parse refuses correct queues.
  *
  * Quoted tokens are matched per physical line rather than over the whole
@@ -40,7 +40,7 @@ export declare function extractSupportFileEntries(content: string): SupportFileE
  * Resolves one `support-files` entry, relative to its manifest's directory,
  * into a matcher over engine-relative paths.
  *
- * Only a `*` inside a single path segment is expanded — the shape the
+ * Only a `*` inside a single path segment is expanded, the shape the
  * downstream report uses (`fixtures/*.sqlite`). `**`, `!` exclusions and
  * absolute `/`-rooted entries return undefined: they either cross directory
  * boundaries or subtract, and a matcher that guessed at them would attribute

package/dist/src/core/patch-lint-forward-registration.js

@@ -1,17 +1,17 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
  * Cross-patch lint rule: a test manifest that registers a file a
- * LATER-ordered patch creates, without declaring the staged dependency.
+ * later-ordered patch creates, without declaring the staged dependency.
  *
- * The import kind has had this arm since forward-import shipped; the
+ * The import kind has had this arm since forward-import shipped. The
  * registration kind never did. `--kind registration` metadata was only ever
- * checked for STALENESS once declared, so a patch whose `xpcshell.toml`
+ * checked for staleness once declared, so a patch whose `xpcshell.toml`
  * carried `support-files = ["fixtures/*.sqlite"]` for a fixture the next
- * patch creates passed lint in both arms — declaring the dependency and
- * removing the declaration produced identical silence, which is what made
- * the gap invisible rather than merely absent.
+ * patch creates passed lint in both arms. Declaring the dependency and
+ * removing the declaration produced identical silence, so the gap was
+ * invisible rather than merely absent.
  *
- * Scope is deliberately narrow: test-manifest `support-files` only. A
+ * Scope is narrow on purpose: test-manifest `support-files` only. A
  * jar.mn packaging line or an actor/customElements registration names its
  * target through indirection the linter cannot resolve without the build
  * system, and a rule that guesses there would refuse correct queues on a
@@ -24,7 +24,7 @@ import { escapeRegex } from '../utils/regex.js';
 import { isLaterOwner, quoteRegistrationLine } from './patch-lint-staged-registration.js';
 /**
  * Manifest basenames whose `support-files` key registers auxiliary files
- * for a test suite. Closed and documented on purpose — a pattern like
+ * for a test suite. Closed and documented on purpose: a pattern like
  * "anything .toml" would sweep in Cargo and taskcluster manifests, whose
  * `support-files`-shaped keys mean something else entirely.
  */
@@ -51,8 +51,8 @@ const SUPPORT_FILES_PATTERN = /^\s*support-files\s*=\s*(.*)$/;
  * with the manifest line it is written on.
  *
  * Handles the TOML array on one line and spread over several, and the
- * whitespace-separated `.ini` spelling. Anything else — a computed value, a
- * shape this does not recognise — yields nothing, because a rule that
+ * whitespace-separated `.ini` spelling. Anything else (a computed value, a
+ * shape this does not recognise) yields nothing, because a rule that
  * guesses at a manifest it cannot parse refuses correct queues.
  *
  * Quoted tokens are matched per physical line rather than over the whole
@@ -115,7 +115,7 @@ export function extractSupportFileEntries(content) {
  * Resolves one `support-files` entry, relative to its manifest's directory,
  * into a matcher over engine-relative paths.
  *
- * Only a `*` inside a single path segment is expanded — the shape the
+ * Only a `*` inside a single path segment is expanded, the shape the
  * downstream report uses (`fixtures/*.sqlite`). `**`, `!` exclusions and
  * absolute `/`-rooted entries return undefined: they either cross directory
  * boundaries or subtract, and a matcher that guessed at them would attribute
@@ -152,7 +152,7 @@ function isDeclared(entry, manifestPath, createdPath) {
 export function lintPatchQueueForwardRegistrations(ctx) {
     const issues = [];
     for (const entry of ctx.entries) {
-        // Both arms: a manifest this patch CREATES and one it MODIFIES can each
+        // Both arms: a manifest this patch creates and one it modifies can each
         // introduce a registration line.
         const manifests = [
             ...entry.newFiles,

package/dist/src/core/patch-lint-jsdoc.d.ts

@@ -28,7 +28,7 @@ export interface ValidateExportJsDocOptions {
  * Validates a top-level function declaration: requires an attached JSDoc
  * comment, then checks @param name matching and @returns presence. Exported
  * so the chrome-subscript validator (`patch-lint-chrome-jsdoc.ts`) can reuse
- * it on `parseScript`-produced declarations — the rule shape is identical
+ * it on `parseScript`-produced declarations. The rule shape is identical
  * between ES-module exports and chrome-subscript top-level declarations.
  *
  * @param fn - FunctionDeclaration AST node
@@ -54,7 +54,7 @@ export declare function validateClassDecl(cls: AcornESTreeNode<ClassDeclaration>
  *   3. methods whose JSDoc carries `@private` or `@internal`
  *
  * A pure-override skip (`super.method(...args)`-only bodies bypassing the
- * return-tag check) is deliberately not implemented; the rule stays simple.
+ * return-tag check) is deliberately not implemented. The rule stays simple.
  */
 export declare function validateClassMethods(cls: AcornESTreeNode<ClassDeclaration>, comments: acorn.Comment[], source: string, severity: 'warning' | 'error'): JsDocIssue[];
 /**