@hominis/fireforge 0.21.0 → 0.21.2

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

@@ -8,6 +8,7 @@ import { isObject, isString } from '../utils/validation.js';
 import { FIREFORGE_DIR } from './config.js';
 import { parseStringArray } from './furnace-config-array-utils.js';
 import { parseCustomConfig } from './furnace-config-custom.js';
+import { orderFurnaceConfigForWrite } from './furnace-config-order.js';
 import { validateRuntimeVariables, validateTokenHostDocuments } from './furnace-config-tokens.js';
 import { resolveFtlDir } from './furnace-constants.js';
 import { detectComposesCycles, validateComposesReferences } from './furnace-graph-utils.js';
@@ -410,7 +411,18 @@ export async function loadFurnaceConfig(root) {
  */
 export async function writeFurnaceConfig(root, config) {
     const paths = getFurnacePaths(root);
-    await writeJson(paths.furnaceConfig, config);
+    let existing;
+    if (await pathExists(paths.furnaceConfig)) {
+        try {
+            const raw = await readJson(paths.furnaceConfig);
+            if (isObject(raw))
+                existing = raw;
+        }
+        catch {
+            existing = undefined;
+        }
+    }
+    await writeJson(paths.furnaceConfig, orderFurnaceConfigForWrite(existing, config));
 }
 /**
  * Stamps every override's `baseVersion` to the supplied version. Used by

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

@@ -233,6 +233,9 @@ async function findOrphanXpcshellScaffolds(root, config) {
     for (const entry of entries) {
         if (known.has(entry))
             continue;
+        const chromeDocPackagingTest = join(parentAbs, entry, `test_${entry}_packaging.js`);
+        if (await pathExists(chromeDocPackagingTest))
+            continue;
         issues.push({
             component: entry,
             severity: 'error',

package/dist/src/core/patch-export-coverage.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Patch coverage and supersession helpers used by export planning.
+ */
+import type { PatchInfo, PatchMetadata } from '../types/commands/index.js';
+/**
+ * Finds patches that are completely superseded by newer patches.
+ * A patch is superseded if all its affected files are covered by newer patches.
+ * @param patchesDir - Path to the patches directory
+ * @param newPatchFiles - Files affected by the new patch
+ * @param excludeFilename - Filename to exclude from results (the new patch itself)
+ * @returns Superseded patches
+ */
+export declare function findSupersededPatches(patchesDir: string, newPatchFiles: string[], excludeFilename?: string): Promise<PatchInfo[]>;
+/**
+ * Report whether a patch is fully covered by a new export, and which of its
+ * files caused the coverage.
+ */
+export interface PatchCoverage {
+    covered: boolean;
+    byFiles: string[];
+}
+/**
+ * Checks whether a patch is fully covered by a new export.
+ * A patch is fully covered when every file it affects is present in the new export.
+ * @param patchFiles - Files affected by the existing patch
+ * @param targetFiles - Files affected by the new export
+ * @returns Coverage report with the triggering file list when `covered` is true
+ */
+export declare function isPatchFullyCovered(patchFiles: string[], targetFiles: string[]): PatchCoverage;
+/**
+ * Finds patches whose filesAffected entries are fully covered by the specified files.
+ * Used for complete supersession when exporting full-file patches.
+ * @param patchesDir - Path to the patches directory
+ * @param targetFiles - Files affected by the new export
+ * @param excludeFilename - Filename to exclude from results (the new patch itself)
+ * @returns Patches that are fully covered by the new export
+ */
+export declare function findAllPatchesForFiles(patchesDir: string, targetFiles: string[], excludeFilename?: string): Promise<PatchInfo[]>;
+/**
+ * Describes which files in a covered patch triggered its supersession.
+ * Returned from `planExport` so dry-run previews can render a complete
+ * "moved / removed" picture rather than a bare patch count.
+ */
+export interface SupersedeCoverageDetail {
+    /** Existing patch filename. */
+    filename: string;
+    /** Files the existing patch claimed that the new export also claims. */
+    coveredByFiles: string[];
+}
+/**
+ * Resolves coverage details for every existing patch that the new export
+ * would fully cover.
+ */
+export declare function findAllPatchesForFilesWithDetails(patchesDir: string, targetFiles: string[], excludeFilename?: string): Promise<{
+    patch: PatchInfo;
+    coverage: PatchCoverage;
+    metadata: PatchMetadata;
+}[]>;

package/dist/src/core/patch-export-coverage.js

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Patch coverage and supersession helpers used by export planning.
+ */
+import { discoverPatches, isNewFilePatch } from './patch-apply.js';
+import { loadPatchesManifest } from './patch-manifest.js';
+/**
+ * Finds patches that are completely superseded by newer patches.
+ * A patch is superseded if all its affected files are covered by newer patches.
+ * @param patchesDir - Path to the patches directory
+ * @param newPatchFiles - Files affected by the new patch
+ * @param excludeFilename - Filename to exclude from results (the new patch itself)
+ * @returns Superseded patches
+ */
+export async function findSupersededPatches(patchesDir, newPatchFiles, excludeFilename) {
+    const manifest = await loadPatchesManifest(patchesDir);
+    if (!manifest)
+        return [];
+    const patches = await discoverPatches(patchesDir);
+    const superseded = [];
+    for (const metadata of manifest.patches) {
+        if (excludeFilename && metadata.filename === excludeFilename)
+            continue;
+        if (metadata.filesAffected.length === 1) {
+            const affectedFile = metadata.filesAffected[0];
+            if (affectedFile && newPatchFiles.includes(affectedFile)) {
+                const patch = patches.find((p) => p.filename === metadata.filename);
+                if (patch && (await isNewFilePatch(patch.path))) {
+                    superseded.push(patch);
+                }
+            }
+        }
+    }
+    return superseded;
+}
+/**
+ * Checks whether a patch is fully covered by a new export.
+ * A patch is fully covered when every file it affects is present in the new export.
+ * @param patchFiles - Files affected by the existing patch
+ * @param targetFiles - Files affected by the new export
+ * @returns Coverage report with the triggering file list when `covered` is true
+ */
+export function isPatchFullyCovered(patchFiles, targetFiles) {
+    if (patchFiles.length === 0) {
+        return { covered: false, byFiles: [] };
+    }
+    const targetFileSet = new Set(targetFiles);
+    const covered = patchFiles.every((file) => targetFileSet.has(file));
+    return {
+        covered,
+        byFiles: covered ? [...patchFiles] : [],
+    };
+}
+/**
+ * Finds patches whose filesAffected entries are fully covered by the specified files.
+ * Used for complete supersession when exporting full-file patches.
+ * @param patchesDir - Path to the patches directory
+ * @param targetFiles - Files affected by the new export
+ * @param excludeFilename - Filename to exclude from results (the new patch itself)
+ * @returns Patches that are fully covered by the new export
+ */
+export async function findAllPatchesForFiles(patchesDir, targetFiles, excludeFilename) {
+    const manifest = await loadPatchesManifest(patchesDir);
+    if (!manifest)
+        return [];
+    const patches = await discoverPatches(patchesDir);
+    const superseded = [];
+    for (const metadata of manifest.patches) {
+        if (excludeFilename && metadata.filename === excludeFilename)
+            continue;
+        if (isPatchFullyCovered(metadata.filesAffected, targetFiles).covered) {
+            const patch = patches.find((p) => p.filename === metadata.filename);
+            if (patch) {
+                superseded.push(patch);
+            }
+        }
+    }
+    return superseded;
+}
+/**
+ * Resolves coverage details for every existing patch that the new export
+ * would fully cover.
+ */
+export async function findAllPatchesForFilesWithDetails(patchesDir, targetFiles, excludeFilename) {
+    const manifest = await loadPatchesManifest(patchesDir);
+    if (!manifest)
+        return [];
+    const patches = await discoverPatches(patchesDir);
+    const results = [];
+    for (const metadata of manifest.patches) {
+        if (excludeFilename && metadata.filename === excludeFilename)
+            continue;
+        const coverage = isPatchFullyCovered(metadata.filesAffected, targetFiles);
+        if (!coverage.covered)
+            continue;
+        const patch = patches.find((p) => p.filename === metadata.filename);
+        if (!patch)
+            continue;
+        results.push({ patch, coverage, metadata });
+    }
+    return results;
+}
+//# sourceMappingURL=patch-export-coverage.js.map

package/dist/src/core/patch-export-metadata.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Manifest metadata mutation helpers for patch export commands.
+ */
+import type { PatchMetadata } from '../types/commands/index.js';
+/**
+ * Optional `PatchMetadata` keys safe to clear via the helpers below.
+ */
+export type ClearablePatchMetadataField = 'tier' | 'lintIgnore';
+/**
+ * Updates metadata for a patch in the manifest.
+ *
+ * @param patchesDir - Path to the patches directory
+ * @param filename - Patch filename
+ * @param updates - Field values to set
+ * @param unsetFields - Optional fields to remove from the entry
+ */
+export declare function updatePatchMetadata(patchesDir: string, filename: string, updates: Partial<PatchMetadata>, unsetFields?: ReadonlyArray<ClearablePatchMetadataField>): Promise<void>;
+/** Return shape from a `mutatePatchMetadata` mutator. */
+export interface PatchMetadataMutation {
+    /** Field values to set on the entry. */
+    set?: Partial<PatchMetadata>;
+    /** Optional fields to remove from the entry entirely. */
+    unset?: ReadonlyArray<ClearablePatchMetadataField>;
+}
+/** Result of a successful `mutatePatchMetadata` call. */
+export interface PatchMetadataMutationResult {
+    /** Pre-mutation snapshot of the patch's metadata. */
+    before: PatchMetadata;
+    /** Post-mutation state of the patch's metadata. */
+    after: PatchMetadata;
+}
+/**
+ * Reads a patch's metadata under the directory lock, applies a mutator
+ * function to compute the update, and writes the result back.
+ */
+export declare function mutatePatchMetadata(patchesDir: string, filename: string, mutator: (existing: PatchMetadata) => PatchMetadataMutation): Promise<PatchMetadataMutationResult | null>;

package/dist/src/core/patch-export-metadata.js

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Manifest metadata mutation helpers for patch export commands.
+ */
+import { withPatchDirectoryLock } from './patch-apply.js';
+import { loadPatchesManifest, savePatchesManifest } from './patch-manifest.js';
+/**
+ * Merges `updates` onto `existing` and removes the listed optional fields.
+ */
+function applyMetadataUpdate(existing, updates, unset) {
+    const next = { ...existing, ...updates };
+    for (const field of unset) {
+        switch (field) {
+            case 'tier':
+                delete next.tier;
+                break;
+            case 'lintIgnore':
+                delete next.lintIgnore;
+                break;
+        }
+    }
+    return next;
+}
+/**
+ * Updates metadata for a patch in the manifest.
+ *
+ * @param patchesDir - Path to the patches directory
+ * @param filename - Patch filename
+ * @param updates - Field values to set
+ * @param unsetFields - Optional fields to remove from the entry
+ */
+export async function updatePatchMetadata(patchesDir, filename, updates, unsetFields = []) {
+    await withPatchDirectoryLock(patchesDir, async () => {
+        const manifest = await loadPatchesManifest(patchesDir);
+        if (!manifest)
+            return;
+        const patchIndex = manifest.patches.findIndex((p) => p.filename === filename);
+        if (patchIndex === -1)
+            return;
+        const existingPatch = manifest.patches[patchIndex];
+        if (existingPatch) {
+            manifest.patches[patchIndex] = applyMetadataUpdate(existingPatch, updates, unsetFields);
+            await savePatchesManifest(patchesDir, manifest);
+        }
+    });
+}
+/**
+ * Reads a patch's metadata under the directory lock, applies a mutator
+ * function to compute the update, and writes the result back.
+ */
+export async function mutatePatchMetadata(patchesDir, filename, mutator) {
+    return await withPatchDirectoryLock(patchesDir, async () => {
+        const manifest = await loadPatchesManifest(patchesDir);
+        if (!manifest)
+            return null;
+        const patchIndex = manifest.patches.findIndex((p) => p.filename === filename);
+        if (patchIndex === -1)
+            return null;
+        const existingPatch = manifest.patches[patchIndex];
+        if (!existingPatch)
+            return null;
+        const { set = {}, unset = [] } = mutator(existingPatch);
+        const updatedPatch = applyMetadataUpdate(existingPatch, set, unset);
+        manifest.patches[patchIndex] = updatedPatch;
+        await savePatchesManifest(patchesDir, manifest);
+        return { before: existingPatch, after: updatedPatch };
+    });
+}
+//# sourceMappingURL=patch-export-metadata.js.map

package/dist/src/core/patch-export-update.d.ts

@@ -0,0 +1,20 @@
+import type { PatchMetadata } from '../types/commands/index.js';
+import type { FireForgeConfig } from '../types/config.js';
+/**
+ * Optional post-commit hook for {@link updatePatchAndMetadata}. Runs inside
+ * the patch directory lock after the mutation has succeeded but before the
+ * lock is released.
+ */
+export type UpdatePatchCommittedHook = () => Promise<void>;
+/** Optional policy gate run against the under-lock projected manifest. */
+export interface UpdatePatchPolicyGate {
+    config: FireForgeConfig;
+    command: string;
+    forceUnsafe?: boolean;
+}
+/**
+ * Updates a patch file body and its manifest row under the same patch
+ * directory lock. Intended for commands like `re-export --files` where the
+ * file body and `filesAffected` metadata must move together.
+ */
+export declare function updatePatchAndMetadata(patchesDir: string, filename: string, newContent: string, updates: Partial<PatchMetadata>, onCommitted?: UpdatePatchCommittedHook, policyGate?: UpdatePatchPolicyGate): Promise<void>;

package/dist/src/core/patch-export-update.js

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { toError } from '../utils/errors.js';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+import { warn } from '../utils/logger.js';
+import { withPatchDirectoryLock } from './patch-apply.js';
+import { loadPatchesManifest, savePatchesManifest } from './patch-manifest.js';
+import { buildProjectedManifest, enforcePatchPolicy } from './patch-policy.js';
+/**
+ * Updates a patch file body and its manifest row under the same patch
+ * directory lock. Intended for commands like `re-export --files` where the
+ * file body and `filesAffected` metadata must move together.
+ */
+export async function updatePatchAndMetadata(patchesDir, filename, newContent, updates, onCommitted, policyGate) {
+    await withPatchDirectoryLock(patchesDir, async () => {
+        const manifest = await loadPatchesManifest(patchesDir);
+        if (!manifest) {
+            throw new Error('Cannot update patch metadata: patches.json is missing.');
+        }
+        const patchIndex = manifest.patches.findIndex((p) => p.filename === filename);
+        if (patchIndex === -1) {
+            throw new Error(`Cannot update patch metadata: ${filename} not found in patches.json.`);
+        }
+        const patchPath = join(patchesDir, filename);
+        if (!(await pathExists(patchPath))) {
+            throw new Error(`Cannot update patch: patch file is missing on disk: ${filename}`);
+        }
+        const originalContent = await readText(patchPath);
+        const existingPatch = manifest.patches[patchIndex];
+        manifest.patches[patchIndex] = { ...existingPatch, ...updates };
+        if (policyGate !== undefined) {
+            enforcePatchPolicy({
+                config: policyGate.config,
+                manifest: buildProjectedManifest(manifest, manifest.patches),
+                command: policyGate.command,
+                forceUnsafe: policyGate.forceUnsafe === true,
+            });
+        }
+        let patchWritten = false;
+        try {
+            await writeText(patchPath, newContent);
+            patchWritten = true;
+            await savePatchesManifest(patchesDir, manifest);
+        }
+        catch (error) {
+            if (patchWritten) {
+                try {
+                    await writeText(patchPath, originalContent);
+                }
+                catch (rollbackError) {
+                    warn(`Rollback warning: could not restore ${filename} after metadata write failed: ${toError(rollbackError).message}`);
+                }
+            }
+            throw error;
+        }
+        if (onCommitted) {
+            try {
+                await onCommitted();
+            }
+            catch (hookError) {
+                warn(`History log append failed after updatePatchAndMetadata committed (${filename}): ` +
+                    toError(hookError).message);
+            }
+        }
+    });
+}
+//# sourceMappingURL=patch-export-update.js.map

package/dist/src/core/patch-export.d.ts

@@ -1,4 +1,9 @@
 import type { PatchCategory, PatchesManifest, PatchInfo, PatchMetadata } from '../types/commands/index.js';
+import type { FireForgeConfig } from '../types/config.js';
+import { type SupersedeCoverageDetail } from './patch-export-coverage.js';
+export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, findSupersededPatches, isPatchFullyCovered, type PatchCoverage, type SupersedeCoverageDetail, } from './patch-export-coverage.js';
+export { type ClearablePatchMetadataField, mutatePatchMetadata, type PatchMetadataMutation, type PatchMetadataMutationResult, updatePatchMetadata, } from './patch-export-metadata.js';
+export { updatePatchAndMetadata } from './patch-export-update.js';
 /**
  * Gets the next patch number for a new patch.
  * @param patchesDir - Path to the patches directory
@@ -35,6 +40,12 @@ export interface CommitExportedPatchInput {
     tier?: 'branding';
     /** Optional `PatchMetadata.lintIgnore` (empty array treated as absent). */
     lintIgnore?: string[];
+    /** Project config, used only when opt-in patchPolicy is present. */
+    config?: FireForgeConfig;
+    /** Mutating command name for policy errors. */
+    policyCommand?: string;
+    /** Whether --force-unsafe was supplied by the mutating command. */
+    forceUnsafe?: boolean;
 }
 export interface CommitExportedPatchResult {
     patchFilename: string;
@@ -76,165 +87,12 @@ export declare function findExistingPatchForFile(patchesDir: string, filePath: s
  * @param newContent - New patch content
  */
 export declare function updatePatch(patchPath: string, newContent: string): Promise<void>;
-/**
- * Optional post-commit hook for {@link updatePatchAndMetadata}. Runs inside
- * the patch directory lock after the mutation has succeeded but before the
- * lock is released. Intended for history-log appends so the audit record
- * lands atomically with the mutation. Hook failures are warned but never
- * re-thrown: by the time the hook runs the mutation is already committed,
- * so there is nothing meaningful to roll back.
- */
-export type UpdatePatchCommittedHook = () => Promise<void>;
-/**
- * Updates a patch file body and its manifest row under the same patch
- * directory lock. Intended for commands like `re-export --files` where the
- * file body and `filesAffected` metadata must move together.
- *
- * If the manifest write fails after the patch body has been rewritten, the
- * original patch content is restored best-effort before the error is
- * re-thrown.
- *
- * @param patchesDir - Path to the patches directory
- * @param filename - Target patch filename
- * @param newContent - New patch body
- * @param updates - Metadata fields to merge into the existing row
- * @param onCommitted - Optional hook that runs inside the same lock after
- *   the mutation succeeds. See {@link UpdatePatchCommittedHook}.
- */
-export declare function updatePatchAndMetadata(patchesDir: string, filename: string, newContent: string, updates: Partial<PatchMetadata>, onCommitted?: UpdatePatchCommittedHook): Promise<void>;
-/**
- * Optional `PatchMetadata` keys safe to clear via the helpers below.
- * Required keys (filename, order, etc.) are excluded by construction so
- * an over-eager `unsetFields: ['filename']` cannot delete a field the
- * manifest validator requires. Add new keys here only when they become
- * optional on the type.
- */
-export type ClearablePatchMetadataField = 'tier' | 'lintIgnore';
-/**
- * Updates metadata for a patch in the manifest.
- *
- * Required-field updates go through the `updates` partial. Clearing an
- * optional field (e.g. removing the `tier` override) goes through
- * `unsetFields` because TypeScript's `exactOptionalPropertyTypes` does
- * not let `Partial<PatchMetadata>` carry an explicit `undefined` value
- * for fields whose declared type does not include `undefined`. The
- * implementation deletes the listed keys from the merged record before
- * writing, so the on-disk JSON omits them and the validator's
- * "preserve only when present" contract is preserved.
- *
- * @param patchesDir - Path to the patches directory
- * @param filename - Patch filename
- * @param updates - Field values to set. Pass an empty object when only
- *   clearing fields.
- * @param unsetFields - Optional fields to remove from the entry (so
- *   serialization drops them).
- */
-export declare function updatePatchMetadata(patchesDir: string, filename: string, updates: Partial<PatchMetadata>, unsetFields?: ReadonlyArray<ClearablePatchMetadataField>): Promise<void>;
-/**
- * Return shape from a {@link mutatePatchMetadata} mutator.
- */
-export interface PatchMetadataMutation {
-    /** Field values to set on the entry. */
-    set?: Partial<PatchMetadata>;
-    /** Optional fields to remove from the entry entirely. */
-    unset?: ReadonlyArray<ClearablePatchMetadataField>;
-}
-/**
- * Result of a successful {@link mutatePatchMetadata} call.
- */
-export interface PatchMetadataMutationResult {
-    /** Pre-mutation snapshot of the patch's metadata. */
-    before: PatchMetadata;
-    /** Post-mutation state of the patch's metadata. */
-    after: PatchMetadata;
-}
-/**
- * Reads a patch's metadata under the directory lock, applies a mutator
- * function to compute the update, and writes the result back — all
- * under a single lock so a concurrent writer cannot interleave a
- * read-modify-write cycle. Useful for operations that need to compute
- * the new value from the old (e.g. unioning a `lintIgnore` list,
- * removing a specific entry), which {@link updatePatchMetadata}'s flat
- * merge cannot express on its own.
- *
- * The mutator returns `{ set, unset }` so it can both write fields
- * and drop optional ones. `set` and `unset` are merged before write:
- * `set` runs first via spread, then `unset` deletes the listed keys.
- *
- * @returns The pre/post metadata pair when the patch is found and the
- *   write succeeds; `null` when the manifest is missing or the named
- *   patch is not in it. Callers should treat `null` as "no-op, nothing
- *   to log".
- */
-export declare function mutatePatchMetadata(patchesDir: string, filename: string, mutator: (existing: PatchMetadata) => PatchMetadataMutation): Promise<PatchMetadataMutationResult | null>;
-/**
- * Finds patches that are completely superseded by newer patches.
- * A patch is superseded if all its affected files are covered by newer patches.
- * @param patchesDir - Path to the patches directory
- * @param newPatchFiles - Files affected by the new patch
- * @param excludeFilename - Filename to exclude from results (the new patch itself)
- * @returns Superseded patches
- */
-export declare function findSupersededPatches(patchesDir: string, newPatchFiles: string[], excludeFilename?: string): Promise<PatchInfo[]>;
 /**
  * Deletes a patch file and removes it from the manifest.
  * @param patchesDir - Path to the patches directory
  * @param filename - Patch filename to delete
  */
 export declare function deletePatch(patchesDir: string, filename: string): Promise<void>;
-/**
- * Report whether a patch is fully covered by a new export, and which of its
- * files caused the coverage.
- *
- * Widened from a bare boolean to `{covered, byFiles}` so that `export
- * --supersede --dry-run` can tell the operator which files in each existing
- * patch triggered its supersession — the opaque "this export would
- * supersede N patches" message was the primary reason `--supersede` was
- * unsafe before this change.
- */
-export interface PatchCoverage {
-    covered: boolean;
-    byFiles: string[];
-}
-/**
- * Checks whether a patch is fully covered by a new export.
- * A patch is fully covered when every file it affects is present in the new export.
- * @param patchFiles - Files affected by the existing patch
- * @param targetFiles - Files affected by the new export
- * @returns Coverage report with the triggering file list when `covered` is true
- */
-export declare function isPatchFullyCovered(patchFiles: string[], targetFiles: string[]): PatchCoverage;
-/**
- * Finds patches whose filesAffected entries are fully covered by the specified files.
- * Used for complete supersession when exporting full-file patches.
- * @param patchesDir - Path to the patches directory
- * @param targetFiles - Files affected by the new export
- * @param excludeFilename - Filename to exclude from results (the new patch itself)
- * @returns Patches that are fully covered by the new export
- */
-export declare function findAllPatchesForFiles(patchesDir: string, targetFiles: string[], excludeFilename?: string): Promise<PatchInfo[]>;
-/**
- * Describes which files in a covered patch triggered its supersession.
- * Returned from {@link planExport} so dry-run previews can render a
- * complete "moved / removed" picture rather than a bare patch count.
- */
-export interface SupersedeCoverageDetail {
-    /** Existing patch filename. */
-    filename: string;
-    /** Files the existing patch claimed that the new export also claims. */
-    coveredByFiles: string[];
-}
-/**
- * Resolves coverage details for every existing patch that the new export
- * would fully cover. Mirrors {@link findAllPatchesForFiles} but returns the
- * widened {@link PatchCoverage.byFiles} list per match so callers can render
- * a per-patch breakdown.
- */
-export declare function findAllPatchesForFilesWithDetails(patchesDir: string, targetFiles: string[], excludeFilename?: string): Promise<{
-    patch: PatchInfo;
-    coverage: PatchCoverage;
-    metadata: PatchMetadata;
-}[]>;
 /**
  * Fully computed plan for a pending export. Returned from
  * {@link planExport} so that `--dry-run` previews can render the full
@@ -281,6 +139,8 @@ export interface PlanExportInput {
      * preserves the field when it has at least one entry.
      */
     lintIgnore?: string[];
+    /** Project config, used only when opt-in patchPolicy is present. */
+    config?: FireForgeConfig;
 }
 /**
  * Read-only planning function — computes everything a real export would