@hominis/fireforge 0.39.0 → 0.41.0

package/dist/src/commands/furnace/remove.js

@@ -3,20 +3,18 @@ import { readdir, unlink } from 'node:fs/promises';
 import { join } from 'node:path';
 import { confirm } from '@clack/prompts';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { removeCustomFtlJarMnEntry } from '../../core/furnace-apply-ftl.js';
-import { extractComponentChecksums, getOverrideEngineTargetPath, isOverrideCopyCandidate, restoreOverrideFileToBaseline, } from '../../core/furnace-apply-helpers.js';
 import { getFurnacePaths, loadFurnaceConfig, loadFurnaceState, updateFurnaceState, writeFurnaceConfig, } from '../../core/furnace-config.js';
 import { resolveFtlDir, xpcshellTestParentDir } from '../../core/furnace-constants.js';
 import { recordFurnaceRollbackFailure, runFurnaceMutation } from '../../core/furnace-operation.js';
-import { removeCustomElementRegistration, removeJarMnEntries, } from '../../core/furnace-registration.js';
 import { createRollbackJournal, restoreRollbackJournalOrThrow, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
 import { isGitRepository } from '../../core/git.js';
 import { deregisterTestManifest } from '../../core/manifest-register.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { toError } from '../../utils/errors.js';
-import { pathExists, readText, removeDir, removeFile, writeText } from '../../utils/fs.js';
+import { pathExists, readText, removeDir, writeText } from '../../utils/fs.js';
 import { cancel, info, intro, isCancel, outro, warn } from '../../utils/logger.js';
-import { dropChecksumsByPrefix, removeDeployedCustomFiles } from './remove-state.js';
+import { performCustomRemovalMutations, performOverrideRemovalMutations, } from './remove-mutations.js';
+import { dropChecksumsByPrefix } from './remove-state.js';
 /**
  * Removes an entire TOML section (header + body lines) for a given test file.
  * Matches from `["filename"]` up to the next section header `[` or end-of-file,
@@ -69,61 +67,6 @@ function findComponentType(config, name) {
         return 'custom';
     return undefined;
 }
-/**
- * Restores every override-deployed file in `engine/` to its pristine HEAD
- * state, inverting what `applyOverrideComponent` would have written. Files that
- * existed in HEAD are restored via `git restore`; files the override
- * introduced (not in HEAD) are deleted outright.
- *
- * The restore set is the **union** of (a) files currently in the override
- * workspace directory and (b) filenames recorded in `previousChecksumKeys`
- * — i.e. files we know we deployed last time, even if the developer has
- * since deleted them from the workspace. Without (b), a workspace deletion
- * leaves an orphaned engine copy that `furnace remove` would never see.
- *
- * Every touched engine file is snapshotted into the rollback journal before
- * mutation so a mid-remove failure still rolls the engine back to its
- * pre-command state.
- */
-async function restoreOverrideEngineFiles(engineDir, overrideDir, overrideConfig, previousChecksumKeys, ftlDir, journal) {
-    // Engine-as-git is a hard precondition for restoration: git HEAD is the only
-    // honest oracle for "what was there before the override". If the engine is
-    // not a git repo we refuse rather than silently leaving files behind — the
-    // previous warn-and-continue behaviour is exactly what this fix removes.
-    if (!(await isGitRepository(engineDir))) {
-        throw new FurnaceError('Cannot restore override files: engine is not a git repository. Run "fireforge download" to initialise it.');
-    }
-    // Build the union of "files we still see on disk" and "files state.json
-    // claims we deployed". The state set is the only authority for files that
-    // were deployed and later deleted from the workspace; the workspace set is
-    // the only authority for files added since last apply that have not yet
-    // been recorded in state. We need both.
-    const fileSet = new Set();
-    if (await pathExists(overrideDir)) {
-        const entries = await readdir(overrideDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isFile())
-                continue;
-            if (!isOverrideCopyCandidate(entry.name, overrideConfig.type))
-                continue;
-            fileSet.add(entry.name);
-        }
-    }
-    for (const key of previousChecksumKeys) {
-        fileSet.add(key);
-    }
-    let restored = 0;
-    let removed = 0;
-    for (const fileName of fileSet) {
-        const enginePath = getOverrideEngineTargetPath(engineDir, overrideConfig, fileName, ftlDir);
-        const action = await restoreOverrideFileToBaseline(engineDir, enginePath, journal);
-        if (action === 'restored')
-            restored += 1;
-        else if (action === 'removed')
-            removed += 1;
-    }
-    return { restored, removed };
-}
 /**
  * Removes generated browser mochitest files associated with a custom component.
  * @param name - Custom component tag name
@@ -410,76 +353,26 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
         try {
             const { config: freshConfig, ftlDir, state: freshState, type: freshType, } = await loadFreshRemoveTarget(projectRoot, name, paths.engine);
             if (freshType === 'override') {
-                const overrideConfig = freshConfig.overrides[name];
-                const dir = join(furnacePaths.overridesDir, name);
-                // Restore deployed engine files BEFORE removing the workspace
-                // directory. The restore set is the union of (a) files currently in
-                // the workspace and (b) files state.json says we deployed last time
-                // — without (b), source-side deletions would orphan engine copies
-                // that this command can never see again.
-                if (overrideConfig?.basePath) {
-                    const previousKeys = Object.keys(extractComponentChecksums(freshState.appliedChecksums, 'override', name));
-                    const { restored, removed } = await restoreOverrideEngineFiles(paths.engine, dir, overrideConfig, previousKeys, ftlDir, journal);
-                    if (restored > 0) {
-                        info(`Restored ${restored} file${restored === 1 ? '' : 's'} in engine/${overrideConfig.basePath} to Firefox baseline`);
-                    }
-                    if (removed > 0) {
-                        info(`Removed ${removed} override-introduced file${removed === 1 ? '' : 's'} from engine/${overrideConfig.basePath}`);
-                    }
-                }
-                if (await pathExists(dir)) {
-                    await snapshotDir(journal, dir);
-                    await removeDir(dir);
-                    info(`Deleted components/overrides/${name}/`);
-                }
+                await performOverrideRemovalMutations({
+                    name,
+                    paths,
+                    furnacePaths,
+                    freshConfig,
+                    freshState,
+                    ftlDir,
+                    journal,
+                });
             }
             else if (freshType === 'custom') {
-                const customConfig = freshConfig.custom[name];
-                // Custom-component removal mutates engine files (jar.mn,
-                // customElements.js, deployed widgets, optional .ftl) and the
-                // rollback journal is the only safety net for those edits while
-                // the command runs. The git-as-engine precondition is enforced
-                // before the lock is acquired (see furnaceRemoveCommand above)
-                // so if we reach this point, the engine is a git repository.
-                if (customConfig?.register) {
-                    // customElements.js is the only file removeCustomElementRegistration touches.
-                    await snapshotFile(journal, join(paths.engine, 'toolkit/content/customElements.js'));
-                    await removeCustomElementRegistration(paths.engine, name);
-                    info(`Deregistered ${name} from customElements.js`);
-                }
-                // jar.mn is the only file removeJarMnEntries touches.
-                await snapshotFile(journal, join(paths.engine, 'toolkit/content/jar.mn'));
-                await removeJarMnEntries(paths.engine, name);
-                info(`Removed ${name} entries from toolkit/content/jar.mn`);
-                const dir = join(furnacePaths.customDir, name);
-                if (await pathExists(dir)) {
-                    await snapshotDir(journal, dir);
-                    await removeDir(dir);
-                    info(`Deleted components/custom/${name}/`);
-                }
-                // Clean up deployed files in engine (per-file — see helper doc).
-                if (customConfig?.targetPath) {
-                    await removeDeployedCustomFiles(projectRoot, paths.engine, name, customConfig.targetPath, journal);
-                }
-                // Localized components deploy a .ftl outside targetPath into the
-                // shared Fluent tree; apply writes it, so remove must delete it too
-                // or the locale payload is orphaned.
-                if (customConfig?.localized) {
-                    const ftlRel = join(ftlDir, `${name}.ftl`);
-                    const ftlPath = join(paths.engine, ftlRel);
-                    if (await pathExists(ftlPath)) {
-                        await snapshotFile(journal, ftlPath);
-                        await removeFile(ftlPath);
-                        info(`Deleted localized file engine/${ftlRel}`);
-                    }
-                    // Drop the locale jar.mn chrome registration that `applyCustomFtlFile`
-                    // wrote during deploy — otherwise the engine is left with a
-                    // `locale/.../${name}.ftl` entry pointing at a file we just
-                    // deleted. 2026-04-21 eval (Finding #1): `furnace remove` left
-                    // `browser/locales/jar.mn` referencing the missing FTL, which
-                    // would break the next package-manifest validation.
-                    await removeCustomFtlJarMnEntry(paths.engine, `${name}.ftl`, ftlDir, customConfig, journal);
-                }
+                await performCustomRemovalMutations({
+                    projectRoot,
+                    name,
+                    paths,
+                    furnacePaths,
+                    freshConfig,
+                    ftlDir,
+                    journal,
+                });
             }
             const testCleanupFailures = freshType === 'custom' ? await cleanupAllCustomTestFiles(name, projectRoot, journal) : [];
             // Remove entry from furnace.json

package/dist/src/commands/furnace/rename-browser-test.js

@@ -16,9 +16,58 @@ export function updateBrowserChromeTestContent(content, oldName, newName, binary
     const newUnderscored = newName.replace(/-/g, '_');
     const oldTestStem = deriveTestStem(oldName, binaryName);
     const newTestStem = deriveTestStem(newName, binaryName);
-    return content
-        .replace(new RegExp(escapeRegex(oldName), 'g'), newName)
-        .replace(new RegExp(escapeRegex(oldClassName), 'g'), newClassName)
-        .replace(new RegExp(escapeRegex(oldUnderscored), 'g'), newUnderscored)
-        .replace(new RegExp(escapeRegex(oldTestStem), 'g'), newTestStem);
+    // ONE pass over the content, not four chained `.replace()` calls.
+    //
+    // Chaining let each rule see the previous rule's output. Renaming
+    // `acme-widget` to `acme-widget-v2` rewrote `test_acme_widget_defined` to
+    // `test_acme_widget_v2_defined` via the underscored form, and then the stem
+    // rule matched the `acme_widget` still inside that result and produced
+    // `test_acme_widget_v2_v2_defined`. A single alternation with a callback
+    // cannot re-enter its own output.
+    //
+    // Ordering is longest-first, because JS alternation takes the first
+    // alternative that matches at a given position.
+    const alternatives = [
+        // The stem is a short bare fragment (`moz-` and binary prefixes stripped,
+        // hyphens underscored) — `panel` for `moz-panel`. Matching it loose, even
+        // with hyphen guards, rewrote unrelated underscore-delimited identifiers
+        // such as `test_panel_group_integration`, because `_` must stay a legal
+        // neighbour for the generated name to match at all. The scaffold emits the
+        // stem in exactly one shape, so anchor to that shape instead of guessing
+        // from boundaries — with its own guards, so the anchored shape cannot
+        // match inside a longer identifier (`mytest_panel_defined_extra`).
+        {
+            pattern: `(?<![\\w-])test_${escapeRegex(oldTestStem)}_defined(?![\\w-])`,
+            to: `test_${newTestStem}_defined`,
+        },
+        // Word-boundary-aware, matching `furnace/rename.ts` and
+        // `rename-xpcshell.ts`: without the guards a rename of `moz-panel` rewrote
+        // `moz-panel-group`. `_` stays a legal neighbour for the underscored form
+        // because it is deliberately embedded in generated identifiers; `-` does
+        // not.
+        //
+        // Skipped when the underscored form IS the tag name (a hyphen-less
+        // component): both rules then match the same text and this one would win
+        // on order, substituting `newUnderscored` where the tag `newName` was
+        // meant. The stem rule still covers the one generated identifier shape.
+        ...(oldUnderscored === oldName
+            ? []
+            : [
+                {
+                    pattern: `(?<![A-Za-z0-9-])${escapeRegex(oldUnderscored)}(?![A-Za-z0-9-])`,
+                    to: newUnderscored,
+                },
+            ]),
+        { pattern: `(?<![\\w-])${escapeRegex(oldName)}(?![\\w-])`, to: newName },
+        { pattern: `\\b${escapeRegex(oldClassName)}\\b`, to: newClassName },
+    ];
+    // Each alternative is its own capture group and the replacement is picked by
+    // the group that matched — not by matched TEXT, which is ambiguous whenever
+    // two rules can produce the same match with different substitutions.
+    const combined = new RegExp(alternatives.map(({ pattern }) => `(${pattern})`).join('|'), 'g');
+    return content.replace(combined, (matched, ...args) => {
+        const groups = args.slice(0, alternatives.length);
+        const index = groups.findIndex((group) => group !== undefined);
+        return alternatives[index]?.to ?? matched;
+    });
 }

package/dist/src/commands/furnace/scan.js

@@ -28,17 +28,10 @@ async function promptAddComponents(components, tracked, projectRoot) {
     }
     const selected = await multiselect({
         message: 'Select components to add as stock',
-        options: untrackedComponents.map((c) => {
-            const features = [];
-            if (c.hasCSS)
-                features.push('CSS');
-            if (c.hasFTL)
-                features.push('FTL');
-            if (c.isRegistered)
-                features.push('registered');
-            const label = features.length > 0 ? `${c.tagName} — ${features.join(', ')}` : c.tagName;
-            return { value: c.tagName, label };
-        }),
+        options: untrackedComponents.map((c) => ({
+            value: c.tagName,
+            label: `${c.tagName}${formatComponentFeatures(c)}`,
+        })),
     });
     if (isCancel(selected)) {
         cancel('Cancelled');
@@ -110,6 +103,22 @@ async function persistStockComponents(projectRoot, names) {
         }
     });
 }
+/**
+ * Renders a component's discovered capabilities as a display suffix.
+ * Written twice before 0.41.0 — once for the interactive multiselect labels
+ * and once for the report rows — which is part of what pinned
+ * `furnaceScanCommand` at complexity 30/30.
+ */
+function formatComponentFeatures(component) {
+    const features = [];
+    if (component.hasCSS)
+        features.push('CSS');
+    if (component.hasFTL)
+        features.push('FTL');
+    if (component.isRegistered)
+        features.push('registered');
+    return features.length > 0 ? ` — ${features.join(', ')}` : '';
+}
 /**
  * Runs the furnace scan command to discover MozLitElement components.
  * @param projectRoot - Root directory of the project
@@ -153,33 +162,15 @@ export async function furnaceScanCommand(projectRoot, options = {}) {
             tracked.set(name, 'custom');
         }
     }
-    // Display each component
+    // Partition once and reuse: the tracked/untracked split was computed twice
+    // (imperatively here, declaratively again for --track) before 0.41.0.
+    const untrackedComponentList = components.filter((c) => !tracked.has(c.tagName));
+    const untrackedCount = untrackedComponentList.length;
+    const trackedCount = components.length - untrackedCount;
     for (const component of components) {
-        const features = [];
-        if (component.hasCSS)
-            features.push('CSS');
-        if (component.hasFTL)
-            features.push('FTL');
-        if (component.isRegistered)
-            features.push('registered');
-        let line = component.tagName;
-        if (features.length > 0) {
-            line += ` — ${features.join(', ')}`;
-        }
         const type = tracked.get(component.tagName);
-        if (type) {
-            line += ` [${type}]`;
-        }
-        info(line);
-    }
-    // Summary
-    let trackedCount = 0;
-    for (const component of components) {
-        if (tracked.has(component.tagName)) {
-            trackedCount++;
-        }
+        info(`${component.tagName}${formatComponentFeatures(component)}${type ? ` [${type}]` : ''}`);
     }
-    const untrackedCount = components.length - trackedCount;
     note(`Total: ${components.length}  Tracked: ${trackedCount}  Untracked: ${untrackedCount}`, 'Summary');
     // --track: persist the discovered untracked inventory into the `stock`
     // section without prompting (works non-interactively). Without it, scan
@@ -191,7 +182,7 @@ export async function furnaceScanCommand(projectRoot, options = {}) {
             outro('Scan complete');
             return;
         }
-        const untrackedNames = components.filter((c) => !tracked.has(c.tagName)).map((c) => c.tagName);
+        const untrackedNames = untrackedComponentList.map((c) => c.tagName);
         await persistStockComponents(projectRoot, untrackedNames);
         success(`Tracked ${untrackedNames.length} component${untrackedNames.length === 1 ? '' : 's'} in the stock section of furnace.json`);
         outro('Scan complete');

package/dist/src/commands/furnace/status.js

@@ -157,42 +157,44 @@ export async function furnaceStatusCommand(projectRoot, name) {
     // hints, so report them separately rather than collapsing into a single
     // "something is off" message.
     if (await pathExists(paths.engine)) {
-        let workspaceChanged = false;
-        let engineDrifted = false;
-        for (const [oName, overrideConfig] of Object.entries(config.overrides)) {
-            const componentDir = join(furnacePaths.overridesDir, oName);
-            if (!(await pathExists(componentDir)))
-                continue;
-            const previous = extractComponentChecksums(state.appliedChecksums, 'override', oName);
-            if (await hasComponentChanged(componentDir, previous)) {
-                workspaceChanged = true;
-            }
-            else if (await hasOverrideEngineDrift(paths.engine, componentDir, overrideConfig, ftlDir)) {
-                engineDrifted = true;
-            }
-            if (workspaceChanged && engineDrifted)
-                break;
-        }
-        if (!(workspaceChanged && engineDrifted)) {
-            for (const [cName, customConfig] of Object.entries(config.custom)) {
-                const componentDir = join(furnacePaths.customDir, cName);
+        // Held in an object rather than two `let`s: the scanner below mutates
+        // them from inside a closure, and TS's control-flow analysis does not
+        // propagate that through the call — it would narrow both to the literal
+        // `false` and flag every later read as always-falsy.
+        const drift = { workspaceChanged: false, engineDrifted: false };
+        /**
+         * Scans one component family for workspace or engine drift.
+         *
+         * The engine probe sits behind `else if` deliberately: a component whose
+         * workspace already changed does not need an engine comparison to decide
+         * what `status` reports, and the probe is the expensive half (it re-hashes
+         * deployed files). The consequence is that engine drift can go UNREPORTED
+         * for a component that also has workspace changes — the summary says
+         * "workspace changed", not both. Preserved verbatim from the two
+         * hand-written copies this replaced.
+         */
+        const scanFamily = async (entries, baseDir, kind, probeEngineDrift) => {
+            for (const [componentName, componentConfig] of entries) {
+                if (drift.workspaceChanged && drift.engineDrifted)
+                    return;
+                const componentDir = join(baseDir, componentName);
                 if (!(await pathExists(componentDir)))
                     continue;
-                const previous = extractComponentChecksums(state.appliedChecksums, 'custom', cName);
+                const previous = extractComponentChecksums(state.appliedChecksums, kind, componentName);
                 if (await hasComponentChanged(componentDir, previous)) {
-                    workspaceChanged = true;
+                    drift.workspaceChanged = true;
                 }
-                else if (await hasCustomEngineDrift(projectRoot, cName, componentDir, customConfig, ftlDir)) {
-                    engineDrifted = true;
+                else if (await probeEngineDrift(componentName, componentDir, componentConfig)) {
+                    drift.engineDrifted = true;
                 }
-                if (workspaceChanged && engineDrifted)
-                    break;
             }
-        }
-        if (workspaceChanged) {
+        };
+        await scanFamily(Object.entries(config.overrides), furnacePaths.overridesDir, 'override', (_name, componentDir, cfg) => hasOverrideEngineDrift(paths.engine, componentDir, cfg, ftlDir));
+        await scanFamily(Object.entries(config.custom), furnacePaths.customDir, 'custom', (name, componentDir, cfg) => hasCustomEngineDrift(projectRoot, name, componentDir, cfg, ftlDir));
+        if (drift.workspaceChanged) {
             warn('Components have been modified since last apply. Run `fireforge build` or `fireforge furnace apply`.');
         }
-        if (engineDrifted) {
+        if (drift.engineDrifted) {
             warn('Engine drift detected since last apply (reset/download/manual edit). Run `fireforge furnace apply` to re-deploy.');
         }
     }

package/dist/src/commands/furnace/validate.js

@@ -6,6 +6,7 @@ import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, } from '../../
 import { addCustomElementRegistration, addJarMnEntries, pruneStaleJarMnEntries, } from '../../core/furnace-registration.js';
 import { validateAllComponents, validateComponent } from '../../core/furnace-validate.js';
 import { FurnaceError } from '../../errors/furnace.js';
+import { toError } from '../../utils/errors.js';
 import { pathExists } from '../../utils/fs.js';
 import { info, intro, note, outro, success, warn } from '../../utils/logger.js';
 import { displayValidationIssues } from './validation-output.js';
@@ -15,6 +16,7 @@ const FIXABLE_CHECKS = new Set([
     'missing-jar-mn-css',
     'wrong-registration-pattern',
     'stale-jar-registration',
+    'missing-custom-element-registration',
 ]);
 /**
  * Auto-fixes registration issues that have deterministic solutions.
@@ -53,7 +55,7 @@ async function autoFixIssues(projectRoot, issues) {
             }
         }
         catch (err) {
-            warn(`Could not prune stale jar.mn lines: ${err instanceof Error ? err.message : String(err)}`);
+            warn(`Could not prune stale jar.mn lines: ${toError(err).message}`);
         }
     }
     // Fix jar.mn entries
@@ -72,21 +74,26 @@ async function autoFixIssues(projectRoot, issues) {
             }
         }
         catch (err) {
-            warn(`Could not fix jar.mn for ${componentName}: ${err instanceof Error ? err.message : String(err)}`);
+            warn(`Could not fix jar.mn for ${componentName}: ${toError(err).message}`);
         }
     }
-    // Fix missing customElements.js registrations
-    for (const issue of issues) {
-        if (issue.check !== 'wrong-registration-pattern')
-            continue;
-        // wrong-registration-pattern means it IS registered, but in the wrong block.
-        // We don't auto-fix this as it requires moving code between blocks, which
-        // is too risky. Only fix truly missing registrations.
-    }
-    // Check for components that are missing from customElements.js entirely
-    // (detected by post-apply consistency, not by validate — but we can check here)
-    for (const [componentName, customConfig] of Object.entries(config.custom)) {
-        if (!customConfig.register)
+    // `wrong-registration-pattern` is deliberately NOT auto-fixed: it means the
+    // component IS registered but in the wrong block, and moving code between
+    // blocks is too risky to do unattended. Only truly missing registrations are
+    // repaired, below.
+    // Repair components missing from customElements.js entirely (reported by
+    // validate as `missing-custom-element-registration`).
+    //
+    // Scoped to the components named in `issues`. Until 0.41.0 this iterated
+    // every entry in `config.custom`, so `furnace validate <one-component> --fix`
+    // wrote customElements.js registrations for EVERY custom component — outside
+    // the issue list it was handed, and invisibly, since `fixed` was never
+    // incremented here. The block's own comment already claimed this scoping;
+    // the code did not implement it.
+    const componentsWithIssues = new Set(issues.map((issue) => issue.component));
+    for (const componentName of componentsWithIssues) {
+        const customConfig = config.custom[componentName];
+        if (!customConfig?.register)
             continue;
         const componentDir = join(furnacePaths.customDir, componentName);
         if (!(await pathExists(componentDir)))
@@ -97,13 +104,13 @@ async function autoFixIssues(projectRoot, issues) {
             continue;
         const modulePath = `chrome://global/content/elements/${componentName}.mjs`;
         try {
+            // Idempotent: returns without error when already registered, so this
+            // stays a no-op for components whose registration is already correct.
             await addCustomElementRegistration(engineDir, componentName, modulePath);
-            // addCustomElementRegistration is idempotent — it returns without error
-            // if already registered. We only count it as fixed if a matching issue
-            // existed in the input.
         }
         catch {
-            // Ignore — idempotent call, may already be registered
+            // Best-effort repair — the re-validation pass at the call site reports
+            // whatever is still outstanding.
         }
     }
     return fixed;

package/dist/src/commands/import.js

@@ -5,12 +5,13 @@ import { Command } from 'commander';
 import { getProjectPaths, loadConfig, loadState, updateState } from '../core/config.js';
 import { getHead } from '../core/git.js';
 import { getDirtyFiles } from '../core/git-status.js';
-import { applyPatchesWithContinue, countPatches, createPatchedContentComputer, discoverPatches, extractAffectedFiles, matchesUntilFilename, PatchError, } from '../core/patch-apply.js';
+import { applyPatchesWithContinue, countPatches, createPatchedContentContext, discoverPatches, extractAffectedFiles, matchesUntilFilename, PatchError, } from '../core/patch-apply.js';
 import { checkVersionCompatibility, loadPatchesManifest, validatePatchesManifestConsistency, validatePatchIntegrity, } from '../core/patch-manifest.js';
 import { getPatchSourceVersion } from '../core/patch-source-metadata.js';
 import { warnIfStaticComponentsStale } from '../core/test-stale-check.js';
 import { GeneralError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
+import { mapWithConcurrency } from '../utils/concurrency.js';
+import { getNodeErrorCode, toError } from '../utils/errors.js';
 import { pathExists, readText } from '../utils/fs.js';
 import { error, info, intro, isCancel, outro, spinner, success, verbose, warn, } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
@@ -24,8 +25,8 @@ import { pickDefined } from '../utils/options.js';
  */
 const SAFE_IO_FALLBACK_CODES = new Set(['ENOENT', 'EACCES', 'EPERM', 'EISDIR', 'EBUSY']);
 function isSafeIoFallback(error) {
-    const code = error?.code;
-    return typeof code === 'string' && SAFE_IO_FALLBACK_CODES.has(code);
+    const code = getNodeErrorCode(error);
+    return code !== undefined && SAFE_IO_FALLBACK_CODES.has(code);
 }
 /** Concurrency bound for per-file classification (each call spawns git). */
 const UNMANAGED_CLASSIFY_CONCURRENCY = 8;
@@ -33,7 +34,7 @@ async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
     // One manifest+patch-discovery load for the whole batch (the per-call
     // computePatchedContent re-read everything for every file), and bounded
     // concurrency instead of an unbounded Promise.all over git spawns.
-    const computeExpected = await createPatchedContentComputer(patchesDir, engineDir);
+    const { computePatched: computeExpected } = await createPatchedContentContext(patchesDir, engineDir);
     const classifications = await mapWithConcurrency(dirtyFiles, UNMANAGED_CLASSIFY_CONCURRENCY, async (file) => {
         try {
             const [expected, exists] = await Promise.all([
@@ -62,21 +63,6 @@ async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
     });
     return classifications.filter((file) => file !== null).sort();
 }
-/** Maps items with at most `limit` in-flight promises. Preserves order. */
-async function mapWithConcurrency(items, limit, fn) {
-    const results = new Array(items.length);
-    let next = 0;
-    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
-        for (;;) {
-            const index = next++;
-            if (index >= items.length)
-                return;
-            results[index] = await fn(items[index]);
-        }
-    });
-    await Promise.all(workers);
-    return results;
-}
 function reportForcedOverwriteRisk(unmanagedDirtyFiles) {
     warn(`--force will overwrite ${unmanagedDirtyFiles.length} unmanaged change${unmanagedDirtyFiles.length === 1 ? '' : 's'} in patch-touched file${unmanagedDirtyFiles.length === 1 ? '' : 's'}:`);
     for (const file of unmanagedDirtyFiles) {