@hominis/fireforge 0.19.6 → 0.21.0

package/dist/src/commands/furnace/chrome-doc.d.ts

@@ -35,7 +35,39 @@ export interface FurnaceChromeDocCreateOptions {
      * because the owning moz.build depends on the fork's layout.
      */
     withTests?: boolean;
+    /** Print the scaffold plan without writing files. */
+    dryRun?: boolean;
 }
+/**
+ * Validates a chrome-doc name. Lowercase ASCII, optional hyphens, no
+ * leading digit — the name is used verbatim in CSS selectors, jar.mn
+ * entries, FTL keys, and file basenames, so anything outside that
+ * character set would break at least one downstream consumer.
+ * @param name Chrome-doc name (file basename without extension).
+ * @throws InvalidArgumentError when the name is unusable.
+ */
+export declare function validateChromeDocName(name: string): void;
+export interface ChromeDocPlan {
+    files: string[];
+    dirs: string[];
+    jarEntries: Array<{
+        file: string;
+        entry: string;
+        present: boolean;
+    }>;
+    localeWildcardCapturesFtl: boolean;
+    testDir?: string;
+    testFiles: string[];
+}
+/** Builds the shared create/remove plan for a top-level chrome document. */
+export declare function buildChromeDocPlan(args: {
+    engineDir: string;
+    name: string;
+    withTests: boolean;
+    binaryName: string;
+    validateCreateConflicts?: boolean;
+    includeLocaleEntryWhenWildcard?: boolean;
+}): Promise<ChromeDocPlan>;
 /**
  * Runs `furnace chrome-doc create <name>`.
  * @param projectRoot Root directory of the project.

package/dist/src/commands/furnace/chrome-doc.js

@@ -37,7 +37,7 @@ const CHROME_DOC_NAME_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
  * @param name Chrome-doc name (file basename without extension).
  * @throws InvalidArgumentError when the name is unusable.
  */
-function validateChromeDocName(name) {
+export function validateChromeDocName(name) {
     if (!name.trim()) {
         throw new InvalidArgumentError('Chrome-doc name is required', 'name');
     }
@@ -45,6 +45,106 @@ function validateChromeDocName(name) {
         throw new InvalidArgumentError('Chrome-doc name must be lowercase ASCII, may contain hyphens, and must not start with a digit (e.g. mybrowser, about-onboarding).', 'name');
     }
 }
+/** Builds the shared create/remove plan for a top-level chrome document. */
+export async function buildChromeDocPlan(args) {
+    const contentDir = join(args.engineDir, 'browser/base/content');
+    const sharedThemeDir = join(args.engineDir, 'browser/themes/shared');
+    const localeDir = join(args.engineDir, 'browser/locales/en-US/browser');
+    const dirs = [contentDir, sharedThemeDir, localeDir];
+    const xhtmlPath = join(contentDir, `${args.name}.xhtml`);
+    if (args.validateCreateConflicts && (await pathExists(xhtmlPath))) {
+        throw new FurnaceError(`${args.name}.xhtml already exists at ${xhtmlPath}. Remove it or choose a different name.`);
+    }
+    const jarMnPath = join(args.engineDir, 'browser/base/jar.mn');
+    const jarIncMnPath = join(args.engineDir, 'browser/themes/shared/jar.inc.mn');
+    const localeJarMnPath = join(args.engineDir, 'browser/locales/jar.mn');
+    for (const requiredJarPath of [jarMnPath, jarIncMnPath, localeJarMnPath]) {
+        if (!(await pathExists(requiredJarPath))) {
+            throw new FurnaceError(`Required jar file ${requiredJarPath} does not exist; cannot register chrome-doc entry. Check that the fork's engine layout matches the expected browser/ and locales/ tree.`);
+        }
+    }
+    const [jarMn, jarIncMn, localeJarMn] = await Promise.all([
+        readText(jarMnPath),
+        readText(jarIncMnPath),
+        readText(localeJarMnPath),
+    ]);
+    const localeWildcardCapturesFtl = localesFtlWildcardCapturesScaffoldedName(localeJarMn);
+    const jarEntries = [];
+    for (const entry of jarMnEntriesForChromeDoc(args.name)) {
+        jarEntries.push({
+            file: 'browser/base/jar.mn',
+            entry,
+            present: jarMn.includes(entry),
+        });
+    }
+    const cssEntry = jarIncMnEntryForChromeDoc(args.name);
+    jarEntries.push({
+        file: 'browser/themes/shared/jar.inc.mn',
+        entry: cssEntry,
+        present: jarIncMn.includes(cssEntry),
+    });
+    if (!localeWildcardCapturesFtl || args.includeLocaleEntryWhenWildcard) {
+        const ftlEntry = localeJarMnEntryForChromeDoc(args.name);
+        jarEntries.push({
+            file: 'browser/locales/jar.mn',
+            entry: ftlEntry,
+            present: localeJarMn.includes(ftlEntry),
+        });
+    }
+    const files = [
+        `browser/base/content/${args.name}.xhtml`,
+        `browser/base/content/${args.name}.js`,
+        `browser/themes/shared/${args.name}-chrome.css`,
+        `browser/locales/en-US/browser/${args.name}.ftl`,
+    ];
+    const testFiles = [];
+    let testDir;
+    if (args.withTests) {
+        const testParentDir = `${args.binaryName}-xpcshell`;
+        testDir = `browser/base/content/test/${testParentDir}/${args.name}`;
+        testFiles.push(`${testDir}/${chromeDocPackagingTestFileName(args.name)}`, `${testDir}/xpcshell.toml`);
+    }
+    return {
+        files,
+        dirs,
+        jarEntries,
+        localeWildcardCapturesFtl,
+        ...(testDir ? { testDir } : {}),
+        testFiles,
+    };
+}
+function renderChromeDocCreateDryRun(name, plan) {
+    const dirLines = plan.dirs.map((dir) => `  ${dir}`);
+    const jarLines = plan.jarEntries.map(({ file, entry, present }) => `  engine/${file}: ${present ? 'already present' : 'would add'} ${entry.trim()}`);
+    const localeLine = plan.localeWildcardCapturesFtl
+        ? [
+            '',
+            'Locale jar.mn already has a [localization] wildcard that captures the FTL;',
+            'no per-file locale entry would be added.',
+        ]
+        : [];
+    const testLines = plan.testFiles.length > 0
+        ? [
+            '',
+            'Would create xpcshell packaging test files:',
+            ...plan.testFiles.map((f) => `  engine/${f}`),
+        ]
+        : [];
+    return [
+        `[dry-run] Chrome document "${name}" scaffold plan`,
+        '',
+        'Directories checked/created as needed:',
+        ...dirLines,
+        '',
+        'Would create source files:',
+        ...plan.files.map((f) => `  engine/${f}`),
+        ...testLines,
+        '',
+        'Jar registrations:',
+        ...jarLines,
+        ...localeLine,
+    ].join('\n');
+}
 /**
  * Appends a line to a jar.mn-style file when that exact line is not
  * already present. Captures the pre-write contents in the journal so a
@@ -192,6 +292,18 @@ export async function furnaceChromeDocCreateCommand(projectRoot, name, options =
     }
     const withTitlebar = options.titlebar ?? true;
     const withTests = options.withTests ?? false;
+    const plan = await buildChromeDocPlan({
+        engineDir,
+        name,
+        withTests,
+        binaryName: forgeConfig.binaryName,
+        validateCreateConflicts: true,
+    });
+    if (options.dryRun) {
+        note(renderChromeDocCreateDryRun(name, plan), name);
+        outro('Dry run complete');
+        return;
+    }
     const written = await runFurnaceMutation(projectRoot, 'chrome-doc-rollback', (ctx) => performChromeDocMutations({
         name,
         license,

package/dist/src/commands/furnace/create-validation.d.ts

@@ -0,0 +1,6 @@
+import type { FurnaceCreateOptions } from '../../types/commands/index.js';
+import type { FurnaceConfig } from '../../types/furnace.js';
+/**
+ * Validates a proposed custom component against the current furnace config.
+ */
+export declare function validateCreateAgainstConfig(config: FurnaceConfig, componentName: string, allowPrefixMismatch: FurnaceCreateOptions['allowPrefixMismatch'], composes: string[] | undefined): void;

package/dist/src/commands/furnace/create-validation.js

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { detectComposesCycles } from '../../core/furnace-config.js';
+import { InvalidArgumentError } from '../../errors/base.js';
+import { FurnaceError } from '../../errors/furnace.js';
+function checkNameConflict(config, name) {
+    if (name in config.custom) {
+        return `A custom component named "${name}" already exists in furnace.json`;
+    }
+    if (name in config.overrides) {
+        return `An override component named "${name}" already exists in furnace.json`;
+    }
+    return undefined;
+}
+function validateComposesTargets(config, componentName, composes) {
+    if (!composes || composes.length === 0)
+        return;
+    const known = new Set([
+        ...config.stock,
+        ...Object.keys(config.overrides),
+        ...Object.keys(config.custom),
+    ]);
+    for (const tag of composes) {
+        if (tag === componentName) {
+            throw new FurnaceError(`Component "${componentName}" cannot compose itself.`);
+        }
+        if (!known.has(tag)) {
+            throw new FurnaceError(`Cannot compose unknown component "${tag}". ` +
+                'The referenced component must be registered as stock, override, or custom.');
+        }
+    }
+    detectComposesCycles({
+        ...config.custom,
+        [componentName]: {
+            description: '',
+            targetPath: `toolkit/content/widgets/${componentName}`,
+            register: true,
+            localized: false,
+            composes,
+        },
+    });
+}
+/**
+ * Validates a proposed custom component against the current furnace config.
+ */
+export function validateCreateAgainstConfig(config, componentName, allowPrefixMismatch, composes) {
+    const conflict = checkNameConflict(config, componentName);
+    if (conflict) {
+        throw new FurnaceError(conflict, componentName);
+    }
+    if (config.componentPrefix &&
+        !componentName.startsWith(config.componentPrefix) &&
+        !allowPrefixMismatch) {
+        throw new InvalidArgumentError(`Name "${componentName}" does not start with the configured prefix "${config.componentPrefix}". ` +
+            `Use a prefixed name (e.g. "${config.componentPrefix}${componentName}"), update ` +
+            '`componentPrefix` in furnace.json, or pass --allow-prefix-mismatch to create the component anyway.', 'name');
+    }
+    validateComposesTargets(config, componentName, composes);
+}
+//# sourceMappingURL=create-validation.js.map

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

@@ -2,7 +2,7 @@
 import { join } from 'node:path';
 import { text } from '@clack/prompts';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { createDefaultFurnaceConfig, detectComposesCycles, furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
+import { createDefaultFurnaceConfig, furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
 import { resolveFtlChromeSubPath, tagNameToClassName } from '../../core/furnace-constants.js';
 import { recordFurnaceRollbackFailure, runFurnaceMutation, } from '../../core/furnace-operation.js';
 import { CUSTOM_ELEMENT_TAG_PATTERN, CUSTOM_ELEMENT_TAG_RULES, } from '../../core/furnace-registration-validate.js';
@@ -21,6 +21,7 @@ import { resolveCreateFeatures } from './create-features.js';
 import { scaffoldMochikitTestFiles } from './create-mochikit.js';
 import { assertCustomEntryPersisted } from './create-readback.js';
 import { generateCssContent, generateFtlContent, generateMjsContent } from './create-templates.js';
+import { validateCreateAgainstConfig } from './create-validation.js';
 import { scaffoldXpcshellTestFiles } from './create-xpcshell.js';
 async function loadAuthoringFurnaceConfig(projectRoot) {
     if (await furnaceConfigExists(projectRoot)) {
@@ -41,18 +42,6 @@ function validateTagName(name) {
         return `Name ${CUSTOM_ELEMENT_TAG_RULES}`;
     return undefined;
 }
-/**
- * Checks if a component name conflicts with existing entries in furnace.json.
- */
-function checkNameConflict(config, name) {
-    if (name in config.custom) {
-        return `A custom component named "${name}" already exists in furnace.json`;
-    }
-    if (name in config.overrides) {
-        return `An override component named "${name}" already exists in furnace.json`;
-    }
-    return undefined;
-}
 /**
  * Scaffolds browser mochitest files for a newly created custom component.
  * @param componentName - Custom element tag name
@@ -247,11 +236,16 @@ async function performCreateMutations(args) {
     const testFiles = [];
     let files;
     try {
+        const freshConfig = await loadAuthoringFurnaceConfig(args.projectRoot);
+        validateCreateAgainstConfig(freshConfig, args.componentName, args.allowPrefixMismatch, args.composes);
+        if (await pathExists(args.componentDir)) {
+            throw new FurnaceError(`Directory already exists: components/custom/${args.componentName}`, args.componentName);
+        }
         // Record the componentDir creation entry immediately after registration
         // so signal-driven rollback can clean it up even if writeComponentFiles
         // is interrupted mid-ensureDir.
         recordCreatedDir(journal, args.componentDir);
-        files = await writeComponentFiles(args.componentDir, args.componentName, args.className, args.description, args.localized, args.license, args.ftlChromeSubPath, args.sharedFtl, journal);
+        files = await writeComponentFiles(args.componentDir, args.componentName, args.className, args.description, args.localized, args.license, resolveFtlChromeSubPath(freshConfig.ftlBasePath), args.sharedFtl, journal);
         const customEntry = {
             description: args.description,
             targetPath: `toolkit/content/widgets/${args.componentName}`,
@@ -264,9 +258,9 @@ async function performCreateMutations(args) {
         if (args.sharedFtl) {
             customEntry.sharedFtl = args.sharedFtl;
         }
-        args.config.custom[args.componentName] = customEntry;
+        freshConfig.custom[args.componentName] = customEntry;
         await snapshotFile(journal, args.furnacePaths.furnaceConfig);
-        await writeFurnaceConfig(args.projectRoot, args.config);
+        await writeFurnaceConfig(args.projectRoot, freshConfig);
         await assertCustomEntryPersisted(args.projectRoot, args.componentName);
         if (args.testStyle === 'browser-chrome') {
             const scafFiles = await scaffoldTestFiles(args.componentName, args.license, args.forgeConfig, args.paths, journal);
@@ -310,41 +304,6 @@ async function resolveDescription(isInteractive, options) {
     }
     return description;
 }
-/**
- * Validates the `--compose` targets against registered components and runs
- * cycle detection if the new component is introduced into the graph. Throws
- * on any failure; returns when the graph is clean.
- */
-function validateComposesTargets(config, componentName, composes) {
-    if (!composes || composes.length === 0)
-        return;
-    const known = new Set([
-        ...config.stock,
-        ...Object.keys(config.overrides),
-        ...Object.keys(config.custom),
-    ]);
-    for (const tag of composes) {
-        if (tag === componentName) {
-            throw new FurnaceError(`Component "${componentName}" cannot compose itself.`);
-        }
-        if (!known.has(tag)) {
-            throw new FurnaceError(`Cannot compose unknown component "${tag}". ` +
-                'The referenced component must be registered as stock, override, or custom.');
-        }
-    }
-    // Check for cycles that would be introduced by adding this component.
-    const tempCustom = {
-        ...config.custom,
-        [componentName]: {
-            description: '',
-            targetPath: `toolkit/content/widgets/${componentName}`,
-            register: true,
-            localized: false,
-            composes,
-        },
-    };
-    detectComposesCycles(tempCustom);
-}
 /**
  * Runs the furnace create command to scaffold a new custom component.
  * @param projectRoot - Root directory of the project
@@ -391,39 +350,14 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
     // succeeds so a cancelled create in a fresh project does not strand a new
     // furnace.json behind.
     const config = await loadAuthoringFurnaceConfig(projectRoot);
-    // Check for conflicts
-    const conflict = checkNameConflict(config, componentName);
-    if (conflict) {
-        throw new FurnaceError(conflict, componentName);
-    }
+    const composes = options.compose;
+    validateCreateAgainstConfig(config, componentName, options.allowPrefixMismatch, composes);
     // Check if it already exists in the engine source tree
     if (await pathExists(paths.engine)) {
         if (await isComponentInEngine(paths.engine, componentName)) {
             throw new FurnaceError(`"${componentName}" already exists in the engine source tree. Use "fireforge furnace override" instead.`, componentName);
         }
     }
-    // Refuse if name doesn't match componentPrefix, unless
-    // --allow-prefix-mismatch was explicitly passed.
-    //
-    // Pre-0.16.0 this was a bare `warn()` and the create flow continued,
-    // which produced a class of validation runs where the command reported
-    // success, scaffolded files under components/custom/<name>/, and
-    // registered tests in browser/base/moz.build, but the component
-    // wasn't a good citizen of the fork's convention — subsequent
-    // follow-up commands (list, status, rename) behaved inconsistently.
-    // Refusing up-front leaves the workspace untouched on a bad name and
-    // forces an intentional `--allow-prefix-mismatch` for the rare case
-    // where the mismatch is deliberate.
-    if (config.componentPrefix &&
-        !componentName.startsWith(config.componentPrefix) &&
-        !options.allowPrefixMismatch) {
-        throw new InvalidArgumentError(`Name "${componentName}" does not start with the configured prefix "${config.componentPrefix}". ` +
-            'Use a prefixed name (e.g. "' +
-            config.componentPrefix +
-            componentName +
-            '"), update `componentPrefix` in furnace.json, ' +
-            'or pass --allow-prefix-mismatch to create the component anyway.', 'name');
-    }
     // --- Resolve description ---
     const description = await resolveDescription(isInteractive, options);
     // --- Resolve features ---
@@ -447,10 +381,6 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
     if (await pathExists(componentDir)) {
         throw new FurnaceError(`Directory already exists: components/custom/${componentName}`, componentName);
     }
-    // --- Validate --compose targets BEFORE any writes so a failed validation
-    // does not strand component files behind.
-    const composes = options.compose;
-    validateComposesTargets(config, componentName, composes);
     // --- Normalize and validate --shared-ftl ahead of any writes. Shares the
     // structural rules with furnace-config.ts so the command and the on-disk
     // schema cannot diverge. Pass the resolved `localized` rather than a
@@ -492,10 +422,6 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
     // state via the shared rollback journal. The mutation runs under the
     // furnace-wide lock and is registered with the global SIGINT/SIGTERM
     // rollback pathway.
-    // Derive the FTL chrome sub-path from the configured ftlBasePath so the
-    // generated `.mjs` calls `insertFTLIfNeeded` at a URI that actually matches
-    // the locale jar.mn entry `furnace apply` will write.
-    const ftlChromeSubPath = resolveFtlChromeSubPath(config.ftlBasePath);
     const { files, testFiles } = await runFurnaceMutation(projectRoot, 'create-rollback', (ctx) => performCreateMutations({
         projectRoot,
         componentName,
@@ -507,12 +433,11 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
         sharedFtl,
         componentDir,
         furnacePaths,
-        config,
+        allowPrefixMismatch: options.allowPrefixMismatch,
         forgeConfig,
         paths,
         license,
         testStyle,
-        ftlChromeSubPath,
         operationContext: ctx,
     }));
     note(formatSuccessNote({

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

@@ -3,6 +3,7 @@ import { Option } from 'commander';
 import { pickDefined } from '../../utils/options.js';
 import { furnaceApplyCommand } from './apply.js';
 import { furnaceChromeDocCreateCommand } from './chrome-doc.js';
+import { furnaceChromeDocRemoveCommand } from './chrome-doc-remove.js';
 import { furnaceCreateCommand } from './create.js';
 import { furnaceDeployCommand } from './deploy.js';
 import { furnaceDiffCommand } from './diff.js';
@@ -86,6 +87,10 @@ function registerFurnaceInfoCommands(furnace, context) {
         .action(withErrorHandling(async (name, options) => {
         await furnaceCreateCommand(getProjectRoot(), name, options);
     }));
+    registerChromeDocCommands(furnace, context);
+}
+function registerChromeDocCommands(furnace, context) {
+    const { getProjectRoot, withErrorHandling } = context;
     const chromeDoc = furnace
         .command('chrome-doc')
         .description('Scaffold top-level chrome documents (xhtml + js + css + ftl + jar.mn)');
@@ -94,9 +99,18 @@ function registerFurnaceInfoCommands(furnace, context) {
         .description('Scaffold a new top-level chrome document')
         .option('--no-titlebar', 'Frameless overlay-style document (omits titlebar-buttonbox)')
         .option('--with-tests', 'Scaffold an xpcshell packaging-verification test that probes XCurProcD/chrome/browser/... directly (bypasses the xpcshell chrome:// URI limitation).')
+        .option('--dry-run', 'Show the chrome-doc scaffold plan without writing')
         .action(withErrorHandling(async (name, options) => {
         await furnaceChromeDocCreateCommand(getProjectRoot(), name, pickDefined(options));
     }));
+    chromeDoc
+        .command('remove <name>')
+        .description('Remove a scaffolded top-level chrome document')
+        .option('-y, --yes', 'Skip confirmation')
+        .option('--dry-run', 'Show the chrome-doc removal plan without writing')
+        .action(withErrorHandling(async (name, options) => {
+        await furnaceChromeDocRemoveCommand(getProjectRoot(), name, pickDefined(options));
+    }));
 }
 /**
  * Registers Furnace commands for authoring, inspection, and maintenance:

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

@@ -213,6 +213,7 @@ export async function furnaceRefreshCommand(projectRoot, name, options = {}) {
     let totalUnchanged = 0;
     let totalSkipped = 0;
     const conflictComponents = [];
+    const failedOverrides = [];
     // Snapshot furnace.json before the batch loop so an unexpected failure
     // (process crash, unhandled error) can be recovered from. Per-component
     // errors caught below are expected and do not trigger a restore — only
@@ -244,7 +245,9 @@ export async function furnaceRefreshCommand(projectRoot, name, options = {}) {
                 }
             }
             catch (error) {
-                warn(`${overrideName}: ${toError(error).message}`);
+                const message = toError(error).message;
+                warn(`${overrideName}: ${message}`);
+                failedOverrides.push({ name: overrideName, message });
             }
         }
     }
@@ -257,12 +260,18 @@ export async function furnaceRefreshCommand(projectRoot, name, options = {}) {
         throw error;
     }
     const summary = `${overrideNames.length} override(s) processed, ${totalSkipped} already up-to-date\n` +
-        `${totalMerged} file(s) merged, ${totalUnchanged} unchanged, ${totalConflicts} conflict(s)`;
+        `${totalMerged} file(s) merged, ${totalUnchanged} unchanged, ${totalConflicts} conflict(s), ` +
+        `${failedOverrides.length} failed`;
     if (conflictComponents.length > 0) {
         warn(`Conflicts in: ${conflictComponents.join(', ')}. ` +
             'Resolve conflict markers, then re-run refresh for those components to update baseVersion.');
     }
     note(summary, dryRun ? 'Dry Run Summary' : 'Refresh Summary');
+    if (failedOverrides.length > 0) {
+        outro(dryRun ? 'Dry run completed with failures' : 'Refresh completed with failures');
+        throw new FurnaceError(`Failed to refresh ${failedOverrides.length} override(s): ` +
+            failedOverrides.map((failure) => `${failure.name}: ${failure.message}`).join('; '));
+    }
     outro(dryRun ? 'Dry run complete' : 'Refresh complete');
 }
 //# sourceMappingURL=refresh.js.map

package/dist/src/commands/furnace/remove-state.d.ts

@@ -0,0 +1,5 @@
+import type { FurnaceState } from '../../types/furnace.js';
+/**
+ * Removes every checksum entry owned by the removed component.
+ */
+export declare function dropChecksumsByPrefix(state: FurnaceState, prefix: string): FurnaceState;

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

@@ -0,0 +1,14 @@
+/**
+ * Removes every checksum entry owned by the removed component.
+ */
+export function dropChecksumsByPrefix(state, prefix) {
+    const result = { ...state };
+    if (state.appliedChecksums) {
+        result.appliedChecksums = Object.fromEntries(Object.entries(state.appliedChecksums).filter(([k]) => !k.startsWith(prefix)));
+    }
+    if (state.engineChecksums) {
+        result.engineChecksums = Object.fromEntries(Object.entries(state.engineChecksums).filter(([k]) => !k.startsWith(prefix)));
+    }
+    return result;
+}
+//# sourceMappingURL=remove-state.js.map