@hominis/fireforge 0.46.0 → 0.46.1

package/dist/src/core/patch-parse.d.ts

@@ -7,7 +7,7 @@
  * `String(order).padStart(3, '0')`, so the padding width lived in eleven
  * places while the filenames it has to agree with are produced in one.
  * @param order - Numeric patch order.
- * @param width - Prefix width; defaults to the on-disk convention.
+ * @param width - Prefix width. Defaults to the on-disk convention.
  * @returns The zero-padded order, e.g. `007`.
  */
 export declare function formatPatchOrder(order: number, width?: number): string;
@@ -35,7 +35,7 @@ export declare function extractOrder(filename: string): number;
  * `Infinity` for a prefix-less filename, which sorts such a patch last and
  * is the right answer for a read: an unparseable name should not crash a
  * status listing. Persisting `Infinity` (or the `0` some call sites used to
- * fall back to) is a different matter — it puts an order in the manifest
+ * fall back to) is a different matter: it puts an order in the manifest
  * that no filename on disk agrees with, and the queue then applies in an
  * order the operator cannot see. Callers here have always just built or
  * looked up a real prefixed filename, so absence is a bug, not input.
@@ -52,7 +52,7 @@ export declare function requirePatchOrder(filename: string): number;
 export interface DiffGitHeader {
     /** Old-side (`a/`) path. */
     sourcePath: string;
-    /** New-side (`b/`) path — the file the patch produces. */
+    /** New-side (`b/`) path: the file the patch produces. */
     targetPath: string;
 }
 /**
@@ -62,8 +62,8 @@ export interface DiffGitHeader {
  * (`diff --git "a/x y" "b/x y"`), and disambiguates the unquoted form for
  * paths that themselves contain ` b/`: for the overwhelmingly common
  * non-rename case the two paths are identical, so a symmetric split
- * (`a/<p> b/<p>`) is tried first — a greedy `a\/.+ b\/(.+)$` splits such
- * lines at the LAST ` b/` and returns a truncated path. Falls back to a
+ * (`a/<p> b/<p>`) is tried first: a greedy `a\/.+ b\/(.+)$` splits such
+ * lines at the last ` b/` and returns a truncated path. Falls back to a
  * non-greedy split for renames.
  *
  * @returns null when the line is not a diff --git header.
@@ -73,7 +73,7 @@ export declare function parseDiffGitHeader(line: string): DiffGitHeader | null;
  * One `diff --git` section of a unified diff, fully structured.
  */
 export interface DiffSection {
-    /** New-side (`b/`) path — the file this section produces. */
+    /** New-side (`b/`) path: the file this section produces. */
     targetPath: string;
     /** Old-side (`a/`) path. */
     sourcePath: string;
@@ -83,21 +83,21 @@ export interface DiffSection {
     isDeletedFile: boolean;
     /**
      * True for binary sections (`GIT binary patch` or `Binary files … differ`).
-     * Binary sections have no parseable hunks; text-oriented consumers must
+     * Binary sections have no parseable hunks. Text-oriented consumers must
      * refuse them rather than treat base85 lines starting with `+` as content.
      */
     isBinary: boolean;
     /**
-     * True ONLY for `GIT binary patch` sections — the body carries a
+     * True only for `GIT binary patch` sections, whose body carries a
      * reconstructable literal/delta payload. False for `Binary files … differ`,
-     * which records THAT the bytes changed but carries none of them and cannot
+     * which records that the bytes changed but carries none of them and cannot
      * be replayed by `git apply`.
      *
      * The distinction is not cosmetic: the stub form still carries a correct
      * `index <old>..<new>` line, so identity checks keyed on {@link indexNewHash}
      * alone happily conclude "the recorded bytes match the live file" for a body
      * that can no longer produce those bytes. Consumers deciding whether a patch
-     * can RECREATE a file must read this flag, never `isBinary` plus a hash.
+     * can recreate a file must read this flag, never `isBinary` plus a hash.
      */
     hasBinaryDelta: boolean;
     /**
@@ -106,14 +106,14 @@ export interface DiffSection {
      * parseable index line (hand-written diffs, `Binary files … differ`).
      */
     indexOldHash?: string;
-    /** New-side blob hash from the `index` line; see {@link indexOldHash}. */
+    /** New-side blob hash from the `index` line. See {@link indexOldHash}. */
     indexNewHash?: string;
     /** Parsed hunks, in file order. Empty for binary or metadata-only sections. */
     hunks: ParsedHunk[];
 }
 /**
- * Parses a unified diff into structured per-file sections — the single
- * shared walker every diff consumer builds on.
+ * Parses a unified diff into structured per-file sections. This is the
+ * single shared walker every diff consumer builds on.
  */
 export declare function parseDiffSections(diffContent: string): DiffSection[];
 /**
@@ -132,7 +132,7 @@ export declare function isNewFileInPatch(patchContent: string, targetFile: strin
 export declare function extractAffectedFiles(diffContent: string): string[];
 /**
  * A single parsed hunk. `noNewlineAtEndOld` / `noNewlineAtEndNew` track the
- * `` marker per side — the marker is a trailing
+ * `` marker per side. The marker is a trailing
  * annotation on the immediately preceding body line, and a `-` precedent
  * sets only the old-side flag, a `+` sets only the new-side flag, and a
  * context ` ` line sets both. Collapsing the two into one boolean makes the

package/dist/src/core/patch-parse.js

@@ -4,7 +4,7 @@ import { assert } from '../utils/assert.js';
  * Pure parsing functions for extracting information from patch files. All
  * functions are synchronous and operate on string content.
  *
- * This module is the ONE unified-diff walker in the codebase. Hand-rolled
+ * This module is the one unified-diff walker in the codebase. Hand-rolled
  * `diff --git` walkers diverge in ways that matter: CRLF handling (a
  * CRLF-saved patch file silently fails target-file matching and
  * `\ No newline` detection on Windows), quoted-path support, and greedy path
@@ -22,7 +22,7 @@ const PATCH_ORDER_WIDTH = 3;
  * `String(order).padStart(3, '0')`, so the padding width lived in eleven
  * places while the filenames it has to agree with are produced in one.
  * @param order - Numeric patch order.
- * @param width - Prefix width; defaults to the on-disk convention.
+ * @param width - Prefix width. Defaults to the on-disk convention.
  * @returns The zero-padded order, e.g. `007`.
  */
 export function formatPatchOrder(order, width = PATCH_ORDER_WIDTH) {
@@ -57,7 +57,7 @@ export function extractOrder(filename) {
  * `Infinity` for a prefix-less filename, which sorts such a patch last and
  * is the right answer for a read: an unparseable name should not crash a
  * status listing. Persisting `Infinity` (or the `0` some call sites used to
- * fall back to) is a different matter — it puts an order in the manifest
+ * fall back to) is a different matter: it puts an order in the manifest
  * that no filename on disk agrees with, and the queue then applies in an
  * order the operator cannot see. Callers here have always just built or
  * looked up a real prefixed filename, so absence is a bug, not input.
@@ -83,8 +83,8 @@ function unquoteGitPath(quoted) {
     for (let i = 0; i < quoted.length; i++) {
         const ch = quoted[i];
         if (ch !== '\\') {
-            // Plain character — may itself be multi-byte when the diff already
-            // contains raw UTF-8; push its bytes.
+            // Plain character, which may itself be multi-byte when the diff already
+            // contains raw UTF-8. Push its bytes.
             const encoded = Buffer.from(quoted[i] ?? '', 'utf-8');
             for (const b of encoded)
                 bytes.push(b);
@@ -112,8 +112,8 @@ function unquoteGitPath(quoted) {
  * (`diff --git "a/x y" "b/x y"`), and disambiguates the unquoted form for
  * paths that themselves contain ` b/`: for the overwhelmingly common
  * non-rename case the two paths are identical, so a symmetric split
- * (`a/<p> b/<p>`) is tried first — a greedy `a\/.+ b\/(.+)$` splits such
- * lines at the LAST ` b/` and returns a truncated path. Falls back to a
+ * (`a/<p> b/<p>`) is tried first: a greedy `a\/.+ b\/(.+)$` splits such
+ * lines at the last ` b/` and returns a truncated path. Falls back to a
  * non-greedy split for renames.
  *
  * @returns null when the line is not a diff --git header.
@@ -153,10 +153,10 @@ export function parseDiffGitHeader(line) {
  * Splits raw diff content into lines, tolerating CRLF-saved patch files.
  *
  * The distinction matters: a patch file saved with CRLF endings (Windows
- * editor, `core.autocrlf` checkout) has `\r` on EVERY line including
- * structural ones — strip it, or headers, `@@` lines and the
+ * editor, `core.autocrlf` checkout) has `\r` on every line including
+ * structural ones. Strip it, or headers, `@@` lines and the
  * `` marker all fail to match. But an LF patch
- * of a file whose CONTENT is CRLF has `\r` only on payload lines, where it
+ * of a file whose content is CRLF has `\r` only on payload lines, where it
  * is significant and must be preserved. Detect the former by checking the
  * structural lines themselves for a trailing `\r`.
  */
@@ -170,8 +170,8 @@ function splitDiffLines(diffContent) {
     return lines.map((line) => (line.endsWith('\r') ? line.slice(0, -1) : line));
 }
 /**
- * Parses a unified diff into structured per-file sections — the single
- * shared walker every diff consumer builds on.
+ * Parses a unified diff into structured per-file sections. This is the
+ * single shared walker every diff consumer builds on.
  */
 export function parseDiffSections(diffContent) {
     const sections = [];
@@ -223,7 +223,7 @@ export function parseDiffSections(diffContent) {
                 continue;
             }
             // `git diff --binary` always records full blob hashes here (git
-            // apply requires them); text sections carry abbreviated ones. The
+            // apply requires them). Text sections carry abbreviated ones. The
             // hashes let binary sections be compared by identity when their
             // payload cannot be applied as text.
             const indexMatch = /^index ([0-9a-f]{7,64})\.\.([0-9a-f]{7,64})(?: \d{6})?$/.exec(line);
@@ -254,7 +254,7 @@ export function parseDiffSections(diffContent) {
         if (line === '\') {
             // The marker is an annotation on the immediately preceding body
             // line. Peek the last collected line to decide which side(s) the
-            // annotation applies to — a single boolean cannot represent the
+            // annotation applies to. A single boolean cannot represent the
             // asymmetric case where only one side lacks the trailing newline.
             const previous = currentHunk.lines[currentHunk.lines.length - 1] ?? '';
             if (previous.startsWith('-')) {
@@ -267,12 +267,12 @@ export function parseDiffSections(diffContent) {
                 // Context line: present in both sides, so the trailing-newline
                 // absence applies to both. This is rare (it only happens when
                 // the hunk ends on an unchanged line that itself is the last
-                // line of the file) but real — git emits it.
+                // line of the file) but real: git emits it.
                 currentHunk.noNewlineAtEndOld = true;
                 currentHunk.noNewlineAtEndNew = true;
             }
             // If the marker appears with no preceding body line (malformed
-            // diff), leave both flags false — the downstream apply logic
+            // diff), leave both flags false. The downstream apply logic
             // will still produce a defined result.
             continue;
         }

package/dist/src/core/patch-registration-refs.d.ts

@@ -8,7 +8,7 @@
  * clean" for the broken queue. This module provides a pattern-scoped scan so
  * `verify` can cross-check registrations against available file bodies.
  *
- * The scan is deliberately narrow: it only matches component-shaped
+ * The scan is narrow on purpose: it only matches component-shaped
  * references (widget tag names, locale fluent names). Unrelated jar.mn or
  * customElements.js edits pass through without spurious warnings.
  */
@@ -28,11 +28,11 @@ export interface PatchRegistrationReference {
 }
 /**
  * Walks a unified-diff patch body and returns the set of
- * component-shaped engine paths that the patch ADDS a registration for.
+ * component-shaped engine paths that the patch adds a registration for.
  *
- * Returns the empty array when no registration hunks are present OR
+ * Returns the empty array when no registration hunks are present, or
  * when the registration hunks do not mention any component-shaped
- * paths — that leaves the scan silent on the vast majority of patches
+ * paths. That leaves the scan silent on the vast majority of patches
  * (branding tweaks, behavioural fixes, module additions) so it only
  * fires when a furnace-managed component is being newly registered.
  *

package/dist/src/core/patch-registration-refs.js

@@ -9,7 +9,7 @@
  * clean" for the broken queue. This module provides a pattern-scoped scan so
  * `verify` can cross-check registrations against available file bodies.
  *
- * The scan is deliberately narrow: it only matches component-shaped
+ * The scan is narrow on purpose: it only matches component-shaped
  * references (widget tag names, locale fluent names). Unrelated jar.mn or
  * customElements.js edits pass through without spurious warnings.
  */
@@ -23,11 +23,11 @@ const REGISTRATION_FILE_PATHS = new Set([
 ]);
 /**
  * Walks a unified-diff patch body and returns the set of
- * component-shaped engine paths that the patch ADDS a registration for.
+ * component-shaped engine paths that the patch adds a registration for.
  *
- * Returns the empty array when no registration hunks are present OR
+ * Returns the empty array when no registration hunks are present, or
  * when the registration hunks do not mention any component-shaped
- * paths — that leaves the scan silent on the vast majority of patches
+ * paths. That leaves the scan silent on the vast majority of patches
  * (branding tweaks, behavioural fixes, module additions) so it only
  * fires when a furnace-managed component is being newly registered.
  *
@@ -38,7 +38,7 @@ export function collectPatchRegistrationReferences(patchBody) {
         return [];
     const refs = [];
     // Key the file state off the `b/` path because that names the target
-    // side and is stable against renames. Only real hunk adds count —
+    // side and is stable against renames. Only real hunk adds count.
     // parseDiffSections has already filtered out header/metadata lines.
     for (const section of parseDiffSections(patchBody)) {
         if (!REGISTRATION_FILE_PATHS.has(section.targetPath))
@@ -59,7 +59,7 @@ export function collectPatchRegistrationReferences(patchBody) {
 }
 /**
  * Per-source extractor. Each registration file has a distinct syntactic
- * shape; we scope the match to that file so a jar.mn regex does not
+ * shape. We scope the match to that file so a jar.mn regex does not
  * accidentally match a customElements.js line.
  */
 function extractTargetPathsFromRegistrationLine(sourceFile, added) {
@@ -68,7 +68,7 @@ function extractTargetPathsFromRegistrationLine(sourceFile, added) {
         //   `   content/global/elements/moz-qa-panel.mjs  (widgets/moz-qa-panel/moz-qa-panel.mjs)`
         // The parenthesised second half is the repo-relative path Firefox's
         // packaging system reads. Widget registrations always live under
-        // `widgets/<tag>/<file>` — the enclosing tree is
+        // `widgets/<tag>/<file>`, and the enclosing tree is
         // `toolkit/content/widgets/`. Reconstruct the engine-relative
         // target path so callers can check it against patch bodies.
         const widgetMatch = /\(\s*(widgets\/[^\s)]+)\s*\)/.exec(added);

package/dist/src/core/patch-transform.d.ts

@@ -5,29 +5,29 @@
 /**
  * Extracts the complete file content from a "new file" patch given a raw
  * diff string already in memory. Callers with a patch file path should
- * prefer {@link extractNewFileContent}; this helper exists for code paths
+ * prefer {@link extractNewFileContent}. This helper exists for code paths
  * that already hold the diff (e.g. the in-flight export planner) and do
  * not want to round-trip through the filesystem.
  *
  * @param diff - Raw unified-diff content
  * @param targetFile - Optional target file to scope extraction to
  * @returns The file content that the patch would create
- * @throws PatchError for binary sections — a `GIT binary patch` payload is
+ * @throws PatchError for binary sections. A `GIT binary patch` payload is
  *   base85 (whose alphabet includes `+`), so "extract the + lines" would
  *   silently write garbage text over a binary target. Callers must treat
  *   binary new-file conflicts as unresolvable rather than auto-resolving.
  */
 export declare function extractNewFileContentFromDiff(diff: string, targetFile?: string): string;
 /**
- * Projects every TEXT new file a diff creates into a path → content map, for
+ * Projects every text new file a diff creates into a path → content map, for
  * the cross-patch lint projections that build a synthetic patch-queue entry.
  *
- * Binary new files are SKIPPED rather than refused. The map feeds only the
- * forward-import rule, which scans content for import statements — a binary
- * blob authors none, so omitting it contributes exactly what including it
- * would. Refusing instead (which is what
+ * Binary new files are skipped rather than refused. The map feeds only the
+ * forward-import rule, which scans content for import statements, and a
+ * binary blob authors none, so omitting it contributes exactly what
+ * including it would. Refusing instead (which is what
  * {@link extractNewFileContentFromDiff} correctly does for a caller that
- * named ONE file) made vendoring a new binary impossible: every projection
+ * named one file) made vendoring a new binary impossible: every projection
  * site fed it every detected new file, so `export --order`, `re-export
  * --scan --scan-file`, `patch move-files-into` and `patch split` all died on
  * a file the export half had just written a valid `GIT binary patch` for.

package/dist/src/core/patch-transform.js

@@ -9,14 +9,14 @@ import { isNewFileInPatch, parseDiffSections, parseHunksForFile } from './patch-
 /**
  * Extracts the complete file content from a "new file" patch given a raw
  * diff string already in memory. Callers with a patch file path should
- * prefer {@link extractNewFileContent}; this helper exists for code paths
+ * prefer {@link extractNewFileContent}. This helper exists for code paths
  * that already hold the diff (e.g. the in-flight export planner) and do
  * not want to round-trip through the filesystem.
  *
  * @param diff - Raw unified-diff content
  * @param targetFile - Optional target file to scope extraction to
  * @returns The file content that the patch would create
- * @throws PatchError for binary sections — a `GIT binary patch` payload is
+ * @throws PatchError for binary sections. A `GIT binary patch` payload is
  *   base85 (whose alphabet includes `+`), so "extract the + lines" would
  *   silently write garbage text over a binary target. Callers must treat
  *   binary new-file conflicts as unresolvable rather than auto-resolving.
@@ -37,7 +37,7 @@ export function extractNewFileContentFromDiff(diff, targetFile) {
  */
 function contentFromSections(sections) {
     // An empty new file is a legitimate git diff: `new file mode` with no
-    // hunks at all. It must extract as '' — the historical line-walker
+    // hunks at all. It must extract as '': the historical line-walker
     // returned '\n' for it, creating a one-byte file that failed checksum
     // and drift comparisons against the truly empty file the patch creates.
     const hunks = sections.flatMap((section) => section.hunks);
@@ -61,15 +61,15 @@ function contentFromSections(sections) {
     return hasNoNewlineMarker ? result : result + '\n';
 }
 /**
- * Projects every TEXT new file a diff creates into a path → content map, for
+ * Projects every text new file a diff creates into a path → content map, for
  * the cross-patch lint projections that build a synthetic patch-queue entry.
  *
- * Binary new files are SKIPPED rather than refused. The map feeds only the
- * forward-import rule, which scans content for import statements — a binary
- * blob authors none, so omitting it contributes exactly what including it
- * would. Refusing instead (which is what
+ * Binary new files are skipped rather than refused. The map feeds only the
+ * forward-import rule, which scans content for import statements, and a
+ * binary blob authors none, so omitting it contributes exactly what
+ * including it would. Refusing instead (which is what
  * {@link extractNewFileContentFromDiff} correctly does for a caller that
- * named ONE file) made vendoring a new binary impossible: every projection
+ * named one file) made vendoring a new binary impossible: every projection
  * site fed it every detected new file, so `export --order`, `re-export
  * --scan --scan-file`, `patch move-files-into` and `patch split` all died on
  * a file the export half had just written a valid `GIT binary patch` for.
@@ -134,7 +134,7 @@ export function applyPatchTextToContent(content, patchContent, targetFile) {
     // The "no newline at end" marker applies to the last hunk in file order
     // (highest oldStart), which is the *first* hunk in our reverse-sorted array.
     // We read the new-side flag because the output we produce corresponds to
-    // the new side; asymmetric diffs (old lacks newline, new has one — or
+    // the new side. Asymmetric diffs (old lacks newline, new has one, or
     // vice versa) would otherwise disagree with `git apply`.
     const lastHunkNoNewline = sortedHunks[0]?.noNewlineAtEndNew ?? false;
     for (const hunk of sortedHunks) {
@@ -158,10 +158,10 @@ export function applyPatchTextToContent(content, patchContent, targetFile) {
             throw new PatchError(`Patch hunk header mismatch for ${targetFile}: header says ${hunk.oldCount} old lines but body has ${actualOldCount}`, targetFile);
         }
         // Replace the old lines with new lines. Unified-diff convention: for a
-        // pure-insertion hunk (`@@ -N,0 +M,k @@`), N names the line BEFORE the
-        // insertion point, so content is spliced at index N (after line N) —
+        // pure-insertion hunk (`@@ -N,0 +M,k @@`), N names the line before the
+        // insertion point, so content is spliced at index N (after line N).
         // `N - 1` inserted one line too early, and `@@ -0,0` (insert at top of
-        // file) produced splice(-1, …), which inserts before the LAST element.
+        // file) produced splice(-1, …), which inserts before the last element.
         const startIndex = hunk.oldCount === 0 ? hunk.oldStart : hunk.oldStart - 1;
         // Verify context lines match before applying
         let verifyIndex = startIndex;

package/dist/src/core/process-cpu-time.d.ts

@@ -3,7 +3,7 @@
  *
  * Best-effort: a missing `ps`, an exited process, or an unparseable field
  * yields `undefined`, which callers must render as "unknown" rather than as
- * zero — reporting a live build as having used no CPU would invert the very
+ * zero. Reporting a live build as having used no CPU would invert the very
  * diagnosis this exists for.
  *
  * @param pid - Process to inspect

package/dist/src/core/process-cpu-time.js

@@ -3,12 +3,12 @@
  * Accumulated-CPU-time probe for a single PID.
  *
  * Exists to answer the one question `kill(pid, 0)` cannot: a lock holder
- * that EXISTS may still be wedged. A downstream fork running five concurrent
- * sessions on one checkout diagnosed exactly this by hand — "a holder at
- * near-zero CPU is hung, not working" — after a queue stalled behind a
+ * that exists may still be wedged. A downstream fork running five concurrent
+ * sessions on one checkout diagnosed exactly this by hand ("a holder at
+ * near-zero CPU is hung, not working") after a queue stalled behind a
  * command that had consumed 0.3 s of CPU in eleven minutes.
  *
- * It is reported as EVIDENCE, never as a verdict. A legitimately slow holder
+ * It is reported as evidence, never as a verdict. A legitimately slow holder
  * can also sit at low CPU while blocked on I/O or on a child process, so
  * nothing keys a refusal, a kill, or a lock steal off this number.
  */
@@ -19,7 +19,7 @@ import { parsePsDuration } from '../utils/ps-duration.js';
  *
  * Best-effort: a missing `ps`, an exited process, or an unparseable field
  * yields `undefined`, which callers must render as "unknown" rather than as
- * zero — reporting a live build as having used no CPU would invert the very
+ * zero. Reporting a live build as having used no CPU would invert the very
  * diagnosis this exists for.
  *
  * @param pid - Process to inspect

package/dist/src/core/rebase-session.d.ts

@@ -12,11 +12,11 @@ export type RebasePatchStatus = 'pending' | 'applied-clean' | 'applied-fuzz' | '
  * A discriminated union on `status`, so a payload can only be present on the
  * status it belongs to. A flat-optionals shape makes
  * `{ status: 'resolved', error, conflictingFiles }` representable, and
- * `rebase --continue` will write it — flipping the status without clearing
+ * `rebase --continue` will write it, flipping the status without clearing
  * the failure payload, then persisting that to the session file.
  *
- * The on-disk validator (`isValidPatchEntry`) is deliberately NOT tightened
- * to match. The session file carries no schema version, so a stricter
+ * The on-disk validator (`isValidPatchEntry`) is not tightened to
+ * match, on purpose. The session file carries no schema version, so a stricter
  * validator would reject an older file mid-rebase, where the only remedies
  * discard the operator's in-progress conflict resolution. Instead
  * {@link normalizeEntry} drops payload that does not belong to the status on
@@ -59,9 +59,9 @@ export declare function getRebaseSessionPath(projectRoot: string): string;
  * discriminated-union form rather than collapsing three states into `null`.
  *
  * Distinguishing `present: false` from `present: true, valid: false` is
- * load-bearing. Collapsing both to `null` while reporting liveness from
+ * important. Collapsing both to `null` while reporting liveness from
  * `pathExists` alone wedges the operator in a closed cycle: `rebase` says
- * "already in progress — use --continue or --abort", and both of those say
+ * "already in progress, use --continue or --abort", and both of those say
  * "no rebase session in progress", with no CLI path deleting the file and no
  * message naming it.
  */
@@ -86,8 +86,8 @@ export type RebaseSessionRead = {
  * that read mean `absent`. A pathExists pre-probe both races deletion (a
  * file removed between probe and read misreports an absent session as
  * corrupt) and swallows EACCES (an unreadable `.fireforge/` misreports a
- * session as absent) — the same failure `readTreeMarker` avoids for tree
- * markers.
+ * session as absent). It is the same failure `readTreeMarker` avoids for
+ * tree markers.
  */
 export declare function readRebaseSession(projectRoot: string): Promise<RebaseSessionRead>;
 /**

package/dist/src/core/rebase-session.js

@@ -29,9 +29,9 @@ const REBASE_PATCH_STATUSES = [
 /**
  * Drops payload that does not belong to an entry's status.
  *
- * Applied on read so a session written by an older FireForge — where
+ * Applied on read so a session written by an older FireForge, where
  * `rebase --continue` left `error`/`conflictingFiles` on a now-`resolved`
- * entry — loads cleanly and is corrected, instead of being refused by a
+ * entry, loads cleanly and is corrected, instead of being refused by a
  * stricter validator mid-rebase.
  *
  * @param entry - A structurally valid entry, possibly carrying stale payload
@@ -74,28 +74,28 @@ function isValidOptionalProduct(value) {
 }
 /**
  * Validates a session file against the shape the rebase commands actually
- * consume — not merely against broad field types.
+ * consume, not merely against broad field types.
  *
  * A looser predicate that checks six `typeof`s and nothing else admits
  * sessions the resume path then acts on. `patches: [null]` reaches
  * `patch-loop.ts`, which reads `.filename` off each entry and hands it to
  * `stampPatchVersions`. A `currentIndex` of `NaN` (legal for
  * `typeof === 'number'`) makes the resume loop run zero iterations and
- * report success; a negative one indexes out of range in `continue.ts`.
+ * report success. A negative one indexes out of range in `continue.ts`.
  * `toVersion: ""` passes `isString` and is stamped verbatim onto every
  * Furnace override's `baseVersion`. `fromProduct`/`toProduct` go unchecked
  * despite being typed `FirefoxProduct`.
  *
  * The session file is written only by `rebase/index.ts` from validated CLI
  * and config values, so every one of these is a corrupt-file or hand-edit
- * case — which is exactly what this predicate exists to catch.
+ * case, which is exactly what this predicate exists to catch.
  */
 function isValidSession(data) {
     if (!isObject(data))
         return false;
     if (!isString(data['startedAt']) || Number.isNaN(Date.parse(data['startedAt'])))
         return false;
-    // 4 is git's own minimum abbreviation length; 40/64 are full SHA-1/SHA-256.
+    // 4 is git's own minimum abbreviation length. 40/64 are full SHA-1/SHA-256.
     if (!isString(data['preRebaseCommit']) || !/^[0-9a-f]{4,64}$/i.test(data['preRebaseCommit'])) {
         return false;
     }
@@ -127,8 +127,8 @@ function isValidSession(data) {
  * that read mean `absent`. A pathExists pre-probe both races deletion (a
  * file removed between probe and read misreports an absent session as
  * corrupt) and swallows EACCES (an unreadable `.fireforge/` misreports a
- * session as absent) — the same failure `readTreeMarker` avoids for tree
- * markers.
+ * session as absent). It is the same failure `readTreeMarker` avoids for
+ * tree markers.
  */
 export async function readRebaseSession(projectRoot) {
     const path = getRebaseSessionPath(projectRoot);

package/dist/src/core/register-result.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shared result shape for manifest registration operations, split out of
  * the `manifest-register.ts` barrel so the `register-*` leaf modules can
- * import it without importing the barrel that re-exports them — that
+ * import it without importing the barrel that re-exports them. That
  * type-only back-edge made the registration dependency graph cyclic.
  */
 /**

package/dist/src/core/register-result.js

@@ -2,7 +2,7 @@
 /**
  * Shared result shape for manifest registration operations, split out of
  * the `manifest-register.ts` barrel so the `register-*` leaf modules can
- * import it without importing the barrel that re-exports them — that
+ * import it without importing the barrel that re-exports them. That
  * type-only back-edge made the registration dependency graph cyclic.
  */
 export {};

package/dist/src/core/register-scaffold.d.ts

@@ -7,7 +7,7 @@
  *
  *  - creating a directory `moz.build` (license header + the requested list
  *    directive) and wiring the parent chain's `DIRS` entries up to the
- *    nearest existing moz.build;
+ *    nearest existing moz.build.
  *  - wiring an `XPCSHELL_TESTS_MANIFESTS` entry for a (possibly freshly
  *    created) `xpcshell.toml` into the nearest existing moz.build.
  *
@@ -33,7 +33,7 @@ export declare function upsertMozBuildListEntry(content: string, directive: stri
  * Ensures every parent directory between `childRelDir` and the nearest
  * existing moz.build carries a `DIRS` entry pointing at the next segment
  * down, creating intermediate moz.build files as needed. Walks upward
- * from the child's parent; throws when no moz.build exists anywhere up
+ * from the child's parent. Throws when no moz.build exists anywhere up
  * to the engine root (an engine checkout always has one at the root, so
  * this indicates a bogus path).
  */

package/dist/src/core/register-scaffold.js

@@ -8,7 +8,7 @@
  *
  *  - creating a directory `moz.build` (license header + the requested list
  *    directive) and wiring the parent chain's `DIRS` entries up to the
- *    nearest existing moz.build;
+ *    nearest existing moz.build.
  *  - wiring an `XPCSHELL_TESTS_MANIFESTS` entry for a (possibly freshly
  *    created) `xpcshell.toml` into the nearest existing moz.build.
  *
@@ -25,7 +25,7 @@ import { findAlphabeticalMozBuildPosition } from './moz-manifest-helpers.js';
 import { tokenizeMozBuildList } from './moz-manifest-tokenizers.js';
 /**
  * moz.build files use Firefox's canonical MPL-2.0 hash-comment header
- * regardless of the fork's own project license — they live in the engine
+ * regardless of the fork's own project license. They live in the engine
  * tree among upstream MPL files.
  */
 function mozBuildHeader() {
@@ -58,7 +58,7 @@ export function upsertMozBuildListEntry(content, directive, value) {
  * Ensures every parent directory between `childRelDir` and the nearest
  * existing moz.build carries a `DIRS` entry pointing at the next segment
  * down, creating intermediate moz.build files as needed. Walks upward
- * from the child's parent; throws when no moz.build exists anywhere up
+ * from the child's parent. Throws when no moz.build exists anywhere up
  * to the engine root (an engine checkout always has one at the root, so
  * this indicates a bogus path).
  */

package/dist/src/core/register-shared-css.d.ts

@@ -12,7 +12,7 @@ import type { RegisterResult } from './register-result.js';
  * freshly registered file at the wrong column and produces avoidable
  * formatting churn, since adjacent Firefox entries are typically padded to a
  * wider column. Returns `undefined` when no existing entries provide an
- * alignment signal — callers fall back to the four-space default.
+ * alignment signal. Callers fall back to the four-space default.
  */
 export declare function measureSourceColumn(content: string): number | undefined;
 /**
@@ -30,7 +30,7 @@ export declare function buildEntry(name: string, sourceColumn: number | undefine
  *   skin/classic/browser/{name}.css    (../shared/{name}.css)
  *
  * The gap between target and source is sized to align with adjacent
- * entries when the manifest already uses a wider column; falls back to
- * a four-space minimum otherwise.
+ * entries when the manifest already uses a wider column. It falls back
+ * to a four-space minimum otherwise.
  */
 export declare function registerSharedCSS(engineDir: string, fileName: string, after?: string, dryRun?: boolean): Promise<RegisterResult>;

package/dist/src/core/register-shared-css.js

@@ -30,7 +30,7 @@ const MIN_SOURCE_GAP = 4;
  * freshly registered file at the wrong column and produces avoidable
  * formatting churn, since adjacent Firefox entries are typically padded to a
  * wider column. Returns `undefined` when no existing entries provide an
- * alignment signal — callers fall back to the four-space default.
+ * alignment signal. Callers fall back to the four-space default.
  */
 export function measureSourceColumn(content) {
     const lines = content.split('\n');
@@ -75,8 +75,8 @@ export function buildEntry(name, sourceColumn) {
  *   skin/classic/browser/{name}.css    (../shared/{name}.css)
  *
  * The gap between target and source is sized to align with adjacent
- * entries when the manifest already uses a wider column; falls back to
- * a four-space minimum otherwise.
+ * entries when the manifest already uses a wider column. It falls back
+ * to a four-space minimum otherwise.
  */
 export async function registerSharedCSS(engineDir, fileName, after, dryRun = false) {
     const manifest = 'browser/themes/shared/jar.inc.mn';
@@ -90,7 +90,7 @@ export async function registerSharedCSS(engineDir, fileName, after, dryRun = fal
     const entry = buildEntry(name, sourceColumn);
     // Idempotency check. `furnace chrome-doc create` writes its CSS as a
     // `content/browser/<name>.css` entry rather than the canonical
-    // `skin/classic/browser/<name>.css` form `register` produces; recognise
+    // `skin/classic/browser/<name>.css` form `register` produces. Recognise
     // both shapes so a follow-up `register` invocation against an
     // already-chrome-doc-registered file reports `skipped` instead of
     // appending a duplicate `skin/classic/browser/...` row.