@hominis/fireforge 0.49.2 → 0.51.0

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

@@ -0,0 +1,429 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * `PatchMetadata.lintIgnore` entries and the waiver filter they drive.
+ *
+ * An entry is either a bare check ID, which suppresses that rule at any
+ * size, or a ceiling `{ rule, max, reason }`, which suppresses a size rule
+ * only while its measurement is at or below `max`. The bare form let a
+ * waived file grow without bound: nothing re-examined the waiver once it
+ * was written, so a 950-line file waived at review time was still waived at
+ * 2,000 lines. The ceiling makes growth past the reviewed size fire again,
+ * and lets a gate say when the waiver is no longer needed at all.
+ *
+ * Its own module so every caller that turns a manifest list into a filter
+ * (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.
+ */
+/**
+ * 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
+ * suppress anything, so the manifest validator refuses it.
+ */
+export const LINT_IGNORE_CEILING_RULES = [
+    'file-too-large',
+    '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';
+}
+/** The check ID an entry names, whatever its form. */
+export function lintIgnoreRule(entry) {
+    return isLintIgnoreCeiling(entry) ? entry.rule : entry;
+}
+/**
+ * One-word rendering for summaries and dry runs: `file-too-large<=1200`,
+ * `large-patch-lines[test]<=900`.
+ */
+export function formatLintIgnoreEntry(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) {
+    return entries.length > 0 ? entries.map(formatLintIgnoreEntry).join(', ') : '(empty)';
+}
+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 &&
+        a.share === b.share &&
+        JSON.stringify(a.meta) === JSON.stringify(b.meta));
+}
+/**
+ * Validates a raw `lintIgnore` value from `patches.json`.
+ *
+ * Bare strings keep their historical leniency (any ID, duplicates collapse
+ * later). A ceiling must name a measured size rule, carry a positive
+ * 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`
+ * @returns The validated entries
+ * @throws Error naming the offending element
+ */
+export function parseLintIgnoreEntries(raw, label) {
+    if (!Array.isArray(raw)) {
+        throw new Error(`${label} must be an array`);
+    }
+    const entries = [];
+    const ceilingRules = new Set();
+    for (const [index, item] of raw.entries()) {
+        const itemLabel = `${label}[${String(index)}]`;
+        if (typeof item === 'string') {
+            entries.push(item);
+            continue;
+        }
+        entries.push(parseCeiling(item, itemLabel));
+    }
+    const sharedRules = new Set();
+    for (const entry of entries) {
+        if (!isLintIgnoreCeiling(entry))
+            continue;
+        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(key);
+        if (entry.share !== undefined)
+            sharedRules.add(entry.rule);
+    }
+    return entries;
+}
+function parseCeiling(item, label) {
+    if (item === null || typeof item !== 'object' || Array.isArray(item)) {
+        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) => !CEILING_KEYS.has(key));
+    if (unknownKeys.length > 0) {
+        throw new Error(`${label} has unknown field(s): ${unknownKeys.join(', ')}`);
+    }
+    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(', ')}`);
+    }
+    if (typeof max !== 'number' || !Number.isInteger(max) || max <= 0) {
+        throw new Error(`${label}.max must be a positive integer`);
+    }
+    if (typeof reason !== 'string' || reason.trim() === '') {
+        throw new Error(`${label}.reason must be a non-empty string`);
+    }
+    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.
+ *
+ * @param entries - `PatchMetadata.lintIgnore`, possibly merged with CLI flags
+ * @returns The filter, or undefined when there is nothing to waive
+ */
+export function buildLintIgnoreChecks(entries) {
+    if (entries === undefined || entries.length === 0)
+        return undefined;
+    const plain = new Set();
+    const ceilings = new Map();
+    for (const entry of entries) {
+        if (isLintIgnoreCeiling(entry))
+            ceilings.set(ceilingKey(entry.rule, entry.share), entry);
+        else
+            plain.add(entry);
+    }
+    return ceilings.size > 0 ? Object.assign(plain, { ceilings }) : plain;
+}
+/**
+ * Canonical string form of a filter for the per-patch lint cache's waiver
+ * comparison: bare IDs as themselves, ceilings as `rule<=max`.
+ */
+export function lintIgnoreCacheTokens(checks) {
+    if (checks === undefined)
+        return [];
+    const ceilings = [...(checks.ceilings?.values() ?? [])].map(formatLintIgnoreEntry);
+    return [...checks, ...ceilings];
+}
+/**
+ * Unions CLI-flag check IDs into an existing list, the append-only
+ * 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. 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 blocked = isLintIgnoreCeiling(entry) ? keys.has(entryKey(entry)) : rules.has(entry);
+        if (blocked)
+            continue;
+        keys.add(entryKey(entry));
+        rules.add(lintIgnoreRule(entry));
+        merged.push(entry);
+    }
+    return merged.length > 0 ? merged : undefined;
+}
+/**
+ * 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) {
+    let next = [...existing];
+    for (const addition of additions) {
+        const rule = lintIgnoreRule(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);
+}
+/** Removes every entry naming one of `rules`. Undefined when nothing is left. */
+export function removeLintIgnoreRules(existing, rules) {
+    const drop = new Set(rules);
+    const remaining = existing.filter((entry) => !drop.has(lintIgnoreRule(entry)));
+    return remaining.length > 0 ? remaining : undefined;
+}
+/** Entries present in `after` but not (identically) in `before`. */
+export function addedLintIgnoreEntries(before, after) {
+    return after.filter((entry) => !before.some((prior) => sameEntry(prior, entry)));
+}
+/**
+ * Splits issues into the ones that still surface and the ones a waiver
+ * drops.
+ *
+ * A bare ID drops every finding of its rule. A ceiling drops a finding only
+ * when it carries a measurement at or below `max`. Past the ceiling the
+ * finding surfaces at its own severity with the ceiling named, and a
+ * finding with no measurement surfaces too (fail closed).
+ */
+export function partitionLintIgnoredIssues(issues, checks) {
+    const kept = [];
+    const suppressed = [];
+    for (const issue of issues) {
+        if (checks?.has(issue.check) === true) {
+            suppressed.push(issue);
+            continue;
+        }
+        const ceiling = ceilingFor(issue, checks);
+        if (ceiling === undefined) {
+            kept.push(issue);
+            continue;
+        }
+        if (issue.measurement !== undefined && issue.measurement <= ceiling.max) {
+            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) {
+    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}). */
+export function isLintIgnored(issue, checks) {
+    return partitionLintIgnoredIssues([issue], checks).suppressed.length === 1;
+}
+/**
+ * Drops issues that a patch owning `issue.file` (via `filesAffected`)
+ * waives. Used where findings carry no patch scope of their own (aggregate
+ * `lint`). Each owner keeps its own filter, so a ceiling stays bounded by
+ * the patch that declared it instead of merging into a file-wide union; an
+ * issue is dropped when any owner waives it.
+ */
+export function filterLintIgnoredByOwners(issues, owners) {
+    const byFile = new Map();
+    for (const owner of owners) {
+        const checks = buildLintIgnoreChecks(owner?.lintIgnore);
+        if (!checks)
+            continue;
+        for (const file of owner?.filesAffected ?? []) {
+            byFile.set(file, [...(byFile.get(file) ?? []), checks]);
+        }
+    }
+    if (byFile.size === 0)
+        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).
+ *
+ * @param entries - The patch's `lintIgnore`
+ * @param issues - Every finding of the patch's lint, surfaced and suppressed
+ * @param patchMeasurements - Patch-level measurements used when a
+ *   patch-size rule did not fire at all, so the report still shows the
+ *   current number
+ */
+export function evaluateLintIgnoreCeilings(entries, issues, patchMeasurements) {
+    const statuses = [];
+    for (const entry of entries ?? []) {
+        if (!isLintIgnoreCeiling(entry))
+            continue;
+        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
+ * discovered by hand.
+ */
+export function removableCeilingIssues(patchFilename, statuses) {
+    return 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)}${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-thresholds.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The patch-size thresholds (`large-patch-lines`, `large-patch-files`) and
+ * their merge with `patchLint.patchSizeThresholds`.
+ *
+ * Its own dependency-free module for the same reason as
+ * `patch-lint-file-size.ts`: the config validator checks an override
+ * against the merged result, and importing the rule bodies from config
+ * parsing would draw an import cycle.
+ */
+import type { PatchLintPatchSizeThresholds } from '../types/config.js';
+import type { ResolvedFileSizeTier } from './patch-lint-file-size.js';
+/** The tiers a patch is measured against. */
+export type PatchSizeTierName = 'general' | 'test' | 'branding';
+/**
+ * A resolved `large-patch-files` triple. `error` is `null` when no error
+ * band is configured. `notice` equal to `warning` means no notice band.
+ */
+export interface ResolvedPatchFilesTier {
+    notice: number;
+    warning: number;
+    error: number | null;
+}
+/** Line and file-count thresholds governing one patch-size tier. */
+export interface PatchSizeThresholds {
+    /** Line counts at which `large-patch-lines` notice/warning/error issues fire. */
+    lines: ResolvedFileSizeTier;
+    /** File counts at which `large-patch-files` notice/warning/error issues fire. */
+    files: ResolvedPatchFilesTier;
+    /**
+     * The `files.warning` threshold, kept for consumers written before the
+     * files triple existed.
+     */
+    maxFiles: number;
+}
+/**
+ * Merges the configured overrides over the defaults for one tier.
+ *
+ * @param tier - The tier to resolve
+ * @param overrides - The `patchLint.patchSizeThresholds` block, if any
+ * @returns The effective thresholds
+ */
+export declare function resolvePatchSizeThresholds(tier: PatchSizeTierName, overrides: PatchLintPatchSizeThresholds | undefined): PatchSizeThresholds;
+/**
+ * True when `file` matches one of the `patchLint.patchSizeRegistrationFiles`
+ * globs. A glob without `/` matches the basename, one with `/` the whole
+ * engine-relative path. `*` and `?` stay within a segment, `**` crosses
+ * segments.
+ *
+ * @param file - Engine-relative POSIX path
+ * @param globs - The configured globs
+ */
+export declare function isPatchSizeRegistrationFile(file: string, globs: readonly string[]): boolean;

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

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * The patch-size thresholds (`large-patch-lines`, `large-patch-files`) and
+ * their merge with `patchLint.patchSizeThresholds`.
+ *
+ * Its own dependency-free module for the same reason as
+ * `patch-lint-file-size.ts`: the config validator checks an override
+ * against the merged result, and importing the rule bodies from config
+ * parsing would draw an import cycle.
+ */
+import { escapeRegex } from '../utils/regex.js';
+/**
+ * Built-in line-count bands per tier.
+ *
+ * Branding patches have a legitimate reason to be large: they include
+ * every locale's `brand.ftl`, copied upstream CSS/PNG assets, and the
+ * fork-specific `configure.sh` / `brand.properties` under a single
+ * `browser/branding/<name>/` subtree. The tier is calibrated against a
+ * fresh-fork branding export, which lands around 15-16k lines (localized
+ * brand.ftl across many locales + SVG path data + copied upstream CSS).
+ * That is the minimum branding diff, so it must surface as a `notice`
+ * rather than a `warning`: the warning band sits above it with ~13%
+ * headroom, and the error band at roughly 2× the baseline, where
+ * non-branding work is probably bundled in.
+ *
+ * Permissive thresholds are safe because the *gate* into this tier is
+ * narrow: auto-detect requires every file under `browser/branding/` plus a
+ * tight registration allowlist, or an explicit `PatchMetadata.tier:
+ * "branding"` opt-in. A non-branding patch cannot accidentally land here.
+ */
+const DEFAULT_PATCH_LINE_THRESHOLDS = {
+    general: { notice: 800, warning: 1500, error: 3000 },
+    test: { notice: 1500, warning: 3000, error: 6000 },
+    branding: { notice: 8000, warning: 18000, error: 30000 },
+};
+/**
+ * Built-in `large-patch-files` warning band per tier. There is no notice or
+ * error band by default: file count expresses scope, not blast radius.
+ *
+ * The branding tier sits well above the typical floor because branding
+ * patches inherently span many files: PNG/ICO icon assets in 7+ sizes, MSIX
+ * manifests, channel-specific configs, locale `.ftl` files, Windows/macOS
+ * launcher resources. A fresh-fork branding bundle is around 56 files, so 60
+ * leaves headroom for additional channels/locales while still firing on a
+ * genuinely bloated patch. The test tier matches general because a
+ * test-only patch rarely touches many files.
+ */
+const DEFAULT_PATCH_FILES_WARNING = {
+    general: 5,
+    test: 5,
+    branding: 60,
+};
+/**
+ * Merges the configured overrides over the defaults for one tier.
+ *
+ * @param tier - The tier to resolve
+ * @param overrides - The `patchLint.patchSizeThresholds` block, if any
+ * @returns The effective thresholds
+ */
+export function resolvePatchSizeThresholds(tier, overrides) {
+    const configured = overrides?.[tier];
+    const lines = { ...DEFAULT_PATCH_LINE_THRESHOLDS[tier], ...configured?.lines };
+    const files = resolveFilesTier(DEFAULT_PATCH_FILES_WARNING[tier], configured?.files);
+    return { lines, files, maxFiles: files.warning };
+}
+function resolveFilesTier(defaultWarning, configured) {
+    const warning = configured?.warning ?? defaultWarning;
+    return {
+        notice: configured?.notice ?? warning,
+        warning,
+        error: configured?.error ?? null,
+    };
+}
+/**
+ * True when `file` matches one of the `patchLint.patchSizeRegistrationFiles`
+ * globs. A glob without `/` matches the basename, one with `/` the whole
+ * engine-relative path. `*` and `?` stay within a segment, `**` crosses
+ * segments.
+ *
+ * @param file - Engine-relative POSIX path
+ * @param globs - The configured globs
+ */
+export function isPatchSizeRegistrationFile(file, globs) {
+    if (globs.length === 0)
+        return false;
+    const basename = file.slice(file.lastIndexOf('/') + 1);
+    return globs.some((glob) => globToRegExp(glob).test(glob.includes('/') ? file : basename));
+}
+function globToRegExp(glob) {
+    let source = '';
+    for (let i = 0; i < glob.length; i++) {
+        const char = glob.charAt(i);
+        if (char === '*' && glob.charAt(i + 1) === '*') {
+            // `**/` matches zero or more whole segments, a bare `**` anything.
+            const slash = glob.charAt(i + 2) === '/';
+            source += slash ? '(?:.*/)?' : '.*';
+            i += slash ? 2 : 1;
+        }
+        else if (char === '*') {
+            source += '[^/]*';
+        }
+        else if (char === '?') {
+            source += '[^/]';
+        }
+        else {
+            source += escapeRegex(char);
+        }
+    }
+    return new RegExp(`^${source}$`);
+}