@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/test-stall-triage.js

@@ -1,142 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Operator-facing triage for the `timed out … with no output` / `Ran 0
- * checks` stall: the shape where the harness dies before any test output.
- *
- * Split out of `test-harness-crash.ts`, which classifies runs. This module
- * only renders advice about one already-classified shape. Keeping the two
- * apart matters because the census below carries claims of unequal
- * evidential strength, and the rules for editing it are not the rules for
- * editing a classifier: a pattern in the classifier is either matched by
- * the output or not, while a cause in the census is an assertion about the
- * world that an operator will act on.
- *
- * Everything here is pure. The platform and the probed display state are
- * injected, so unit tests need no mocking.
- */
-/**
- * First step for the `timed out … with no output` / `Ran 0 checks`
- * signature, printed above the cause list. Running a known-good control
- * separates "this test" from "this build" and is the correct opening move
- * for every cause below. It is not specific to any one of them, so
- * attaching it to a single entry made reaching that entry informationally
- * empty.
- */
-const NO_OUTPUT_STALL_CONTROL_STEP = 'First, run a known-good control test. If the control stalls too, the cause is not the test ' +
-    'under investigation, and the list below applies to the build or the host.';
-/**
- * Recorded causes of the `timed out … with no output` / `Ran 0 checks`
- * signature, each paired with the probe that discriminates it from the
- * others. Printed verbatim under the hint.
- *
- * Evidence per entry is unequal, and the text says so:
- *
- *  - (1) is measured: `probeDisplaySleepState` reads the display's power
- *    state, so the hint states it as fact rather than as a possibility.
- *  - (2) is discriminated by `--headless`.
- *  - (4) is mechanical and was root-caused downstream: the harness serves
- *    its manifest from `server.js` on 8888, and a survivor of an
- *    interrupted run keeps the port. Its probe is exact, and the preflight
- *    in `mochitest-server-port.ts` refuses it before a run starts.
- *  - (3) is mechanical and root-caused. A `chrome://` (or `resource://`) URL that
- *    resolves to nothing reaches `CheckForBrokenChromeURL`
- *    (netwerk/base/nsNetUtil.cpp), which outside automation only
- *    `printf_stderr`s `Missing chrome or resource URL: <uri>`, but under
- *    `xpc::IsInAutomation()` the same condition is
- *    `MOZ_CRASH_UNSAFE_PRINTF("Missing chrome or resource URLs: %s")`. A
- *    downstream reproduction symbolicated the faulting frame as
- *    `CheckForBrokenChromeURL`, which is the established diagnosis the bar
- *    in `mach-error-hints.ts` asks for. It is not a "stalls first paint"
- *    problem: a failed image load in Gecko fires `error` and does not gate the
- *    document load event.
- *
- * Detection by log line is not specified for (3), because of the mechanism
- * itself: in the reproduction the crash landed in a content
- * process (`plugin-container`, a child of the browser) with the
- * crash reporter compiled out, so the harness log carried neither the crash
- * message nor a crash line, only the no-output timeout, `Ran 0 checks`,
- * and mochitest's "Can't trigger Breakpad, just killing process". Under
- * automation the message is in the process that died, not in the log, so
- * the census points at the two artefacts that do carry it: the OS crash
- * report (whose faulting frame names `CheckForBrokenChromeURL`) and the
- * out-of-automation smoke probe (which prints the non-crashing spelling
- * and counts it as an unallowed error so the exit code
- * agrees with the capture).
- */
-const NO_OUTPUT_STALL_TRIAGE = [
-    '  1. A sleeping or locked display on an unattended HEADED run (macOS). The browser never ' +
-        'paints and never reaches its first test.',
-    '  2. A headless SWGL compositor failure — re-run with --headless to separate this from (1): ' +
-        'if --headless passes, the stall was display/compositor-side, not product-side.',
-    '  3. A broken `chrome://` or `resource://` URL reached from the startup document. Under ' +
-        'automation this is a MOZ_CRASH in whichever process opened the channel ' +
-        '(CheckForBrokenChromeURL, netwerk/base/nsNetUtil.cpp), so the browser dies before the ' +
-        'harness sees anything. Expect the log to name NOTHING: with the crash in a content ' +
-        'process and the crash reporter compiled out, the only artefacts are the OS crash report ' +
-        '(macOS: ~/Library/Logs/DiagnosticReports/plugin-container-*.ips — the faulting frame ' +
-        'reads CheckForBrokenChromeURL) and the smoke probe below. Discriminate with ' +
-        '"fireforge run --smoke-exit 60 --headless --capture-console <file>", which launches the ' +
-        'same browser OUTSIDE automation, where the same condition only PRINTS ' +
-        '"Missing chrome or resource URL: <uri>" — a line the probe counts as an unallowed ' +
-        'error, so its exit code and its capture now agree. A clean window with no unallowed ' +
-        'console errors means product-side startup is healthy and the stall is harness- or ' +
-        'test-side.',
-    '  4. A stale mochitest httpd holding the harness server port (127.0.0.1:8888). A fresh ' +
-        "browser connects to THAT server, which cannot serve this run's manifest, so the run " +
-        'stalls before TEST_START. Probe with "lsof -nP -iTCP:8888": any listener that is not ' +
-        "this run's own is the cause. FireForge now refuses this at preflight, so it should " +
-        'reach a stall only on a host where the port could not be probed.',
-];
-/**
- * Optional hint appended to the harness-crash message when a headed run on
- * macOS died at the no-output timeout.
- *
- * When `displayState` names a measured display state, the hint states it as
- * fact rather than as one of three possibilities, which is what probing is
- * for: an operator staring at a bare test failure should not have to
- * rediscover that their machine dimmed. `caffeinate` is described accurately
- * (it prevents sleep, and cannot wake an already-sleeping display), so
- * operators are not sent to a command that could not have helped them.
- *
- * Pure. The platform and the probed state are injected so unit tests need
- * no mocking.
- *
- * @param signature - The recognized crash shape
- * @param context - Run mode, platform, and the probed display state
- * @returns The hint text, or undefined when the shape does not apply
- */
-export function headedNoOutputTimeoutHint(signature, context) {
-    if (context.platform !== 'darwin' || context.headless)
-        return undefined;
-    if (!signature.reason.includes('no-output timeout'))
-        return undefined;
-    const lead = context.displayState === 'asleep'
-        ? 'Hint: this was a HEADED run on macOS and the display was MEASURED ASLEEP ' +
-            '(IODisplayWrangler below its awake power state). A headed browser on a sleeping ' +
-            'display never paints and never starts a test, so this stall is environmental — not a ' +
-            'product or test failure.'
-        : context.displayState === 'awake'
-            ? 'Hint: this was a HEADED run on macOS that died at the no-output timeout. The display ' +
-                'was measured AWAKE, so the sleeping-display cause below is ruled out for this run.'
-            : 'Hint: this was a HEADED run on macOS that died at the no-output timeout. The display ' +
-                'state could not be measured, so all three causes below remain open.';
-    const remedy = 'Note that `caffeinate -disu` PREVENTS sleep; it cannot WAKE a display that is already ' +
-        'asleep. Wake the display (or run on an attended machine), or pass --headless.';
-    return (`${lead}\n\n${NO_OUTPUT_STALL_CONTROL_STEP}\n\n` +
-        `Known causes of this exact signature:\n${NO_OUTPUT_STALL_TRIAGE.join('\n')}\n\n${remedy}`);
-}
-/**
- * Verdict-line note for a headed no-output stall whose display was
- * measured asleep. Returned as the parenthetical the verdict line carries,
- * so the one greppable line an automated consumer reads already names the
- * environmental cause instead of a bare `FAIL reason=crash`.
- */
-export function headedDisplayAsleepVerdictNote(signature, context) {
-    if (context.platform !== 'darwin' || context.headless)
-        return undefined;
-    if (context.displayState !== 'asleep')
-        return undefined;
-    if (!signature.reason.includes('no-output timeout'))
-        return undefined;
-    return 'headed run stalled with the display asleep';
-}

package/dist/src/core/test-xpcshell-retry.d.ts

@@ -1,35 +0,0 @@
-import { type MachCommandResult, type MachTestSuiteKind } from './mach.js';
-export interface XpcshellRetryClassification {
-    xpcshell: readonly string[];
-    nonXpcshell: readonly string[];
-}
-export interface XpcshellRetryOptions {
-    /** Engine checkout the run happened in. */
-    engineDir: string;
-    /** Object directory the run used, when one is configured. */
-    objDir: string | undefined;
-    /** Result of the run that may need repairing and retrying. */
-    result: MachCommandResult;
-    /** Which of the requested paths are xpcshell tests, and which are not. */
-    classification: XpcshellRetryClassification;
-    /** Test paths, normalized, as handed to mach. */
-    normalizedPaths: string[];
-    /** Extra mach arguments the run was started with. */
-    extraArgs: string[];
-    /** Environment overlay for the retried run. */
-    env?: Record<string, string> | undefined;
-    /** Mach command kind to retry with. Defaults to the generic `test`. */
-    kind?: MachTestSuiteKind | undefined;
-    /** Whether the run was started with full harness output. */
-    fullOutput?: boolean | undefined;
-    /** Per-chunk feed for the retried run's output (start-marker tracking). */
-    onOutputChunk?: ((stream: 'stdout' | 'stderr', chunk: string) => void) | undefined;
-}
-/**
- * Removes a stale xpcshell install symlink and retries the focused mach test
- * once. The retry uses the same mach command `kind` (suite-specific or
- * generic) the caller is already running on, so an xpcshell-suite run repairs
- * and re-runs via `mach xpcshell-test` rather than falling back to the
- * generic command.
- */
-export declare function retryAfterXpcshellSymlinkRepair(options: XpcshellRetryOptions): Promise<MachCommandResult>;

package/dist/src/core/test-xpcshell-retry.js

@@ -1,31 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { runMachTestSuite } from './mach.js';
-import { tryRepairStaleXpcshellTestSymlink } from './test-stale-symlink.js';
-/**
- * Removes a stale xpcshell install symlink and retries the focused mach test
- * once. The retry uses the same mach command `kind` (suite-specific or
- * generic) the caller is already running on, so an xpcshell-suite run repairs
- * and re-runs via `mach xpcshell-test` rather than falling back to the
- * generic command.
- */
-export async function retryAfterXpcshellSymlinkRepair(options) {
-    const { engineDir, objDir, result, classification, normalizedPaths, extraArgs, env, kind = 'test', fullOutput, onOutputChunk, } = options;
-    if (result.exitCode !== 0 &&
-        classification.xpcshell.length > 0 &&
-        classification.nonXpcshell.length === 0) {
-        const repaired = await tryRepairStaleXpcshellTestSymlink(engineDir, objDir, `${result.stdout}\n${result.stderr}`);
-        if (repaired) {
-            // The repaired re-run is the same logical invocation, so it keeps
-            // the verbosity the run was started with.
-            return runMachTestSuite(kind, {
-                engineDir,
-                testPaths: normalizedPaths,
-                args: extraArgs,
-                env,
-                fullOutput,
-                ...(onOutputChunk === undefined ? {} : { teardown: { onOutputChunk } }),
-            });
-        }
-    }
-    return result;
-}

package/dist/src/core/token-category.d.ts

@@ -1,54 +0,0 @@
-/**
- * True when `lines` contain a category header (single-line or multi-line
- * banner shape) whose name equals `category`. Shared by the pre-add
- * assertion, the banner creation path, and the section finder so all
- * agree on what "exists" means.
- */
-export declare function categoryHeaderExists(lines: string[], category: string): boolean;
-export interface TokenCategorySection {
-    name: string;
-    categoryLine: number;
-    sectionEnd: number;
-}
-/** Parses category regions owned by the base root, including nested CSS rules. */
-export declare function parseTokenCategorySections(lines: string[]): TokenCategorySection[];
-/**
- * Asserts the category banner exists (or that creation was requested).
- * Throws a GeneralError naming the available categories and the
- * `--create-category` remedy otherwise.
- */
-export declare function assertTokenCategoryExists(engineDir: string, tokensCssPath: string, category: string, createCategory?: boolean): Promise<void>;
-/**
- * Splices a new single-line category banner ("= Name =" comment shape, the
- * same format `discoverCategoryHeaders` recognises) just before the closing
- * brace of the `:root` block, making the new category the last section.
- * Mutates `lines` in place.
- */
-export declare function declareCategoryBanner(lines: string[], category: string, tokensCssPath: string): void;
-/** Locates and bounds the named category section. Throws when absent. */
-export declare function findCategorySection(lines: string[], category: string, tokensCssPath: string): {
-    categoryLine: number;
-    sectionEnd: number;
-};
-/** 0-based open/close line indices of the base `:root {` block. */
-export declare function findBaseRootBounds(lines: string[]): {
-    open: number;
-    close: number;
-} | undefined;
-/** Masks block-comment content per line so declarations inside comments never match. */
-export declare function maskCommentLines(lines: string[]): string[];
-/** Location of an existing base-`:root` token declaration. */
-export interface TokenDeclarationLocation {
-    /** 1-based line number in the tokens CSS file. */
-    line: number;
-    /** Nearest enclosing category banner name, when one precedes the declaration. */
-    category?: string;
-}
-/**
- * Finds an existing declaration of `tokenName` inside the base `:root`
- * block. Dark `@media` and `:root[variant]` companion blocks are
- * excluded: they mirror the base declaration, they do not
- * own the token. Comment content never matches, and the name match is
- * exact (`--foo-bar` does not match `--x-foo-bar`).
- */
-export declare function findTokenDeclarationInRoot(lines: string[], tokenName: string): TokenDeclarationLocation | undefined;

package/dist/src/core/token-category.js

@@ -1,299 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Category banner and token-declaration helpers for the tokens CSS file.
- * Split out of `token-manager.ts` to stay inside the per-file line budget.
- *
- * Banner matching is exact: the text between the `=` runs (single-line
- * shape) or on the block line (multi-line shape) must equal the category
- * after trimming. With a substring match, a TOC comment or a longer banner
- * whose name merely starts with the category (a canvas colors banner
- * satisfying a lookup for `Colors`) would also match, and `token add` would
- * then write into the wrong section, or no-op, with exit 0.
- */
-import { join } from 'node:path';
-import { GeneralError } from '../errors/base.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { escapeRegex } from '../utils/regex.js';
-/**
- * Body of the first `/* … *\/` comment on `line`, or `undefined` when the
- * line carries no closed block comment.
- *
- * This uses index arithmetic rather than a regex: the natural regex
- * spellings of "banner comment" are super-linear on a line that
- * repeats the opening shape (CodeQL `js/polynomial-redos`), and `tokens.css`
- * is a file FireForge reads out of a consumer's engine tree, so a
- * pathological line needs no attacker to arrive.
- */
-function blockCommentBody(line) {
-    const open = line.indexOf('/*');
-    if (open === -1)
-        return undefined;
-    const close = line.indexOf('*/', open + 2);
-    if (close === -1)
-        return undefined;
-    return line.slice(open + 2, close);
-}
-/**
- * True when `line` carries a single-line banner comment: a closed block
- * comment whose body both opens and closes with `=`. Recognises the decorative
- * all-`=` rule as well as a named `= Foo =` banner, which is what the section
- * scan wants: either shape ends the preceding section.
- */
-function isSingleLineBannerLine(line) {
-    const body = blockCommentBody(line)?.trim();
-    return body !== undefined && body.length >= 2 && body.startsWith('=') && body.endsWith('=');
-}
-/**
- * Name declared by a single-line banner (`/* = Foo = *\/` → `Foo`), or
- * `undefined` when the line is not a named banner. The `=` runs on both sides
- * are required. A decorative all-`=` rule carries no name and yields
- * `undefined`.
- */
-function singleLineBannerName(line) {
-    const body = blockCommentBody(line);
-    if (body === undefined)
-        return undefined;
-    let start = 0;
-    let end = body.length;
-    while (start < end && /\s/.test(body[start] ?? ''))
-        start++;
-    const leadingEqStart = start;
-    while (start < end && body[start] === '=')
-        start++;
-    if (start === leadingEqStart)
-        return undefined;
-    while (end > start && /\s/.test(body[end - 1] ?? ''))
-        end--;
-    const trailingEqEnd = end;
-    while (end > start && body[end - 1] === '=')
-        end--;
-    if (end === trailingEqEnd)
-        return undefined;
-    const name = body.slice(start, end).trim();
-    return name.length > 0 ? name : undefined;
-}
-/**
- * True when `lines` contain a category header (single-line or multi-line
- * banner shape) whose name equals `category`. Shared by the pre-add
- * assertion, the banner creation path, and the section finder so all
- * agree on what "exists" means.
- */
-export function categoryHeaderExists(lines, category) {
-    return parseTokenCategorySections(lines).some((section) => section.name === category);
-}
-/**
- * Category name declared by the banner starting at `index`, or `undefined`
- * when that line opens no banner.
- *
- * The single reader for both banner shapes, so the inventory walk, the
- * "available categories" error body and the section finder cannot drift on
- * what counts as a header.
- *
- * @param lines - Tokens CSS split into lines
- * @param index - 0-based line index to test
- * @returns The declared category name, or undefined
- */
-function categoryBannerNameAt(lines, index) {
-    const line = lines[index] ?? '';
-    const extracted = singleLineBannerName(line);
-    if (extracted !== undefined)
-        return extracted;
-    if (/^\s*\/\*\s*=+/.test(line) && !/\*\//.test(line)) {
-        for (let j = index + 1; j < Math.min(index + 6, lines.length); j++) {
-            const blockLine = lines[j] ?? '';
-            if (/\*\//.test(blockLine))
-                break;
-            const trimmed = blockLine.replace(/^\s*\*\s*/, '').trim();
-            if (trimmed.length === 0)
-                continue;
-            if (/^=+$/.test(trimmed))
-                continue;
-            return trimmed;
-        }
-    }
-    return undefined;
-}
-function discoverCategoryHeaders(lines) {
-    return [...new Set(parseTokenCategorySections(lines).map((section) => section.name))];
-}
-/** Parses category regions owned by the base root, including nested CSS rules. */
-export function parseTokenCategorySections(lines) {
-    const bounds = findBaseRootBounds(lines);
-    if (bounds === undefined || bounds.close === -1)
-        return [];
-    const masked = maskCommentLines(lines);
-    const sections = [];
-    let current;
-    let bodyStarted = false;
-    for (let index = bounds.open + 1; index < bounds.close; index++) {
-        const line = lines[index] ?? '';
-        const name = categoryBannerNameAt(lines, index);
-        const boundary = name !== undefined || isSingleLineBannerLine(line);
-        if (!boundary) {
-            if ((masked[index] ?? '').trim())
-                bodyStarted = true;
-            continue;
-        }
-        // A decorative rule immediately after a named header belongs to that
-        // header. A later rule, after declarations, ends its section.
-        if (name === undefined && current && !bodyStarted)
-            continue;
-        if (current)
-            current.sectionEnd = index;
-        current = undefined;
-        if (name !== undefined) {
-            current = { name, categoryLine: index, sectionEnd: bounds.close };
-            bodyStarted = false;
-            sections.push(current);
-        }
-    }
-    return sections;
-}
-/**
- * Asserts the category banner exists (or that creation was requested).
- * Throws a GeneralError naming the available categories and the
- * `--create-category` remedy otherwise.
- */
-export async function assertTokenCategoryExists(engineDir, tokensCssPath, category, createCategory = false) {
-    const filePath = join(engineDir, tokensCssPath);
-    if (!(await pathExists(filePath))) {
-        throw new GeneralError(`Token CSS file not found: ${tokensCssPath}`);
-    }
-    const content = await readText(filePath);
-    const lines = content.split('\n');
-    if (categoryHeaderExists(lines, category))
-        return;
-    // The write path declares the banner in the same edit as the token
-    // insertion, so a missing category is fine when creation was requested.
-    if (createCategory)
-        return;
-    const discoveredCategories = discoverCategoryHeaders(lines);
-    const available = discoveredCategories.length > 0
-        ? `Available categories in the file: ${discoveredCategories.map((name) => `"${name}"`).join(', ')}.`
-        : 'The file currently has no category headers.';
-    throw new GeneralError(`Category "${category}" not found in ${tokensCssPath}.\n\n` +
-        `${available}\n\n` +
-        'Categories are declared by comment headers. Single-line shape: /* = My Category = */. ' +
-        'Multi-line shape: /* =============\\n * My Category\\n * ============= */.\n\n' +
-        'Re-run with --create-category to declare the banner and insert the token in one step.');
-}
-/**
- * Splices a new single-line category banner ("= Name =" comment shape, the
- * same format `discoverCategoryHeaders` recognises) just before the closing
- * brace of the `:root` block, making the new category the last section.
- * Mutates `lines` in place.
- */
-export function declareCategoryBanner(lines, category, tokensCssPath) {
-    const bounds = findBaseRootBounds(lines);
-    if (bounds === undefined) {
-        throw new GeneralError(`Cannot create category "${category}": no :root block found in ${tokensCssPath}. ` +
-            'Run "fireforge furnace init --force" to re-scaffold the tokens CSS file.');
-    }
-    if (bounds.close === -1) {
-        throw new GeneralError(`Cannot create category "${category}": the :root block in ${tokensCssPath} never closes.`);
-    }
-    lines.splice(bounds.close, 0, '', `  /* = ${category} = */`);
-}
-/** Locates and bounds the named category section. Throws when absent. */
-export function findCategorySection(lines, category, tokensCssPath) {
-    const sections = parseTokenCategorySections(lines);
-    const section = sections.find((entry) => entry.name === category);
-    if (section === undefined) {
-        const discoveredCategories = discoverCategoryHeaders(lines);
-        const available = discoveredCategories.length > 0
-            ? `Available categories in the file: ${discoveredCategories.map((name) => `"${name}"`).join(', ')}.`
-            : 'The file currently has no category headers.';
-        throw new GeneralError(`Category "${category}" not found in ${tokensCssPath}.\n\n` +
-            `${available}\n\n` +
-            'Add a header by hand inside the :root block (format: "/* = My Category = */") or re-run "fireforge furnace init --force" to re-seed the default categories.');
-    }
-    return { categoryLine: section.categoryLine, sectionEnd: section.sectionEnd };
-}
-/**
- * Drops complete quoted strings from one CSS line in linear time. An
- * unterminated quote is kept, and once one fails to close every later quote
- * of that kind fails too, so no start position is ever rescanned.
- */
-function stripCssStrings(line) {
-    let out = '';
-    const unterminated = new Set();
-    for (let i = 0; i < line.length; i++) {
-        const quote = line.charAt(i);
-        if ((quote !== '"' && quote !== "'") || unterminated.has(quote)) {
-            out += quote;
-            continue;
-        }
-        let end = i + 1;
-        while (end < line.length && line.charAt(end) !== quote)
-            end += line.charAt(end) === '\\' ? 2 : 1;
-        if (end >= line.length) {
-            unterminated.add(quote);
-            out += quote;
-        }
-        else {
-            i = end;
-        }
-    }
-    return out;
-}
-/** 0-based open/close line indices of the base `:root {` block. */
-export function findBaseRootBounds(lines) {
-    const open = lines.findIndex((line) => /:root\s*\{/.test(line));
-    if (open === -1)
-        return undefined;
-    const masked = maskCommentLines(lines);
-    let depth = 0;
-    for (let i = open; i < lines.length; i++) {
-        // Ignore braces in CSS strings (including data URLs).
-        const code = stripCssStrings(masked[i] ?? '');
-        for (const char of code) {
-            if (char === '{')
-                depth++;
-            if (char === '}' && --depth === 0)
-                return { open, close: i };
-        }
-    }
-    return { open, close: -1 };
-}
-/** Masks block-comment content per line so declarations inside comments never match. */
-export function maskCommentLines(lines) {
-    const source = lines.join('\n');
-    const parts = [];
-    let cursor = 0;
-    for (;;) {
-        const open = source.indexOf('/*', cursor);
-        if (open === -1)
-            break;
-        const close = source.indexOf('*/', open + 2);
-        // An unfinished edit has no complete comment to mask. Searching only
-        // once prevents restarting a regex at every repeated comment opener.
-        if (close === -1)
-            break;
-        parts.push(source.slice(cursor, open), source.slice(open, close + 2).replace(/[^\n]/g, ' '));
-        cursor = close + 2;
-    }
-    parts.push(source.slice(cursor));
-    return parts.join('').split('\n');
-}
-/**
- * Finds an existing declaration of `tokenName` inside the base `:root`
- * block. Dark `@media` and `:root[variant]` companion blocks are
- * excluded: they mirror the base declaration, they do not
- * own the token. Comment content never matches, and the name match is
- * exact (`--foo-bar` does not match `--x-foo-bar`).
- */
-export function findTokenDeclarationInRoot(lines, tokenName) {
-    const bounds = findBaseRootBounds(lines);
-    if (bounds === undefined || bounds.close === -1)
-        return undefined;
-    const masked = maskCommentLines(lines);
-    const sections = parseTokenCategorySections(lines);
-    const declPattern = new RegExp(`^\\s*${escapeRegex(tokenName)}\\s*:`);
-    for (let i = bounds.open + 1; i < bounds.close; i++) {
-        if (!declPattern.test(masked[i] ?? ''))
-            continue;
-        const category = sections.find((section) => i > section.categoryLine && i < section.sectionEnd)?.name;
-        return category === undefined ? { line: i + 1 } : { line: i + 1, category };
-    }
-    return undefined;
-}

package/dist/src/core/token-coverage.d.ts

@@ -1,12 +0,0 @@
-import type { TokenCoverageReport } from '../types/commands/index.js';
-/**
- * Measures design token coverage across CSS files.
- *
- * Counts var(--{prefix}*) usages, allowlisted vars, unknown vars, and raw
- * color values. Reuses the same regex patterns as patch-lint.ts.
- *
- * @param repoDir - Absolute path to the engine (repository) directory
- * @param cssFiles - File paths (relative to repoDir) to scan
- * @returns Aggregate and per-file coverage report
- */
-export declare function measureTokenCoverage(repoDir: string, cssFiles: string[], projectRoot?: string): Promise<TokenCoverageReport>;

package/dist/src/core/token-coverage.js

@@ -1,96 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { toError } from '../utils/errors.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { verbose } from '../utils/logger.js';
-import { countRawCssColors } from '../utils/regex.js';
-import { loadFurnaceConfig } from './furnace-config.js';
-/**
- * Default platform prefixes treated as allowlisted upstream vars. Any
- * `var(--moz-*)` usage in a fork's CSS is a Firefox platform variable the
- * fork does not own and must not count as an unknown. Otherwise a
- * `furnace override moz-button -t css-only` plus one fork token reports 1%
- * coverage, because the ~84 upstream `--moz-*` vars in the copied baseline
- * all count against it.
- *
- * Forks that want to opt out can override this via
- * `furnace.json.platformPrefixes = []`. Forks that want more can extend it
- * (e.g. `['--moz-', '--in-content-']`). The config is additive: nothing is
- * removed from the defaults unless the operator writes a shorter list.
- */
-const DEFAULT_PLATFORM_PREFIXES = ['--moz-'];
-/**
- * Measures design token coverage across CSS files.
- *
- * Counts var(--{prefix}*) usages, allowlisted vars, unknown vars, and raw
- * color values. Reuses the same regex patterns as patch-lint.ts.
- *
- * @param repoDir - Absolute path to the engine (repository) directory
- * @param cssFiles - File paths (relative to repoDir) to scan
- * @returns Aggregate and per-file coverage report
- */
-export async function measureTokenCoverage(repoDir, cssFiles, projectRoot) {
-    // Load furnace config gracefully
-    let tokenPrefix;
-    let tokenAllowlist;
-    let platformPrefixes = DEFAULT_PLATFORM_PREFIXES;
-    try {
-        const root = projectRoot ?? join(repoDir, '..');
-        const config = await loadFurnaceConfig(root);
-        if (config.tokenPrefix) {
-            tokenPrefix = config.tokenPrefix;
-            tokenAllowlist = new Set(config.tokenAllowlist ?? []);
-        }
-        if (config.platformPrefixes !== undefined) {
-            platformPrefixes = config.platformPrefixes;
-        }
-    }
-    catch (error) {
-        verbose(`Proceeding without furnace token metadata because furnace.json could not be loaded: ${toError(error).message}`);
-    }
-    const entries = [];
-    for (const file of cssFiles) {
-        const filePath = join(repoDir, file);
-        if (!(await pathExists(filePath)))
-            continue;
-        const rawCss = await readText(filePath);
-        // Strip block comments before scanning
-        const css = rawCss.replace(/\/\*[\s\S]*?\*\//g, '');
-        // Count raw color values
-        const rawColors = countRawCssColors(css);
-        // Count custom property usages by category
-        let tokenUsages = 0;
-        let allowlisted = 0;
-        let unknownVars = 0;
-        const varPattern = /var\(\s*(--[\w-]+)/g;
-        let match;
-        while ((match = varPattern.exec(css)) !== null) {
-            const prop = match[1];
-            if (!prop)
-                continue;
-            if (tokenPrefix && prop.startsWith(tokenPrefix)) {
-                tokenUsages++;
-            }
-            else if (tokenAllowlist?.has(prop)) {
-                allowlisted++;
-            }
-            else if (platformPrefixes.some((prefix) => prop.startsWith(prefix))) {
-                // Platform vars (upstream `--moz-*`) are counted as allowlisted
-                // so they don't drag the fork-owned coverage percentage down.
-                allowlisted++;
-            }
-            else {
-                unknownVars++;
-            }
-        }
-        entries.push({ file, tokenUsages, allowlisted, unknownVars, rawColors });
-    }
-    return {
-        filesScanned: entries.length,
-        tokenUsages: entries.reduce((s, e) => s + e.tokenUsages, 0),
-        allowlistedUsages: entries.reduce((s, e) => s + e.allowlisted, 0),
-        unknownVarUsages: entries.reduce((s, e) => s + e.unknownVars, 0),
-        rawColorCount: entries.reduce((s, e) => s + e.rawColors, 0),
-        files: entries,
-    };
-}