@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,373 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/*
- * Platform-gate detection for the post-build dist-tree audit.
- *
- * `moz.build` files commonly wrap entries in conditional blocks like
- * `if CONFIG["MAKENSISU"]:` (Windows-only stubinstaller) or
- * `if CONFIG["OS_TARGET"] == "Darwin":` (macOS-only artwork). On a host that
- * does not match the gate, the wrapped files are never processed by the
- * build, so they cannot appear under `dist/`. Without this detection the
- * audit warns about every gated file on every off-platform build.
- *
- * Two gate sources are consulted, in order:
- *   1. Python-style `if CONFIG[...]:` blocks in the owning `moz.build`.
- *   2. Path-convention gates: certain directory fragments are packaged by
- *      platform-specific Makefile.in / NSIS recipes that FireForge does not
- *      parse, so a file under `browser/installer/windows/` or any
- *      `/stubinstaller/` subtree is Windows-only regardless of what its
- *      nearest moz.build says.
- *
- * The detection is lightweight: walk up from the source file
- * to the closest `moz.build`, scan it for the source basename inside an
- * `if CONFIG[...]:` block, and check whether the gate matches the host. The
- * path-convention pass runs only when no moz.build gate is found, so an
- * explicit gate always wins.
- *
- * Best-effort. False negatives (missing a gate and warning anyway) are
- * tolerable because the audit is warn-only. False positives (skipping a file
- * that should ship on this host) are not tolerable, so it errs toward not
- * skipping when uncertain.
- */
-import { stat } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { pathExists, readText } from '../utils/fs.js';
-import { getPlatform } from '../utils/platform.js';
-import { escapeRegex } from '../utils/regex.js';
-/**
- * Tokens that uniquely identify a Windows-only `if CONFIG[...]:` block.
- * `MAKENSISU` is the Windows stubinstaller compiler. `OS_TARGET ==
- * "WINNT"` and `MOZ_WIDGET_TOOLKIT == "windows"` are the conventional
- * platform discriminators.
- */
-const WINDOWS_ONLY_GATE_TOKENS = ['MAKENSISU', '"WINNT"', "'WINNT'", '"windows"', "'windows'"];
-/** Tokens that mark a macOS-only `if CONFIG[...]:` block. */
-const DARWIN_ONLY_GATE_TOKENS = ['"Darwin"', "'Darwin'", '"cocoa"', "'cocoa'"];
-/** Tokens that mark a Linux-only `if CONFIG[...]:` block. */
-const LINUX_ONLY_GATE_TOKENS = ['"Linux"', "'Linux'", '"gtk"', "'gtk'"];
-/**
- * Returns true when the platform-gate expression includes one of the
- * tokens characteristic of a single OS that is not the current host.
- */
-function isGateOffHost(expression, host) {
-    const matchesWindows = WINDOWS_ONLY_GATE_TOKENS.some((t) => expression.includes(t));
-    const matchesDarwin = DARWIN_ONLY_GATE_TOKENS.some((t) => expression.includes(t));
-    const matchesLinux = LINUX_ONLY_GATE_TOKENS.some((t) => expression.includes(t));
-    // Negation gates (`!= "WINNT"`, `not CONFIG["MAKENSISU"]`) flip the
-    // semantics. Keep this conservative: if we cannot confidently parse
-    // a negation, return false so we don't wrongly suppress a warning.
-    const negated = /\bnot\b|!=/.test(expression);
-    if (negated)
-        return false;
-    if (matchesWindows && host !== 'win32')
-        return true;
-    if (matchesDarwin && host !== 'darwin')
-        return true;
-    if (matchesLinux && host !== 'linux')
-        return true;
-    return false;
-}
-/**
- * Walks from a starting directory up to (but not above) the engine root,
- * yielding the first `moz.build` encountered. Returns undefined when no
- * ancestor has one, typically only for files that live above any
- * moz.build entry point, which would not be packageable anyway.
- */
-async function findOwningMozBuild(engineDir, sourceDir) {
-    let current = sourceDir;
-    const root = engineDir.replace(/\/+$/, '');
-    while (current.startsWith(root)) {
-        const candidate = join(current, 'moz.build');
-        if (await pathExists(candidate))
-            return candidate;
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return undefined;
-}
-/**
- * Matches a `basename` appearing at the tail of a quoted path literal
- * on a single moz.build line. Catches both the bare entry
- * `"installing_page.css"` and the path-prefixed entry
- * `"stubinstaller/installing_page.css"`.
- */
-function matchesQuotedBasename(line, basename) {
-    const escaped = escapeRegex(basename);
-    return new RegExp(`["'](?:[^"']*\\/)?${escaped}["']`).test(line);
-}
-/**
- * Scans a moz.build file for a basename match inside a conditional
- * block, returning the gate expression when one encloses the match.
- *
- * The scanner uses indentation to track block scope (Python-style):
- * an `if CONFIG[…]:` line opens a scope at indent N+1, and dedenting
- * back to indent N closes it. A basename match inside that scope
- * inherits the gate expression.
- *
- * @param content moz.build file content
- * @param basename Basename of the source file we are auditing
- * @returns The enclosing gate expression, or undefined if none
- */
-export function findEnclosingGate(content, basename) {
-    const lines = content.split('\n');
-    const stack = [];
-    for (const line of lines) {
-        if (line.trim() === '')
-            continue;
-        const indent = (/^(\s*)/.exec(line)?.[1] ?? '').length;
-        while (stack.length > 0) {
-            const top = stack[stack.length - 1];
-            if (top && indent <= top.indent) {
-                stack.pop();
-                continue;
-            }
-            break;
-        }
-        const ifMatch = /^\s*if\s+(.+?):\s*(?:#.*)?$/.exec(line);
-        if (ifMatch?.[1]) {
-            stack.push({ indent, expression: ifMatch[1] });
-            continue;
-        }
-        if (matchesQuotedBasename(line, basename)) {
-            const top = stack[stack.length - 1];
-            if (top)
-                return top.expression;
-            return undefined;
-        }
-    }
-    return undefined;
-}
-/**
- * Path-convention gates: directories whose files are packaged by
- * platform-specific build recipes (NSIS stub installer, DMG creation, Linux
- * installer scripts) that live outside the moz.build graph. A file under any
- * of these fragments is platform-restricted regardless of what its nearest
- * `moz.build` says.
- *
- * `stubinstaller/` is the Windows NSIS stub installer asset tree, referenced
- * from `browser/installer/windows/Makefile.in` and `nsis/stub.nsh` rather
- * than through any `if CONFIG[…]:` block an ancestor moz.build exposes.
- */
-const PATH_GATES = [
-    { fragment: '/stubinstaller/', platform: 'win32', label: 'path convention: /stubinstaller/' },
-    {
-        fragment: '/browser/installer/windows/',
-        platform: 'win32',
-        label: 'path convention: browser/installer/windows/',
-    },
-    {
-        fragment: '/browser/installer/macosx/',
-        platform: 'darwin',
-        label: 'path convention: browser/installer/macosx/',
-    },
-    {
-        fragment: '/browser/installer/linux/',
-        platform: 'linux',
-        label: 'path convention: browser/installer/linux/',
-    },
-];
-/**
- * Returns a path-convention gate for `sourcePath` when one applies.
- * Leading slash added so `startsWith`-style prefix traps
- * (`browser/installer/windows/…`) match whether or not the input
- * starts with a separator.
- */
-function findPathConventionGate(sourcePath) {
-    const normalised = `/${sourcePath}`.replace(/\/+/g, '/');
-    for (const entry of PATH_GATES) {
-        if (normalised.includes(entry.fragment)) {
-            return { platform: entry.platform, label: entry.label };
-        }
-    }
-    return undefined;
-}
-/**
- * Determines whether the given source file is gated off on the current
- * host by an enclosing `if CONFIG[...]:` block in its owning moz.build,
- * or by a path-convention rule for installer-tree subdirectories that
- * are packaged via Makefile.in recipes the audit does not parse.
- * Returns `gatedOff: false` and no expression when no gate is found. The
- * file is not platform-restricted, so the caller should audit it
- * normally.
- *
- * @param engineDir Absolute path to the engine root
- * @param sourcePath Engine-relative POSIX path of the source file
- * @returns Detection result
- */
-export async function detectPlatformGate(engineDir, sourcePath) {
-    let host;
-    try {
-        host = getPlatform();
-    }
-    catch {
-        // Unrecognised host platform. The platform gates below are advisory, so an
-        // unknown host disables them rather than failing a warn-only audit.
-        host = undefined;
-    }
-    const sourceDir = dirname(join(engineDir, sourcePath));
-    const mozBuild = await findOwningMozBuild(engineDir, sourceDir);
-    if (mozBuild) {
-        let content;
-        try {
-            content = await readText(mozBuild);
-        }
-        catch {
-            // An unreadable moz.build contributes no platform gates. The audit is
-            // warn-only, so a missing input degrades to 'no gate found', not an error.
-            content = '';
-        }
-        const sourceBasename = sourcePath.split('/').pop() ?? '';
-        const expression = findEnclosingGate(content, sourceBasename);
-        if (expression) {
-            if (host && isGateOffHost(expression, host)) {
-                return { gatedOff: true, gateExpression: expression };
-            }
-            return { gatedOff: false, gateExpression: expression };
-        }
-    }
-    const pathGate = findPathConventionGate(sourcePath);
-    if (pathGate && host && host !== pathGate.platform) {
-        return { gatedOff: true, gateExpression: pathGate.label };
-    }
-    return { gatedOff: false };
-}
-/**
- * Maximum ancestor levels walked looking for a gating `DIRS` entry, and the
- * largest `moz.build` read while doing it. The audit runs on every build, so
- * a pathological tree must not be able to make it slow. Beyond these bounds
- * the walk gives up and the caller keeps today's behaviour (warn).
- */
-const MAX_ANCESTOR_DEPTH = 12;
-const MAX_MOZ_BUILD_BYTES = 256 * 1024;
-/** Matches a line that begins a `DIRS` assignment. */
-const DIRS_ASSIGNMENT_PATTERN = /^\s*DIRS\s*\+?=/;
-/**
- * Collects the full stack of `if CONFIG[…]:` expressions enclosing the
- * `DIRS` entry whose value equals `relDir`.
- *
- * Two differences from {@link findEnclosingGate}, both load-bearing here:
- * only quoted values inside a `DIRS` assignment are considered (an
- * unrelated string literal elsewhere in the file must not gate a
- * directory), and every enclosing expression is returned rather than the
- * innermost. Firefox nests these: `toolkit/moz.build` reaches
- * `mozapps/defaultagent` inside `OS_ARCH == "WINNT"`, then a `CC_TYPE`
- * test, then `MOZ_DEFAULT_BROWSER_AGENT`, and it is the outermost one that
- * excludes the directory on a macOS host.
- *
- * @param content - `moz.build` file content
- * @param relDir - Directory path relative to the `moz.build`, POSIX-separated
- * @returns Enclosing gate expressions, outermost first. Empty when ungated
- *   or when no `DIRS` entry reaches `relDir`
- */
-function findDirsEntryGates(content, relDir) {
-    const lines = content.split('\n');
-    const stack = [];
-    let inDirs = false;
-    for (const line of lines) {
-        if (line.trim() === '')
-            continue;
-        const indent = (/^(\s*)/.exec(line)?.[1] ?? '').length;
-        while (stack.length > 0) {
-            const top = stack[stack.length - 1];
-            if (top && indent <= top.indent) {
-                stack.pop();
-                continue;
-            }
-            break;
-        }
-        const ifMatch = /^\s*if\s+(.+?):\s*(?:#.*)?$/.exec(line);
-        if (ifMatch?.[1]) {
-            stack.push({ indent, expression: ifMatch[1] });
-            inDirs = false;
-            continue;
-        }
-        if (DIRS_ASSIGNMENT_PATTERN.test(line)) {
-            // A `DIRS += [` list body continues on later lines. A single-line
-            // `DIRS += ["x"]` is fully handled by the match below.
-            inDirs = !line.includes(']');
-            if (dirsLineNames(line, relDir))
-                return stack.map((entry) => entry.expression);
-            continue;
-        }
-        if (inDirs) {
-            if (dirsLineNames(line, relDir))
-                return stack.map((entry) => entry.expression);
-            if (line.includes(']'))
-                inDirs = false;
-        }
-    }
-    return undefined;
-}
-/** True when `line` carries `relDir` as a quoted value. */
-function dirsLineNames(line, relDir) {
-    const escaped = escapeRegex(relDir.replace(/\/+$/, ''));
-    return new RegExp(`["']${escaped}\\/?["']`).test(line);
-}
-/**
- * Determines whether the source file's directory is excluded from this
- * build by a gate in an ancestor `moz.build`.
- *
- * `detectPlatformGate` reads only the file's own nearest `moz.build`, which
- * misses the common Firefox shape where the whole subtree is reached
- * through a conditional `DIRS +=` one or more levels up: nothing in
- * `toolkit/mozapps/defaultagent/moz.build` says "Windows only", yet none of
- * it is built on macOS.
- *
- * Errs toward not skipping, like the rest of this module: an unreadable or
- * oversized ancestor, or a directory no `DIRS` entry names, yields
- * `gatedOff: false`.
- *
- * @param engineDir - Absolute path to the engine root
- * @param sourcePath - Engine-relative POSIX path of the source file
- */
-export async function detectAncestorDirsGate(engineDir, sourcePath) {
-    let host;
-    try {
-        host = getPlatform();
-    }
-    catch {
-        return { gatedOff: false };
-    }
-    const segments = sourcePath.split('/').filter(Boolean);
-    // Drop the basename: the walk is over directories.
-    segments.pop();
-    const root = engineDir.replace(/[/\\]+$/, '');
-    const depth = Math.min(segments.length, MAX_ANCESTOR_DEPTH);
-    // Start at the immediate parent of the file's directory and walk up, so
-    // the nearest gating ancestor is found first.
-    for (let cut = segments.length - 1; cut >= segments.length - depth; cut -= 1) {
-        const ancestorSegments = segments.slice(0, cut);
-        const relDir = segments.slice(cut).join('/');
-        if (relDir === '')
-            continue;
-        const mozBuild = join(root, ...ancestorSegments, 'moz.build');
-        if (!(await pathExists(mozBuild)))
-            continue;
-        let content;
-        try {
-            const stats = await stat(mozBuild);
-            if (stats.size > MAX_MOZ_BUILD_BYTES)
-                continue;
-            content = await readText(mozBuild);
-        }
-        catch {
-            continue;
-        }
-        const gates = findDirsEntryGates(content, relDir);
-        if (gates === undefined)
-            continue;
-        const offHost = gates.find((expression) => isGateOffHost(expression, host));
-        if (offHost !== undefined) {
-            return {
-                gatedOff: true,
-                gateExpression: offHost,
-                gateFile: [...ancestorSegments, 'moz.build'].join('/'),
-            };
-        }
-        // The directory is reached from here and this host passes every gate.
-        // A further ancestor cannot un-reach it.
-        return { gatedOff: false };
-    }
-    return { gatedOff: false };
-}

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

@@ -1,80 +0,0 @@
-/** Parsed jar.mn registration anchored to a specific engine source path. */
-export interface RegistrationHit {
-    /** Target path extracted from the entry (POSIX). */
-    target: string;
-    /** Source path from the entry (POSIX, relative to the jar.mn directory). */
-    source: string;
-    /** Absolute path of the jar.mn that owns the registration. */
-    jarManifest: string;
-}
-/** Result of a registration-aware dist probe. */
-export interface RegistrationProbeResult {
-    /** Absolute path of the packaged artifact matching the registration target. */
-    artifact: string;
-    /** The registration entry that anchored the match. */
-    hit: RegistrationHit;
-}
-/**
- * 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 declare function parseJarMnEntry(line: string): {
-    target: string;
-    source: string;
-} | undefined;
-/**
- * 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 declare function findJarMnEntryForSource(content: string, relativeSource: string): {
-    target: string;
-    source: string;
-} | 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 declare function findRegisteredTarget(engineDir: string, source: string): Promise<RegistrationHit | undefined>;
-/**
- * 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 declare function resolveArtifactByRegistration(engineDir: string, source: string, searchRoots: readonly string[]): Promise<RegistrationProbeResult | 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 declare function collectSameBasenameCandidates(source: string, searchRoots: readonly string[]): Promise<string[]>;

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;
-}