@hominis/fireforge 0.45.0 → 0.46.1

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

@@ -1,20 +1,9 @@
 import type { ComponentApplyContext, CustomComponentConfig, DryRunAction, OverrideComponentConfig, StepError } from '../types/furnace.js';
 import { type RollbackJournal } from './furnace-rollback.js';
-interface DirectoryEntry {
-    isFile(): boolean;
-    isSymbolicLink?(): boolean;
-    name: string;
-}
-/**
- * True for a plain-file directory entry — symlinks and directories are
- * never copy candidates. Exported for the patch-owned overwrite probe,
- * which walks the same override copy-candidate set as apply.
- */
-export declare function isRegularFile(entry: DirectoryEntry): boolean;
 /**
  * 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 exact same file set — the "files to restore" set is defined as the
+ * using the same file set: the "files to restore" set is defined as the
  * inverse of the "files apply would have written" set.
  */
 export declare function isOverrideCopyCandidate(entryName: string, type: OverrideComponentConfig['type']): boolean;
@@ -27,14 +16,14 @@ export declare function getOverrideEngineTargetPath(engineDir: string, config: O
  * 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
+ * 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
+ * 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 declare function restoreOverrideFileToBaseline(engineDir: string, enginePath: string, journal: RollbackJournal): Promise<'restored' | 'removed' | 'noop'>;
@@ -43,14 +32,14 @@ export declare function computeComponentChecksums(componentDir: string): Promise
 /**
  * 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
+ * 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 — refusing here would surface a confusing
- * error in a recovery path).
+ * 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
+ * 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.
  */
@@ -62,9 +51,9 @@ export declare function undeployCustomFiles(engineDir: string, config: CustomCom
  * 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
+ * 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
+ * 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.
  */

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

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { createHash } from 'node:crypto';
 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';
@@ -12,30 +12,16 @@ import { applyCustomFtlFile, applySharedFtlPrune, removeCustomFtlJarMnEntry, } f
 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';
-/**
- * True for a plain-file directory entry — symlinks and directories are
- * never copy candidates. Exported for the patch-owned overwrite probe,
- * which walks the same override copy-candidate set as apply.
- */
-export function isRegularFile(entry) {
-    if (!entry.isFile())
-        return false;
-    if (typeof entry.isSymbolicLink === 'function' && entry.isSymbolicLink())
-        return false;
-    return true;
-}
-function isChecksummedComponentFile(name) {
-    return name.endsWith('.mjs') || name.endsWith('.css') || name.endsWith('.ftl');
-}
 /**
  * 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 exact same file set — the "files to restore" set is defined as the
+ * 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) {
@@ -60,18 +46,18 @@ export function getOverrideEngineTargetPath(engineDir, config, fileName, ftlDir)
  * 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
+ * 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
+ * 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:
+    // 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
@@ -80,8 +66,8 @@ export async function restoreOverrideFileToBaseline(engineDir, enginePath, journ
     // 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 — exactly the inverse of "we just
-    // wrote a file here", which is correct for the noop case too.
+    // 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);
@@ -102,10 +88,13 @@ export async function computeComponentChecksums(componentDir) {
             continue;
         if (entry.name === 'override.json')
             continue;
-        if (!isChecksummedComponentFile(entry.name))
+        // 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 = createHash('sha256').update(normalizeForChecksum(content)).digest('hex');
+        const hash = sha256Hex(normalizeForChecksum(content));
         checksums[entry.name] = hash;
     }
     return checksums;
@@ -113,14 +102,14 @@ export async function computeComponentChecksums(componentDir) {
 /**
  * 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
+ * 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 — refusing here would surface a confusing
- * error in a recovery path).
+ * 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
+ * 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.
  */
@@ -138,7 +127,7 @@ export async function undeployCustomFiles(engineDir, config, deletedFiles, ftlDi
             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
+        // 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).
@@ -153,9 +142,9 @@ export async function undeployCustomFiles(engineDir, config, deletedFiles, ftlDi
  * 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
+ * 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
+ * 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.
  */
@@ -169,11 +158,11 @@ export async function undeployOverrideFiles(engineDir, config, deletedFiles, ftl
     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 deliberately do not re-filter `deletedFiles` through
+    // 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` — exactly the case we need cleanup for.
+    // from `full` to `css-only`, which is the case we need cleanup for.
     const restored = [];
     const removed = [];
     for (const fileName of deletedFiles) {
@@ -233,13 +222,13 @@ export async function hasOverrideEngineDrift(ctx, config, cachedEngineChecksums)
         const engineContent = normalizeForChecksum(await readText(enginePath));
         // Fast path: compare engine content hash against cached value from last apply
         if (cachedEngineChecksums) {
-            const engineHash = createHash('sha256').update(engineContent).digest('hex');
+            const engineHash = sha256Hex(engineContent);
             const cachedHash = cachedEngineChecksums[entry.name];
             if (cachedHash && engineHash !== cachedHash) {
                 return true;
             }
             if (cachedHash)
-                continue; // Hash match — skip full source comparison
+                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)));
@@ -270,7 +259,7 @@ export async function hasCustomEngineDrift(ctx, config) {
     // 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.
+    // 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;
@@ -322,16 +311,16 @@ export async function applyCustomComponent(ctx, config, dryRun = false, rollback
     // 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)
+    // 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).
+    // 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,
+    // fragment-expanded form. The workspace source keeps only the directive,
     // so shared CSS stays single-sourced.
     const sharedDir = join(componentDir, '..', '..', SHARED_FRAGMENTS_DIR);
     await Promise.all(filesToCopy.map(async (entry) => {

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

@@ -52,7 +52,7 @@ export function logApplyResult(result, isDryRun) {
         }
     }
     // Patch-owned overwrite warnings print on every non-dry-run
-    // outcome — including the rolled-back branch, where the overwrite
+    // 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 && result.warnings !== undefined) {

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

@@ -1,18 +1,18 @@
 /**
  * Patch-owned overwrite warnings for `furnace apply`.
  *
- * For Furnace-managed components, apply OVERWRITES the deployed engine
+ * 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
+ * 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 exact case BEFORE
- * the copy (deployed bytes differ from the component source AND the file is
+ * "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 —
+ * The per-file byte comparison already exists:
  * `checkRegistrationConsistency` for custom components (fragment- and
- * ftl-aware) and the copy-candidate walk for overrides — so this module only
+ * ftl-aware) and the copy-candidate walk for overrides. This module only
  * surfaces what was previously computed and thrown away.
  */
 import type { CustomComponentConfig, OverrideComponentConfig } from '../types/furnace.js';
@@ -26,7 +26,7 @@ export interface PatchOwnedOverwriteWarning {
 }
 /**
  * Loads the file → owning-patch map for the overwrite warning.
- * A missing or unreadable patches manifest degrades to an empty map — the
+ * 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[]>>;
@@ -55,8 +55,8 @@ export type PatchOwnedOverwriteProbe = {
 };
 /**
  * Finds deployed files this component's apply is about to overwrite whose
- * engine bytes differ from the component source AND that are patch-owned.
- * Probe failures degrade to a verbose line and an empty list — the apply
+ * engine bytes differ from the component source and that are patch-owned.
+ * 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[]>;

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

@@ -2,18 +2,18 @@
 /**
  * Patch-owned overwrite warnings for `furnace apply`.
  *
- * For Furnace-managed components, apply OVERWRITES the deployed engine
+ * 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
+ * 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 exact case BEFORE
- * the copy (deployed bytes differ from the component source AND the file is
+ * "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 —
+ * The per-file byte comparison already exists:
  * `checkRegistrationConsistency` for custom components (fragment- and
- * ftl-aware) and the copy-candidate walk for overrides — so this module only
+ * ftl-aware) and the copy-candidate walk for overrides. This module only
  * surfaces what was previously computed and thrown away.
  */
 import { readdir } from 'node:fs/promises';
@@ -21,15 +21,17 @@ import { join, relative } from 'node:path';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
+import { normalizePathSlashes } from '../utils/paths.js';
 import { getProjectPaths } from './config.js';
-import { getOverrideEngineTargetPath, isOverrideCopyCandidate, isRegularFile, } from './furnace-apply-helpers.js';
+import { getOverrideEngineTargetPath, isOverrideCopyCandidate } from './furnace-apply-helpers.js';
 import { FTL_DIR } from './furnace-constants.js';
+import { isRegularFile } from './furnace-dir-entry.js';
 import { checkRegistrationConsistency } from './furnace-validate-registration.js';
 import { loadPatchesManifest } from './patch-manifest.js';
 import { buildPatchClaims } from './status-classify.js';
 /**
  * Loads the file → owning-patch map for the overwrite warning.
- * A missing or unreadable patches manifest degrades to an empty map — the
+ * A missing or unreadable patches manifest degrades to an empty map. The
  * warning is advisory and must never block an apply.
  */
 export async function loadPatchClaimsForApply(root) {
@@ -86,7 +88,7 @@ async function findOverrideOverwrites(args) {
         // A missing target is a fresh deploy, not a lost engine edit.
         if (!(await pathExists(enginePath)))
             continue;
-        const engineRel = relative(engineDir, enginePath).replace(/\\/g, '/');
+        const engineRel = normalizePathSlashes(relative(engineDir, enginePath));
         const owners = patchClaims.get(engineRel);
         if (owners === undefined || owners.length === 0)
             continue;
@@ -102,8 +104,8 @@ async function findOverrideOverwrites(args) {
 }
 /**
  * Finds deployed files this component's apply is about to overwrite whose
- * engine bytes differ from the component source AND that are patch-owned.
- * Probe failures degrade to a verbose line and an empty list — the apply
+ * engine bytes differ from the component source and that are patch-owned.
+ * 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 async function findPatchOwnedOverwrites(args) {

package/dist/src/core/furnace-apply-undeploy-actions.d.ts

@@ -1,7 +1,7 @@
 /**
  * Dry-run action builders for files deleted from a component workspace since
  * the last apply. Split out of `furnace-apply.ts` to stay under the per-file
- * line budget; the real undeploy paths stay in `furnace-apply-helpers.ts`.
+ * line budget. The real undeploy paths stay in `furnace-apply-helpers.ts`.
  */
 import type { CustomComponentConfig, DryRunAction, OverrideComponentConfig } from '../types/furnace.js';
 /** Plans the engine-restore actions for deleted override workspace files. */

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

@@ -2,7 +2,7 @@
 /**
  * Dry-run action builders for files deleted from a component workspace since
  * the last apply. Split out of `furnace-apply.ts` to stay under the per-file
- * line budget; the real undeploy paths stay in `furnace-apply-helpers.ts`.
+ * line budget. The real undeploy paths stay in `furnace-apply-helpers.ts`.
  */
 import { join } from 'node:path';
 import { getOverrideEngineTargetPath } from './furnace-apply-helpers.js';

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

@@ -1,15 +1,15 @@
 import type { ApplyResult, DryRunAction } from '../types/furnace.js';
 import { type FurnaceOperationContext } from './furnace-operation.js';
 import { type RollbackJournal } from './furnace-rollback.js';
-export { computeComponentChecksums, hasComponentChanged, prefixChecksums, } from './furnace-apply-helpers.js';
+export { computeComponentChecksums, prefixChecksums } from './furnace-apply-helpers.js';
 /**
  * Result of {@link applyAllComponents}.
  *
  * Named so consumers can refer to the shape directly instead of going
  * through `Awaited<ReturnType<typeof applyAllComponents>>`.
  *
- * `actions` is populated only on a dry run; `rollbackJournal` only when
- * `persistState: false` hands journal ownership back to the caller.
+ * `actions` is populated only on a dry run. `rollbackJournal` is set only
+ * when `persistState: false` hands journal ownership back to the caller.
  */
 export type ApplyAllComponentsResult = ApplyResult & {
     actions?: DryRunAction[];
@@ -44,6 +44,6 @@ export declare function applyAllComponents(root: string, dryRun?: boolean, optio
 }): Promise<ApplyAllComponentsResult>; /**
  * 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
+ * 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-apply.js

@@ -19,7 +19,18 @@ import { addJarMnEntries, removeCustomElementRegistration, removeJarMnEntries, }
 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, hasComponentChanged, prefixChecksums, } from './furnace-apply-helpers.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,
@@ -48,13 +59,13 @@ async function applyOverrideBatch(ctx) {
             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; the
-                // checksum record alone cannot detect that.
+                // 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, reason: 'No changes since last apply' });
-                    Object.assign(newChecksums, prefixChecksums(previous, 'override', name));
+                    recordComponentChecksums(newChecksums, previous, 'override', name);
                     continue;
                 }
             }
@@ -75,9 +86,9 @@ async function applyOverrideBatch(ctx) {
                 filesAffectedTotal.push(...restored, ...removed);
             }
             if (!dryRun) {
-                // Runs unconditionally — including when the component source
-                // changed — because the lost-work case is precisely a deployed
-                // engine edit that the incoming copy is about to replace.
+                // 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,
@@ -95,7 +106,7 @@ async function applyOverrideBatch(ctx) {
             filesAffectedTotal.push(...filesAffected);
             result.applied.push({ name, type: 'override', filesAffected: filesAffectedTotal });
             if (!dryRun) {
-                Object.assign(newChecksums, prefixChecksums(currentChecksums, 'override', name));
+                recordComponentChecksums(newChecksums, currentChecksums, 'override', name);
             }
         }
         catch (error) {
@@ -110,11 +121,12 @@ async function applyOverrideBatch(ctx) {
  * After undeploying deleted files, the in-engine jar.mn and
  * customElements.js still carry entries for the removed files. Re-sync them
  * by removing all of `name`'s jar.mn entries and re-adding only those that
- * still exist in the workspace; if the .mjs itself was deleted, also drop
+ * still exist in the workspace. 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(engineDir, name, config, deletedFiles, currentChecksums, rollbackJournal, filesAffected) {
+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'));
@@ -129,13 +141,14 @@ async function reconcileCustomRegistrationAfterUndeploy(engineDir, name, config,
     await removeJarMnEntries(engineDir, name);
     const liveJarFiles = Object.keys(currentChecksums).filter((f) => f.endsWith('.mjs') || f.endsWith('.css'));
     if (liveJarFiles.length > 0) {
-        // applyCustomComponent has already added live entries; the remove above
-        // dropped them too, so re-add now to leave jar.mn in the correct state.
+        // applyCustomComponent has already added live entries, and the remove
+        // above dropped them too, so re-add now to leave jar.mn in the correct
+        // state.
         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
+    // 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) {
@@ -212,7 +225,7 @@ async function applyCustomBatch(ctx, root, markerComment) {
                 const drifted = await hasCustomEngineDrift({ root, name, componentDir, ftlDir }, customConfig);
                 if (!drifted) {
                     result.skipped.push({ name, reason: 'No changes since last apply' });
-                    Object.assign(newChecksums, prefixChecksums(previous, 'custom', name));
+                    recordComponentChecksums(newChecksums, previous, 'custom', name);
                     continue;
                 }
             }
@@ -233,9 +246,9 @@ async function applyCustomBatch(ctx, root, markerComment) {
                 filesAffectedTotal.push(...removed);
             }
             if (!dryRun) {
-                // Runs unconditionally — the `changed === true` path used to skip
-                // drift detection entirely, which is exactly when a deployed
-                // engine-only fix gets silently replaced (J6).
+                // Runs unconditionally. The `changed === true` path used to skip
+                // drift detection entirely, which is when a deployed engine-only
+                // fix gets silently replaced (J6).
                 recordOverwriteWarnings(result, await findPatchOwnedOverwrites({
                     type: 'custom',
                     root,
@@ -250,7 +263,15 @@ async function applyCustomBatch(ctx, root, markerComment) {
                 allActions.push(...actions);
             }
             if (!dryRun && deletedFiles.length > 0 && blockingStepErrors(stepErrors).length === 0) {
-                await reconcileCustomRegistrationAfterUndeploy(engineDir, name, customConfig, deletedFiles, currentChecksums, rollbackJournal, filesAffectedTotal);
+                await reconcileCustomRegistrationAfterUndeploy({
+                    engineDir,
+                    name,
+                    config: customConfig,
+                    deletedFiles,
+                    currentChecksums,
+                    rollbackJournal,
+                    filesAffected: filesAffectedTotal,
+                });
             }
             filesAffectedTotal.push(...filesAffected);
             result.applied.push({
@@ -259,12 +280,12 @@ async function applyCustomBatch(ctx, root, markerComment) {
                 filesAffected: filesAffectedTotal,
                 ...(stepErrors.length > 0 ? { stepErrors } : {}),
             });
-            // Only store checksums when the component applied without BLOCKING
+            // 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 —
+            // 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) {
-                Object.assign(newChecksums, prefixChecksums(currentChecksums, 'custom', name));
+                recordComponentChecksums(newChecksums, currentChecksums, 'custom', name);
             }
         }
         catch (error) {
@@ -308,7 +329,7 @@ export async function applyAllComponents(root, dryRun = false, options) {
     // 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
+    // `lintModificationComments`. That rule keys on
     // `${binaryName.toUpperCase()}:`. An explicit `markerComment` still wins.
     const forgeConfig = await loadConfig(root).catch(() => undefined);
     const markerComment = resolveFurnaceMarkerComment(forgeConfig);
@@ -318,7 +339,7 @@ export async function applyAllComponents(root, dryRun = false, options) {
         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
+    // 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
@@ -330,7 +351,7 @@ export async function applyAllComponents(root, dryRun = false, options) {
         errors: [],
     };
     const allActions = [];
-    const newChecksums = {};
+    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).
@@ -341,7 +362,7 @@ export async function applyAllComponents(root, dryRun = false, options) {
         }
     }
     // Patch-claim map for the overwrite warning: loaded once per
-    // apply. A missing/unreadable manifest degrades to an empty map — the
+    // 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 = {
@@ -370,7 +391,7 @@ export async function applyAllComponents(root, dryRun = false, options) {
     if (!dryRun && !hasApplyStepErrors && result.errors.length === 0) {
         await runPostApplyConsistencyChecks(root, config, result, ftlDir);
     }
-    // Recompute AFTER the consistency checks: they MUTATE entry.stepErrors
+    // 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
@@ -406,8 +427,8 @@ export async function applyAllComponents(root, dryRun = false, options) {
             // instead of byte-comparing against workspace sources.
             await updateFurnaceState(root, {
                 lastApply: new Date().toISOString(),
-                appliedChecksums: newChecksums,
-                engineChecksums: { ...newChecksums },
+                appliedChecksums: Object.fromEntries(newChecksums),
+                engineChecksums: Object.fromEntries(newChecksums),
             });
         }
         else if (rollbackJournal) {
@@ -422,6 +443,6 @@ export async function applyAllComponents(root, dryRun = false, options) {
 } /**
  * 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
+ * parameters. The 12-13 positional parameters this replaced let call sites
  * drift and made every new parameter a two-signature change.
  */