@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/furnace-validate-compatibility.js

@@ -1,295 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { pathExists, readText } from '../utils/fs.js';
-import { escapeRegex, hasRawCssColors } from '../utils/regex.js';
-import { getProjectPaths } from './config.js';
-import { createIssue } from './furnace-validate-helpers.js';
-async function validateMjsCompatibility(mjsPath, tagName, isLibrary) {
-    if (!(await pathExists(mjsPath)))
-        return [];
-    const mjsContent = await readText(mjsPath);
-    const issues = [];
-    if (hasRelativeModuleImport(mjsContent)) {
-        issues.push(createIssue(tagName, 'error', 'relative-import', 'Imports must use chrome:// URIs, not relative paths.'));
-    }
-    // A library component (kind: "library") deliberately defines no element:
-    // it exports a base class + helpers for other components to extend, so
-    // the define/extends requirements do not apply.
-    if (isLibrary) {
-        return issues;
-    }
-    if (!hasCustomElementDefineCall(mjsContent)) {
-        issues.push(createIssue(tagName, 'error', 'no-custom-element-define', 'Missing customElements.define() call. Component will not be registered.'));
-    }
-    if (!classExtendsMozLitElement(mjsContent)) {
-        issues.push(createIssue(tagName, 'error', 'not-moz-lit-element', 'Component class must extend MozLitElement.'));
-    }
-    return issues;
-}
-async function validateCssCompatibility(cssPath, tagName, type, config, root) {
-    if (!(await pathExists(cssPath)))
-        return [];
-    const rawCss = await readText(cssPath);
-    const cssContent = stripCssBlockComments(rawCss);
-    const issues = [];
-    if (hasRawCssColors(cssContent)) {
-        issues.push(createIssue(tagName, 'error', 'raw-color-value', 'Raw color value found. Use CSS custom properties (var(--...)) for design token consistency.'));
-    }
-    if (config?.tokenPrefix) {
-        const { allowlist, inheritedOverrideVars, runtimeVariables } = await getTokenPrefixContext(tagName, type, config, root);
-        // Auto-exempt component-local runtime channels: a CSS custom property
-        // both declared and consumed in the same file is a runtime state
-        // channel (e.g. `--cam-x`), not a design-token reference. See
-        // `runtimeVariables` in furnace.json for cross-component cases.
-        const localDeclarations = collectCssVariableDeclarations(cssContent);
-        for (const prop of collectCssVariableReferences(cssContent)) {
-            if (prop.startsWith(config.tokenPrefix))
-                continue;
-            if (allowlist.has(prop))
-                continue;
-            if (inheritedOverrideVars.has(prop))
-                continue;
-            if (runtimeVariables.has(prop))
-                continue;
-            if (localDeclarations.has(prop))
-                continue;
-            issues.push(createIssue(tagName, 'error', 'token-prefix-violation', `CSS references var(${prop}) which does not match the required token prefix "${config.tokenPrefix}". Use a design token, add to tokenAllowlist, or (for runtime state channels) list the variable in runtimeVariables.`));
-        }
-    }
-    // Flag excessive !important usage
-    const importantCount = (cssContent.match(/!important/g) ?? []).length;
-    if (importantCount > 3) {
-        issues.push(createIssue(tagName, 'warning', 'excessive-important', `Found ${importantCount} uses of !important. Minimize !important to avoid specificity issues; prefer structural CSS changes.`));
-    }
-    // Check for animations without prefers-reduced-motion
-    if (/(?:animation|transition)\s*:/m.test(cssContent) &&
-        !/@media\s*\(\s*prefers-reduced-motion/m.test(rawCss)) {
-        issues.push(createIssue(tagName, 'warning', 'missing-reduced-motion', 'CSS uses animation or transition without a prefers-reduced-motion media query. Add one for accessibility.'));
-    }
-    // Check for prefers-color-scheme without design token usage
-    if (/@media\s*\(\s*prefers-color-scheme/m.test(rawCss)) {
-        issues.push(createIssue(tagName, 'warning', 'prefers-color-scheme', 'CSS contains a prefers-color-scheme media query. Prefer using design tokens (CSS custom properties) for theming consistency.'));
-    }
-    return issues;
-}
-/**
- * Checks whether a tag name appears in an HTML template context (as an element
- * tag in a template literal) or as a CSS tag selector. Substring matches in
- * string literals, comments, or variable names are excluded.
- */
-function isReferencedAsElement(source, tagName) {
-    // Match as an HTML element: <tagName or </tagName
-    const htmlPattern = new RegExp(`</?${escapeRegex(tagName)}[\\s/>]`);
-    if (htmlPattern.test(source))
-        return true;
-    // Match as a CSS tag selector: standalone word at start of line or after combinators
-    const cssPattern = new RegExp(`(?:^|[\\s,>+~])${escapeRegex(tagName)}(?:[\\s,{:>+~.[#]|$)`, 'm');
-    if (cssPattern.test(source))
-        return true;
-    // Also accept querySelector/querySelectorAll('tagName') as intentional usage
-    const querySelectorPattern = new RegExp(`querySelector(?:All)?\\(\\s*["'\`]${escapeRegex(tagName)}(?:[\\s"'\`.,>+~:[#])`);
-    if (querySelectorPattern.test(source))
-        return true;
-    return false;
-}
-/**
- * Validates that composed tags declared in furnace.json are actually referenced
- * in the component's source (.mjs and .css) in an HTML template or CSS context.
- * A compose entry that is not referenced as an element tag is likely a metadata
- * error.
- */
-async function validateComposeReferences(componentDir, tagName, composes) {
-    if (composes.length === 0)
-        return [];
-    const issues = [];
-    const mjsPath = join(componentDir, `${tagName}.mjs`);
-    const cssPath = join(componentDir, `${tagName}.css`);
-    let mjsContent = '';
-    let cssContent = '';
-    if (await pathExists(mjsPath)) {
-        mjsContent = await readText(mjsPath);
-    }
-    if (await pathExists(cssPath)) {
-        cssContent = await readText(cssPath);
-    }
-    const combinedSource = mjsContent + cssContent;
-    for (const composed of composes) {
-        if (!isReferencedAsElement(combinedSource, composed)) {
-            issues.push(createIssue(tagName, 'warning', 'compose-not-referenced', `Declares composition of "${composed}" but no HTML template or CSS selector reference found in source files. Remove the entry from composes or add a reference.`));
-        }
-    }
-    return issues;
-}
-/**
- * Validates compatibility patterns in a component's .mjs and .css files.
- * Checks imports, class hierarchy, registration, design tokens, and compose references.
- */
-export async function validateCompatibility(componentDir, tagName, type, config, root) {
-    const issues = [];
-    const mjsPath = join(componentDir, `${tagName}.mjs`);
-    const cssPath = join(componentDir, `${tagName}.css`);
-    const isLibrary = type === 'custom' && config?.custom[tagName]?.kind === 'library';
-    const mjsIssues = await validateMjsCompatibility(mjsPath, tagName, isLibrary);
-    issues.push(...mjsIssues);
-    const cssIssues = await validateCssCompatibility(cssPath, tagName, type, config, root);
-    issues.push(...cssIssues);
-    // Compose reference validation (custom components only)
-    if (type === 'custom' && config) {
-        const customConfig = config.custom[tagName];
-        if (customConfig?.composes && customConfig.composes.length > 0) {
-            issues.push(...(await validateComposeReferences(componentDir, tagName, customConfig.composes)));
-            // Warn when a composed component is not registered in furnace.json
-            const allKnown = new Set([
-                ...config.stock,
-                ...Object.keys(config.overrides),
-                ...Object.keys(config.custom),
-            ]);
-            for (const composed of customConfig.composes) {
-                if (!allKnown.has(composed)) {
-                    issues.push(createIssue(tagName, 'warning', 'compose-not-registered', `Composes "${composed}" which is not registered in furnace.json. ` +
-                        'The dependency may be missing at runtime. Add it as stock, override, or custom.'));
-                }
-            }
-        }
-    }
-    return issues;
-}
-/** Removes CSS block comments before running simple string-based checks. */
-function stripCssBlockComments(content) {
-    return content.replace(/\/\*[\s\S]*?\*\//g, '');
-}
-/** Detects relative ES module imports in a component module file. */
-function hasRelativeModuleImport(mjsContent) {
-    return (/^\s*import\s.*from\s+["']\.\.?\//m.test(mjsContent) ||
-        /^\s*import\s+["']\.\.?\//m.test(mjsContent));
-}
-/** Detects whether a module defines a custom element at runtime. */
-function hasCustomElementDefineCall(mjsContent) {
-    return /customElements\.define\s*\(/.test(mjsContent);
-}
-/**
- * Detects whether the module's `customElements.define(...)` call includes a
- * literal `extends:` option (third argument). That shape is the marker for
- * a customized built-in element: the class extends a specific
- * `HTMLxxxElement` rather than the autonomous `MozLitElement` path.
- *
- * Firefox's own widgets use this pattern for toolkit anchors (e.g.
- * `moz-support-link` extends `HTMLAnchorElement` with
- * `customElements.define("moz-support-link", ..., { extends: "a" })`), and
- * the validator's `not-moz-lit-element` check must allow them through or
- * `furnace override` of a valid upstream component fails its own
- * `furnace validate` pass with nothing the operator can fix.
- */
-function hasCustomElementExtendsOption(mjsContent) {
-    // Match `customElements.define(..., { ..., extends: "..." })`. Tolerant of
-    // whitespace, line breaks, and other object properties. The `[^)]*` stops
-    // the inner greedy match at the closing define call paren so a later
-    // `define` call on a different custom element in the same module does
-    // not bleed its options in.
-    return /customElements\.define\s*\([^)]*\bextends\s*:\s*["'`]/.test(mjsContent);
-}
-/**
- * Checks whether a declared component class extends a valid element base.
- *
- * Two shapes are accepted:
- *
- * 1. Autonomous custom element: `class X extends MozLitElement`, the
- *    default FireForge pattern for fork-authored components and most
- *    toolkit widgets.
- * 2. Customized built-in: `class X extends HTML<Something>Element` paired
- *    with a `customElements.define(..., ..., { extends: "<tagname>" })`
- *    call. Firefox's `moz-support-link`, `moz-button-group` tabbing
- *    widgets, and a handful of other toolkit components use this form.
- *    `furnace override` of those components writes the original source
- *    verbatim and the validator must not reject them.
- *
- * A class that extends a plain `HTMLElement` without an `extends:` option
- * is still rejected. That is the legitimate `not-moz-lit-element` case
- * the rule was originally designed to catch.
- */
-function classExtendsMozLitElement(mjsContent) {
-    const hasClassDeclaration = /class\s+\w+\s+extends\s+/.test(mjsContent);
-    if (!hasClassDeclaration) {
-        // No class declaration, so skip this check since the component may use a
-        // different pattern (e.g. function-based). Other validators will catch
-        // structural issues.
-        return true;
-    }
-    if (/class\s+\w+\s+extends\s+MozLitElement\b/.test(mjsContent)) {
-        return true;
-    }
-    // Customized built-in: extend a specific HTMLxxxElement and the define
-    // call carries an `extends:` option. Both halves are required: a class
-    // that extends `HTMLAnchorElement` without the matching define option is
-    // almost certainly an author mistake, and a define call with `extends:`
-    // without a matching class is unreachable.
-    const extendsCustomizedBuiltin = /class\s+\w+\s+extends\s+HTML[A-Z]\w*Element\b/.test(mjsContent);
-    if (extendsCustomizedBuiltin && hasCustomElementExtendsOption(mjsContent)) {
-        return true;
-    }
-    return false;
-}
-/** Collects CSS custom property references used via var(--token-name). */
-function collectCssVariableReferences(cssContent) {
-    const referencedVariables = [];
-    const variablePattern = /var\(\s*(--[\w-]+)/g;
-    let match;
-    while ((match = variablePattern.exec(cssContent)) !== null) {
-        const variableName = match[1];
-        if (variableName) {
-            referencedVariables.push(variableName);
-        }
-    }
-    return referencedVariables;
-}
-/**
- * Collects CSS custom property *declarations*, i.e. names appearing on the
- * left-hand side of a `--name:` declaration. Used to auto-exempt
- * component-local runtime variables from the token-prefix check: if the
- * component both declares and consumes a variable in its own CSS file, it
- * is a local runtime channel, not a design-token reference.
- *
- * The anchor `(?:^|[{;,\s])` rules out `var(--name)` occurrences (which are
- * always preceded by `(`), so references are not mistaken for declarations.
- */
-function collectCssVariableDeclarations(cssContent) {
-    const declared = new Set();
-    const pattern = /(?:^|[{;,\s])(--[\w-]+)\s*:/g;
-    let match;
-    while ((match = pattern.exec(cssContent)) !== null) {
-        const name = match[1];
-        if (name)
-            declared.add(name);
-    }
-    return declared;
-}
-async function collectInheritedOverrideVariables(tagName, config, root) {
-    const inheritedVariables = new Set();
-    const basePath = config.overrides[tagName]?.basePath;
-    if (!basePath) {
-        return inheritedVariables;
-    }
-    const { engine: engineDir } = getProjectPaths(root);
-    const originalCssPath = join(engineDir, basePath, `${tagName}.css`);
-    if (!(await pathExists(originalCssPath))) {
-        return inheritedVariables;
-    }
-    const originalCssContent = stripCssBlockComments(await readText(originalCssPath));
-    for (const variableName of collectCssVariableReferences(originalCssContent)) {
-        inheritedVariables.add(variableName);
-    }
-    return inheritedVariables;
-}
-/** Builds token-validation context from the config allowlist and inherited override CSS. */
-async function getTokenPrefixContext(tagName, type, config, root) {
-    const allowlist = new Set(config.tokenAllowlist ?? []);
-    const runtimeVariables = new Set(config.runtimeVariables ?? []);
-    if (type !== 'override' || !root) {
-        return { allowlist, inheritedOverrideVars: new Set(), runtimeVariables };
-    }
-    return {
-        allowlist,
-        inheritedOverrideVars: await collectInheritedOverrideVariables(tagName, config, root),
-        runtimeVariables,
-    };
-}

package/dist/src/core/furnace-validate-exceptions.d.ts

@@ -1,49 +0,0 @@
-/**
- * Applies `furnace.json#validationExceptions[]` to a `furnace validate`
- * result. An exception suppresses every finding of its check on its
- * component, or with `tag`, a finding whose element tags it (and its
- * sibling tag entries) cover, or with `file`, a finding whose module files
- * it (and its sibling file entries) cover. One that suppresses nothing is stale: the
- * finding was fixed (or renamed) and the review record outlived it, so it
- * is reported as a warning naming the entry to delete, which keeps the
- * list honest under `--max-warnings 0`.
- *
- * An exception never suppresses an error: an error blocks apply, and a
- * review record cannot make a broken component deployable. The error stays
- * counted and the matching entry is reported as
- * `validation-exception-on-error`.
- */
-import type { FurnaceValidationException, ValidationIssue } from '../types/furnace.js';
-/** The check name of the warning a stale exception produces. */
-export declare const STALE_VALIDATION_EXCEPTION_CHECK = "stale-validation-exception";
-/** The check name of the error an exception matching an error produces. */
-export declare const EXCEPTION_ON_ERROR_CHECK = "validation-exception-on-error";
-/** A finding an exception suppressed, with the exception's reason. */
-export interface ExceptedValidationIssue extends ValidationIssue {
-    reason: string;
-}
-/** {@link applyValidationExceptions}'s result. */
-export interface ValidationExceptionOutcome {
-    /** Findings that still count, stale-exception warnings included. */
-    issues: ValidationIssue[];
-    /** Findings an exception suppressed. */
-    excepted: ExceptedValidationIssue[];
-    /** Exceptions that matched no finding of a component this run judged. */
-    stale: FurnaceValidationException[];
-}
-/**
- * Splits findings into counted and excepted, and reports stale exceptions.
- *
- * @param issues - Every finding of the run
- * @param exceptions - `furnace.json#validationExceptions`
- * @param judged - Whether the run judged an exception's component. A run
- *   scoped to one component cannot call another component's exception
- *   stale, while the full run judges them all (including components
- *   furnace.json no longer declares)
- */
-export declare function applyValidationExceptions(issues: readonly ValidationIssue[], exceptions: readonly FurnaceValidationException[] | undefined, judged: (component: string) => boolean): ValidationExceptionOutcome;
-/** Counts error- and warning-severity findings. */
-export declare function countValidationSeverities(issues: readonly ValidationIssue[]): {
-    errors: number;
-    warnings: number;
-};

package/dist/src/core/furnace-validate-exceptions.js

@@ -1,98 +0,0 @@
-import { createIssue } from './furnace-validate-helpers.js';
-/** The check name of the warning a stale exception produces. */
-export const STALE_VALIDATION_EXCEPTION_CHECK = 'stale-validation-exception';
-/** The check name of the error an exception matching an error produces. */
-export const EXCEPTION_ON_ERROR_CHECK = 'validation-exception-on-error';
-function matches(exception, issue) {
-    return exception.component === issue.component && exception.check === issue.check;
-}
-/** An exception's narrowing: the finding field it reads and its value. */
-function scopeOf(entry) {
-    if (entry.tag !== undefined)
-        return { key: 'tags', value: entry.tag };
-    if (entry.file !== undefined)
-        return { key: 'files', value: entry.file };
-    return undefined;
-}
-/**
- * The exceptions that suppress a warning: an unscoped one alone, or scoped
- * ones that together cover every tag (or every file) the finding names.
- */
-function coveringExceptions(issue, candidates) {
-    const unscoped = candidates.find((entry) => scopeOf(entry) === undefined);
-    if (unscoped !== undefined)
-        return [unscoped];
-    for (const key of ['tags', 'files']) {
-        const named = issue[key] ?? [];
-        if (named.length === 0)
-            continue;
-        const covering = named.map((value) => candidates.find((entry) => {
-            const scope = scopeOf(entry);
-            return scope?.key === key && scope.value === value;
-        }));
-        if (covering.every((entry) => entry !== undefined))
-            return [...new Set(covering)];
-    }
-    return [];
-}
-/**
- * Splits findings into counted and excepted, and reports stale exceptions.
- *
- * @param issues - Every finding of the run
- * @param exceptions - `furnace.json#validationExceptions`
- * @param judged - Whether the run judged an exception's component. A run
- *   scoped to one component cannot call another component's exception
- *   stale, while the full run judges them all (including components
- *   furnace.json no longer declares)
- */
-export function applyValidationExceptions(issues, exceptions, judged) {
-    const outcome = { issues: [], excepted: [], stale: [] };
-    const list = exceptions ?? [];
-    const used = new Set();
-    const onError = new Set();
-    for (const issue of issues) {
-        const candidates = list.filter((entry) => matches(entry, issue));
-        if (issue.severity === 'error') {
-            for (const entry of candidates) {
-                used.add(entry);
-                onError.add(entry);
-            }
-            outcome.issues.push(issue);
-            continue;
-        }
-        const covering = coveringExceptions(issue, candidates);
-        if (covering.length === 0) {
-            // A scoped exception that covers some of the tags (or files) is not
-            // stale: its element still carries the finding, beside one it does
-            // not cover.
-            for (const entry of candidates) {
-                const scope = scopeOf(entry);
-                if (scope !== undefined && issue[scope.key]?.includes(scope.value) === true) {
-                    used.add(entry);
-                }
-            }
-            outcome.issues.push(issue);
-            continue;
-        }
-        for (const entry of covering)
-            used.add(entry);
-        outcome.excepted.push({ ...issue, reason: covering.map((entry) => entry.reason).join('; ') });
-    }
-    for (const exception of onError) {
-        outcome.issues.push(createIssue(exception.component, 'error', EXCEPTION_ON_ERROR_CHECK, `furnace.json validationExceptions entry for [${exception.check}] matches an error, ` +
-            'which an exception cannot suppress. Fix the error, then delete the entry.'));
-    }
-    for (const exception of list) {
-        if (used.has(exception) || !judged(exception.component))
-            continue;
-        outcome.stale.push(exception);
-        outcome.issues.push(createIssue(exception.component, 'warning', STALE_VALIDATION_EXCEPTION_CHECK, `furnace.json validationExceptions entry for [${exception.check}] matches no finding. ` +
-            'Delete the entry: the finding it records is gone.'));
-    }
-    return outcome;
-}
-/** Counts error- and warning-severity findings. */
-export function countValidationSeverities(issues) {
-    const errors = issues.filter((issue) => issue.severity === 'error').length;
-    return { errors, warnings: issues.length - errors };
-}

package/dist/src/core/furnace-validate-helpers.d.ts

@@ -1,7 +0,0 @@
-/**
- * The one genuinely shared helper across the furnace validators. Every other
- * helper lives with the single validator that uses it.
- */
-import type { ValidationIssue } from '../types/furnace.js';
-/** Creates a normalized validation issue object. */
-export declare function createIssue(component: string, severity: ValidationIssue['severity'], check: ValidationIssue['check'], message: string): ValidationIssue;

package/dist/src/core/furnace-validate-helpers.js

@@ -1,4 +0,0 @@
-/** Creates a normalized validation issue object. */
-export function createIssue(component, severity, check, message) {
-    return { component, severity, check, message };
-}

package/dist/src/core/furnace-validate-icon-button.d.ts

@@ -1,7 +0,0 @@
-/**
- * Counts icon-only `<moz-button>` elements in the module's Lit templates
- * that carry neither `data-l10n-id` nor `aria-label`.
- *
- * @param content - The component module's source
- */
-export declare function countUnlabelledIconButtons(content: string): number;

package/dist/src/core/furnace-validate-icon-button.js

@@ -1,78 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The opt-in `icon-button-label` check (`furnace.json#optInChecks`): an
- * icon-only `<moz-button>` has no visible text, so its accessible name has
- * to come from `data-l10n-id` (whose FTL message carries the label or
- * `.aria-label`) or from `aria-label`. Without one, screen readers announce
- * just "button".
- *
- * Scans the Lit `html` templates of the component module only. A button
- * built with `document.createElement` is not seen.
- */
-import { collectLitTemplateRegions, parseTemplateAttributes } from './lit-template-regions.js';
-/**
- * Attributes (and their Lit property-binding spellings) that give the
- * button an accessible name. `parseTemplateAttributes` lowercases names,
- * so `.ariaLabel=${…}` arrives as `.arialabel`.
- */
-const NAMING_ATTRIBUTES = ['data-l10n-id', 'aria-label', '.arialabel'];
-/** Attributes that give the button a visible label, so it is not icon-only. */
-const LABEL_ATTRIBUTES = ['label', '.label'];
-/**
- * Whether the button's content has a non-blank character outside tags.
- * Scans instead of stripping tags, so nested or unbalanced markup cannot
- * leave a fragment behind that reads as text, and a `>` inside a quoted
- * attribute value does not end its tag.
- */
-function hasVisibleText(markup) {
-    let inTag = false;
-    let quote;
-    for (const char of markup) {
-        if (quote !== undefined) {
-            if (char === quote)
-                quote = undefined;
-        }
-        else if (inTag) {
-            if (char === '"' || char === "'")
-                quote = char;
-            else if (char === '>')
-                inTag = false;
-        }
-        else if (char === '<') {
-            inTag = true;
-        }
-        else if (char.trim() !== '') {
-            return true;
-        }
-    }
-    return false;
-}
-function isIconOnly(attrs, innerText) {
-    if (LABEL_ATTRIBUTES.some((name) => attrs.has(name)))
-        return false;
-    if (hasVisibleText(innerText))
-        return false;
-    const type = attrs.get('type') ?? '';
-    return attrs.has('iconsrc') || attrs.has('.iconsrc') || /(^|\s)icon(\s|$)/.test(type);
-}
-/**
- * Counts icon-only `<moz-button>` elements in the module's Lit templates
- * that carry neither `data-l10n-id` nor `aria-label`.
- *
- * @param content - The component module's source
- */
-export function countUnlabelledIconButtons(content) {
-    let count = 0;
-    for (const region of collectLitTemplateRegions(content)) {
-        const pattern = /<moz-button\b((?:"[^"]*"|'[^']*'|[^'">])*)>([\s\S]*?)<\/moz-button>/gi;
-        for (const match of region.matchAll(pattern)) {
-            const attrs = parseTemplateAttributes(match[1] ?? '');
-            if (!isIconOnly(attrs, match[2] ?? ''))
-                continue;
-            if (NAMING_ATTRIBUTES.some((name) => attrs.has(name)))
-                continue;
-            count++;
-        }
-    }
-    return count;
-}

package/dist/src/core/furnace-validate-registration.d.ts

@@ -1,67 +0,0 @@
-import type { CustomComponentConfig, FurnaceConfig, RegistrationStatus, StepError, ValidationIssue } from '../types/furnace.js';
-/**
- * Validates that all Furnace-managed .mjs components are registered in the
- * DOMContentLoaded/importESModule block (Pattern B), not the loadSubScript
- * block (Pattern A).
- *
- * @param root - Project root directory
- * @param config - Furnace configuration
- * @returns Array of validation issues for mis-placed registrations
- */
-export declare function validateRegistrationPatterns(root: string, config: FurnaceConfig): Promise<ValidationIssue[]>;
-/**
- * Checks registration consistency for a single custom component.
- *
- * Compares source files, engine target files, jar.mn entries, and
- * customElements.js registration for a given component.
- *
- * @param root - Project root directory
- * @param name - Component tag name
- * @param config - Custom component configuration
- * @returns Registration status with per-check booleans and drift info
- */
-export declare function checkRegistrationConsistency(root: string, name: string, config: CustomComponentConfig, ftlDir?: string): Promise<RegistrationStatus>;
-/**
- * Validates that each custom component with `register: true` has its .mjs and
- * .css entries in jar.mn.
- *
- * @param root - Project root directory
- * @param config - Furnace configuration
- * @returns Array of validation issues for missing jar.mn entries
- */
-export declare function validateJarMnEntries(root: string, config: FurnaceConfig): Promise<ValidationIssue[]>;
-/**
- * Runs `body` with the per-run caches enabled, then clears them.
- *
- * @param body - The batch to run
- * @returns Whatever `body` resolves to
- */
-export declare function withRegistrationValidationCache<T>(body: () => Promise<T>): Promise<T>;
-/**
- * Validates that components using design tokens have the tokens CSS
- * linked in at least one chrome host document. Without the link, tokens
- * silently resolve to nothing at runtime.
- *
- * Scan set is the union of (a) the configured `tokenHostDocuments` (or
- * the upstream default when unset) and (b) any `browser/base/content/*.xhtml`
- * document that references `tagName`. The auto-detection path catches
- * forks that mount components from a replacement chrome document without
- * having configured `tokenHostDocuments`. The warning fires only when
- * none of the documents in the final scan set link the tokens CSS.
- */
-export declare function validateTokenLink(componentDir: string, tagName: string, root: string, tokenPrefix?: string, tokenHostDocuments?: string[]): Promise<ValidationIssue[]>;
-/**
- * Post-apply registration consistency check for custom components.
- *
- * Detects customElements.js / jar.mn inconsistencies caused by a partial
- * apply. Errors are surfaced as step-level warnings on the affected
- * component rather than blocking the entire apply.
- */
-export declare function runPostApplyConsistencyChecks(root: string, config: {
-    custom: Record<string, CustomComponentConfig>;
-}, result: {
-    applied: Array<{
-        name: string;
-        stepErrors?: StepError[];
-    }>;
-}, ftlDir: string): Promise<void>;