@hominis/fireforge 0.44.4 → 0.46.0

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,26 +12,12 @@ 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
@@ -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;
@@ -233,7 +222,7 @@ 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;

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

@@ -21,9 +21,11 @@ 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';
@@ -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;

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

@@ -1,7 +1,7 @@
 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}.
  *

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,
@@ -54,7 +65,7 @@ async function applyOverrideBatch(ctx) {
                 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;
                 }
             }
@@ -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) {
@@ -114,7 +125,8 @@ async function applyOverrideBatch(ctx) {
  * 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'));
@@ -212,7 +224,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;
                 }
             }
@@ -250,7 +262,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({
@@ -264,7 +284,7 @@ async function applyCustomBatch(ctx, root, markerComment) {
             // the next run. Advisory errors (FTL degradation) still persist —
             // 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) {
@@ -330,7 +350,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).
@@ -406,8 +426,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) {

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

@@ -6,7 +6,7 @@ export declare const SHARED_FRAGMENTS_DIR = "shared";
 /**
  * Paths for furnace-related files and directories.
  */
-interface FurnacePaths {
+export interface FurnacePaths {
     /** Path to furnace.json */
     furnaceConfig: string;
     /** Path to components directory */

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

@@ -53,25 +53,18 @@ export async function furnaceConfigExists(root) {
     const paths = getFurnacePaths(root);
     return pathExists(paths.furnaceConfig);
 }
+/** True when a recovered record carries at least one entry. */
+function hasEntries(record) {
+    return Object.keys(record).length > 0;
+}
 /** The current (and only) config schema version. */
 const CURRENT_CONFIG_VERSION = 1;
 /**
- * Migrates a furnace config from an older schema version to the current one.
- * Returns the data unchanged if it is already at the current version.
- *
- * When a future version 2 is introduced, add a `case 1:` that transforms
- * v1 data into v2 shape and falls through to validation. The pattern is:
- *
- * ```
- * case 1:
- *   data = migrateV1ToV2(data);
- *   // fallthrough
- * case 2:
- *   break;
- * ```
+ * Rejects a config whose `version` field is not the single schema version that
+ * exists. A non-integer or sub-1 value is a malformed document; a value above
+ * the current version was written by a newer FireForge and cannot be read here.
  */
-function migrateFurnaceConfig(data) {
-    const version = data['version'];
+function validateConfigVersion(version) {
     if (typeof version !== 'number' || !Number.isInteger(version) || version < 1) {
         throw new FurnaceError(`Furnace config: "version" must be a positive integer (got ${JSON.stringify(version)}). ` +
             `Current schema version is ${CURRENT_CONFIG_VERSION}.`);
@@ -80,9 +73,6 @@ function migrateFurnaceConfig(data) {
         throw new FurnaceError(`Furnace config: version ${version} is newer than what this version of FireForge supports (${CURRENT_CONFIG_VERSION}). ` +
             'Upgrade FireForge to read this config.');
     }
-    // Today only version 1 exists, so no migration is needed. When future
-    // versions are added, migration steps will be chained here.
-    return data;
 }
 /**
  * Validates a raw config object and returns a typed FurnaceConfig.
@@ -97,31 +87,28 @@ export function validateFurnaceConfig(data) {
     // Furnace config documents arrive from JSON.parse (loadFurnaceConfig /
     // writeFurnaceConfig round-trips), which can only produce JSON values,
     // so the object check above is the only invariant left to establish.
-    // Run migration before validation so older configs are transparently upgraded.
-    const migrated = migrateFurnaceConfig(data);
-    if (migrated['version'] !== CURRENT_CONFIG_VERSION) {
-        throw new FurnaceError(`Furnace config: "version" must be ${CURRENT_CONFIG_VERSION} after migration`);
-    }
-    if (!isString(migrated['componentPrefix'])) {
+    const raw = data;
+    validateConfigVersion(raw['version']);
+    if (!isString(raw['componentPrefix'])) {
         throw new FurnaceError('Furnace config: "componentPrefix" must be a string');
     }
     // Validate optional tokenPrefix
-    if (migrated['tokenPrefix'] !== undefined && !isString(migrated['tokenPrefix'])) {
+    if (raw['tokenPrefix'] !== undefined && !isString(raw['tokenPrefix'])) {
         throw new FurnaceError('Furnace config: "tokenPrefix" must be a string if provided');
     }
     // Validate optional tokenAllowlist
-    if (migrated['tokenAllowlist'] !== undefined) {
-        parseStringArray(migrated['tokenAllowlist'], 'tokenAllowlist');
+    if (raw['tokenAllowlist'] !== undefined) {
+        parseStringArray(raw['tokenAllowlist'], 'tokenAllowlist');
     }
     // Validate optional runtimeVariables — CSS runtime state channels
     // (e.g. `--cam-x`) that are exempt from `token-prefix-violation`.
-    validateRuntimeVariables(migrated['runtimeVariables']);
+    validateRuntimeVariables(raw['runtimeVariables']);
     // Validate optional tokenHostDocuments — list of chrome XHTMLs that the
     // `missing-token-link` validator scans for the tokens CSS link.
-    validateTokenHostDocuments(migrated['tokenHostDocuments']);
-    const stock = parseStockList(migrated['stock']);
-    const overrides = parseNamedComponentMap(migrated['overrides'], 'override', 'overrides', parseOverrideConfig);
-    const custom = parseNamedComponentMap(migrated['custom'], 'custom', 'custom', parseCustomConfig);
+    validateTokenHostDocuments(raw['tokenHostDocuments']);
+    const stock = parseStockList(raw['stock']);
+    const overrides = parseNamedComponentMap(raw['overrides'], 'override', 'overrides', parseOverrideConfig);
+    const custom = parseNamedComponentMap(raw['custom'], 'custom', 'custom', parseCustomConfig);
     // Detect circular composes references among custom components.
     detectComposesCycles(custom);
     // Validate that every composes reference points to a known component.
@@ -146,12 +133,12 @@ export function validateFurnaceConfig(data) {
     }
     const config = {
         version: CURRENT_CONFIG_VERSION,
-        componentPrefix: migrated['componentPrefix'],
+        componentPrefix: raw['componentPrefix'],
         stock,
         overrides,
         custom,
     };
-    applyOptionalFurnaceFields(migrated, config);
+    applyOptionalFurnaceFields(raw, config);
     return config;
 }
 /**
@@ -228,7 +215,7 @@ function sanitizeFurnaceState(data) {
                 }
                 appliedChecksums[filePath] = checksum;
             }
-            if (Object.keys(appliedChecksums).length > 0 || !hasInvalidChecksum) {
+            if (hasEntries(appliedChecksums) || !hasInvalidChecksum) {
                 state.appliedChecksums = appliedChecksums;
                 recoveredFields.push('appliedChecksums');
             }
@@ -245,7 +232,7 @@ function sanitizeFurnaceState(data) {
                     engineChecksums[filePath] = checksum;
                 }
             }
-            if (Object.keys(engineChecksums).length > 0) {
+            if (hasEntries(engineChecksums)) {
                 state.engineChecksums = engineChecksums;
                 recoveredFields.push('engineChecksums');
             }

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

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 /** Path to customElements.js within the engine source tree */
 export const CUSTOM_ELEMENTS_JS = 'toolkit/content/customElements.js';
+import { normalizePathSlashes } from '../utils/paths.js';
 /** Path to jar.mn within the engine source tree (toolkit global) */
 export const JAR_MN = 'toolkit/content/jar.mn';
 /**
@@ -78,7 +79,7 @@ export function resolveFtlDir(configuredPath) {
  * degrade gracefully rather than inventing a path.
  */
 export function resolveFtlChromeSubPath(ftlBasePath) {
-    const path = (ftlBasePath ?? FTL_DIR).replace(/\\/g, '/');
+    const path = normalizePathSlashes(ftlBasePath ?? FTL_DIR);
     const match = /^(.*?)\/locales\/[^/]+\/(.+?)\/?$/.exec(path);
     if (!match?.[2])
         return undefined;
@@ -93,7 +94,7 @@ export function resolveFtlChromeSubPath(ftlBasePath) {
  * callers must treat that as "cannot locate" and degrade gracefully.
  */
 export function resolveFtlLocaleJarMnPath(ftlBasePath) {
-    const path = (ftlBasePath ?? FTL_DIR).replace(/\\/g, '/');
+    const path = normalizePathSlashes(ftlBasePath ?? FTL_DIR);
     const match = /^(.*?)\/locales\/[^/]+\//.exec(path);
     if (!match?.[1])
         return undefined;

package/dist/src/core/furnace-dir-entry.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The minimal `readdir(..., { withFileTypes: true })` entry shape the furnace
+ * apply path needs, plus the single predicate that decides whether an entry is
+ * a copy candidate. Kept in its own leaf module so both `furnace-apply-helpers`
+ * and its dry-run mirror can share one definition without importing each other.
+ */
+/** Structural subset of `Dirent` used by the furnace apply/dry-run walkers. */
+export interface DirectoryEntry {
+    isFile(): boolean;
+    isSymbolicLink?(): boolean;
+    name: string;
+}
+/**
+ * True for a plain-file directory entry — symlinks and directories are
+ * never copy candidates.
+ *
+ * @param entry - Directory entry to classify
+ * @returns True when the entry is a regular file
+ */
+export declare function isRegularFile(entry: DirectoryEntry): boolean;

package/dist/src/core/furnace-dir-entry.js

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * The minimal `readdir(..., { withFileTypes: true })` entry shape the furnace
+ * apply path needs, plus the single predicate that decides whether an entry is
+ * a copy candidate. Kept in its own leaf module so both `furnace-apply-helpers`
+ * and its dry-run mirror can share one definition without importing each other.
+ */
+/**
+ * True for a plain-file directory entry — symlinks and directories are
+ * never copy candidates.
+ *
+ * @param entry - Directory entry to classify
+ * @returns True when the entry is a regular file
+ */
+export function isRegularFile(entry) {
+    if (!entry.isFile())
+        return false;
+    if (typeof entry.isSymbolicLink === 'function' && entry.isSymbolicLink())
+        return false;
+    return true;
+}

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

@@ -188,5 +188,7 @@ export declare function recordFurnaceRollbackFailure(root: string, operation: Fu
  * reuse the module across tests, so the test suite must call this between
  * cases that exercise the signal pathway. Not exported from the package
  * entry point.
+ *
+ * @internal Exported only so tests can reach it; not part of the public surface.
  */
 export declare function __resetFurnaceOperationStateForTests(): void;

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

@@ -381,7 +381,7 @@ export async function runFurnaceMutation(root, kind, body, options = {}) {
         const lockStatus = await readLockStatus(lockPath);
         assert(lockStatus.held, 'furnace lock held before the mutation body runs');
         assert(lockStatus.holder === undefined || lockStatus.holder.pid === process.pid, () => `furnace lock is owned by this process ` +
-            `(held by PID ${String(lockStatus.holder?.pid)}, we are ${String(process.pid)})`);
+            `(held by PID ${lockStatus.holder?.pid}, we are ${process.pid})`);
         activeOperations.set(token, operation);
         try {
             return await body({
@@ -432,6 +432,8 @@ export async function recordFurnaceRollbackFailure(root, operation, reason) {
  * reuse the module across tests, so the test suite must call this between
  * cases that exercise the signal pathway. Not exported from the package
  * entry point.
+ *
+ * @internal Exported only so tests can reach it; not part of the public surface.
  */
 export function __resetFurnaceOperationStateForTests() {
     activeOperations.clear();

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

@@ -3,14 +3,26 @@ export interface RefreshFileResult {
     status: 'merged' | 'conflict' | 'unchanged' | 'new-file';
     conflictMarkers?: number;
 }
+export interface RefreshOverrideFileOptions {
+    /** Path to the engine git repository. */
+    engineDir: string;
+    /** Path to the current override file in the workspace. */
+    overridePath: string;
+    /** Engine-relative path for git show. */
+    engineRelPath: string;
+    /** The git ref at which the override was originally created. */
+    baseCommit: string;
+    /** Display name for the file. */
+    fileName: string;
+    /** When true, compute the merge but write nothing. */
+    dryRun?: boolean | undefined;
+    /** Conflict resolution preference handed to `git merge-file`. */
+    strategy?: 'ours' | 'theirs' | undefined;
+}
 /**
  * Refreshes a single override file against the current engine HEAD.
  *
- * @param engineDir - Path to the engine git repository
- * @param overridePath - Path to the current override file in the workspace
- * @param engineRelPath - Engine-relative path for git show
- * @param baseCommit - The git ref at which the override was originally created
- * @param fileName - Display name for the file
+ * @param options - See {@link RefreshOverrideFileOptions}
  * @returns Merge result with the updated content written to the override file
  */
-export declare function refreshOverrideFile(engineDir: string, overridePath: string, engineRelPath: string, baseCommit: string, fileName: string, dryRun?: boolean, strategy?: 'ours' | 'theirs'): Promise<RefreshFileResult>;
+export declare function refreshOverrideFile(options: RefreshOverrideFileOptions): Promise<RefreshFileResult>;

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

@@ -81,14 +81,11 @@ async function threeWayMergeFile(base, ours, theirs, label, strategy) {
 /**
  * Refreshes a single override file against the current engine HEAD.
  *
- * @param engineDir - Path to the engine git repository
- * @param overridePath - Path to the current override file in the workspace
- * @param engineRelPath - Engine-relative path for git show
- * @param baseCommit - The git ref at which the override was originally created
- * @param fileName - Display name for the file
+ * @param options - See {@link RefreshOverrideFileOptions}
  * @returns Merge result with the updated content written to the override file
  */
-export async function refreshOverrideFile(engineDir, overridePath, engineRelPath, baseCommit, fileName, dryRun, strategy) {
+export async function refreshOverrideFile(options) {
+    const { engineDir, overridePath, engineRelPath, baseCommit, fileName, dryRun, strategy } = options;
     // Read the three versions
     const oursContent = await readText(overridePath);
     const baseContent = await getFileContentAtRef(engineDir, engineRelPath, baseCommit);

package/dist/src/core/furnace-registration-ast.d.ts

@@ -28,7 +28,6 @@ export interface RegistrationWriteOptions {
      */
     markerComment?: string;
 }
-export { removeCustomElementRegistration } from './furnace-registration-remove.js';
 /**
  * Adds a custom element registration entry to customElements.js.
  *

package/dist/src/core/furnace-registration-ast.js

@@ -46,9 +46,6 @@ function formatMarkerSuffix(markerComment) {
         return '';
     return `  // ${markerComment}:`;
 }
-// Re-export from split modules so existing import sites continue working
-export { removeCustomElementRegistration } from './furnace-registration-remove.js';
-// Re-export constants so existing import sites continue working
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

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

@@ -1,4 +1,5 @@
-export { addCustomElementRegistration, removeCustomElementRegistration, validateCustomElementRegistration, } from './furnace-registration-ast.js';
+export { addCustomElementRegistration, validateCustomElementRegistration, } from './furnace-registration-ast.js';
+export { removeCustomElementRegistration } from './furnace-registration-remove.js';
 /**
  * Adds jar.mn entries that map chrome:// URIs to on-disk paths for a
  * component's files.

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

@@ -2,22 +2,31 @@
 import { join } from 'node:path';
 import { FurnaceError } from '../errors/furnace.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
+/**
+ * Returns the leading whitespace of the first line matching `pattern`, whose
+ * first capture group must be that indentation. `undefined` when no line
+ * matches, so callers can chain progressively looser patterns before falling
+ * back to a convention default.
+ */
+function detectIndent(lines, pattern) {
+    for (const line of lines) {
+        const match = pattern.exec(line);
+        if (match?.[1])
+            return match[1];
+    }
+    return undefined;
+}
 /**
  * Detects the indentation used by existing `content/global/elements/` lines
  * in jar.mn. Falls back to 3 spaces (the historical Firefox convention) when
  * no reference line is found.
  */
 function detectJarMnIndent(lines) {
-    for (const line of lines) {
-        const match = /^(\s+)content\/global\/elements\//.exec(line);
-        if (match?.[1]) {
-            return match[1];
-        }
-    }
-    return '   ';
+    return detectIndent(lines, /^(\s+)content\/global\/elements\//) ?? '   ';
 }
 // Re-export everything from the AST module so existing imports keep working
-export { addCustomElementRegistration, removeCustomElementRegistration, validateCustomElementRegistration, } from './furnace-registration-ast.js';
+export { addCustomElementRegistration, validateCustomElementRegistration, } from './furnace-registration-ast.js';
+export { removeCustomElementRegistration } from './furnace-registration-remove.js';
 import { escapeRegex } from '../utils/regex.js';
 import { JAR_MN } from './furnace-constants.js';
 /**
@@ -72,10 +81,7 @@ export async function addJarMnEntries(engineDir, tagName, files) {
     // Find insertion point among existing content/global/elements/ lines
     const elementLinePattern = /^\s+content\/global\/elements\/([^.]+)\./;
     let insertIndex = -1;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (line === undefined)
-            continue;
+    for (const [i, line] of lines.entries()) {
         const match = elementLinePattern.exec(line);
         if (match) {
             const existingTag = match[1] ?? '';
@@ -148,10 +154,7 @@ export async function addLocaleFtlJarMnEntry(engineDir, jarMnRelPath, tagName, c
     const newEntry = `${indent}locale/@AB_CD@/${chromeSubPath}/${ftlFile} (%${chromeSubPath}/${ftlFile})`;
     const sectionPattern = new RegExp(`^(\\s+)locale\\/(?:@AB_CD@|[a-zA-Z-]+)\\/${escapedChrome}\\/([^.\\s]+)\\.ftl`);
     let insertIndex = -1;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (line === undefined)
-            continue;
+    for (const [i, line] of lines.entries()) {
         const match = sectionPattern.exec(line);
         if (match) {
             const existingTag = match[2] ?? '';
@@ -174,19 +177,9 @@ export async function addLocaleFtlJarMnEntry(engineDir, jarMnRelPath, tagName, c
 /** Detects locale jar.mn indentation by sampling an existing matching entry. */
 function detectLocaleJarMnIndent(lines, chromeSubPath) {
     const escapedChrome = escapeRegex(chromeSubPath);
-    const pattern = new RegExp(`^(\\s+)locale\\/(?:@AB_CD@|[a-zA-Z-]+)\\/${escapedChrome}\\/`);
-    for (const line of lines) {
-        const match = pattern.exec(line);
-        if (match?.[1])
-            return match[1];
-    }
-    // Fall back to detecting any existing `locale/...` indent before giving up.
-    for (const line of lines) {
-        const match = /^(\s+)locale\//.exec(line);
-        if (match?.[1])
-            return match[1];
-    }
-    return '  ';
+    const exact = new RegExp(`^(\\s+)locale\\/(?:@AB_CD@|[a-zA-Z-]+)\\/${escapedChrome}\\/`);
+    // Fall back to any existing `locale/...` indent before giving up.
+    return detectIndent(lines, exact) ?? detectIndent(lines, /^(\s+)locale\//) ?? '  ';
 }
 /**
  * Removes a locale jar.mn entry previously written by `addLocaleFtlJarMnEntry`.

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

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { createHash } from 'node:crypto';
 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';
@@ -48,7 +48,7 @@ export async function scanCustomElementsRegistrations(engineDir) {
         return registrations;
     }
     const content = await readText(filePath);
-    const contentHash = createHash('sha256').update(content).digest('hex');
+    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);
@@ -121,10 +121,7 @@ export async function scanCustomElementsRegistrations(engineDir) {
             '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 (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (line === undefined)
-                continue;
+        for (const [i, line] of lines.entries()) {
             const callbackMatch = /setElementCreationCallback\(\s*"([^"]+)"/.exec(line);
             if (!callbackMatch?.[1])
                 continue;

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

@@ -20,7 +20,7 @@
  * `furnace validate`.
  */
 import { type ApplyAllComponentsResult } from './furnace-apply.js';
-import { type getFurnacePaths } from './furnace-config.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).
@@ -65,4 +65,4 @@ export declare function getPersistableAppliedEntry(commandLabel: string, name: s
 export declare function persistSingleComponentState(projectRoot: string, appliedEntry: {
     name: string;
     type: 'override' | 'custom';
-}, furnacePaths: ReturnType<typeof getFurnacePaths>): Promise<void>;
+}, furnacePaths: FurnacePaths): Promise<void>;