@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/furnace-composed-source.js

@@ -1,167 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The Furnace-composed form of a component source, and the questions that
- * need it.
- *
- * `furnace apply` does not copy every source verbatim: a stylesheet with
- * `@fireforge-include` directives is deployed with each fragment body from
- * `components/shared/` inlined between the directive and its
- * `@fireforge-end-include` marker. Anything that compares a deployed engine
- * file with its source has to compare against that composed form, or a
- * freshly deployed widget reads as a large difference it is not:
- *
- *  - the unexported-drift belt (`build`/`test --refuse-unexported-drift`),
- *    which must not refuse to overwrite a deployed file with the very bytes
- *    it already holds;
- *  - `furnace diff`, which must show what the next apply would change.
- */
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { pathExists, readText } from '../utils/fs.js';
-import { sha256Hex } from '../utils/hash.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { isOverrideCopyCandidate } from './furnace-apply-helpers.js';
-import { extractComponentChecksums, normalizeForChecksum } from './furnace-checksum-utils.js';
-import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, loadFurnaceState, } from './furnace-config.js';
-import { resolveFtlDir } from './furnace-constants.js';
-import { expandCssFragments, listFragmentIncludes, stripExpandedFragments, } from './furnace-css-fragments.js';
-import { isRegularFile } from './furnace-dir-entry.js';
-/**
- * Composes one component source into the bytes apply deploys: a stylesheet
- * carrying include directives is fragment-expanded, anything else is
- * returned as is.
- *
- * @param content - Workspace source content
- * @param fileName - Source file name (only `.css` is ever expanded)
- * @param sharedDir - Absolute path of `components/shared/`
- * @returns The composed content
- * @throws FurnaceError when an included fragment is missing or nested
- */
-export async function composeComponentSource(content, fileName, sharedDir) {
-    if (!fileName.endsWith('.css') || listFragmentIncludes(content).length === 0)
-        return content;
-    return (await expandCssFragments(content, sharedDir)).expanded;
-}
-/**
- * Maps every engine-relative path `furnace apply` writes to the workspace
- * source it writes there: custom `.mjs`/`.css` into `targetPath`, a custom
- * component's own `.ftl` into the Fluent tree (never for `sharedFtl`), and
- * each override copy candidate onto its engine target.
- *
- * @param root - Project root
- * @param config - Loaded furnace.json
- * @returns Engine-relative path (POSIX) → deployed source
- */
-export async function mapDeployedComponentSources(root, config) {
-    const furnacePaths = getFurnacePaths(root);
-    const ftlDir = resolveFtlDir(config.ftlBasePath);
-    const sources = new Map();
-    for (const [component, custom] of Object.entries(config.custom)) {
-        const componentDir = join(furnacePaths.customDir, component);
-        for (const fileName of await listSourceFiles(componentDir)) {
-            let engineRel;
-            if (fileName.endsWith('.mjs') || fileName.endsWith('.css')) {
-                engineRel = normalizePathSlashes(join(custom.targetPath, fileName));
-            }
-            else if (fileName === `${component}.ftl` && custom.localized && !custom.sharedFtl) {
-                engineRel = normalizePathSlashes(join(ftlDir, fileName));
-            }
-            if (engineRel === undefined)
-                continue;
-            sources.set(engineRel, {
-                type: 'custom',
-                component,
-                fileName,
-                sourcePath: join(componentDir, fileName),
-            });
-        }
-    }
-    for (const [component, override] of Object.entries(config.overrides)) {
-        const componentDir = join(furnacePaths.overridesDir, component);
-        for (const fileName of await listSourceFiles(componentDir)) {
-            if (!isOverrideCopyCandidate(fileName, override.type))
-                continue;
-            // Same target rule as `getOverrideEngineTargetPath`, engine-relative.
-            const base = fileName.endsWith('.ftl') ? ftlDir : override.basePath;
-            sources.set(normalizePathSlashes(join(base, fileName)), {
-                type: 'override',
-                component,
-                fileName,
-                sourcePath: join(componentDir, fileName),
-            });
-        }
-    }
-    return sources;
-}
-async function listSourceFiles(componentDir) {
-    if (!(await pathExists(componentDir)))
-        return [];
-    const entries = await readdir(componentDir, { withFileTypes: true, encoding: 'utf8' });
-    return entries.filter((entry) => isRegularFile(entry)).map((entry) => entry.name);
-}
-/**
- * Classifies one deployed engine file against its component source.
- *
- * @returns The match, or undefined when the engine copy is explained by
- *   none of them (a real, unrecorded engine edit)
- */
-async function matchDeployedSource(engineContent, source, sharedDir, appliedChecksums) {
-    const sourceContent = await readText(source.sourcePath);
-    const engine = normalizeForChecksum(engineContent);
-    let composed;
-    try {
-        composed = await composeComponentSource(sourceContent, source.fileName, sharedDir);
-    }
-    catch {
-        // A missing fragment: no composed form exists. The other two
-        // comparisons below still apply.
-    }
-    if (composed !== undefined && normalizeForChecksum(composed) === engine) {
-        return 'composed-source';
-    }
-    const strippedEngine = stripExpandedFragments(engine);
-    if (listFragmentIncludes(sourceContent).length > 0 &&
-        strippedEngine === stripExpandedFragments(normalizeForChecksum(sourceContent))) {
-        return 'fragment-refresh';
-    }
-    const recorded = extractComponentChecksums(appliedChecksums, source.type, source.component)[source.fileName];
-    // Apply records the checksum of the (unexpanded) source it deployed, so
-    // an engine copy with its expansions collapsed hashes to that value
-    // exactly when it is that deployment.
-    if (recorded !== undefined && sha256Hex(strippedEngine) === recorded) {
-        return 'previous-deploy';
-    }
-    return undefined;
-}
-/**
- * For each engine-relative path, decides whether its current engine content
- * is a Furnace deployment of its component source (see
- * {@link DeployedSourceMatch}). Paths with no component source, an
- * unreadable engine copy, or content explained by none of the matches are
- * absent from the result.
- *
- * @param root - Project root
- * @param engineDir - Absolute engine directory
- * @param files - Engine-relative paths to classify
- * @returns Engine-relative path → match, for the matching paths only
- */
-export async function matchDeployedComponentFiles(root, engineDir, files) {
-    const matches = new Map();
-    if (files.length === 0 || !(await furnaceConfigExists(root)))
-        return matches;
-    const sources = await mapDeployedComponentSources(root, await loadFurnaceConfig(root));
-    const { sharedDir } = getFurnacePaths(root);
-    const { appliedChecksums } = await loadFurnaceState(root);
-    for (const file of files) {
-        const source = sources.get(file);
-        if (source === undefined)
-            continue;
-        const enginePath = join(engineDir, file);
-        if (!(await pathExists(enginePath)))
-            continue;
-        const match = await matchDeployedSource(await readText(enginePath), source, sharedDir, appliedChecksums);
-        if (match !== undefined)
-            matches.set(file, match);
-    }
-    return matches;
-}

package/dist/src/core/furnace-config-array-utils.d.ts

@@ -1,11 +0,0 @@
-/**
- * Shared string-array parsing for furnace.json validation. Lives in its own
- * module so `furnace-config-custom.ts` and `furnace-config-tokens.ts` can use
- * it without importing `furnace-config.ts`, which would create import cycles.
- */
-/**
- * Parses a JSON array-of-strings field from raw furnace config data.
- * @param value - Raw value from JSON
- * @param fieldName - Field label for error messages
- */
-export declare function parseStringArray(value: unknown, fieldName: string): string[];

package/dist/src/core/furnace-config-array-utils.js

@@ -1,26 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Shared string-array parsing for furnace.json validation. Lives in its own
- * module so `furnace-config-custom.ts` and `furnace-config-tokens.ts` can use
- * it without importing `furnace-config.ts`, which would create import cycles.
- */
-import { FurnaceError } from '../errors/furnace.js';
-import { isArray, isString } from '../utils/validation.js';
-/**
- * Parses a JSON array-of-strings field from raw furnace config data.
- * @param value - Raw value from JSON
- * @param fieldName - Field label for error messages
- */
-export function parseStringArray(value, fieldName) {
-    if (!isArray(value)) {
-        throw new FurnaceError(`Furnace config: "${fieldName}" must be an array`);
-    }
-    const items = [];
-    for (const item of value) {
-        if (!isString(item)) {
-            throw new FurnaceError(`Furnace config: "${fieldName}" array must contain only strings`);
-        }
-        items.push(item);
-    }
-    return items;
-}

package/dist/src/core/furnace-config-custom.d.ts

@@ -1,15 +0,0 @@
-/**
- * Parser for the `custom` entries in furnace.json. Extracted from
- * `furnace-config.ts` so the main config module stays under the
- * per-file LOC budget. The custom-component schema has grown to
- * carry opt-in fields (`composes`, `keyboardCovered`, `sharedFtl`) that
- * each add their own validation branch.
- */
-import type { CustomComponentConfig } from '../types/furnace.js';
-import type { JsonObject } from '../types/json.js';
-/**
- * Validates a custom component config object.
- * @param data - Raw data to validate
- * @param name - Component name for error messages
- */
-export declare function parseCustomConfig(data: JsonObject, name: string): CustomComponentConfig;

package/dist/src/core/furnace-config-custom.js

@@ -1,73 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Parser for the `custom` entries in furnace.json. Extracted from
- * `furnace-config.ts` so the main config module stays under the
- * per-file LOC budget. The custom-component schema has grown to
- * carry opt-in fields (`composes`, `keyboardCovered`, `sharedFtl`) that
- * each add their own validation branch.
- */
-import { FurnaceError } from '../errors/furnace.js';
-import { isExplicitAbsolutePath } from '../utils/paths.js';
-import { isBoolean, isString } from '../utils/validation.js';
-import { parseStringArray } from './furnace-config-array-utils.js';
-import { validateSharedFtl } from './shared-ftl.js';
-/**
- * Validates a custom component config object.
- * @param data - Raw data to validate
- * @param name - Component name for error messages
- */
-export function parseCustomConfig(data, name) {
-    if (!isString(data['description'])) {
-        throw new FurnaceError(`Furnace config: custom "${name}.description" must be a string`);
-    }
-    if (!isString(data['targetPath'])) {
-        throw new FurnaceError(`Furnace config: custom "${name}.targetPath" must be a string`);
-    }
-    if (data['targetPath'].includes('..') || data['targetPath'].includes('\0')) {
-        throw new FurnaceError(`Furnace config: custom "${name}.targetPath" must not contain ".." or null bytes (path traversal)`);
-    }
-    if (isExplicitAbsolutePath(data['targetPath'])) {
-        throw new FurnaceError(`Furnace config: custom "${name}.targetPath" must not be an absolute path`);
-    }
-    if (!isBoolean(data['register'])) {
-        throw new FurnaceError(`Furnace config: custom "${name}.register" must be a boolean`);
-    }
-    if (!isBoolean(data['localized'])) {
-        throw new FurnaceError(`Furnace config: custom "${name}.localized" must be a boolean`);
-    }
-    if (data['kind'] !== undefined && data['kind'] !== 'element' && data['kind'] !== 'library') {
-        throw new FurnaceError(`Furnace config: custom "${name}.kind" must be "element" or "library" when set`);
-    }
-    if (data['kind'] === 'library' && data['register']) {
-        throw new FurnaceError(`Furnace config: custom "${name}" has kind "library" but register: true — ` +
-            'a library exports no custom element; set register: false');
-    }
-    if (data['composes'] !== undefined) {
-        parseStringArray(data['composes'], `${name}.composes`);
-    }
-    if (data['keyboardCovered'] !== undefined && !isBoolean(data['keyboardCovered'])) {
-        throw new FurnaceError(`Furnace config: custom "${name}.keyboardCovered" must be a boolean when set`);
-    }
-    let sharedFtl;
-    if (data['sharedFtl'] !== undefined) {
-        const result = validateSharedFtl(data['sharedFtl'], { localized: data['localized'] });
-        if (!result.ok) {
-            throw new FurnaceError(`Furnace config: custom "${name}.sharedFtl" ${result.reason}`);
-        }
-        sharedFtl = result.value;
-    }
-    return {
-        description: data['description'],
-        targetPath: data['targetPath'],
-        register: data['register'],
-        localized: data['localized'],
-        ...(data['composes'] !== undefined
-            ? { composes: parseStringArray(data['composes'], `${name}.composes`) }
-            : {}),
-        ...(data['keyboardCovered'] === true ? { keyboardCovered: true } : {}),
-        // Explicit `kind: "element"` is the default. Normalize it away so the
-        // stored config carries the field only when it changes behavior.
-        ...(data['kind'] === 'library' ? { kind: 'library' } : {}),
-        ...(sharedFtl !== undefined ? { sharedFtl } : {}),
-    };
-}

package/dist/src/core/furnace-config-order.d.ts

@@ -1,8 +0,0 @@
-import type { FurnaceConfig } from '../types/furnace.js';
-import type { JsonObject } from '../types/json.js';
-/**
- * Orders furnace.json output using the existing file as the primary key
- * sequence, preserving unknown extension keys and appending newly supported
- * fields only when needed.
- */
-export declare function orderFurnaceConfigForWrite(existing: JsonObject | undefined, config: FurnaceConfig): JsonObject;

package/dist/src/core/furnace-config-order.js

@@ -1,90 +0,0 @@
-import { isJsonObject } from '../utils/validation.js';
-const FURNACE_CONFIG_TOP_LEVEL_KEYS = new Set([
-    'version',
-    'componentPrefix',
-    'tokenPrefix',
-    'tokenAllowlist',
-    'platformPrefixes',
-    'runtimeVariables',
-    'tokenHostDocuments',
-    'ftlBasePath',
-    'scanPaths',
-    'stock',
-    'overrides',
-    'custom',
-]);
-function orderObjectLikeExisting(existing, next) {
-    if (!existing)
-        return next;
-    const ordered = {};
-    for (const key of Object.keys(existing)) {
-        if (Object.hasOwn(next, key)) {
-            ordered[key] = next[key];
-        }
-    }
-    for (const key of Object.keys(next)) {
-        if (!Object.hasOwn(ordered, key)) {
-            ordered[key] = next[key];
-        }
-    }
-    return ordered;
-}
-function orderComponentMapLikeExisting(existing, next) {
-    if (!isJsonObject(next))
-        return next;
-    if (!isJsonObject(existing))
-        return next;
-    const ordered = {};
-    for (const key of Object.keys(existing)) {
-        if (Object.hasOwn(next, key)) {
-            const existingValue = existing[key];
-            const nextValue = next[key];
-            ordered[key] =
-                isJsonObject(existingValue) && isJsonObject(nextValue)
-                    ? orderObjectLikeExisting(existingValue, nextValue)
-                    : nextValue;
-        }
-    }
-    for (const key of Object.keys(next)) {
-        if (!Object.hasOwn(ordered, key)) {
-            ordered[key] = next[key];
-        }
-    }
-    return ordered;
-}
-/**
- * Orders furnace.json output using the existing file as the primary key
- * sequence, preserving unknown extension keys and appending newly supported
- * fields only when needed.
- */
-export function orderFurnaceConfigForWrite(existing, config) {
-    // FurnaceConfig is plain parsed-JSON data, but as an interface it carries
-    // no index signature, so the compiler cannot verify the JsonObject
-    // contract structurally, hence the double assertion. This is the one
-    // place a typed furnace config re-enters the raw-document world.
-    // eslint-disable-next-line no-restricted-syntax -- see above
-    const next = config;
-    if (!existing)
-        return next;
-    const ordered = {};
-    for (const key of Object.keys(existing)) {
-        if (key === 'overrides' || key === 'custom') {
-            ordered[key] = orderComponentMapLikeExisting(existing[key], next[key]);
-        }
-        else if (Object.hasOwn(next, key)) {
-            ordered[key] = next[key];
-        }
-        else if (!FURNACE_CONFIG_TOP_LEVEL_KEYS.has(key)) {
-            ordered[key] = existing[key];
-        }
-    }
-    for (const key of Object.keys(next)) {
-        if (Object.hasOwn(ordered, key))
-            continue;
-        ordered[key] =
-            key === 'overrides' || key === 'custom'
-                ? orderComponentMapLikeExisting(existing[key], next[key])
-                : next[key];
-    }
-    return ordered;
-}

package/dist/src/core/furnace-config-tokens.d.ts

@@ -1,17 +0,0 @@
-/**
- * Small validation helpers for furnace.json token-related fields. Extracted
- * from `furnace-config.ts` so the main config module stays under the per-file
- * LOC budget.
- */
-/**
- * Validates a `tokenHostDocuments` raw value. Each entry must be a non-empty
- * relative path contained in the engine tree. Throws `FurnaceError` on
- * violation. Does nothing for `undefined` (field is optional).
- */
-export declare function validateTokenHostDocuments(raw: unknown): void;
-/**
- * Validates a `runtimeVariables` raw value. Each entry must start with `--`
- * (it is a CSS custom property name). Throws `FurnaceError` on violation.
- * Does nothing for `undefined` (field is optional).
- */
-export declare function validateRuntimeVariables(raw: unknown): void;

package/dist/src/core/furnace-config-tokens.js

@@ -1,42 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Small validation helpers for furnace.json token-related fields. Extracted
- * from `furnace-config.ts` so the main config module stays under the per-file
- * LOC budget.
- */
-import { FurnaceError } from '../errors/furnace.js';
-import { isContainedRelativePath } from '../utils/paths.js';
-import { parseStringArray } from './furnace-config-array-utils.js';
-/**
- * Validates a `tokenHostDocuments` raw value. Each entry must be a non-empty
- * relative path contained in the engine tree. Throws `FurnaceError` on
- * violation. Does nothing for `undefined` (field is optional).
- */
-export function validateTokenHostDocuments(raw) {
-    if (raw === undefined)
-        return;
-    const docs = parseStringArray(raw, 'tokenHostDocuments');
-    for (const doc of docs) {
-        if (doc.trim() === '') {
-            throw new FurnaceError('Furnace config: "tokenHostDocuments" entries must be non-empty strings');
-        }
-        if (!isContainedRelativePath(doc)) {
-            throw new FurnaceError(`Furnace config: "tokenHostDocuments" entry "${doc}" must stay within the engine tree (no absolute paths, no "..")`);
-        }
-    }
-}
-/**
- * Validates a `runtimeVariables` raw value. Each entry must start with `--`
- * (it is a CSS custom property name). Throws `FurnaceError` on violation.
- * Does nothing for `undefined` (field is optional).
- */
-export function validateRuntimeVariables(raw) {
-    if (raw === undefined)
-        return;
-    const vars = parseStringArray(raw, 'runtimeVariables');
-    for (const name of vars) {
-        if (!name.startsWith('--')) {
-            throw new FurnaceError(`Furnace config: "runtimeVariables" entries must start with "--" (got ${JSON.stringify(name)})`);
-        }
-    }
-}

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

@@ -1,17 +0,0 @@
-import { type FurnaceOptInCheck, type FurnaceValidationException } from '../types/furnace.js';
-/**
- * Parses `validationExceptions[]`: `{ component, check, tag?, file?, reason }`
- * objects, no other keys, every field a non-empty string, at most one of
- * `tag` and `file` (a bare file name of the component), and no two entries
- * for the same component, check and scope.
- */
-export declare function parseValidationExceptions(raw: unknown): FurnaceValidationException[];
-/**
- * Parses `tokenSiblingSheets`: an object from a sheet glob to a non-empty
- * list of partner paths or globs.
- */
-export declare function parseTokenSiblingSheets(raw: unknown): Record<string, string[]>;
-/** Parses `minComponents`: a positive integer. */
-export declare function parseMinComponents(raw: unknown): number;
-/** Parses `optInChecks[]`: names from {@link FURNACE_OPT_IN_CHECKS}. */
-export declare function parseOptInChecks(raw: unknown): FurnaceOptInCheck[];

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

@@ -1,122 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Validators for the `furnace validate` and `token lint` policy fields of
- * furnace.json: `validationExceptions[]`, `optInChecks[]`, `minComponents`
- * and `tokenSiblingSheets`.
- *
- * Strict on purpose, like `buildAudit.unpackaged`: every exception is a
- * standing suppression of a finding, so a malformed one must fail at load
- * rather than quietly suppress nothing (or everything).
- */
-import { FurnaceError } from '../errors/furnace.js';
-import { FURNACE_OPT_IN_CHECKS, } from '../types/furnace.js';
-import { isArray, isObject, isString } from '../utils/validation.js';
-const EXCEPTION_KEYS = new Set(['component', 'check', 'tag', 'file', 'reason']);
-function requireNonEmptyString(entry, key, field) {
-    const value = entry[key];
-    if (!isString(value) || value.trim().length === 0) {
-        throw new FurnaceError(`Furnace config: "${field}.${key}" must be a non-empty string`);
-    }
-    return value;
-}
-/**
- * Parses `validationExceptions[]`: `{ component, check, tag?, file?, reason }`
- * objects, no other keys, every field a non-empty string, at most one of
- * `tag` and `file` (a bare file name of the component), and no two entries
- * for the same component, check and scope.
- */
-export function parseValidationExceptions(raw) {
-    if (!isArray(raw)) {
-        throw new FurnaceError('Furnace config: "validationExceptions" must be an array');
-    }
-    const seen = new Set();
-    return raw.map((entry, index) => {
-        const field = `validationExceptions[${String(index)}]`;
-        if (!isObject(entry)) {
-            throw new FurnaceError(`Furnace config: "${field}" must be an object with "component", "check" and "reason"`);
-        }
-        for (const key of Object.keys(entry)) {
-            if (!EXCEPTION_KEYS.has(key)) {
-                throw new FurnaceError(`Furnace config: "${field}" has unknown key "${key}"`);
-            }
-        }
-        const exception = {
-            component: requireNonEmptyString(entry, 'component', field),
-            check: requireNonEmptyString(entry, 'check', field),
-            reason: requireNonEmptyString(entry, 'reason', field),
-        };
-        if (entry['tag'] !== undefined)
-            exception.tag = requireNonEmptyString(entry, 'tag', field);
-        if (entry['file'] !== undefined) {
-            if (exception.tag !== undefined) {
-                throw new FurnaceError(`Furnace config: "${field}" may name a "tag" or a "file", not both`);
-            }
-            const file = requireNonEmptyString(entry, 'file', field);
-            if (/[\\/]/.test(file) || file === '.' || file === '..') {
-                throw new FurnaceError(`Furnace config: "${field}.file" must be a file name in the component's directory, not a path`);
-            }
-            exception.file = file;
-        }
-        const scope = exception.tag !== undefined
-            ? `tag:${exception.tag}`
-            : exception.file !== undefined
-                ? `file:${exception.file}`
-                : '';
-        const identity = `${exception.component}\u0000${exception.check}\u0000${scope}`;
-        if (seen.has(identity)) {
-            const on = exception.tag !== undefined
-                ? ` on <${exception.tag}>`
-                : exception.file !== undefined
-                    ? ` in ${exception.file}`
-                    : '';
-            throw new FurnaceError(`Furnace config: "${field}" repeats the exception for ${exception.component} [${exception.check}]${on}`);
-        }
-        seen.add(identity);
-        return exception;
-    });
-}
-function isOptInCheck(value) {
-    return FURNACE_OPT_IN_CHECKS.includes(value);
-}
-/**
- * Parses `tokenSiblingSheets`: an object from a sheet glob to a non-empty
- * list of partner paths or globs.
- */
-export function parseTokenSiblingSheets(raw) {
-    if (!isObject(raw)) {
-        throw new FurnaceError('Furnace config: "tokenSiblingSheets" must be an object');
-    }
-    const out = {};
-    for (const [pattern, partners] of Object.entries(raw)) {
-        const valid = isArray(partners) &&
-            partners.length > 0 &&
-            partners.every((partner) => isString(partner) && partner.trim() !== '');
-        if (pattern.includes('..') || !valid || partners.some((p) => String(p).includes('..'))) {
-            throw new FurnaceError(`Furnace config: "tokenSiblingSheets.${pattern}" must be a non-empty list of engine-relative paths or globs (no "..")`);
-        }
-        out[pattern] = partners;
-    }
-    return out;
-}
-/** Parses `minComponents`: a positive integer. */
-export function parseMinComponents(raw) {
-    if (typeof raw !== 'number' || !Number.isInteger(raw) || raw < 1) {
-        throw new FurnaceError('Furnace config: "minComponents" must be a positive integer');
-    }
-    return raw;
-}
-/** Parses `optInChecks[]`: names from {@link FURNACE_OPT_IN_CHECKS}. */
-export function parseOptInChecks(raw) {
-    if (!isArray(raw)) {
-        throw new FurnaceError('Furnace config: "optInChecks" must be an array');
-    }
-    const checks = [];
-    for (const value of raw) {
-        if (!isString(value) || !isOptInCheck(value)) {
-            throw new FurnaceError(`Furnace config: "optInChecks" entry ${JSON.stringify(value)} is not an opt-in check. Valid: ${FURNACE_OPT_IN_CHECKS.join(', ')}`);
-        }
-        if (!checks.includes(value))
-            checks.push(value);
-    }
-    return checks;
-}

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

@@ -1,32 +0,0 @@
-/**
- * Section validators for `validateFurnaceConfig`, split out of
- * `furnace-config.ts` to keep that module inside the per-file line
- * budget. Each helper owns one shape: the override entry, the stock
- * list, the named-component maps, and the optional-field tail.
- */
-import type { FurnaceConfig, OverrideComponentConfig } from '../types/furnace.js';
-import type { JsonObject, JsonValue } from '../types/json.js';
-/**
- * Validates an override component config object.
- * @param data - Raw data to validate
- * @param name - Component name for error messages
- */
-export declare function parseOverrideConfig(data: JsonObject, name: string): OverrideComponentConfig;
-/**
- * Parses and validates the `stock` component list: lowercase identifiers,
- * no duplicates.
- */
-export declare function parseStockList(raw: unknown): string[];
-/**
- * Parses one of the named-component maps (`overrides` / `custom`): the
- * map must be an object, every key a lowercase identifier, every value an
- * object handed to the kind-specific parser.
- */
-export declare function parseNamedComponentMap<T>(raw: JsonValue | undefined, kind: 'override' | 'custom', key: 'overrides' | 'custom', parse: (value: JsonObject, name: string) => T): Record<string, T>;
-/**
- * Copies the validated optional fields (token settings, platform
- * prefixes, ftl/jsconfig/scan paths) from the migrated raw config onto
- * the typed config, re-validating the path-shaped ones against
- * traversal.
- */
-export declare function applyOptionalFurnaceFields(migrated: JsonObject, config: FurnaceConfig): void;