@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/patch-policy-content.js

@@ -1,216 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Registration-only patch policy: the `patchPolicy` rules that need the
- * patch bodies, not just the manifest.
- *
- * - `upstreamAllowlist`: which upstream files (files no patch in the queue
- *   creates) a non-reserved patch may modify.
- * - `addOnly` allowlist entries: for shared registration files, a patch may
- *   only add lines, and each non-blank added line must carry the marker.
- * - `scopeRules`: limit a class of patch (a category, or a filename pattern
- *   such as `-tests\.patch$`) to the files its globs name.
- * - `verifyDocumentPaths`: every reserved allowlist entry's `adr` /
- *   `documentation` path must exist.
- *
- * Every rule is opt-in, and none can be evaluated from `patches.json`
- * alone, which is why they live apart from `patch-policy.ts`: that module
- * answers synchronously over a (possibly projected) manifest, this one reads
- * patch bodies and the filesystem. `verify` and `lint --per-patch` run both.
- */
-import { join } from 'node:path';
-import { pathExists } from '../utils/fs.js';
-import { matchesAnyGlob } from '../utils/path-glob.js';
-import { buildPatchQueueContext } from './patch-lint-cross.js';
-import { parseDiffSections } from './patch-parse.js';
-/** True when the policy sets any rule this module evaluates. */
-export function hasPatchPolicyContentRules(config) {
-    const cfg = config.patchPolicy;
-    return (cfg !== undefined &&
-        (cfg.upstreamAllowlist !== undefined ||
-            cfg.scopeRules !== undefined ||
-            cfg.verifyDocumentPaths === true));
-}
-function normalizeAllowEntry(entry) {
-    return typeof entry === 'string' ? { path: entry } : entry;
-}
-function isReservedOrder(cfg, order) {
-    return (cfg.reservedRanges ?? []).some((range) => order >= range.from && order <= range.to);
-}
-/**
- * The upstream files a patch body edits, keyed by path: every section that
- * does not create its file, minus paths some patch in the queue creates. A
- * rename counts against both of its paths.
- */
-function collectUpstreamEdits(diff, queueCreated) {
-    const edits = new Map();
-    for (const section of parseDiffSections(diff)) {
-        if (section.isNewFile)
-            continue;
-        const paths = new Set([section.sourcePath, section.targetPath]);
-        for (const path of paths) {
-            if (queueCreated.has(path))
-                continue;
-            const edit = edits.get(path) ?? { added: [], removed: [], deleted: false, binary: false };
-            edit.deleted ||= section.isDeletedFile;
-            edit.binary ||= section.isBinary;
-            for (const hunk of section.hunks) {
-                for (const line of hunk.lines) {
-                    if (line.startsWith('+'))
-                        edit.added.push(line.slice(1));
-                    else if (line.startsWith('-'))
-                        edit.removed.push(line.slice(1));
-                }
-            }
-            edits.set(path, edit);
-        }
-    }
-    return edits;
-}
-/**
- * Why an add-only file's edit breaks the mode, or undefined when it holds.
- * Blank lines are free in both directions: they carry no registration.
- */
-function addOnlyViolation(edit, marker) {
-    if (edit.deleted)
-        return 'deletes the file';
-    if (edit.binary)
-        return 'carries a binary change';
-    const removed = edit.removed.filter((line) => line.trim() !== '');
-    if (removed.length > 0) {
-        return `removes ${String(removed.length)} line(s), first: ${JSON.stringify(removed[0])}`;
-    }
-    const needle = marker.toLowerCase();
-    const unmarked = edit.added.filter((line) => line.trim() !== '' && !line.toLowerCase().includes(needle));
-    if (unmarked.length > 0) {
-        return (`adds ${String(unmarked.length)} line(s) without the "${marker}" marker, ` +
-            `first: ${JSON.stringify(unmarked[0])}`);
-    }
-    return undefined;
-}
-function evaluateUpstreamEdits(cfg, filename, edits, severity) {
-    const allowlist = (cfg.upstreamAllowlist ?? []).map(normalizeAllowEntry);
-    const issues = [];
-    const outside = [];
-    for (const [path, edit] of [...edits].sort(([a], [b]) => a.localeCompare(b))) {
-        const matches = allowlist.filter((entry) => matchesAnyGlob(path, [entry.path]));
-        if (matches.length === 0) {
-            outside.push(path);
-            continue;
-        }
-        // Strictest wins: any add-only match makes the file add-only.
-        const addOnly = matches.find((entry) => entry.addOnly === true);
-        if (!addOnly)
-            continue;
-        const marker = addOnly.marker ?? cfg.addOnlyMarker ?? '';
-        const violation = addOnlyViolation(edit, marker);
-        if (violation !== undefined) {
-            issues.push({
-                code: 'add-only',
-                filename,
-                severity,
-                message: `${filename} edits ${path}, which patchPolicy.upstreamAllowlist marks add-only ` +
-                    `(added lines carrying "${marker}"), but ${violation}.`,
-            });
-        }
-    }
-    if (outside.length > 0) {
-        issues.push({
-            code: 'upstream-allowlist',
-            filename,
-            severity,
-            message: `${filename} modifies upstream file(s) outside patchPolicy.upstreamAllowlist: ` +
-                `${outside.join(', ')}. Move the change into a fork-owned file, or add a reviewed allowlist entry.`,
-        });
-    }
-    return issues;
-}
-function evaluateScopeRules(cfg, filename, category, files, severity) {
-    const issues = [];
-    for (const [index, rule] of (cfg.scopeRules ?? []).entries()) {
-        if (rule.category !== undefined && rule.category !== category)
-            continue;
-        if (rule.filenamePattern !== undefined && !new RegExp(rule.filenamePattern).test(filename)) {
-            continue;
-        }
-        const outside = files.filter((file) => !matchesAnyGlob(file, rule.files));
-        if (outside.length === 0)
-            continue;
-        issues.push({
-            code: 'scope',
-            filename,
-            severity,
-            message: `${filename} is scoped by patchPolicy.scopeRules[${String(index)}] to ` +
-                `${rule.files.join(', ')}, but touches: ${outside.join(', ')}. ` +
-                'Move those files to a patch of the class that owns them.',
-        });
-    }
-    return issues;
-}
-async function evaluateDocumentPaths(cfg, projectRoot, severity) {
-    if (cfg.verifyDocumentPaths !== true)
-        return [];
-    const issues = [];
-    for (const range of cfg.reservedRanges ?? []) {
-        for (const allowed of range.allowed) {
-            for (const [field, path] of [
-                ['adr', allowed.adr],
-                ['documentation', allowed.documentation],
-            ]) {
-                if (path === undefined || (await pathExists(join(projectRoot, path))))
-                    continue;
-                issues.push({
-                    code: 'reserved-document-missing',
-                    filename: allowed.filename,
-                    severity,
-                    message: `${allowed.filename}'s reserved-range allowlist entry names ${field} "${path}", ` +
-                        'which does not exist. Restore the document or correct the path.',
-                });
-            }
-        }
-    }
-    return issues;
-}
-/**
- * Evaluates the body-dependent `patchPolicy` rules over a patch queue.
- *
- * @param config - Project configuration
- * @param projectRoot - Project root, for the document-path check
- * @param manifest - Current manifest (category and order per patch)
- * @param entries - Patch queue entries with their bodies
- * @returns Findings, in the same shape {@link evaluatePatchPolicy} returns
- */
-export async function evaluatePatchPolicyContent(config, projectRoot, manifest, entries) {
-    const cfg = config.patchPolicy;
-    if (!cfg || !hasPatchPolicyContentRules(config))
-        return [];
-    const severity = cfg.mutationMode === 'warn' ? 'warning' : 'error';
-    const queueCreated = new Set();
-    for (const entry of entries)
-        for (const file of entry.createdFiles)
-            queueCreated.add(file);
-    const bodies = new Map(entries.map((entry) => [entry.filename, entry.diff]));
-    const issues = [];
-    for (const patch of manifest.patches) {
-        const diff = bodies.get(patch.filename);
-        if (cfg.upstreamAllowlist !== undefined && diff !== undefined) {
-            if (!isReservedOrder(cfg, patch.order)) {
-                const edits = collectUpstreamEdits(diff, queueCreated);
-                issues.push(...evaluateUpstreamEdits(cfg, patch.filename, edits, severity));
-            }
-        }
-        issues.push(...evaluateScopeRules(cfg, patch.filename, patch.category, patch.filesAffected, severity));
-    }
-    issues.push(...(await evaluateDocumentPaths(cfg, projectRoot, severity)));
-    return issues;
-}
-/**
- * {@link evaluatePatchPolicyContent} for a caller without a queue context
- * in hand (`verify`): reads the patch bodies only when a body-dependent
- * rule is configured.
- */
-export async function evaluatePatchPolicyContentForQueue(config, projectRoot, patchesDir, manifest) {
-    if (!hasPatchPolicyContentRules(config))
-        return [];
-    const { entries } = await buildPatchQueueContext(patchesDir);
-    return evaluatePatchPolicyContent(config, projectRoot, manifest, entries);
-}

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

@@ -1,80 +0,0 @@
-/**
- * Project-specific patch queue policy evaluation.
- *
- * The policy is opt-in via `fireforge.json#patchPolicy`. Callers feed this
- * module either the current manifest (`verify`, `lint --per-patch`) or a
- * projected manifest assembled before a mutation commits (`export`,
- * `patch reorder`, etc.).
- */
-import type { PatchesManifest, PatchMetadata } from '../types/commands/index.js';
-import type { FireForgeConfig, PatchPolicyConfig, PatchPolicyRange } from '../types/config.js';
-/** Stable issue codes returned by patch policy evaluation. */
-export type PatchPolicyIssueCode = 'filename-pattern' | 'filename-captures' | 'filename-metadata-mismatch' | 'order-collision' | 'category-range' | 'reserved-range' | 'reserved-documentation' | 'reserved-files' | 'description-required' | 'numeric-gap' | 'upstream-allowlist' | 'add-only' | 'scope' | 'reserved-document-missing';
-/** A single patch policy validation finding. */
-export interface PatchPolicyIssue {
-    code: PatchPolicyIssueCode;
-    filename: string;
-    message: string;
-    severity: 'error' | 'warning';
-}
-/** Input for enforcing policy during mutating commands. */
-export interface PatchPolicyEnforcementInput {
-    config: FireForgeConfig;
-    manifest: PatchesManifest;
-    command: string;
-    forceUnsafe?: boolean;
-    /**
-     * Per-issue-code remediation lines appended to matching details, so a
-     * refusal can name the exact flag or command that fixes it on the
-     * command it was raised from (e.g. `--description` on
-     * `patch move-files --create`).
-     */
-    hints?: Partial<Record<PatchPolicyIssueCode, string>>;
-    /**
-     * Patch filenames whose findings this mutation answers for. When set, only
-     * issues attributed to these rows are enforced: queue-level findings
-     * (order collisions, numeric gaps) and other patches' findings are left to
-     * `verify` and `lint --per-patch`. For mutations that change only the
-     * scoped rows' contents (`re-export`), so one patch's stale row cannot fail
-     * an unrelated patch refreshed in the same call.
-     */
-    scope?: readonly string[];
-}
-/** Returns valid categories for prompts and CLI validation under the config. */
-export declare function getPatchPolicyCategories(config: FireForgeConfig): string[];
-/** Checks whether a category is accepted by the built-in defaults or the policy ranges. */
-export declare function isCategoryAllowedByConfig(config: FireForgeConfig, category: string): boolean;
-/**
- * Human-readable label for a category's configured ranges, e.g. `300-399`.
- * Exported for the forward-import hint, which must render the
- * range it found no legal ordinal in.
- */
-export declare function categoryRangeLabel(ranges: readonly PatchPolicyRange[], category: string): string;
-/**
- * Returns the configured range that contains `order` for `category`, or
- * null when no such range exists. Exported for the forward-import hint,
- * which suppresses ordinal suggestions the reorder policy
- * would refuse.
- */
-export declare function categoryRangeForOrder(cfg: PatchPolicyConfig, category: string, order: number): PatchPolicyRange | null;
-/** Evaluates an entire patch manifest against the configured policy. */
-export declare function evaluatePatchPolicy(config: Pick<FireForgeConfig, 'patchPolicy'>, manifest: PatchesManifest): PatchPolicyIssue[];
-/**
- * Builds a sorted manifest snapshot from projected patch metadata. Retired
- * slots of `current` carry over unless a projected patch fills them, so a
- * projection judges gaps the way the written manifest will.
- */
-export declare function buildProjectedManifest(current: PatchesManifest | null, patches: PatchMetadata[]): PatchesManifest;
-/** Applies a filename/order rename projection to a manifest without mutating it. */
-export declare function applyRenameMapToManifest(manifest: PatchesManifest, renameMap: ReadonlyMap<string, {
-    newFilename: string;
-    newOrder: number;
-}>): PatchesManifest;
-/** Enforces patch policy according to the configured mutation mode. */
-export declare function enforcePatchPolicy(input: PatchPolicyEnforcementInput): void;
-/**
- * Allocates the next available order inside the configured ranges for a
- * category. Orders in `reserved` (`patch reserve`) are skipped: they are
- * held for their owner's export.
- */
-export declare function allocatePolicyOrder(config: FireForgeConfig, patches: readonly PatchMetadata[], category: string, reserved?: ReadonlySet<number>): number | null;

package/dist/src/core/patch-policy.js

@@ -1,394 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Project-specific patch queue policy evaluation.
- *
- * The policy is opt-in via `fireforge.json#patchPolicy`. Callers feed this
- * module either the current manifest (`verify`, `lint --per-patch`) or a
- * projected manifest assembled before a mutation commits (`export`,
- * `patch reorder`, etc.).
- */
-import { InvalidArgumentError } from '../errors/base.js';
-import { warn } from '../utils/logger.js';
-import { PATCH_CATEGORIES } from '../utils/validation.js';
-import { rewriteStagedDependencyOwners } from './patch-manifest-io.js';
-import { formatOrderRange, formatPatchOrder } from './patch-parse.js';
-import { manifestWithRetiredSlots, reservedOrderSet, retiredOrderSet } from './patch-retired.js';
-/** Default patch filename contract used when a policy omits `filenamePattern`. */
-const DEFAULT_PATCH_POLICY_FILENAME_PATTERN = '^(?<order>\\d{3})-(?<category>[a-z][a-z0-9-]*)-(?<slug>[a-z0-9-]+)\\.patch$';
-function policy(config) {
-    return config.patchPolicy;
-}
-function mutationMode(config) {
-    return policy(config)?.mutationMode ?? 'error';
-}
-/** Returns valid categories for prompts and CLI validation under the config. */
-export function getPatchPolicyCategories(config) {
-    const cfg = policy(config);
-    if (!cfg)
-        return [...PATCH_CATEGORIES];
-    return Array.from(new Set(cfg.ranges.map((range) => range.category))).sort((a, b) => a.localeCompare(b));
-}
-/** Checks whether a category is accepted by the built-in defaults or the policy ranges. */
-export function isCategoryAllowedByConfig(config, category) {
-    if (!/^[a-z][a-z0-9-]*$/.test(category))
-        return false;
-    const cfg = policy(config);
-    if (!cfg)
-        return PATCH_CATEGORIES.includes(category);
-    return cfg.ranges.some((range) => range.category === category);
-}
-/**
- * Human-readable label for a category's configured ranges, e.g. `300-399`.
- * Exported for the forward-import hint, which must render the
- * range it found no legal ordinal in.
- */
-export function categoryRangeLabel(ranges, category) {
-    const matches = ranges.filter((range) => range.category === category);
-    if (matches.length === 0)
-        return '(no configured range)';
-    return matches.map(formatOrderRange).join(', ');
-}
-function reservedRangeForOrder(cfg, order) {
-    return cfg.reservedRanges?.find((range) => order >= range.from && order <= range.to) ?? null;
-}
-/**
- * Returns the configured range that contains `order` for `category`, or
- * null when no such range exists. Exported for the forward-import hint,
- * which suppresses ordinal suggestions the reorder policy
- * would refuse.
- */
-export function categoryRangeForOrder(cfg, category, order) {
-    return (cfg.ranges.find((range) => {
-        return range.category === category && order >= range.from && order <= range.to;
-    }) ?? null);
-}
-function anyRangeForOrder(cfg, order) {
-    return cfg.ranges.find((range) => order >= range.from && order <= range.to) ?? null;
-}
-function parseFilenameWithPolicy(cfg, patch, severity) {
-    if (cfg.filenamePattern === undefined) {
-        const defaultMatch = /^(?<order>\d{3})-(?<rest>[a-z0-9-]+)\.patch$/.exec(patch.filename);
-        const orderRaw = defaultMatch?.groups?.['order'];
-        const rest = defaultMatch?.groups?.['rest'];
-        if (!orderRaw || !rest) {
-            return [
-                {
-                    code: 'filename-pattern',
-                    filename: patch.filename,
-                    severity,
-                    message: `${patch.filename} does not match the default patchPolicy filename pattern ` +
-                        '(NNN-category-slug.patch).',
-                },
-            ];
-        }
-        const categories = Array.from(new Set(cfg.ranges.map((range) => range.category))).sort((a, b) => b.length - a.length);
-        const category = categories.find((candidate) => rest.startsWith(`${candidate}-`));
-        if (!category) {
-            return [
-                {
-                    code: 'filename-captures',
-                    filename: patch.filename,
-                    severity,
-                    message: `${patch.filename} does not encode one of the configured patchPolicy categories.`,
-                },
-            ];
-        }
-        const slug = rest.slice(category.length + 1);
-        if (!/^[a-z0-9-]+$/.test(slug)) {
-            return [
-                {
-                    code: 'filename-captures',
-                    filename: patch.filename,
-                    severity,
-                    message: `${patch.filename} does not encode a lowercase slug after category "${category}".`,
-                },
-            ];
-        }
-        return { order: Number.parseInt(orderRaw, 10), category };
-    }
-    const pattern = new RegExp(cfg.filenamePattern ?? DEFAULT_PATCH_POLICY_FILENAME_PATTERN);
-    const match = pattern.exec(patch.filename);
-    if (!match) {
-        return [
-            {
-                code: 'filename-pattern',
-                filename: patch.filename,
-                severity,
-                message: `${patch.filename} does not match patchPolicy.filenamePattern ` +
-                    `(${cfg.filenamePattern ?? DEFAULT_PATCH_POLICY_FILENAME_PATTERN}).`,
-            },
-        ];
-    }
-    const groups = match.groups;
-    const orderRaw = groups?.['order'];
-    const category = groups?.['category'];
-    const slug = groups?.['slug'];
-    if (!orderRaw || !category || slug === undefined) {
-        return [
-            {
-                code: 'filename-captures',
-                filename: patch.filename,
-                severity,
-                message: 'patchPolicy.filenamePattern must expose named captures "order", "category", and "slug".',
-            },
-        ];
-    }
-    const order = Number.parseInt(orderRaw, 10);
-    if (!Number.isInteger(order)) {
-        return [
-            {
-                code: 'filename-captures',
-                filename: patch.filename,
-                severity,
-                message: `${patch.filename} has a non-numeric order capture "${orderRaw}".`,
-            },
-        ];
-    }
-    return { order, category };
-}
-function evaluatePatchMetadata(cfg, patch, severity) {
-    const issues = [];
-    const parsed = parseFilenameWithPolicy(cfg, patch, severity);
-    if (Array.isArray(parsed)) {
-        return parsed;
-    }
-    if (parsed.order !== patch.order || parsed.category !== patch.category) {
-        issues.push({
-            code: 'filename-metadata-mismatch',
-            filename: patch.filename,
-            severity,
-            message: `${patch.filename} encodes order/category ${parsed.order}/${parsed.category}, ` +
-                `but patches.json records ${patch.order}/${patch.category}.`,
-        });
-    }
-    if (cfg.requireDescription === true && patch.description.trim() === '') {
-        issues.push({
-            code: 'description-required',
-            filename: patch.filename,
-            severity,
-            message: `${patch.filename} has an empty description, but patchPolicy.requireDescription is true.`,
-        });
-    }
-    const reserved = reservedRangeForOrder(cfg, patch.order);
-    if (reserved) {
-        const allowed = reserved.allowed.find((entry) => entry.filename === patch.filename);
-        if (!allowed) {
-            issues.push({
-                code: 'reserved-range',
-                filename: patch.filename,
-                severity,
-                message: `${patch.filename} is in reserved range ${formatOrderRange(reserved)}. ` +
-                    'Reserved ranges require an exact patchPolicy.reservedRanges[].allowed filename exception.',
-            });
-            return issues;
-        }
-        if (!allowed.adr && !allowed.documentation) {
-            issues.push({
-                code: 'reserved-documentation',
-                filename: patch.filename,
-                severity,
-                message: `${patch.filename} is allowlisted for reserved range ${formatOrderRange(reserved)}, ` +
-                    'but the allowlist entry must include either "adr" or "documentation".',
-            });
-        }
-        if (allowed.files !== undefined) {
-            const allowedFiles = new Set(allowed.files);
-            const extraFiles = patch.filesAffected.filter((file) => !allowedFiles.has(file));
-            if (extraFiles.length > 0) {
-                issues.push({
-                    code: 'reserved-files',
-                    filename: patch.filename,
-                    severity,
-                    message: `${patch.filename} is allowlisted for reserved range ${formatOrderRange(reserved)}, ` +
-                        `but touches file(s) outside its reserved allowlist: ${extraFiles.join(', ')}.`,
-                });
-            }
-        }
-        return issues;
-    }
-    const matchingRange = categoryRangeForOrder(cfg, patch.category, patch.order);
-    if (!matchingRange) {
-        const owner = anyRangeForOrder(cfg, patch.order);
-        const expected = categoryRangeLabel(cfg.ranges, patch.category);
-        const actual = owner !== null
-            ? `${formatPatchOrder(patch.order)} is configured for ${owner.category} (${formatOrderRange(owner)})`
-            : `${formatPatchOrder(patch.order)} is outside all configured ranges`;
-        issues.push({
-            code: 'category-range',
-            filename: patch.filename,
-            severity,
-            message: `${patch.category} patches must use ${expected}; ${actual}. ` +
-                `Choose a ${patch.category} order in ${expected} or configure an explicit reserved-range exception.`,
-        });
-    }
-    return issues;
-}
-function evaluateGaps(cfg, patches, severity, retiredOrders = new Set()) {
-    if (cfg.allowGaps !== false)
-        return [];
-    const issues = [];
-    for (const range of cfg.ranges) {
-        const occupied = patches
-            .filter((patch) => {
-            return (patch.category === range.category &&
-                patch.order >= range.from &&
-                patch.order <= range.to &&
-                reservedRangeForOrder(cfg, patch.order) === null);
-        })
-            .map((patch) => patch.order)
-            .sort((a, b) => a - b);
-        if (occupied.length <= 1)
-            continue;
-        const occupiedSet = new Set(occupied);
-        const first = occupied[0];
-        const last = occupied[occupied.length - 1];
-        const missing = [];
-        for (let order = first; order <= last; order++) {
-            // A retired slot (`patch retire`) or a reservation (`patch reserve`)
-            // is an occupied order with no patch behind it, so it is not a gap.
-            if (!occupiedSet.has(order) &&
-                !retiredOrders.has(order) &&
-                reservedRangeForOrder(cfg, order) === null) {
-                missing.push(order);
-            }
-        }
-        if (missing.length > 0) {
-            issues.push({
-                code: 'numeric-gap',
-                filename: `${range.category}:${formatOrderRange(range)}`,
-                severity,
-                message: `${range.category} range ${formatOrderRange(range)} has numeric gap(s): ` +
-                    missing.map((order) => formatPatchOrder(order)).join(', ') +
-                    '. patchPolicy.allowGaps is false.',
-            });
-        }
-    }
-    return issues;
-}
-function evaluateOrderCollisions(patches, severity) {
-    const byOrder = new Map();
-    for (const patch of patches) {
-        const matches = byOrder.get(patch.order) ?? [];
-        matches.push(patch);
-        byOrder.set(patch.order, matches);
-    }
-    const issues = [];
-    for (const [order, matches] of [...byOrder.entries()].sort((a, b) => a[0] - b[0])) {
-        if (matches.length <= 1)
-            continue;
-        const filenames = matches.map((patch) => patch.filename).sort((a, b) => a.localeCompare(b));
-        issues.push({
-            code: 'order-collision',
-            filename: formatPatchOrder(order),
-            severity,
-            message: `patchPolicy requires unique numeric orders; order ${formatPatchOrder(order)} ` +
-                `is used by: ${filenames.join(', ')}.`,
-        });
-    }
-    return issues;
-}
-/** Evaluates an entire patch manifest against the configured policy. */
-export function evaluatePatchPolicy(config, manifest) {
-    const cfg = policy(config);
-    if (!cfg)
-        return [];
-    const severity = mutationMode(config) === 'warn' ? 'warning' : 'error';
-    const issues = manifest.patches.flatMap((patch) => evaluatePatchMetadata(cfg, patch, severity));
-    issues.push(...evaluateOrderCollisions(manifest.patches, severity));
-    // Retired and reserved slots are both spent orders with no patch behind
-    // them: neither is a gap.
-    const placeholders = new Set([...retiredOrderSet(manifest), ...reservedOrderSet(manifest)]);
-    issues.push(...evaluateGaps(cfg, manifest.patches, severity, placeholders));
-    return issues;
-}
-/**
- * Builds a sorted manifest snapshot from projected patch metadata. Retired
- * slots of `current` carry over unless a projected patch fills them, so a
- * projection judges gaps the way the written manifest will.
- */
-export function buildProjectedManifest(current, patches) {
-    const next = patches
-        .map((patch) => ({ ...patch, filesAffected: [...patch.filesAffected] }))
-        .sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
-    return manifestWithRetiredSlots(current, next);
-}
-/** Applies a filename/order rename projection to a manifest without mutating it. */
-export function applyRenameMapToManifest(manifest, renameMap) {
-    const ownerLookup = (oldFilename) => renameMap.get(oldFilename)?.newFilename;
-    return buildProjectedManifest(manifest, manifest.patches.map((patch) => {
-        // Staged-dependency owners reference other patches' filenames, so the
-        // projection rewrites them on every row to mirror what
-        // renumberPatchesInManifest persists.
-        const withOwners = rewriteStagedDependencyOwners(patch, ownerLookup);
-        const rename = renameMap.get(patch.filename);
-        if (!rename)
-            return withOwners;
-        return {
-            ...withOwners,
-            filename: rename.newFilename,
-            order: rename.newOrder,
-        };
-    }));
-}
-/** Enforces patch policy according to the configured mutation mode. */
-export function enforcePatchPolicy(input) {
-    if (policy(input.config) === undefined)
-        return;
-    const scope = input.scope === undefined ? undefined : new Set(input.scope);
-    const issues = evaluatePatchPolicy(input.config, input.manifest).filter((issue) => scope === undefined || scope.has(issue.filename));
-    if (issues.length === 0)
-        return;
-    const mode = mutationMode(input.config);
-    const details = issues.map((issue) => {
-        const hint = input.hints?.[issue.code];
-        return `  [${issue.code}] ${issue.message}${hint ? `\n      → ${hint}` : ''}`;
-    });
-    if (mode === 'warn') {
-        warn(`${input.command}: patch policy warning(s):`);
-        for (const detail of details)
-            warn(detail);
-        return;
-    }
-    if (mode === 'force' && input.forceUnsafe === true) {
-        warn(`${input.command}: bypassing patch policy violation(s) because --force-unsafe was provided:`);
-        for (const detail of details)
-            warn(detail);
-        return;
-    }
-    const suffix = mode === 'force'
-        ? '\n\nPass --force-unsafe only if you intentionally accept this policy violation.'
-        : '';
-    throw new InvalidArgumentError(`${input.command} would violate patchPolicy:\n${details.join('\n')}${suffix}`, mode === 'force' ? '--force-unsafe' : 'patchPolicy');
-}
-/**
- * Allocates the next available order inside the configured ranges for a
- * category. Orders in `reserved` (`patch reserve`) are skipped: they are
- * held for their owner's export.
- */
-export function allocatePolicyOrder(config, patches, category, reserved = new Set()) {
-    const cfg = policy(config);
-    if (!cfg)
-        return null;
-    const ranges = cfg.ranges
-        .filter((range) => range.category === category)
-        .sort((a, b) => a.from - b.from || a.to - b.to);
-    if (ranges.length === 0)
-        return null;
-    const occupied = new Set([...patches.map((patch) => patch.order), ...reserved]);
-    const highestInRanges = patches.reduce((highest, patch) => {
-        if (!ranges.some((range) => patch.order >= range.from && patch.order <= range.to)) {
-            return highest;
-        }
-        return highest === null ? patch.order : Math.max(highest, patch.order);
-    }, null);
-    const start = highestInRanges === null ? ranges[0]?.from : highestInRanges + 1;
-    if (start === undefined)
-        return null;
-    for (const range of ranges) {
-        for (let order = Math.max(start, range.from); order <= range.to; order++) {
-            if (!occupied.has(order))
-                return order;
-        }
-    }
-    return null;
-}