@dynamicagents/plugins 0.13.0 → 0.14.0

package/dist/workspace/deps-snapshot.js

@@ -0,0 +1,424 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { DEPS_ROOTS_COMMAND, parseDepsRoots } from "./container-deps.js";
+/**
+ * A snapshot of a container that has just installed, so the next container
+ * starts from it instead of installing again.
+ *
+ * Dependency trees live on the container's disk (see `./container-deps.ts`), so
+ * a new container reinstalls before its first command can use them — what that
+ * costs is in `./install-job.ts`. A Containers snapshot is that disk: restored,
+ * the trees are back. It holds nothing else worth having — the checkout is this
+ * object's storage, mounted over FUSE, and a mount is not in a snapshot.
+ *
+ * ## When a snapshot is restored
+ *
+ * Only into a start that would otherwise install the same thing, which takes
+ * all of:
+ *
+ * - **The image it was taken on.** A snapshot replaces the image rather than
+ *   layering on it, so one from before a deploy boots the old image's
+ *   `computerd`, which nothing downstream catches.
+ * - **The same checkout and install fingerprint**, so the marker it carries is
+ *   the one an install would write now.
+ * - **Every package root's inputs unchanged.** A bootstrap installs roots the
+ *   fingerprint does not cover — a submodule's lockfile — and a restore brings
+ *   all of them back at once.
+ * - **The same set of package roots.** A root added since — a new submodule —
+ *   has no tree in the snapshot, and restoring it would skip the install that
+ *   gives it one: see {@link packageRootSet}.
+ *
+ * What came up is then checked, not assumed: the setup mounts the restored trees
+ * and reads the marker, and only a match is adopted as installed. Anything else —
+ * an expired snapshot, which the platform reports as a failed start, after which
+ * the backend's restart takes the image — drops the record, and the install runs
+ * and snapshots again.
+ *
+ * ## Taken of the tree it was asked for, and nothing since
+ *
+ * An install asks for its snapshot in the same write as its verdict, so a stop
+ * that comes before the wake still sees the request. Snapshots run one at a
+ * time, and one is recorded only if the install record still names the tree it
+ * was taken of: a reinstall empties the tree before it rebuilds it, and a
+ * snapshot taken across that is of neither.
+ *
+ * ## The record outlives the container, and the snapshot outlives the record
+ *
+ * Unlike the tree record, which goes with its container, this is what a later
+ * container starts from. The platform keeps a snapshot for thirty days from its
+ * last restore and offers no way to delete one, so a dropped record leaves its
+ * snapshot to expire.
+ */
+/** Where the record lives. */
+const RECORD_KEY = "deps:snapshot";
+/** The tree a finished install asked to have snapshotted, until it is. */
+const DUE_KEY = "deps:snapshot-due";
+/**
+ * Which package roots a checkout has, as one digest: every directory under
+ * `dir` with a `package.json`, and the submodules `.gitmodules` declares — one a
+ * bootstrap clones in the container has no `package.json` here until then.
+ */
+export async function packageRootSet(fs, dir) {
+    const found = await fs
+        .find(dir, "**/package.json", { exclude: ["**/.git", "**/node_modules"] })
+        .catch((err) => {
+        if (err?.code === "ENOENT")
+            return [];
+        throw err;
+    });
+    const gitmodules = await fs
+        .readFile(`${dir}/.gitmodules`, "utf8")
+        .catch(() => "");
+    const input = [
+        ...found.map((entry) => entry.path).sort(),
+        "\0.gitmodules",
+        gitmodules
+    ].join("\n");
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
+    return [...new Uint8Array(digest)]
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+/**
+ * The launch options `ContainerBackend` spreads into every start, whose
+ * `containerSnapshot` is read at that moment.
+ *
+ * A getter, because the backend keeps this object for its lifetime and builds
+ * each start from it — the initial one and every restart after a failed health
+ * check — and only the first of those may restore: a restart is the backend
+ * recovering from a start that did not come up, which an expired snapshot is.
+ */
+function launchOptions(take) {
+    return {
+        get containerSnapshot() {
+            return take();
+        }
+    };
+}
+export class DepsSnapshot {
+    deps;
+    /** Restore with the next start, once. */
+    #pending;
+    /** Whether a start has taken {@link #pending} since it was armed. */
+    #launched = false;
+    #taking;
+    launch = launchOptions(() => {
+        const pending = this.#pending;
+        if (!pending)
+            return undefined;
+        this.#pending = undefined;
+        this.#launched = true;
+        return pending;
+    });
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Restore with the next start if the record fits it, and say which record.
+     *
+     * `expected` is a thunk because it reads the checkout, and a workspace with no
+     * snapshot or one from another image should not pay for that.
+     */
+    async arm(expected) {
+        this.disarm();
+        const record = await this.get();
+        if (!record)
+            return undefined;
+        const refused = await this.#refusal(record, expected);
+        if (refused) {
+            console.info(`[${this.deps.tag()}] not restoring the dependency snapshot`, {
+                id: this.deps.id(),
+                snapshot: record.id,
+                reason: refused
+            });
+            return undefined;
+        }
+        this.#pending = { id: record.id };
+        console.info(`[${this.deps.tag()}] restoring the dependency snapshot`, {
+            id: this.deps.id(),
+            snapshot: record.id,
+            bytes: record.size,
+            dir: record.dir
+        });
+        return record;
+    }
+    /** Forget an armed restore, taken or not. */
+    disarm() {
+        this.#pending = undefined;
+        this.#launched = false;
+    }
+    /**
+     * Whether the container that came up holds `record`'s tree, judged by the
+     * marker the setup read in it.
+     *
+     * Drops the record when a start took it and the tree is not there; leaves it
+     * when no start did, since nothing was learned about it.
+     */
+    async restored(record, marker) {
+        if (!this.#launched)
+            return false;
+        if (marker === record.fingerprint)
+            return true;
+        await this.#drop(record, marker === undefined
+            ? "the restored container could not be read"
+            : "the restored container does not hold the tree");
+        return false;
+    }
+    /**
+     * Snapshot the running container, which has just installed `tree`, after any
+     * snapshot already in flight — a later install's request is never dropped for
+     * an earlier one's.
+     *
+     * Never throws: a container that cannot be snapshotted installs again next
+     * time, which is today's cost and no worse.
+     */
+    async take(tree) {
+        const turn = (this.#taking ?? Promise.resolve()).then(() => this.#take(tree));
+        this.#taking = turn;
+        try {
+            await turn;
+        }
+        finally {
+            if (this.#taking === turn)
+                this.#taking = undefined;
+        }
+    }
+    /** Snapshots in flight, finished — for whatever is about to stop the container. */
+    async settled() {
+        await this.#taking;
+    }
+    /**
+     * The entries that ask for `tree`'s snapshot, for the install to write with
+     * its verdict — see the file comment, and {@link takeDue}.
+     */
+    dueEntries(tree) {
+        return { [DUE_KEY]: tree };
+    }
+    /** Take the snapshot an install asked for, if one is waiting. */
+    async takeDue() {
+        const due = await this.deps.storage.get(DUE_KEY);
+        if (!due)
+            return;
+        await this.deps.storage.delete(DUE_KEY);
+        await this.take(due);
+    }
+    /** The container went, and the disk an asked-for snapshot was of with it. */
+    async forgetDue() {
+        await this.deps.storage.delete(DUE_KEY);
+    }
+    async get() {
+        return await this.deps.storage.get(RECORD_KEY);
+    }
+    /**
+     * Start from another workspace's snapshot — one taken for the same checkout
+     * path on the same image, as a worktree shares with the checkout it was cut
+     * from.
+     *
+     * Kept out when this workspace's own snapshot already fits, and refused when
+     * the offered one does not.
+     */
+    async seed(record, expected) {
+        if (!isRecord(record))
+            return { seeded: false, reason: "not a snapshot" };
+        const now = await expected();
+        const fits = async () => now;
+        const own = await this.get();
+        if (own && !(await this.#refusal(own, fits)))
+            return { seeded: false, reason: "this workspace's own snapshot fits" };
+        const refused = await this.#refusal(record, fits);
+        if (refused)
+            return { seeded: false, reason: refused };
+        await this.deps.storage.put(RECORD_KEY, record);
+        console.info(`[${this.deps.tag()}] seeded a dependency snapshot`, {
+            id: this.deps.id(),
+            snapshot: record.id,
+            dir: record.dir
+        });
+        return { seeded: true };
+    }
+    /**
+     * Why `record` must not be restored now, or `undefined` if it may. A check
+     * that throws refuses: a start must not fail for a snapshot it can go without.
+     */
+    async #refusal(record, expected) {
+        if (record.image !== this.deps.image())
+            return "taken on another image";
+        try {
+            const tree = await expected();
+            if (!tree)
+                return "there is nothing to install here";
+            if (record.dir !== tree.dir)
+                return "taken for another checkout";
+            if (record.fingerprint !== tree.fingerprint)
+                return "the install's inputs have changed";
+            for (const root of record.roots) {
+                if ((await this.deps.rootFingerprint(root.dir)) !== root.fingerprint)
+                    return `${root.dir} has changed`;
+            }
+            if ((await packageRootSet(this.deps.workspace().fs, tree.dir)) !==
+                record.rootSet)
+                return "the checkout's package roots have changed";
+            return undefined;
+        }
+        catch (err) {
+            return `it could not be checked: ${String(err)}`;
+        }
+    }
+    /** Whether the install record still names `tree`. */
+    async #holds(tree) {
+        const now = await this.deps.tree();
+        return (now?.dir === tree.dir &&
+            now.fingerprint === tree.fingerprint &&
+            now.at === tree.at);
+    }
+    async #drop(record, reason) {
+        // Only this record: a later install may have put a newer one there.
+        if ((await this.get())?.id === record.id)
+            await this.deps.storage.delete(RECORD_KEY);
+        console.warn(`[${this.deps.tag()}] dropped the dependency snapshot`, {
+            id: this.deps.id(),
+            snapshot: record.id,
+            reason
+        });
+    }
+    async #take(tree) {
+        const container = this.deps.container();
+        const image = this.deps.image();
+        if (!container?.running || image === undefined)
+            return;
+        // Replaced, or reinstalling, since the install asked.
+        if (!(await this.#holds(tree)))
+            return;
+        const startedAt = Date.now();
+        try {
+            const roots = await this.#roots();
+            // Without a root to mount, a restore would read no marker and be dropped.
+            if (roots.length === 0) {
+                console.warn(`[${this.deps.tag()}] no dependency tree to snapshot on this disk`, { id: this.deps.id(), dir: tree.dir });
+                return;
+            }
+            const fingerprinted = [];
+            for (const dir of roots)
+                fingerprinted.push({
+                    dir,
+                    fingerprint: await this.deps.rootFingerprint(dir)
+                });
+            const rootSet = await packageRootSet(this.deps.workspace().fs, tree.dir);
+            const snapshot = await container.snapshotContainer({
+                name: `deps-${tree.fingerprint.slice(0, 16)}`
+            });
+            if (!(await this.#holds(tree))) {
+                console.warn(`[${this.deps.tag()}] discarded a dependency snapshot taken while the tree changed`, { id: this.deps.id(), snapshot: snapshot.id, dir: tree.dir });
+                return;
+            }
+            await this.deps.storage.put(RECORD_KEY, {
+                id: snapshot.id,
+                size: snapshot.size,
+                image,
+                dir: tree.dir,
+                fingerprint: tree.fingerprint,
+                roots: fingerprinted,
+                rootSet,
+                at: Date.now()
+            });
+            console.info(`[${this.deps.tag()}] took a dependency snapshot`, {
+                id: this.deps.id(),
+                snapshot: snapshot.id,
+                bytes: snapshot.size,
+                roots,
+                ms: Date.now() - startedAt
+            });
+        }
+        catch (err) {
+            console.warn(`[${this.deps.tag()}] could not take a dependency snapshot`, {
+                id: this.deps.id(),
+                err: String(err)
+            });
+        }
+    }
+    /** The package roots whose trees are on this container's disk. */
+    async #roots() {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const handle = __addDisposableResource(env_1, await this.deps
+                .workspace()
+                .runtime.exec(DEPS_ROOTS_COMMAND, {
+                cwd: "/",
+                encoding: "utf8",
+                timeoutMs: 30_000
+            }), false);
+            const result = await handle.result();
+            if (result.exitCode !== 0)
+                throw new Error(`could not list the dependency trees: ${result.stderr || `exit ${result.exitCode}`}`);
+            return parseDepsRoots(result.stdout ?? "");
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+}
+/** Enough of a record's shape to restore from — it arrives over RPC. */
+function isRecord(value) {
+    const r = value;
+    return (typeof r?.id === "string" &&
+        typeof r.image === "string" &&
+        typeof r.dir === "string" &&
+        typeof r.fingerprint === "string" &&
+        typeof r.rootSet === "string" &&
+        Array.isArray(r.roots) &&
+        r.roots.every((root) => typeof root?.dir === "string"));
+}

package/dist/workspace/index.d.ts

@@ -42,7 +42,8 @@ export { workspaceExec, DEFAULT_CWD, DEFAULT_TIMEOUT_MS, type WorkspaceClientCon
  * import time is a base that evaluates `undefined`.
  */
 export { WorkspaceObjectBase, IDLE_RECLAIM_MS, WORKSPACE_DIR, workspaceName, type WorkspaceObjectConfig, type WorkspaceGitConfig } from "./object.js";
-export { InstallJob, type InstallJobDeps } from "./install-job.js";
+export { InstallJob, type InstallJobDeps, type InstallTarget } from "./install-job.js";
+export type { DepsSnapshotRecord } from "./deps-snapshot.js";
 export { WorkspaceSync, SYNC_DRAIN_BUDGET_MS, SYNC_DRAIN_RESUME_MS, SYNC_DRAIN_MAX_BACKOFF_MS, syncRetryDelayMs, type DrainOutcome, type SyncDrainIntent, type WorkspaceSyncDeps } from "./sync.js";
 export { ContainerTrust, TRUST_CA_COMMAND, type ContainerTrustDeps } from "./ca-trust.js";
 export { WorkspaceGitHost, type GitHostDeps } from "./git-host.js";

package/dist/workspace/install-job.d.ts

@@ -22,9 +22,30 @@ export interface InstallJobDeps {
     waitUntil: (promise: Promise<unknown>) => void;
     /** A container was replaced, so nothing believed about it still holds. */
     containerGone: () => Promise<void>;
+    /**
+     * Storage entries the host keeps about a tree an install finished, written in
+     * the same write as that install's verdict — nothing can read the one without
+     * the other.
+     */
+    installedRecords: (tree: {
+        dir: string;
+        fingerprint: string;
+        at: number;
+    }) => Record<string, unknown>;
+    /** After that write: an install exited 0, so this container holds the tree. */
+    installed: (tree: {
+        dir: string;
+        fingerprint: string;
+        at: number;
+    }) => Promise<void>;
     tag: () => string;
     id: () => string;
 }
+/** Where an install goes: the checkout, and the repository for its override. */
+export interface InstallTarget {
+    dir: string;
+    repo?: string;
+}
 export declare class InstallJob {
     #private;
     private readonly deps;
@@ -48,6 +69,34 @@ export declare class InstallJob {
     armIfTreeMissing(): Promise<void>;
     /** Where the last install ran, for the container setup's marker read. */
     dir(): Promise<string | undefined>;
+    /** Where the last install ran, and for which repository's override. */
+    target(): Promise<InstallTarget | undefined>;
+    /**
+     * The fingerprint an install into `target` would write as its marker, from the
+     * checkout as it stands — `null` when there is nothing to install there.
+     */
+    fingerprintFor(target: InstallTarget): Promise<string | null>;
+    /** What `dir`'s install inputs hash to — see `rootFingerprint`. */
+    rootFingerprint(dir: string): Promise<string | null>;
+    /** The tree this container holds, if a finished install says it does. */
+    tree(): Promise<{
+        dir: string;
+        fingerprint: string | null;
+        at: number;
+    } | undefined>;
+    /**
+     * Record a tree this container came up holding — restored with a snapshot of
+     * the container that installed it — as if this container had installed it.
+     *
+     * Only for a tree whose marker the setup read and matched against the checkout
+     * as it stands; see `./deps-snapshot.ts`. So the last install's context moves
+     * to it too: a checkout that moved since that install would otherwise read as
+     * missing its tree, and arm an install that finds the tree already there.
+     */
+    adopt(tree: {
+        dir: string;
+        fingerprint: string;
+    }): Promise<void>;
     /** The container went away, and its tree with it. */
     containerGone(): Promise<void>;
     /**

package/dist/workspace/install-job.js

@@ -4,7 +4,7 @@ import { JobLifecycle } from "@dynamicagents/core/job";
 // re-exports this directory, so reaching it from here would be a cycle — through
 // a module that builds a class at import time, where initialisation order
 // decides whether the base is `undefined`.
-import { installFingerprint, resolveInstallCommand } from "./install.js";
+import { installFingerprint, resolveInstallCommand, rootFingerprint } from "./install.js";
 import { pathExists } from "./read.js";
 import { deploymentFault } from "./container-fault.js";
 import { INSTALLED_MARKER } from "./container-deps.js";
@@ -38,8 +38,9 @@ function execWasLost(err) {
  * ## What decides that an install is needed
  *
  * The tree lives on the container's disk (see `./container-deps.ts`), so it goes
- * with the container. {@link CONTAINER_TREE_KEY} records a successful install and
- * is cleared whenever that container is seen gone.
+ * with the container. {@link CONTAINER_TREE_KEY} records a successful install — or
+ * a tree restored with a snapshot of the container that ran one, through
+ * {@link InstallJob.adopt} — and is cleared whenever that container is seen gone.
  */
 /**
  * The install's job id, which is also the key its state record lives under.
@@ -212,6 +213,57 @@ export class InstallJob {
     async dir() {
         return (await this.#job.context())?.dir;
     }
+    /** Where the last install ran, and for which repository's override. */
+    async target() {
+        const context = await this.#job.context();
+        if (!context?.dir)
+            return undefined;
+        return {
+            dir: context.dir,
+            ...(context.repo ? { repo: context.repo } : {})
+        };
+    }
+    /**
+     * The fingerprint an install into `target` would write as its marker, from the
+     * checkout as it stands — `null` when there is nothing to install there.
+     */
+    async fingerprintFor(target) {
+        const probe = this.#probe();
+        const resolution = await resolveInstallCommand(probe, target.dir, this.deps.plan(), target.repo);
+        return await installFingerprint(probe, target.dir, resolution);
+    }
+    /** What `dir`'s install inputs hash to — see `rootFingerprint`. */
+    async rootFingerprint(dir) {
+        return await rootFingerprint(this.#probe(), dir, this.deps.plan());
+    }
+    /** The tree this container holds, if a finished install says it does. */
+    async tree() {
+        const tree = await this.#tree();
+        return (tree && { dir: tree.dir, fingerprint: tree.fingerprint, at: tree.at });
+    }
+    /**
+     * Record a tree this container came up holding — restored with a snapshot of
+     * the container that installed it — as if this container had installed it.
+     *
+     * Only for a tree whose marker the setup read and matched against the checkout
+     * as it stands; see `./deps-snapshot.ts`. So the last install's context moves
+     * to it too: a checkout that moved since that install would otherwise read as
+     * missing its tree, and arm an install that finds the tree already there.
+     */
+    async adopt(tree) {
+        await this.deps.storage.put(CONTAINER_TREE_KEY, {
+            dir: tree.dir,
+            fingerprint: tree.fingerprint,
+            at: Date.now()
+        });
+        const context = await this.#job.context();
+        if (context?.dir === tree.dir && context.fingerprint !== tree.fingerprint)
+            await this.#job.putContext({ ...context, fingerprint: tree.fingerprint });
+        console.info(`[${this.deps.tag()}] adopted a restored dependency tree`, {
+            id: this.deps.id(),
+            dir: tree.dir
+        });
+    }
     /** The container went away, and its tree with it. */
     async containerGone() {
         await this.deps.storage.delete(CONTAINER_TREE_KEY);
@@ -673,8 +725,10 @@ export class InstallJob {
             return false;
         };
         const settle = async (verdict, also) => {
-            if (!(await run.write(verdict, also)))
-                await superseded();
+            if (await run.write(verdict, also))
+                return true;
+            await superseded();
+            return false;
         };
         try {
             const result = await handle.result();
@@ -700,14 +754,28 @@ export class InstallJob {
                     command,
                     seconds: Math.round((Date.now() - startedAt) / 1000)
                 });
-                await settle({
+                const installed = tree?.fingerprint
+                    ? { dir: tree.dir, fingerprint: tree.fingerprint, at: tree.at }
+                    : undefined;
+                const kept = await settle({
                     state: "done",
                     command,
                     exitCode: 0,
                     finishedAt: Date.now(),
                     ms: Date.now() - startedAt,
                     tail
-                }, tree ? { [CONTAINER_TREE_KEY]: tree } : undefined);
+                }, tree
+                    ? {
+                        ...(installed ? this.deps.installedRecords(installed) : {}),
+                        [CONTAINER_TREE_KEY]: tree
+                    }
+                    : undefined);
+                // Outside the verdict: a host that cannot act on the news must not turn
+                // a finished install into a failed one, which the catch below would.
+                if (kept && installed)
+                    await this.deps.installed(installed).catch((err) => {
+                        console.warn(`[${this.deps.tag()}] could not act on a finished install`, { id: this.deps.id(), err: String(err) });
+                    });
             }
             else {
                 // Logged, and this line is not optional. This is the *ordinary* way an

package/dist/workspace/install.d.ts

@@ -187,3 +187,12 @@ export declare function resolveInstallCommand(fs: InstallProbe, dir: string, pla
  * finished it — see `./install-job.ts`.
  */
 export declare function installFingerprint(fs: InstallProbe, dir: string, resolution: InstallResolution): Promise<string | null>;
+/**
+ * The same digest for a package root an install reached without being pointed
+ * at it — a submodule a bootstrap installs, say — where there is no command to
+ * fold in, and every lockfile the plan knows stands in for the one it would pick.
+ *
+ * For `./deps-snapshot.ts`, which restores every root's tree at once and so has
+ * to know none of them moved.
+ */
+export declare function rootFingerprint(fs: InstallProbe, dir: string, plan: InstallPlan): Promise<string | null>;

package/dist/workspace/install.js

@@ -96,6 +96,10 @@ function pinnedManager(packageJson) {
         return undefined;
     }
 }
+/** Every lockfile the plan names, each once. */
+function planLockfiles(plan) {
+    return [...new Set(plan.rules.flatMap((r) => [...r.lockfiles]))];
+}
 /**
  * Every lockfile the plan knows of that is present in `dir`.
  *
@@ -103,9 +107,8 @@ function pinnedManager(packageJson) {
  * about which manager it drives.
  */
 async function knownLockfiles(fs, dir, plan) {
-    const names = [...new Set(plan.rules.flatMap((r) => [...r.lockfiles]))];
     const present = [];
-    for (const name of names) {
+    for (const name of planLockfiles(plan)) {
         if (await fs.exists(`${dir}/${name}`))
             present.push(name);
     }
@@ -273,10 +276,25 @@ export async function installFingerprint(fs, dir, resolution) {
         ...resolution.lockfiles,
         ...INSTALL_CONFIG_FILES
     ];
+    return await digestFiles(fs, dir, names, resolution.command);
+}
+/**
+ * The same digest for a package root an install reached without being pointed
+ * at it — a submodule a bootstrap installs, say — where there is no command to
+ * fold in, and every lockfile the plan knows stands in for the one it would pick.
+ *
+ * For `./deps-snapshot.ts`, which restores every root's tree at once and so has
+ * to know none of them moved.
+ */
+export async function rootFingerprint(fs, dir, plan) {
+    return await digestFiles(fs, dir, ["package.json", ...planLockfiles(plan), ...INSTALL_CONFIG_FILES], "");
+}
+/** `prefix`, then every file of `names` present in `dir`; null when none is. */
+async function digestFiles(fs, dir, names, prefix) {
     // Names as well as contents. Two lockfiles will not collide on content in
     // practice, but a digest that cannot say *which* file it read is one that
     // silently depends on the caller resolving them in the same order forever.
-    let input = resolution.command;
+    let input = prefix;
     let found = false;
     for (const name of names) {
         if (!(await fs.exists(`${dir}/${name}`)))