@hominis/fireforge 0.45.0 → 0.46.1

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.
@@ -101,16 +101,6 @@ export async function extractNewFileContent(patchPath, targetFile) {
     const content = await readText(patchPath);
     return extractNewFileContentFromDiff(content, targetFile);
 }
-/**
- * Applies a patch's changes to content.
- * @param content - Original content (null for new files)
- * @param patchPath - Path to the patch file
- * @param targetFile - The file path within the patch
- * @returns Modified content
- */
-export async function applyPatchToContent(content, patchPath, targetFile) {
-    return applyPatchTextToContent(content, await readText(patchPath), targetFile);
-}
 /**
  * Applies an already-read patch body to content. Batched callers that hold
  * many (patch, file) pairs use this to read each patch body once instead of
@@ -144,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) {
@@ -168,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
@@ -34,7 +34,7 @@ export async function readProcessCpuSeconds(pid) {
                 '-NoProfile',
                 '-NonInteractive',
                 '-Command',
-                `(Get-Process -Id ${String(pid)} -ErrorAction SilentlyContinue).CPU`,
+                `(Get-Process -Id ${pid} -ErrorAction SilentlyContinue).CPU`,
             ]);
             const seconds = Number.parseFloat(result.stdout.trim());
             return Number.isFinite(seconds) ? seconds : undefined;

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
@@ -52,14 +52,16 @@ export interface RebaseSession {
     /** Index of the next patch to process (resume point). */
     currentIndex: number;
 }
+/** Absolute path of the session file, for messages that must name it. */
+export declare function getRebaseSessionPath(projectRoot: string): string;
 /**
  * Outcome of reading the session file, following the {@link LockOwner}
  * 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.
  */
@@ -74,8 +76,6 @@ export type RebaseSessionRead = {
     valid: false;
     reason: string;
 };
-/** Absolute path of the session file, for messages that must name it. */
-export declare function getRebaseSessionPath(projectRoot: string): string;
 /**
  * Reads the session file, reporting absent, valid, and corrupt as three
  * distinct outcomes. Never throws for a malformed file: `readJson` calls
@@ -86,16 +86,10 @@ export declare function getRebaseSessionPath(projectRoot: string): string;
  * 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>;
-/**
- * Loads an existing rebase session, or returns `null` when none exists or the
- * file on disk is unusable. Callers that must tell those two apart — every
- * command that reports to an operator — should use {@link readRebaseSession}.
- */
-export declare function tryReadRebaseSession(projectRoot: string): Promise<RebaseSession | null>;
 /**
  * Persists a rebase session atomically.
  */

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

@@ -13,7 +13,8 @@ import { getProjectPaths } from './config-paths.js';
 import { createSiblingLockPath, withFileLock } from './file-lock.js';
 // ── Helpers ──
 const SESSION_FILENAME = 'rebase-session.json';
-function sessionPath(projectRoot) {
+/** Absolute path of the session file, for messages that must name it. */
+export function getRebaseSessionPath(projectRoot) {
     return join(getProjectPaths(projectRoot).fireforgeDir, SESSION_FILENAME);
 }
 const REBASE_PATCH_STATUSES = [
@@ -28,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
@@ -73,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;
     }
@@ -116,10 +117,6 @@ function isValidSession(data) {
         return false;
     return currentIndex >= 0 && currentIndex <= patches.length;
 }
-/** Absolute path of the session file, for messages that must name it. */
-export function getRebaseSessionPath(projectRoot) {
-    return sessionPath(projectRoot);
-}
 /**
  * Reads the session file, reporting absent, valid, and corrupt as three
  * distinct outcomes. Never throws for a malformed file: `readJson` calls
@@ -130,11 +127,11 @@ export function getRebaseSessionPath(projectRoot) {
  * 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 = sessionPath(projectRoot);
+    const path = getRebaseSessionPath(projectRoot);
     let data;
     try {
         data = await readJson(path);
@@ -159,20 +156,11 @@ export async function readRebaseSession(projectRoot) {
         session: { ...data, patches: data.patches.map(normalizeEntry) },
     };
 }
-/**
- * Loads an existing rebase session, or returns `null` when none exists or the
- * file on disk is unusable. Callers that must tell those two apart — every
- * command that reports to an operator — should use {@link readRebaseSession}.
- */
-export async function tryReadRebaseSession(projectRoot) {
-    const result = await readRebaseSession(projectRoot);
-    return result.present && result.valid ? result.session : null;
-}
 /**
  * Persists a rebase session atomically.
  */
 export async function saveRebaseSession(projectRoot, session) {
-    const path = sessionPath(projectRoot);
+    const path = getRebaseSessionPath(projectRoot);
     await withFileLock(createSiblingLockPath(path, '.rebase-session.lock'), async () => {
         await writeJson(path, session);
     });
@@ -181,7 +169,7 @@ export async function saveRebaseSession(projectRoot, session) {
  * Removes the rebase session file.
  */
 export async function clearRebaseSession(projectRoot) {
-    const path = sessionPath(projectRoot);
+    const path = getRebaseSessionPath(projectRoot);
     if (await pathExists(path)) {
         await removeFile(path);
     }

package/dist/src/core/register-browser-content.js

@@ -5,6 +5,7 @@
 import { join } from 'node:path';
 import { GeneralError } from '../errors/base.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
+import { normalizePathSlashes } from '../utils/paths.js';
 import { insertJarMnEntry } from './moz-manifest-helpers.js';
 /**
  * Tokenizer-based implementation for browser content registration.
@@ -30,8 +31,8 @@ export async function registerBrowserContent(engineDir, fileName, after, sourceP
     if (!(await pathExists(manifestPath))) {
         throw new GeneralError(`Manifest not found: ${manifest}`);
     }
-    const source = (sourcePath ?? `content/${fileName}`).replace(/\\/g, '/');
-    const entry = `        content/browser/${fileName}    (${source})`.replace(/\\/g, '/');
+    const source = normalizePathSlashes(sourcePath ?? `content/${fileName}`);
+    const entry = normalizePathSlashes(`        content/browser/${fileName}    (${source})`);
     const content = await readText(manifestPath);
     // Idempotency check
     if (content.includes(`content/browser/${fileName}`)) {

package/dist/src/core/register-browser-test.js

@@ -5,6 +5,7 @@
 import { join } from 'node:path';
 import { GeneralError } from '../errors/base.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
+import { normalizePathSlashes } from '../utils/paths.js';
 import { insertMozBuildListEntry } from './moz-manifest-helpers.js';
 /**
  * Tokenizer-based implementation for test manifest registration.
@@ -28,7 +29,7 @@ export async function registerTestManifest(engineDir, testDir, dryRun = false) {
     if (!(await pathExists(manifestPath))) {
         throw new GeneralError(`Manifest not found: ${manifest}`);
     }
-    const entry = `    "content/test/${testDir}/browser.toml",`.replace(/\\/g, '/');
+    const entry = normalizePathSlashes(`    "content/test/${testDir}/browser.toml",`);
     const content = await readText(manifestPath);
     // Idempotency check
     if (content.includes(`content/test/${testDir}/browser.toml`)) {

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

@@ -5,6 +5,7 @@
 import { join } from 'node:path';
 import { GeneralError } from '../errors/base.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
+import { normalizePathSlashes } from '../utils/paths.js';
 import { insertMozBuildListEntry } from './moz-manifest-helpers.js';
 import { scaffoldModuleMozBuild } from './register-scaffold.js';
 /**
@@ -41,7 +42,7 @@ export async function registerFireForgeModule(engineDir, fileName, moduleDir, dr
         }
         throw new GeneralError(`Manifest not found: ${manifest}. Pass --create-manifest to scaffold it and wire the parent DIRS entry.`);
     }
-    const entry = `    "${fileName}",`.replace(/\\/g, '/');
+    const entry = normalizePathSlashes(`    "${fileName}",`);
     const content = await readText(manifestPath);
     // Idempotency check
     if (content.includes(`"${fileName}"`)) {

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.
  *
@@ -19,12 +19,13 @@
 import { dirname, join } from 'node:path';
 import { GeneralError } from '../errors/base.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
+import { normalizePathSlashes } from '../utils/paths.js';
 import { getLicenseHeader } from './license-headers.js';
 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() {
@@ -57,14 +58,14 @@ 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).
  */
 export async function ensureParentDirsWiring(engineDir, childRelDir, dryRun) {
     const actions = [];
     let childName = childRelDir.split('/').at(-1) ?? childRelDir;
-    let parentRel = dirname(childRelDir).replace(/\\/g, '/');
+    let parentRel = normalizePathSlashes(dirname(childRelDir));
     for (;;) {
         if (parentRel === '.' || parentRel === '' || parentRel === '/') {
             throw new GeneralError(`No moz.build found in any parent of ${childRelDir} up to the engine root; ` +
@@ -90,7 +91,7 @@ export async function ensureParentDirsWiring(engineDir, childRelDir, dryRun) {
             await writeText(parentManifestPath, scaffold);
         actions.push({ manifest: parentManifestRel, change: `created with DIRS += ["${childName}"]` });
         childName = parentRel.split('/').at(-1) ?? parentRel;
-        parentRel = dirname(parentRel).replace(/\\/g, '/');
+        parentRel = normalizePathSlashes(dirname(parentRel));
     }
 }
 /**
@@ -122,7 +123,7 @@ export async function scaffoldModuleMozBuild(engineDir, moduleDir, fileName, dry
  * entry already exists).
  */
 export async function ensureXpcshellManifestWiring(engineDir, manifestRelPath, dryRun) {
-    let dirRel = dirname(manifestRelPath).replace(/\\/g, '/');
+    let dirRel = normalizePathSlashes(dirname(manifestRelPath));
     for (;;) {
         if (dirRel === '.' || dirRel === '' || dirRel === '/') {
             throw new GeneralError(`No moz.build found in any parent of ${manifestRelPath} up to the engine root; ` +
@@ -140,6 +141,6 @@ export async function ensureXpcshellManifestWiring(engineDir, manifestRelPath, d
                 await writeText(mozBuildPath, updated);
             return [{ manifest: mozBuildRel, change: `XPCSHELL_TESTS_MANIFESTS += ["${relEntry}"]` }];
         }
-        dirRel = dirname(dirRel).replace(/\\/g, '/');
+        dirRel = normalizePathSlashes(dirname(dirRel));
     }
 }

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

@@ -5,6 +5,7 @@
 import { basename, join } from 'node:path';
 import { GeneralError } from '../errors/base.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
+import { normalizePathSlashes } from '../utils/paths.js';
 import { insertJarMnEntry } from './moz-manifest-helpers.js';
 /**
  * Tokenizer-based implementation for shared CSS registration.
@@ -29,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');
@@ -65,7 +66,7 @@ export function buildEntry(name, sourceColumn) {
     const minColumn = target.length + MIN_SOURCE_GAP;
     const column = sourceColumn !== undefined && sourceColumn >= minColumn ? sourceColumn : minColumn;
     const padding = ' '.repeat(column - target.length);
-    return `${target}${padding}(../shared/${name}.css)`.replace(/\\/g, '/');
+    return normalizePathSlashes(`${target}${padding}(../shared/${name}.css)`);
 }
 /**
  * Registers a CSS file in browser/themes/shared/jar.inc.mn.
@@ -74,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';
@@ -89,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.

package/dist/src/core/register-xpcshell-test.d.ts

@@ -2,8 +2,8 @@
  * xpcshell test-file registration. Without it, xpcshell test files (e.g.
  * `<module-dir>/test/unit/test_*.js`) are rejected by `fireforge register`
  * as "Unknown file pattern". This writer inserts the `["test_*.js"]` section
- * into the directory's `xpcshell.toml` (alphabetically, idempotently) and —
- * with `--create-manifest` — creates the manifest and wires
+ * into the directory's `xpcshell.toml` (alphabetically, idempotently). With
+ * `--create-manifest` it also creates the manifest and wires
  * `XPCSHELL_TESTS_MANIFESTS` into the nearest moz.build.
  */
 import type { RegisterResult } from './register-result.js';

package/dist/src/core/register-xpcshell-test.js

@@ -3,8 +3,8 @@
  * xpcshell test-file registration. Without it, xpcshell test files (e.g.
  * `<module-dir>/test/unit/test_*.js`) are rejected by `fireforge register`
  * as "Unknown file pattern". This writer inserts the `["test_*.js"]` section
- * into the directory's `xpcshell.toml` (alphabetically, idempotently) and —
- * with `--create-manifest` — creates the manifest and wires
+ * into the directory's `xpcshell.toml` (alphabetically, idempotently). With
+ * `--create-manifest` it also creates the manifest and wires
  * `XPCSHELL_TESTS_MANIFESTS` into the nearest moz.build.
  */
 import { join } from 'node:path';

package/dist/src/core/run-log-redact.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Conservative secret redaction for the run-log FILE tee.
+ *
+ * A run log is a complete copy of mach's output, and mach echoes its
+ * environment in places (configure summaries, `mach env`, harness
+ * diagnostics that print the command line). The terminal already showed
+ * every byte to the operator who ran it. The file, by contrast, is retained
+ * twenty deep and gets attached to bug reports. So the file gets a narrow
+ * masking pass and the terminal does not.
+ *
+ * Minimal and pattern-based. See {@link redactRunLogText} for the exact
+ * contract. It is a seatbelt against the common accidental leak, not a
+ * guarantee that a log is free of secrets.
+ */
+/**
+ * Masks the obvious secret shapes in run-log text, line by line.
+ *
+ * Redacted:
+ * - the value of an env-style assignment `KEY=value` whose KEY matches
+ *   `/(TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|AUTH)/i`. The value up to the
+ *   next whitespace, or a whole quoted string, becomes `KEY=<redacted>`.
+ *   The `--flag=value` and `-DNAME=value` spellings of the same shape are
+ *   covered (`--password=x` → `--password=<redacted>`).
+ * - the credential of an `Authorization:` header (`Bearer`, `Basic` and
+ *   `Token` schemes keep the scheme word, and anything else masks the
+ *   whole value).
+ *
+ * Not redacted: secrets that appear without one of those key names or
+ * headers (a bare token in a URL query string, a space-separated
+ * `--password foo` CLI argument, JSON `"token": "..."` fields, cookies).
+ * Line structure and every other byte pass through unchanged. `\n`, `\r\n`
+ * and lone `\r` all delimit lines, so carriage-return-repainted progress
+ * output is masked per repaint.
+ *
+ * @param text - One or more complete lines
+ * @returns The same text with masked values
+ */
+export declare function redactRunLogText(text: string): string;