@code-yeongyu/senpi 2026.9.29-5 → 2026.9.30

package/dist/modes/rpc/extension-ui-response.d.ts

@@ -1,3 +1,4 @@
+import type { QuestionRequest, QuestionResponse } from "../../core/extensions/types.ts";
 import type { RpcExtensionUIResponse } from "./rpc-types.ts";
 /**
  * An `extension_ui_response` carries two ids: `id`, the frame's own correlation id that its reply
@@ -8,6 +9,16 @@ export declare function answeredUiRequestId(frame: {
     readonly id?: unknown;
     readonly uiRequestId?: unknown;
 }): string | undefined;
+/**
+ * How a `question` answer settles, identically on a host and a terminal control endpoint: it reads
+ * `answers` and `comment` (a `value` or `confirmed` beside them belongs to the other dialogs and is
+ * ignored). A non-blank comment settles it `comment-submitted`, the status that carries the comment
+ * to the model; otherwise any answer settles it `answered`; neither leaves it unsettled
+ * (`question_incomplete`).
+ */
+export declare function settledQuestionStatus(answers: QuestionResponse["answers"], comment: string | undefined): "answered" | "comment-submitted" | undefined;
+/** The questions an answer leaves without a selection or text, reported back to the model. */
+export declare function unansweredQuestionIds(questions: QuestionRequest["questions"], answers: QuestionResponse["answers"]): string[];
 export type ExtensionUiResponseReply = {
     readonly id: string;
     readonly type: "response";

package/dist/modes/rpc/extension-ui-response.js

@@ -8,6 +8,24 @@ export function answeredUiRequestId(frame) {
         return frame.uiRequestId;
     return typeof frame.id === "string" ? frame.id : undefined;
 }
+/**
+ * How a `question` answer settles, identically on a host and a terminal control endpoint: it reads
+ * `answers` and `comment` (a `value` or `confirmed` beside them belongs to the other dialogs and is
+ * ignored). A non-blank comment settles it `comment-submitted`, the status that carries the comment
+ * to the model; otherwise any answer settles it `answered`; neither leaves it unsettled
+ * (`question_incomplete`).
+ */
+export function settledQuestionStatus(answers, comment) {
+    if (comment?.trim())
+        return "comment-submitted";
+    return Object.keys(answers).length > 0 ? "answered" : undefined;
+}
+/** The questions an answer leaves without a selection or text, reported back to the model. */
+export function unansweredQuestionIds(questions, answers) {
+    return questions
+        .filter((question) => !answers[question.id]?.selected.length && !answers[question.id]?.text?.trim())
+        .map((question) => question.id);
+}
 /**
  * Settles one response on a host connection and returns its reply, keyed by the frame `id`.
  * `undefined` only on an unrouted (single-session stdio) connection for a response no request here

package/dist/modes/rpc/host-lifecycle.d.ts

@@ -56,8 +56,11 @@ export declare const INTERNAL_SUPERVISOR_FLAG = "--internal-rpc-host-supervisor"
 export declare function findInternalSupervisorArgs(argv: readonly string[]): readonly string[] | undefined;
 /** `--socket <path>` selects the public socket; every other argument is forwarded to the host CLI. */
 export declare function parseSupervisorArgs(argv: readonly string[]): SupervisorLaunch | undefined;
-/** Resolves the committed CLI entry this supervisor wraps (source tree or built dist). */
-export declare function resolveCliMainPath(): string;
+/**
+ * Resolves the committed CLI entry this supervisor wraps (source tree or built dist).
+ * Exported for tests, which pass the module path and layout of a bundled install.
+ */
+export declare function resolveCliMainPath(modulePath?: string, bundled?: boolean): string;
 /**
  * Resolves the host child spawn. Explicit child commands (desktop launchers)
  * are forwarded untouched. The default re-enters the committed CLI entry

package/dist/modes/rpc/host-lifecycle.js

@@ -193,18 +193,24 @@ function parseSocketIdentity(value) {
     const match = /^(\d+):(\d+)$/.exec(value);
     return match ? { dev: Number(match[1]), ino: Number(match[2]) } : undefined;
 }
-/** Resolves the committed CLI entry this supervisor wraps (source tree or built dist). */
-export function resolveCliMainPath() {
-    const modulePath = fileURLToPath(import.meta.url);
+/**
+ * Resolves the committed CLI entry this supervisor wraps (source tree or built dist).
+ * Exported for tests, which pass the module path and layout of a bundled install.
+ */
+export function resolveCliMainPath(modulePath = fileURLToPath(import.meta.url), bundled = isBundledNode) {
+    // Bundled, take the entry from the package's own declared bin: the bundle's cli.js beside
+    // this chunk, so a host started from a runtime snapshot runs the snapshot's copy and claims
+    // it the way a session does (#2409). Counting ".." instead lands on dist/cli-main.js, the
+    // unbundled tree the package also ships, which a snapshot links back to the install that an
+    // upgrade replaces, or on the package root, where no cli-main was ever emitted.
+    const declared = bundled ? resolveDeclaredCliEntry(modulePath) : undefined;
+    if (declared !== undefined)
+        return declared;
     const extension = modulePath.endsWith(".ts") ? ".ts" : ".js";
     const unbundled = resolve(dirname(modulePath), "..", "..", `cli-main${extension}`);
     if (existsSync(unbundled))
         return unbundled;
-    // Bundled, ".." twice reaches the PACKAGE ROOT rather than dist/, naming a cli-main that
-    // was never emitted. Take the entry from the package's own declared bin instead of
-    // counting directories: it is the one statement of where the CLI lives that holds in
-    // every layout. Falls back to the old path when nothing is declared, so a caller that
-    // was working keeps working.
+    // Falls back to the old path when nothing is declared, so a caller that was working keeps working.
     return resolveDeclaredCliEntry(modulePath) ?? unbundled;
 }
 /** The CLI entry declared by the nearest enclosing package.json, when it exists on disk. */

package/dist/modes/rpc/rpc-client.d.ts

@@ -116,7 +116,7 @@ export declare class RpcClient {
         retain_on_disconnect?: boolean;
         /** Per-session auto-titling; needs the host's `auto_title_per_session`. */
         auto_title?: boolean;
-        /** Where this session's replies render; needs the host's `prompt_surface`. */
+        /** Where this session's replies render; needs the host's `prompt_surface` (`prompt_surface_chat` for `chat`). */
         promptSurface?: PromptSurface;
     }): Promise<{
         sessionId: string;

package/dist/modes/rpc/rpc-input-validation.d.ts

@@ -31,7 +31,7 @@ export declare function sessionAutoTitleError(value: unknown): string | undefine
 /**
  * Detail for an `open_session.promptSurface` the host refuses, or undefined when the value is
  * absent or a known surface. An unknown value is never read as `terminal`: a client that asked
- * for the app prompt must not silently get the routing line.
+ * for the app or chat prompt must not silently get the routing line.
  */
 export declare function sessionPromptSurfaceError(value: unknown): string | undefined;
 export declare function rpcCommandShapeError(command: unknown): string | undefined;

package/dist/modes/rpc/rpc-input-validation.js

@@ -133,12 +133,12 @@ export function sessionAutoTitleError(value) {
 /**
  * Detail for an `open_session.promptSurface` the host refuses, or undefined when the value is
  * absent or a known surface. An unknown value is never read as `terminal`: a client that asked
- * for the app prompt must not silently get the routing line.
+ * for the app or chat prompt must not silently get the routing line.
  */
 export function sessionPromptSurfaceError(value) {
-    if (value === undefined || value === "terminal" || value === "app")
+    if (value === undefined || value === "terminal" || value === "app" || value === "chat")
         return undefined;
-    return `promptSurface must be "terminal" or "app".`;
+    return `promptSurface must be "terminal", "app" or "chat".`;
 }
 export function rpcCommandShapeError(command) {
     if (typeof command !== "object" || command === null || Array.isArray(command)) {

package/dist/modes/rpc/rpc-mode.d.ts

@@ -49,7 +49,8 @@
  * applies to CREATE only - re-opening an existing `sessionPath` keeps that file's header
  * id, so identity is never rewritten by a resume.
  *
- * `open_session.promptSurface` (`terminal` | `app`, host capability `prompt_surface`) builds that
+ * `open_session.promptSurface` (`terminal` | `app` | `chat`, host capabilities `prompt_surface` and
+ * `prompt_surface_chat`) builds that
  * session's system prompt for where its replies render; omitted, the host's `SENPI_PROMPT_SURFACE`
  * decides. An attach naming another surface rebuilds the live session's prompt.
  *
@@ -60,7 +61,7 @@
  * `open_failed: <detail>`, `invalid_session_context: <detail>` (a `context` past a
  * documented cap), `invalid_session_kind: <detail>` (a `kind` that is neither
  * `interactive` nor `worker`), `invalid_launch_profile: <detail>` (a non-boolean
- * `auto_title`, or a `promptSurface` other than `terminal`/`app`), `invalid_session_id: <detail>` (a `durableSessionId` that is not a
+ * `auto_title`, or a `promptSurface` other than `terminal`/`app`/`chat`), `invalid_session_id: <detail>` (a `durableSessionId` that is not a
  * legal session id), `session_id_in_use` (a `durableSessionId` a LIVE session already
  * holds).
  *

package/dist/modes/rpc/rpc-mode.js

@@ -49,7 +49,8 @@
  * applies to CREATE only - re-opening an existing `sessionPath` keeps that file's header
  * id, so identity is never rewritten by a resume.
  *
- * `open_session.promptSurface` (`terminal` | `app`, host capability `prompt_surface`) builds that
+ * `open_session.promptSurface` (`terminal` | `app` | `chat`, host capabilities `prompt_surface` and
+ * `prompt_surface_chat`) builds that
  * session's system prompt for where its replies render; omitted, the host's `SENPI_PROMPT_SURFACE`
  * decides. An attach naming another surface rebuilds the live session's prompt.
  *
@@ -60,7 +61,7 @@
  * `open_failed: <detail>`, `invalid_session_context: <detail>` (a `context` past a
  * documented cap), `invalid_session_kind: <detail>` (a `kind` that is neither
  * `interactive` nor `worker`), `invalid_launch_profile: <detail>` (a non-boolean
- * `auto_title`, or a `promptSurface` other than `terminal`/`app`), `invalid_session_id: <detail>` (a `durableSessionId` that is not a
+ * `auto_title`, or a `promptSurface` other than `terminal`/`app`/`chat`), `invalid_session_id: <detail>` (a `durableSessionId` that is not a
  * legal session id), `session_id_in_use` (a `durableSessionId` a LIVE session already
  * holds).
  *

package/dist/modes/rpc/rpc-types.d.ts

@@ -478,9 +478,10 @@ export type RpcCommand = (RpcSessionCommand & {
     /**
      * Where THIS session's replies render (default: the host's `SENPI_PROMPT_SURFACE`). `app` builds
      * a prompt with no visible routing line that keeps tool and hook feedback with the agent;
-     * `terminal` is the classic prompt. A later open that attaches with another value rebuilds
-     * the session's prompt; an attach without it keeps the current surface. Requires the host
-     * capability `prompt_surface`. Any other value is refused with `invalid_launch_profile`.
+     * `terminal` is the classic prompt; `chat` (a chat bridge) is `app` with no handoff block, ledger
+     * lines, or todo handoff cues, and needs `prompt_surface_chat`. A later open that attaches with
+     * another value rebuilds the session's prompt; an attach without it keeps the current surface.
+     * Requires the host capability `prompt_surface`. Any other value is refused with `invalid_launch_profile`.
      */
     promptSurface?: PromptSurface;
 } | {

package/dist/modes/rpc/session-command-router.js

@@ -1,6 +1,7 @@
 import { VERSION } from "../../config.js";
+import { ACCEPT_EDITS_PERMISSION_PRESET_CAPABILITY } from "../../core/extensions/builtin/permission-system/config.js";
 import { buildRpcSessionState } from "./connection-handler.js";
-import { AUTO_TITLE_PER_SESSION_CAPABILITY, AUTO_TITLE_SESSIONS_CAPABILITY, DURABLE_SESSION_ID_CAPABILITY, MEDIA_PLACEHOLDERS_CAPABILITY, PROMPT_SURFACE_CAPABILITY, RETAIN_ON_DISCONNECT_CAPABILITY, SESSION_CONTEXT_CAPABILITY, SESSION_KIND_CAPABILITY, WARM_CAPABILITY, } from "./custom-capability.js";
+import { AUTO_TITLE_PER_SESSION_CAPABILITY, AUTO_TITLE_SESSIONS_CAPABILITY, DURABLE_SESSION_ID_CAPABILITY, MEDIA_PLACEHOLDERS_CAPABILITY, PROMPT_SURFACE_CAPABILITY, PROMPT_SURFACE_CHAT_CAPABILITY, RETAIN_ON_DISCONNECT_CAPABILITY, SESSION_CONTEXT_CAPABILITY, SESSION_KIND_CAPABILITY, WARM_CAPABILITY, } from "./custom-capability.js";
 import { answerWarm } from "./host-warm.js";
 import { protocolIdentity } from "./protocol-identity.js";
 import { sessionAutoTitleError, sessionContextError, sessionKindError, sessionPromptSurfaceError, } from "./rpc-input-validation.js";
@@ -182,6 +183,8 @@ export class SessionCommandRouter {
                 DURABLE_SESSION_ID_CAPABILITY,
                 // Every session's prompt is built from its own launch profile, so one host serves both surfaces.
                 PROMPT_SURFACE_CAPABILITY,
+                PROMPT_SURFACE_CHAT_CAPABILITY,
+                ACCEPT_EDITS_PERMISSION_PRESET_CAPABILITY,
                 // Only an in-process runtime shares the loop a warm loads into (senpi#2314).
                 ...(this.registry.warm ? [WARM_CAPABILITY] : []),
                 ...(this.connectionOptions?.capabilities ?? []),

package/dist/runtime-snapshot/enter.d.ts

@@ -13,5 +13,5 @@ export type RuntimeSnapshotDecision = {
  * snapshot taken once per build and install, and claims it so it outlives later upgrades.
  * A launch already running from a snapshot only claims it. Any failure keeps the old behavior.
  */
-export declare function prepareRuntimeSnapshot(entryPath: string, packageDir: string, agentDir: string): RuntimeSnapshotDecision;
+export declare function prepareRuntimeSnapshot(entryPath: string, packageDir: string, agentDir: string): Promise<RuntimeSnapshotDecision>;
 //# sourceMappingURL=enter.d.ts.map

package/dist/runtime-snapshot/enter.js

@@ -4,7 +4,7 @@ import { basename, dirname, join, relative } from "node:path";
 import { pathToFileURL } from "node:url";
 import { materializeRuntimeSnapshot } from "./layout.js";
 import { readRuntimeSnapshotMarker } from "./marker.js";
-import { claimRuntimeSnapshot, pruneRuntimeSnapshots, withRuntimeLock } from "./registry.js";
+import { claimRuntimeSnapshot, pruneRuntimeSnapshots, withBuildLock, withRuntimeLock } from "./registry.js";
 export const RUNTIME_MANIFEST = "runtime-manifest.json";
 function readRuntimeManifest(bundleDir) {
     let parsed;
@@ -35,7 +35,7 @@ function readRuntimeManifest(bundleDir) {
  * snapshot taken once per build and install, and claims it so it outlives later upgrades.
  * A launch already running from a snapshot only claims it. Any failure keeps the old behavior.
  */
-export function prepareRuntimeSnapshot(entryPath, packageDir, agentDir) {
+export async function prepareRuntimeSnapshot(entryPath, packageDir, agentDir) {
     const bundleDir = dirname(entryPath);
     const runtimeRoot = join(agentDir, "runtime");
     try {
@@ -49,15 +49,25 @@ export function prepareRuntimeSnapshot(entryPath, packageDir, agentDir) {
         const installId = createHash("sha256").update(realpathSync(packageDir)).digest("hex").slice(0, 12);
         const snapshotId = `${manifest.buildId}-${installId}`;
         const snapshotDir = join(runtimeRoot, snapshotId);
-        const ready = withRuntimeLock(runtimeRoot, () => {
-            if (readRuntimeSnapshotMarker(snapshotDir)?.buildId !== manifest.buildId) {
-                materializeRuntimeSnapshot(packageDir, snapshotDir, manifest);
-            }
+        const isBuilt = () => readRuntimeSnapshotMarker(snapshotDir)?.buildId === manifest.buildId;
+        const claim = () => withRuntimeLock(runtimeRoot, () => {
+            if (!isBuilt())
+                return false;
             claimRuntimeSnapshot(snapshotDir, process.pid);
             pruneRuntimeSnapshots(runtimeRoot, snapshotId, Date.now());
             return true;
         });
-        if (!ready)
+        let claimed = claim();
+        if (claimed === false) {
+            const built = await withBuildLock(runtimeRoot, snapshotId, async () => {
+                if (!isBuilt())
+                    await materializeRuntimeSnapshot(packageDir, snapshotDir, manifest);
+                return true;
+            });
+            if (built)
+                claimed = claim();
+        }
+        if (claimed !== true)
             return { kind: "run-here" };
         const entryUrl = pathToFileURL(join(snapshotDir, "dist", "bundle", basename(entryPath))).href;
         return { kind: "hand-off", entryUrl, snapshotDir };

package/dist/runtime-snapshot/file-copier.d.ts

@@ -0,0 +1,24 @@
+/**
+ * How a file gets into a snapshot. A clone (APFS, btrfs, XFS, ReFS) is copy-on-write: free, and
+ * independent of the install even if something rewrites the install's file in place. A hardlink
+ * is just as free but shares the file itself, so it is only taken where the filesystem cannot
+ * clone (ext4, NTFS); package managers replace files rather than rewriting them, which keeps a
+ * linked snapshot on the build it was taken from. A plain copy is the last resort (another
+ * volume, a filesystem that refuses links).
+ */
+export type SnapshotCopyMode = "clone" | "clone-or-copy" | "link" | "copy";
+export interface SnapshotFileOperations {
+    copyFile(source: string, target: string, mode: number): Promise<void>;
+    link(source: string, target: string): Promise<void>;
+}
+export interface SnapshotFileCopier {
+    copy(source: string, target: string): Promise<void>;
+    readonly mode: SnapshotCopyMode;
+}
+/**
+ * A file copier that starts with the cheapest independent copy and settles on the first mode the
+ * filesystem accepts, so a snapshot of thousands of files pays for a refused mode once.
+ */
+export declare function createSnapshotFileCopier(platform?: NodeJS.Platform, operations?: SnapshotFileOperations): SnapshotFileCopier;
+export declare function copyFiles(pairs: readonly (readonly [string, string])[], copier: SnapshotFileCopier): Promise<void>;
+//# sourceMappingURL=file-copier.d.ts.map

package/dist/runtime-snapshot/file-copier.js

@@ -0,0 +1,76 @@
+import { constants } from "node:fs";
+import { copyFile, link } from "node:fs/promises";
+function errorCode(error) {
+    return error instanceof Error && "code" in error ? error.code : undefined;
+}
+const FILE_OPERATIONS = { copyFile, link };
+/** Clones go through the filesystem's metadata path, which stops scaling past a few in flight. */
+const COPY_CONCURRENCY = 8;
+function nextCopyMode(mode, error, platform) {
+    const code = errorCode(error);
+    // A missing source or an occupied target is about this file, not about what the filesystem can do.
+    if (code === "ENOENT" || code === "ENOTDIR" || code === "EEXIST")
+        return undefined;
+    switch (mode) {
+        case "clone":
+            // Node on macOS cannot force a clone (ENOSYS), but its plain clone request clones on APFS
+            // and copies elsewhere, which is exactly the order wanted without ever sharing an inode.
+            return platform === "darwin" && code === "ENOSYS" ? "clone-or-copy" : "link";
+        case "link":
+            return "copy";
+        case "clone-or-copy":
+        case "copy":
+            return undefined;
+    }
+}
+/**
+ * A file copier that starts with the cheapest independent copy and settles on the first mode the
+ * filesystem accepts, so a snapshot of thousands of files pays for a refused mode once.
+ */
+export function createSnapshotFileCopier(platform = process.platform, operations = FILE_OPERATIONS) {
+    let mode = "clone";
+    const attempt = (current, source, target) => {
+        switch (current) {
+            case "clone":
+                return operations.copyFile(source, target, constants.COPYFILE_FICLONE_FORCE);
+            case "clone-or-copy":
+                return operations.copyFile(source, target, constants.COPYFILE_FICLONE);
+            case "link":
+                return operations.link(source, target);
+            case "copy":
+                return operations.copyFile(source, target, 0);
+        }
+    };
+    return {
+        get mode() {
+            return mode;
+        },
+        async copy(source, target) {
+            for (let current = mode;;) {
+                try {
+                    await attempt(current, source, target);
+                    return;
+                }
+                catch (error) {
+                    const next = nextCopyMode(current, error, platform);
+                    if (next === undefined)
+                        throw error;
+                    current = next;
+                    mode = next;
+                }
+            }
+        },
+    };
+}
+export async function copyFiles(pairs, copier) {
+    let next = 0;
+    const worker = async () => {
+        for (let index = next++; index < pairs.length; index = next++) {
+            const [source, target] = pairs[index] ?? [];
+            if (source !== undefined && target !== undefined)
+                await copier.copy(source, target);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(COPY_CONCURRENCY, pairs.length) }, worker));
+}
+//# sourceMappingURL=file-copier.js.map

package/dist/runtime-snapshot/layout.d.ts

@@ -1,3 +1,4 @@
+import { type SnapshotFileCopier } from "./file-copier.ts";
 export interface RuntimeManifest {
     readonly buildId: string;
     readonly externals: readonly string[];
@@ -6,10 +7,13 @@ export declare class RuntimeSnapshotLayoutError extends Error {
     readonly packageName: string;
     constructor(packageName: string);
 }
+export declare const STAGING_PREFIX = ".tmp-";
 /**
- * Builds `target` as a copy of the package that no reinstall can touch: `dist/bundle` and
- * `package.json` are copied, every other entry is linked back to the install. Built beside the
- * target and renamed into place, so a crash never leaves a half-built snapshot under its name.
+ * Builds `target` as a copy of the package that no reinstall can touch: the package itself and
+ * every package its dependency graph reaches, with nothing linked back to the install, so an
+ * upgrade that deletes, rewrites or re-lays-out the install (bundledDependencies on or off) never
+ * changes what a running session loads (#2408). Built beside the target and renamed into place,
+ * so a crash never leaves a half-built snapshot under its name.
  */
-export declare function materializeRuntimeSnapshot(packageDir: string, target: string, manifest: RuntimeManifest): void;
+export declare function materializeRuntimeSnapshot(packageDir: string, target: string, manifest: RuntimeManifest, copier?: SnapshotFileCopier): Promise<void>;
 //# sourceMappingURL=layout.d.ts.map

package/dist/runtime-snapshot/layout.js

@@ -1,5 +1,6 @@
-import { copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { basename, dirname, join } from "node:path";
+import { copyFiles, createSnapshotFileCopier } from "./file-copier.js";
 import { RUNTIME_SNAPSHOT_MARKER } from "./marker.js";
 export class RuntimeSnapshotLayoutError extends Error {
     constructor(packageName) {
@@ -7,44 +8,53 @@ export class RuntimeSnapshotLayoutError extends Error {
         this.packageName = packageName;
     }
 }
+export const STAGING_PREFIX = ".tmp-";
+/** Type declarations and source maps: no runtime ever loads them, and they are half the files. */
+const UNLOADED_FILE = /\.(?:d\.[cm]?ts|map)$/;
 function isMissing(error) {
     return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
-function occupied(path) {
-    try {
-        lstatSync(path);
-        return true;
-    }
-    catch (error) {
-        if (isMissing(error))
-            return false;
-        throw error;
-    }
-}
-function linkEntry(source, target) {
-    let isDirectory;
-    try {
-        isDirectory = statSync(source).isDirectory();
-    }
-    catch (error) {
-        // A dangling link in the install stays unresolvable from the snapshot too.
-        if (isMissing(error))
-            return;
-        throw error;
-    }
-    // Windows file symlinks need a privilege; the files involved are small, so copy them.
-    if (process.platform === "win32" && !isDirectory) {
-        copyFileSync(source, target);
+/**
+ * Creates the directories of a tree copy and lists the files to copy into them, following
+ * symlinks so nothing in the result points back at the source. `skipModules` leaves nested
+ * `node_modules` out: dependencies are placed on their own.
+ */
+function planTree(source, target, files, skipModules, seen = new Set()) {
+    const real = realpathSync(source);
+    if (seen.has(real))
         return;
-    }
-    symlinkSync(source, target, isDirectory ? "junction" : "file");
-}
-function linkChildren(sourceDir, targetDir, skip) {
-    for (const name of readdirSync(sourceDir)) {
-        if (skip.has(name) || occupied(join(targetDir, name)))
+    seen.add(real);
+    mkdirSync(target, { recursive: true });
+    for (const entry of readdirSync(real, { withFileTypes: true })) {
+        if (skipModules && entry.name === "node_modules")
             continue;
-        linkEntry(join(sourceDir, name), join(targetDir, name));
+        const from = join(real, entry.name);
+        const to = join(target, entry.name);
+        if (entry.isDirectory()) {
+            planTree(from, to, files, skipModules, seen);
+        }
+        else if (entry.isFile()) {
+            if (!UNLOADED_FILE.test(entry.name))
+                files.push([from, to]);
+        }
+        else if (entry.isSymbolicLink()) {
+            let isDirectory;
+            try {
+                isDirectory = statSync(from).isDirectory();
+            }
+            catch (error) {
+                // A dangling link in the install stays unresolvable in the snapshot too.
+                if (isMissing(error))
+                    continue;
+                throw error;
+            }
+            if (isDirectory)
+                planTree(from, to, files, skipModules, seen);
+            else if (!UNLOADED_FILE.test(entry.name))
+                files.push([realpathSync(from), to]);
+        }
     }
+    seen.delete(real);
 }
 /** The node_modules directories Node's resolver walks from `dir`, nearest first. */
 function moduleDirectoriesFrom(dir) {
@@ -59,27 +69,6 @@ function moduleDirectoriesFrom(dir) {
             return directories;
     }
 }
-/**
- * One node_modules that resolves every package name the way the install does: the union of the
- * install's resolution path, nearest directory first, so hoisted and nested layouts both hold.
- */
-function linkModules(packageDir, target) {
-    mkdirSync(target, { recursive: true });
-    for (const source of moduleDirectoriesFrom(packageDir)) {
-        for (const name of readdirSync(source)) {
-            if (name === ".bin")
-                continue;
-            const scoped = name.startsWith("@") && statSync(join(source, name)).isDirectory();
-            if (!scoped) {
-                if (!occupied(join(target, name)))
-                    linkEntry(join(source, name), join(target, name));
-                continue;
-            }
-            mkdirSync(join(target, name), { recursive: true });
-            linkChildren(join(source, name), join(target, name), new Set());
-        }
-    }
-}
 function packageRootFrom(dir, packageName) {
     for (const modules of moduleDirectoriesFrom(dir)) {
         const root = join(modules, packageName);
@@ -88,31 +77,109 @@ function packageRootFrom(dir, packageName) {
     }
     return undefined;
 }
-function verifyExternals(packageDir, snapshotBundleDir, externals) {
+function dependencyNames(packageDir) {
+    const manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8"));
+    if (typeof manifest !== "object" || manifest === null)
+        return [];
+    const names = new Set();
+    for (const field of ["dependencies", "optionalDependencies", "peerDependencies"]) {
+        const block = manifest[field];
+        if (typeof block === "object" && block !== null)
+            for (const name of Object.keys(block))
+                names.add(name);
+    }
+    return [...names];
+}
+function closureNames(packageDir, extra) {
+    const names = new Set(extra);
+    const visited = new Set();
+    const pending = [realpathSync(packageDir)];
+    for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
+        if (visited.has(dir))
+            continue;
+        visited.add(dir);
+        for (const name of dependencyNames(dir)) {
+            names.add(name);
+            const root = packageRootFrom(dir, name);
+            if (root !== undefined && !visited.has(root))
+                pending.push(root);
+        }
+    }
+    return names;
+}
+/**
+ * The snapshot's own `node_modules`: a copy of every package the install's dependency graph
+ * reaches, placed so each one resolves its dependencies to copies of exactly the packages the
+ * install resolves them to. Each name first goes where the package itself would find it (the
+ * nearest copy, nested or hoisted); a package that needs another copy of a name gets it nested
+ * under itself. Returns the snapshot path of each placed package and the install copy it holds.
+ */
+function planModules(packageDir, snapshotRoot, externals, files) {
+    const self = realpathSync(packageDir);
+    const placed = new Map();
+    const pending = [];
+    const place = (installDir, snapshotDir) => {
+        planTree(installDir, snapshotDir, files, true);
+        placed.set(snapshotDir, installDir);
+        pending.push({ installDir, snapshotDir });
+    };
+    const resolvePlaced = (from, name) => {
+        for (let dir = from;; dir = dirname(dir)) {
+            if (basename(dir) !== "node_modules") {
+                const found = placed.get(join(dir, "node_modules", name));
+                if (found !== undefined)
+                    return found;
+            }
+            if (dir === snapshotRoot || dirname(dir) === dir)
+                return undefined;
+        }
+    };
+    for (const name of closureNames(packageDir, externals)) {
+        const source = packageRootFrom(packageDir, name);
+        if (source !== undefined && source !== self)
+            place(source, join(snapshotRoot, "node_modules", name));
+    }
+    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+        for (const name of dependencyNames(next.installDir)) {
+            const expected = packageRootFrom(next.installDir, name);
+            if (expected === undefined || expected === self)
+                continue;
+            if (resolvePlaced(next.snapshotDir, name) !== expected) {
+                place(expected, join(next.snapshotDir, "node_modules", name));
+            }
+        }
+    }
+    return placed;
+}
+/** Each external the bundle imports must resolve, from the snapshot's bundle, to the snapshot's copy of the install's package. */
+function verifyExternals(packageDir, snapshotBundleDir, externals, placed) {
     for (const name of externals) {
         const expected = packageRootFrom(packageDir, name);
-        if (expected !== undefined && packageRootFrom(snapshotBundleDir, name) !== expected) {
+        if (expected === undefined)
+            continue;
+        const found = moduleDirectoriesFrom(snapshotBundleDir)
+            .map((modules) => join(modules, name))
+            .find((root) => existsSync(join(root, "package.json")));
+        if (found === undefined || placed.get(found) !== expected)
             throw new RuntimeSnapshotLayoutError(name);
-        }
     }
 }
 /**
- * Builds `target` as a copy of the package that no reinstall can touch: `dist/bundle` and
- * `package.json` are copied, every other entry is linked back to the install. Built beside the
- * target and renamed into place, so a crash never leaves a half-built snapshot under its name.
+ * Builds `target` as a copy of the package that no reinstall can touch: the package itself and
+ * every package its dependency graph reaches, with nothing linked back to the install, so an
+ * upgrade that deletes, rewrites or re-lays-out the install (bundledDependencies on or off) never
+ * changes what a running session loads (#2408). Built beside the target and renamed into place,
+ * so a crash never leaves a half-built snapshot under its name.
  */
-export function materializeRuntimeSnapshot(packageDir, target, manifest) {
-    const staging = join(dirname(target), `.tmp-${basename(target)}-${process.pid}`);
+export async function materializeRuntimeSnapshot(packageDir, target, manifest, copier = createSnapshotFileCopier()) {
+    const staging = join(dirname(target), `${STAGING_PREFIX}${basename(target)}-${process.pid}`);
     rmSync(staging, { recursive: true, force: true });
     try {
-        const snapshotBundleDir = join(staging, "dist", "bundle");
-        mkdirSync(join(staging, "dist"), { recursive: true });
-        cpSync(join(packageDir, "dist", "bundle"), snapshotBundleDir, { recursive: true });
-        copyFileSync(join(packageDir, "package.json"), join(staging, "package.json"));
-        linkChildren(packageDir, staging, new Set(["dist", "package.json", "node_modules"]));
-        linkChildren(join(packageDir, "dist"), join(staging, "dist"), new Set(["bundle"]));
-        linkModules(packageDir, join(staging, "node_modules"));
-        verifyExternals(packageDir, join(snapshotBundleDir, "chunks"), manifest.externals);
+        const files = [];
+        planTree(packageDir, staging, files, true);
+        const placed = planModules(packageDir, staging, manifest.externals, files);
+        await copyFiles(files, copier);
+        verifyExternals(packageDir, join(staging, "dist", "bundle", "chunks"), manifest.externals, placed);
         const marker = { buildId: manifest.buildId, installPackageDir: realpathSync(packageDir) };
         writeFileSync(join(staging, RUNTIME_SNAPSHOT_MARKER), `${JSON.stringify(marker)}\n`);
         rmSync(target, { recursive: true, force: true });