@hominis/fireforge 0.50.0 → 0.51.0

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

@@ -43,16 +43,20 @@ async function loadCssTokenContext(repoDir) {
  * matching how a CSS parser treats it.
  */
 export 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'));
+    // Linear indexOf scan rather than a lazy `/\*[\s\S]*?\*\/` regex: with
+    // many openers and no closer, the regex retries from every `/*` to EOF
+    // (quadratic in file size).
+    let masked = '';
+    let cursor = 0;
+    for (;;) {
+        const open = source.indexOf('/*', cursor);
+        if (open === -1)
+            return masked + source.slice(cursor);
+        const close = source.indexOf('*/', open + 2);
+        const end = close === -1 ? source.length : close + 2;
+        masked += source.slice(cursor, open) + source.slice(open, end).replace(/[^\n]/g, ' ');
+        cursor = end;
+    }
 }
 const RAW_COLOR_IGNORE_MARKER = 'fireforge-ignore: raw-color-value';
 /**

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

@@ -24,6 +24,11 @@ export interface ForwardRegistration {
     /** Paste-and-run declaration that records the stage as intentional. */
     command: string;
 }
+/**
+ * jar target → packaged source, over every jar.mn line the queue adds. Only
+ * exact (wildcard-free) sources can back a chrome URL lookup.
+ */
+export declare function buildJarTargetIndex(entries: readonly PatchQueueForwardRegistrationEntry[]): Map<string, string>;
 /** True for a jar.mn, moz.build or test manifest, the carriers {@link resolveCarrierReferences} reads. */
 export declare function isRegistrationCarrier(file: string): boolean;
 /**

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

@@ -116,7 +116,7 @@ function testManifestReferences(file, content) {
  * jar target → packaged source, over every jar.mn line the queue adds. Only
  * exact (wildcard-free) sources can back a chrome URL lookup.
  */
-function buildJarTargetIndex(entries) {
+export function buildJarTargetIndex(entries) {
     const index = new Map();
     for (const entry of entries) {
         for (const [file, content] of [...entry.newFiles, ...entry.modifiedFileAdditions]) {

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

@@ -13,7 +13,7 @@
  * (export, re-export, per-patch and aggregate lint, split, move-files)
  * shares one reading of an entry, and so `patch-lint.ts` only calls into it.
  */
-import type { LintIgnoreCeiling, LintIgnoreEntry, PatchLintIssue } from '../types/commands/index.js';
+import type { LintIgnoreCeiling, LintIgnoreEntry, PatchLintIssue, PatchSizeShare } from '../types/commands/index.js';
 /**
  * The size rules whose findings carry a `measurement`, and therefore the
  * only rules a ceiling can bound. A ceiling on any other rule could never
@@ -22,7 +22,7 @@ import type { LintIgnoreCeiling, LintIgnoreEntry, PatchLintIssue } from '../type
 export declare const LINT_IGNORE_CEILING_RULES: readonly string[];
 /**
  * A waiver filter: the bare check IDs as a set (so a plain `Set<string>`
- * still satisfies the type), plus the ceilings keyed by rule.
+ * still satisfies the type), plus the ceilings keyed by {@link ceilingKey}.
  *
  * Bare IDs and ceilings are kept apart on purpose. A caller that only knows
  * `has()` treats a ceiling-waived rule as not waived, which fails closed.
@@ -34,7 +34,10 @@ export type LintIgnoreChecks = ReadonlySet<string> & {
 export declare function isLintIgnoreCeiling(entry: LintIgnoreEntry): entry is LintIgnoreCeiling;
 /** The check ID an entry names, whatever its form. */
 export declare function lintIgnoreRule(entry: LintIgnoreEntry): string;
-/** One-word rendering for summaries and dry runs: `file-too-large<=1200`. */
+/**
+ * One-word rendering for summaries and dry runs: `file-too-large<=1200`,
+ * `large-patch-lines[test]<=900`.
+ */
 export declare function formatLintIgnoreEntry(entry: LintIgnoreEntry): string;
 /** Renders a list for messages, `(empty)` when there is nothing to show. */
 export declare function formatLintIgnoreList(entries: readonly LintIgnoreEntry[]): string;
@@ -46,6 +49,9 @@ export declare function formatLintIgnoreList(entries: readonly LintIgnoreEntry[]
  * integer `max` and a non-empty `reason`, and must be the only entry for
  * its rule: a bare ID beside a ceiling for the same rule would make the
  * ceiling dead, and two ceilings would leave the effective one ambiguous.
+ * The one exception is `large-patch-lines`, which may carry one ceiling
+ * per `share` instead of a single share-less one. `meta` must be a JSON
+ * object and is kept verbatim.
  *
  * @param raw - The value under `lintIgnore`
  * @param label - Field label for error messages, e.g. `patches[3].lintIgnore`
@@ -70,15 +76,18 @@ export declare function lintIgnoreCacheTokens(checks: LintIgnoreChecks | undefin
  * semantics `export` / `re-export --lint-ignore` have always had. A bare ID
  * whose rule already has an entry (bare or ceiling) is a no-op: widening a
  * reviewed ceiling to an unbounded waiver is `patch lint-ignore`'s job, where
- * it is confirmed explicitly.
+ * it is confirmed explicitly. Ceilings deduplicate by rule and share, so a
+ * rule's per-share ceilings all survive.
  *
  * @returns The merged list, or undefined when it is empty
  */
 export declare function mergeLintIgnoreIds(existing: readonly LintIgnoreEntry[] | undefined, ids: readonly string[] | undefined): LintIgnoreEntry[] | undefined;
 /**
- * Adds or replaces entries by rule, the `patch lint-ignore --add` semantics:
- * an explicit `--add <rule>` turns a ceiling into a bare waiver, and
- * `--add <rule> --max <n>` sets or moves the ceiling.
+ * Adds or replaces entries, the `patch lint-ignore --add` semantics: an
+ * explicit `--add <rule>` turns a rule's ceilings into a bare waiver,
+ * `--add <rule> --max <n>` sets or moves the rule's ceiling, and a
+ * share-scoped ceiling replaces only its own share (plus any bare or
+ * share-less entry for the rule, which it would contradict).
  *
  * @returns The new list, or undefined when it is empty
  */
@@ -120,16 +129,43 @@ export interface LintIgnoreCeilingStatus {
     rule: string;
     max: number;
     reason: string;
+    /** The share the ceiling bounds, when it is share-scoped. */
+    share?: PatchSizeShare;
+    /** The ceiling's `meta`, verbatim, when it has one. */
+    meta?: Record<string, unknown>;
     /** Largest current measurement for the rule, null when none was taken. */
     measurement: number | null;
     /**
-     * `exceeded`: a finding measured past `max` and surfaced.
+     * `exceeded`: a warning- or error-band finding measured past `max` and
+     * surfaced. A notice never exceeds a ceiling: it gates nothing.
      * `removable`: the rule no longer reaches its own warning band, so the
      * waiver changes no gate and can be dropped.
      * `within`: the waiver is doing its job.
      */
     state: LintIgnoreCeilingState;
 }
+/**
+ * One waiver's standing, bare or ceiling, as the report's
+ * `lintIgnoreWaivers` records it. A bare waiver has `max: null`; its
+ * `state` is `within` while the rule still finds something to suppress at
+ * warning band or above, and `removable` otherwise (informational: a bare
+ * waiver of a rule this lint does not run reads as removable too).
+ */
+export interface LintIgnoreWaiverStatus {
+    kind: 'bare' | 'ceiling';
+    rule: string;
+    max: number | null;
+    reason: string | null;
+    share?: PatchSizeShare;
+    meta?: Record<string, unknown>;
+    measurement: number | null;
+    state: LintIgnoreCeilingState;
+}
+/** Patch-level measurements a size rule falls back to when it did not fire. */
+interface PatchMeasurements {
+    lines: number;
+    files: number;
+}
 /**
  * Evaluates each ceiling on a patch against the findings its lint produced
  * (both surfaced and suppressed).
@@ -140,13 +176,21 @@ export interface LintIgnoreCeilingStatus {
  *   patch-size rule did not fire at all, so the report still shows the
  *   current number
  */
-export declare function evaluateLintIgnoreCeilings(entries: readonly LintIgnoreEntry[] | undefined, issues: readonly PatchLintIssue[], patchMeasurements: {
-    lines: number;
-    files: number;
-}): LintIgnoreCeilingStatus[];
+export declare function evaluateLintIgnoreCeilings(entries: readonly LintIgnoreEntry[] | undefined, issues: readonly PatchLintIssue[], patchMeasurements: PatchMeasurements): LintIgnoreCeilingStatus[];
+/**
+ * Evaluates every waiver on a patch, bare IDs included, so a waiver audit
+ * reads each one's current measurement from the report instead of
+ * re-measuring bare waivers from `suppressedIssues`.
+ *
+ * @param entries - The patch's `lintIgnore`
+ * @param issues - Every finding of the patch's lint, surfaced and suppressed
+ * @param patchMeasurements - See {@link evaluateLintIgnoreCeilings}
+ */
+export declare function evaluateLintIgnoreWaivers(entries: readonly LintIgnoreEntry[] | undefined, issues: readonly PatchLintIssue[], patchMeasurements: PatchMeasurements): LintIgnoreWaiverStatus[];
 /**
  * Notice-severity findings for ceilings that are no longer needed, so the
  * waiver's removal is prompted by the tool that enforces it rather than
  * discovered by hand.
  */
 export declare function removableCeilingIssues(patchFilename: string, statuses: readonly LintIgnoreCeilingStatus[]): PatchLintIssue[];
+export {};

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

@@ -24,6 +24,16 @@ export const LINT_IGNORE_CEILING_RULES = [
     'large-patch-lines',
     'large-patch-files',
 ];
+/** The only rule whose findings carry a {@link PatchSizeShare}. */
+const SHARE_RULE = 'large-patch-lines';
+const SHARES = ['product', 'test'];
+/**
+ * The key a ceiling is stored under: the rule, plus `#<share>` for a
+ * share-scoped ceiling, so one rule can carry a ceiling per share.
+ */
+function ceilingKey(rule, share) {
+    return share === undefined ? rule : `${rule}#${share}`;
+}
 /** Narrows an entry to the ceiling form. */
 export function isLintIgnoreCeiling(entry) {
     return typeof entry !== 'string';
@@ -32,9 +42,19 @@ export function isLintIgnoreCeiling(entry) {
 export function lintIgnoreRule(entry) {
     return isLintIgnoreCeiling(entry) ? entry.rule : entry;
 }
-/** One-word rendering for summaries and dry runs: `file-too-large<=1200`. */
+/**
+ * One-word rendering for summaries and dry runs: `file-too-large<=1200`,
+ * `large-patch-lines[test]<=900`.
+ */
 export function formatLintIgnoreEntry(entry) {
-    return isLintIgnoreCeiling(entry) ? `${entry.rule}<=${String(entry.max)}` : entry;
+    if (!isLintIgnoreCeiling(entry))
+        return entry;
+    const share = entry.share === undefined ? '' : `[${entry.share}]`;
+    return `${entry.rule}${share}<=${String(entry.max)}`;
+}
+/** The identity an entry is upserted and deduplicated by. */
+function entryKey(entry) {
+    return isLintIgnoreCeiling(entry) ? ceilingKey(entry.rule, entry.share) : entry;
 }
 /** Renders a list for messages, `(empty)` when there is nothing to show. */
 export function formatLintIgnoreList(entries) {
@@ -43,7 +63,11 @@ export function formatLintIgnoreList(entries) {
 function sameEntry(a, b) {
     if (!isLintIgnoreCeiling(a) || !isLintIgnoreCeiling(b))
         return a === b;
-    return a.rule === b.rule && a.max === b.max && a.reason === b.reason;
+    return (a.rule === b.rule &&
+        a.max === b.max &&
+        a.reason === b.reason &&
+        a.share === b.share &&
+        JSON.stringify(a.meta) === JSON.stringify(b.meta));
 }
 /**
  * Validates a raw `lintIgnore` value from `patches.json`.
@@ -53,6 +77,9 @@ function sameEntry(a, b) {
  * integer `max` and a non-empty `reason`, and must be the only entry for
  * its rule: a bare ID beside a ceiling for the same rule would make the
  * ceiling dead, and two ceilings would leave the effective one ambiguous.
+ * The one exception is `large-patch-lines`, which may carry one ceiling
+ * per `share` instead of a single share-less one. `meta` must be a JSON
+ * object and is kept verbatim.
  *
  * @param raw - The value under `lintIgnore`
  * @param label - Field label for error messages, e.g. `patches[3].lintIgnore`
@@ -73,13 +100,21 @@ export function parseLintIgnoreEntries(raw, label) {
         }
         entries.push(parseCeiling(item, itemLabel));
     }
+    const sharedRules = new Set();
     for (const entry of entries) {
         if (!isLintIgnoreCeiling(entry))
             continue;
-        if (ceilingRules.has(entry.rule) || entries.includes(entry.rule)) {
-            throw new Error(`${label} names "${entry.rule}" more than once; keep a single entry (bare or ceiling) per rule`);
+        const key = ceilingKey(entry.rule, entry.share);
+        const clash = ceilingRules.has(key) ||
+            entries.includes(entry.rule) ||
+            (entry.share === undefined ? sharedRules.has(entry.rule) : ceilingRules.has(entry.rule));
+        if (clash) {
+            throw new Error(`${label} names "${entry.rule}" more than once; keep a single entry (bare or ceiling) ` +
+                'per rule, or one ceiling per share');
         }
-        ceilingRules.add(entry.rule);
+        ceilingRules.add(key);
+        if (entry.share !== undefined)
+            sharedRules.add(entry.rule);
     }
     return entries;
 }
@@ -88,11 +123,11 @@ function parseCeiling(item, label) {
         throw new Error(`${label} must be a check ID string or a { rule, max, reason } object`);
     }
     const record = item;
-    const unknownKeys = Object.keys(record).filter((key) => key !== 'rule' && key !== 'max' && key !== 'reason');
+    const unknownKeys = Object.keys(record).filter((key) => !CEILING_KEYS.has(key));
     if (unknownKeys.length > 0) {
         throw new Error(`${label} has unknown field(s): ${unknownKeys.join(', ')}`);
     }
-    const { rule, max, reason } = record;
+    const { rule, max, reason, share, meta } = record;
     if (typeof rule !== 'string' || !LINT_IGNORE_CEILING_RULES.includes(rule)) {
         throw new Error(`${label}.rule must be one of the measured size rules: ${LINT_IGNORE_CEILING_RULES.join(', ')}`);
     }
@@ -102,8 +137,22 @@ function parseCeiling(item, label) {
     if (typeof reason !== 'string' || reason.trim() === '') {
         throw new Error(`${label}.reason must be a non-empty string`);
     }
-    return { rule, max, reason };
+    const ceiling = { rule, max, reason };
+    if (share !== undefined) {
+        if (rule !== SHARE_RULE || !SHARES.includes(share)) {
+            throw new Error(`${label}.share must be "product" or "test", and only on ${SHARE_RULE}`);
+        }
+        ceiling.share = share;
+    }
+    if (meta !== undefined) {
+        if (meta === null || typeof meta !== 'object' || Array.isArray(meta)) {
+            throw new Error(`${label}.meta must be a JSON object`);
+        }
+        ceiling.meta = meta;
+    }
+    return ceiling;
 }
+const CEILING_KEYS = new Set(['rule', 'max', 'reason', 'share', 'meta']);
 /**
  * Builds the waiver filter for a patch's entries.
  *
@@ -117,7 +166,7 @@ export function buildLintIgnoreChecks(entries) {
     const ceilings = new Map();
     for (const entry of entries) {
         if (isLintIgnoreCeiling(entry))
-            ceilings.set(entry.rule, entry);
+            ceilings.set(ceilingKey(entry.rule, entry.share), entry);
         else
             plain.add(entry);
     }
@@ -138,38 +187,52 @@ export function lintIgnoreCacheTokens(checks) {
  * semantics `export` / `re-export --lint-ignore` have always had. A bare ID
  * whose rule already has an entry (bare or ceiling) is a no-op: widening a
  * reviewed ceiling to an unbounded waiver is `patch lint-ignore`'s job, where
- * it is confirmed explicitly.
+ * it is confirmed explicitly. Ceilings deduplicate by rule and share, so a
+ * rule's per-share ceilings all survive.
  *
  * @returns The merged list, or undefined when it is empty
  */
 export function mergeLintIgnoreIds(existing, ids) {
     const merged = [];
+    const keys = new Set();
     const rules = new Set();
     for (const entry of [...(existing ?? []), ...(ids ?? [])]) {
-        const rule = lintIgnoreRule(entry);
-        if (rules.has(rule))
+        const blocked = isLintIgnoreCeiling(entry) ? keys.has(entryKey(entry)) : rules.has(entry);
+        if (blocked)
             continue;
-        rules.add(rule);
+        keys.add(entryKey(entry));
+        rules.add(lintIgnoreRule(entry));
         merged.push(entry);
     }
     return merged.length > 0 ? merged : undefined;
 }
 /**
- * Adds or replaces entries by rule, the `patch lint-ignore --add` semantics:
- * an explicit `--add <rule>` turns a ceiling into a bare waiver, and
- * `--add <rule> --max <n>` sets or moves the ceiling.
+ * Adds or replaces entries, the `patch lint-ignore --add` semantics: an
+ * explicit `--add <rule>` turns a rule's ceilings into a bare waiver,
+ * `--add <rule> --max <n>` sets or moves the rule's ceiling, and a
+ * share-scoped ceiling replaces only its own share (plus any bare or
+ * share-less entry for the rule, which it would contradict).
  *
  * @returns The new list, or undefined when it is empty
  */
 export function upsertLintIgnoreEntries(existing, additions) {
-    const next = [...existing];
+    let next = [...existing];
     for (const addition of additions) {
         const rule = lintIgnoreRule(addition);
-        const index = next.findIndex((entry) => lintIgnoreRule(entry) === rule);
-        if (index === -1)
-            next.push(addition);
-        else
-            next[index] = addition;
+        const scoped = isLintIgnoreCeiling(addition) && addition.share !== undefined;
+        const replaced = (entry) => lintIgnoreRule(entry) === rule &&
+            (!scoped ||
+                !isLintIgnoreCeiling(entry) ||
+                entry.share === undefined ||
+                entryKey(entry) === entryKey(addition));
+        const index = next.findIndex(replaced);
+        const kept = next.filter((entry) => !replaced(entry));
+        // The addition takes the first replaced entry's place, so a moved
+        // ceiling keeps its position in the list.
+        next =
+            index === -1
+                ? [...kept, addition]
+                : [...kept.slice(0, index), addition, ...kept.slice(index)];
     }
     return mergeLintIgnoreIds(next, undefined);
 }
@@ -200,7 +263,7 @@ export function partitionLintIgnoredIssues(issues, checks) {
             suppressed.push(issue);
             continue;
         }
-        const ceiling = checks?.ceilings?.get(issue.check);
+        const ceiling = ceilingFor(issue, checks);
         if (ceiling === undefined) {
             kept.push(issue);
             continue;
@@ -209,12 +272,31 @@ export function partitionLintIgnoredIssues(issues, checks) {
             suppressed.push(issue);
             continue;
         }
+        // A notice never gates, so a ceiling does not bound it: one past `max`
+        // surfaces as the plain notice it is, not as an exceeded waiver.
+        if (issue.severity === 'notice') {
+            kept.push(issue);
+            continue;
+        }
         kept.push({ ...issue, message: `${issue.message} ${describeExceededCeiling(ceiling)}` });
     }
     return { kept, suppressed };
 }
+/** The ceiling that governs `issue`: its share's, else the rule's share-less one. */
+function ceilingFor(issue, checks) {
+    const ceilings = checks?.ceilings;
+    if (ceilings === undefined)
+        return undefined;
+    if (issue.share !== undefined) {
+        const scoped = ceilings.get(ceilingKey(issue.check, issue.share));
+        if (scoped !== undefined)
+            return scoped;
+    }
+    return ceilings.get(issue.check);
+}
 function describeExceededCeiling(ceiling) {
-    return (`This exceeds the patch's lintIgnore ceiling for ${ceiling.rule} ` +
+    const share = ceiling.share === undefined ? '' : ` (${ceiling.share} share)`;
+    return (`This exceeds the patch's lintIgnore ceiling for ${ceiling.rule}${share} ` +
         `(max ${String(ceiling.max)}: ${ceiling.reason}).`);
 }
 /** True when `checks` waives `issue` (see {@link partitionLintIgnoredIssues}). */
@@ -242,6 +324,31 @@ export function filterLintIgnoredByOwners(issues, owners) {
         return issues;
     return issues.filter((issue) => !(byFile.get(issue.file) ?? []).some((checks) => isLintIgnored(issue, checks)));
 }
+function judgeWaiver(rule, max, share, issues, patchMeasurements) {
+    const findings = issues.filter((issue) => issue.check === rule && (share === undefined || issue.share === share));
+    const measured = findings
+        .map((issue) => issue.measurement)
+        .filter((value) => value !== undefined);
+    // A share-scoped ceiling has no patch-level fallback: the total counts
+    // both shares, which is not what it bounds.
+    const fallback = share !== undefined
+        ? null
+        : rule === 'large-patch-lines'
+            ? patchMeasurements.lines
+            : rule === 'large-patch-files'
+                ? patchMeasurements.files
+                : null;
+    const measurement = measured.length > 0 ? Math.max(...measured) : fallback;
+    const gating = findings.filter((issue) => issue.severity !== 'notice');
+    const exceeded = max !== null &&
+        gating.some((issue) => issue.measurement !== undefined && issue.measurement > max);
+    const state = exceeded
+        ? 'exceeded'
+        : gating.length > 0
+            ? 'within'
+            : 'removable';
+    return { measurement, state };
+}
 /**
  * Evaluates each ceiling on a patch against the findings its lint produced
  * (both surfaced and suppressed).
@@ -257,26 +364,48 @@ export function evaluateLintIgnoreCeilings(entries, issues, patchMeasurements) {
     for (const entry of entries ?? []) {
         if (!isLintIgnoreCeiling(entry))
             continue;
-        const findings = issues.filter((issue) => issue.check === entry.rule);
-        const measured = findings
-            .map((issue) => issue.measurement)
-            .filter((value) => value !== undefined);
-        const fallback = entry.rule === 'large-patch-lines'
-            ? patchMeasurements.lines
-            : entry.rule === 'large-patch-files'
-                ? patchMeasurements.files
-                : null;
-        const measurement = measured.length > 0 ? Math.max(...measured) : fallback;
-        const gating = findings.some((issue) => issue.severity !== 'notice');
-        const state = measured.some((value) => value > entry.max)
-            ? 'exceeded'
-            : gating
-                ? 'within'
-                : 'removable';
-        statuses.push({ rule: entry.rule, max: entry.max, reason: entry.reason, measurement, state });
+        statuses.push({
+            rule: entry.rule,
+            max: entry.max,
+            reason: entry.reason,
+            ...(entry.share !== undefined ? { share: entry.share } : {}),
+            ...(entry.meta !== undefined ? { meta: entry.meta } : {}),
+            ...judgeWaiver(entry.rule, entry.max, entry.share, issues, patchMeasurements),
+        });
     }
     return statuses;
 }
+/**
+ * Evaluates every waiver on a patch, bare IDs included, so a waiver audit
+ * reads each one's current measurement from the report instead of
+ * re-measuring bare waivers from `suppressedIssues`.
+ *
+ * @param entries - The patch's `lintIgnore`
+ * @param issues - Every finding of the patch's lint, surfaced and suppressed
+ * @param patchMeasurements - See {@link evaluateLintIgnoreCeilings}
+ */
+export function evaluateLintIgnoreWaivers(entries, issues, patchMeasurements) {
+    return (entries ?? []).map((entry) => {
+        if (!isLintIgnoreCeiling(entry)) {
+            return {
+                kind: 'bare',
+                rule: entry,
+                max: null,
+                reason: null,
+                ...judgeWaiver(entry, null, undefined, issues, patchMeasurements),
+            };
+        }
+        return {
+            kind: 'ceiling',
+            rule: entry.rule,
+            max: entry.max,
+            reason: entry.reason,
+            ...(entry.share !== undefined ? { share: entry.share } : {}),
+            ...(entry.meta !== undefined ? { meta: entry.meta } : {}),
+            ...judgeWaiver(entry.rule, entry.max, entry.share, issues, patchMeasurements),
+        };
+    });
+}
 /**
  * Notice-severity findings for ceilings that are no longer needed, so the
  * waiver's removal is prompted by the tool that enforces it rather than
@@ -287,10 +416,11 @@ export function removableCeilingIssues(patchFilename, statuses) {
         .filter((status) => status.state === 'removable')
         .map((status) => {
         const now = status.measurement === null ? 'below its notice band' : `at ${String(status.measurement)}`;
+        const share = status.share === undefined ? '' : `, ${status.share} share`;
         return {
             file: patchFilename,
             check: 'lint-ignore-removable',
-            message: `lintIgnore ceiling for ${status.rule} (max ${String(status.max)}) is no longer needed: ` +
+            message: `lintIgnore ceiling for ${status.rule} (max ${String(status.max)}${share}) is no longer needed: ` +
                 `the measurement is ${now}, under the rule's own warning threshold. ` +
                 `Remove it with "fireforge patch lint-ignore ${patchFilename} --remove ${status.rule}".`,
             severity: 'notice',

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

@@ -51,6 +51,16 @@ export declare function resolvePatchOwnedChromeScripts(currentNewFiles: Set<stri
  * `patch-lint-ownership.test.ts`.
  */
 export declare function isTestScriptFile(file: string): boolean;
+/**
+ * For each test script, the ES modules (`.mjs`, `.sys.mjs`) the queue
+ * creates up to and including the test's own patch: what its imports can
+ * resolve to in a per-test checkJs program. A test no patch touches sees
+ * every module the queue creates.
+ *
+ * @param patchQueueCtx - The queue, in apply order
+ * @returns Lookup from a test script path to its resolvable modules
+ */
+export declare function resolvableModulesForTests(patchQueueCtx: PatchQueueContext): (testFile: string) => ReadonlySet<string>;
 /**
  * Returns the set of patch-owned test `.js` files. Same
  * ownership semantics as {@link resolvePatchOwnedSysMjs}. Consumed by the

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

@@ -84,6 +84,32 @@ export function isTestScriptFile(file) {
     const basename = file.split('/').pop() ?? '';
     return /^(?:browser_|test_|xpcshell_).*\.js$/.test(basename);
 }
+/**
+ * For each test script, the ES modules (`.mjs`, `.sys.mjs`) the queue
+ * creates up to and including the test's own patch: what its imports can
+ * resolve to in a per-test checkJs program. A test no patch touches sees
+ * every module the queue creates.
+ *
+ * @param patchQueueCtx - The queue, in apply order
+ * @returns Lookup from a test script path to its resolvable modules
+ */
+export function resolvableModulesForTests(patchQueueCtx) {
+    const byTest = new Map();
+    const upTo = new Set();
+    for (const entry of patchQueueCtx.entries) {
+        for (const file of entry.newFiles.keys()) {
+            if (file.endsWith('.mjs') && !isTestScriptFile(file))
+                upTo.add(file);
+        }
+        const snapshot = new Set(upTo);
+        for (const file of [...entry.newFiles.keys(), ...entry.modifiedFileAdditions.keys()]) {
+            if (isTestScriptFile(file) && !byTest.has(file))
+                byTest.set(file, snapshot);
+        }
+    }
+    const all = upTo;
+    return (testFile) => byTest.get(testFile) ?? all;
+}
 /**
  * Returns the set of patch-owned test `.js` files. Same
  * ownership semantics as {@link resolvePatchOwnedSysMjs}. Consumed by the

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

@@ -248,19 +248,26 @@ function formatPatchSizeMessage(subject, band, thresholds) {
  */
 function lineChecks(measurement, tier, thresholds, config) {
     const perClass = measurement.metric === 'addedCode' && tier === 'general';
-    if (!perClass || measurement.testLines === 0) {
+    if (!perClass) {
         return [{ count: measurement.lines, thresholds: thresholds.lines, scope: '' }];
     }
+    if (measurement.testLines === 0) {
+        return [
+            { count: measurement.lines, thresholds: thresholds.lines, scope: '', share: 'product' },
+        ];
+    }
     return [
         {
             count: measurement.lines - measurement.testLines,
             thresholds: thresholds.lines,
             scope: ' in non-test files',
+            share: 'product',
         },
         {
             count: measurement.testLines,
             thresholds: getPatchSizeThresholds('test', config).lines,
             scope: ' in test files (test tier)',
+            share: 'test',
         },
     ];
 }
@@ -317,6 +324,7 @@ export function lintPatchSize(filesAffected, measured, patchTier, config) {
             message: formatPatchSizeMessage(subject, band, check.thresholds),
             severity: band,
             measurement: check.count,
+            ...(check.share !== undefined ? { share: check.share } : {}),
         });
     }
     return issues;