@vibe-agent-toolkit/utils 0.2.0-rc.11 → 0.2.0-rc.12

package/dist/tree-change/apply-decisions.js

@@ -0,0 +1,139 @@
+/**
+ * The decisions of the apply half of the tree-change primitive, and of its file helpers, that touch
+ * no filesystem: each is handed what was read and answers what to do. `apply.ts` and `files.ts` are
+ * the halves that make the calls — and hold nothing else to decide.
+ */
+import { pathsActedOn } from '../errors/errno-table.js';
+import { FsFaultError } from '../errors/fs-fault.js';
+import { VatError } from '../errors/vat-error.js';
+import { relativeEscapesRoot, safePath } from '../path-core.js';
+/** {@link tempDirRefusal}: a directory to dispose of that is not strictly under the temp directory — a defect in the caller. */
+export const TEMP_DIR_OUTSIDE_TMPDIR_CODE = 'TEMP_DIR_OUTSIDE_TMPDIR';
+/** A replaced entry, parked once the new one was live, that could not be removed. */
+export const TREE_CLEANUP_INCOMPLETE_CODE = 'TREE_CLEANUP_INCOMPLETE';
+/**
+ * Whether a `write` fill's failure is the DESTINATION's: a path the failing call acted on
+ * ({@link pathsActedOn} — the one reading of an errno's two paths, so never a symlink's target
+ * text) is under the staged tree, all the callback may write. Anything else, an input the
+ * callback read (a sibling of the destination included), is not: it is rethrown as it was, for
+ * the verb's boundary to classify.
+ *
+ * @param facts - The errno, the call and the paths the OS named
+ * @param sideOf - The side a path is on, with the staged tree as the only `destination`
+ */
+export function fillFaultIsDestinations(facts, sideOf) {
+    return pathsActedOn(facts).some((named) => sideOf(named) === 'destination');
+}
+/**
+ * Whether a destination is no longer what the plan decided on — staging (a whole copy, a whole
+ * build) runs between the plan and the first rename, and anything can write there meanwhile:
+ * - another KIND of entry than the plan saw (nothing where it parks; something where it creates);
+ * - a directory a `must-be-free` change took because it was EMPTY, and now is not.
+ *
+ * @returns What changed, for the refusal's wording; `undefined` when it is as planned
+ */
+export function changedSincePlan(planned, now) {
+    if (now.kind !== planned.existing) {
+        return `it was ${describeKind(planned.existing)} when the change was planned and is ${describeKind(now.kind)} now`;
+    }
+    const tookAsFree = planned.change.ownership.kind === 'must-be-free' && planned.existing === 'directory';
+    return tookAsFree && !now.emptyDirectory ? 'it was an empty directory when the change was planned and holds entries now' : undefined;
+}
+const describeKind = (kind) => (kind === 'absent' ? 'absent' : `a ${kind}`);
+/**
+ * The refusal of a destination that changed under the apply: the table's `occupied` destination
+ * fault (something appeared while the command wrote), naming it and what changed. The entry is
+ * left exactly as it was found.
+ */
+export function changedDestinationFault(planned, what) {
+    const { dest, label } = planned.change;
+    return new FsFaultError({
+        side: 'destination',
+        faultClass: 'occupied',
+        errno: 'EEXIST',
+        path: dest,
+        origin: 'argument',
+        action: `put ${label} in place: something else changed the destination while it was being prepared (${what}); it was left as found`,
+        cause: undefined,
+    });
+}
+/**
+ * What a finalize does with the parked entries it could not remove: a REMOVE's is thrown (removal
+ * was the job; the first one, with every other recorded beside it), a replace's is a warning — the
+ * new tree is live.
+ *
+ * @param refused - Each parked entry that would not go, with the op of its change
+ * @returns The index of the one to throw, or `undefined` when every one is a warning
+ */
+export function finalizeThrows(refused) {
+    const index = refused.findIndex((each) => each.op === 'remove');
+    return index === -1 ? undefined : index;
+}
+/**
+ * Where the removal of the parents a create made goes next: `dir` is removed only while it is
+ * `top` (the first directory `mkdir` made) or under it, and the walk stops once `top` itself went.
+ *
+ * @param top - The first directory staging made, canonical
+ * @param dir - The directory about to be removed, canonical
+ * @returns `stop` (outside what staging made: never touched), `last` (it is `top`), or `continue` (go on to its parent)
+ */
+export function madeParentStep(top, dir) {
+    const below = safePath.relative(top, dir);
+    if (relativeEscapesRoot(below))
+        return 'stop';
+    return below === '' ? 'last' : 'continue';
+}
+/**
+ * The refusal of a file VAT writes into a tree it is building, where what was copied into that tree
+ * already holds an entry on the way — a file or a link at the file's own name, or a link (or a file)
+ * where one of its directories goes. Whatever is there came with the tree, so it is the SOURCE's
+ * layout (origin `content`), never something to write over or through.
+ *
+ * @param entry - The entry in the way, as a path
+ * @param writing - What VAT was writing, for the message: `VAT's marketplace marker`
+ * @param cause - The errno that reported it, when one did
+ */
+export function entryInTheWayFault(entry, writing, cause) {
+    return new FsFaultError({
+        side: 'source',
+        faultClass: 'occupied',
+        errno: 'EEXIST',
+        path: entry,
+        origin: 'content',
+        action: `write ${writing}: the tree it goes into already holds an entry there, which VAT never writes over or through`,
+        cause,
+    });
+}
+/** A rename is tried this many times under win32 when the OS reports contention; the waits between are 50, 100, 200, 400, 800 ms. */
+export const RENAME_TRIES = 6;
+const FIRST_BACKOFF_MS = 50;
+/**
+ * Whether a refused rename is tried again, and after how long: only under win32, only for
+ * contention (a scanner, an indexer, a handle still closing), and only while tries are left.
+ *
+ * @param platform - `process.platform`
+ * @param attempt - The 0-based try that just failed
+ * @param contention - Whether the errno is one a rename race raises there
+ * @returns The wait in milliseconds before the next try, or `undefined` when the refusal is final
+ */
+export function renameRetryDelay(platform, attempt, contention) {
+    if (platform !== 'win32' || !contention || attempt + 1 >= RENAME_TRIES)
+        return undefined;
+    return FIRST_BACKOFF_MS * 2 ** attempt;
+}
+/**
+ * The refusal — a defect in the caller — of a directory to dispose of that is not strictly under
+ * the temp directory: the disposal makes a read-only tree writable before it deletes it, so a wrong
+ * argument (an empty string, a project directory) must be refused before anything is touched.
+ *
+ * @param dir - The directory handed to the disposal
+ * @param tmp - The temp directory
+ * @param containment - Where `dir` is against `tmp`, as `isUnderRoot` judged it
+ * @returns The error to throw, or `undefined` when `dir` may be disposed of
+ */
+export function tempDirRefusal(dir, tmp, containment) {
+    if (containment !== 'outside')
+        return undefined;
+    return new VatError(TEMP_DIR_OUTSIDE_TMPDIR_CODE, `Refusing to dispose of ${dir}: it is not inside the temporary directory ${tmp}`);
+}
+//# sourceMappingURL=apply-decisions.js.map

package/dist/tree-change/apply-decisions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-decisions.js","sourceRoot":"","sources":["../../src/tree-change/apply-decisions.ts"],"names":[],"mappings":"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"}

package/dist/tree-change/apply.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The apply half of the tree-change primitive: carry out a {@link TreePlan} as one
+ * transaction, in a fixed order —
+ *
+ * 1. **Stage** every new entry beside its destination, on the same filesystem (so
+ *    a swap never crosses devices): a `mkdtemp` directory filled by `copyTree`, a
+ *    fresh directory (plain `mkdir`, the caller's mode) filled by the `write`
+ *    callback, or a fresh name for a file or a link. A failure removes
+ *    every staged entry, and every parent directory a create made; no destination
+ *    has changed.
+ * 2. **Park** every entry being replaced or removed: `rename(dest, <staged>.previous)`.
+ *    Every park happens before any swap, so a name is free before anything lands
+ *    on it — on a case-folding filesystem `Old` and `old` are one name. Each
+ *    destination is examined again first: one that is no longer what the plan decided
+ *    on (another writer filled a directory the plan took as empty, or put an entry
+ *    where it found none) is a `destination` fault, class `occupied`, and is left as
+ *    found — the plan is rolled back.
+ * 3. **Swap** every staged entry in: `rename(staged, dest)`.
+ * 4. **`afterSwap()`** — the caller's own writes that must agree with the tree
+ *    (a registry). A throw rolls back every swap.
+ * 5. **Rollback**, when 2–4 throw: in reverse, each swapped entry is moved off its
+ *    destination and its parked entry renamed back, then the parents a create made
+ *    are removed. A parked entry is NEVER deleted on a failure path: if one cannot
+ *    be put back — or a create's new entry cannot be moved off — the error is
+ *    {@link TreeRollbackIncompleteError}, naming each.
+ * 6. **Finalize**: each parked entry is removed, its modes notwithstanding. For a
+ *    replace a refusal is only a warning ({@link TREE_CLEANUP_INCOMPLETE_CODE}): the
+ *    new tree is live. For a remove, removal is the job, so it is a `destination`
+ *    fault naming the parked path — the data is already off the user's path.
+ *
+ * Every rename is {@link renameFileAtomic}'s, retried under win32 on contention.
+ * The primitive's own filesystem faults are classified `destination` (staging sits
+ * beside the user's destination); a `copy` source's read is already classified on
+ * the fill's declared side; a
+ * `write` fill's raw errno is `destination` only when it names a path under the
+ * destination's parent — anything else (an input the callback read) is rethrown
+ * raw, for the verb's boundary to classify.
+ *
+ * A thrown failure is never mutated. What a failure path could not clean up (a
+ * staged entry, a parent, a replaced tree beside a failed remove) is recorded
+ * beside it, off its cause chain: `suppressedFaultsOf(error)`.
+ */
+import { TREE_CLEANUP_INCOMPLETE_CODE } from './apply-decisions.js';
+import { type TreePlan } from './plan.js';
+export { TREE_CLEANUP_INCOMPLETE_CODE } from './apply-decisions.js';
+export interface ApplyOptions {
+    /**
+     * Runs once every swap is done; a throw rolls every change back and is rethrown.
+     * ⚠️ Its own filesystem faults must be classified `destination` (it writes user
+     * state beside the tree): should the rollback then fail, the error becomes
+     * `TREE_ROLLBACK_INCOMPLETE` (`RUN_INCOMPLETE`), which agrees with every
+     * destination row of the refusal table and with no other side's.
+     */
+    readonly afterSwap?: () => Promise<void>;
+}
+/** A finding a successful apply reports: the change is done, something beside it is left. */
+export interface TreeChangeWarning {
+    readonly code: typeof TREE_CLEANUP_INCOMPLETE_CODE;
+    /** The entry left behind. */
+    readonly path: string;
+    readonly message: string;
+}
+export interface ApplyResult {
+    readonly warnings: readonly TreeChangeWarning[];
+}
+/**
+ * Carry out `plan`: stage, park, swap, `afterSwap`, finalize — or roll back so
+ * every destination is exactly as it was.
+ *
+ * @param plan - What `planTreeChanges` decided; `keep` and `subsumed` changes are not touched
+ * @param options - `afterSwap`, run once the new tree is in place
+ * @returns The warnings of a change that is done: a previous tree left beside a replaced one
+ * @throws the first failure, after the rollback and unchanged: an `FsFaultError` (side
+ *   `destination`, or the fill's declared side for a copy source's read), a `write` fill's own error or raw
+ *   errno, or whatever `afterSwap` threw — with what could not be cleaned up in
+ *   `suppressedFaultsOf(error)`; {@link TreeRollbackIncompleteError} (cause: that
+ *   failure) when the rollback could not undo every change; for a `remove` whose
+ *   parked entry cannot be removed, an `FsFaultError` side `destination` naming it
+ */
+export declare function applyTreePlan(plan: TreePlan, options?: ApplyOptions): Promise<ApplyResult>;
+/** What {@link applyTreePlanOrLeftover} finished with: the warnings of a clean apply, or the failure that came after the commit. */
+export interface ApplyOutcome extends ApplyResult {
+    /**
+     * The failure that came once every change was in place (and `afterSwap` had run): a parked entry of
+     * a `remove` the OS would not delete. It cannot be undone and is no refusal of the change — the
+     * change is DONE, every destination as planned — so it is returned, naming what is left (its `path`
+     * the parked entry), for the verb to report beside the work it finished. Absent when the apply finished clean.
+     */
+    readonly leftover?: unknown;
+}
+/**
+ * {@link applyTreePlan}, for a verb that reports a change it finished even when what it parked could
+ * not then be deleted (an uninstall, a clear): a failure before the commit — every swap made and
+ * `afterSwap` run — rolled back and is thrown, as by `applyTreePlan`; one after it is returned as
+ * `leftover`. The commit is the one line between "nothing finished" and "the change is done".
+ */
+export declare function applyTreePlanOrLeftover(plan: TreePlan, options?: ApplyOptions): Promise<ApplyOutcome>;
+//# sourceMappingURL=apply.d.ts.map

package/dist/tree-change/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../src/tree-change/apply.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAcH,OAAO,EAAsG,4BAA4B,EAAE,MAAM,sBAAsB,CAAC;AAIxK,OAAO,EAAgD,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAIxF,OAAO,EAAE,4BAA4B,EAAE,MAAM,sBAAsB,CAAC;AAKpE,MAAM,WAAW,YAAY;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED,6FAA6F;AAC7F,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,4BAA4B,CAAC;IACnD,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACjD;AAiQD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CAE9F;AAED,oIAAoI;AACpI,MAAM,WAAW,YAAa,SAAQ,WAAW;IAC/C;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAa/G"}

package/dist/tree-change/apply.js

@@ -0,0 +1,364 @@
+/**
+ * The apply half of the tree-change primitive: carry out a {@link TreePlan} as one
+ * transaction, in a fixed order —
+ *
+ * 1. **Stage** every new entry beside its destination, on the same filesystem (so
+ *    a swap never crosses devices): a `mkdtemp` directory filled by `copyTree`, a
+ *    fresh directory (plain `mkdir`, the caller's mode) filled by the `write`
+ *    callback, or a fresh name for a file or a link. A failure removes
+ *    every staged entry, and every parent directory a create made; no destination
+ *    has changed.
+ * 2. **Park** every entry being replaced or removed: `rename(dest, <staged>.previous)`.
+ *    Every park happens before any swap, so a name is free before anything lands
+ *    on it — on a case-folding filesystem `Old` and `old` are one name. Each
+ *    destination is examined again first: one that is no longer what the plan decided
+ *    on (another writer filled a directory the plan took as empty, or put an entry
+ *    where it found none) is a `destination` fault, class `occupied`, and is left as
+ *    found — the plan is rolled back.
+ * 3. **Swap** every staged entry in: `rename(staged, dest)`.
+ * 4. **`afterSwap()`** — the caller's own writes that must agree with the tree
+ *    (a registry). A throw rolls back every swap.
+ * 5. **Rollback**, when 2–4 throw: in reverse, each swapped entry is moved off its
+ *    destination and its parked entry renamed back, then the parents a create made
+ *    are removed. A parked entry is NEVER deleted on a failure path: if one cannot
+ *    be put back — or a create's new entry cannot be moved off — the error is
+ *    {@link TreeRollbackIncompleteError}, naming each.
+ * 6. **Finalize**: each parked entry is removed, its modes notwithstanding. For a
+ *    replace a refusal is only a warning ({@link TREE_CLEANUP_INCOMPLETE_CODE}): the
+ *    new tree is live. For a remove, removal is the job, so it is a `destination`
+ *    fault naming the parked path — the data is already off the user's path.
+ *
+ * Every rename is {@link renameFileAtomic}'s, retried under win32 on contention.
+ * The primitive's own filesystem faults are classified `destination` (staging sits
+ * beside the user's destination); a `copy` source's read is already classified on
+ * the fill's declared side; a
+ * `write` fill's raw errno is `destination` only when it names a path under the
+ * destination's parent — anything else (an input the callback read) is rethrown
+ * raw, for the verb's boundary to classify.
+ *
+ * A thrown failure is never mutated. What a failure path could not clean up (a
+ * staged entry, a parent, a replaced tree beside a failed remove) is recorded
+ * beside it, off its cause chain: `suppressedFaultsOf(error)`.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fsFaultOf, isAlreadyExistsError, isOccupiedError } from '../errors/errno-table.js';
+import { fsBoundary } from '../errors/fs-boundary.js';
+import { classifyFsFault, isFsFaultError, withFsFault } from '../errors/fs-fault.js';
+import { recordSuppressedFault } from '../errors/suppressed-faults.js';
+import { isVatError } from '../errors/vat-error.js';
+import { forEachInOrder, mapInOrder } from '../in-order.js';
+import { safePath, toForwardSlash } from '../path-core.js';
+import { withoutWin32Namespace } from '../win32-namespace.js';
+import { changedDestinationFault, changedSincePlan, fillFaultIsDestinations, finalizeThrows, madeParentStep, TREE_CLEANUP_INCOMPLETE_CODE } from './apply-decisions.js';
+import { copyTree } from './copy-tree.js';
+import { removeEntry, renameFileAtomic } from './files.js';
+import { sameEntry } from './identity.js';
+import { destinationNow, isActive } from './plan.js';
+import { TreeRollbackIncompleteError } from './rollback-error.js';
+import { PARKED_SUFFIX, stagingName, stagingPrefix } from './staging-names.js';
+export { TREE_CLEANUP_INCOMPLETE_CODE } from './apply-decisions.js';
+/** Suffix of a swapped-in entry moved back off its destination by a rollback. */
+const DISCARD_SUFFIX = '.discard';
+const destOf = (slot) => slot.planned.change.dest;
+const labelOf = (slot) => slot.planned.change.label;
+const messageOf = (error) => (error instanceof Error ? error.message : String(error));
+/** Run `work` for `slot`, a raw errno classified `destination` with `action`. */
+function onDestination(slot, action, work) {
+    return withFsFault({ side: 'destination', action: `${action} ${labelOf(slot)}`, path: destOf(slot) }, work);
+}
+/**
+ * A `write` fill's failure: a raw errno naming a path under the staged tree — all the
+ * callback may write — is the destination's; anything else, an input the callback read
+ * (a sibling of the destination included), is rethrown as it was, for the verb's
+ * boundary to classify.
+ */
+function writeFillFault(error, slot, staged) {
+    const facts = fsFaultOf(error);
+    if (isVatError(error) || facts === undefined)
+        return error;
+    const ours = fsBoundary({ destination: [staged] });
+    if (!fillFaultIsDestinations(facts, (named) => ours.sideOf(named)))
+        return error;
+    return classifyFsFault(error, { side: 'destination', action: `stage the new ${labelOf(slot)}`, path: destOf(slot) });
+}
+/** The parent of the destination, made when absent; the first directory made is remembered. */
+async function makeParent(slot) {
+    const made = await onDestination(slot, 'make the parent directory of', () => fs.mkdir(path.dirname(destOf(slot)), { recursive: true }));
+    slot.createdParent = made === undefined ? undefined : toForwardSlash(withoutWin32Namespace(made));
+}
+/** How many fresh names a `write` fill tries before an `EEXIST` is the answer (as `mkdtemp` retries its own). */
+const STAGING_NAME_TRIES = 8;
+/** The staged directory beside `dest`: `mkdtemp` for a copy, a plain `mkdir` of a fresh name for a `write` (see {@link stageTree}). */
+async function makeStagedDirectory(dest, from, attempt = 1) {
+    if (from === 'copy')
+        return fs.mkdtemp(stagingPrefix(dest));
+    const name = stagingName(dest);
+    try {
+        await fs.mkdir(name);
+        return name;
+    }
+    catch (error) {
+        // A collision with a leftover of the same random name: draw another, as `mkdtemp` does.
+        if (!isAlreadyExistsError(error) || attempt >= STAGING_NAME_TRIES)
+            throw error;
+        return makeStagedDirectory(dest, from, attempt + 1);
+    }
+}
+/**
+ * Stage a directory tree beside the destination, filled by the copy or the caller's `write`. A copy
+ * stages in a `mkdtemp` directory (the copy gives it its source's mode). A `write` stages in a fresh
+ * name made by a plain `mkdir`, so the tree it becomes gets the mode any directory the caller makes
+ * gets — never a temp directory's 0700 (`dist/skills`, a marketplace). The name is as unique: a
+ * collision is `EEXIST`, never a shared directory.
+ */
+async function stageTree(slot, fill) {
+    const staged = toForwardSlash(await onDestination(slot, 'stage the new', () => makeStagedDirectory(destOf(slot), fill.from)));
+    slot.staged = staged;
+    if (fill.from === 'copy') {
+        await onDestination(slot, 'copy the new', () => copyTree(fill.source, staged, '', { links: fill.links, side: fill.side, onto: 'fresh', ...(fill.filter === undefined ? {} : { filter: fill.filter }) }));
+    }
+    else if (fill.from === 'write') {
+        // `try`/`await`, not `.catch`: a callback that throws synchronously is judged the same way.
+        try {
+            await fill.write(staged);
+        }
+        catch (error) {
+            throw writeFillFault(error, slot, staged);
+        }
+    }
+}
+/** Make the new entry beside the destination. */
+async function stage(slot) {
+    const { change } = slot.planned;
+    if (change.op === 'remove')
+        return;
+    await makeParent(slot);
+    if (change.op === 'replace-file') {
+        const staged = stagingName(change.dest);
+        slot.staged = staged;
+        const { contents } = change;
+        await onDestination(slot, 'stage the new', () => fs.writeFile(staged, typeof contents === 'function' ? contents() : contents, { flag: 'wx' }));
+        return;
+    }
+    if (change.fill.from !== 'link') {
+        await stageTree(slot, change.fill);
+        return;
+    }
+    const staged = stagingName(change.dest);
+    slot.staged = staged;
+    const { target } = change.fill;
+    // `dir`: parity with today's `--dev` lanes, both of which refuse win32 before staging. Should a win32
+    // `--dev` lane ever exist, the repo's precedent is `junction` (dev-tools `link-workspace-packages.ts`),
+    // which needs no symlink privilege.
+    await onDestination(slot, 'stage the link for', () => fs.symlink(target, staged, 'dir'));
+}
+/**
+ * The name `dest` has on disk. On a case-folding filesystem a plan may spell a
+ * destination `plugins/old` while the directory is `plugins/Old`: a rollback must
+ * put it back as `Old`. When the parent lists `dest`'s own name, that is it (two
+ * names one fold apart cannot both exist); otherwise the sibling that is the same
+ * entry, judged by identity, never by comparing names.
+ */
+async function spelledOnDisk(dest) {
+    const parent = path.dirname(dest);
+    const names = await fs.readdir(parent);
+    if (names.includes(toForwardSlash(path.basename(dest))))
+        return dest;
+    const alias = names.find((name) => sameEntry(safePath.join(parent, name), dest) === 'same');
+    return alias === undefined ? dest : safePath.join(parent, alias);
+}
+/**
+ * Refuse a destination that is no longer what the plan decided on (`changedSincePlan`): staging runs
+ * between the plan and the first rename, and a `must-be-free` destination another writer filled
+ * meanwhile must not be parked and deleted, nor a file that appeared at a `create` renamed over.
+ * Asked immediately before the rename it guards; the entry is left exactly as found.
+ */
+function requireAsPlanned(slot) {
+    const changed = changedSincePlan(slot.planned, destinationNow(destOf(slot), slot.planned));
+    if (changed !== undefined)
+        throw changedDestinationFault(slot.planned, changed);
+}
+async function park(slot) {
+    requireAsPlanned(slot);
+    const parked = `${slot.staged ?? stagingName(destOf(slot))}${PARKED_SUFFIX}`;
+    await onDestination(slot, 'move aside the previous', async () => {
+        slot.spelled = await spelledOnDisk(destOf(slot));
+        await renameFileAtomic(destOf(slot), parked);
+    });
+    slot.parked = parked;
+}
+async function swap(slot) {
+    // A destination the plan found absent was never parked: nothing has vouched for it since the plan.
+    if (slot.planned.existing === 'absent')
+        requireAsPlanned(slot);
+    const staged = slot.staged;
+    await onDestination(slot, 'put in place the new', () => renameFileAtomic(staged, destOf(slot)));
+    slot.swapped = true;
+}
+/** Remove `entry`, VAT's own leftover; a refusal is recorded beside `error`, never thrown over it. */
+async function discard(entry, error) {
+    if (entry === undefined)
+        return;
+    try {
+        await removeEntry(entry);
+    }
+    catch (error_) {
+        recordSuppressedFault(error, classifyFsFault(error_, { side: 'destination', action: `remove the staged ${entry}`, path: entry }));
+    }
+}
+/**
+ * Remove, deepest first, the empty parents staging made for `slot`: from the
+ * destination's parent up to the first directory `mkdir` made, never past it — both
+ * in the canonical spelling, bounded by containment, not by comparing strings. A
+ * parent still holding entries (another change's, stranded) is left without a
+ * word; one the OS refuses is recorded beside `error`.
+ */
+function removeMadeParents(slot, error) {
+    if (slot.createdParent === undefined)
+        return Promise.resolve();
+    const top = safePath.resolve(slot.createdParent);
+    const removeFrom = (dir) => {
+        const step = madeParentStep(top, dir);
+        if (step === 'stop')
+            return Promise.resolve();
+        return fs.rmdir(dir).then(() => (step === 'last' ? undefined : removeFrom(safePath.resolve(path.dirname(dir)))), (error_) => {
+            if (isOccupiedError(error_))
+                return;
+            recordSuppressedFault(error, classifyFsFault(error_, { side: 'destination', action: 'remove the directory made for', path: dir }));
+        });
+    };
+    return removeFrom(safePath.resolve(path.dirname(destOf(slot))));
+}
+/** Move a swapped-in entry back off its destination, to be discarded. What could not move is returned. */
+async function unswap(slot) {
+    const discarded = `${slot.staged}${DISCARD_SUFFIX}`;
+    try {
+        await renameFileAtomic(destOf(slot), discarded);
+        slot.staged = discarded;
+        return undefined;
+    }
+    catch (error_) {
+        return { dest: destOf(slot), parked: slot.parked, why: `the new content could not be moved off it: ${messageOf(error_)}` };
+    }
+}
+/** Undo one slot: the new entry off the destination, the previous one back on. What could not be undone is returned. */
+async function restore(slot, error) {
+    const stuck = slot.swapped ? await unswap(slot) : undefined;
+    if (stuck !== undefined)
+        return stuck;
+    await discard(slot.staged, error);
+    if (slot.parked === undefined)
+        return undefined;
+    try {
+        await renameFileAtomic(slot.parked, slot.spelled ?? destOf(slot));
+        return undefined;
+    }
+    catch (error_) {
+        return { dest: destOf(slot), parked: slot.parked, why: messageOf(error_) };
+    }
+}
+/** Remove the parents staging made, for every slot fully undone (newest first). */
+function removeAllMadeParents(slots, error, stranded = []) {
+    return forEachInOrder(slots.toReversed().filter((slot) => !stranded.includes(slot)), (slot) => removeMadeParents(slot, error));
+}
+/** Undo every slot, newest first; the error to throw is `error`, or a rollback-incomplete one carrying it. */
+async function rolledBack(slots, error) {
+    const outcomes = await mapInOrder(slots.toReversed(), async (slot) => ({ slot, stranded: await restore(slot, error) }));
+    const stuck = outcomes.filter((o) => o.stranded !== undefined);
+    await removeAllMadeParents(slots, error, stuck.map((o) => o.slot));
+    return stuck.length === 0 ? error : new TreeRollbackIncompleteError(error, stuck.map((o) => o.stranded));
+}
+/** Remove a parked entry: `undefined` when gone, else the classified fault naming the parked path. */
+async function removeParked(slot) {
+    const parked = slot.parked;
+    try {
+        await removeEntry(parked);
+        return undefined;
+    }
+    catch (error_) {
+        const fault = classifyFsFault(error_, { side: 'destination', action: `remove the previous ${labelOf(slot)}, parked at ${parked}`, path: parked });
+        if (!isFsFaultError(fault))
+            throw error_;
+        return fault;
+    }
+}
+/**
+ * Remove every parked entry. A replace's refusal is a warning; a remove's is thrown
+ * (after every removal was tried), with every other refusal recorded beside it.
+ */
+async function finalize(slots) {
+    const parked = slots.filter((slot) => slot.parked !== undefined);
+    const outcomes = (await mapInOrder(parked, async (slot) => ({ slot, fault: await removeParked(slot) }))).filter((o) => o.fault !== undefined);
+    const thrownAt = finalizeThrows(outcomes.map((o) => ({ op: o.slot.planned.change.op })));
+    const thrown = thrownAt === undefined ? undefined : outcomes[thrownAt];
+    if (thrown !== undefined) {
+        for (const other of outcomes)
+            if (other !== thrown)
+                recordSuppressedFault(thrown.fault, other.fault);
+        throw thrown.fault;
+    }
+    return {
+        warnings: outcomes.map(({ slot, fault }) => ({ code: TREE_CLEANUP_INCOMPLETE_CODE, path: slot.parked, message: messageOf(fault) })),
+    };
+}
+/**
+ * Carry out `plan`: stage, park, swap, `afterSwap`, finalize — or roll back so
+ * every destination is exactly as it was.
+ *
+ * @param plan - What `planTreeChanges` decided; `keep` and `subsumed` changes are not touched
+ * @param options - `afterSwap`, run once the new tree is in place
+ * @returns The warnings of a change that is done: a previous tree left beside a replaced one
+ * @throws the first failure, after the rollback and unchanged: an `FsFaultError` (side
+ *   `destination`, or the fill's declared side for a copy source's read), a `write` fill's own error or raw
+ *   errno, or whatever `afterSwap` threw — with what could not be cleaned up in
+ *   `suppressedFaultsOf(error)`; {@link TreeRollbackIncompleteError} (cause: that
+ *   failure) when the rollback could not undo every change; for a `remove` whose
+ *   parked entry cannot be removed, an `FsFaultError` side `destination` naming it
+ */
+export function applyTreePlan(plan, options = {}) {
+    return applyStages(plan, options);
+}
+/**
+ * {@link applyTreePlan}, for a verb that reports a change it finished even when what it parked could
+ * not then be deleted (an uninstall, a clear): a failure before the commit — every swap made and
+ * `afterSwap` run — rolled back and is thrown, as by `applyTreePlan`; one after it is returned as
+ * `leftover`. The commit is the one line between "nothing finished" and "the change is done".
+ */
+export async function applyTreePlanOrLeftover(plan, options = {}) {
+    let committed = false;
+    try {
+        return await applyStages(plan, {
+            afterSwap: async () => {
+                await options.afterSwap?.();
+                committed = true;
+            },
+        });
+    }
+    catch (error) {
+        if (!committed)
+            throw error;
+        return { warnings: [], leftover: error };
+    }
+}
+async function applyStages(plan, options) {
+    const slots = plan.changes.filter(isActive).map((planned) => ({ planned, createdParent: undefined, staged: undefined, parked: undefined, spelled: undefined, swapped: false }));
+    try {
+        await forEachInOrder(slots, stage);
+    }
+    catch (error) {
+        await forEachInOrder(slots, (slot) => discard(slot.staged, error));
+        await removeAllMadeParents(slots, error);
+        throw error;
+    }
+    try {
+        await forEachInOrder(slots.filter((slot) => slot.planned.existing !== 'absent'), park);
+        await forEachInOrder(slots.filter((slot) => slot.staged !== undefined), swap);
+        await options.afterSwap?.();
+    }
+    catch (error) {
+        throw await rolledBack(slots, error);
+    }
+    return finalize(slots);
+}
+//# sourceMappingURL=apply.js.map

package/dist/tree-change/apply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.js","sourceRoot":"","sources":["../../src/tree-change/apply.ts"],"names":[],"mappings":"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"}