@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/setup-support.js

@@ -1,386 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { cpus } from 'node:os';
-import { join } from 'node:path';
-import { group, select, text } from '@clack/prompts';
-import { getProjectPaths, writeConfig } from '../core/config.js';
-import { PATCHES_MANIFEST, savePatchesManifest } from '../core/patch-manifest-io.js';
-import { CancellationError, InvalidArgumentError } from '../errors/base.js';
-import { ensureDir, pathExists, readText, writeText } from '../utils/fs.js';
-import { cancel } from '../utils/logger.js';
-import { getPackageRoot } from '../utils/package-root.js';
-import { FIREFOX_PRODUCTS, inferProductFromVersion, isValidAppId, isValidFirefoxProduct, isValidFirefoxVersion, isValidProjectLicense, } from '../utils/validation.js';
-function getTemplatesDir() {
-    return join(getPackageRoot(), 'templates');
-}
-function renderLicenseTemplate(license, template, vendor, now = new Date()) {
-    if (license !== '0BSD') {
-        return template;
-    }
-    return template.replace(/\[year\]/g, String(now.getFullYear())).replace(/\[fullname\]/g, vendor);
-}
-/**
- * Narrows a raw CLI or prompt value to a supported Firefox product.
- * @param value - Raw value from `--product` or the setup prompt.
- * @param field - Field name quoted in the refusal (e.g. `--product`).
- * @returns The validated product.
- * @throws {@link InvalidArgumentError} when the value names no supported product.
- */
-export function resolveFirefoxProduct(value, field) {
-    // Matches the sibling `resolveProjectLicense`, which already delegates to
-    // its guard. The `||` chain this replaced spelled the member list twice,
-    // once as the predicate and once in the message.
-    if (typeof value === 'string' && isValidFirefoxProduct(value)) {
-        return value;
-    }
-    throw new InvalidArgumentError(`Invalid product (use: ${FIREFOX_PRODUCTS.join(', ')})`, field);
-}
-/**
- * Narrows a raw CLI or prompt value to a supported SPDX licence identifier.
- * @param value - Raw value from `--license` or the setup prompt.
- * @param field - Field name quoted in the refusal (e.g. `--license`).
- * @returns The validated licence identifier.
- * @throws {@link InvalidArgumentError} when the value names no supported licence.
- */
-export function resolveProjectLicense(value, field) {
-    if (typeof value === 'string' && isValidProjectLicense(value)) {
-        return value;
-    }
-    throw new InvalidArgumentError('Invalid license (use: EUPL-1.2, MPL-2.0, 0BSD, GPL-2.0-or-later)', field);
-}
-/** Validates non-interactive setup options before project scaffolding begins. */
-export function validateSetupOptions(options) {
-    if (options.name !== undefined) {
-        if (!options.name.trim()) {
-            throw new InvalidArgumentError('Name is required', '--name');
-        }
-        if (options.name.length > 50) {
-            throw new InvalidArgumentError('Name must be 50 characters or less', '--name');
-        }
-    }
-    if (options.vendor !== undefined && !options.vendor.trim()) {
-        throw new InvalidArgumentError('Vendor is required', '--vendor');
-    }
-    if (options.appId !== undefined && !isValidAppId(options.appId)) {
-        throw new InvalidArgumentError('Invalid app ID format (use reverse-domain: org.example.browser)', '--app-id');
-    }
-    if (options.binaryName !== undefined && !/^[a-z][a-z0-9-]*$/.test(options.binaryName)) {
-        throw new InvalidArgumentError('Binary name must start with a letter and contain only lowercase letters, numbers, and hyphens', '--binary-name');
-    }
-    if (options.firefoxVersion !== undefined && !isValidFirefoxVersion(options.firefoxVersion)) {
-        throw new InvalidArgumentError('Invalid Firefox version format (e.g., 140.9.0, 140.9.0esr, or 147.0b1)', '--firefox-version');
-    }
-    if (options.product !== undefined) {
-        resolveFirefoxProduct(options.product, '--product');
-    }
-    if (options.license !== undefined) {
-        resolveProjectLicense(options.license, '--license');
-    }
-}
-async function promptSetupInputs(options) {
-    const project = await group({
-        name: () => options.name
-            ? Promise.resolve(options.name)
-            : text({
-                message: 'What is the name of your browser?',
-                placeholder: 'MyBrowser',
-                validate: (value) => {
-                    const normalizedValue = value ?? '';
-                    if (!normalizedValue.trim())
-                        return 'Name is required';
-                    if (normalizedValue.length > 50)
-                        return 'Name must be 50 characters or less';
-                    return undefined;
-                },
-            }),
-        vendor: () => options.vendor
-            ? Promise.resolve(options.vendor)
-            : text({
-                message: 'What is your vendor/company name?',
-                placeholder: 'My Company',
-                validate: (value) => {
-                    if (!(value ?? '').trim())
-                        return 'Vendor is required';
-                    return undefined;
-                },
-            }),
-        appId: ({ results }) => options.appId
-            ? Promise.resolve(options.appId)
-            : text({
-                message: 'Application ID (reverse-domain format)',
-                placeholder: `org.${(results.name ?? 'browser').toLowerCase().replace(/[^a-z0-9]/g, '')}.browser`,
-                validate: (value) => {
-                    if (value && !isValidAppId(value)) {
-                        return 'Must be in reverse-domain format (e.g., org.example.browser)';
-                    }
-                    return undefined;
-                },
-            }),
-        binaryName: ({ results }) => options.binaryName
-            ? Promise.resolve(options.binaryName)
-            : text({
-                message: 'Binary name (executable name)',
-                placeholder: (results.name ?? 'browser').toLowerCase().replace(/[^a-z0-9]/g, ''),
-                validate: (value) => {
-                    if (value && !/^[a-z][a-z0-9-]*$/.test(value)) {
-                        return 'Must start with a letter and contain only lowercase letters, numbers, and hyphens';
-                    }
-                    return undefined;
-                },
-            }),
-        firefoxVersion: () => options.firefoxVersion
-            ? Promise.resolve(options.firefoxVersion)
-            : text({
-                message: 'Firefox version to base on',
-                placeholder: '140.9.0esr',
-                validate: (value) => {
-                    if (value && !isValidFirefoxVersion(value)) {
-                        return 'Invalid Firefox version format (e.g., 140.9.0, 140.9.0esr, or 147.0b1)';
-                    }
-                    return undefined;
-                },
-            }),
-        product: ({ results }) => {
-            if (options.product) {
-                return Promise.resolve(options.product);
-            }
-            const effectiveVersion = (typeof results.firefoxVersion === 'string' && results.firefoxVersion.trim()) ||
-                options.firefoxVersion ||
-                '140.9.0esr';
-            const inferredProduct = inferProductFromVersion(effectiveVersion);
-            if (inferredProduct) {
-                return Promise.resolve(inferredProduct);
-            }
-            return select({
-                message: 'Which Firefox product?',
-                options: [
-                    { value: 'firefox', label: 'Firefox (stable releases)' },
-                    { value: 'firefox-esr', label: 'Firefox ESR (extended support)' },
-                    { value: 'firefox-beta', label: 'Firefox Beta (pre-release)' },
-                    { value: 'firefox-devedition', label: 'Firefox Developer Edition' },
-                ],
-            });
-        },
-        license: () => options.license
-            ? Promise.resolve(options.license)
-            : select({
-                message: 'Project license',
-                options: [
-                    {
-                        value: 'EUPL-1.2',
-                        label: 'EUPL 1.2 (recommended)',
-                        hint: 'copyleft, MPL-2.0 compatible',
-                    },
-                    { value: 'MPL-2.0', label: 'MPL 2.0', hint: 'file-level copyleft' },
-                    { value: '0BSD', label: '0BSD', hint: 'permissive, no conditions' },
-                    { value: 'GPL-2.0-or-later', label: 'GPL 2.0+', hint: 'strong copyleft' },
-                ],
-                initialValue: 'EUPL-1.2',
-            }),
-    }, {
-        onCancel: () => {
-            cancel('Setup cancelled');
-            throw new CancellationError();
-        },
-    });
-    return finalizePromptedSetupInputs(project);
-}
-/**
- * Validates the raw prompt result and resolves the canonical
- * {@link ResolvedSetupInputs}. Extracted from {@link promptSetupInputs} so
- * the prompt body stays under the per-function line limit.
- */
-function finalizePromptedSetupInputs(project) {
-    const sanitizedName = project.name.toLowerCase().replace(/[^a-z0-9]/g, '');
-    // Project names that contain no ASCII alphanumerics (e.g. "----", "漢字",
-    // emoji-only) collapse to an empty sanitised slug, which would silently
-    // produce an invalid `appId` ("org..browser") and an empty `binaryName`.
-    // Refuse to derive defaults from such names. The user must supply
-    // explicit appId / binaryName values instead.
-    const explicitAppId = typeof project.appId === 'string' ? project.appId.trim() : '';
-    const explicitBinaryName = typeof project.binaryName === 'string' ? project.binaryName.trim() : '';
-    if (sanitizedName === '' && (explicitAppId === '' || explicitBinaryName === '')) {
-        throw new InvalidArgumentError(`Project name "${project.name}" contains no characters that can be used to derive default appId / binaryName values. Re-run setup and supply --app-id and --binary-name explicitly.`, 'name');
-    }
-    const finalAppId = explicitAppId || `org.${sanitizedName}.browser`;
-    const finalBinaryName = explicitBinaryName || sanitizedName;
-    const finalFirefoxVersion = (typeof project.firefoxVersion === 'string' ? project.firefoxVersion.trim() : '') ||
-        '140.9.0esr';
-    if (!isValidAppId(finalAppId)) {
-        throw new InvalidArgumentError(`Derived appId "${finalAppId}" is invalid.`, 'appId');
-    }
-    if (finalBinaryName === '') {
-        throw new InvalidArgumentError('Derived binaryName is empty. Supply --binary-name explicitly.', 'binaryName');
-    }
-    if (!isValidFirefoxVersion(finalFirefoxVersion)) {
-        throw new InvalidArgumentError(`Default Firefox version "${finalFirefoxVersion}" is invalid.`, 'firefoxVersion');
-    }
-    return {
-        finalName: project.name,
-        finalVendor: project.vendor,
-        finalAppId,
-        finalBinaryName,
-        finalFirefoxVersion,
-        finalProduct: (typeof project.product === 'string'
-            ? resolveFirefoxProduct(project.product, 'product')
-            : undefined) ??
-            inferProductFromVersion(finalFirefoxVersion) ??
-            'firefox',
-        finalLicense: resolveProjectLicense(project.license, 'license'),
-    };
-}
-/** Resolves setup inputs from CLI flags and optional interactive prompts. */
-export async function resolveSetupInputs(options, isInteractive) {
-    if (options.name &&
-        options.vendor &&
-        options.appId &&
-        options.binaryName &&
-        options.firefoxVersion) {
-        return {
-            finalName: options.name,
-            finalVendor: options.vendor,
-            finalAppId: options.appId,
-            finalBinaryName: options.binaryName,
-            finalFirefoxVersion: options.firefoxVersion,
-            finalProduct: options.product ?? inferProductFromVersion(options.firefoxVersion) ?? 'firefox',
-            finalLicense: options.license ?? 'EUPL-1.2',
-        };
-    }
-    if (!isInteractive) {
-        throw new InvalidArgumentError('Missing required options for non-interactive mode. Required: --name, --vendor, --app-id, --binary-name, --firefox-version');
-    }
-    return promptSetupInputs(options);
-}
-/** Builds the persisted FireForge config from resolved setup inputs. */
-export function buildSetupConfig(inputs) {
-    return {
-        name: inputs.finalName,
-        vendor: inputs.finalVendor,
-        appId: inputs.finalAppId,
-        binaryName: inputs.finalBinaryName,
-        license: inputs.finalLicense,
-        firefox: {
-            version: inputs.finalFirefoxVersion,
-            product: inputs.finalProduct,
-        },
-        build: {
-            jobs: Math.max(1, cpus().length),
-        },
-    };
-}
-/**
- * Creates or updates the root `package.json` so its `license` field matches
- * the project license selected during setup. When the file already exists
- * only the `license` field is touched, preserving `name`, `description`,
- * `dependencies`, `scripts`, and every other author-editorial field. Without
- * this sync, a `fireforge setup --force` that picks a new license leaves the
- * old one in `package.json`, so the two files describe different projects.
- *
- * Preserves the file's trailing newline state so a hand-edited
- * `package.json` with a specific EOL convention is not silently
- * re-normalised.
- */
-async function syncRootPackageJson(projectRoot, license) {
-    const rootPackageJsonPath = join(projectRoot, 'package.json');
-    if (!(await pathExists(rootPackageJsonPath))) {
-        const rootPackageJson = {
-            private: true,
-            license,
-        };
-        await writeText(rootPackageJsonPath, JSON.stringify(rootPackageJson, null, 2) + '\n');
-        return;
-    }
-    const raw = await readText(rootPackageJsonPath);
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        // Malformed package.json is the operator's editorial responsibility to
-        // repair. Rewriting it would risk clobbering hand-authored content that
-        // the parser happens to reject. Leave the file alone and rely on the
-        // doctor / lint paths that already surface invalid JSON.
-        return;
-    }
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-        return;
-    }
-    // Treat the object as a typed shape with only the one field modified.
-    // Keeping it narrowly typed rather than `Record<string, unknown>` avoids
-    // eslint's `dot-notation` / `noPropertyAccessFromIndexSignature` friction,
-    // and the rest of the package.json body is preserved via object spread at
-    // the write site.
-    const packageJson = parsed;
-    if (packageJson.license === license) {
-        return;
-    }
-    const trailingNewline = raw.endsWith('\n') ? '\n' : '';
-    await writeText(rootPackageJsonPath, JSON.stringify({ ...packageJson, license }, null, 2) + trailingNewline);
-}
-/** Writes the initial project files produced by the setup workflow. */
-export async function writeSetupProjectFiles(projectRoot, config) {
-    const paths = getProjectPaths(projectRoot);
-    await ensureDir(paths.patches);
-    await ensureDir(paths.configs);
-    await ensureDir(paths.fireforgeDir);
-    await writeConfig(projectRoot, config);
-    const manifestPath = join(paths.patches, PATCHES_MANIFEST);
-    if (!(await pathExists(manifestPath))) {
-        await savePatchesManifest(paths.patches, { version: 1, patches: [] });
-    }
-    const gitignorePath = join(projectRoot, '.gitignore');
-    const requiredIgnores = ['node_modules/', 'dist/', 'engine/', '.fireforge/'];
-    if (await pathExists(gitignorePath)) {
-        const existingContent = await readText(gitignorePath);
-        const lines = existingContent.split('\n').map((line) => line.trim());
-        const missing = requiredIgnores.filter((item) => {
-            const withoutSlash = item.endsWith('/') ? item.slice(0, -1) : item;
-            return !lines.includes(item) && !lines.includes(withoutSlash);
-        });
-        if (missing.length > 0) {
-            const toAppend = (existingContent.endsWith('\n') ? '' : '\n') + missing.join('\n') + '\n';
-            await writeText(gitignorePath, existingContent + toAppend);
-        }
-    }
-    else {
-        await writeText(gitignorePath, requiredIgnores.join('\n') + '\n');
-    }
-    // FireForgeConfig types license as optional, but `buildSetupConfig` always
-    // fills it from the resolved setup inputs (which default to `EUPL-1.2`).
-    // Narrow explicitly so the helper takes a concrete license rather than
-    // widening its own signature for a field that is always set at this call
-    // site.
-    if (config.license !== undefined) {
-        await syncRootPackageJson(projectRoot, config.license);
-    }
-    const templatesDir = getTemplatesDir();
-    if (config.license !== undefined) {
-        const licenseTemplatePath = join(templatesDir, 'licenses', `${config.license}.md`);
-        if (await pathExists(licenseTemplatePath)) {
-            const licenseText = renderLicenseTemplate(config.license, await readText(licenseTemplatePath), config.vendor);
-            await writeText(join(projectRoot, 'LICENSE'), licenseText);
-        }
-    }
-    const configsTemplateDir = join(templatesDir, 'configs');
-    if (!(await pathExists(configsTemplateDir))) {
-        return;
-    }
-    const configFiles = [
-        'common.mozconfig',
-        'darwin.mozconfig',
-        'linux.mozconfig',
-        'win32.mozconfig',
-    ];
-    for (const file of configFiles) {
-        const srcPath = join(configsTemplateDir, file);
-        const destPath = join(paths.configs, file);
-        if (!(await pathExists(srcPath))) {
-            continue;
-        }
-        const content = (await readText(srcPath))
-            .replace(/\$\{name\}/g, config.name)
-            .replace(/\$\{vendor\}/g, config.vendor)
-            .replace(/\$\{appId\}/g, config.appId)
-            .replace(/\$\{binaryName\}/g, config.binaryName);
-        await writeText(destPath, content);
-    }
-}

package/dist/src/commands/setup.d.ts

@@ -1,11 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-import type { SetupOptions } from '../types/commands/index.js';
-/**
- * Runs the setup command.
- * @param projectRoot - Root directory for the project
- * @param options - CLI options for non-interactive mode
- */
-export declare function setupCommand(projectRoot: string, options?: SetupOptions): Promise<void>;
-/** Registers the setup command on the CLI program. */
-export declare function registerSetup(program: Command, { withErrorHandling }: CommandContext): void;

package/dist/src/commands/source.d.ts

@@ -1,9 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-import type { SourceSetOptions } from '../types/commands/index.js';
-/**
- * Atomically updates the Firefox source tuple in fireforge.json.
- */
-export declare function sourceSetCommand(projectRoot: string, options: SourceSetOptions): Promise<void>;
-/** Registers the source command on the CLI program. */
-export declare function registerSource(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/source.js

@@ -1,120 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { Command, Option } from 'commander';
-import { configExists, loadRawConfigDocument, validateConfig, withConfigFileLock, writeConfigDocument, } from '../core/config.js';
-import { resolveArchive } from '../core/firefox-archive.js';
-import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-import { info, intro, outro, success } from '../utils/logger.js';
-import { FIREFOX_PRODUCTS, isJsonObject, isObject, isValidFirefoxCandidate, isValidFirefoxProduct, } from '../utils/validation.js';
-function cloneRawConfig(raw) {
-    const cloned = structuredClone(raw);
-    if (!isObject(cloned)) {
-        throw new GeneralError('Cannot update fireforge.json: config clone was not an object.');
-    }
-    // A structured clone of a JSON document is itself a JSON document. The
-    // object check above is the only invariant left to establish.
-    return cloned;
-}
-function parseSourceProduct(product) {
-    if (isValidFirefoxProduct(product)) {
-        return product;
-    }
-    throw new InvalidArgumentError(`--product must be one of: ${FIREFOX_PRODUCTS.join(', ')}`, '--product');
-}
-function parseSourceCandidate(candidate) {
-    if (isValidFirefoxCandidate(candidate)) {
-        return candidate;
-    }
-    throw new InvalidArgumentError(`--candidate must look like "buildN" (e.g. "build2"), got "${candidate}"`, '--candidate');
-}
-/**
- * Atomically updates the Firefox source tuple in fireforge.json.
- */
-export async function sourceSetCommand(projectRoot, options) {
-    intro('FireForge Source');
-    if (!(await configExists(projectRoot))) {
-        throw new GeneralError('No fireforge.json found. Run "fireforge setup" to create a project.');
-    }
-    if (options.sha256 !== undefined && options.clearSha256 === true) {
-        throw new InvalidArgumentError('--sha256 cannot be combined with --clear-sha256', '--sha256');
-    }
-    if (options.candidate !== undefined && options.clearCandidate === true) {
-        throw new InvalidArgumentError('--candidate cannot be combined with --clear-candidate', '--candidate');
-    }
-    const written = await withConfigFileLock(projectRoot, async () => {
-        const raw = await loadRawConfigDocument(projectRoot);
-        const updated = cloneRawConfig(raw);
-        const existingFirefox = updated['firefox'];
-        const firefox = isJsonObject(existingFirefox) ? { ...existingFirefox } : {};
-        firefox['version'] = options.version;
-        firefox['product'] = options.product;
-        if (options.clearSha256 === true) {
-            delete firefox['sha256'];
-        }
-        else if (options.sha256 !== undefined) {
-            firefox['sha256'] = options.sha256;
-        }
-        if (options.clearCandidate === true) {
-            delete firefox['candidate'];
-        }
-        else if (options.candidate !== undefined) {
-            firefox['candidate'] = options.candidate;
-        }
-        updated['firefox'] = firefox;
-        const validated = validateConfig(updated);
-        if (validated.firefox.sha256 !== undefined) {
-            firefox['sha256'] = validated.firefox.sha256;
-        }
-        await writeConfigDocument(projectRoot, updated);
-        return validated.firefox;
-    });
-    const archive = resolveArchive(written.version, written.product, written.candidate);
-    success(`Set firefox.version = ${written.version}`);
-    success(`Set firefox.product = ${written.product}`);
-    success(`Resolved source URL: ${archive.url}`);
-    if (written.sha256 !== undefined) {
-        success(`Set firefox.sha256 = ${written.sha256}`);
-    }
-    else if (options.clearSha256 === true) {
-        info('Cleared firefox.sha256');
-    }
-    if (written.candidate !== undefined) {
-        success(`Set firefox.candidate = ${written.candidate}`);
-    }
-    else if (options.clearCandidate === true) {
-        info('Cleared firefox.candidate');
-    }
-    outro('');
-}
-/** Registers the source command on the CLI program. */
-export function registerSource(program, { getProjectRoot, withErrorHandling }) {
-    const source = program
-        .command('source')
-        .description('Manage Firefox source configuration')
-        // No-subcommand contract shared with `patch`/`token`/`furnace`: help on
-        // stdout, exit 0 (see `handleParseError` for the groups without an action).
-        .action(() => {
-        source.outputHelp();
-    });
-    source
-        .command('set')
-        .description('Atomically set Firefox source version, product, and optional checksum')
-        .requiredOption('--version <version>', 'Firefox version to base on')
-        .addOption(new Option('--product <product>', 'Firefox product')
-        .choices([...FIREFOX_PRODUCTS])
-        .makeOptionMandatory())
-        .option('--sha256 <hash>', 'Pinned SHA-256 for the resolved source archive')
-        .option('--clear-sha256', 'Clear any existing pinned SHA-256')
-        .option('--candidate <buildN>', 'Release-candidate build directory (e.g. "build2")', parseSourceCandidate)
-        .option('--clear-candidate', 'Clear any existing release-candidate build directory')
-        .action(withErrorHandling(async (options) => {
-        const { product, version, sha256, clearSha256, candidate, clearCandidate } = options;
-        await sourceSetCommand(getProjectRoot(), {
-            version,
-            product: parseSourceProduct(product),
-            ...(sha256 !== undefined ? { sha256 } : {}),
-            ...(clearSha256 !== undefined ? { clearSha256 } : {}),
-            ...(candidate !== undefined ? { candidate } : {}),
-            ...(clearCandidate !== undefined ? { clearCandidate } : {}),
-        });
-    }));
-}

package/dist/src/commands/status-check.d.ts

@@ -1,87 +0,0 @@
-/**
- * `status --check` enforcement policy. Turns the classified status view into
- * a CI-enforceable non-zero exit: the default policy fails on any
- * classification outside {patch-backed, branding, furnace}, and
- * `--fail-on <class,...>` replaces that set for finer control.
- * `--allow <class,...>` names classes that never fail, and
- * `--fail-on-unknown` fails every present class that neither list names,
- * so a gate keeps failing closed when FireForge adds a classification.
- * `ownership-conflict` is a check class beside the file classifications:
- * a path claimed by more than one patch, judged from the same rows as
- * `--include-ownership`.
- *
- * Helper module consumed by status.ts, which sits at the max-lines budget.
- * No top-level registrar is exported and none is wanted.
- */
-import type { ClassifiedFile, FileClassification } from '../core/status-classify.js';
-/**
- * A class `--fail-on`/`--allow` can name: every file classification, plus
- * `ownership-conflict`, which is judged from the ownership rows rather
- * than from a file's classification.
- */
-export type StatusCheckClass = FileClassification | 'ownership-conflict';
-/** Resolved `--check`/`--fail-on` policy for one status invocation. */
-export interface StatusCheckPolicy {
-    checkEnabled: boolean;
-    /** Classes that fail: `--fail-on` (or the default set) minus `--allow`. */
-    failOn: readonly StatusCheckClass[];
-    /** `--allow`: classes that never fail. Set only when the flag was given. */
-    allow?: readonly StatusCheckClass[];
-    /** `--fail-on-unknown`: a present class named by neither list fails. */
-    failOnUnknown?: boolean;
-}
-/**
- * Resolves the enforcement policy from the raw flags. `--fail-on`,
- * `--allow` and `--fail-on-unknown` each imply `--check`. `--fail-on`
- * replaces the default set and `--allow` subtracts from it (naming one
- * class in both is refused). `--fail-on-unknown` needs `--allow`: without
- * an allow list every class the caller did not name, `patch-backed`
- * included, would fail. All of them are refused alongside the modes that
- * skip (or elide) classification.
- */
-export declare function resolveStatusCheckPolicy(options: {
-    check?: boolean;
-    failOn?: string;
-    allow?: string;
-    failOnUnknown?: boolean;
-    raw?: boolean;
-    unmanaged?: boolean;
-    ownership?: boolean;
-    testCoverage?: boolean;
-}): StatusCheckPolicy;
-/**
- * True when the policy can fail on `ownership-conflict`, so the caller has
- * to build the ownership rows even without `--include-ownership`.
- */
-export declare function policyNeedsOwnership(policy: StatusCheckPolicy): boolean;
-/** One failing class with a non-empty file list. */
-export interface StatusCheckOffender {
-    classification: StatusCheckClass;
-    count: number;
-    files: string[];
-    /**
-     * Set when the class failed only through `--fail-on-unknown`: neither
-     * `--fail-on` nor `--allow` named it.
-     */
-    unnamed?: true;
-}
-/**
- * Collects the failing classes that have offending files, with full file
- * lists: the fail set in policy order, then (under `--fail-on-unknown`)
- * every other present class neither list names, in first-seen order.
- * Shared by the human `--check` verdict and the JSON `check` block so the
- * two views can never disagree about what failed.
- *
- * @param classified - Classified worktree entries
- * @param policy - Resolved policy
- * @param ownershipConflicts - Paths claimed by more than one patch. Only
- *   read for the `ownership-conflict` class
- */
-export declare function collectStatusCheckOffenders(classified: readonly ClassifiedFile[], policy: StatusCheckPolicy, ownershipConflicts?: readonly string[]): StatusCheckOffender[];
-/**
- * Throws a GeneralError (exit 1) when the policy is enabled and any
- * failing class is non-empty, naming each offending class with its first
- * few files. A disabled policy or a fully tool-covered tree passes
- * silently.
- */
-export declare function runStatusCheck(classified: readonly ClassifiedFile[], policy: StatusCheckPolicy, ownershipConflicts?: readonly string[]): void;