@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,13 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Patches manifest: re-exports from focused sub-modules.
- *
- * Callers should continue to import from this module. The internal split
- * is an implementation detail.
- */
-export { rebuildPatchesManifest, recommendManifestRepair, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';
-export { repairPatchesFilesAffected, } from './patch-manifest-files-affected.js';
-export { addPatchToManifest, loadPatchesManifest, loadPatchesManifestForWrite, mutatePatchRowsInManifest, PATCHES_MANIFEST, removePatchFileAndManifest, renumberPatchesInManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from './patch-manifest-io.js';
-export { checkVersionCompatibility, findPatchesAffectingFile, getClaimedFiles, stampPatchVersions, validatePatchIntegrity, } from './patch-manifest-query.js';
-export { resolvePatchIdentifier } from './patch-manifest-resolve.js';
-export { validatePatchesManifest } from './patch-manifest-validate.js';

package/dist/src/core/patch-order-legal.d.ts

@@ -1,26 +0,0 @@
-/**
- * The earliest order a new patch can take after a given order, under the
- * queue's occupancy and `patchPolicy`.
- *
- * A refusal that says "export it as its own later patch" leaves the
- * operator to find a number that is free, inside the category's range, and
- * (with `allowGaps: false`) does not open a gap. Each wrong guess costs a
- * full export attempt. This answers it once, with the same policy
- * evaluation the export itself will run.
- */
-import type { PatchesManifest } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
-/**
- * Smallest order strictly greater than `after` that no patch occupies and
- * that adds no order-related `patchPolicy` finding (collision, category
- * range, reserved range, numeric gap) for a `category` patch. A retired
- * slot counts as free, since a patch may fill it; a reservation does not,
- * since it is held for its owner's export. Returns null when no such
- * order exists inside the category's configured ranges.
- *
- * @param config - Project config (only `patchPolicy` is read)
- * @param manifest - Current manifest
- * @param category - Category the new patch would carry
- * @param after - The order the new patch must come after
- */
-export declare function earliestLegalOrderAfter(config: Pick<FireForgeConfig, 'patchPolicy'>, manifest: PatchesManifest, category: string, after: number): number | null;

package/dist/src/core/patch-order-legal.js

@@ -1,88 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The earliest order a new patch can take after a given order, under the
- * queue's occupancy and `patchPolicy`.
- *
- * A refusal that says "export it as its own later patch" leaves the
- * operator to find a number that is free, inside the category's range, and
- * (with `allowGaps: false`) does not open a gap. Each wrong guess costs a
- * full export attempt. This answers it once, with the same policy
- * evaluation the export itself will run.
- */
-import { formatPatchOrder } from './patch-parse.js';
-import { evaluatePatchPolicy } from './patch-policy.js';
-import { reservedOrderSet } from './patch-retired.js';
-/** Policy codes an order choice alone can trip. */
-const ORDER_CODES = new Set([
-    'order-collision',
-    'category-range',
-    'reserved-range',
-    'numeric-gap',
-]);
-/** Upper bound on the search when no policy range bounds it. */
-const UNBOUNDED_SEARCH = 1000;
-const GAP_ORDERS_PATTERN = /numeric gap\(s\): (?<orders>[^.]+)\./;
-/**
- * Order-related findings as comparable keys. A `numeric-gap` finding
- * becomes one key per missing order, so filling one gap of several reads as
- * removing a key rather than as a new, differently worded finding.
- */
-function orderIssueKeys(config, manifest) {
-    const keys = new Set();
-    for (const issue of evaluatePatchPolicy(config, manifest)) {
-        if (!ORDER_CODES.has(issue.code))
-            continue;
-        const gaps = issue.code === 'numeric-gap' ? GAP_ORDERS_PATTERN.exec(issue.message) : null;
-        if (gaps?.groups?.['orders'] === undefined) {
-            keys.add(`${issue.code}|${issue.message}`);
-            continue;
-        }
-        for (const order of gaps.groups['orders'].split(',')) {
-            keys.add(`numeric-gap|${issue.filename}|${order.trim()}`);
-        }
-    }
-    return keys;
-}
-/**
- * Smallest order strictly greater than `after` that no patch occupies and
- * that adds no order-related `patchPolicy` finding (collision, category
- * range, reserved range, numeric gap) for a `category` patch. A retired
- * slot counts as free, since a patch may fill it; a reservation does not,
- * since it is held for its owner's export. Returns null when no such
- * order exists inside the category's configured ranges.
- *
- * @param config - Project config (only `patchPolicy` is read)
- * @param manifest - Current manifest
- * @param category - Category the new patch would carry
- * @param after - The order the new patch must come after
- */
-export function earliestLegalOrderAfter(config, manifest, category, after) {
-    const occupied = new Set([
-        ...manifest.patches.map((patch) => patch.order),
-        ...reservedOrderSet(manifest),
-    ]);
-    const ranges = config.patchPolicy?.ranges.filter((range) => range.category === category) ?? [];
-    const limit = ranges.length > 0 ? Math.max(...ranges.map((range) => range.to)) : after + UNBOUNDED_SEARCH;
-    const baseline = config.patchPolicy ? orderIssueKeys(config, manifest) : new Set();
-    for (let order = after + 1; order <= limit; order++) {
-        if (occupied.has(order))
-            continue;
-        if (!config.patchPolicy)
-            return order;
-        const probe = {
-            filename: `${formatPatchOrder(order)}-${category}-probe.patch`,
-            order,
-            category,
-            name: 'probe',
-            description: 'probe',
-            createdAt: '',
-            sourceEsrVersion: '',
-            filesAffected: [],
-        };
-        const projected = { ...manifest, patches: [...manifest.patches, probe] };
-        const introduced = [...orderIssueKeys(config, projected)].filter((key) => !baseline.has(key));
-        if (introduced.length === 0)
-            return order;
-    }
-    return null;
-}

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

@@ -1,176 +0,0 @@
-/**
- * Renders a patch order as the zero-padded prefix used in filenames and in
- * every message that names an order.
- *
- * Eleven call sites across `patch-policy`, `patch-export`, `export-flow`,
- * `export-placement-policy` and `patch move-files` spelled this as
- * `String(order).padStart(3, '0')`, so the padding width lived in eleven
- * places while the filenames it has to agree with are produced in one.
- * @param order - Numeric patch order.
- * @param width - Prefix width. Defaults to the on-disk convention.
- * @returns The zero-padded order, e.g. `007`.
- */
-export declare function formatPatchOrder(order: number, width?: number): string;
-/**
- * Renders an inclusive order range the way `patchPolicy` diagnostics name it.
- * @param range - Inclusive `from`/`to` order bounds.
- * @returns The range label, e.g. `100-199`.
- */
-export declare function formatOrderRange(range: {
-    from: number;
-    to: number;
-}): string;
-/**
- * Extracts the order number from a patch filename.
- * Expects format like "001-description.patch"
- * @param filename - Patch filename
- * @returns Order number, or Infinity if no prefix
- */
-export declare function extractOrder(filename: string): number;
-/**
- * Extracts the order number from a patch filename that is about to be
- * written into the manifest.
- *
- * The write-side counterpart to {@link extractOrder}. That one answers
- * `Infinity` for a prefix-less filename, which sorts such a patch last and
- * is the right answer for a read: an unparseable name should not crash a
- * status listing. Persisting `Infinity` (or a fallback `0`) is a different
- * matter: it puts an order in the manifest
- * that no filename on disk agrees with, and the queue then applies in an
- * order the operator cannot see. Callers here have just built or
- * looked up a real prefixed filename, so absence is a bug, not input.
- *
- * @param filename - Patch filename carrying a numeric order prefix
- * @returns The parsed order
- * @throws {@link InternalInvariantError} when `filename` has no numeric prefix.
- */
-export declare function requirePatchOrder(filename: string): number;
-/**
- * A parsed `diff --git` header: both sides' paths, unquoted and with any
- * CRLF residue stripped.
- */
-export interface DiffGitHeader {
-    /** Old-side (`a/`) path. */
-    sourcePath: string;
-    /** New-side (`b/`) path: the file the patch produces. */
-    targetPath: string;
-}
-/**
- * Parses a `diff --git` line into its two paths.
- *
- * Handles the quoted form git emits for paths with special characters
- * (`diff --git "a/x y" "b/x y"`), and disambiguates the unquoted form for
- * paths that themselves contain ` b/`: for the overwhelmingly common
- * non-rename case the two paths are identical, so a symmetric split
- * (`a/<p> b/<p>`) is tried first: a greedy `a\/.+ b\/(.+)$` splits such
- * lines at the last ` b/` and returns a truncated path. Falls back to a
- * non-greedy split for renames.
- *
- * @returns null when the line is not a diff --git header.
- */
-export declare function parseDiffGitHeader(line: string): DiffGitHeader | null;
-/**
- * One `diff --git` section of a unified diff, fully structured.
- */
-export interface DiffSection {
-    /** New-side (`b/`) path: the file this section produces. */
-    targetPath: string;
-    /** Old-side (`a/`) path. */
-    sourcePath: string;
-    /** True when the section carries a `new file mode` marker. */
-    isNewFile: boolean;
-    /** True when the section carries a `deleted file mode` marker. */
-    isDeletedFile: boolean;
-    /**
-     * True for binary sections (`GIT binary patch` or `Binary files … differ`).
-     * Binary sections have no parseable hunks. Text-oriented consumers must
-     * refuse them rather than treat base85 lines starting with `+` as content.
-     */
-    isBinary: boolean;
-    /**
-     * True only for `GIT binary patch` sections, whose body carries a
-     * reconstructable literal/delta payload. False for `Binary files … differ`,
-     * which records that the bytes changed but carries none of them and cannot
-     * be replayed by `git apply`.
-     *
-     * The distinction is not cosmetic: the stub form still carries a correct
-     * `index <old>..<new>` line, so identity checks keyed on {@link indexNewHash}
-     * alone happily conclude "the recorded bytes match the live file" for a body
-     * that can no longer produce those bytes. Consumers deciding whether a patch
-     * can recreate a file must read this flag, never `isBinary` plus a hash.
-     */
-    hasBinaryDelta: boolean;
-    /**
-     * Old-side blob hash from the section's `index <old>..<new>` line
-     * (possibly abbreviated). Undefined when the metadata zone carries no
-     * parseable index line (hand-written diffs, `Binary files … differ`).
-     */
-    indexOldHash?: string;
-    /** New-side blob hash from the `index` line. See {@link indexOldHash}. */
-    indexNewHash?: string;
-    /** Parsed hunks, in file order. Empty for binary or metadata-only sections. */
-    hunks: ParsedHunk[];
-}
-/**
- * Parses a unified diff into structured per-file sections. This is the
- * single shared walker every diff consumer builds on.
- */
-export declare function parseDiffSections(diffContent: string): DiffSection[];
-/**
- * Gives a plain unified diff (`diff -u`, no `diff --git` lines) the git
- * header {@link parseDiffSections} keys on, one per `---`/`+++` pair. A
- * diff that already carries `diff --git` headers is returned unchanged.
- * Hunk bodies are skipped by their header counts, so a removed line that
- * reads `-- x` is never taken for a file header.
- *
- * The two sides keep the names the diff gives them, so a section written
- * as `diff -u <(body) engine/<file>` has a different path on each side;
- * the caller decides which side names the file.
- *
- * @param content - The diff file's text
- * @returns The diff with a `diff --git` header before each file
- */
-export declare function withGitHeaders(content: string): string;
-/**
- * Checks whether a specific file is a new-file addition within a patch.
- * For multi-file patches, only inspects the section belonging to targetFile.
- * @param patchContent - The full patch content
- * @param targetFile - The file path to check
- * @returns true if the patch creates targetFile as a new file
- */
-export declare function isNewFileInPatch(patchContent: string, targetFile: string): boolean;
-/**
- * Extracts affected file paths from a diff/patch content.
- * @param diffContent - The diff content to parse
- * @returns Array of file paths
- */
-export declare function extractAffectedFiles(diffContent: string): string[];
-/**
- * A single parsed hunk. `noNewlineAtEndOld` / `noNewlineAtEndNew` track the
- * `` marker per side. The marker is a trailing
- * annotation on the immediately preceding body line, and a `-` precedent
- * sets only the old-side flag, a `+` sets only the new-side flag, and a
- * context ` ` line sets both. Collapsing the two into one boolean makes the
- * projection disagree with `git apply` on asymmetric trailing-newline
- * changes (e.g. removing a newline on one side but not the other).
- */
-export interface ParsedHunk {
-    oldStart: number;
-    oldCount: number;
-    newStart: number;
-    newCount: number;
-    lines: string[];
-    noNewlineAtEndOld: boolean;
-    noNewlineAtEndNew: boolean;
-}
-/**
- * Parses hunks from a patch file for a specific target file.
- * @param patchContent - The full patch content
- * @param targetFile - The file path to extract hunks for
- * @returns Array of hunk objects with line info and changes
- */
-export declare function parseHunksForFile(patchContent: string, targetFile: string): ParsedHunk[];
-/**
- * Extracts conflicting file paths from git apply error message.
- */
-export declare function extractConflictingFiles(error?: string): string[];