@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,436 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { readdir } from 'node:fs/promises';
-import { join, relative } from 'node:path';
-import { FurnaceError } from '../errors/furnace.js';
-import { toError } from '../utils/errors.js';
-import { copyFile, ensureDir, pathExists, readText, removeFile } from '../utils/fs.js';
-import { sha256Hex } from '../utils/hash.js';
-import { verbose } from '../utils/logger.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { buildCustomDryRunActions } from './furnace-apply-dry-run.js';
-import { applyCustomFtlFile, applySharedFtlPrune, removeCustomFtlJarMnEntry, } from './furnace-apply-ftl.js';
-import { normalizeForChecksum } from './furnace-checksum-utils.js';
-import { CUSTOM_ELEMENTS_JS, JAR_MN } from './furnace-constants.js';
-import { deployFileWithFragments, SHARED_FRAGMENTS_DIR } from './furnace-css-fragments.js';
-import { isRegularFile } from './furnace-dir-entry.js';
-import { addCustomElementRegistration, addJarMnEntries } from './furnace-registration.js';
-import { recordCreatedDir, snapshotFile } from './furnace-rollback.js';
-import { checkRegistrationConsistency } from './furnace-validate-registration.js';
-import { isGitRepository } from './git.js';
-import { fileExistsInHead, restoreTrackedPath } from './git-file-ops.js';
-/**
- * Filter deciding which files in an override workspace directory are candidates
- * for copying into the engine. Exported so `furnace remove` can invert apply
- * using the same file set: the "files to restore" set is defined as the
- * inverse of the "files apply would have written" set.
- */
-export function isOverrideCopyCandidate(entryName, type) {
-    if (entryName === 'override.json') {
-        return false;
-    }
-    if (type === 'css-only') {
-        return entryName.endsWith('.css');
-    }
-    return entryName.endsWith('.mjs') || entryName.endsWith('.css') || entryName.endsWith('.ftl');
-}
-/** Resolves the engine destination path for a single override-managed file. */
-export function getOverrideEngineTargetPath(engineDir, config, fileName, ftlDir) {
-    return fileName.endsWith('.ftl')
-        ? join(engineDir, ftlDir, fileName)
-        : join(engineDir, config.basePath, fileName);
-}
-/**
- * Restores a single override-deployed engine file to its pristine HEAD state,
- * inverting whatever apply wrote into that path.
- *
- * Behaviour matches the per-file branch of `restoreOverrideEngineFiles` in
- * `furnace remove`: snapshot first, then either `git restore` (if the file
- * exists in HEAD) or hard-delete (if the override introduced the file). The
- * caller must guarantee `engineDir` is a git repository. This helper does
- * not re-check, because both `furnace remove` and `furnace apply` already
- * own the precondition check at their entry points and re-checking on every
- * file would balloon git invocations.
- *
- * Returns the action taken so the caller can produce accurate user-facing
- * counts (`restored` vs `removed`). `noop` means the file was neither in HEAD
- * nor on disk, which can happen when the engine was reset out-of-band. The
- * caller should treat that as a successful no-op rather than an error.
- */
-export async function restoreOverrideFileToBaseline(engineDir, enginePath, journal) {
-    // Engine-relative paths are identifiers here, not filesystem arguments:
-    // they are handed to git, recorded in furnace state, and compared against
-    // the POSIX paths furnace.json and jar.mn already carry. `relative()`
-    // returns backslashes on Windows, so without this the same file has two
-    // spellings and every cross-check misses.
-    const relPath = normalizePathSlashes(relative(engineDir, enginePath));
-    // Snapshot before mutation so a later rollback can undo both restoration
-    // (writes whatever content we removed back) and deletion (recreates the
-    // file). Snapshotting a missing path records `{ existed: false }`, which
-    // restoreFile turns into a delete, the inverse of "we just wrote a file
-    // here", which is correct for the noop case too.
-    await snapshotFile(journal, enginePath);
-    if (await fileExistsInHead(engineDir, relPath)) {
-        await restoreTrackedPath(engineDir, relPath);
-        return 'restored';
-    }
-    if (await pathExists(enginePath)) {
-        await removeFile(enginePath);
-        return 'removed';
-    }
-    return 'noop';
-}
-/** Computes stable checksums for the source files that define a component. */
-export async function computeComponentChecksums(componentDir) {
-    const checksums = {};
-    const entries = await readdir(componentDir, { withFileTypes: true, encoding: 'utf8' });
-    for (const entry of entries) {
-        if (!isRegularFile(entry))
-            continue;
-        if (entry.name === 'override.json')
-            continue;
-        // The three extensions a component can deploy. Anything else in the
-        // workspace directory is not part of the component's checksum identity.
-        const { name: entryName } = entry;
-        if (!entryName.endsWith('.mjs') && !entryName.endsWith('.css') && !entryName.endsWith('.ftl'))
-            continue;
-        const content = await readText(join(componentDir, entry.name));
-        const hash = sha256Hex(normalizeForChecksum(content));
-        checksums[entry.name] = hash;
-    }
-    return checksums;
-}
-/**
- * Removes engine copies of files that the developer has deleted from a custom
- * component's workspace since the last apply. `.ftl` files live under the
- * shared Fluent tree (`engine/${FTL_DIR}`). Everything else lives under
- * `engine/${config.targetPath}`. Snapshots each removal into the journal so a
- * mid-apply failure can roll the engine back to its pre-undeploy state. Files
- * that are already missing from the engine are silently no-op (the engine
- * may have been reset out-of-band, and refusing here would surface a
- * confusing error in a recovery path).
- *
- * Does not touch jar.mn or customElements.js: registration churn is the
- * caller's responsibility, since it must coordinate with the new file list
- * computed by the regular apply step that follows.
- */
-export async function undeployCustomFiles(engineDir, config, deletedFiles, ftlDir, rollbackJournal) {
-    const removed = [];
-    for (const fileName of deletedFiles) {
-        const enginePath = fileName.endsWith('.ftl')
-            ? join(engineDir, ftlDir, fileName)
-            : join(engineDir, config.targetPath, fileName);
-        if (rollbackJournal) {
-            await snapshotFile(rollbackJournal, enginePath);
-        }
-        if (await pathExists(enginePath)) {
-            await removeFile(enginePath);
-            removed.push(normalizePathSlashes(relative(engineDir, enginePath)));
-        }
-        // When an `.ftl` is deleted from the workspace the corresponding locale
-        // jar.mn entry must also be dropped. Otherwise the chrome URI points at
-        // a missing file and runtime Fluent resolution breaks silently.
-        // `removeCustomFtlJarMnEntry` early-returns for `sharedFtl` components
-        // (the shared bundle is owned elsewhere).
-        await removeCustomFtlJarMnEntry(engineDir, fileName, ftlDir, config, rollbackJournal);
-    }
-    return removed;
-}
-/**
- * Restores or removes engine copies of files that the developer has deleted
- * from an override component's workspace since the last apply. Each file is
- * routed through `restoreOverrideFileToBaseline`, which restores it from
- * HEAD if it was a Firefox baseline file or hard-deletes it if the override
- * had introduced it.
- *
- * Requires `engineDir` to be a git repository: overrides cannot be inverted
- * without git HEAD as the source of truth. The caller is expected to have
- * already validated this precondition for the apply path. We re-check here
- * so unit tests that exercise this helper directly cannot accidentally
- * silent-fail on a non-git fixture.
- */
-export async function undeployOverrideFiles(engineDir, config, deletedFiles, ftlDir, rollbackJournal) {
-    if (deletedFiles.length === 0) {
-        return { restored: [], removed: [] };
-    }
-    if (!rollbackJournal) {
-        throw new FurnaceError('Internal: undeployOverrideFiles requires a rollback journal so deletions can be undone on failure.');
-    }
-    if (!(await isGitRepository(engineDir))) {
-        throw new FurnaceError('Cannot undeploy override files: engine is not a git repository. Run "fireforge download" to initialise it.');
-    }
-    // Note: we do not re-filter `deletedFiles` through
-    // `isOverrideCopyCandidate(fileName, config.type)`. A file recorded in
-    // `previous` was already a valid copy candidate when it was deployed, and
-    // re-filtering would block cleanup if the override type later flipped
-    // from `full` to `css-only`, which is the case we need cleanup for.
-    const restored = [];
-    const removed = [];
-    for (const fileName of deletedFiles) {
-        const enginePath = getOverrideEngineTargetPath(engineDir, config, fileName, ftlDir);
-        const action = await restoreOverrideFileToBaseline(engineDir, enginePath, rollbackJournal);
-        const relPath = normalizePathSlashes(relative(engineDir, enginePath));
-        if (action === 'restored')
-            restored.push(relPath);
-        else if (action === 'removed')
-            removed.push(relPath);
-    }
-    return { restored, removed };
-}
-/** Compares current component file checksums against the previously recorded state. */
-export async function hasComponentChanged(componentDir, previousChecksums, currentChecksums) {
-    const current = currentChecksums ?? (await computeComponentChecksums(componentDir));
-    return componentChecksumsChanged(current, previousChecksums);
-}
-/** Pure checksum-map comparison used when the caller already walked the component. */
-function componentChecksumsChanged(current, previousChecksums) {
-    const currentKeys = Object.keys(current);
-    const previousKeys = Object.keys(previousChecksums);
-    if (currentKeys.length !== previousKeys.length) {
-        return true;
-    }
-    for (const key of currentKeys) {
-        if (current[key] !== previousChecksums[key]) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Detects whether an override component's deployed files are missing from the
- * engine or differ from the source. Used as a guard before skipping apply on a
- * checksum match, so that reset/download/manual engine edits do not leave the
- * caller with a stale "up to date" report.
- *
- * When `cachedEngineChecksums` is provided (populated on last successful apply),
- * the function computes a SHA-256 hash of the engine file and compares it
- * against the cached value. This avoids reading the full workspace source for
- * the comparison when the engine hash still matches, which is the common case
- * for projects with many components.
- */
-export async function hasOverrideEngineDrift(ctx, config, cachedEngineChecksums) {
-    const { engineDir, componentDir, ftlDir } = ctx;
-    const entries = await readdir(componentDir, { withFileTypes: true, encoding: 'utf8' });
-    for (const entry of entries) {
-        if (!isRegularFile(entry))
-            continue;
-        if (!isOverrideCopyCandidate(entry.name, config.type))
-            continue;
-        const enginePath = getOverrideEngineTargetPath(engineDir, config, entry.name, ftlDir);
-        if (!(await pathExists(enginePath))) {
-            return true;
-        }
-        const engineContent = normalizeForChecksum(await readText(enginePath));
-        // Fast path: compare engine content hash against cached value from last apply
-        if (cachedEngineChecksums) {
-            const engineHash = sha256Hex(engineContent);
-            const cachedHash = cachedEngineChecksums[entry.name];
-            if (cachedHash && engineHash !== cachedHash) {
-                return true;
-            }
-            if (cachedHash)
-                continue; // Hash match, skip full source comparison
-        }
-        // Slow path: byte-compare engine content against workspace source
-        const srcContent = normalizeForChecksum(await readText(join(componentDir, entry.name)));
-        if (srcContent !== engineContent) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Detects whether a custom component's deployed copies, jar.mn entries, or
- * customElements.js registration are missing from the engine or out of sync.
- * Delegates to `checkRegistrationConsistency` so the oracle stays aligned with
- * the validate command.
- */
-export async function hasCustomEngineDrift(ctx, config) {
-    const { root, name, componentDir, ftlDir } = ctx;
-    const status = await checkRegistrationConsistency(root, name, config, ftlDir);
-    if (!status.targetExists || !status.filesInSync) {
-        return true;
-    }
-    if (status.missingTargetFiles.length > 0 || status.driftedFiles.length > 0) {
-        return true;
-    }
-    if (!config.register) {
-        return false;
-    }
-    // Registration drift: only check jar.mn entries for the file types that
-    // actually exist in source. jarMn{Mjs,Css} are substring checks, so a
-    // component with only .mjs (no .css) should not be flagged when jarMnCss
-    // is false. That is the expected post-apply state, not drift.
-    const entries = await readdir(componentDir, { withFileTypes: true, encoding: 'utf8' });
-    let hasMjs = false;
-    let hasCss = false;
-    for (const entry of entries) {
-        if (!isRegularFile(entry))
-            continue;
-        if (entry.name.endsWith('.mjs'))
-            hasMjs = true;
-        else if (entry.name.endsWith('.css'))
-            hasCss = true;
-    }
-    if (!status.customElementsPresent || !status.customElementsCorrectBlock) {
-        return true;
-    }
-    if (hasMjs && !status.jarMnMjs) {
-        return true;
-    }
-    if (hasCss && !status.jarMnCss) {
-        return true;
-    }
-    return false;
-}
-/** Applies a custom component into the engine tree and captures registration step errors. */
-export async function applyCustomComponent(ctx, config, dryRun = false, rollbackJournal, applyOptions = {}) {
-    // `ftlDir` stays on the context (the FTL and dry-run callees below read
-    // it) but is not needed by name here.
-    const { engineDir, name, componentDir } = ctx;
-    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
-        throw new FurnaceError(`Invalid component name "${name}": must match /^[a-z][a-z0-9-]*$/`);
-    }
-    const targetDir = join(engineDir, config.targetPath);
-    const entries = await readdir(componentDir, { withFileTypes: true, encoding: 'utf8' });
-    const customSymlinks = entries.filter((e) => typeof e.isSymbolicLink === 'function' && e.isSymbolicLink());
-    if (customSymlinks.length > 0) {
-        verbose(`Skipped ${customSymlinks.length} symlink(s) in "${name}": ${customSymlinks.map((e) => e.name).join(', ')}`);
-    }
-    if (dryRun) {
-        const { actions, stepErrors } = await buildCustomDryRunActions(ctx, config, targetDir, entries);
-        return { affectedPaths: [], stepErrors, actions };
-    }
-    if (rollbackJournal && !(await pathExists(targetDir))) {
-        recordCreatedDir(rollbackJournal, targetDir);
-    }
-    await ensureDir(targetDir);
-    const affectedPaths = [];
-    const stepErrors = [];
-    const copiedFileNames = [];
-    // Collect copy candidates, then snapshot + copy in parallel. Snapshots
-    // must complete before any copy (they read the original content), but
-    // independent files can be processed concurrently.
-    const filesToCopy = entries.filter((entry) => isRegularFile(entry) && (entry.name.endsWith('.mjs') || entry.name.endsWith('.css')));
-    // Snapshot phase (serial: journal is not concurrent-safe for the same path)
-    for (const entry of filesToCopy) {
-        const dest = join(targetDir, entry.name);
-        if (rollbackJournal) {
-            await snapshotFile(rollbackJournal, dest);
-        }
-    }
-    // Copy phase (parallel: independent file writes to different paths).
-    // CSS files carrying @fireforge-include directives are written as their
-    // fragment-expanded form. The workspace source keeps only the directive,
-    // so shared CSS stays single-sourced.
-    const sharedDir = join(componentDir, '..', '..', SHARED_FRAGMENTS_DIR);
-    const copies = await Promise.allSettled(filesToCopy.map(async (entry) => {
-        const src = join(componentDir, entry.name);
-        const dest = join(targetDir, entry.name);
-        await deployFileWithFragments(src, dest, sharedDir);
-        affectedPaths.push(normalizePathSlashes(relative(engineDir, dest)));
-        copiedFileNames.push(entry.name);
-    }));
-    const failedCopy = copies.find((copy) => copy.status === 'rejected');
-    if (failedCopy?.status === 'rejected')
-        throw failedCopy.reason;
-    // See buildCustomDryRunActions for the rationale: when `sharedFtl` is set
-    // the shared bundle is owned elsewhere and FireForge must not copy or
-    // register a per-component `.ftl` on its behalf.
-    if (config.localized && !config.sharedFtl) {
-        await applyCustomFtlFile(ctx, affectedPaths, stepErrors, rollbackJournal);
-    }
-    else if (config.localized && config.sharedFtl) {
-        // Drop any dangling per-widget locale jar.mn entry that would point at a
-        // non-existent `<chromeSubPath>/<name>.ftl` and fail `mach build`. The
-        // shared bundle (a different chrome path/base name) is never touched.
-        await applySharedFtlPrune(ctx, config, affectedPaths, stepErrors, rollbackJournal);
-    }
-    if (config.register) {
-        try {
-            const modulePath = `chrome://global/content/elements/${name}.mjs`;
-            if (rollbackJournal) {
-                await snapshotFile(rollbackJournal, join(engineDir, CUSTOM_ELEMENTS_JS));
-            }
-            await addCustomElementRegistration(engineDir, name, modulePath, {
-                ...(applyOptions.markerComment !== undefined
-                    ? { markerComment: applyOptions.markerComment }
-                    : {}),
-            });
-            affectedPaths.push(CUSTOM_ELEMENTS_JS);
-        }
-        catch (error) {
-            stepErrors.push({
-                step: 'customElements.js registration',
-                error: toError(error).message,
-            });
-        }
-    }
-    if (copiedFileNames.length > 0) {
-        try {
-            if (rollbackJournal) {
-                await snapshotFile(rollbackJournal, join(engineDir, JAR_MN));
-            }
-            await addJarMnEntries(engineDir, name, copiedFileNames);
-            affectedPaths.push(JAR_MN);
-        }
-        catch (error) {
-            stepErrors.push({
-                step: 'jar.mn registration',
-                error: toError(error).message,
-            });
-        }
-    }
-    return { affectedPaths, stepErrors };
-}
-/** Applies an override component by copying its matching files onto the engine tree. */
-export async function applyOverrideComponent(ctx, config, dryRun = false, rollbackJournal) {
-    const { engineDir, name, componentDir, ftlDir } = ctx;
-    const targetDir = join(engineDir, config.basePath);
-    if (!(await pathExists(targetDir))) {
-        throw new FurnaceError(`Override target path not found in engine: ${config.basePath}`, name);
-    }
-    const entries = await readdir(componentDir, { withFileTypes: true, encoding: 'utf8' });
-    const overrideSymlinks = entries.filter((e) => typeof e.isSymbolicLink === 'function' && e.isSymbolicLink());
-    if (overrideSymlinks.length > 0) {
-        verbose(`Skipped ${overrideSymlinks.length} symlink(s) in "${name}": ${overrideSymlinks.map((e) => e.name).join(', ')}`);
-    }
-    if (dryRun) {
-        const actions = entries
-            .filter((entry) => isRegularFile(entry) && isOverrideCopyCandidate(entry.name, config.type))
-            .map((entry) => ({
-            component: name,
-            action: 'copy',
-            source: join(componentDir, entry.name),
-            target: getOverrideEngineTargetPath(engineDir, config, entry.name, ftlDir),
-            description: `Override ${entry.name} in ${entry.name.endsWith('.ftl') ? ftlDir : config.basePath}`,
-        }));
-        if (actions.length === 0) {
-            throw new FurnaceError(`No matching files found in override directory for "${name}"`, name);
-        }
-        return { affectedPaths: [], actions };
-    }
-    const affectedPaths = [];
-    const candidateEntries = entries.filter((entry) => isRegularFile(entry) && isOverrideCopyCandidate(entry.name, config.type));
-    // Snapshot phase (serial)
-    for (const entry of candidateEntries) {
-        const dest = getOverrideEngineTargetPath(engineDir, config, entry.name, ftlDir);
-        if (rollbackJournal) {
-            await snapshotFile(rollbackJournal, dest);
-        }
-    }
-    // Copy phase (parallel)
-    const copies = await Promise.allSettled(candidateEntries.map(async (entry) => {
-        const src = join(componentDir, entry.name);
-        const dest = getOverrideEngineTargetPath(engineDir, config, entry.name, ftlDir);
-        await copyFile(src, dest);
-        affectedPaths.push(normalizePathSlashes(relative(engineDir, dest)));
-    }));
-    const failedCopy = copies.find((copy) => copy.status === 'rejected');
-    if (failedCopy?.status === 'rejected')
-        throw failedCopy.reason;
-    if (affectedPaths.length === 0) {
-        throw new FurnaceError(`No matching files found in override directory for "${name}"`, name);
-    }
-    return { affectedPaths };
-}
-export { diffDeletedFiles, extractComponentChecksums, prefixChecksums, } from './furnace-checksum-utils.js';

package/dist/src/core/furnace-apply-output.d.ts

@@ -1,36 +0,0 @@
-import type { ApplyResult, DryRunAction } from '../types/furnace.js';
-type ApplyResultWithActions = ApplyResult & {
-    actions?: DryRunAction[];
-};
-/**
- * The reason breakdown appended to a "skipped N" summary, e.g.
- * ` (2 already current)`, so `Applied 0, skipped 1` says whether the
- * component was already current or skipped for another reason without
- * diffing the deployed files by hand. Empty when nothing was skipped.
- *
- * @param skipped - `result.skipped` from applyAllComponents
- * @returns The parenthesised breakdown with a leading space, or ''
- */
-export declare function formatSkipBreakdown(skipped: ApplyResult['skipped']): string;
-/**
- * Prints a standard summary of an apply result for both normal and dry-run flows.
- *
- * Dry-run output lists the planned actions collected by the apply helpers.
- * Normal output lists applied files, skipped components, and any step errors.
- * Errors are always printed after the main body.
- *
- * @param result - Result returned by applyAllComponents
- * @param isDryRun - Whether apply was invoked with dryRun=true
- */
-export declare function logApplyResult(result: ApplyResultWithActions, isDryRun: boolean): void;
-/**
- * Prints the operator-facing apply warnings (patch-owned overwrites) one
- * per line and returns how many were printed. Shared by `furnace apply`
- * and the pre-build source → engine sync, so a warning the apply computed
- * is never dropped on one path and printed on the other.
- *
- * @param warnings - `result.warnings` from applyAllComponents
- * @returns Number of warning lines printed
- */
-export declare function logApplyWarnings(warnings: readonly string[] | undefined): number;
-export {};

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

@@ -1,111 +0,0 @@
-import { error, info, success, warn } from '../utils/logger.js';
-/** Summary label and per-component explanation for each skip kind. */
-const SKIP_KIND_TEXT = {
-    'already-current': {
-        label: 'already current',
-        detail: 'already current: source unchanged since the last recorded apply (from any session) and the engine copy matches it',
-    },
-};
-/** The per-component line text for one skip. */
-function describeSkip(skipped) {
-    return skipped.kind !== undefined ? SKIP_KIND_TEXT[skipped.kind].detail : skipped.reason;
-}
-/**
- * The reason breakdown appended to a "skipped N" summary, e.g.
- * ` (2 already current)`, so `Applied 0, skipped 1` says whether the
- * component was already current or skipped for another reason without
- * diffing the deployed files by hand. Empty when nothing was skipped.
- *
- * @param skipped - `result.skipped` from applyAllComponents
- * @returns The parenthesised breakdown with a leading space, or ''
- */
-export function formatSkipBreakdown(skipped) {
-    if (skipped.length === 0)
-        return '';
-    const counts = new Map();
-    for (const entry of skipped) {
-        const label = entry.kind !== undefined ? SKIP_KIND_TEXT[entry.kind].label : entry.reason;
-        counts.set(label, (counts.get(label) ?? 0) + 1);
-    }
-    return ` (${[...counts].map(([label, count]) => `${count} ${label}`).join(', ')})`;
-}
-/**
- * Prints a standard summary of an apply result for both normal and dry-run flows.
- *
- * Dry-run output lists the planned actions collected by the apply helpers.
- * Normal output lists applied files, skipped components, and any step errors.
- * Errors are always printed after the main body.
- *
- * @param result - Result returned by applyAllComponents
- * @param isDryRun - Whether apply was invoked with dryRun=true
- */
-export function logApplyResult(result, isDryRun) {
-    if (isDryRun && result.actions && result.actions.length > 0) {
-        info('Planned actions:');
-        for (const action of result.actions) {
-            info(`  [${action.action}] ${action.component}: ${action.description}`);
-        }
-    }
-    else if (isDryRun) {
-        info('No actions would be performed.');
-    }
-    else if (result.rolledBack) {
-        // When the rollback journal was restored, entries in `applied` reflect
-        // what was attempted but no longer exists in the engine. Print them as
-        // "attempted" rather than "success" to avoid misleading the operator.
-        if (result.applied.length > 0) {
-            warn('The following components were applied but have been rolled back due to errors:');
-            for (const applied of result.applied) {
-                warn(`  ${applied.name} (${applied.type}) — rolled back`);
-                if (applied.stepErrors && applied.stepErrors.length > 0) {
-                    for (const stepErr of applied.stepErrors) {
-                        warn(`    ${applied.name}: [${stepErr.step}] ${stepErr.error}`);
-                    }
-                }
-            }
-        }
-    }
-    else {
-        for (const applied of result.applied) {
-            success(`${applied.name} (${applied.type}) → ${applied.filesAffected.length} files`);
-        }
-        for (const skipped of result.skipped) {
-            info(`${skipped.name} — ${describeSkip(skipped)}`);
-        }
-        for (const applied of result.applied) {
-            if (applied.stepErrors && applied.stepErrors.length > 0) {
-                for (const stepErr of applied.stepErrors) {
-                    const advisoryPrefix = stepErr.advisory === true ? '(advisory) ' : '';
-                    warn(`${applied.name}: ${advisoryPrefix}[${stepErr.step}] ${stepErr.error}`);
-                }
-            }
-        }
-    }
-    // Patch-owned overwrite warnings print on every non-dry-run
-    // outcome, including the rolled-back branch, where the overwrite
-    // happened before the rollback restored it and the operator still needs
-    // to know the deployed copy was momentarily replaced.
-    if (!isDryRun) {
-        logApplyWarnings(result.warnings);
-    }
-    for (const err of result.errors) {
-        error(`${err.name} — ${err.error}`);
-    }
-}
-/**
- * Prints the operator-facing apply warnings (patch-owned overwrites) one
- * per line and returns how many were printed. Shared by `furnace apply`
- * and the pre-build source → engine sync, so a warning the apply computed
- * is never dropped on one path and printed on the other.
- *
- * @param warnings - `result.warnings` from applyAllComponents
- * @returns Number of warning lines printed
- */
-export function logApplyWarnings(warnings) {
-    if (warnings === undefined)
-        return 0;
-    for (const line of warnings) {
-        warn(line);
-    }
-    return warnings.length;
-}

package/dist/src/core/furnace-apply-overwrite-warn.d.ts

@@ -1,67 +0,0 @@
-/**
- * Patch-owned overwrite warnings for `furnace apply`.
- *
- * For Furnace-managed components, apply overwrites the deployed engine
- * copies with the `components/` sources. A fix made directly in `engine/` and
- * exported into a patch (but never back-ported to the component source) is
- * silently undone by the next apply, and a plain drift line reads like
- * "someone's uncommitted work". This module detects that case before
- * the copy (deployed bytes differ from the component source and the file is
- * patch-owned) and produces a per-file warning naming the file, the owning
- * patch, and the consequence.
- *
- * The per-file byte comparison already exists:
- * `checkRegistrationConsistency` for custom components (fragment- and
- * ftl-aware) and the copy-candidate walk for overrides. This module only
- * surfaces what those comparisons compute.
- */
-import type { CustomComponentConfig, OverrideComponentConfig } from '../types/furnace.js';
-/** One deployed, patch-owned file about to be overwritten with different bytes. */
-export interface PatchOwnedOverwriteWarning {
-    component: string;
-    /** Engine-relative path of the deployed file being replaced. */
-    file: string;
-    /** Patch filenames claiming the path in patches.json. */
-    owners: string[];
-}
-/**
- * Loads the file → owning-patch map for the overwrite warning.
- * A missing or unreadable patches manifest degrades to an empty map. The
- * warning is advisory and must never block an apply.
- */
-export declare function loadPatchClaimsForApply(root: string): Promise<ReadonlyMap<string, readonly string[]>>;
-/** Appends formatted overwrite warnings onto the run's result. */
-export declare function recordOverwriteWarnings(result: {
-    warnings?: string[];
-}, warnings: readonly PatchOwnedOverwriteWarning[]): void;
-/** Renders the operator-facing warning line for one overwrite. */
-export declare function formatPatchOwnedOverwriteWarning(warning: PatchOwnedOverwriteWarning): string;
-/** Inputs for {@link findPatchOwnedOverwrites}, discriminated by component type. */
-export type PatchOwnedOverwriteProbe = {
-    type: 'custom';
-    root: string;
-    name: string;
-    config: CustomComponentConfig;
-    ftlDir: string;
-    patchClaims: ReadonlyMap<string, readonly string[]>;
-} | {
-    type: 'override';
-    engineDir: string;
-    name: string;
-    componentDir: string;
-    config: OverrideComponentConfig;
-    ftlDir: string;
-    patchClaims: ReadonlyMap<string, readonly string[]>;
-};
-/**
- * Finds deployed files this component's apply is about to overwrite whose
- * engine bytes differ from the component source and that are patch-owned.
- * A probe failure throws, for callers that refuse on the result.
- */
-export declare function probePatchOwnedOverwrites(args: PatchOwnedOverwriteProbe): Promise<PatchOwnedOverwriteWarning[]>;
-/**
- * {@link probePatchOwnedOverwrites} for the advisory warning: probe
- * failures degrade to a verbose line and an empty list. The apply itself
- * must not fail because the warning probe could not run.
- */
-export declare function findPatchOwnedOverwrites(args: PatchOwnedOverwriteProbe): Promise<PatchOwnedOverwriteWarning[]>;