@hominis/fireforge 0.39.0 → 0.40.0

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

@@ -28,7 +28,7 @@
 import { basename, resolve } from 'node:path';
 import { pathExists } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
-import { composeShimSource, SHIM_FILENAME, SUPPRESSED_DIAGNOSTIC_CODES, UNDEFINED_IDENTIFIER_CODES, UNDEFINED_IDENTIFIER_HINT, } from './typecheck-shim.js';
+import { composeShimSource, SHIM_FILENAME, SUPPRESSED_DIAGNOSTIC_CODES, TEST_HARNESS_SHIM, UNDEFINED_IDENTIFIER_CODES, UNDEFINED_IDENTIFIER_HINT, } from './typecheck-shim.js';
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -148,7 +148,7 @@ function createPathsResolver(ts, paths, baseDir, fileExists, onResolved) {
  * @param mode - Strictness preset plus allowlisted compiler-option overrides
  * @returns Diagnostics grouped per owning file plus run-level errors
  */
-export async function runCheckJsGrouped(repoDir, resolutionOwned, extraShimPath, projectRoot, mode) {
+export async function runCheckJsGrouped(repoDir, resolutionOwned, extraShimPath, projectRoot, mode, builtinShimSuffix) {
     const empty = { byFile: new Map(), global: [] };
     if (resolutionOwned.size === 0)
         return empty;
@@ -193,7 +193,11 @@ export async function runCheckJsGrouped(repoDir, resolutionOwned, extraShimPath,
     let shimSource;
     try {
         const composed = await composeShimSource(projectRoot ?? repoDir, extraShimPath);
-        shimSource = composed.source;
+        // The suffix (e.g. the loose test-harness baseline, FORGE G5) goes
+        // AFTER the consumer's extra shim: TypeScript resolves conflicting
+        // `declare var` redeclarations to the FIRST declaration, so a typed
+        // consumer declaration must precede the loose fallback to win.
+        shimSource = builtinShimSuffix ? `${composed.source}\n${builtinShimSuffix}` : composed.source;
         if (composed.extraShimAppended) {
             verbose(`checkJs: extra shim ${extraShimPath ?? ''} appended to Firefox globals shim`);
         }
@@ -402,6 +406,55 @@ export async function runCheckJs(repoDir, patchOwnedFiles, extraShimPath, projec
 export async function invokePatchLintCheckJs(repoDir, patchOwnedFiles, patchLint, projectRoot, reportScope) {
     return runCheckJs(repoDir, patchOwnedFiles, patchLint.checkJsExtraShim, projectRoot, modeFromPatchLintConfig(patchLint), reportScope);
 }
+/**
+ * Runs the checkJs pass over patch-owned test `.js` files (FORGE G5,
+ * `patchLint.checkJsTestFiles`). Each test file gets its OWN small
+ * program — mochitest scripts share top-level scope only with their
+ * directory's `head*.js` helpers, so one multi-script program would emit
+ * false cross-file redeclaration errors — with roots = the test file plus
+ * any same-directory patch-owned `head*.js`, checked against the built-in
+ * Firefox shim + {@link TEST_HARNESS_SHIM} + the optional consumer
+ * `checkJsTestShim`. Only the target file's diagnostics are reported per
+ * program (head helpers report from their own program), and run-level
+ * errors are de-duplicated across programs.
+ *
+ * @param repoDir - Absolute engine (repository) directory
+ * @param testFiles - Patch-owned test-script paths (repo-relative)
+ * @param patchLint - The resolved `patchLint` config block
+ * @param projectRoot - FireForge project root for shim resolution
+ */
+export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint, projectRoot) {
+    const merged = { byFile: new Map(), global: [] };
+    if (testFiles.size === 0)
+        return merged;
+    const mode = modeFromPatchLintConfig(patchLint);
+    const seenGlobal = new Set();
+    const files = [...testFiles].sort((a, b) => a.localeCompare(b));
+    for (const file of files) {
+        const dir = file.slice(0, file.lastIndexOf('/') + 1);
+        const roots = new Set([file]);
+        for (const candidate of files) {
+            if (candidate === file)
+                continue;
+            const base = candidate.split('/').pop() ?? '';
+            if (candidate.startsWith(dir) && /^head(?:_.*)?\.js$/.test(base)) {
+                roots.add(candidate);
+            }
+        }
+        const result = await runCheckJsGrouped(repoDir, roots, patchLint.checkJsTestShim, projectRoot, mode, TEST_HARNESS_SHIM);
+        const own = result.byFile.get(file);
+        if (own && own.length > 0) {
+            merged.byFile.set(file, [...(merged.byFile.get(file) ?? []), ...own]);
+        }
+        for (const globalIssue of result.global) {
+            if (seenGlobal.has(globalIssue.message))
+                continue;
+            seenGlobal.add(globalIssue.message);
+            merged.global.push(globalIssue);
+        }
+    }
+    return merged;
+}
 /** Derives the {@link CheckJsMode} from a `patchLint` config block. */
 function modeFromPatchLintConfig(patchLint) {
     const strict = patchLint.checkJsStrict === true;

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

@@ -15,7 +15,7 @@ import { pathExists, readText } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { hasRawCssColors } from '../utils/regex.js';
 import { loadFurnaceConfig } from './furnace-config.js';
-import { extractAddedLinesPerFile } from './patch-lint-diff.js';
+import { extractAddedLineNumbersPerFile, extractAddedLinesPerFile } from './patch-lint-diff.js';
 /**
  * Loads the furnace token-prefix lint inputs gracefully — returns
  * undefined (skipping the token-prefix check) when furnace.json cannot
@@ -38,11 +38,48 @@ async function loadCssTokenContext(repoDir) {
     }
     return undefined;
 }
+/**
+ * Masks CSS block comments with spaces, preserving newlines so line
+ * numbers stay stable. An unclosed trailing `/*` is masked to EOF —
+ * matching how a CSS parser treats it (FORGE G4).
+ */
+function maskCssComments(source) {
+    const masked = source.replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, ' '));
+    const openerIndex = masked.indexOf('/*');
+    if (openerIndex === -1)
+        return masked;
+    return (masked.slice(0, openerIndex) +
+        masked
+            .slice(openerIndex)
+            .split('\n')
+            .map((line) => ' '.repeat(line.length))
+            .join('\n'));
+}
+const RAW_COLOR_IGNORE_MARKER = 'fireforge-ignore: raw-color-value';
+/**
+ * Builds the scan source for the diff branch with full-file comment
+ * awareness: comments are masked across the whole post-patch file so a
+ * 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
+ * joined-added-lines scan rather than misattributing lines.
+ */
+function buildAddedLinesScanSource(rawCss, addedNumbers) {
+    const rawLines = rawCss.split('\n');
+    if (!addedNumbers.every((n) => n >= 1 && n <= rawLines.length))
+        return undefined;
+    const maskedLines = maskCssComments(rawCss).split('\n');
+    return addedNumbers
+        .filter((n) => !(rawLines[n - 1] ?? '').includes(RAW_COLOR_IGNORE_MARKER))
+        .map((n) => maskedLines[n - 1] ?? '')
+        .join('\n');
+}
 /**
  * Raw-color check for one patched CSS file, scoped to introduced lines
  * when diff context is available. Pushes onto `issues`.
  */
-function checkRawColorValues(file, rawCss, addedLinesByFile, config, issues) {
+function checkRawColorValues(file, rawCss, addedLinesByFile, addedLineNumbersByFile, config, issues) {
     // 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
@@ -55,25 +92,33 @@ function checkRawColorValues(file, rawCss, addedLinesByFile, config, issues) {
     const allowlist = config?.patchLint?.rawColorAllowlist;
     const isAllowlisted = allowlist?.some((entry) => file === entry || file.endsWith('/' + entry));
     const isBranding = file.startsWith('browser/branding/');
-    if (!isAllowlisted && !isBranding) {
-        // Strip lines with inline fireforge-ignore: raw-color-value suppression.
-        // Check against rawCss (before comment stripping) so the CSS comment marker is still present.
+    if (isAllowlisted || isBranding)
+        return;
+    let suppressedContent;
+    const addedNumbers = addedLineNumbersByFile?.get(file);
+    if (addedNumbers !== undefined) {
+        suppressedContent = buildAddedLinesScanSource(rawCss, addedNumbers);
+    }
+    if (suppressedContent === undefined) {
+        // Legacy scan: full file (no diff), or the joined added lines when
+        // the diff and on-disk file disagree. Waiver lines are filtered
+        // against the pre-strip text so the CSS comment marker is present.
         const sourceForSuppression = addedLinesByFile
             ? (addedLinesByFile.get(file) ?? []).join('\n')
             : rawCss;
-        const suppressedContent = sourceForSuppression
+        suppressedContent = sourceForSuppression
             .split('\n')
-            .filter((line) => !line.includes('fireforge-ignore: raw-color-value'))
+            .filter((line) => !line.includes(RAW_COLOR_IGNORE_MARKER))
             .join('\n')
             .replace(/\/\*[\s\S]*?\*\//g, '');
-        if (hasRawCssColors(suppressedContent)) {
-            issues.push({
-                file,
-                check: 'raw-color-value',
-                message: 'Raw color value found. Use CSS custom properties (var(--...)) for design token consistency.',
-                severity: 'error',
-            });
-        }
+    }
+    if (hasRawCssColors(suppressedContent)) {
+        issues.push({
+            file,
+            check: 'raw-color-value',
+            message: 'Raw color value found. Use CSS custom properties (var(--...)) for design token consistency.',
+            severity: 'error',
+        });
     }
 }
 /**
@@ -157,6 +202,9 @@ export async function lintPatchedCss(repoDir, affectedFiles, diffContent, config
     const tokenContext = await loadCssTokenContext(repoDir);
     const issues = [];
     const addedLinesByFile = diffContent ? extractAddedLinesPerFile(diffContent) : undefined;
+    const addedLineNumbersByFile = diffContent
+        ? extractAddedLineNumbersPerFile(diffContent)
+        : undefined;
     for (const file of cssFiles) {
         const filePath = join(repoDir, file);
         if (!(await pathExists(filePath)))
@@ -164,7 +212,7 @@ export async function lintPatchedCss(repoDir, affectedFiles, diffContent, config
         const rawCss = await readText(filePath);
         // Strip block comments before scanning
         const cssContent = rawCss.replace(/\/\*[\s\S]*?\*\//g, '');
-        checkRawColorValues(file, rawCss, addedLinesByFile, config, issues);
+        checkRawColorValues(file, rawCss, addedLinesByFile, addedLineNumbersByFile, config, issues);
         checkTokenPrefixViolations(file, cssContent, addedLinesByFile, tokenContext, issues);
     }
     return issues;

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

@@ -18,6 +18,14 @@ export declare function detectNewFilesInDiff(diffContent: string): Set<string>;
  * Returns a map of file path → array of added line contents (without the leading `+`).
  */
 export declare function extractAddedLinesPerFile(diffContent: string): Map<string, string[]>;
+/**
+ * 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 (FORGE G4) — map the patch's additions onto the applied file.
+ */
+export declare function extractAddedLineNumbersPerFile(diffContent: string): Map<string, number[]>;
 /**
  * Builds the `modifiedFileAdditions` map the cross-patch lint expects for
  * a given unified diff. Exposed so callers that construct synthetic /

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

@@ -45,6 +45,37 @@ export function extractAddedLinesPerFile(diffContent) {
     }
     return result;
 }
+/**
+ * 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 (FORGE G4) — map the patch's additions onto the applied file.
+ */
+export function extractAddedLineNumbersPerFile(diffContent) {
+    const result = new Map();
+    for (const section of parseDiffSections(diffContent)) {
+        for (const hunk of section.hunks) {
+            let newLine = hunk.newStart;
+            for (const line of hunk.lines) {
+                if (line.startsWith('\\'))
+                    continue; // ""
+                if (line.startsWith('-'))
+                    continue;
+                if (line.startsWith('+')) {
+                    let arr = result.get(section.targetPath);
+                    if (!arr) {
+                        arr = [];
+                        result.set(section.targetPath, arr);
+                    }
+                    arr.push(newLine);
+                }
+                newLine++;
+            }
+        }
+    }
+    return result;
+}
 /**
  * Builds the `modifiedFileAdditions` map the cross-patch lint expects for
  * a given unified diff. Exposed so callers that construct synthetic /

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

@@ -41,3 +41,24 @@ export declare function resolvePatchOwnedSysMjs(currentNewFiles: Set<string>, pa
  * @returns Set of patch-owned chrome-subscript file paths
  */
 export declare function resolvePatchOwnedChromeScripts(currentNewFiles: Set<string>, patchQueueCtx?: PatchQueueContext): Set<string>;
+/**
+ * Test-script predicate for the `checkJsTestFiles` pass (FORGE G5):
+ * plain `.js` files (not `.sys.mjs` modules) that live under a `/test/`
+ * path or carry a `browser_` / `test_` / `xpcshell_` basename. Duplicates
+ * `patch-lint.ts`'s `isTestFile` shape rather than importing it —
+ * patch-lint.ts imports this module, so the reverse edge would create an
+ * import cycle (dpdm gate). The agreement is pinned by
+ * `patch-lint-ownership.test.ts`.
+ */
+export declare function isTestScriptFile(file: string): boolean;
+/**
+ * Returns the set of patch-owned test `.js` files (FORGE G5). Same
+ * ownership semantics as {@link resolvePatchOwnedSysMjs}; consumed by the
+ * `patchLint.checkJsTestFiles` pass, which checks each as its own small
+ * script-scope program.
+ *
+ * @param currentNewFiles - Files newly created in the current diff
+ * @param patchQueueCtx - Optional cross-patch context for queue-wide ownership
+ * @returns Set of patch-owned test-script file paths
+ */
+export declare function resolvePatchOwnedTestScripts(currentNewFiles: Set<string>, patchQueueCtx?: PatchQueueContext): Set<string>;

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

@@ -67,3 +67,33 @@ export function resolvePatchOwnedSysMjs(currentNewFiles, patchQueueCtx) {
 export function resolvePatchOwnedChromeScripts(currentNewFiles, patchQueueCtx) {
     return resolveOwned(currentNewFiles, patchQueueCtx, (file) => file.endsWith('.js') && !file.endsWith('.sys.mjs'));
 }
+/**
+ * Test-script predicate for the `checkJsTestFiles` pass (FORGE G5):
+ * plain `.js` files (not `.sys.mjs` modules) that live under a `/test/`
+ * path or carry a `browser_` / `test_` / `xpcshell_` basename. Duplicates
+ * `patch-lint.ts`'s `isTestFile` shape rather than importing it —
+ * patch-lint.ts imports this module, so the reverse edge would create an
+ * import cycle (dpdm gate). The agreement is pinned by
+ * `patch-lint-ownership.test.ts`.
+ */
+export function isTestScriptFile(file) {
+    if (!file.endsWith('.js') || file.endsWith('.sys.mjs'))
+        return false;
+    if (file.includes('/test/'))
+        return true;
+    const basename = file.split('/').pop() ?? '';
+    return /^(?:browser_|test_|xpcshell_).*\.js$/.test(basename);
+}
+/**
+ * Returns the set of patch-owned test `.js` files (FORGE G5). Same
+ * ownership semantics as {@link resolvePatchOwnedSysMjs}; consumed by the
+ * `patchLint.checkJsTestFiles` pass, which checks each as its own small
+ * script-scope program.
+ *
+ * @param currentNewFiles - Files newly created in the current diff
+ * @param patchQueueCtx - Optional cross-patch context for queue-wide ownership
+ * @returns Set of patch-owned test-script file paths
+ */
+export function resolvePatchOwnedTestScripts(currentNewFiles, patchQueueCtx) {
+    return resolveOwned(currentNewFiles, patchQueueCtx, isTestScriptFile);
+}

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

@@ -2,5 +2,5 @@
  * Public re-exports for {@link ./patch-lint.ts}. Split out so the
  * orchestrator stays within the ESLint `max-lines` budget.
  */
-export { buildPatchQueueContext, collectForwardImportEdges, collectNewFileCreatorsByPath, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, type ForwardImportEdge, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, type PatchQueueContext, type PatchQueueEntry, } from './patch-lint-cross.js';
+export { buildPatchQueueContext, collectForwardImportEdges, collectNewFileCreatorsByPath, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, type PatchQueueContext, type PatchQueueEntry, } from './patch-lint-cross.js';
 export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';

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

@@ -128,6 +128,21 @@ export type PatchSizeTierDecision = {
  * defensive-for-tests choice.
  */
 export declare function resolvePatchSizeTier(filesAffected: ReadonlyArray<string>, patchTier?: 'branding'): PatchSizeTierDecision;
+/**
+ * Read-only view of the size thresholds a tier enforces (FORGE G9).
+ * Public-API companion to {@link resolvePatchSizeTier} /
+ * {@link countNonBinaryDiffLines} so consumers can build waiver-freshness
+ * checks against the SAME numbers `large-patch-lines` /
+ * `large-patch-files` fire on instead of mirroring them.
+ */
+export declare function getPatchSizeThresholds(tier: 'general' | 'test' | 'branding'): {
+    lines: {
+        notice: number;
+        warning: number;
+        error: number;
+    };
+    maxFiles: number;
+};
 /**
  * Checks patch size and emits advisory warnings.
  *
@@ -179,6 +194,14 @@ export interface LintExportedPatchOptions {
      * attributes findings per patch instead of rebuilding per patch.
      */
     precomputedCheckJs?: readonly PatchLintIssue[];
+    /**
+     * Invoked with the issues DROPPED by the `ignoreChecks` waiver filter,
+     * when any were (FORGE G10). Suppression semantics are unchanged — the
+     * returned issue list still excludes them — but the caller can report
+     * the measurement a waived size finding carried (per-patch NOTICE lines
+     * and the `--report` JSON) instead of losing it entirely.
+     */
+    onSuppressed?: (suppressed: PatchLintIssue[]) => void;
 }
 /**
  * Runs all patch lint checks and returns combined issues.

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

@@ -3,7 +3,7 @@ import { dirname, join } from 'node:path';
 import { pathExists, readText } from '../utils/fs.js';
 import { stripJsComments } from '../utils/regex.js';
 import { containsUpstreamLicenseText, getLicenseHeader, hasAnyLicenseHeader, hasAnyLicenseHeaderAnyStyle, hasUpstreamMplBlockHeader, } from './license-headers.js';
-import { invokePatchLintCheckJs } from './patch-lint-checkjs.js';
+import { invokePatchLintCheckJs, runCheckJsTestFilesGrouped } from './patch-lint-checkjs.js';
 import { lintChromeScriptJsDocForFile } from './patch-lint-chrome-jsdoc.js';
 import { lintPatchedCss } from './patch-lint-css.js';
 import { detectNewFilesInDiff, extractAddedLinesPerFile } from './patch-lint-diff.js';
@@ -12,7 +12,7 @@ import { hasRelativeImport } from './patch-lint-imports.js';
 import { validateExportJsDoc } from './patch-lint-jsdoc.js';
 import { lintMozBuildSortedLists } from './patch-lint-mozbuild.js';
 import { lintObserverTopics } from './patch-lint-observer.js';
-import { resolvePatchOwnedChromeScripts, resolvePatchOwnedSysMjs } from './patch-lint-ownership.js';
+import { resolvePatchOwnedChromeScripts, resolvePatchOwnedSysMjs, resolvePatchOwnedTestScripts, } from './patch-lint-ownership.js';
 // ---------------------------------------------------------------------------
 // Cross-patch lint re-exports
 // ---------------------------------------------------------------------------
@@ -481,6 +481,19 @@ export function resolvePatchSizeTier(filesAffected, patchTier) {
         return { tier: 'branding', source: 'auto' };
     return { tier: 'general' };
 }
+/**
+ * Read-only view of the size thresholds a tier enforces (FORGE G9).
+ * Public-API companion to {@link resolvePatchSizeTier} /
+ * {@link countNonBinaryDiffLines} so consumers can build waiver-freshness
+ * checks against the SAME numbers `large-patch-lines` /
+ * `large-patch-files` fire on instead of mirroring them.
+ */
+export function getPatchSizeThresholds(tier) {
+    return {
+        lines: { ...PATCH_LINE_THRESHOLDS[tier] },
+        maxFiles: PATCH_FILES_THRESHOLDS[tier],
+    };
+}
 /**
  * Checks patch size and emits advisory warnings.
  *
@@ -644,6 +657,17 @@ export async function lintExportedPatch(repoDir, affectedFiles, diffContent, con
     }
     else if (config.patchLint?.checkJs) {
         issues.push(...(await invokePatchLintCheckJs(repoDir, patchOwnedFiles, config.patchLint, dirname(repoDir), options?.checkJsReportScope)));
+        // Export-time twin of per-patch lint's test-file pass (FORGE G5), so
+        // export/re-export and `lint --per-patch` agree on the checked surface.
+        if (config.patchLint.checkJsTestFiles === true) {
+            const testGrouped = await runCheckJsTestFilesGrouped(repoDir, resolvePatchOwnedTestScripts(newFiles, patchQueueCtx), config.patchLint, dirname(repoDir));
+            issues.push(...testGrouped.global);
+            for (const [rel, list] of testGrouped.byFile) {
+                if (options?.checkJsReportScope && !options.checkJsReportScope.has(rel))
+                    continue;
+                issues.push(...list);
+            }
+        }
     }
     // Filter out ignored checks last so every rule still runs (keeps the
     // implementation uniform) but suppressed rules do not surface. We do not
@@ -651,6 +675,10 @@ export async function lintExportedPatch(repoDir, affectedFiles, diffContent, con
     // inline `fireforge-ignore: <check>` markers work in the CSS and
     // forward-import rules.
     if (ignoreChecks && ignoreChecks.size > 0) {
+        const suppressed = issues.filter((issue) => ignoreChecks.has(issue.check));
+        if (suppressed.length > 0) {
+            options?.onSuppressed?.(suppressed);
+        }
         return issues.filter((issue) => !ignoreChecks.has(issue.check));
     }
     return issues;

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

@@ -5,7 +5,7 @@
  * is an implementation detail.
  */
 export { rebuildPatchesManifest, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';
-export { addPatchToManifest, loadPatchesManifest, loadPatchesManifestForWrite, mutatePatchRowsInManifest, PATCHES_MANIFEST, type PatchManifestRowMutation, type PatchManifestRowMutationResult, type PatchRenameEntry, removePatchFileAndManifest, renumberPatchesInManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from './patch-manifest-io.js';
+export { addPatchToManifest, loadPatchesManifest, loadPatchesManifestForWrite, mutatePatchRowsInManifest, PATCHES_MANIFEST, type PatchRenameEntry, removePatchFileAndManifest, renumberPatchesInManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from './patch-manifest-io.js';
 export { checkVersionCompatibility, findPatchesAffectingFile, getClaimedFiles, stampPatchVersions, validatePatchIntegrity, } from './patch-manifest-query.js';
 export { resolvePatchIdentifier } from './patch-manifest-resolve.js';
 export { validatePatchesManifest } from './patch-manifest-validate.js';

package/dist/src/core/smoke-patterns.d.ts

@@ -22,24 +22,40 @@ export declare const SMOKE_ERROR_PATTERNS: readonly RegExp[];
 /**
  * Returns `true` when `line` matches any pattern in
  * {@link SMOKE_ERROR_PATTERNS}. Does not consult the allowlist — that step
- * lives in {@link matchesAllowlist}, so the smoke runner can count
+ * lives in {@link matchAllowlist}, so the smoke runner can count
  * allowlisted hits separately from raw error matches for its summary.
  */
 export declare function matchesSmokeError(line: string): boolean;
 /**
- * Returns `true` when `line` matches any regex in `allow`. Safe to call
- * with an empty allowlist (always returns `false`).
+ * One compiled allowlist entry with its provenance retained so the smoke
+ * summary can attribute hits per entry (FORGE G8) — an entry that silently
+ * stops matching (its suppressed shape changed upstream) is only
+ * detectable when zero-hit entries are visible.
  */
-export declare function matchesAllowlist(line: string, allow: readonly RegExp[]): boolean;
+export interface CompiledAllowlistEntry {
+    pattern: RegExp;
+    /** Verbatim source text of the entry. */
+    source: string;
+    /** Human-readable origin: `allow.txt:12` or `--console-allow #2`. */
+    origin: string;
+}
+/**
+ * Returns the index of the FIRST entry in `allow` matching `line`, or -1.
+ * First-match attribution is deterministic and cheap; a line matching
+ * several entries credits the earliest one. Safe to call with an empty
+ * allowlist (always returns -1).
+ */
+export declare function matchAllowlist(line: string, allow: readonly CompiledAllowlistEntry[]): number;
 /**
  * Parses a newline-delimited allowlist file body. Lines are trimmed; blank
  * lines and `#`-prefixed comments are skipped. Each remaining line is
- * compiled as a RegExp. A bad pattern throws immediately — better to fail
- * fast at CLI parse time than to silently let a typo match nothing.
+ * compiled as a RegExp with its `<file>:<line>` origin retained. A bad
+ * pattern throws immediately — better to fail fast at CLI parse time than
+ * to silently let a typo match nothing.
  */
-export declare function compileAllowlistFromFile(body: string, sourcePath: string): RegExp[];
+export declare function compileAllowlistFromFile(body: string, sourcePath: string): CompiledAllowlistEntry[];
 /**
  * Compiles an array of regex-string inputs (e.g. repeated `--console-allow`
  * flag values). Same fail-fast semantics as {@link compileAllowlistFromFile}.
  */
-export declare function compileAllowlistFromStrings(sources: readonly string[]): RegExp[];
+export declare function compileAllowlistFromStrings(sources: readonly string[]): CompiledAllowlistEntry[];

package/dist/src/core/smoke-patterns.js

@@ -32,7 +32,7 @@ export const SMOKE_ERROR_PATTERNS = [
 /**
  * Returns `true` when `line` matches any pattern in
  * {@link SMOKE_ERROR_PATTERNS}. Does not consult the allowlist — that step
- * lives in {@link matchesAllowlist}, so the smoke runner can count
+ * lives in {@link matchAllowlist}, so the smoke runner can count
  * allowlisted hits separately from raw error matches for its summary.
  */
 export function matchesSmokeError(line) {
@@ -44,22 +44,25 @@ export function matchesSmokeError(line) {
     return false;
 }
 /**
- * Returns `true` when `line` matches any regex in `allow`. Safe to call
- * with an empty allowlist (always returns `false`).
+ * Returns the index of the FIRST entry in `allow` matching `line`, or -1.
+ * First-match attribution is deterministic and cheap; a line matching
+ * several entries credits the earliest one. Safe to call with an empty
+ * allowlist (always returns -1).
  */
-export function matchesAllowlist(line, allow) {
-    for (const pattern of allow) {
-        if (pattern.test(line)) {
-            return true;
+export function matchAllowlist(line, allow) {
+    for (let i = 0; i < allow.length; i++) {
+        if (allow[i]?.pattern.test(line)) {
+            return i;
         }
     }
-    return false;
+    return -1;
 }
 /**
  * Parses a newline-delimited allowlist file body. Lines are trimmed; blank
  * lines and `#`-prefixed comments are skipped. Each remaining line is
- * compiled as a RegExp. A bad pattern throws immediately — better to fail
- * fast at CLI parse time than to silently let a typo match nothing.
+ * compiled as a RegExp with its `<file>:<line>` origin retained. A bad
+ * pattern throws immediately — better to fail fast at CLI parse time than
+ * to silently let a typo match nothing.
  */
 export function compileAllowlistFromFile(body, sourcePath) {
     const lines = body.split(/\r?\n/);
@@ -69,7 +72,11 @@ export function compileAllowlistFromFile(body, sourcePath) {
         if (!line || line.startsWith('#'))
             return;
         try {
-            compiled.push(new RegExp(line));
+            compiled.push({
+                pattern: new RegExp(line),
+                source: line,
+                origin: `${sourcePath}:${String(index + 1)}`,
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -88,7 +95,11 @@ export function compileAllowlistFromStrings(sources) {
     const compiled = [];
     sources.forEach((source, index) => {
         try {
-            compiled.push(new RegExp(source));
+            compiled.push({
+                pattern: new RegExp(source),
+                source,
+                origin: `--console-allow #${String(index + 1)}`,
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);

package/dist/src/core/status-classify.d.ts

@@ -49,6 +49,14 @@ export interface ClassifiedFile extends StatusFile {
      * single claim is fully captured by the classification itself.
      */
     claimedBy?: string[];
+    /**
+     * Owning patch filename when exactly one patch claims this path
+     * (patch-backed, patch-owned-drift, and single-owner furnace entries).
+     * Unset for unowned, branding-generated, unowned-furnace, and conflict
+     * entries — conflicts carry `claimedBy` instead. Exposed through
+     * `status --json` as the `patch` field (FORGE G11).
+     */
+    owner?: string;
 }
 /**
  * Builds the file → owning-patch-filenames multimap from manifest rows.
@@ -66,6 +74,14 @@ export declare function buildPatchClaims(manifestPatches: ReadonlyArray<{
  * Single source of truth — status-output.ts renders from the same logic.
  */
 export declare function getPrimaryStatusCode(status: string): string;
+/**
+ * True for the branding paths whose content FireForge generates itself
+ * (configure.sh, brand.properties/ftl, browser/moz.configure). Unlike the
+ * broader branding-root test, a brand-new unowned file under the branding
+ * directory is NOT generated — it is a patch candidate and must stay
+ * visible as unmanaged (the Assets.car precedent).
+ */
+export declare function isGeneratedBrandingPath(file: string, binaryName: string): boolean;
 /**
  * Classifies files into patch-backed, unmanaged, branding, furnace, or
  * conflict buckets.