@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,236 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { toError } from '../utils/errors.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { sha256Hex } from '../utils/hash.js';
-import { verbose, warn } from '../utils/logger.js';
-import { asEstree, getNodeSource, parseScript, walkAST } from './ast-utils.js';
-import { CUSTOM_ELEMENTS_JS, FTL_DIR, WIDGETS_DIR } from './furnace-constants.js';
-/** Path to the widgets directory within the engine source tree */
-/**
- * Additional Firefox source directories known to contain MozLitElement
- * components. Used by `--deep` scan mode to discover components beyond
- * the primary widgets directory.
- */
-export const DEEP_SCAN_PATHS = [
-    'browser/components/shopping',
-    'browser/components/migration',
-    'browser/components/firefoxview',
-    'browser/components/sidebar',
-    'browser/components/backup',
-    'toolkit/components/aboutprocesses',
-    'toolkit/components/printing',
-];
-/**
- * Module-level cache for parsed customElements.js registrations, keyed by
- * SHA-256 of the file content. Avoids re-parsing the same file within a
- * single process lifetime (scan → status → apply chain).
- */
-let registrationCache;
-/**
- * Parses customElements.js to extract tag-to-module mappings.
- *
- * Looks for registration patterns like:
- * ```
- * lazy.customElements.setElementCreationCallback("moz-button", () => {
- *   import("chrome://global/content/elements/moz-button.mjs");
- * });
- * ```
- *
- * @param engineDir - Path to the Firefox engine source root
- * @returns Map of tagName to module path
- */
-export async function scanCustomElementsRegistrations(engineDir) {
-    const registrations = new Map();
-    const filePath = join(engineDir, CUSTOM_ELEMENTS_JS);
-    if (!(await pathExists(filePath))) {
-        return registrations;
-    }
-    const content = await readText(filePath);
-    const contentHash = sha256Hex(content);
-    // Return cached result if file hasn't changed since last parse.
-    if (registrationCache && registrationCache.hash === contentHash) {
-        return new Map(registrationCache.registrations);
-    }
-    try {
-        const ast = parseScript(content);
-        const recordRegistration = (tagName, modulePath = '') => {
-            const existing = registrations.get(tagName);
-            if (existing && existing.length > 0 && modulePath.length === 0) {
-                return;
-            }
-            registrations.set(tagName, modulePath);
-        };
-        walkAST(ast, {
-            enter(node) {
-                if (node.type === 'ForOfStatement') {
-                    const forOf = asEstree(node);
-                    if (forOf.right.type !== 'ArrayExpression') {
-                        return;
-                    }
-                    const bodySource = getNodeSource(content, asEstree(forOf.body));
-                    if (!bodySource.includes('setElementCreationCallback')) {
-                        return;
-                    }
-                    for (const element of forOf.right.elements) {
-                        if (!element || element.type !== 'ArrayExpression')
-                            continue;
-                        const [tagNode, moduleNode] = element.elements;
-                        if (!tagNode || !moduleNode)
-                            continue;
-                        if (tagNode.type !== 'Literal' || moduleNode.type !== 'Literal')
-                            continue;
-                        if (typeof tagNode.value !== 'string' || typeof moduleNode.value !== 'string')
-                            continue;
-                        recordRegistration(tagNode.value, moduleNode.value);
-                    }
-                    return;
-                }
-                if (node.type !== 'CallExpression') {
-                    return;
-                }
-                const call = asEstree(node);
-                if (call.callee.type !== 'MemberExpression') {
-                    return;
-                }
-                const property = call.callee.property;
-                if (property.type !== 'Identifier' || property.name !== 'setElementCreationCallback') {
-                    return;
-                }
-                const [tagArg] = call.arguments;
-                if (!tagArg || tagArg.type !== 'Literal' || typeof tagArg.value !== 'string') {
-                    return;
-                }
-                const callSource = getNodeSource(content, call);
-                const moduleMatch = /(?:import|importESModule|loadSubScript)\(\s*"([^"]+)"/.exec(callSource) ??
-                    /(?:import|importESModule|loadSubScript)\(\s*'([^']+)'/.exec(callSource);
-                if (!moduleMatch?.[1]) {
-                    return;
-                }
-                recordRegistration(tagArg.value, moduleMatch[1]);
-            },
-        });
-    }
-    catch (parseError) {
-        // Best-effort scanner: if upstream syntax changes or the file is damaged,
-        // fall back to the old literal callback heuristic instead of failing the
-        // whole scan command.
-        const reason = toError(parseError).message;
-        warn(`AST parsing of customElements.js failed (${reason}). Falling back to regex-based heuristic. ` +
-            'Results may be incomplete — run "fireforge furnace validate" to verify registration consistency.');
-        verbose(`Scanner regex fallback activated due to parse error: ${reason}`);
-        const lines = content.split('\n');
-        for (const [i, line] of lines.entries()) {
-            const callbackMatch = /setElementCreationCallback\(\s*"([^"]+)"/.exec(line);
-            if (!callbackMatch?.[1])
-                continue;
-            const tagName = callbackMatch[1];
-            let modulePath = '';
-            const searchEnd = Math.min(i + 15, lines.length);
-            for (let j = i + 1; j < searchEnd; j++) {
-                const importLine = lines[j];
-                if (importLine === undefined)
-                    continue;
-                const importMatch = /(?:import|importESModule|loadSubScript)\(\s*"([^"]+)"/.exec(importLine);
-                if (importMatch?.[1]) {
-                    modulePath = importMatch[1];
-                    break;
-                }
-            }
-            registrations.set(tagName, modulePath);
-        }
-    }
-    // Cache results for subsequent calls within the same process.
-    registrationCache = { hash: contentHash, registrations: new Map(registrations) };
-    return registrations;
-}
-/**
- * Scans the widgets directory to discover all MozLitElement custom elements.
- *
- * Each subdirectory starting with `moz-` that contains a `.mjs` file is
- * considered a component. For each component, checks whether it has associated
- * CSS, Fluent localization, and customElements.js registration.
- *
- * @param engineDir - Path to the Firefox engine source root
- * @returns Array of discovered components
- */
-export async function scanWidgetsDirectory(engineDir, ftlDir, extraPaths, componentPrefix) {
-    const searchPaths = [WIDGETS_DIR, ...(extraPaths ?? [])];
-    const registrations = await scanCustomElementsRegistrations(engineDir);
-    const components = [];
-    const seen = new Set();
-    const prefix = componentPrefix ?? 'moz-';
-    for (const searchDir of searchPaths) {
-        const dirPath = join(engineDir, searchDir);
-        if (!(await pathExists(dirPath))) {
-            continue;
-        }
-        const entries = await readdir(dirPath, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory() || !entry.name.startsWith(prefix) || seen.has(entry.name)) {
-                continue;
-            }
-            const tagName = entry.name;
-            seen.add(tagName);
-            const componentDir = join(dirPath, tagName);
-            const componentEntries = await readdir(componentDir, { withFileTypes: true });
-            // Only include directories that contain a .mjs file
-            const hasMjs = componentEntries.some((e) => e.isFile() && e.name.endsWith('.mjs'));
-            if (!hasMjs) {
-                continue;
-            }
-            const hasCSS = componentEntries.some((e) => e.isFile() && e.name.endsWith('.css'));
-            const ftlPath = join(engineDir, ftlDir ?? FTL_DIR, `${tagName}.ftl`);
-            const hasFTL = await pathExists(ftlPath);
-            const isRegistered = registrations.has(tagName);
-            components.push({
-                tagName,
-                sourcePath: join(searchDir, tagName),
-                hasCSS,
-                hasFTL,
-                isRegistered,
-            });
-        }
-    }
-    return components;
-}
-/**
- * Gets detailed information about a single component by tag name.
- * @param engineDir - Path to the Firefox engine source root
- * @param tagName - Component tag name (e.g., "moz-button")
- * @returns Component details, or null if not found in the source tree
- */
-export async function getComponentDetails(engineDir, tagName, ftlDir) {
-    const componentDir = join(engineDir, WIDGETS_DIR, tagName);
-    if (!(await pathExists(componentDir))) {
-        return null;
-    }
-    const entries = await readdir(componentDir, { withFileTypes: true });
-    const hasMjs = entries.some((e) => e.isFile() && e.name.endsWith('.mjs'));
-    if (!hasMjs) {
-        return null;
-    }
-    const hasCSS = entries.some((e) => e.isFile() && e.name.endsWith('.css'));
-    const ftlPath = join(engineDir, ftlDir ?? FTL_DIR, `${tagName}.ftl`);
-    const hasFTL = await pathExists(ftlPath);
-    const registrations = await scanCustomElementsRegistrations(engineDir);
-    const isRegistered = registrations.has(tagName);
-    return {
-        tagName,
-        sourcePath: join(WIDGETS_DIR, tagName),
-        hasCSS,
-        hasFTL,
-        isRegistered,
-    };
-}
-/**
- * Checks whether a component directory exists in the engine source tree.
- * @param engineDir - Path to the Firefox engine source root
- * @param tagName - Component tag name (e.g., "moz-button")
- * @returns True if the component directory exists
- */
-export async function isComponentInEngine(engineDir, tagName) {
-    const componentDir = join(engineDir, WIDGETS_DIR, tagName);
-    return pathExists(componentDir);
-}

package/dist/src/core/furnace-stale-export.d.ts

@@ -1,60 +0,0 @@
-/**
- * Stale-furnace-source gate for `fireforge patch export` / `re-export`.
- *
- * Exports capture the deployed engine copies of furnace-managed files, not
- * the `components/` sources. Editing a component source and re-exporting its
- * owning patch without an intervening `furnace deploy`/`apply` silently
- * exports the stale deployed copy: per-patch lint then flags the old line
- * count and the patch body lags the source. This gate detects that sequence
- * by comparing component source directories against the checksums recorded
- * at the last apply (`FurnaceState.appliedChecksums`), the same signal
- * `warnIfFurnaceStale` uses for run/watch, and refuses the export unless
- * the operator passes `--allow-stale-furnace`.
- *
- * Checksum-based on purpose: git checkouts and `furnace refresh` churn
- * mtimes without content changes, so an mtime comparison would misfire.
- *
- * Probe failures (broken furnace config, missing state) degrade to a verbose
- * log and an empty result. A broken furnace setup must never block
- * non-furnace patch work.
- */
-/** One furnace component whose source drifted from its deployed copy. */
-export interface StaleFurnaceComponent {
-    /** Component name (furnace.json key). */
-    name: string;
-    /** Component flavor, which resolves the source directory root. */
-    type: 'custom' | 'override';
-    /** Engine-relative deployed prefix (`/`-terminated) the component owns. */
-    prefix: string;
-}
-/**
- * Returns the furnace components whose deployed engine copies the given
- * files fall under and whose `components/` sources have changed since the
- * last apply. Empty when furnace is not configured, never applied, or the
- * probe fails.
- *
- * Files are attributed per component: the custom `targetPath` / override
- * `basePath` prefixes, plus, for a localized non-sharedFtl custom
- * component, its exact deployed `<ftlDir>/<name>.ftl` file (the shared
- * FTL dir as a whole stays unclaimed, because sibling files there belong
- * to other components). `sharedFtl` bundles are not furnace-deployed (apply
- * only prunes a dangling per-widget jar.mn line), so they have no deployed
- * copy to go stale and get no candidate by design. The storybook stories
- * prefix is likewise skipped.
- *
- * @param projectRoot - Project root directory
- * @param files - Engine-relative paths the export will capture
- */
-export declare function findStaleFurnaceComponentsForFiles(projectRoot: string, files: readonly string[]): Promise<StaleFurnaceComponent[]>;
-/**
- * Gate helper for export/re-export: refuses (or, with `allow`, warns) when
- * any exported file belongs to a furnace component whose source changed
- * since the last apply, where the export would capture the stale deployed
- * copy.
- *
- * @param projectRoot - Project root directory
- * @param files - Engine-relative paths the export will capture
- * @param allow - True when the operator passed `--allow-stale-furnace`
- * @param command - Which command runs the gate (message wording only)
- */
-export declare function enforceFreshFurnaceSources(projectRoot: string, files: readonly string[], allow: boolean, command: 'export' | 're-export'): Promise<void>;

package/dist/src/core/furnace-stale-export.js

@@ -1,125 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Stale-furnace-source gate for `fireforge patch export` / `re-export`.
- *
- * Exports capture the deployed engine copies of furnace-managed files, not
- * the `components/` sources. Editing a component source and re-exporting its
- * owning patch without an intervening `furnace deploy`/`apply` silently
- * exports the stale deployed copy: per-patch lint then flags the old line
- * count and the patch body lags the source. This gate detects that sequence
- * by comparing component source directories against the checksums recorded
- * at the last apply (`FurnaceState.appliedChecksums`), the same signal
- * `warnIfFurnaceStale` uses for run/watch, and refuses the export unless
- * the operator passes `--allow-stale-furnace`.
- *
- * Checksum-based on purpose: git checkouts and `furnace refresh` churn
- * mtimes without content changes, so an mtime comparison would misfire.
- *
- * Probe failures (broken furnace config, missing state) degrade to a verbose
- * log and an empty result. A broken furnace setup must never block
- * non-furnace patch work.
- */
-import { GeneralError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
-import { pathExists } from '../utils/fs.js';
-import { verbose, warn } from '../utils/logger.js';
-import { extractComponentChecksums, hasComponentChanged } from './furnace-apply-helpers.js';
-import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, loadFurnaceState, } from './furnace-config.js';
-import { resolveFtlDir } from './furnace-constants.js';
-/**
- * Returns the furnace components whose deployed engine copies the given
- * files fall under and whose `components/` sources have changed since the
- * last apply. Empty when furnace is not configured, never applied, or the
- * probe fails.
- *
- * Files are attributed per component: the custom `targetPath` / override
- * `basePath` prefixes, plus, for a localized non-sharedFtl custom
- * component, its exact deployed `<ftlDir>/<name>.ftl` file (the shared
- * FTL dir as a whole stays unclaimed, because sibling files there belong
- * to other components). `sharedFtl` bundles are not furnace-deployed (apply
- * only prunes a dangling per-widget jar.mn line), so they have no deployed
- * copy to go stale and get no candidate by design. The storybook stories
- * prefix is likewise skipped.
- *
- * @param projectRoot - Project root directory
- * @param files - Engine-relative paths the export will capture
- */
-export async function findStaleFurnaceComponentsForFiles(projectRoot, files) {
-    try {
-        if (files.length === 0)
-            return [];
-        if (!(await furnaceConfigExists(projectRoot)))
-            return [];
-        const config = await loadFurnaceConfig(projectRoot);
-        const state = await loadFurnaceState(projectRoot);
-        if (!state.appliedChecksums)
-            return [];
-        const furnacePaths = getFurnacePaths(projectRoot);
-        const ftlDir = resolveFtlDir(config.ftlBasePath);
-        const ftlPrefix = ftlDir.endsWith('/') ? ftlDir : `${ftlDir}/`;
-        const candidates = [
-            ...Object.entries(config.overrides).map(([name, cfg]) => ({
-                name,
-                type: 'override',
-                prefix: cfg.basePath.endsWith('/') ? cfg.basePath : `${cfg.basePath}/`,
-                exactFiles: [],
-            })),
-            ...Object.entries(config.custom).map(([name, cfg]) => ({
-                name,
-                type: 'custom',
-                prefix: cfg.targetPath.endsWith('/') ? cfg.targetPath : `${cfg.targetPath}/`,
-                // A localized non-sharedFtl component also owns exactly one
-                // deployed file in the shared FTL dir (applyCustomFtlFile copies
-                // `<name>.ftl` there). sharedFtl bundles are not furnace-deployed.
-                exactFiles: cfg.localized && cfg.sharedFtl === undefined ? [`${ftlPrefix}${name}.ftl`] : [],
-            })),
-        ];
-        const stale = [];
-        for (const candidate of candidates) {
-            if (!files.some((file) => file.startsWith(candidate.prefix) || candidate.exactFiles.includes(file)))
-                continue;
-            const sourceRoot = candidate.type === 'override' ? furnacePaths.overridesDir : furnacePaths.customDir;
-            const sourceDir = `${sourceRoot}/${candidate.name}`;
-            if (!(await pathExists(sourceDir)))
-                continue;
-            const previous = extractComponentChecksums(state.appliedChecksums, candidate.type, candidate.name);
-            if (await hasComponentChanged(sourceDir, previous)) {
-                stale.push({ name: candidate.name, type: candidate.type, prefix: candidate.prefix });
-            }
-        }
-        return stale;
-    }
-    catch (error) {
-        verbose(`Stale-furnace export gate skipped due to an error: ${toError(error).message}`);
-        return [];
-    }
-}
-/**
- * Gate helper for export/re-export: refuses (or, with `allow`, warns) when
- * any exported file belongs to a furnace component whose source changed
- * since the last apply, where the export would capture the stale deployed
- * copy.
- *
- * @param projectRoot - Project root directory
- * @param files - Engine-relative paths the export will capture
- * @param allow - True when the operator passed `--allow-stale-furnace`
- * @param command - Which command runs the gate (message wording only)
- */
-export async function enforceFreshFurnaceSources(projectRoot, files, allow, command) {
-    const stale = await findStaleFurnaceComponentsForFiles(projectRoot, files);
-    if (stale.length === 0)
-        return;
-    const list = stale
-        .map((component) => `${component.name} (components/${component.type === 'custom' ? 'custom' : 'overrides'}/${component.name}/ → ${component.prefix})`)
-        .join(', ');
-    const message = `Component source${stale.length === 1 ? '' : 's'} changed since the last furnace apply: ${list}. ` +
-        `The deployed engine cop${stale.length === 1 ? 'y is' : 'ies are'} stale, so this ${command} would ` +
-        'capture the OLD component content into the patch. Run "fireforge furnace deploy" (or ' +
-        '"fireforge furnace apply") first so the export captures the current source, or pass ' +
-        '--allow-stale-furnace to export the deployed copy anyway.';
-    if (allow) {
-        warn(message);
-        return;
-    }
-    throw new GeneralError(message);
-}

package/dist/src/core/furnace-staleness.d.ts

@@ -1,24 +0,0 @@
-/**
- * Furnace staleness advisory, shared between `fireforge run` and
- * `fireforge watch`. Both commands launch the built browser without
- * first running `furnace apply`, so this helper surfaces a warning when
- * component files have drifted from the last-applied checksums and the
- * user is about to run with stale engine state.
- *
- * The check is advisory only: errors (broken furnace config, partial
- * state, transient filesystem failure) must never block the caller.
- */
-/**
- * Names of the tracked override and custom components whose source changed
- * on disk since the last apply, i.e. edits engine/ does not hold yet.
- * Throws on a broken config or state; {@link warnIfFurnaceStale} downgrades
- * that.
- */
-export declare function listStaleFurnaceComponents(projectRoot: string): Promise<string[]>;
-/**
- * Emits a warning when any tracked override or custom component has
- * changed on disk since the last apply. Safe to call from any build-time
- * command that does not auto-apply. A failure inside the probe is
- * downgraded to a verbose log and the caller continues.
- */
-export declare function warnIfFurnaceStale(projectRoot: string): Promise<void>;

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

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Furnace staleness advisory, shared between `fireforge run` and
- * `fireforge watch`. Both commands launch the built browser without
- * first running `furnace apply`, so this helper surfaces a warning when
- * component files have drifted from the last-applied checksums and the
- * user is about to run with stale engine state.
- *
- * The check is advisory only: errors (broken furnace config, partial
- * state, transient filesystem failure) must never block the caller.
- */
-import { pathExists } from '../utils/fs.js';
-import { verbose, warn } from '../utils/logger.js';
-import { extractComponentChecksums, hasComponentChanged } from './furnace-apply-helpers.js';
-import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, loadFurnaceState, } from './furnace-config.js';
-/**
- * Names of the tracked override and custom components whose source changed
- * on disk since the last apply, i.e. edits engine/ does not hold yet.
- * Throws on a broken config or state; {@link warnIfFurnaceStale} downgrades
- * that.
- */
-export async function listStaleFurnaceComponents(projectRoot) {
-    if (!(await furnaceConfigExists(projectRoot)))
-        return [];
-    const config = await loadFurnaceConfig(projectRoot);
-    const state = await loadFurnaceState(projectRoot);
-    const furnacePaths = getFurnacePaths(projectRoot);
-    if (!state.appliedChecksums)
-        return [];
-    const stale = [];
-    for (const name of Object.keys(config.overrides)) {
-        const dir = `${furnacePaths.overridesDir}/${name}`;
-        if (!(await pathExists(dir)))
-            continue;
-        const prev = extractComponentChecksums(state.appliedChecksums, 'override', name);
-        if (await hasComponentChanged(dir, prev))
-            stale.push(name);
-    }
-    for (const name of Object.keys(config.custom)) {
-        const dir = `${furnacePaths.customDir}/${name}`;
-        if (!(await pathExists(dir)))
-            continue;
-        const prev = extractComponentChecksums(state.appliedChecksums, 'custom', name);
-        if (await hasComponentChanged(dir, prev))
-            stale.push(name);
-    }
-    return stale;
-}
-/**
- * Emits a warning when any tracked override or custom component has
- * changed on disk since the last apply. Safe to call from any build-time
- * command that does not auto-apply. A failure inside the probe is
- * downgraded to a verbose log and the caller continues.
- */
-export async function warnIfFurnaceStale(projectRoot) {
-    try {
-        const stale = await listStaleFurnaceComponents(projectRoot);
-        if (stale.length > 0) {
-            warn(`Furnace component${stale.length === 1 ? '' : 's'} modified since last apply: ${stale.join(', ')}. ` +
-                'Run "fireforge furnace apply" (or "fireforge build" which auto-applies) to update the engine.');
-        }
-    }
-    catch {
-        // Non-fatal: a broken furnace config should not block the caller.
-        verbose('Furnace staleness check skipped due to an error.');
-    }
-}

package/dist/src/core/furnace-state-persist.d.ts

@@ -1,68 +0,0 @@
-/**
- * Single-component furnace state persistence.
- *
- * There are exactly two sanctioned ways checksums land in
- * furnace-state.json:
- *
- *  1. The batch path inside `applyAllComponents` (persistState: true), which
- *     replaces `appliedChecksums` wholesale. That is correct only when the
- *     run covered every component.
- *  2. The per-component merge in this module, which rewrites only the
- *     `<type>/<name>/…` keys of the component that was applied.
- *
- * Every targeted (named) apply/deploy must use path 2 with
- * `persistState: false`. Routing a named run through the batch path wipes
- * every other component's checksum state: the batch loops filter to the
- * named component, so the wholesale replace persists a state file containing
- * only that component. Downstream, `diffDeletedFiles` and
- * `findOrphanedEngineFiles` both key on `appliedChecksums`, so the wiped
- * components' stale engine files become undetectable by apply and by
- * `furnace validate`.
- */
-import { type ApplyAllComponentsResult } from './furnace-apply.js';
-import { type FurnacePaths } from './furnace-config.js';
-/**
- * Counts applied entries that carry at least one blocking step error
- * (advisory step errors are warnings and never fail a run).
- */
-export declare function getStepFailureCount(result: ApplyAllComponentsResult): number;
-/**
- * Decides whether a single-component apply/deploy completed cleanly enough
- * to persist its checksums into furnace-state.json.
- *
- * Named runs are atomic: if any apply step fails, the rollback journal
- * restores the engine to its pre-run state and this helper returns `false`
- * so state is not touched. The conditions must stay in lock-step with the
- * rollback trigger in `applyAllComponents`: both read step errors, so a
- * future refactor cannot drift them apart and accidentally persist partial
- * state.
- */
-export declare function shouldPersistSingleComponentState(result: ApplyAllComponentsResult, isDryRun: boolean): boolean;
-/**
- * Validates and narrows the applied entry a named run should persist.
- *
- * Guards against future refactors that might reorder or misroute the
- * applied[] array: a named run persists state under a single component
- * name, so the first applied entry must be that component. Persisting a
- * different component's checksums would cause the next status/apply run to
- * mis-report health for both components involved.
- *
- * @param commandLabel - Human label for error messages ("Deploy", "Apply")
- */
-export declare function getPersistableAppliedEntry(commandLabel: string, name: string, appliedEntry: ApplyAllComponentsResult['applied'][number] | undefined): {
-    name: string;
-    type: 'override' | 'custom';
-};
-/**
- * Persists checksum state for a successfully applied named component by
- * merging its `<type>/<name>/…` keys into the existing state rather than
- * replacing the whole map.
- *
- * @param projectRoot - Root directory of the project
- * @param appliedEntry - Applied component descriptor
- * @param furnacePaths - Resolved Furnace workspace paths
- */
-export declare function persistSingleComponentState(projectRoot: string, appliedEntry: {
-    name: string;
-    type: 'override' | 'custom';
-}, furnacePaths: FurnacePaths): Promise<void>;