@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/queue/capture.js

@@ -0,0 +1,298 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Capturing engine edits into the queue: `export` records edits no patch
+ * owns as a new patch, `re-export` rewrites existing patches from what the
+ * engine holds now.
+ *
+ * Re-export and overlapping patches. When several patches change one file,
+ * the engine holds the sum. An edit to that file (the engine differs from
+ * what the queue leaves there) goes to the re-exported patch whose lines it
+ * touches, when exactly one patch's lines are touched (`attribute.ts`), and
+ * otherwise to the last re-exported patch that changes the file. That
+ * patch's step is rewritten to end in the engine's content, and every other
+ * patch keeps its step. A file still holding what the last import wrote is
+ * behind the queue, not edited, and goes to no patch. When that
+ * patch is not the last one changing the file, the later patches' sections
+ * for it are first taken back out of the engine's content (applied in
+ * reverse), so they still apply on top and the queue still ends in exactly
+ * what the engine holds; when that is impossible (the edit touches lines a
+ * later patch changes) the re-export is refused, naming the later patch to
+ * re-export instead. A patch whose files hold no edit keeps its body byte
+ * for byte, so re-exporting an unchanged engine changes nothing. A deleted
+ * file is captured as a deletion; a file a patch created that the engine no
+ * longer has leaves the patch.
+ *
+ * Every body comes from `regeneratePatchBody`.
+ */
+import { dirname } from 'node:path';
+import { affectedPaths, parsePatch } from '../diff/index.js';
+import { captureWorktree, writeTree } from '../git/index.js';
+import { ExitCode } from '../kernel/errors.js';
+import { applyToTree, covers, sparseTree, statesIn, unapplyFromTree, } from './apply.js';
+import { attributeEdits } from './attribute.js';
+import { classifyEngine, projectQueue, readApplied, regeneratePatchBody, sameState, } from './baseline.js';
+import { queueChanges, requireApplies } from './changes.js';
+import { categoryOf, sameStamp } from './manifest.js';
+import { requireNewName, resolvePlacement } from './operations.js';
+import { nextOrder, place } from './placement.js';
+import { loadQueue, mutateQueue, previewQueue, queueError, selectPatches, slicePatch, } from './queue.js';
+import { requireNoSession, stampOf } from './session.js';
+function usage(message) {
+    return queueError('invalid-argument', message, undefined, ExitCode.INVALID_ARGUMENT);
+}
+/**
+ * Runs a queue change, or with `dryRun` only previews it. Returns the queue
+ * as written (or as it would be), and for a preview its owned changes.
+ */
+async function commit(project, label, dryRun, edit) {
+    if (!dryRun) {
+        const result = await mutateQueue(project, label, edit);
+        return { result, queue: await loadQueue(project) };
+    }
+    const preview = await previewQueue(project, label, edit);
+    return { ...preview, changes: await queueChanges(project, preview.queue) };
+}
+function placementOf(options) {
+    const given = [];
+    if (options.order !== undefined)
+        given.push({ order: options.order });
+    if (options.before !== undefined)
+        given.push({ before: options.before });
+    if (options.after !== undefined)
+        given.push({ after: options.after });
+    if (given.length > 1)
+        throw usage('Give at most one of order, before and after.');
+    return given[0];
+}
+/**
+ * The paths an export captures: every unowned edit the request covers. A
+ * named path must cover one; a named file a patch changes is refused.
+ */
+function exportedPaths(paths, classified) {
+    const files = classified
+        .filter((entry) => entry.state === 'unmanaged')
+        .map((entry) => entry.path);
+    const owned = classified.filter((entry) => entry.owners.length > 0 && entry.state !== 'clean');
+    for (const path of paths) {
+        const ownedHere = owned.find((entry) => entry.path === path.replace(/\/+$/, ''));
+        if (ownedHere !== undefined) {
+            throw queueError('export-owned', `${ownedHere.path} is already changed by ${ownedHere.owners.join(', ')}.`, `Record the edit there with "fireforge re-export ${ownedHere.owners.at(-1) ?? ''}".`);
+        }
+        if (!files.some((file) => covers(path, file))) {
+            throw queueError('export-nothing', `${path} holds no edit that no patch owns.`, owned.some((entry) => covers(path, entry.path))
+                ? 'Its edited files belong to patches; "fireforge re-export" records the edits there.'
+                : undefined);
+        }
+    }
+    return files;
+}
+/**
+ * Captures engine edits that no patch owns into a new patch: the diff of
+ * the named paths (or of every unowned edit, with `all`) against the
+ * pristine engine, stamped with the project's pin. A named file another
+ * patch already changes is refused; under a named directory such files are
+ * left out (they are `re-export`'s).
+ *
+ * The caller holds the engine lock (shared for a dry run). Linting is the
+ * caller's: a dry run returns the would-be queue as owned changes, and the
+ * real run writes exactly that queue.
+ *
+ * @param project - A patch-mode project with an engine
+ * @param options - See {@link ExportOptions}
+ * @throws `export-nothing` or `export-owned` (exit code 6); `patch-name-invalid` or `patch-exists` (exit code 8)
+ */
+export async function exportPatch(project, options) {
+    const paths = options.paths ?? [];
+    if ((options.all === true) === paths.length > 0) {
+        throw usage('Name the paths to export, or export every unowned edit with "all".');
+    }
+    await requireNoSession(project, 'the export');
+    const queue = await loadQueue(project);
+    requireNewName(queue, options.name);
+    const placement = placementOf(options);
+    const resolved = placement === undefined ? undefined : resolvePlacement(queue, placement);
+    const projection = await projectQueue(project, queue);
+    const scope = options.all === true ? undefined : paths;
+    const files = exportedPaths(paths, await classifyEngine(project, projection, scope));
+    if (files.length === 0)
+        throw queueError('export-nothing', 'The engine holds no unowned edit.');
+    const engine = project.paths.engine;
+    const before = await sparseTree(engine, projection.base, files);
+    const { body } = await regeneratePatchBody(engine, { before, paths: files });
+    const label = `the export of ${options.name}`;
+    const done = await commit(project, label, options.dryRun === true, (draft) => {
+        draft.patches.push({
+            order: nextOrder(project.config.patchPolicy, draft, categoryOf(options.name)),
+            name: options.name,
+            description: options.description ?? '',
+            firefox: stampOf(project),
+            ...(options.tier === undefined ? {} : { tier: options.tier }),
+            body,
+        });
+        if (resolved !== undefined)
+            place(draft, options.name, resolved);
+    });
+    const patch = done.queue.patches.find((candidate) => candidate.name === options.name);
+    if (patch === undefined)
+        throw queueError('export-lost', `${options.name} was not written.`);
+    return { patch, files, ...(done.changes === undefined ? {} : { changes: done.changes }) };
+}
+/**
+ * The unowned edits `scan` adopts, by patch name: a changed path no patch
+ * owns, in a directory one of a selected patch's files is in. A path two
+ * selected patches could adopt goes to the later one.
+ */
+async function adoptions(project, projection, selected) {
+    const dirOf = (path) => (dirname(path) === '.' ? '' : dirname(path));
+    const dirs = [...new Set(selected.flatMap((patch) => patch.files.map(dirOf)))];
+    const found = new Map();
+    for (const entry of await classifyEngine(project, projection, dirs)) {
+        if (entry.state !== 'unmanaged')
+            continue;
+        const owner = [...selected]
+            .reverse()
+            .find((patch) => patch.files.some((file) => dirOf(file) === dirOf(entry.path)));
+        if (owner !== undefined)
+            found.set(owner.name, [...(found.get(owner.name) ?? []), entry.path]);
+    }
+    return found;
+}
+/**
+ * Decides which selected patch takes each edit: the one whose lines it
+ * touches (see `attribute.ts`), else the default candidate. A path still
+ * holding what the last import wrote is behind the queue, not edited.
+ */
+async function assignEdits(project, queue, plan, choice) {
+    const engine = project.paths.engine;
+    const { projection, start, paths } = plan;
+    const worktree = await captureWorktree(engine, { base: start, paths });
+    const now = await statesIn(engine, worktree, paths);
+    const base = await statesIn(engine, start, paths);
+    const applied = await readApplied(project, projection.base);
+    const queued = new Set(projection.paths);
+    const final = (path) => queued.has(path) ? projection.final(path) : (base.get(path) ?? null);
+    const edited = (path) => !sameState(now.get(path), final(path)) &&
+        !(applied.has(path) && sameState(now.get(path), applied.get(path)));
+    const takers = new Map([...choice.candidates].filter(([path]) => edited(path)));
+    const attributed = await attributeEdits(engine, projection, new Map([...takers.keys()].map((path) => [path, now.get(path) ?? null])));
+    for (const [path, filename] of attributed) {
+        const owner = choice.selected.find((patch) => patch.filename === filename);
+        if (owner?.files.includes(path) === true)
+            takers.set(path, owner);
+    }
+    let tree = worktree;
+    for (const later of [...queue.patches].reverse()) {
+        const back = later.files.filter((path) => (takers.get(path)?.index ?? Infinity) < later.index);
+        if (back.length === 0)
+            continue;
+        const outcome = await unapplyFromTree(engine, tree, slicePatch(later, new Set(back), true));
+        if (!outcome.applied) {
+            const names = [...new Set(back.map((path) => takers.get(path)?.filename ?? ''))];
+            throw queueError('re-export-overlap', `The edit to ${back.join(', ')} cannot go to ${names.join(', ')}: ${later.filename} changes the same lines after it.`, `Re-export ${later.filename} as well, so it can take the edit.`);
+        }
+        tree = outcome.tree;
+    }
+    const targets = await statesIn(engine, tree, [...takers.keys()]);
+    const expected = new Map(paths.map((path) => [path, takers.has(path) ? (now.get(path) ?? null) : final(path)]));
+    return { takers, targets, expected };
+}
+/**
+ * The new bodies: the queue replayed from the pristine engine, each patch
+ * that takes an edit rewritten from the tree before it to that tree with
+ * its own step applied and the taken paths set to their targets.
+ */
+async function rewriteBodies(project, queue, start, takes, adopted) {
+    const engine = project.paths.engine;
+    const bodies = new Map();
+    let tree = start;
+    for (const patch of queue.patches) {
+        const outcome = await applyToTree(engine, tree, patch);
+        if (!outcome.applied) {
+            throw queueError('re-export-overlap', `${patch.filename} would no longer apply after the edits before it: ${outcome.message}`, `Re-export ${patch.filename} as well.`);
+        }
+        const taken = [...takes.takers].filter(([, taker]) => taker === patch).map(([path]) => path);
+        if (taken.length === 0) {
+            tree = outcome.tree;
+            continue;
+        }
+        const after = await writeTree(engine, taken.map((path) => {
+            const state = takes.targets.get(path) ?? null;
+            return state === null
+                ? { path, remove: true }
+                : { path, oid: state.oid, mode: state.mode };
+        }), outcome.tree);
+        const files = [...new Set([...patch.files, ...(adopted.get(patch.name) ?? [])])].sort();
+        const { body } = await regeneratePatchBody(engine, { before: tree, after, paths: files });
+        if (body.length === 0) {
+            throw queueError('re-export-empty', `${patch.filename} would be left with no change: the engine holds none of its edits.`, 'Delete or retire it ("fireforge patch delete|retire"), or run "fireforge import" if the engine lost them.');
+        }
+        bodies.set(patch.name, body);
+        tree = after;
+    }
+    const result = await statesIn(engine, tree, [...takes.expected.keys()]);
+    const off = [...takes.expected].filter(([path, state]) => !sameState(result.get(path), state));
+    if (off.length > 0) {
+        throw queueError('re-export-mismatch', `The rewritten queue would not reproduce the engine in ${off.map(([path]) => path).join(', ')}.`);
+    }
+    return bodies;
+}
+/**
+ * Rewrites patches from what the engine holds now, so their edits since the
+ * last export are recorded (see the module comment for how an edit to a
+ * file several patches change is placed). With `scan`, unowned edits in the
+ * selected patches' directories are adopted. Metadata is kept; `stamp`
+ * restamps the selected patches with the project's pin.
+ *
+ * The caller holds the engine lock (shared for a dry run).
+ *
+ * @param project - A patch-mode project with an engine
+ * @param options - See {@link ReExportOptions}
+ * @throws `re-export-overlap`, `re-export-empty` or `queue-does-not-apply` (exit code 6)
+ */
+export async function reExport(project, options) {
+    const named = options.patches ?? [];
+    if ((options.all === true) === named.length > 0) {
+        throw usage('Name the patches to re-export, or re-export every patch with "all".');
+    }
+    await requireNoSession(project, 'the re-export');
+    const queue = await loadQueue(project);
+    const selected = options.all === true ? [...queue.patches] : selectPatches(queue, named);
+    const projection = await projectQueue(project, queue);
+    requireApplies(projection);
+    const adopted = options.scan === true
+        ? await adoptions(project, projection, selected)
+        : new Map();
+    const candidates = new Map();
+    for (const patch of selected)
+        for (const path of patch.files)
+            candidates.set(path, patch);
+    for (const patch of selected) {
+        for (const path of adopted.get(patch.name) ?? [])
+            candidates.set(path, patch);
+    }
+    const engine = project.paths.engine;
+    const paths = [...new Set([...projection.paths, ...candidates.keys()])].sort();
+    const start = await sparseTree(engine, projection.base, paths);
+    const takes = await assignEdits(project, queue, { projection, start, paths }, { candidates, selected });
+    const bodies = await rewriteBodies(project, queue, start, takes, adopted);
+    const stamp = stampOf(project);
+    const done = await commit(project, 'the re-export', options.dryRun === true, (draft) => selected.map((patch) => {
+        const row = draft.patches.find((candidate) => candidate.name === patch.name);
+        const body = bodies.get(patch.name) ?? patch.body;
+        const stamped = options.stamp === true && !sameStamp(patch.firefox, stamp);
+        if (row !== undefined) {
+            row.body = body;
+            if (stamped)
+                row.firefox = stamp;
+        }
+        const files = new Set(affectedPaths(parsePatch(body)));
+        return {
+            patch: patch.filename,
+            status: body.equals(patch.body) ? 'unchanged' : 'rewritten',
+            adopted: (adopted.get(patch.name) ?? []).filter((path) => files.has(path)),
+            dropped: patch.files.filter((path) => !files.has(path)),
+            stamped,
+        };
+    }));
+    return { patches: done.result, ...(done.changes === undefined ? {} : { changes: done.changes }) };
+}

package/dist/src/queue/changes.js

@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * The patch queue as the owned-change model (`project/changes.ts`).
+ *
+ * Two change sets describe a patch-mode project:
+ *
+ *  - {@link queueChanges}: the stored queue. One group per patch, in queue
+ *    order; one step per patch per path it changes, relative to what the
+ *    earlier patches left. Rules about a patch's own work read this
+ *    (`lint --per-patch`, size, waivers).
+ *  - {@link engineChanges}: what the engine holds now, relative to HEAD. One
+ *    step per changed path. A path the queue touches belongs to the first
+ *    patch that touches it; an edit to any other path has no group, which is
+ *    how work not yet exported appears. Every change carries `meta.state`,
+ *    its {@link EngineState}, so a rule or report can tell exported work from
+ *    edits not yet in a patch. Rules about what the engine ends up holding
+ *    read this (`lint` by default).
+ *
+ * Both share the queue's groups, so tier and waivers apply either way.
+ */
+import { formatPatch } from '../diff/index.js';
+import { diffTrees, readBlobs, writeTree } from '../git/index.js';
+import { ExitCode, FireForgeError } from '../kernel/errors.js';
+import { createChangeSet, textContent, } from '../project/index.js';
+import { statesIn } from './apply.js';
+import { classifyEngine, engineStates, projectQueue, sameState, } from './baseline.js';
+import { loadQueue, sectionsFor } from './queue.js';
+/**
+ * Reads blobs on demand, batching the requests made in one turn of the event
+ * loop into one `git cat-file --batch`.
+ */
+function blobReader(repo) {
+    let pending;
+    const flush = async (batch) => {
+        try {
+            const blobs = await readBlobs(repo, [...batch.keys()]);
+            for (const [oid, waiters] of batch) {
+                const bytes = blobs.get(oid);
+                for (const waiter of waiters) {
+                    if (bytes === undefined)
+                        waiter.reject(new FireForgeError('queue-blob-missing', `Blob ${oid} is missing.`));
+                    else
+                        waiter.resolve(bytes);
+                }
+            }
+        }
+        catch (error) {
+            for (const waiters of batch.values())
+                for (const waiter of waiters)
+                    waiter.reject(error);
+        }
+    };
+    return (oid) => new Promise((resolve, reject) => {
+        if (pending === undefined) {
+            const batch = new Map();
+            pending = batch;
+            queueMicrotask(() => {
+                pending = undefined;
+                void flush(batch);
+            });
+        }
+        pending.set(oid, [...(pending.get(oid) ?? []), { resolve, reject }]);
+    });
+}
+/** The change model's mode for a git file mode. */
+function changeMode(mode) {
+    return mode === '100755' || mode === '120000' ? mode : '100644';
+}
+/** The group a patch forms, with the facts rules read. */
+function groupOf(patch) {
+    const dependencies = (patch.stagedDependencies ?? []).map(({ file, creates }) => ({
+        file,
+        creates,
+    }));
+    const meta = {
+        name: patch.name,
+        order: patch.order,
+        category: patch.category,
+        description: patch.description,
+        firefox: patch.firefox,
+        ...(dependencies.length === 0 ? {} : { stagedDependencies: dependencies }),
+    };
+    return {
+        id: patch.filename,
+        ...(patch.tier === undefined ? {} : { tier: patch.tier }),
+        ...(patch.lintIgnore === undefined || patch.lintIgnore.length === 0
+            ? {}
+            : { lintIgnore: patch.lintIgnore }),
+        meta,
+    };
+}
+function groupsOf(queue) {
+    return queue.patches.map(groupOf);
+}
+/** One change from two states; undefined when they are equal. */
+function changeOf(input, read) {
+    const { path, before, after, binary, meta } = input;
+    const base = { path, binary, ...(input.group === undefined ? {} : { group: input.group }), meta };
+    if (before === null && after !== null) {
+        return { ...base, kind: 'create', after: () => read(after.oid), mode: changeMode(after.mode) };
+    }
+    if (before !== null && after === null) {
+        return {
+            ...base,
+            kind: 'delete',
+            before: () => read(before.oid),
+            previousMode: changeMode(before.mode),
+        };
+    }
+    if (before === null || after === null || sameState(before, after))
+        return undefined;
+    return {
+        ...base,
+        kind: 'modify',
+        before: () => read(before.oid),
+        after: () => read(after.oid),
+        previousMode: changeMode(before.mode),
+        mode: changeMode(after.mode),
+    };
+}
+/** The diff of any change, from its content: two one-file trees, diffed in the pinned format. */
+async function diffOfContent(repo, change) {
+    const before = change.kind === 'create'
+        ? []
+        : [{ path: change.path, content: await change.before(), mode: change.previousMode }];
+    const after = change.kind === 'delete'
+        ? []
+        : [{ path: change.path, content: await change.after(), mode: change.mode }];
+    const [from, to] = [await writeTree(repo, before), await writeTree(repo, after)];
+    return (await diffTrees(repo, from, to)).toString('utf8');
+}
+function isBinarySection(patch, path) {
+    return sectionsFor(patch, path).some((file) => file.binary !== undefined || file.encoding === 'latin1');
+}
+/**
+ * Refuses a projection that stops before the end of the queue.
+ *
+ * @param projection - The queue replayed onto the engine's HEAD
+ * @throws `queue-does-not-apply` (exit code 6)
+ */
+export function requireApplies(projection) {
+    const failure = projection.failure;
+    if (failure === undefined)
+        return;
+    throw new FireForgeError('queue-does-not-apply', `The patch queue does not apply to the engine from ${failure.patch} on: ${failure.message}`, {
+        exitCode: ExitCode.PATCH_ERROR,
+        hint: 'Run "fireforge import" to see the conflict and resolve it, or "fireforge rebase" after a pin change.',
+    });
+}
+/**
+ * The stored queue as a change set: one group per patch, one step per patch
+ * per path it changes. Content is read from the engine's object store.
+ *
+ * @param project - A patch-mode project with an engine
+ * @param draft - A queue to judge instead of the stored one (see `queueOfDraft`)
+ * @throws `queue-does-not-apply` (exit code 6) when the queue does not replay onto the engine's HEAD
+ */
+export async function queueChanges(project, draft) {
+    const engine = project.paths.engine;
+    const queue = draft ?? (await loadQueue(project));
+    const projection = await projectQueue(project, queue, { cache: draft === undefined });
+    requireApplies(projection);
+    const read = blobReader(engine);
+    const sections = new Map();
+    const changes = [];
+    const current = new Map(projection.paths.map((path) => [path, projection.history(path)[0]?.state ?? null]));
+    for (const [index, step] of projection.steps.entries()) {
+        const patch = queue.patches[index];
+        if (patch === undefined)
+            continue;
+        for (const { path, state } of step.changes) {
+            const change = changeOf({
+                path,
+                before: current.get(path) ?? null,
+                after: state,
+                binary: isBinarySection(patch, path),
+                group: patch.filename,
+                meta: {},
+            }, read);
+            current.set(path, state);
+            if (change === undefined)
+                continue;
+            const files = sectionsFor(patch, path);
+            sections.set(change, formatPatch({ ...patch.diff, preamble: [], files, finalNewline: true }).toString(patch.diff.encoding));
+            changes.push(change);
+        }
+    }
+    return createChangeSet({
+        groups: groupsOf(queue),
+        changes,
+        diff: async (change) => sections.get(change) ?? diffOfContent(engine, change),
+    });
+}
+/**
+ * What the engine holds now, relative to HEAD, as a change set (see the
+ * module comment). Edits not yet exported are the changes without a group,
+ * and the queue files' edits carry `meta.state: "modified"`.
+ *
+ * @param project - A patch-mode project with an engine
+ */
+export async function engineChanges(project) {
+    const engine = project.paths.engine;
+    const queue = await loadQueue(project);
+    const projection = await projectQueue(project, queue);
+    const classified = await classifyEngine(project, projection);
+    const paths = classified.map((entry) => entry.path);
+    const now = await engineStates(engine, projection.start, paths);
+    const head = await statesIn(engine, projection.base, paths);
+    const differing = classified.filter((entry) => !sameState(now.get(entry.path), head.get(entry.path)));
+    const blobs = await readBlobs(engine, differing.flatMap((entry) => [now.get(entry.path), head.get(entry.path)].flatMap((state) => state == null ? [] : [state.oid])));
+    const isText = (state) => {
+        const bytes = state == null ? undefined : blobs.get(state.oid);
+        return bytes === undefined || textContent(bytes) !== undefined;
+    };
+    const read = blobReader(engine);
+    const changes = differing.flatMap((entry) => {
+        const before = head.get(entry.path) ?? null;
+        const after = now.get(entry.path) ?? null;
+        const change = changeOf({
+            path: entry.path,
+            before,
+            after,
+            binary: !isText(before) || !isText(after),
+            ...(entry.owners[0] === undefined ? {} : { group: entry.owners[0] }),
+            meta: { state: entry.state },
+        }, read);
+        return change === undefined ? [] : [change];
+    });
+    return createChangeSet({
+        groups: groupsOf(queue),
+        changes,
+        diff: (change) => diffOfContent(engine, change),
+    });
+}

package/dist/src/queue/index.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Patch mode: the patch queue in `patches/` and the engine it applies to.
+ *
+ * - The manifest (`manifest.ts`) is the one source of truth for the queue's
+ *   patches, their order and metadata; filenames, categories and touched
+ *   files are derived.
+ * - Every change to the queue is one transaction ({@link mutateQueue}).
+ * - Every patch application goes through `apply.ts`: index-only replays
+ *   onto trees, with the reduced-context ladder and new-file replacement as
+ *   options, plus the working-tree apply that leaves `.rej` files.
+ * - The baseline (`baseline.ts`) is what the engine holds with the queue
+ *   applied, and how the engine compares with it. Every change to engine
+ *   files is one transaction on the engine journal.
+ * - `import` and `rebase` are one resumable session (`session.ts`).
+ * - `export` and `re-export` capture engine edits (`capture.ts`); the
+ *   queue operations (`operations.ts`) rename, reorder, split, merge,
+ *   remove and annotate patches, and those that only move work around
+ *   prove the queue still produces the same tree.
+ * - Where a patch goes, and the ordering half of `patchPolicy`, is
+ *   `placement.ts`.
+ * - Every patch body is produced by {@link regeneratePatchBody}.
+ *
+ * Commands that change the engine or the queue hold the engine lock
+ * exclusively (`withEngineLock` of the engine module); the functions here assume it.
+ */
+import { ExitCode } from '../kernel/errors.js';
+import { queueError } from './queue.js';
+export { replayQueue } from './apply.js';
+export { regeneratePatchBody } from './baseline.js';
+export { exportPatch, reExport } from './capture.js';
+export { engineChanges, queueChanges } from './changes.js';
+export {} from './manifest.js';
+export { compactQueue, deletePatch, moveFiles, renamePatch, reorderPatch, retirePatch, setPatchMeta, splitPatch, stagedDependencyOf, } from './operations.js';
+export {} from './placement.js';
+export { mutateQueue, readQueue, writeQueue } from './queue.js';
+export { discard, enginePaths, resetEngine } from './restore.js';
+export { importQueue, rebaseQueue, resolvePatchFromEngine } from './session.js';
+export { queueStatus, verifyQueue } from './status.js';
+/**
+ * The project as a patch-mode project, for the commands only patch mode has.
+ *
+ * @param project - A loaded project
+ * @throws `patch-mode-required` (exit code 8) for a source-mode project
+ */
+export function requirePatchMode(project) {
+    if (project.mode === 'patches')
+        return project;
+    throw queueError('patch-mode-required', 'This command works on a patch-mode project only.', 'A source-mode project keeps its owned files under the source root; edit them there.', ExitCode.INVALID_ARGUMENT);
+}