@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/export-flow.js

@@ -1,423 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Planning + dry-run + placement helpers extracted from `export.ts`.
- *
- * These functions are pure or narrowly-scoped async helpers that compose
- * into `exportCommand`. Splitting them out keeps `export.ts` under the
- * per-file / per-function line budgets and makes each step individually
- * testable without dragging the whole command harness along for the ride.
- */
-import { dirname, join } from 'node:path';
-import {} from '../core/destructive.js';
-import { buildPlanExportInput, findAllPatchesForFilesWithDetails, patchNameSlug, planExport, } from '../core/patch-export.js';
-import { buildPatchQueueContext, lintPatchQueue } from '../core/patch-lint.js';
-import { formatLintIgnoreList } from '../core/patch-lint-ignore.js';
-import { withPatchDirectoryLock } from '../core/patch-lock.js';
-import { addPatchToManifest, loadPatchesManifest, loadPatchesManifestForWrite, renumberPatchesInManifest, resolvePatchIdentifier, savePatchesManifest, } from '../core/patch-manifest.js';
-import { formatPatchOrder, requirePatchOrder } from '../core/patch-parse.js';
-import { applyRenameMapToManifest, buildProjectedManifest, enforcePatchPolicy, } from '../core/patch-policy.js';
-import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
-import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
-import { info, warn } from '../utils/logger.js';
-import { describePlacementAdvice } from './export-adopt-check.js';
-import { groupProjectedPlacementErrors } from './export-placement-conflicts.js';
-import { assertPlacementAvoidsReservedRanges } from './export-placement-policy.js';
-import { findPartialOwnershipOverlap } from './export-shared.js';
-import { acceptTreeRegisteredModules } from './export-staged-registration.js';
-import { projectEntryBody } from './patch/entry-projection.js';
-import { getSortedRenameEntries, renameMapsEqual } from './patch-rename-map.js';
-function buildFilenameForPlacement(category, name, order, width) {
-    const padded = String(order).padStart(Math.max(3, width), '0');
-    return `${padded}-${category}-${patchNameSlug(name, category)}.patch`;
-}
-function prefixWidthForPatches(manifestPatches, requestedOrder) {
-    return manifestPatches.reduce((width, patch) => {
-        const match = /^(\d+)-/.exec(patch.filename);
-        return Math.max(width, match?.[1]?.length ?? 3, String(requestedOrder).length);
-    }, 3);
-}
-/**
- * Structural equality for placement plans. Used by placement-mode export
- * and `patch split` to verify the queue did not change between the
- * confirmed preview and the under-lock commit.
- */
-export function placementPlansEqual(left, right) {
-    if (left.insertionOrder !== right.insertionOrder || left.newFilename !== right.newFilename) {
-        return false;
-    }
-    return renameMapsEqual(left.renameMap, right.renameMap);
-}
-/**
- * Computes the shift map that moves existing patches out of the requested
- * slot to make room for a new patch at `requestedOrder`.
- */
-export function computePlacementPlan(manifestPatches, newPatchCategory, newPatchName, requestedOrder) {
-    // Defense-in-depth: the --order argParser already validates, but this
-    // function is exported and reachable from tests / future callers.
-    // Failing fast here prevents a NaN requestedOrder from producing a
-    // filename like "NaN-ui-foo.patch".
-    if (!Number.isInteger(requestedOrder) || requestedOrder <= 0) {
-        throw new InvalidArgumentError(`computePlacementPlan requires a positive integer order, got ${requestedOrder}.`, 'requestedOrder');
-    }
-    const sorted = [...manifestPatches].sort((a, b) => a.order - b.order);
-    const renameMap = new Map();
-    const prefixWidth = prefixWidthForPatches(sorted, requestedOrder);
-    // Patches at requestedOrder or later shift up by one, but only until the
-    // cascade reaches a free ordinal. A gap absorbs the insert, so the tail
-    // beyond it (including any reserved block) keeps its numbering.
-    let cursor = requestedOrder;
-    for (const patch of sorted) {
-        if (patch.order < requestedOrder) {
-            continue;
-        }
-        if (patch.order > cursor) {
-            break;
-        }
-        const newOrder = cursor + 1;
-        const currentRest = patch.filename.replace(/^\d+-/, '');
-        const newFilename = `${formatPatchOrder(newOrder, prefixWidth)}-${currentRest}`;
-        renameMap.set(patch.filename, { newOrder, newFilename });
-        cursor = newOrder;
-    }
-    const newFilename = buildFilenameForPlacement(newPatchCategory, newPatchName, requestedOrder, prefixWidth);
-    return {
-        insertionOrder: requestedOrder,
-        newFilename,
-        renameMap,
-    };
-}
-/**
- * Computes an exact sparse placement plan for `--order <N>`. Unlike
- * positional insertion, this never renumbers existing patches: the order
- * must be unused, and policy validation decides whether the requested
- * category/order is allowed.
- */
-export function computeExactPlacementPlan(manifestPatches, newPatchCategory, newPatchName, requestedOrder) {
-    if (!Number.isInteger(requestedOrder) || requestedOrder <= 0) {
-        throw new InvalidArgumentError(`--order must be a positive integer, got ${requestedOrder}.`, '--order');
-    }
-    const occupied = manifestPatches.find((patch) => patch.order === requestedOrder);
-    if (occupied) {
-        throw new InvalidArgumentError(`--order ${requestedOrder} is already occupied by ${occupied.filename}. ` +
-            'Choose an unused order or use --before/--after for positional insertion.', '--order');
-    }
-    return {
-        insertionOrder: requestedOrder,
-        newFilename: buildFilenameForPlacement(newPatchCategory, newPatchName, requestedOrder, prefixWidthForPatches(manifestPatches, requestedOrder)),
-        renameMap: new Map(),
-    };
-}
-/**
- * Resolves a placement plan from CLI flags against the current manifest.
- * When `config` is provided, positional plans (`--before`/`--after`) are
- * refused up front if their renumber would touch a reserved range, giving
- * one error for the whole shift instead of per-patch policy findings. The
- * exact `--order` branch never renames, so it bypasses that gate.
- */
-export async function resolvePlacementPlan(patchesDir, options, category, name, config) {
-    // ForWrite: placement planning feeds a manifest rewrite. A corrupt
-    // manifest read as empty would allocate colliding orders.
-    const manifest = await loadPatchesManifestForWrite(patchesDir);
-    const existingPatches = manifest?.patches ?? [];
-    let targetOrder;
-    if (options.order !== undefined) {
-        // Defense-in-depth: argParser covers the CLI path, but this
-        // function is called directly from the command body which could
-        // reach here with a NaN/0/negative value passed in via test harness.
-        if (!Number.isInteger(options.order) || options.order <= 0) {
-            throw new InvalidArgumentError(`--order must be a positive integer, got ${options.order}.`, '--order');
-        }
-        return computeExactPlacementPlan(existingPatches, category, name, options.order);
-    }
-    else if (options.before !== undefined) {
-        const anchor = resolvePatchIdentifier(options.before, existingPatches);
-        if (!anchor) {
-            throw new InvalidArgumentError(`--before anchor "${options.before}" not found.`, '--before');
-        }
-        targetOrder = anchor.order;
-    }
-    else {
-        const afterAnchorId = options.after;
-        if (afterAnchorId === undefined) {
-            throw new InvalidArgumentError('Placement flag resolver reached --after branch with no value set.', '--after');
-        }
-        const anchor = resolvePatchIdentifier(afterAnchorId, existingPatches);
-        if (!anchor) {
-            throw new InvalidArgumentError(`--after anchor "${afterAnchorId}" not found.`, '--after');
-        }
-        targetOrder = anchor.order + 1;
-    }
-    const plan = computePlacementPlan(existingPatches, category, name, targetOrder);
-    assertPlacementAvoidsReservedRanges(plan, existingPatches, config);
-    return plan;
-}
-/**
- * Projects the placement through cross-patch lint to detect forward-imports
- * the renumber would introduce, or that the new patch itself would
- * introduce by landing earlier than one of its dependencies. Returns null
- * when the projection is clean.
- */
-export async function projectPlacementForLint(patchesDir, plan, diff, config) {
-    const baseCtx = await buildPatchQueueContext(patchesDir, config);
-    const projectedEntries = baseCtx.entries.map((entry) => {
-        const rename = plan.renameMap.get(entry.filename);
-        if (!rename)
-            return entry;
-        return { ...entry, filename: rename.newFilename, order: rename.newOrder };
-    });
-    // Synthetic entry for the pending patch, populated with both its new-file
-    // content and its added-line content for files it modifies, so the
-    // forward-import rule can inspect imports the patch itself authors,
-    // whether they live in a brand-new file or are added to an existing one.
-    // Leaving either map empty lets a patch land before one of its own
-    // dependencies and still pass the gate.
-    const pendingBody = projectEntryBody(diff);
-    projectedEntries.push({
-        filename: plan.newFilename,
-        order: plan.insertionOrder,
-        metadata: null,
-        ...pendingBody,
-    });
-    projectedEntries.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
-    // The projection keeps every queue-wide lint setting of the baseline
-    // (patch policy, forward-registration scope, token scales), so a
-    // test-manifest suite entry is checked exactly as the committed gate
-    // checks it.
-    // A new module whose moz.build line is declared (staged registration)
-    // and present in the working tree, but not yet exported by its owner, is
-    // accepted with a "re-export the owner next" note instead of refused.
-    const registration = await acceptTreeRegisteredModules({
-        engineDir: join(dirname(patchesDir), 'engine'),
-        baseCtx,
-        newFilename: plan.newFilename,
-        pendingNewFiles: new Set(pendingBody.newFiles.keys()),
-        projectedIssues: lintPatchQueue({ ...baseCtx, entries: projectedEntries }).filter((i) => i.severity === 'error'),
-    });
-    for (const note of registration.accepted)
-        warn(note);
-    const projectedIssues = registration.remaining;
-    if (projectedIssues.length === 0)
-        return null;
-    // Baseline lint over the un-renumbered queue: an error present here is
-    // pre-existing breakage rather than a consequence of this placement, and
-    // calling it one would misattribute. Entries are already in memory,
-    // so this second pass costs no additional IO.
-    const baselineIssues = lintPatchQueue(baseCtx).filter((i) => i.severity === 'error');
-    // Register-first and new-file + moved-code advice: name the working
-    // sequence instead of leaving the operator to derive it from two
-    // individually-correct guards that together dead-end, but only offer
-    // adopt-then-split for a real moved block whose adopt would itself pass.
-    return {
-        reason: `placement would introduce ${projectedIssues.length} cross-patch lint error(s)`,
-        details: [
-            ...groupProjectedPlacementErrors(projectedIssues, baselineIssues, plan),
-            ...registration.advice,
-            ...describePlacementAdvice(baseCtx, diff, projectedIssues, plan),
-        ],
-    };
-}
-/**
- * Builds the change-summary lines printed by the placement confirmation.
- */
-export function placementSummary(plan) {
-    const summary = [
-        `place new patch as ${plan.newFilename} (order ${plan.insertionOrder})`,
-    ];
-    const sortedRenames = getSortedRenameEntries(plan.renameMap);
-    if (sortedRenames.length > 0) {
-        summary.push(`${sortedRenames.length} existing patch(es) would be renumbered:`);
-        for (const [oldName, rename] of sortedRenames) {
-            summary.push(`  ${oldName}  →  ${rename.newFilename}`);
-        }
-    }
-    return summary;
-}
-/**
- * Commits a previously-confirmed placement export under the patch
- * directory lock. Re-resolves the placement plan against the current
- * queue and aborts if anything changed since the preview so the command
- * never applies a silently different rename set than the user saw.
- */
-export async function commitPlacementExport(input) {
-    return withPatchDirectoryLock(input.patchesDir, async () => {
-        const currentPlan = await resolvePlacementPlan(input.patchesDir, input.options, input.category, input.name, input.config);
-        if (!placementPlansEqual(currentPlan, input.expectedPlan)) {
-            throw new InvalidArgumentError('Patch queue changed while waiting for export confirmation. Re-run the command to recompute placement.', 'export placement');
-        }
-        const conflicts = await projectPlacementForLint(input.patchesDir, currentPlan, input.diff, input.config);
-        if (conflicts && input.unsafeOverride !== true) {
-            throw new InvalidArgumentError(`Refusing to run export: ${conflicts.reason}:\n  ${conflicts.details.join('\n  ')}\n` +
-                'If the conflict names files owned by another patch (e.g. duplicate-new-file-creation), ' +
-                're-run the export with an explicit file list that leaves those files with their owner — ' +
-                'do NOT bypass with --force-unsafe. Pass --force-unsafe only for a reviewed placement conflict.', '--force-unsafe');
-        }
-        const originalManifest = await loadPatchesManifestForWrite(input.patchesDir);
-        if (input.config !== undefined) {
-            const renamed = originalManifest !== null
-                ? applyRenameMapToManifest(originalManifest, currentPlan.renameMap)
-                : buildProjectedManifest(null, []);
-            enforcePatchPolicy({
-                config: input.config,
-                manifest: buildProjectedManifest(renamed, [
-                    ...renamed.patches,
-                    {
-                        ...input.metadata,
-                        filename: currentPlan.newFilename,
-                        order: currentPlan.insertionOrder,
-                    },
-                ]),
-                command: 'export',
-                forceUnsafe: input.forceUnsafe === true,
-            });
-        }
-        // Snapshot pre-mutation state so we can best-effort restore the queue
-        // if any of the three steps below fail mid-flight. Mirrors the
-        // rollback shape in commitExportedPatch (src/core/patch-export.ts), but
-        // inlined because the two rollbacks operate on different state shapes
-        // (rename map vs. supersede set) and sharing a helper would be forced.
-        const patchPath = join(input.patchesDir, currentPlan.newFilename);
-        const originalNewPatchContent = (await pathExists(patchPath))
-            ? await readText(patchPath)
-            : null;
-        let renumberApplied = false;
-        try {
-            if (currentPlan.renameMap.size > 0) {
-                await renumberPatchesInManifest(input.patchesDir, currentPlan.renameMap);
-                renumberApplied = true;
-            }
-            // Normalize identically to commitExportedPatch: the two export
-            // paths must produce one artifact contract for the same diff.
-            await writeText(patchPath, input.diff);
-            await addPatchToManifest(input.patchesDir, {
-                ...input.metadata,
-                filename: currentPlan.newFilename,
-                order: currentPlan.insertionOrder,
-            });
-            if (input.onCommitted) {
-                try {
-                    await input.onCommitted(currentPlan);
-                }
-                catch (hookError) {
-                    // Mutation has already committed and is not reversible. Warn
-                    // so operators know the audit trail has a gap, but do not
-                    // re-throw, which would look like the export itself failed.
-                    warn(`History log append failed after export committed (export-order, ${currentPlan.newFilename}): ` +
-                        toError(hookError).message);
-                }
-            }
-            return currentPlan;
-        }
-        catch (error) {
-            // Best-effort rollback. Each restoration step gets its own nested
-            // try/catch so a secondary failure warns without masking the
-            // original error we are about to rethrow.
-            try {
-                if (originalNewPatchContent === null) {
-                    if (await pathExists(patchPath)) {
-                        await removeFile(patchPath);
-                    }
-                }
-                else {
-                    await writeText(patchPath, originalNewPatchContent);
-                }
-            }
-            catch (rollbackError) {
-                warn(`Rollback warning: could not restore new patch file: ${toError(rollbackError).message}`);
-            }
-            if (renumberApplied) {
-                // Invert the forward rename map and re-apply through the same
-                // two-phase staging renumber. The oldFilename encodes its
-                // original order in the leading digits, so parsing them back
-                // avoids tracking a second map during the forward pass.
-                const inverseMap = new Map();
-                for (const [oldFilename, entry] of currentPlan.renameMap) {
-                    const oldOrder = requirePatchOrder(oldFilename);
-                    inverseMap.set(entry.newFilename, {
-                        newOrder: oldOrder,
-                        newFilename: oldFilename,
-                    });
-                }
-                try {
-                    await renumberPatchesInManifest(input.patchesDir, inverseMap);
-                }
-                catch (rollbackError) {
-                    warn(`Rollback warning: could not invert placement renumber: ${toError(rollbackError).message}`);
-                }
-            }
-            // Belt-and-braces: overwrite the manifest with the original
-            // snapshot so a partial addPatchToManifest write (new entry
-            // appended but inverse renumber skipped or incomplete) is erased.
-            // Safe because by this point the disk filenames should match the
-            // original manifest's filenames.
-            if (originalManifest) {
-                try {
-                    await savePatchesManifest(input.patchesDir, originalManifest);
-                }
-                catch (rollbackError) {
-                    warn(`Rollback warning: could not restore manifest: ${toError(rollbackError).message}`);
-                }
-            }
-            throw error;
-        }
-    });
-}
-/**
- * Renders the plain (non-placement) dry-run preview: calls planExport,
- * prints the allocated filename + metadata, and with supersede enumerates
- * the per-patch coverage detail that was opaque before this refactor.
- */
-export async function renderDryRunPreview(input) {
-    const supersedeDetails = await findAllPatchesForFilesWithDetails(input.patchesDir, input.filesAffected);
-    const supersedingFilenames = new Set(supersedeDetails.map((detail) => detail.patch.filename));
-    const manifest = await loadPatchesManifest(input.patchesDir);
-    const overlap = manifest !== null
-        ? findPartialOwnershipOverlap(manifest, input.filesAffected, supersedingFilenames)
-        : new Map();
-    const plan = await planExport(buildPlanExportInput(input));
-    if (input.config !== undefined) {
-        enforcePatchPolicy({
-            config: input.config,
-            manifest: plan.manifestAfter,
-            command: 'export',
-            forceUnsafe: input.forceUnsafe === true,
-        });
-    }
-    info(`\n[dry-run] Would write: patches/${plan.patchFilename}`);
-    info(`  category: ${plan.metadata.category}`);
-    info(`  order: ${plan.metadata.order}`);
-    info(`  description: ${plan.metadata.description || '(none)'}`);
-    info(`  filesAffected (${plan.metadata.filesAffected.length}): ${plan.metadata.filesAffected.join(', ')}`);
-    if (plan.metadata.tier !== undefined) {
-        info(`  tier: ${plan.metadata.tier}`);
-    }
-    if (plan.metadata.lintIgnore !== undefined && plan.metadata.lintIgnore.length > 0) {
-        info(`  lintIgnore: ${formatLintIgnoreList(plan.metadata.lintIgnore)}`);
-    }
-    if (supersedeDetails.length > 0) {
-        info(`\n[dry-run] Would supersede ${supersedeDetails.length} existing patch(es):`);
-        for (const detail of supersedeDetails) {
-            info(`  - ${detail.patch.filename}  (covered by: ${detail.coverage.byFiles.join(', ')})`);
-        }
-        if (!input.explicitSupersede) {
-            warn('Real run would prompt for confirmation or require --supersede in non-interactive mode.');
-        }
-    }
-    else {
-        info('\n[dry-run] No patches would be superseded.');
-    }
-    if (overlap.size > 0) {
-        const entries = [...overlap.entries()].sort(([a], [b]) => a.localeCompare(b));
-        warn(`\n[dry-run] Would create cross-patch ownership overlap on ${entries.length} file${entries.length === 1 ? '' : 's'}:`);
-        for (const [file, owners] of entries) {
-            warn(`  - ${file} already claimed by: ${owners.join(', ')}`);
-        }
-        warn('The real export would leave the queue verify-failing. Repartition ownership with `fireforge re-export --files <paths> <existing-patch>` before exporting, or pass --allow-overlap to acknowledge the conflict.');
-        if (!input.allowOverlap) {
-            throw new GeneralError('Dry-run detected cross-patch ownership overlap. Pass --allow-overlap to preview the acknowledged conflict, or repartition ownership via `fireforge re-export --files`.');
-        }
-    }
-    else {
-        info('[dry-run] No cross-patch ownership overlap detected.');
-    }
-}

package/dist/src/commands/export-placement-conflicts.d.ts

@@ -1,17 +0,0 @@
-import type { PatchRenameEntry } from '../core/patch-manifest.js';
-import type { PatchLintIssue } from '../types/commands/index.js';
-/** Inputs {@link groupProjectedPlacementErrors} needs from the plan. */
-export interface PlacementAttributionPlan {
-    insertionOrder: number;
-    newFilename: string;
-    renameMap: Map<string, PatchRenameEntry>;
-}
-/**
- * Partitions the projected placement errors into three labeled groups
- * (defects in the exported content, consequences of the renumbering, and
- * errors the queue already had), rendered as indented detail lines for
- * {@link ConflictReport.details}. Grouping travels through the plain
- * `details: string[]`, so both refusal sites and confirmDestructive's
- * conflict printer show it without changes.
- */
-export declare function groupProjectedPlacementErrors(projectedErrors: readonly PatchLintIssue[], baselineErrors: readonly PatchLintIssue[], plan: PlacementAttributionPlan): string[];

package/dist/src/commands/export-placement-conflicts.js

@@ -1,75 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Attribution of projected placement lint errors, split out of
- * export-flow.ts for the line budget.
- *
- * A placement projection lints one merged queue (the renumbered existing
- * patches plus a synthetic entry for the pending patch), so a flat error
- * list reads as though the new patch caused every one of them. A renumbering
- * that re-evaluates pre-existing staged relationships (patch 455 importing a
- * module created by 456, legal only at their current ordinals) then sends
- * the operator auditing a perfectly fine export.
- *
- * Consumed by export-flow.ts. No top-level registrar is exported and none is
- * wanted.
- */
-import { formatPatchLintIssue } from '../core/patch-lint.js';
-/**
- * Identity for baseline comparison: check + site file + implicated
- * patches, with projected filenames mapped back through the rename map so
- * a pre-existing error keeps its identity across the renumber. Never
- * parses the fingerprint. It is documented rename-sensitive.
- */
-function issueKey(issue, mapBackToOldName) {
-    const patches = (issue.patches ?? []).map(mapBackToOldName).sort((a, b) => a.localeCompare(b));
-    return `${issue.check}|${issue.file}|${patches.join(',')}`;
-}
-/**
- * Partitions the projected placement errors into three labeled groups
- * (defects in the exported content, consequences of the renumbering, and
- * errors the queue already had), rendered as indented detail lines for
- * {@link ConflictReport.details}. Grouping travels through the plain
- * `details: string[]`, so both refusal sites and confirmDestructive's
- * conflict printer show it without changes.
- */
-export function groupProjectedPlacementErrors(projectedErrors, baselineErrors, plan) {
-    const oldNameByNew = new Map();
-    for (const [oldFilename, rename] of plan.renameMap) {
-        oldNameByNew.set(rename.newFilename, oldFilename);
-    }
-    const mapBack = (name) => oldNameByNew.get(name) ?? name;
-    const baselineKeys = new Set(baselineErrors.map((issue) => issueKey(issue, (name) => name)));
-    const exported = [];
-    const renumbering = [];
-    const preExisting = [];
-    for (const issue of projectedErrors) {
-        // The synthetic entry's filename is unique in the projection, so
-        // membership in `patches` attributes exactly. Issues from older rules
-        // without the field fall back to a message scan, then to "the queue".
-        const implicatesNewPatch = issue.patches?.includes(plan.newFilename) ?? issue.message.includes(plan.newFilename);
-        if (implicatesNewPatch) {
-            exported.push(issue);
-        }
-        else if (baselineKeys.has(issueKey(issue, mapBack))) {
-            preExisting.push(issue);
-        }
-        else {
-            renumbering.push(issue);
-        }
-    }
-    const details = [];
-    const pushGroup = (header, issues) => {
-        if (issues.length === 0)
-            return;
-        details.push(header);
-        for (const issue of issues) {
-            details.push(`  ${formatPatchLintIssue(issue)}`);
-        }
-    };
-    pushGroup(`errors in the exported patch content (${exported.length}):`, exported);
-    pushGroup(`consequences of renumbering existing patches to make room at ordinal ` +
-        `${plan.insertionOrder} (${renumbering.length}) — these come from ` +
-        'renumbering, NOT from the exported content:', renumbering);
-    pushGroup(`errors already present in the queue before this export (${preExisting.length}):`, preExisting);
-    return details;
-}

package/dist/src/commands/export-placement-gate.d.ts

@@ -1,42 +0,0 @@
-/**
- * Placement-flag gating for `fireforge export`, split out of `export.ts`
- * to keep the command body inside the per-function and per-file line
- * budgets. `gatePlacementPlan` owns every policy/confirmation decision a
- * placement export makes before the locked commit in `export.ts` runs.
- */
-import type { ExportOptions } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
-import type { SpinnerHandle } from '../utils/logger.js';
-import { type PlacementPlan } from './export-flow.js';
-/**
- * Spreadable optional metadata (`tier`, `lintIgnore`) derived from the
- * export flags. Every manifest-row construction site in this command
- * shares this shape. With exactOptionalPropertyTypes the keys must be
- * omitted entirely (not set to undefined) when the flags are absent.
- */
-export declare function patchMetadataExtras(options: ExportOptions): {
-    tier?: 'branding';
-    /** CLI flags only ever carry bare check IDs. */
-    lintIgnore?: string[];
-};
-/**
- * Resolves and gates the placement plan when any placement flag
- * (`--order`/`--before`/`--after`) was given: rejects the `--supersede`
- * combination, enforces reserved ranges and patch policy against the
- * projected manifest, and routes destructive renumbers (or dry-runs)
- * through `confirmDestructive`. Returns the plan to commit, or `'stop'`
- * when the command should end here (dry-run rendered or operator
- * cancelled, and the corresponding outro has already been printed).
- */
-export declare function gatePlacementPlan(args: {
-    patchesDir: string;
-    options: ExportOptions;
-    selectedCategory: string;
-    patchName: string;
-    description: string;
-    filesAffected: string[];
-    diff: string;
-    config: FireForgeConfig;
-    isDryRun: boolean;
-    s: SpinnerHandle;
-}): Promise<PlacementPlan | 'stop'>;

package/dist/src/commands/export-placement-gate.js

@@ -1,107 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Placement-flag gating for `fireforge export`, split out of `export.ts`
- * to keep the command body inside the per-function and per-file line
- * budgets. `gatePlacementPlan` owns every policy/confirmation decision a
- * placement export makes before the locked commit in `export.ts` runs.
- */
-import { confirmDestructive } from '../core/destructive.js';
-import { loadPatchesManifest } from '../core/patch-manifest.js';
-import { applyRenameMapToManifest, buildProjectedManifest, enforcePatchPolicy, } from '../core/patch-policy.js';
-import { reservationAt } from '../core/patch-retired.js';
-import { buildPatchSourceMetadata } from '../core/patch-source-metadata.js';
-import { InvalidArgumentError } from '../errors/base.js';
-import { proceedAfterDecision } from './destructive-decision.js';
-import { placementSummary, projectPlacementForLint, resolvePlacementPlan, } from './export-flow.js';
-/**
- * Spreadable optional metadata (`tier`, `lintIgnore`) derived from the
- * export flags. Every manifest-row construction site in this command
- * shares this shape. With exactOptionalPropertyTypes the keys must be
- * omitted entirely (not set to undefined) when the flags are absent.
- */
-export function patchMetadataExtras(options) {
-    return {
-        ...(options.tier !== undefined ? { tier: options.tier } : {}),
-        ...(options.lintIgnore !== undefined && options.lintIgnore.length > 0
-            ? { lintIgnore: options.lintIgnore }
-            : {}),
-    };
-}
-/**
- * Resolves and gates the placement plan when any placement flag
- * (`--order`/`--before`/`--after`) was given: rejects the `--supersede`
- * combination, enforces reserved ranges and patch policy against the
- * projected manifest, and routes destructive renumbers (or dry-runs)
- * through `confirmDestructive`. Returns the plan to commit, or `'stop'`
- * when the command should end here (dry-run rendered or operator
- * cancelled, and the corresponding outro has already been printed).
- */
-export async function gatePlacementPlan(args) {
-    const { patchesDir, options, selectedCategory, patchName, description, filesAffected, diff, config, isDryRun, s, } = args;
-    if (options.supersede) {
-        throw new InvalidArgumentError('Placement flags (--order/--before/--after) cannot be combined with --supersede.', 'export placement');
-    }
-    // resolvePlacementPlan runs the reserved-range gate itself when config
-    // is passed: one up-front error per run instead of per-patch findings.
-    const placementPlan = await resolvePlacementPlan(patchesDir, options, selectedCategory, patchName, config);
-    const currentManifest = await loadPatchesManifest(patchesDir);
-    const conflicts = await projectPlacementForLint(patchesDir, placementPlan, diff, config);
-    const renamed = currentManifest !== null
-        ? applyRenameMapToManifest(currentManifest, placementPlan.renameMap)
-        : buildProjectedManifest(null, []);
-    enforcePatchPolicy({
-        config,
-        manifest: buildProjectedManifest(renamed, [
-            ...renamed.patches,
-            {
-                filename: placementPlan.newFilename,
-                order: placementPlan.insertionOrder,
-                category: selectedCategory,
-                name: patchName,
-                description,
-                createdAt: new Date().toISOString(),
-                ...buildPatchSourceMetadata(config.firefox),
-                filesAffected,
-                ...patchMetadataExtras(options),
-            },
-        ]),
-        command: 'export',
-        forceUnsafe: options.forceUnsafe === true,
-    });
-    const summary = placementSummary(placementPlan);
-    const reservation = reservationAt(currentManifest, placementPlan.insertionOrder);
-    if (reservation !== undefined) {
-        const notice = `order ${placementPlan.insertionOrder} is reserved by ${reservation.owner}; ` +
-            'this export fills the reservation';
-        summary.push(notice);
-        s.message(notice);
-    }
-    const renameCount = placementPlan.renameMap.size;
-    // Route through confirmDestructive when the operation is destructive
-    // enough to warrant a prompt (more than one rename) or when the user asked
-    // for a dry-run. The dry-run branch must always print the placement
-    // summary. Otherwise single-rename and no-rename dry-runs exit silently
-    // with no filename or projected layout.
-    if (renameCount > 1 || isDryRun) {
-        s.stop();
-        const decision = await confirmDestructive({
-            operation: 'export-order',
-            title: `Export with placement at order ${placementPlan.insertionOrder}`,
-            summary,
-            yes: options.yes === true,
-            dryRun: isDryRun,
-            unsafeOverride: options.forceUnsafe === true,
-            conflicts,
-        });
-        if (!proceedAfterDecision(decision, 'Export cancelled'))
-            return 'stop';
-    }
-    else if (conflicts && options.forceUnsafe !== true) {
-        s.stop();
-        throw new InvalidArgumentError(`Refusing to run export: ${conflicts.reason}:\n  ${conflicts.details.join('\n  ')}\n` +
-            'If the conflict names files owned by another patch (e.g. duplicate-new-file-creation), ' +
-            're-run the export with an explicit file list that leaves those files with their owner — ' +
-            'do NOT bypass with --force-unsafe. Pass --force-unsafe only for a reviewed placement conflict.', '--force-unsafe');
-    }
-    return placementPlan;
-}