@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/patch-lint-css.js

@@ -1,228 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * CSS patch-lint rules: introduced raw color values, non-tokenized
- * custom-property references, and (opt-in) token scales over created CSS.
- *
- * Split out of `patch-lint.ts` so each rule family stays within the
- * per-file line budget. `patch-lint.ts` re-exports `lintPatchedCss` so
- * existing callers keep importing from the single module.
- */
-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 { hasRawCssColors } from '../utils/regex.js';
-import { loadFurnaceConfig } from './furnace-config.js';
-import { detectNewFilesInDiff, extractAddedLineNumbersPerFile, extractAddedLinesPerFile, } from './patch-lint-diff.js';
-import { lintTokenScales } from './patch-lint-token-scale.js';
-/**
- * Loads the furnace token-prefix lint inputs gracefully. Returns
- * undefined (skipping the token-prefix check) when furnace.json cannot
- * be loaded or no tokenPrefix is configured.
- */
-async function loadCssTokenContext(repoDir) {
-    try {
-        const root = join(repoDir, '..');
-        const furnaceConfig = await loadFurnaceConfig(root);
-        if (furnaceConfig.tokenPrefix) {
-            return {
-                tokenPrefix: furnaceConfig.tokenPrefix,
-                tokenAllowlist: new Set(furnaceConfig.tokenAllowlist ?? []),
-                runtimeVariables: new Set(furnaceConfig.runtimeVariables ?? []),
-            };
-        }
-    }
-    catch (error) {
-        verbose(`Skipping furnace token-prefix lint hints because furnace.json could not be loaded: ${toError(error).message}`);
-    }
-    return undefined;
-}
-/**
- * Masks CSS block comments with spaces, preserving newlines so line
- * numbers stay stable. An unclosed trailing `/*` is masked to EOF,
- * matching how a CSS parser treats it.
- */
-export function maskCssComments(source) {
-    // Linear indexOf scan rather than a lazy `/\*[\s\S]*?\*\/` regex: with
-    // many openers and no closer, the regex retries from every `/*` to EOF
-    // (quadratic in file size).
-    let masked = '';
-    let cursor = 0;
-    for (;;) {
-        const open = source.indexOf('/*', cursor);
-        if (open === -1)
-            return masked + source.slice(cursor);
-        const close = source.indexOf('*/', open + 2);
-        const end = close === -1 ? source.length : close + 2;
-        masked += source.slice(cursor, open) + source.slice(open, end).replace(/[^\n]/g, ' ');
-        cursor = end;
-    }
-}
-const RAW_COLOR_IGNORE_MARKER = 'fireforge-ignore: raw-color-value';
-/**
- * Builds the scan source for the diff branch with full-file comment
- * awareness: comments are masked across the whole post-patch file so a
- * comment spanning the context/added boundary suppresses its hex, then
- * only the patch's added line numbers are scanned. Returns undefined
- * when any added line number falls outside the on-disk file (patch not
- * applied / drifted). The caller then falls back to the
- * joined-added-lines scan rather than misattributing lines.
- */
-function buildAddedLinesScanSource(rawCss, addedNumbers) {
-    const rawLines = rawCss.split('\n');
-    if (!addedNumbers.every((n) => n >= 1 && n <= rawLines.length))
-        return undefined;
-    const maskedLines = maskCssComments(rawCss).split('\n');
-    return addedNumbers
-        .filter((n) => !(rawLines[n - 1] ?? '').includes(RAW_COLOR_IGNORE_MARKER))
-        .map((n) => maskedLines[n - 1] ?? '')
-        .join('\n');
-}
-function checkRawColorValues(input) {
-    const { file, rawCss, addedLinesByFile, addedLineNumbersByFile, config, issues } = input;
-    // Check only introduced raw color values when diff context is available.
-    // Skip files on the raw-color allowlist (exact path or basename match) and
-    // auto-exempt files under `browser/branding/`: those are the fork's
-    // visual identity assets (app-about dialogs, installer pages, branded CSS
-    // copied from Firefox's `unofficial` template) and belong to the
-    // design-decision layer the design-token system does not govern. Without
-    // the auto-exemption, every first-time setup's copied CSS fails
-    // `raw-color-value` with no actionable fix short of listing each path in
-    // `rawColorAllowlist`.
-    const allowlist = config?.patchLint?.rawColorAllowlist;
-    const isAllowlisted = allowlist?.some((entry) => file === entry || file.endsWith('/' + entry));
-    const isBranding = file.startsWith('browser/branding/');
-    if (isAllowlisted || isBranding)
-        return;
-    let suppressedContent;
-    const addedNumbers = addedLineNumbersByFile?.get(file);
-    if (addedNumbers !== undefined) {
-        suppressedContent = buildAddedLinesScanSource(rawCss, addedNumbers);
-    }
-    if (suppressedContent === undefined) {
-        // Fallback scan: full file (no diff), or the joined added lines when
-        // the diff and on-disk file disagree. Waiver lines are filtered
-        // against the pre-strip text so the CSS comment marker is present.
-        const sourceForSuppression = addedLinesByFile
-            ? (addedLinesByFile.get(file) ?? []).join('\n')
-            : rawCss;
-        suppressedContent = sourceForSuppression
-            .split('\n')
-            .filter((line) => !line.includes(RAW_COLOR_IGNORE_MARKER))
-            .join('\n')
-            .replace(/\/\*[\s\S]*?\*\//g, '');
-    }
-    if (hasRawCssColors(suppressedContent)) {
-        issues.push({
-            file,
-            check: 'raw-color-value',
-            message: 'Raw color value found. Use CSS custom properties (var(--...)) for design token consistency.',
-            severity: 'error',
-        });
-    }
-}
-/**
- * Token-prefix check for one patched CSS file: flags `var(--x)` references
- * that match neither the configured prefix, the allowlist, the runtime
- * variables, nor a same-file declaration. Pushes onto `issues`.
- */
-function checkTokenPrefixViolations(file, cssContent, addedLinesByFile, tokenContext, issues) {
-    // Check for non-tokenized custom properties. A variable that is both
-    // declared and consumed inside the same file is auto-exempted as a runtime
-    // state channel (see furnace.json → runtimeVariables).
-    //
-    // When diff context is available, scope the `var(...)` scan to
-    // added/modified lines only. `cssContent` (full-file) is still the source
-    // of `localDeclarations` so vars declared anywhere in the file are
-    // recognised as same-file refs regardless of where the consuming `var(...)`
-    // appears. Without the scoping, a small edit to a Furnace override of a
-    // stock component (e.g. moz-card) produces a `token-prefix-violation` for
-    // every stock `var(--moz-card-*)` the upstream file already carried.
-    if (tokenContext) {
-        const declarationPattern = /(?:^|[{;,\s])(--[\w-]+)\s*:/g;
-        const localDeclarations = new Set();
-        let declMatch;
-        while ((declMatch = declarationPattern.exec(cssContent)) !== null) {
-            const name = declMatch[1];
-            if (name)
-                localDeclarations.add(name);
-        }
-        const prefixScanSource = addedLinesByFile
-            ? (addedLinesByFile.get(file) ?? []).join('\n').replace(/\/\*[\s\S]*?\*\//g, '')
-            : cssContent;
-        if (prefixScanSource.length > 0) {
-            const varPattern = /var\(\s*(--[\w-]+)/g;
-            const flaggedProps = new Set();
-            let match;
-            while ((match = varPattern.exec(prefixScanSource)) !== null) {
-                const prop = match[1];
-                if (!prop)
-                    continue;
-                if (prop.startsWith(tokenContext.tokenPrefix))
-                    continue;
-                if (tokenContext.tokenAllowlist.has(prop))
-                    continue;
-                if (tokenContext.runtimeVariables.has(prop))
-                    continue;
-                if (localDeclarations.has(prop))
-                    continue;
-                // De-duplicate per (file, prop) pair so the same introduced var
-                // used five times in the added hunk doesn't produce five
-                // identical issue entries.
-                if (flaggedProps.has(prop))
-                    continue;
-                flaggedProps.add(prop);
-                issues.push({
-                    file,
-                    check: 'token-prefix-violation',
-                    message: `CSS references var(${prop}) which does not match the required token prefix "${tokenContext.tokenPrefix}". Use a design token, add to tokenAllowlist, or (for runtime state channels) list the variable in runtimeVariables.`,
-                    severity: 'error',
-                });
-            }
-        }
-    }
-}
-/**
- * Lints patched CSS files for introduced raw color values and non-tokenized
- * custom properties.
- *
- * @param repoDir - Absolute path to the engine (repository) directory
- * @param affectedFiles - File paths (relative to repoDir) affected by the patch
- * @param diffContent - Optional unified diff used to scope raw color checks to introduced lines
- * @param config - Project configuration
- * @returns Array of lint issues found
- */
-export async function lintPatchedCss(repoDir, affectedFiles, diffContent, config) {
-    const cssFiles = affectedFiles.filter((f) => f.endsWith('.css'));
-    if (cssFiles.length === 0)
-        return [];
-    const tokenContext = await loadCssTokenContext(repoDir);
-    const issues = [];
-    const addedLinesByFile = diffContent ? extractAddedLinesPerFile(diffContent) : undefined;
-    const addedLineNumbersByFile = diffContent
-        ? extractAddedLineNumbersPerFile(diffContent)
-        : undefined;
-    // `patchLint.tokenScales` governs only CSS the patch creates.
-    const tokenScales = config?.patchLint?.tokenScales ?? [];
-    const createdFiles = diffContent && tokenScales.length > 0 ? detectNewFilesInDiff(diffContent) : new Set();
-    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 cssContent = rawCss.replace(/\/\*[\s\S]*?\*\//g, '');
-        checkRawColorValues({
-            file,
-            rawCss,
-            addedLinesByFile,
-            addedLineNumbersByFile,
-            config,
-            issues,
-        });
-        checkTokenPrefixViolations(file, cssContent, addedLinesByFile, tokenContext, issues);
-        if (createdFiles.has(file))
-            issues.push(...lintTokenScales(file, rawCss, tokenScales));
-    }
-    return issues;
-}

package/dist/src/core/patch-lint-diff-tag.d.ts

@@ -1,51 +0,0 @@
-/**
- * Diff-scoping for `fireforge lint`.
- *
- * Pre-existing patch-state errors and errors introduced by the current task
- * print identically, so triaging "is the diff I just produced clean?"
- * otherwise means mentally subtracting the pre-existing noise. This module
- * classifies each lint issue as either `introduced` (the file was touched
- * since the user-supplied git revision) or `cumulative` (pre-existing
- * drift), without changing what the underlying rules emit.
- */
-import type { PatchLintIssue } from '../types/commands/index.js';
-/**
- * Collects engine-relative paths that changed between `rev` and `HEAD`,
- * plus any workdir modifications and untracked files. An empty set means
- * "no diff we can prove". Downstream treats every issue as `cumulative`
- * in that case (operator ran `lint --since HEAD` with no pending work).
- * @param engineDir Path to the engine git repository.
- * @param rev Git revision to diff against (e.g. `HEAD`, a branch, a SHA).
- */
-export declare function collectDiffFilePaths(engineDir: string, rev: string): Promise<Set<string>>;
-/**
- * Synthetic "file" value used by aggregate patch-size rules
- * (`large-patch-files` / `large-patch-lines`) to flag that a finding
- * describes the whole diff rather than a single path. Exported so callers
- * can keep the tagging contract visible in one place.
- */
-export declare const AGGREGATE_PATCH_FILE = "(patch)";
-/**
- * Annotates a list of lint issues with `introduced` / `cumulative` tags
- * based on whether the issue's file is part of the supplied diff set.
- * Mutates each issue in place and returns the list for chaining.
- *
- * Issues with no file (`issue.file === ''`), for example cross-patch rules
- * that describe queue-wide state, are always `cumulative` under `--since`
- * because they describe drift accumulated across many commits, not a single
- * current-task edit.
- *
- * Aggregate patch-size rules emit `issue.file === AGGREGATE_PATCH_FILE`, a
- * synthetic placeholder that can never appear in a real `diffFiles` set.
- * Without special-casing, `large-patch-files` / `large-patch-lines` are
- * always tagged `[cumulative]` under `--only-introduced` even when the diff
- * is the aggregate the rules measured, which reads as "this pre-existed" to
- * an operator asking "what did this diff introduce?". The aggregate tag is
- * therefore promoted to `introduced` whenever the diff set has any content:
- * a non-empty `diffFiles` means the operator asked about a specific diff
- * scope, and the aggregate finding describes exactly that scope.
- *
- * @param issues Issues returned by the lint orchestrator.
- * @param diffFiles File paths touched since the user's revision.
- */
-export declare function tagLintIssues(issues: PatchLintIssue[], diffFiles: Set<string>): PatchLintIssue[];

package/dist/src/core/patch-lint-diff-tag.js

@@ -1,105 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Diff-scoping for `fireforge lint`.
- *
- * Pre-existing patch-state errors and errors introduced by the current task
- * print identically, so triaging "is the diff I just produced clean?"
- * otherwise means mentally subtracting the pre-existing noise. This module
- * classifies each lint issue as either `introduced` (the file was touched
- * since the user-supplied git revision) or `cumulative` (pre-existing
- * drift), without changing what the underlying rules emit.
- */
-import { toError } from '../utils/errors.js';
-import { verbose } from '../utils/logger.js';
-import { isMissingHeadError } from './git.js';
-import { git } from './git-base.js';
-import { getUntrackedFiles } from './git-status.js';
-/**
- * Collects engine-relative paths that changed between `rev` and `HEAD`,
- * plus any workdir modifications and untracked files. An empty set means
- * "no diff we can prove". Downstream treats every issue as `cumulative`
- * in that case (operator ran `lint --since HEAD` with no pending work).
- * @param engineDir Path to the engine git repository.
- * @param rev Git revision to diff against (e.g. `HEAD`, a branch, a SHA).
- */
-export async function collectDiffFilePaths(engineDir, rev) {
-    const files = new Set();
-    try {
-        const commitDiff = await git(['diff', '--name-only', `${rev}...HEAD`], engineDir);
-        for (const line of commitDiff.split('\n')) {
-            const trimmed = line.trim();
-            if (trimmed)
-                files.add(trimmed);
-        }
-    }
-    catch (error) {
-        if (!isMissingHeadError(error)) {
-            verbose(`lint --since: could not diff against ${rev} — ${toError(error).message}`);
-        }
-    }
-    try {
-        const worktreeDiff = await git(['diff', '--name-only', 'HEAD'], engineDir);
-        for (const line of worktreeDiff.split('\n')) {
-            const trimmed = line.trim();
-            if (trimmed)
-                files.add(trimmed);
-        }
-    }
-    catch (error) {
-        verbose(`lint --since: could not enumerate workdir diff — ${toError(error).message}`);
-    }
-    try {
-        for (const file of await getUntrackedFiles(engineDir)) {
-            files.add(file);
-        }
-    }
-    catch (error) {
-        verbose(`lint --since: could not list untracked files — ${toError(error).message}`);
-    }
-    return files;
-}
-/**
- * Synthetic "file" value used by aggregate patch-size rules
- * (`large-patch-files` / `large-patch-lines`) to flag that a finding
- * describes the whole diff rather than a single path. Exported so callers
- * can keep the tagging contract visible in one place.
- */
-export const AGGREGATE_PATCH_FILE = '(patch)';
-/**
- * Annotates a list of lint issues with `introduced` / `cumulative` tags
- * based on whether the issue's file is part of the supplied diff set.
- * Mutates each issue in place and returns the list for chaining.
- *
- * Issues with no file (`issue.file === ''`), for example cross-patch rules
- * that describe queue-wide state, are always `cumulative` under `--since`
- * because they describe drift accumulated across many commits, not a single
- * current-task edit.
- *
- * Aggregate patch-size rules emit `issue.file === AGGREGATE_PATCH_FILE`, a
- * synthetic placeholder that can never appear in a real `diffFiles` set.
- * Without special-casing, `large-patch-files` / `large-patch-lines` are
- * always tagged `[cumulative]` under `--only-introduced` even when the diff
- * is the aggregate the rules measured, which reads as "this pre-existed" to
- * an operator asking "what did this diff introduce?". The aggregate tag is
- * therefore promoted to `introduced` whenever the diff set has any content:
- * a non-empty `diffFiles` means the operator asked about a specific diff
- * scope, and the aggregate finding describes exactly that scope.
- *
- * @param issues Issues returned by the lint orchestrator.
- * @param diffFiles File paths touched since the user's revision.
- */
-export function tagLintIssues(issues, diffFiles) {
-    const hasDiffContent = diffFiles.size > 0;
-    for (const issue of issues) {
-        if (!issue.file) {
-            issue.tag = 'cumulative';
-            continue;
-        }
-        if (issue.file === AGGREGATE_PATCH_FILE) {
-            issue.tag = hasDiffContent ? 'introduced' : 'cumulative';
-            continue;
-        }
-        issue.tag = diffFiles.has(issue.file) ? 'introduced' : 'cumulative';
-    }
-    return issues;
-}

package/dist/src/core/patch-lint-diff.d.ts

@@ -1,42 +0,0 @@
-/**
- * Unified-diff walking helpers shared between per-patch lint rules,
- * cross-patch lint rules, and the export / re-export projection paths.
- *
- * Factored out of `patch-lint.ts` so the per-patch lint body and
- * cross-patch lint body (in `patch-lint-cross.ts`) can both depend on
- * the same diff walkers without inducing a circular import. Callers
- * should keep importing these through `patch-lint.ts`. This file is
- * an implementation detail. The actual line-walking lives in
- * `parseDiffSections` (patch-parse.ts), the codebase's single diff walker.
- */
-/**
- * Extracts new-file paths from a unified diff by scanning for `new file mode` markers.
- */
-export declare function detectNewFilesInDiff(diffContent: string): Set<string>;
-/**
- * Extracts added lines per file from a unified diff.
- * Returns a map of file path → array of added line contents (without the leading `+`).
- */
-export declare function extractAddedLinesPerFile(diffContent: string): Map<string, string[]>;
-/**
- * Extracts 1-based post-patch line numbers of added lines per file from a
- * unified diff. Walking each hunk with a new-file line counter (`+` and
- * context lines advance it, `-` lines do not) lets rules that need
- * full-file context (e.g. comment masking across the context/added
- * boundary) map the patch's additions onto the applied file.
- */
-export declare function extractAddedLineNumbersPerFile(diffContent: string): Map<string, number[]>;
-/**
- * Builds the `modifiedFileAdditions` map the cross-patch lint expects for
- * a given unified diff. Exposed so callers that construct synthetic /
- * projected `PatchQueueEntry` values (notably `re-export --files`
- * and `export --order`) can populate the field identically to
- * `buildPatchQueueContext`.
- *
- * Matches buildPatchQueueContext's algorithm exactly: skip paths that are
- * created by the diff, since those are already covered by the `newFiles` map,
- * which carries full content rather than only the added lines.
- *
- * @param diff - Unified diff content
- */
-export declare function buildModifiedFileAdditionsFromDiff(diff: string): Map<string, string>;

package/dist/src/core/patch-lint-diff.js

@@ -1,100 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Unified-diff walking helpers shared between per-patch lint rules,
- * cross-patch lint rules, and the export / re-export projection paths.
- *
- * Factored out of `patch-lint.ts` so the per-patch lint body and
- * cross-patch lint body (in `patch-lint-cross.ts`) can both depend on
- * the same diff walkers without inducing a circular import. Callers
- * should keep importing these through `patch-lint.ts`. This file is
- * an implementation detail. The actual line-walking lives in
- * `parseDiffSections` (patch-parse.ts), the codebase's single diff walker.
- */
-import { parseDiffSections } from './patch-parse.js';
-/**
- * Extracts new-file paths from a unified diff by scanning for `new file mode` markers.
- */
-export function detectNewFilesInDiff(diffContent) {
-    const newFiles = new Set();
-    for (const section of parseDiffSections(diffContent)) {
-        if (section.isNewFile) {
-            newFiles.add(section.targetPath);
-        }
-    }
-    return newFiles;
-}
-/**
- * Extracts added lines per file from a unified diff.
- * Returns a map of file path → array of added line contents (without the leading `+`).
- */
-export function extractAddedLinesPerFile(diffContent) {
-    const result = new Map();
-    for (const section of parseDiffSections(diffContent)) {
-        for (const hunk of section.hunks) {
-            for (const line of hunk.lines) {
-                if (!line.startsWith('+'))
-                    continue;
-                let arr = result.get(section.targetPath);
-                if (!arr) {
-                    arr = [];
-                    result.set(section.targetPath, arr);
-                }
-                arr.push(line.slice(1));
-            }
-        }
-    }
-    return result;
-}
-/**
- * Extracts 1-based post-patch line numbers of added lines per file from a
- * unified diff. Walking each hunk with a new-file line counter (`+` and
- * context lines advance it, `-` lines do not) lets rules that need
- * full-file context (e.g. comment masking across the context/added
- * boundary) map the patch's additions onto the applied file.
- */
-export function extractAddedLineNumbersPerFile(diffContent) {
-    const result = new Map();
-    for (const section of parseDiffSections(diffContent)) {
-        for (const hunk of section.hunks) {
-            let newLine = hunk.newStart;
-            for (const line of hunk.lines) {
-                if (line.startsWith('\\'))
-                    continue; // ""
-                if (line.startsWith('-'))
-                    continue;
-                if (line.startsWith('+')) {
-                    let arr = result.get(section.targetPath);
-                    if (!arr) {
-                        arr = [];
-                        result.set(section.targetPath, arr);
-                    }
-                    arr.push(newLine);
-                }
-                newLine++;
-            }
-        }
-    }
-    return result;
-}
-/**
- * Builds the `modifiedFileAdditions` map the cross-patch lint expects for
- * a given unified diff. Exposed so callers that construct synthetic /
- * projected `PatchQueueEntry` values (notably `re-export --files`
- * and `export --order`) can populate the field identically to
- * `buildPatchQueueContext`.
- *
- * Matches buildPatchQueueContext's algorithm exactly: skip paths that are
- * created by the diff, since those are already covered by the `newFiles` map,
- * which carries full content rather than only the added lines.
- *
- * @param diff - Unified diff content
- */
-export function buildModifiedFileAdditionsFromDiff(diff) {
-    const newFilePaths = detectNewFilesInDiff(diff);
-    const result = new Map();
-    for (const [file, lines] of extractAddedLinesPerFile(diff)) {
-        if (!newFilePaths.has(file))
-            result.set(file, lines.join('\n'));
-    }
-    return result;
-}

package/dist/src/core/patch-lint-file-size.d.ts

@@ -1,57 +0,0 @@
-/**
- * The `file-too-large` thresholds and their rendered message.
- *
- * Its own module for two reasons: the config validator needs the defaults
- * to validate an override triple against the merged result, and importing
- * `patch-lint.ts` from `config-validate.ts` for a constant would draw an
- * import edge (and a cycle) between the rule bodies and config parsing.
- *
- * On the vocabulary: the bands are `notice` / `warning` / `error`, and the
- * middle one is not a "soft limit". Under the posture FireForge itself
- * recommends for a release gate, `--max-warnings 0`, a warning is a hard
- * failure. The message below therefore says what the band is (a warning)
- * and what a zero-warning gate does with it, and the thresholds are tunable, so a project whose file-size
- * policy differs has a dial instead of an argument. The notice band is the
- * design target: advisory, and its message says so rather than borrowing
- * the warning band's gate sentence.
- */
-import type { PatchLintFileSizeThresholds } from '../types/config.js';
-/** A fully resolved threshold triple. */
-export interface ResolvedFileSizeTier {
-    notice: number;
-    warning: number;
-    error: number;
-}
-/** Built-in defaults, per file class. */
-export declare const DEFAULT_FILE_SIZE_THRESHOLDS: {
-    general: ResolvedFileSizeTier;
-    test: ResolvedFileSizeTier;
-};
-/**
- * Merges a configured override over the defaults for one file class.
- *
- * @param overrides - The `patchLint.fileSizeThresholds` block, if any
- * @param isTest - Whether the file counts as a test file
- * @returns The effective triple for this file
- */
-export declare function resolveFileSizeThresholds(overrides: PatchLintFileSizeThresholds | undefined, isTest: boolean): ResolvedFileSizeTier;
-/**
- * Renders the `file-too-large` message for a given band.
- *
- * Each band says what it means for a gate. A notice is over the design
- * target and advisory: it never fails `--max-warnings 0`, and saying it
- * did once got a test suite split for nothing. A warning is what a
- * zero-warning gate fails on, so it names that and the dial. Only the
- * error band suggests splitting, because a test-file split pushes against
- * one suite per subject and should not be the default advice below it.
- * Every band names the unit, which matters once `fileSizeMetric` makes
- * code lines a choice.
- */
-export declare function formatFileTooLargeMessage(args: {
-    label: string;
-    lineCount: number;
-    unit: 'lines' | 'code lines';
-    thresholds: ResolvedFileSizeTier;
-    band: 'notice' | 'warning' | 'error';
-    verb: string;
-}): string;

package/dist/src/core/patch-lint-file-size.js

@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The `file-too-large` thresholds and their rendered message.
- *
- * Its own module for two reasons: the config validator needs the defaults
- * to validate an override triple against the merged result, and importing
- * `patch-lint.ts` from `config-validate.ts` for a constant would draw an
- * import edge (and a cycle) between the rule bodies and config parsing.
- *
- * On the vocabulary: the bands are `notice` / `warning` / `error`, and the
- * middle one is not a "soft limit". Under the posture FireForge itself
- * recommends for a release gate, `--max-warnings 0`, a warning is a hard
- * failure. The message below therefore says what the band is (a warning)
- * and what a zero-warning gate does with it, and the thresholds are tunable, so a project whose file-size
- * policy differs has a dial instead of an argument. The notice band is the
- * design target: advisory, and its message says so rather than borrowing
- * the warning band's gate sentence.
- */
-/** Built-in defaults, per file class. */
-export const DEFAULT_FILE_SIZE_THRESHOLDS = {
-    general: { notice: 500, warning: 750, error: 900 },
-    test: { notice: 1200, warning: 1400, error: 1600 },
-};
-/**
- * Merges a configured override over the defaults for one file class.
- *
- * @param overrides - The `patchLint.fileSizeThresholds` block, if any
- * @param isTest - Whether the file counts as a test file
- * @returns The effective triple for this file
- */
-export function resolveFileSizeThresholds(overrides, isTest) {
-    const key = isTest ? 'test' : 'general';
-    const configured = overrides?.[key] ?? {};
-    return { ...DEFAULT_FILE_SIZE_THRESHOLDS[key], ...configured };
-}
-/**
- * Renders the `file-too-large` message for a given band.
- *
- * Each band says what it means for a gate. A notice is over the design
- * target and advisory: it never fails `--max-warnings 0`, and saying it
- * did once got a test suite split for nothing. A warning is what a
- * zero-warning gate fails on, so it names that and the dial. Only the
- * error band suggests splitting, because a test-file split pushes against
- * one suite per subject and should not be the default advice below it.
- * Every band names the unit, which matters once `fileSizeMetric` makes
- * code lines a choice.
- */
-export function formatFileTooLargeMessage(args) {
-    const { label, lineCount, unit, thresholds, band, verb } = args;
-    const measured = `${label} has ${lineCount} ${unit}`;
-    if (band === 'error') {
-        return `${measured} (error threshold: ${thresholds.error}). Consider ${verb}.`;
-    }
-    const limits = `(warning threshold: ${thresholds.warning}, error threshold: ${thresholds.error})`;
-    if (band === 'notice') {
-        return (`${measured}, over the design target of ${thresholds.notice} ${limits}. ` +
-            'Advisory; does not fail --max-warnings 0.');
-    }
-    return (`${measured} ${limits}. ` +
-        'Reported as a warning, which a gate running --max-warnings 0 treats as a failure; ' +
-        'tune "patchLint.fileSizeThresholds" if these limits are wrong for this project.');
-}