@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/furnace-apply.js

@@ -1,465 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { FurnaceError } from '../errors/furnace.js';
-import { assert } from '../utils/assert.js';
-import { toError } from '../utils/errors.js';
-import { pathExists } from '../utils/fs.js';
-import { info } from '../utils/logger.js';
-import { captureComponentSources, componentSourceErrors } from './component-source-guard.js';
-import { getProjectPaths, loadConfig } from './config.js';
-import { assertComponentWriteBoundaries } from './engine-write-boundary.js';
-import { applyCustomComponent, applyOverrideComponent, computeComponentChecksums, diffDeletedFiles, extractComponentChecksums, hasComponentChanged, hasCustomEngineDrift, hasOverrideEngineDrift, prefixChecksums, undeployCustomFiles, undeployOverrideFiles, } from './furnace-apply-helpers.js';
-import { findPatchOwnedOverwrites, loadPatchClaimsForApply, recordOverwriteWarnings, } from './furnace-apply-overwrite-warn.js';
-import { buildCustomUndeployActions, buildOverrideUndeployActions, } from './furnace-apply-undeploy-actions.js';
-import { getFurnacePaths, loadFurnaceConfig, loadFurnaceState, updateFurnaceState, } from './furnace-config.js';
-import { CUSTOM_ELEMENTS_JS, JAR_MN, resolveFtlDir } from './furnace-constants.js';
-import { topologicalSortCustom } from './furnace-graph-utils.js';
-import { resolveFurnaceMarkerComment } from './furnace-marker.js';
-import { recordFurnaceRollbackFailure } from './furnace-operation.js';
-import { assertFurnaceEngineDirReady } from './furnace-precondition.js';
-import { addJarMnEntries, removeCustomElementRegistration } from './furnace-registration.js';
-import { removeJarMnFileEntries } from './furnace-registration-jar-inplace.js';
-import { createRollbackJournal, restoreRollbackJournalOrThrow, snapshotFile, } from './furnace-rollback.js';
-import { blockingStepErrors, hasBlockingStepErrors } from './furnace-step-errors.js';
-import { runPostApplyConsistencyChecks } from './furnace-validate-registration.js';
-export { computeComponentChecksums, prefixChecksums } from './furnace-apply-helpers.js';
-/**
- * Records one component's checksums into the run-wide accumulator, under the
- * flattened `type/name/file` keys the state file stores. A Map keeps the
- * accumulation explicit. The previous `Object.assign` merges read as if
- * they replaced the accumulator rather than adding to it.
- */
-function recordComponentChecksums(accumulator, checksums, type, name) {
-    for (const [key, value] of Object.entries(prefixChecksums(checksums, type, name))) {
-        accumulator.set(key, value);
-    }
-}
-function addMissingComponentError(result, name, directoryPath) {
-    result.errors.push({
-        name,
-        error: `Component directory not found: ${directoryPath}`,
-    });
-}
-/**
- * The skip both batch loops record when a component's source is unchanged
- * since the last recorded apply and its engine copy still matches. `reason`
- * keeps its long-standing text for API consumers; `kind` lets summaries
- * name it.
- */
-const ALREADY_CURRENT_SKIP = {
-    reason: 'No changes since last apply',
-    kind: 'already-current',
-};
-async function applyOverrideBatch(ctx) {
-    const { config, furnacePaths, state, engineDir, ftlDir, dryRun } = ctx;
-    const { result, allActions, newChecksums, rollbackJournal, componentName } = ctx;
-    const overrideEntries = Object.entries(config.overrides).filter(([name]) => !componentName || name === componentName);
-    const totalOverrides = overrideEntries.length;
-    let overrideIndex = 0;
-    for (const [name, overrideConfig] of overrideEntries) {
-        overrideIndex++;
-        if (!dryRun && totalOverrides > 1) {
-            info(`Applying override ${name} (${overrideIndex}/${totalOverrides})...`);
-        }
-        const componentDir = join(furnacePaths.overridesDir, name);
-        if (!(await pathExists(componentDir))) {
-            addMissingComponentError(result, name, `components/overrides/${name}`);
-            continue;
-        }
-        const previous = extractComponentChecksums(state.appliedChecksums, 'override', name);
-        const currentChecksums = await computeComponentChecksums(componentDir);
-        if (!dryRun) {
-            const changed = await hasComponentChanged(componentDir, previous, currentChecksums);
-            if (!changed) {
-                // Fast path holds only if the engine still reflects what we deployed.
-                // reset/download/manual edits can silently erase engine files, and
-                // the checksum record alone cannot detect that.
-                const cachedEngine = extractComponentChecksums(state.engineChecksums, 'override', name);
-                const drifted = await hasOverrideEngineDrift({ engineDir, componentDir, ftlDir }, overrideConfig, cachedEngine);
-                if (!drifted) {
-                    result.skipped.push({ name, ...ALREADY_CURRENT_SKIP });
-                    recordComponentChecksums(newChecksums, previous, 'override', name);
-                    continue;
-                }
-            }
-        }
-        try {
-            const filesAffectedTotal = [];
-            // Compute which files (if any) were removed from the workspace since
-            // the last apply. We do this for both dry-run and real runs so the
-            // planned-actions output stays honest.
-            const deletedFiles = diffDeletedFiles(previous, currentChecksums);
-            if (dryRun) {
-                if (deletedFiles.length > 0) {
-                    allActions.push(...buildOverrideUndeployActions(name, overrideConfig, engineDir, deletedFiles, ftlDir));
-                }
-            }
-            else if (deletedFiles.length > 0) {
-                const { restored, removed } = await undeployOverrideFiles(engineDir, overrideConfig, deletedFiles, ftlDir, rollbackJournal);
-                filesAffectedTotal.push(...restored, ...removed);
-            }
-            if (!dryRun) {
-                // Runs unconditionally, including when the component source
-                // changed, because the lost-work case is a deployed engine edit
-                // that the incoming copy is about to replace.
-                recordOverwriteWarnings(result, await findPatchOwnedOverwrites({
-                    type: 'override',
-                    engineDir,
-                    name,
-                    componentDir,
-                    config: overrideConfig,
-                    ftlDir,
-                    patchClaims: ctx.patchClaims,
-                }));
-            }
-            const { affectedPaths: filesAffected, actions } = await applyOverrideComponent({ engineDir, name, componentDir, ftlDir }, overrideConfig, dryRun, rollbackJournal);
-            if (dryRun && actions) {
-                allActions.push(...actions);
-            }
-            filesAffectedTotal.push(...filesAffected);
-            result.applied.push({ name, type: 'override', filesAffected: filesAffectedTotal });
-            if (!dryRun) {
-                recordComponentChecksums(newChecksums, currentChecksums, 'override', name);
-            }
-        }
-        catch (error) {
-            result.errors.push({
-                name,
-                error: toError(error).message,
-            });
-        }
-    }
-}
-/**
- * After undeploying deleted files, the in-engine jar.mn and
- * customElements.js still carry entries for the removed files. Re-sync them
- * by removing only the deleted files' jar.mn lines in place and adding any
- * live file that has none. If the .mjs itself was deleted, also drop
- * the customElements.js registration. Snapshots are taken under the same
- * journal so the undo path is symmetric with apply.
- */
-async function reconcileCustomRegistrationAfterUndeploy(args) {
-    const { engineDir, name, config, deletedFiles, currentChecksums, rollbackJournal, filesAffected, } = args;
-    if (!config.register || deletedFiles.length === 0)
-        return;
-    const deletedRegistrationFiles = deletedFiles.filter((f) => f.endsWith('.mjs') || f.endsWith('.css'));
-    if (deletedRegistrationFiles.length === 0)
-        return;
-    // jar.mn re-sync: drop only the deleted files' lines, so the rest of the
-    // widget's block keeps its order and the owning patch carries no reorder
-    // hunks. addJarMnEntries is idempotent, so the add pass inserts only a
-    // live file that has no line yet. The journal snapshot before the
-    // mutation gives us a clean rollback target.
-    if (rollbackJournal) {
-        await snapshotFile(rollbackJournal, join(engineDir, JAR_MN));
-    }
-    await removeJarMnFileEntries(engineDir, name, deletedRegistrationFiles);
-    const liveJarFiles = Object.keys(currentChecksums).filter((f) => f.endsWith('.mjs') || f.endsWith('.css'));
-    if (liveJarFiles.length > 0) {
-        await addJarMnEntries(engineDir, name, liveJarFiles);
-    }
-    filesAffected.push(JAR_MN);
-    // If the .mjs file itself was deleted, the customElements registration
-    // must go too. Otherwise we leave a dangling import in the Pattern B
-    // block that fails at runtime.
-    if (deletedFiles.includes(`${name}.mjs`)) {
-        if (rollbackJournal) {
-            await snapshotFile(rollbackJournal, join(engineDir, CUSTOM_ELEMENTS_JS));
-        }
-        await removeCustomElementRegistration(engineDir, name);
-        filesAffected.push(CUSTOM_ELEMENTS_JS);
-    }
-}
-async function applyCustomBatch(ctx, root, markerComment) {
-    const { config, furnacePaths, state, engineDir, ftlDir, dryRun } = ctx;
-    const { result, allActions, newChecksums, rollbackJournal, componentName } = ctx;
-    const allKnown = new Set([
-        ...config.stock,
-        ...Object.keys(config.overrides),
-        ...Object.keys(config.custom),
-    ]);
-    // Build a set of component names that failed during the override batch so
-    // custom components that compose them can be skipped. This includes both
-    // hard errors and step-error failures.
-    const failedDependencies = new Set();
-    for (const entry of result.errors) {
-        failedDependencies.add(entry.name);
-    }
-    for (const entry of result.applied) {
-        if (entry.stepErrors && entry.stepErrors.length > 0) {
-            failedDependencies.add(entry.name);
-        }
-    }
-    const sortedNames = topologicalSortCustom(config.custom).filter((name) => !componentName || name === componentName);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- names from Object.keys
-    const customEntries = sortedNames.map((name) => [name, config.custom[name]]);
-    const totalCustom = customEntries.length;
-    let customIndex = 0;
-    for (const [name, customConfig] of customEntries) {
-        customIndex++;
-        if (!dryRun && totalCustom > 1) {
-            info(`Applying custom component ${name} (${customIndex}/${totalCustom})...`);
-        }
-        if (customConfig.composes) {
-            const missing = customConfig.composes.filter((ref) => !allKnown.has(ref));
-            if (missing.length > 0) {
-                result.errors.push({
-                    name,
-                    error: `Composes unknown component(s): ${missing.join(', ')}. Each reference must be registered as stock, override, or custom.`,
-                });
-                failedDependencies.add(name);
-                continue;
-            }
-            // Skip this component if any of its composed dependencies failed.
-            const failedRefs = customConfig.composes.filter((ref) => failedDependencies.has(ref));
-            if (failedRefs.length > 0) {
-                result.errors.push({
-                    name,
-                    error: `Skipped: composed dependency ${failedRefs.join(', ')} failed to apply.`,
-                });
-                failedDependencies.add(name);
-                continue;
-            }
-        }
-        const componentDir = join(furnacePaths.customDir, name);
-        if (!(await pathExists(componentDir))) {
-            addMissingComponentError(result, name, `components/custom/${name}`);
-            continue;
-        }
-        const previous = extractComponentChecksums(state.appliedChecksums, 'custom', name);
-        const currentChecksums = await computeComponentChecksums(componentDir);
-        if (!dryRun) {
-            const changed = await hasComponentChanged(componentDir, previous, currentChecksums);
-            if (!changed) {
-                // As with overrides, the checksum record is not sufficient on its
-                // own: a reset/download that cleared the engine must trigger a
-                // re-apply even though the workspace is unchanged.
-                const drifted = await hasCustomEngineDrift({ root, name, componentDir, ftlDir }, customConfig);
-                if (!drifted) {
-                    result.skipped.push({ name, ...ALREADY_CURRENT_SKIP });
-                    recordComponentChecksums(newChecksums, previous, 'custom', name);
-                    continue;
-                }
-            }
-        }
-        try {
-            const filesAffectedTotal = [];
-            // Diff against previous to find files the developer has deleted from
-            // the workspace since last apply. Run for both dry-run and real apply
-            // so plan output and execution stay aligned.
-            const deletedFiles = diffDeletedFiles(previous, currentChecksums);
-            if (dryRun) {
-                if (deletedFiles.length > 0) {
-                    allActions.push(...buildCustomUndeployActions(name, customConfig, engineDir, deletedFiles, ftlDir));
-                }
-            }
-            else if (deletedFiles.length > 0) {
-                const removed = await undeployCustomFiles(engineDir, customConfig, deletedFiles, ftlDir, rollbackJournal);
-                filesAffectedTotal.push(...removed);
-            }
-            if (!dryRun) {
-                // Runs unconditionally, including on the `changed === true` path:
-                // that is when a deployed engine-only fix gets silently replaced
-                // (J6).
-                recordOverwriteWarnings(result, await findPatchOwnedOverwrites({
-                    type: 'custom',
-                    root,
-                    name,
-                    config: customConfig,
-                    ftlDir,
-                    patchClaims: ctx.patchClaims,
-                }));
-            }
-            const { affectedPaths: filesAffected, stepErrors, actions, } = await applyCustomComponent({ engineDir, name, componentDir, ftlDir }, customConfig, dryRun, rollbackJournal, markerComment !== undefined ? { markerComment } : {});
-            if (dryRun && actions) {
-                allActions.push(...actions);
-            }
-            if (!dryRun && deletedFiles.length > 0 && blockingStepErrors(stepErrors).length === 0) {
-                await reconcileCustomRegistrationAfterUndeploy({
-                    engineDir,
-                    name,
-                    config: customConfig,
-                    deletedFiles,
-                    currentChecksums,
-                    rollbackJournal,
-                    filesAffected: filesAffectedTotal,
-                });
-            }
-            filesAffectedTotal.push(...filesAffected);
-            result.applied.push({
-                name,
-                type: 'custom',
-                filesAffected: filesAffectedTotal,
-                ...(stepErrors.length > 0 ? { stepErrors } : {}),
-            });
-            // Only store checksums when the component applied without blocking
-            // step errors, so that partially failed components are re-applied on
-            // the next run. Advisory errors (FTL degradation) still persist, since
-            // re-applying cannot fix a fork that has no locale jar.mn.
-            if (!dryRun && blockingStepErrors(stepErrors).length === 0) {
-                recordComponentChecksums(newChecksums, currentChecksums, 'custom', name);
-            }
-        }
-        catch (error) {
-            result.errors.push({
-                name,
-                error: toError(error).message,
-            });
-        }
-    }
-}
-/**
- * Applies all override and custom components to the engine source tree.
- *
- * Unchanged components (matching checksums) are skipped. If any component
- * fails, FireForge restores only the engine files touched during this apply
- * attempt and leaves the state file unchanged.
- *
- * When `options.persistState` is false, the furnace state file is left alone
- * on success and the rollback journal is returned on the result so the caller
- * can restore the engine later (used by `furnace preview` to stage workspace
- * files for Storybook and then roll them back on teardown).
- *
- * @param root - Root directory of the project
- * @param dryRun - If true, enumerate planned actions without writing
- * @param options - Optional behavior flags. `persistState` controls whether
- *   the furnace state file is updated on success (preview teardown sets this
- *   to false to keep ownership of the journal). `operationContext` is the
- *   lifecycle-wrapper hook used by `runFurnaceMutation` so a Ctrl+C mid-apply
- *   can find the in-flight rollback journal.
- * @returns Summary of applied, skipped, and errored components (with actions
- *          when dry-run, and with rollbackJournal when persistState=false)
- */
-export async function applyAllComponents(root, dryRun = false, options) {
-    const persistState = options?.persistState ?? true;
-    const operationContext = options?.operationContext;
-    const config = await loadFurnaceConfig(root);
-    const state = await loadFurnaceState(root);
-    const { engine: engineDir } = getProjectPaths(root);
-    const furnacePaths = getFurnacePaths(root);
-    const ftlDir = resolveFtlDir(config.ftlBasePath);
-    // When `markerComment` is unset in fireforge.json, default it to
-    // `binaryName.toUpperCase()` so the furnace-emitted edits to upstream
-    // files (e.g. customElements.js) carry a marker that satisfies
-    // `lintModificationComments`. That rule keys on
-    // `${binaryName.toUpperCase()}:`. An explicit `markerComment` still wins.
-    const forgeConfig = await loadConfig(root).catch(() => undefined);
-    const markerComment = resolveFurnaceMarkerComment(forgeConfig);
-    await assertFurnaceEngineDirReady(engineDir);
-    if (!dryRun) {
-        await assertComponentWriteBoundaries(engineDir, config, ftlDir);
-    }
-    const sourceSnapshot = await captureComponentSources(furnacePaths, config, dryRun, options);
-    const rollbackJournal = dryRun ? undefined : createRollbackJournal();
-    if (rollbackJournal && operationContext) {
-        operationContext.registerJournal(rollbackJournal);
-    }
-    // Everything below this line can write to the engine. A real apply that
-    // reached it without a journal would have no way back: neither the
-    // lifecycle wrapper's throw path nor the signal handler can restore what
-    // was never captured. `operationContext` is legitimately absent for the
-    // few callers that drive apply outside the wrapper, so the invariant is on
-    // the journal itself.
-    assert(dryRun || rollbackJournal !== undefined, 'rollback journal created before a real apply');
-    const result = {
-        applied: [],
-        skipped: [],
-        errors: [],
-    };
-    const allActions = [];
-    const newChecksums = new Map();
-    const componentName = options?.componentName;
-    // When a single component is requested, validate it exists before running
-    // the batch functions (which would silently skip an unknown name).
-    if (componentName) {
-        const isKnown = componentName in config.overrides || componentName in config.custom;
-        if (!isKnown) {
-            throw new FurnaceError(`Component "${componentName}" not found in furnace.json. Run "fireforge furnace list" to see registered components.`, componentName);
-        }
-    }
-    // Patch-claim map for the overwrite warning: loaded once per
-    // apply. A missing/unreadable manifest degrades to an empty map. The
-    // warning is advisory and must never block the apply.
-    const patchClaims = await loadPatchClaimsForApply(root);
-    const batchContext = {
-        config,
-        furnacePaths,
-        state,
-        engineDir,
-        ftlDir,
-        dryRun,
-        result,
-        allActions,
-        newChecksums,
-        rollbackJournal,
-        componentName,
-        patchClaims,
-    };
-    await applyOverrideBatch(batchContext);
-    await applyCustomBatch(batchContext, root, markerComment);
-    result.errors.push(...(await componentSourceErrors(sourceSnapshot)));
-    // Check for any partial failures (blocking step errors on applied
-    // components). Advisory step errors (e.g. FTL degradation) are warnings
-    // and never gate rollback.
-    const hasApplyStepErrors = result.applied.some((entry) => hasBlockingStepErrors(entry));
-    // Orphaned components are implicitly cleaned up: newChecksums only
-    // contains entries for components that still exist in furnace.json,
-    // and it fully replaces state.appliedChecksums below.
-    if (!dryRun && !hasApplyStepErrors && result.errors.length === 0) {
-        await runPostApplyConsistencyChecks(root, config, result, ftlDir);
-    }
-    // Recompute after the consistency checks: they mutate entry.stepErrors
-    // when the applied output is inconsistent (e.g. a jar.mn entry that
-    // silently mis-landed). Reading the pre-check snapshot lets those failures
-    // skip rollback and persist checksums for a component known to be
-    // inconsistent, while the CLI simultaneously reports "failed to apply
-    // cleanly".
-    const hasStepErrors = result.applied.some((entry) => hasBlockingStepErrors(entry));
-    // --- Rollback on failure, persist on success (skip for dry-run) ---
-    if (!dryRun) {
-        if (result.errors.length > 0 || hasStepErrors) {
-            if (rollbackJournal) {
-                // This branch owns the rollback for the collected-errors case, so the
-                // lifecycle wrapper must not restore the same journal again if the
-                // restore below throws on its way out.
-                operationContext?.markRolledBack();
-                try {
-                    await restoreRollbackJournalOrThrow(rollbackJournal, 'Furnace apply failed');
-                    result.rolledBack = true;
-                }
-                catch (rollbackError) {
-                    // Rollback itself failed: the engine is in a partially restored
-                    // state. Persist a pending-repair marker so the next `fireforge
-                    // doctor --repair-furnace` run knows to reconcile.
-                    const failedComponents = result.errors.map((e) => e.name).join(', ');
-                    await recordFurnaceRollbackFailure(root, 'apply-rollback', `failed component(s): ${failedComponents || '(unknown)'}: ${toError(rollbackError).message}`);
-                    throw rollbackError;
-                }
-            }
-        }
-        else if (persistState) {
-            // After a successful apply, workspace checksums equal the engine content
-            // (we just copied workspace → engine). Store them as engineChecksums so
-            // drift detection can compare engine files against the cached hash
-            // instead of byte-comparing against workspace sources.
-            await updateFurnaceState(root, {
-                lastApply: new Date().toISOString(),
-                appliedChecksums: Object.fromEntries(newChecksums),
-                engineChecksums: Object.fromEntries(newChecksums),
-            });
-        }
-        else if (rollbackJournal) {
-            // Caller owns the journal and will restore on teardown.
-            result.rollbackJournal = rollbackJournal;
-        }
-    }
-    if (dryRun) {
-        result.actions = allActions;
-    }
-    return result;
-} /**
- * Shared context threaded through the batch apply loops. Bundles the state
- * both loops mutate (result/actions/checksums) with the immutable run
- * parameters. The 12-13 positional parameters this replaced let call sites
- * drift and made every new parameter a two-signature change.
- */

package/dist/src/core/furnace-checksum-utils.d.ts

@@ -1,25 +0,0 @@
-/** Extracts per-component checksums from the flattened state-file checksum map. */
-export declare function extractComponentChecksums(allChecksums: Record<string, string> | undefined, type: string, name: string): Record<string, string>;
-/** Prefixes component checksums so they can be stored in the flattened state format. */
-export declare function prefixChecksums(checksums: Record<string, string>, type: string, name: string): Record<string, string>;
-/**
- * Returns the filenames present in `previous` that are absent from
- * `current`, i.e. files we know we deployed last time but the workspace has
- * since deleted. The order of returned names is stable (sorted
- * alphabetically) so test snapshots and CLI output are deterministic.
- */
-export declare function diffDeletedFiles(previous: Record<string, string>, current: Record<string, string>): string[];
-/**
- * Canonical content normalization for every FireForge component checksum.
- *
- * Strips a leading BOM and folds CRLF to LF, so a file that differs from its
- * deployed copy only by line endings or a byte-order mark is not reported as
- * drift. Every comparison that decides "has this component changed?" must
- * use it. Otherwise `furnace status` and `furnace validate` can disagree
- * with `apply`'s skip fast-path about the same pair of files on a CRLF
- * checkout.
- *
- * @param content - Raw file content
- * @returns Content with the BOM removed and CRLF folded to LF
- */
-export declare function normalizeForChecksum(content: string): string;

package/dist/src/core/furnace-checksum-utils.js

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/** Extracts per-component checksums from the flattened state-file checksum map. */
-export function extractComponentChecksums(allChecksums, type, name) {
-    if (!allChecksums)
-        return {};
-    const prefix = `${type}/${name}/`;
-    const result = {};
-    for (const [key, value] of Object.entries(allChecksums)) {
-        if (key.startsWith(prefix)) {
-            result[key.slice(prefix.length)] = value;
-        }
-    }
-    return result;
-}
-/** Prefixes component checksums so they can be stored in the flattened state format. */
-export function prefixChecksums(checksums, type, name) {
-    const prefix = `${type}/${name}/`;
-    const result = {};
-    for (const [key, value] of Object.entries(checksums)) {
-        result[`${prefix}${key}`] = value;
-    }
-    return result;
-}
-/**
- * Returns the filenames present in `previous` that are absent from
- * `current`, i.e. files we know we deployed last time but the workspace has
- * since deleted. The order of returned names is stable (sorted
- * alphabetically) so test snapshots and CLI output are deterministic.
- */
-export function diffDeletedFiles(previous, current) {
-    const deleted = [];
-    for (const key of Object.keys(previous)) {
-        if (!(key in current)) {
-            deleted.push(key);
-        }
-    }
-    return deleted.sort();
-}
-/**
- * Canonical content normalization for every FireForge component checksum.
- *
- * Strips a leading BOM and folds CRLF to LF, so a file that differs from its
- * deployed copy only by line endings or a byte-order mark is not reported as
- * drift. Every comparison that decides "has this component changed?" must
- * use it. Otherwise `furnace status` and `furnace validate` can disagree
- * with `apply`'s skip fast-path about the same pair of files on a CRLF
- * checkout.
- *
- * @param content - Raw file content
- * @returns Content with the BOM removed and CRLF folded to LF
- */
-export function normalizeForChecksum(content) {
-    return content.replace(/^\uFEFF/, '').replace(/\r\n/g, '\n');
-}

package/dist/src/core/furnace-composed-source.d.ts

@@ -1,76 +0,0 @@
-/**
- * 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 type { FurnaceConfig } from '../types/furnace.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 declare function composeComponentSource(content: string, fileName: string, sharedDir: string): Promise<string>;
-/** The workspace source apply deploys to one engine path. */
-export interface FurnaceDeployedSource {
-    type: 'custom' | 'override';
-    component: string;
-    /** Source file name inside the component directory. */
-    fileName: string;
-    /** Absolute path of the workspace source. */
-    sourcePath: string;
-}
-/**
- * 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 declare function mapDeployedComponentSources(root: string, config: FurnaceConfig): Promise<Map<string, FurnaceDeployedSource>>;
-/**
- * Why a deployed engine file is safe to overwrite from its component
- * source even though no patch body or baseline explains it:
- *
- * - `composed-source`: it already equals the Furnace-composed current
- *   source, so the overwrite writes the same bytes;
- * - `fragment-refresh`: it differs from the composed source only inside
- *   Furnace-generated fragment expansions (a fragment changed since it was
- *   deployed), so the overwrite only refreshes generated text;
- * - `previous-deploy`: it is exactly the content Furnace's last recorded
- *   apply deployed (the source has moved on since), so the overwrite loses
- *   nothing that was not already a component source.
- */
-export type DeployedSourceMatch = 'composed-source' | 'fragment-refresh' | 'previous-deploy';
-/**
- * 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 declare function matchDeployedComponentFiles(root: string, engineDir: string, files: readonly string[]): Promise<Map<string, DeployedSourceMatch>>;