@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/moz-manifest-rules.js

@@ -1,264 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { basename, join } from 'node:path';
-import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { warn } from '../utils/logger.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { escapeRegex } from '../utils/regex.js';
-import { getProjectPaths, loadConfig } from './config.js';
-import { registerBrowserContent, registerFireForgeModule, registerSharedCSS, registerTestManifest, registerToolkitWidget, } from './moz-manifest-register.js';
-import { isXpcshellTestRegistered, registerXpcshellTest } from './register-xpcshell-test.js';
-/**
- * Returns manifest registration rules for the supported engine file
- * patterns. `createManifest` (from `register --create-manifest`) lets the
- * module and xpcshell-test rules scaffold a missing manifest (directory
- * moz.build / xpcshell.toml) and wire the parent chain instead of failing
- * with "Manifest not found".
- */
-export function getRules(binaryName, createManifest = false) {
-    const moduleDir = `browser/modules/${binaryName}`;
-    return [
-        {
-            pattern: /^browser\/themes\/shared\/(.+\.css)$/,
-            isRegistered: (engineDir, fileName) => isSharedCSSRegistered(engineDir, fileName),
-            register: (engineDir, after, dryRun, fileName) => registerSharedCSS(engineDir, fileName, after, dryRun),
-            extractArgs: (m) => [m[1] ?? ''],
-            supportsAfter: true,
-        },
-        {
-            // `.inc.xhtml` fragments under browser/base/content/ are excluded on
-            // purpose: they are consumed via `#include` from a registered chrome
-            // document (typically browser.xhtml) and do not get their own packaged
-            // chrome URI. Without the carve-out, `status` flags every wired
-            // fragment as "potentially unregistered" and `register --dry-run`
-            // proposes a bogus jar.mn entry. The lookahead blocks the match so
-            // `getUnregistrableAdvice` can emit the correct guidance instead.
-            //
-            // Test implementation files under `browser/base/content/test/` are
-            // also excluded: they belong in the nearest `browser.toml` manifest,
-            // not in jar.mn. The negative lookahead routes those paths to
-            // `getUnregistrableAdvice`, which returns browser.toml-centric
-            // guidance rather than proposing a jar.mn entry for a test file.
-            pattern: /^browser\/base\/content\/(?!.+\.inc\.xhtml$)(?!test\/)(.+\.(?:js|mjs|xhtml|css))$/,
-            isRegistered: (engineDir, fileName) => isBrowserContentRegistered(engineDir, fileName),
-            register: (engineDir, after, dryRun, fileName) => registerBrowserContent(engineDir, fileName, after, undefined, dryRun),
-            extractArgs: (m) => [m[1] ?? ''],
-            supportsAfter: true,
-        },
-        {
-            // Fork-owned browser.toml manifests at any depth under
-            // browser/base/content/test/. A one-level pattern rejects nested
-            // browser-chrome manifests.
-            pattern: /^browser\/base\/content\/test\/((?:[^/]+\/)*[^/]+)\/browser\.toml$/,
-            isRegistered: (_engineDir, testDir) => isTestManifestRegistered(_engineDir, testDir),
-            register: (_engineDir, _after, dryRun, testDir) => registerTestManifest(_engineDir, testDir, dryRun),
-            extractArgs: (m) => [m[1] ?? ''],
-            supportsAfter: false,
-        },
-        {
-            pattern: new RegExp(`^browser/modules/${escapeRegex(binaryName)}/(.+\\.sys\\.mjs)$`),
-            isRegistered: (_engineDir, fileName) => isFireForgeModuleRegistered(_engineDir, fileName, moduleDir),
-            register: (_engineDir, _after, dryRun, fileName) => registerFireForgeModule(_engineDir, fileName, moduleDir, dryRun, createManifest),
-            extractArgs: (m) => [m[1] ?? ''],
-            supportsAfter: false,
-        },
-        {
-            pattern: /^toolkit\/content\/widgets\/([^/]+)\/(.+\.(?:mjs|css))$/,
-            isRegistered: (_engineDir, tagName, fileName) => isToolkitWidgetRegistered(_engineDir, tagName, fileName),
-            register: (_engineDir, _after, dryRun, tagName, fileName) => registerToolkitWidget(_engineDir, tagName, fileName, dryRun),
-            extractArgs: (m) => [m[1] ?? '', m[2] ?? ''],
-            supportsAfter: false,
-        },
-        {
-            // xpcshell test files. Any `test_*.js` outside
-            // browser/base/content/test/ (which stays browser-chrome territory
-            // with its browser.toml guidance) registers into the directory's
-            // xpcshell.toml. With --create-manifest a missing manifest is
-            // scaffolded and wired via XPCSHELL_TESTS_MANIFESTS.
-            pattern: /^(?!browser\/base\/content\/test\/)(.+)\/(test_[^/]+\.js)$/,
-            isRegistered: (engineDir, dirRel, fileName) => isXpcshellTestRegistered(engineDir, dirRel, fileName),
-            register: (engineDir, after, dryRun, dirRel, fileName) => registerXpcshellTest(engineDir, dirRel, fileName, dryRun, createManifest, after),
-            // Both groups are guaranteed by the pattern, so slice avoids dead
-            // fallback branches.
-            extractArgs: (m) => m.slice(1, 3),
-            // `--after <entry>` places the section after that entry's block.
-            supportsAfter: true,
-        },
-    ];
-}
-/**
- * Reads an engine manifest and reports whether it contains any of `needles`.
- *
- * The five registration probes below share this shape: resolve the manifest
- * relative to the engine, refuse with the manifest's own path when it is
- * missing, then substring-match the entry each registrar writes.
- *
- * @param engineDir - Path to the engine directory
- * @param manifestRel - Engine-relative manifest path (forward slashes, and
- *   also the path named in the refusal message)
- * @param needles - Entry forms that count as registered
- * @returns True when the manifest contains at least one needle
- * @throws GeneralError when the manifest does not exist
- */
-async function manifestIncludes(engineDir, manifestRel, needles) {
-    const manifestPath = join(engineDir, manifestRel);
-    if (!(await pathExists(manifestPath))) {
-        throw new GeneralError(`Manifest not found: ${manifestRel}`);
-    }
-    const content = await readText(manifestPath);
-    return needles.some((needle) => content.includes(needle));
-}
-async function isSharedCSSRegistered(engineDir, fileName) {
-    const name = basename(fileName, '.css');
-    // `register` writes the canonical `skin/classic/browser/<name>.css` form.
-    // `furnace chrome-doc create` writes a `content/browser/<name>.css` entry
-    // because the CSS is loaded by a chrome document via a `chrome://browser/
-    // content/<name>.css` URI. Match either prefix so paths registered by the
-    // chrome-doc scaffolder are not flagged as "potentially unregistered" by
-    // `status` and so a re-run of `register` against the same file recognises
-    // the existing entry instead of proposing a duplicate.
-    return manifestIncludes(engineDir, 'browser/themes/shared/jar.inc.mn', [
-        `skin/classic/browser/${name}.css`,
-        `content/browser/${name}.css`,
-    ]);
-}
-async function isBrowserContentRegistered(engineDir, fileName) {
-    return manifestIncludes(engineDir, 'browser/base/jar.mn', [`content/browser/${fileName}`]);
-}
-async function isTestManifestRegistered(engineDir, testDir) {
-    return manifestIncludes(engineDir, 'browser/base/moz.build', [
-        `content/test/${testDir}/browser.toml`,
-    ]);
-}
-async function isFireForgeModuleRegistered(engineDir, fileName, moduleDir) {
-    return manifestIncludes(engineDir, `${moduleDir}/moz.build`, [`"${fileName}"`]);
-}
-async function isToolkitWidgetRegistered(engineDir, _tagName, fileName) {
-    return manifestIncludes(engineDir, 'toolkit/content/jar.mn', [
-        `content/global/elements/${fileName}`,
-    ]);
-}
-/**
- * Checks if a file path matches any known registrable pattern.
- * @param filePath - Path relative to engine/
- * @param binaryName - Binary name from fireforge.json (used for module directory)
- * @returns True if the file matches a known registration pattern
- */
-export function matchesRegistrablePattern(filePath, binaryName) {
-    const normalized = normalizePathSlashes(filePath);
-    const rules = getRules(binaryName);
-    return rules.some((rule) => rule.pattern.test(normalized));
-}
-/** Returns advice for files that cannot be registered, or null if no advice applies. */
-function getUnregistrableAdvice(filePath) {
-    if (filePath.endsWith('.ftl')) {
-        return "FTL locale files are auto-discovered via jar.mn glob patterns and don't need manual registration.";
-    }
-    // `.inc.xhtml` fragments live under browser/base/content/ but are
-    // consumed via `#include` from a registered chrome document (browser.xhtml
-    // by default, or a fork's custom top-level doc when `wire --dom-target` is
-    // set). The preprocessor resolves the include at packaging time, so the
-    // fragment never needs its own chrome URI entry in jar.mn. Give the
-    // operator the actionable `wire` path instead of letting the generic
-    // "unknown file pattern" message above fire.
-    if (/^browser\/base\/content\/.+\.inc\.xhtml$/.test(filePath)) {
-        return ('`.inc.xhtml` fragments are consumed via `#include` from a registered chrome document ' +
-            '(e.g. browser.xhtml). They do not need an independent jar.mn entry — run ' +
-            '"fireforge wire <name> --dom <path>" to insert the #include, or add the directive manually ' +
-            'in the top-level chrome document.');
-    }
-    // xpcshell.toml manifests scaffolded by `furnace create --test-style
-    // xpcshell` or `furnace chrome-doc create --with-tests` live under
-    // `browser/base/content/test/<binary-name>-xpcshell/<component>/`. The
-    // scaffold does not auto-register, because wiring
-    // `XPCSHELL_TESTS_MANIFESTS` requires a deliberate choice about which
-    // moz.build should own the entry. `register` surfaces that same guidance
-    // instead of falling through to browser.toml-centric advice for a path
-    // that is xpcshell-shaped and contains no browser.toml.
-    if (filePath.endsWith('/xpcshell.toml')) {
-        return (`xpcshell.toml manifests are not auto-registered by "fireforge register". ` +
-            `Add "XPCSHELL_TESTS_MANIFESTS += ['${basename(filePath)}']" to the ` +
-            `moz.build that covers ${filePath.replace(/\/xpcshell\.toml$/, '/')}, ` +
-            'or register one of its test files with "fireforge register <path>/test_*.js --create-manifest", ' +
-            'which scaffolds the manifest and wires XPCSHELL_TESTS_MANIFESTS automatically. ' +
-            'Browser-chrome tests (browser.toml) are auto-registered via "fireforge register <path>/browser.toml".');
-    }
-    const testMatch = filePath.match(/^browser\/base\/content\/test\/([^/]+)\/(?!browser\.toml$).+$/);
-    if (testMatch) {
-        const dir = testMatch[1];
-        return ('Individual test files should be added directly to the corresponding browser.toml manifest. ' +
-            `Use 'fireforge register browser/base/content/test/${dir}/browser.toml' to register new test directories.`);
-    }
-    return null;
-}
-/**
- * Checks whether a supported registrable file is already present in its manifest.
- *
- * @param root - Project root directory
- * @param filePath - Path relative to engine/
- * @returns True if the file is already registered in its manifest
- */
-export async function isFileRegistered(root, filePath) {
-    const { engine: engineDir } = getProjectPaths(root);
-    const config = await loadConfig(root);
-    const rules = getRules(config.binaryName);
-    const normalizedPath = normalizePathSlashes(filePath);
-    for (const rule of rules) {
-        const match = normalizedPath.match(rule.pattern);
-        if (match) {
-            const args = rule.extractArgs(match);
-            return rule.isRegistered(engineDir, ...args);
-        }
-    }
-    const advice = getUnregistrableAdvice(normalizedPath);
-    if (advice) {
-        throw new InvalidArgumentError(advice, 'path');
-    }
-    throw new InvalidArgumentError(buildUnknownPatternMessage(normalizedPath, config.binaryName), 'path');
-}
-/** Shared "Unknown file pattern" message naming every supported pattern. */
-function buildUnknownPatternMessage(normalizedPath, binaryName) {
-    return (`Unknown file pattern: "${normalizedPath}". Supported patterns:\n` +
-        '  browser/themes/shared/*.css\n' +
-        '  browser/base/content/*.{js,mjs,xhtml,css}\n' +
-        '  browser/base/content/test/**/browser.toml\n' +
-        `  browser/modules/${binaryName}/*.sys.mjs\n` +
-        '  toolkit/content/widgets/*/*.{mjs,css}\n' +
-        '  **/test_*.js (xpcshell test files; registers into the nearest xpcshell.toml)');
-}
-/**
- * Registers a file in the appropriate build manifest.
- *
- * @param root - Project root directory
- * @param filePath - Path relative to engine/
- * @param dryRun - If true, return what would be done without writing
- * @param after - Optional substring to place entry after (instead of alphabetical)
- * @param options - `createManifest` scaffolds a missing manifest (directory
- *   moz.build / xpcshell.toml) and wires the parent chain instead of failing
- * @returns Registration result
- */
-export async function registerFile(root, filePath, dryRun = false, after, options = {}) {
-    const { engine: engineDir } = getProjectPaths(root);
-    const config = await loadConfig(root);
-    const rules = getRules(config.binaryName, options.createManifest === true);
-    // Normalize path separators
-    const normalizedPath = normalizePathSlashes(filePath);
-    for (const rule of rules) {
-        const match = normalizedPath.match(rule.pattern);
-        if (match) {
-            const args = rule.extractArgs(match);
-            if (after !== undefined && !rule.supportsAfter) {
-                // Say so rather than inserting alphabetically and letting the
-                // operator believe their placement was honoured.
-                warn(`--after is not supported for ${normalizedPath}: this manifest is ` +
-                    'kept in sorted order, so the entry was inserted alphabetically.');
-            }
-            return rule.register(engineDir, after, dryRun, ...args);
-        }
-    }
-    const advice = getUnregistrableAdvice(normalizedPath);
-    if (advice) {
-        throw new InvalidArgumentError(advice, 'path');
-    }
-    throw new InvalidArgumentError(buildUnknownPatternMessage(normalizedPath, config.binaryName), 'path');
-}

package/dist/src/core/moz-manifest-tokenizers.d.ts

@@ -1,38 +0,0 @@
-/** Token for jar.mn / jar.inc.mn files */
-export interface JarMnToken {
-    type: 'header' | 'directive' | 'entry' | 'empty' | 'comment';
-    raw: string;
-    lineIndex: number;
-    parsed?: {
-        target: string;
-        source: string;
-    } | undefined;
-}
-/** Token for moz.build Python-style list blocks */
-export interface MozBuildToken {
-    type: 'list-open' | 'list-item' | 'list-close' | 'other';
-    raw: string;
-    lineIndex: number;
-    parsed?: {
-        value: string;
-    } | undefined;
-}
-/**
- * Tokenizes a jar.mn file into structured tokens.
- * Recognizes headers, `%` directives, entries with (source) paths,
- * comments, and blank lines.
- */
-export declare function tokenizeJarMn(lines: string[]): JarMnToken[];
-/**
- * Tokenizes a moz.build Python list block, returning the tokens and their
- * line range within the file.
- *
- * Supports both multi-line lists (the common shape) and single-line empty
- * lists of the form `EXTRA_JS_MODULES += []`, which a freshly-scaffolded
- * module directory's `moz.build` can start with.
- */
-export declare function tokenizeMozBuildList(lines: string[], listPattern: RegExp): {
-    tokens: MozBuildToken[];
-    startLine: number;
-    endLine: number;
-} | null;

package/dist/src/core/moz-manifest-tokenizers.js

@@ -1,108 +0,0 @@
-/**
- * Tokenizes a jar.mn file into structured tokens.
- * Recognizes headers, `%` directives, entries with (source) paths,
- * comments, and blank lines.
- */
-export function tokenizeJarMn(lines) {
-    const tokens = [];
-    for (let i = 0; i < lines.length; i++) {
-        const raw = lines[i] ?? '';
-        const trimmed = raw.trim();
-        if (trimmed === '') {
-            tokens.push({ type: 'empty', raw, lineIndex: i });
-            continue;
-        }
-        if (trimmed.startsWith('#')) {
-            tokens.push({ type: 'comment', raw, lineIndex: i });
-            continue;
-        }
-        if (trimmed.startsWith('%')) {
-            tokens.push({ type: 'directive', raw, lineIndex: i });
-            continue;
-        }
-        // Entries with source paths: "  target/path  (source/path)" or "target/path  (source/path)"
-        const entryMatch = /^(\s*)(\S+)\s+\(([^)]+)\)/.exec(raw);
-        if (entryMatch) {
-            tokens.push({
-                type: 'entry',
-                raw,
-                lineIndex: i,
-                parsed: { target: entryMatch[2] ?? '', source: entryMatch[3] ?? '' },
-            });
-            continue;
-        }
-        // Non-indented lines without (source) are headers (e.g., "browser.jar:" or Python assignment)
-        if (/^\S.*[:+=]/.test(raw)) {
-            tokens.push({ type: 'header', raw, lineIndex: i });
-            continue;
-        }
-        // Fallback: treat indented lines without (source) as entries
-        tokens.push({ type: 'entry', raw, lineIndex: i });
-    }
-    return tokens;
-}
-/**
- * Tokenizes a moz.build Python list block, returning the tokens and their
- * line range within the file.
- *
- * Supports both multi-line lists (the common shape) and single-line empty
- * lists of the form `EXTRA_JS_MODULES += []`, which a freshly-scaffolded
- * module directory's `moz.build` can start with.
- */
-export function tokenizeMozBuildList(lines, listPattern) {
-    const tokens = [];
-    let startLine = -1;
-    let endLine = -1;
-    for (let i = 0; i < lines.length; i++) {
-        const raw = lines[i] ?? '';
-        if (startLine === -1) {
-            if (listPattern.test(raw)) {
-                // Single-line empty-list handling: a fresh scaffold sometimes
-                // writes `EXTRA_JS_MODULES += []` on one line, which a tokenizer
-                // looking for a line starting with `]` never closes, leaving
-                // `register` with a "Could not find module list section" error
-                // against the documented browser/modules/<fork>/ scaffold.
-                //
-                // The in-place split rewrites the single-line form into the
-                // canonical multi-line shape so the caller's
-                // `lines.splice(insertIndex, 0, entry)` lands inside the list body.
-                // The tokens are emitted to mirror the new structure.
-                const singleLineMatch = /^([^[]*\[)\s*\]\s*$/.exec(raw);
-                if (singleLineMatch) {
-                    const openPart = singleLineMatch[1] ?? '';
-                    lines[i] = openPart;
-                    lines.splice(i + 1, 0, ']');
-                    startLine = i;
-                    endLine = i + 1;
-                    tokens.push({ type: 'list-open', raw: openPart, lineIndex: i });
-                    tokens.push({ type: 'list-close', raw: ']', lineIndex: i + 1 });
-                    break;
-                }
-                startLine = i;
-                tokens.push({ type: 'list-open', raw, lineIndex: i });
-            }
-            continue;
-        }
-        // Inside the list block
-        if (/^\s*\]/.test(raw)) {
-            endLine = i;
-            tokens.push({ type: 'list-close', raw, lineIndex: i });
-            break;
-        }
-        const itemMatch = /^\s+["']([^"']+)["']/.exec(raw);
-        if (itemMatch) {
-            tokens.push({
-                type: 'list-item',
-                raw,
-                lineIndex: i,
-                parsed: { value: itemMatch[1] ?? '' },
-            });
-        }
-        else {
-            tokens.push({ type: 'other', raw, lineIndex: i });
-        }
-    }
-    if (startLine === -1 || endLine === -1)
-        return null;
-    return { tokens, startLine, endLine };
-}

package/dist/src/core/negative-control-compiled.d.ts

@@ -1,46 +0,0 @@
-/**
- * Which negative-control targets only a build can deliver.
- *
- * A control is applied after the pre-test build and right before dispatch,
- * which is right for a file the runtime reads from the source tree or the
- * objdir links to. A C++ (or Rust, IDL, …) source edited at that point is
- * never compiled: the run tests the unmutated binary and reports
- * `control=missed`, which reads as a test that cannot fail. Such a target
- * is refused without `--build`, and with `--build` the control is
- * applied before the build so the binary under test carries it. That build
- * is a full `mach build`: the pre-test build is otherwise `mach build
- * faster`, which compiles nothing, so the control would still miss.
- */
-/**
- * Whether an engine-relative path has a compiled-source extension: a file
- * the build compiles or code-generates into the binary. This is the
- * extension test only. {@link findCompiledControlTargets} additionally
- * drops non-header files an install manifest ships as-is.
- *
- * @param path - Engine-relative path
- */
-export declare function isCompiledSourcePath(path: string): boolean;
-/**
- * The engine-relative targets that reach the runtime only through a
- * compile: a compiled-source extension and no install-manifest entry that
- * ships the file itself. Headers are always compiled, even when an
- * `EXPORTS` manifest installs them into `dist/include`.
- *
- * @param engineDir - Absolute engine directory
- * @param enginePaths - The control's engine-relative targets
- */
-export declare function findCompiledControlTargets(engineDir: string, enginePaths: readonly string[]): Promise<string[]>;
-/**
- * The notice that explains why a compiled control's pre-test build is a
- * full `mach build` instead of `mach build faster`.
- *
- * @param compiled - Engine-relative compiled targets
- */
-export declare function formatCompiledControlBuildNotice(compiled: readonly string[]): string;
-/**
- * The refusal for a compiled control without `--build`, naming the manual
- * procedure for a run that wants to keep its build out of FireForge.
- *
- * @param compiled - Engine-relative compiled targets
- */
-export declare function formatCompiledControlRefusal(compiled: readonly string[]): string;

package/dist/src/core/negative-control-compiled.js

@@ -1,109 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Which negative-control targets only a build can deliver.
- *
- * A control is applied after the pre-test build and right before dispatch,
- * which is right for a file the runtime reads from the source tree or the
- * objdir links to. A C++ (or Rust, IDL, …) source edited at that point is
- * never compiled: the run tests the unmutated binary and reports
- * `control=missed`, which reads as a test that cannot fail. Such a target
- * is refused without `--build`, and with `--build` the control is
- * applied before the build so the binary under test carries it. That build
- * is a full `mach build`: the pre-test build is otherwise `mach build
- * faster`, which compiles nothing, so the control would still miss.
- */
-import { extname } from 'node:path';
-import { classifyRuntimeDelivery } from './objdir-install-manifests.js';
-import { loadEngineInstallIndex } from './test-stale-exempt.js';
-/** Extensions of sources the build compiles or code-generates into the binary. */
-const COMPILED_EXTENSIONS = new Set([
-    '.c',
-    '.cc',
-    '.cpp',
-    '.cxx',
-    '.h',
-    '.hh',
-    '.hpp',
-    '.m',
-    '.mm',
-    '.rs',
-    '.idl',
-    '.webidl',
-    '.ipdl',
-    '.ipdlh',
-    '.yaml',
-    '.yml',
-]);
-/**
- * Header extensions. An `EXPORTS` install manifest names many headers (it
- * copies them into `dist/include`), but that copy only feeds other
- * compiles: the runtime never reads a header, so a header edit reaches the
- * binary through a compile whatever the manifests say.
- */
-const HEADER_EXTENSIONS = new Set(['.h', '.hh', '.hpp', '.ipdlh']);
-/**
- * Whether an engine-relative path has a compiled-source extension: a file
- * the build compiles or code-generates into the binary. This is the
- * extension test only. {@link findCompiledControlTargets} additionally
- * drops non-header files an install manifest ships as-is.
- *
- * @param path - Engine-relative path
- */
-export function isCompiledSourcePath(path) {
-    return COMPILED_EXTENSIONS.has(extname(path));
-}
-/**
- * The engine-relative targets that reach the runtime only through a
- * compile: a compiled-source extension and no install-manifest entry that
- * ships the file itself. Headers are always compiled, even when an
- * `EXPORTS` manifest installs them into `dist/include`.
- *
- * @param engineDir - Absolute engine directory
- * @param enginePaths - The control's engine-relative targets
- */
-export async function findCompiledControlTargets(engineDir, enginePaths) {
-    const candidates = enginePaths.filter(isCompiledSourcePath);
-    if (candidates.length === 0)
-        return [];
-    if (candidates.every((path) => HEADER_EXTENSIONS.has(extname(path))))
-        return candidates;
-    const index = await loadEngineInstallIndex(engineDir);
-    if (index === undefined)
-        return candidates;
-    const compiled = [];
-    for (const path of candidates) {
-        if (HEADER_EXTENSIONS.has(extname(path)) ||
-            (await classifyRuntimeDelivery(index, engineDir, path)) === 'unlisted') {
-            compiled.push(path);
-        }
-    }
-    return compiled;
-}
-/**
- * The notice that explains why a compiled control's pre-test build is a
- * full `mach build` instead of `mach build faster`.
- *
- * @param compiled - Engine-relative compiled targets
- */
-export function formatCompiledControlBuildNotice(compiled) {
-    const files = compiled.map((path) => `engine/${path}`).join(', ');
-    return (`The negative control edits compiled source (${files}); escalating this pre-test build to ` +
-        'a full mach build, since mach build faster compiles nothing and the binary under test ' +
-        'would not carry the control.');
-}
-/**
- * The refusal for a compiled control without `--build`, naming the manual
- * procedure for a run that wants to keep its build out of FireForge.
- *
- * @param compiled - Engine-relative compiled targets
- */
-export function formatCompiledControlRefusal(compiled) {
-    const files = compiled.map((path) => `engine/${path}`).join(', ');
-    return (`This negative control edits compiled source (${files}). Applied right before dispatch, ` +
-        'it would never be compiled: the run would test the unmutated binary and report ' +
-        'control=missed. Add --build: the control is then applied before the pre-test build, so ' +
-        'the binary under test carries it, and restored afterwards with a fresh mtime so the next ' +
-        'build recompiles the original. To run it by hand instead: copy the mutated file in, ' +
-        '`touch` it, `fireforge build`, `fireforge test`, restore the file byte-exact, `touch` it ' +
-        'again and rebuild.');
-}

package/dist/src/core/negative-control-diff.d.ts

@@ -1,51 +0,0 @@
-/**
- * Parsing and strict application of a `fireforge test --negative-control`
- * diff.
- *
- * A control is a reviewed mutation, so the applier is deliberately strict:
- * every context and removed line must match exactly, the only tolerance is
- * a line offset (the same one `git apply` allows, never fuzz), and a hunk
- * that does not apply refuses the whole control before any file is
- * written. Only plain text modifications of existing files are accepted: a
- * created, deleted, renamed or binary file has no byte-exact restore story
- * that is worth its risk for a neuter.
- */
-import { type ParsedHunk } from './patch-parse.js';
-/** One file of a control diff. */
-export interface ControlDiffFile {
-    /** The path the diff names, without git's `a/`/`b/` prefix. */
-    path: string;
-    /** The hunks to apply, in file order. */
-    hunks: ParsedHunk[];
-}
-/** Options for {@link parseControlDiff}. */
-export interface ParseControlDiffOptions {
-    /**
-     * Called for a section whose old and new paths differ. Returns the path
-     * the control targets (a `git diff --no-index <file> <edited copy>` names
-     * the copy on its new side), or undefined for a real rename, which is
-     * refused.
-     */
-    resolveRename?: (sourcePath: string, targetPath: string) => string | undefined;
-}
-/**
- * Parses a control diff. Accepts `git diff` output (a `diff --git` header
- * per file), which is what `git -C engine diff -- <file>` or a project-root
- * `git diff` writes, a plain unified diff (`diff -u`), and, through
- * `resolveRename`, a `git diff --no-index` against an edited copy.
- *
- * @param content - The diff file's text
- * @param options - See {@link ParseControlDiffOptions}
- * @returns One entry per file, in diff order
- */
-export declare function parseControlDiff(content: string, options?: ParseControlDiffOptions): ControlDiffFile[];
-/**
- * Applies `hunks` to `original`, strictly.
- *
- * @param original - The file's current text
- * @param hunks - Hunks parsed from the control diff
- * @param label - File label for refusal messages
- * @returns The mutated text
- * @throws GeneralError when any hunk does not apply
- */
-export declare function applyControlHunks(original: string, hunks: readonly ParsedHunk[], label: string): string;