@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/build-audit-registration.js

@@ -1,181 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/*
- * Registration-aware artifact resolution for the post-build dist-tree audit.
- *
- * The basename-plus-similarity heuristic in `build-audit-resolve.ts` cannot
- * distinguish two unrelated files that share a source basename: one fork
- * registers `content/mybrowser.js` in `browser/base/jar.mn` (packaged under
- * `chrome/browser/content/browser/mybrowser.js`) while an unrelated patch
- * registers a `mybrowser.js` pref file under `browser/defaults/preferences/`.
- * The basename walker surfaces both, `scoreCandidate` awards them an equal
- * trailing-overlap score, and whichever the directory walk hits first wins.
- *
- * This module anchors resolution to the `(source)` reference inside `jar.mn`.
- * For a source under audit it walks the ancestor directories for an owning
- * `jar.mn`, finds the entry whose `(source)` resolves to that path, and
- * exposes both the registered target and the manifest that owns it. Callers
- * prefer candidates whose dist-tree path ends with the registered target and
- * report an unambiguous "registered but not packaged" miss when none exists.
- *
- * When no jar.mn registration is found, the caller falls back to the
- * similarity heuristic, which covers sources registered through moz.build
- * (`FINAL_TARGET_FILES`, `JS_PREFERENCE_FILES`) or `package-manifest.in`.
- * Parsing every Firefox registration surface would bloat the audit, and the
- * heuristic's weak case is surfaced to the operator in the warning copy.
- */
-import { basename, dirname, join, relative, sep } from 'node:path';
-import { pathExists, readText } from '../utils/fs.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { findAllByBasename } from './build-audit-resolve.js';
-/** Ceiling on ancestor-directory hops when searching for an owning jar.mn. */
-const MAX_JAR_MN_SCAN_DEPTH = 8;
-/**
- * Parses a single jar.mn line into `{ target, source }` when the line is a
- * content entry with an explicit `(source)` reference. Returns undefined
- * for comments, headers (`browser.jar:`), `%` manifest directives, blank
- * lines, and entries without a source reference.
- *
- * Accepted entry shapes:
- *   `        content/browser/foo.js     (content/foo.js)`   bare
- *   `*       content/browser/foo.js     (content/foo.js)`   `*` = preprocessed
- *   `en-US.jar:        content/foo.js  (content/foo.js)`    locale-prefixed
- */
-export function parseJarMnEntry(line) {
-    if (!line)
-        return undefined;
-    const trimmed = line.trim();
-    if (trimmed === '' || trimmed.startsWith('#') || trimmed.startsWith('%'))
-        return undefined;
-    // Leading `*` (preprocessed) and optional `locale.jar:` prefix are dropped
-    // before matching the target/(source) pair. Both are whitespace-separated
-    // from the target entry.
-    const stripped = trimmed.replace(/^\*\s+/, '').replace(/^[A-Za-z0-9.\-_]+\.jar:\s+/, '');
-    const match = /^(\S+)\s+\(([^)]+)\)\s*$/.exec(stripped);
-    if (!match)
-        return undefined;
-    const target = (match[1] ?? '').trim();
-    const source = (match[2] ?? '').trim();
-    if (!target || !source)
-        return undefined;
-    return { target, source };
-}
-/**
- * Scans a jar.mn file's contents for an entry whose source reference
- * matches `relativeSource` (POSIX, relative to the jar.mn directory).
- * Returns the first match. jar.mn enforces uniqueness of `(source)` in
- * practice, so a first-match wins behaviour is adequate.
- */
-export function findJarMnEntryForSource(content, relativeSource) {
-    const normalized = normalizePathSlashes(relativeSource);
-    for (const line of content.split('\n')) {
-        const parsed = parseJarMnEntry(line);
-        if (!parsed)
-            continue;
-        if (parsed.source === normalized)
-            return parsed;
-    }
-    return undefined;
-}
-/**
- * Walks from the source's directory upward to the engine root, returning
- * the first jar.mn entry that registers the given source. Returns undefined
- * when no ancestor jar.mn claims the source.
- *
- * @param engineDir Absolute engine root. The walk halts here.
- * @param source Engine-relative POSIX source path.
- */
-export async function findRegisteredTarget(engineDir, source) {
-    const sourceAbs = join(engineDir, source);
-    const root = engineDir.replace(/[/\\]+$/, '');
-    let current = dirname(sourceAbs);
-    let depth = 0;
-    while (depth <= MAX_JAR_MN_SCAN_DEPTH &&
-        (current === root || current.startsWith(`${root}/`) || current.startsWith(`${root}\\`))) {
-        const jarMn = join(current, 'jar.mn');
-        if (await pathExists(jarMn)) {
-            let content;
-            try {
-                content = await readText(jarMn);
-            }
-            catch {
-                // An unreadable jar.mn contributes no registration hints. The resolver falls
-                // through to its other strategies.
-                content = '';
-            }
-            const rel = relative(current, sourceAbs).split(sep).join('/');
-            const entry = findJarMnEntryForSource(content, rel);
-            if (entry) {
-                return { target: entry.target, source: entry.source, jarManifest: jarMn };
-            }
-        }
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-        depth += 1;
-    }
-    return undefined;
-}
-/**
- * Normalises an absolute filesystem path to POSIX separators so the
- * suffix comparison against a jar.mn target (always POSIX) is platform-
- * independent.
- */
-function toPosix(path) {
-    return normalizePathSlashes(path);
-}
-/**
- * Probes the dist tree for the artifact registered against the given
- * source. Returns the matched candidate and the registration hit that
- * anchored it. Undefined when the source has no owning jar.mn or when
- * no same-basename candidate under the search roots ends with the
- * registered target path.
- *
- * Suffix-matching against the target path is intentional: jar.mn targets
- * are relative to the jar root (`browser.jar:`, `toolkit.jar:`), but the
- * dist tree prefixes every entry with a jar-specific directory
- * (`.../chrome/browser/content/browser/…`). The source basename plus the
- * target suffix are unambiguous across every packaging convention we
- * care about.
- *
- * @param engineDir Absolute engine root.
- * @param source Engine-relative POSIX source path.
- * @param searchRoots Absolute roots to probe (dist/, _tests/).
- */
-export async function resolveArtifactByRegistration(engineDir, source, searchRoots) {
-    const hit = await findRegisteredTarget(engineDir, source);
-    if (!hit)
-        return undefined;
-    const name = basename(source);
-    const targetSuffix = `/${hit.target.replace(/^\/+/, '')}`;
-    const candidates = [];
-    for (const root of searchRoots) {
-        const found = await findAllByBasename(root, name);
-        candidates.push(...found);
-    }
-    for (const candidate of candidates) {
-        if (toPosix(candidate).endsWith(targetSuffix)) {
-            return { artifact: candidate, hit };
-        }
-    }
-    return undefined;
-}
-/**
- * Returns the absolute paths of every same-basename candidate under the
- * given search roots. Used by the audit to enumerate all false-match
- * candidates when the heuristic fallback downgrades to "missing". The
- * operator needs to see the full set, not just the scorer's pick, to
- * distinguish a registration bug from a genuine packaging drop.
- *
- * @param source Engine-relative POSIX source path.
- * @param searchRoots Absolute roots to scan.
- */
-export async function collectSameBasenameCandidates(source, searchRoots) {
-    const name = basename(source);
-    const out = [];
-    for (const root of searchRoots) {
-        const found = await findAllByBasename(root, name);
-        out.push(...found);
-    }
-    return out;
-}

package/dist/src/core/build-audit-resolve.d.ts

@@ -1,78 +0,0 @@
-/**
- * Heuristic test for "this looks like a packaged-test source file". The
- * audit routes such paths to `_tests/` instead of `dist/`. Matches
- * mochitest / xpcshell / browser-chrome conventions: any source under a
- * `/test/` or `/tests/` directory, anywhere under a `testing/` subtree
- * (which holds mochitest / marionette / xpcshell harness sources), or
- * with a `browser_` / `test_` prefix on a `.js`/`.toml` basename. Test
- * manifests (`*.toml`, `*.list`, `*.ini`) under those directories also
- * qualify.
- *
- * @param sourcePath Engine-relative POSIX path
- * @returns True when the file belongs to the test tree, not the bundle
- */
-export declare function isTestPath(sourcePath: string): boolean;
-/**
- * Counts how many trailing segments two paths share. Used to score
- * candidate dist artifacts against a source path so that
- * `branding/<name>/content/aboutDialog.css` prefers a candidate at
- * `…/content/branding/aboutDialog.css` over one at
- * `…/content/browser/aboutDialog.css`.
- *
- * @param a First path
- * @param b Second path
- * @returns Count of matching trailing segments (basename always counts as 1)
- */
-export declare function countTrailingSegmentMatches(a: string, b: string): number;
-/**
- * Path segments too common to identify an artifact on their own.
- *
- * Shared on purpose: this set governs two halves of one decision,
- * `scoreCandidate` (selection) and `isConfidentMatch` (confirmation, in
- * `build-audit.ts`). Separate copies would disagree, so a source path
- * could earn a selection bonus for a segment that confirmation then
- * rejected as meaningless, leaving the chosen artifact unconfirmable. One
- * set makes every addition apply to both halves.
- */
-export declare const GENERIC_PATH_SEGMENTS: ReadonlySet<string>;
-/**
- * Computes a score for `candidatePath` relative to `sourcePath`. Higher
- * scores win. Score = trailing-segment match count, with a bonus when the
- * candidate's path contains a meaningful intermediate segment from the
- * source (e.g. `branding`, or the branding dir name itself).
- *
- * The bonus exists because Firefox packaging often re-roots files: a source
- * `branding/<name>/content/aboutDialog.css` lands at
- * `chrome/browser/content/branding/aboutDialog.css`. Only the basename
- * trails-match, but the `branding` segment moved into the middle of the
- * candidate path. Without the bonus that candidate ties with the unrelated
- * `chrome/browser/content/browser/aboutDialog.css`.
- *
- * @param sourcePath Engine-relative POSIX path
- * @param candidatePath Absolute path under the dist tree
- * @returns Numeric score, where higher means better match
- */
-export declare function scoreCandidate(sourcePath: string, candidatePath: string): number;
-/**
- * Walks a tree under `root` and returns every file whose basename equals
- * `name`. Skips dotfile / hidden directories so the symlinked
- * `.mozbuild` cache (a full upstream copy) does not dominate the scan
- * on macOS.
- *
- * @param root Tree root to search
- * @param name Basename to match
- * @param maxDepth Optional traversal cap (default 12)
- * @returns All matching absolute paths
- */
-export declare function findAllByBasename(root: string, name: string, maxDepth?: number): Promise<string[]>;
-/**
- * Resolves the best-matching artifact for a source path under one or
- * more search roots. Returns the highest-scoring candidate by trailing
- * segment overlap. Ties go to the first-found path (deterministic via
- * the directory-walk order). Returns undefined when no candidate exists.
- *
- * @param sourcePath Engine-relative POSIX source path
- * @param searchRoots Absolute roots to scan (e.g. dist/, _tests/)
- * @returns Best-matching artifact path, or undefined
- */
-export declare function resolveBestArtifact(sourcePath: string, searchRoots: readonly string[]): Promise<string | undefined>;

package/dist/src/core/build-audit-resolve.js

@@ -1,240 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/*
- * Path-resolution helpers for the post-build dist-tree audit.
- *
- * Resolves the expected on-disk artifact location for a given engine source
- * path. Matching purely by basename produces three classes of false
- * positive, each of which these helpers exist to avoid:
- *
- *   1. A branding override (`engine/browser/branding/<name>/content/
- *      aboutDialog.css`, shipped at `chrome/browser/content/branding/
- *      aboutDialog.css`) matching the unrelated upstream
- *      `chrome/browser/content/browser/aboutDialog.css`. Handled by ranking
- *      same-basename candidates on shared trailing path segments.
- *   2. Test files (`browser_*.js`, `test_*.js`) living under `_tests/`, not
- *      `dist/`. Handled by routing test paths to a separate resolver.
- *   3. Build inputs (`jar.mn`, `moz.build`, `Makefile.in`, `moz.configure`)
- *      that are consumed rather than packaged. Handled in `build-audit.ts`
- *      via `isPackageablePath`.
- */
-import { readdir } from 'node:fs/promises';
-import { basename, join } from 'node:path';
-import { pathExists } from '../utils/fs.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-/** Maximum directory depth to traverse when scanning a tree root. */
-const MAX_SCAN_DEPTH = 12;
-/**
- * Heuristic test for "this looks like a packaged-test source file". The
- * audit routes such paths to `_tests/` instead of `dist/`. Matches
- * mochitest / xpcshell / browser-chrome conventions: any source under a
- * `/test/` or `/tests/` directory, anywhere under a `testing/` subtree
- * (which holds mochitest / marionette / xpcshell harness sources), or
- * with a `browser_` / `test_` prefix on a `.js`/`.toml` basename. Test
- * manifests (`*.toml`, `*.list`, `*.ini`) under those directories also
- * qualify.
- *
- * @param sourcePath Engine-relative POSIX path
- * @returns True when the file belongs to the test tree, not the bundle
- */
-export function isTestPath(sourcePath) {
-    if (sourcePath.includes('/test/') || sourcePath.includes('/tests/')) {
-        return true;
-    }
-    // `testing/{mochitest,marionette,xpcshell,...}` are test-infrastructure
-    // trees that ship under `_tests/`, not `dist/`. Match both as a root
-    // segment (e.g. `testing/mochitest/api.js`) and as an interior segment
-    // (e.g. a vendored harness under `third_party/.../testing/...`).
-    if (sourcePath.startsWith('testing/') || sourcePath.includes('/testing/')) {
-        return true;
-    }
-    const name = basename(sourcePath);
-    if (/^browser_.+\.(js|toml|ini)$/.test(name))
-        return true;
-    if (/^test_.+\.(js|toml|ini)$/.test(name))
-        return true;
-    return false;
-}
-/**
- * Splits a path into segments, dropping empties.
- *
- * Separators are normalized first because the candidates come from `join()`
- * over a `readdir` walk of the dist tree: on Windows those carry backslashes,
- * which a `/`-only split collapses into a single segment. Every candidate then
- * scores the same, so the trailing-overlap heuristic that disambiguates
- * same-basename artifacts (`branding/…/aboutDialog.css` versus
- * `browser/…/aboutDialog.css`) silently picks an arbitrary one.
- *
- * @param path Path in either separator style
- */
-function pathSegments(path) {
-    return normalizePathSlashes(path).split('/').filter(Boolean);
-}
-/**
- * Counts how many trailing segments two paths share. Used to score
- * candidate dist artifacts against a source path so that
- * `branding/<name>/content/aboutDialog.css` prefers a candidate at
- * `…/content/branding/aboutDialog.css` over one at
- * `…/content/browser/aboutDialog.css`.
- *
- * @param a First path
- * @param b Second path
- * @returns Count of matching trailing segments (basename always counts as 1)
- */
-export function countTrailingSegmentMatches(a, b) {
-    const aSegs = pathSegments(a);
-    const bSegs = pathSegments(b);
-    let matches = 0;
-    while (matches < aSegs.length &&
-        matches < bSegs.length &&
-        aSegs[aSegs.length - 1 - matches] === bSegs[bSegs.length - 1 - matches]) {
-        matches += 1;
-    }
-    return matches;
-}
-/**
- * Path segments too common to identify an artifact on their own.
- *
- * Shared on purpose: this set governs two halves of one decision,
- * `scoreCandidate` (selection) and `isConfidentMatch` (confirmation, in
- * `build-audit.ts`). Separate copies would disagree, so a source path
- * could earn a selection bonus for a segment that confirmation then
- * rejected as meaningless, leaving the chosen artifact unconfirmable. One
- * set makes every addition apply to both halves.
- */
-export const GENERIC_PATH_SEGMENTS = new Set([
-    'content',
-    'chrome',
-    'bin',
-    'browser',
-    'toolkit',
-    'modules',
-    'base',
-    'app',
-    'profile',
-    'shared',
-    'themes',
-    'test',
-    'tests',
-    'unit',
-    'common',
-    'xpcshell',
-    'mochitest',
-]);
-/**
- * Computes a score for `candidatePath` relative to `sourcePath`. Higher
- * scores win. Score = trailing-segment match count, with a bonus when the
- * candidate's path contains a meaningful intermediate segment from the
- * source (e.g. `branding`, or the branding dir name itself).
- *
- * The bonus exists because Firefox packaging often re-roots files: a source
- * `branding/<name>/content/aboutDialog.css` lands at
- * `chrome/browser/content/branding/aboutDialog.css`. Only the basename
- * trails-match, but the `branding` segment moved into the middle of the
- * candidate path. Without the bonus that candidate ties with the unrelated
- * `chrome/browser/content/browser/aboutDialog.css`.
- *
- * @param sourcePath Engine-relative POSIX path
- * @param candidatePath Absolute path under the dist tree
- * @returns Numeric score, where higher means better match
- */
-export function scoreCandidate(sourcePath, candidatePath) {
-    const trailing = countTrailingSegmentMatches(sourcePath, candidatePath);
-    const sourceSegs = pathSegments(sourcePath);
-    const candSegs = pathSegments(candidatePath);
-    // Look for source segments that appear anywhere in the candidate path
-    // but are not part of the trailing match. Each unique mid-path hit on
-    // a meaningful (>2-char, not generic like 'content'/'chrome'/'bin')
-    // segment adds 1 to the score.
-    const generic = GENERIC_PATH_SEGMENTS;
-    const trailingSet = new Set(sourceSegs.slice(sourceSegs.length - trailing));
-    let bonus = 0;
-    for (const seg of sourceSegs) {
-        if (seg.length <= 2)
-            continue;
-        if (generic.has(seg))
-            continue;
-        if (trailingSet.has(seg))
-            continue;
-        if (candSegs.includes(seg))
-            bonus += 1;
-    }
-    return trailing * 10 + bonus;
-}
-/**
- * Walks a tree under `root` and returns every file whose basename equals
- * `name`. Skips dotfile / hidden directories so the symlinked
- * `.mozbuild` cache (a full upstream copy) does not dominate the scan
- * on macOS.
- *
- * @param root Tree root to search
- * @param name Basename to match
- * @param maxDepth Optional traversal cap (default 12)
- * @returns All matching absolute paths
- */
-export async function findAllByBasename(root, name, maxDepth = MAX_SCAN_DEPTH) {
-    const results = [];
-    if (!(await pathExists(root)))
-        return results;
-    const stack = [{ dir: root, depth: 0 }];
-    while (stack.length > 0) {
-        const entry = stack.pop();
-        if (!entry)
-            break;
-        if (entry.depth > maxDepth)
-            continue;
-        let children;
-        try {
-            children = await readdir(entry.dir, { withFileTypes: true });
-        }
-        catch {
-            // An unreadable subdirectory yields no candidates. Skip it and keep
-            // scoring the rest rather than abandoning the whole resolution.
-            continue;
-        }
-        for (const child of children) {
-            const fullPath = join(entry.dir, child.name);
-            if (child.isDirectory()) {
-                if (child.name.startsWith('.'))
-                    continue;
-                stack.push({ dir: fullPath, depth: entry.depth + 1 });
-                continue;
-            }
-            if (child.name === name) {
-                results.push(fullPath);
-            }
-        }
-    }
-    return results;
-}
-/**
- * Resolves the best-matching artifact for a source path under one or
- * more search roots. Returns the highest-scoring candidate by trailing
- * segment overlap. Ties go to the first-found path (deterministic via
- * the directory-walk order). Returns undefined when no candidate exists.
- *
- * @param sourcePath Engine-relative POSIX source path
- * @param searchRoots Absolute roots to scan (e.g. dist/, _tests/)
- * @returns Best-matching artifact path, or undefined
- */
-export async function resolveBestArtifact(sourcePath, searchRoots) {
-    const name = basename(sourcePath);
-    const allCandidates = [];
-    for (const root of searchRoots) {
-        const found = await findAllByBasename(root, name);
-        allCandidates.push(...found);
-    }
-    if (allCandidates.length === 0)
-        return undefined;
-    if (allCandidates.length === 1)
-        return allCandidates[0];
-    let bestScore = -1;
-    let best;
-    for (const candidate of allCandidates) {
-        const score = scoreCandidate(sourcePath, candidate);
-        if (score > bestScore) {
-            bestScore = score;
-            best = candidate;
-        }
-    }
-    return best;
-}

package/dist/src/core/build-audit-skip.d.ts

@@ -1,57 +0,0 @@
-/**
- * Why a changed engine path was not audited.
- *
- * Each reason is structured so summaries and machine output can count
- * skips by cause instead of reading verbose log strings.
- */
-export type AuditSkipReason = 'not-packageable' | 'platform-gated' | 'platform-gated-ancestor' | 'tests-not-packaged' | 'source-unreadable' | 'branding-not-selected' | 'storybook-story' | 'declared-unpackaged';
-/** Render order for the `Packaged:` summary's per-class breakdown. */
-export declare const AUDIT_SKIP_REASONS: readonly AuditSkipReason[];
-/** True for a Storybook story module. */
-export declare function isStorybookStoryPath(sourcePath: string): boolean;
-/**
- * Reads the branding directory this objdir was configured with.
- *
- * FireForge generates `engine/mozconfig` and writes the
- * `ac_add_options --with-branding=…` line into it, so the selected branding
- * is knowable from the tree. Returns undefined when the mozconfig cannot be
- * read or carries no directive. The caller must then keep warning, because
- * a skip that cannot name its evidence is a masked warning.
- *
- * @param engineDir - Absolute path to the engine root
- * @returns Engine-relative branding path, or undefined
- */
-export declare function resolveSelectedBranding(engineDir: string): Promise<string | undefined>;
-/**
- * True when `sourcePath` lives under a branding tree that is not the one
- * this objdir was configured with.
- *
- * An unselected branding directory is not an input to this build at all, so
- * its files can never appear in `dist/`. Worse, the basename walker matched
- * them against the selected branding's same-named artifact and reported the
- * unselected file as "newer than its packaged artifact", a stale warning
- * about a comparison that has no meaning.
- *
- * @param sourcePath - Engine-relative POSIX path
- * @param selectedBranding - Engine-relative selected branding path
- */
-export declare function isUnselectedBrandingPath(sourcePath: string, selectedBranding: string | undefined): boolean;
-/** One `buildAudit.unpackaged` carve-out from `fireforge.json`. */
-export interface UnpackagedDeclaration {
-    /** Engine-relative path or glob. */
-    path: string;
-    /** Why this file is deliberately never packaged. Required, non-empty. */
-    reason: string;
-}
-/**
- * Finds the declaration admitting `sourcePath`, if any.
- *
- * Exact match or a `*`-within-one-segment glob, matching the
- * `support-files` matcher's narrowness: `**` and other cross-directory
- * shapes are not accepted, because a carve-out that silently widens is the
- * failure this feature is warned against.
- *
- * @param sourcePath - Engine-relative POSIX path
- * @param declarations - The project's `buildAudit.unpackaged` entries
- */
-export declare function matchUnpackagedDeclaration(sourcePath: string, declarations: readonly UnpackagedDeclaration[]): UnpackagedDeclaration | undefined;

package/dist/src/core/build-audit-skip.js

@@ -1,112 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Skip classification for the post-build packaging audit.
- *
- * The audit is warn-only, which makes a false positive cheap individually
- * and expensive in aggregate: an operator who learns that `Audit:` lines are
- * usually wrong stops reading the one that is right. Every classifier here
- * exists to remove a warning whose "missing packaged artifact" claim is
- * structurally impossible, and each carries its own reason so the
- * `Packaged:` summary can say what it skipped and why. This replaces a run
- * reporting `4 missing` with zero real misses.
- */
-import { readText } from '../utils/fs.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { escapeRegex } from '../utils/regex.js';
-import { extractWithBrandingPath } from './mach-mozconfig.js';
-/** Render order for the `Packaged:` summary's per-class breakdown. */
-export const AUDIT_SKIP_REASONS = [
-    'not-packageable',
-    'platform-gated',
-    'platform-gated-ancestor',
-    'tests-not-packaged',
-    'source-unreadable',
-    'branding-not-selected',
-    'storybook-story',
-    'declared-unpackaged',
-];
-/**
- * Suffixes of Storybook story modules.
- *
- * Firefox's in-tree Storybook renders these through its own Vite config.
- * No `jar.mn` or `moz.build` entry packages one, so "no packaged artifact"
- * is the expected state rather than a missing registration. Kept as a
- * closed list on purpose: generalising to "anything with a dotted infix"
- * would swallow `*.worker.js` and `*.sys.mjs`, which are packaged.
- */
-const STORYBOOK_SUFFIXES = ['.stories.mjs', '.stories.js'];
-/** True for a Storybook story module. */
-export function isStorybookStoryPath(sourcePath) {
-    const normalised = normalizePathSlashes(sourcePath);
-    return STORYBOOK_SUFFIXES.some((suffix) => normalised.endsWith(suffix));
-}
-/** Prefix under which every branding tree lives. */
-const BRANDING_ROOT = 'browser/branding/';
-/**
- * Reads the branding directory this objdir was configured with.
- *
- * FireForge generates `engine/mozconfig` and writes the
- * `ac_add_options --with-branding=…` line into it, so the selected branding
- * is knowable from the tree. Returns undefined when the mozconfig cannot be
- * read or carries no directive. The caller must then keep warning, because
- * a skip that cannot name its evidence is a masked warning.
- *
- * @param engineDir - Absolute path to the engine root
- * @returns Engine-relative branding path, or undefined
- */
-export async function resolveSelectedBranding(engineDir) {
-    try {
-        const content = await readText(`${engineDir.replace(/[/\\]+$/, '')}/mozconfig`);
-        const selected = extractWithBrandingPath(content);
-        return selected === undefined ? undefined : normalizePathSlashes(selected).replace(/\/+$/, '');
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * True when `sourcePath` lives under a branding tree that is not the one
- * this objdir was configured with.
- *
- * An unselected branding directory is not an input to this build at all, so
- * its files can never appear in `dist/`. Worse, the basename walker matched
- * them against the selected branding's same-named artifact and reported the
- * unselected file as "newer than its packaged artifact", a stale warning
- * about a comparison that has no meaning.
- *
- * @param sourcePath - Engine-relative POSIX path
- * @param selectedBranding - Engine-relative selected branding path
- */
-export function isUnselectedBrandingPath(sourcePath, selectedBranding) {
-    if (selectedBranding === undefined)
-        return false;
-    const normalised = normalizePathSlashes(sourcePath);
-    if (!normalised.startsWith(BRANDING_ROOT))
-        return false;
-    const selected = `${selectedBranding}/`;
-    return !normalised.startsWith(selected);
-}
-/**
- * Finds the declaration admitting `sourcePath`, if any.
- *
- * Exact match or a `*`-within-one-segment glob, matching the
- * `support-files` matcher's narrowness: `**` and other cross-directory
- * shapes are not accepted, because a carve-out that silently widens is the
- * failure this feature is warned against.
- *
- * @param sourcePath - Engine-relative POSIX path
- * @param declarations - The project's `buildAudit.unpackaged` entries
- */
-export function matchUnpackagedDeclaration(sourcePath, declarations) {
-    const normalised = normalizePathSlashes(sourcePath);
-    return declarations.find((declaration) => {
-        const pattern = normalizePathSlashes(declaration.path);
-        if (!pattern.includes('*'))
-            return pattern === normalised;
-        const regex = new RegExp(`^${pattern
-            .split('*')
-            .map((part) => escapeRegex(part))
-            .join('[^/]*')}$`);
-        return regex.test(normalised);
-    });
-}