@tlockney/cdp-kernel 0.4.0 → 0.6.0

package/dist/target.js

@@ -4,17 +4,42 @@
 import { Buffer } from "node:buffer";
 import process from "node:process";
 import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
 import { join } from "node:path";
-import { asEvaluateResult, CdpAbandoned, CdpSession } from "./cdp.js";
+import { fileURLToPath } from "node:url";
+import { asEvaluateResult, CdpAbandoned, CdpError, CdpSession } from "./cdp.js";
 import { SHIM, transformCell } from "./transform.js";
 import { hostRuntime, isInsideNodeModules, runtimeDir } from "./package.js";
-const BINDING = "__cdpk_send";
+import { killOnExit } from "./children.js";
+/**
+ * The inspector keeps every object it returns a remote reference to alive
+ * until it is released, so a cell's result would never be collected (#286).
+ * Cells and lookups put theirs in these groups, which are released once the
+ * kernel is done with them.
+ */
+const CELL_GROUP = "cdpk-cell";
+const LOOKUP_GROUP = "cdpk-lookup";
+/** How long a target may take from spawn to a usable session. */
+const START_TIMEOUT_MS = 60_000;
 const MARKER_RE = /\x1b\[cdpk:(\d+)(m?)\]\x1b/;
 const MAX_MARKER_LEN = 24;
 // Lines the runtimes print to stderr on their own: inspector notices, and
 // Deno's npm/jsr "Download https://..." progress (which `deno jupyter`
-// sends to the server log rather than the notebook).
-const INSPECTOR_CHATTER = /^(?:\x1b\[[0-9;]*m)*(Debugger listening on |Debugger attached\.|For help, see: |Visit chrome:\/\/inspect|Waiting for the debugger to disconnect|Download(?:\x1b\[[0-9;]*m)* https?:\/\/).*\n/gm;
+// sends to the server log rather than the notebook). Each entry is the
+// line's start once colour codes are removed.
+const INSPECTOR_CHATTER = [
+    "Debugger listening on ",
+    "Debugger attached.",
+    "For help, see: https://nodejs.org/",
+    "Visit chrome://inspect",
+    "Waiting for the debugger to disconnect",
+];
+// Deno prints "Debugger session started." for each session the host opens
+// (#281).
+const DENO_CHATTER = [...INSPECTOR_CHATTER, "Debugger session started.", "Download http://", "Download https://"];
+const ANSI_SGR = /\x1b\[[0-9;]*m/g;
+/** A colour code cut off at the end of a chunk. */
+const PARTIAL_SGR = /\x1b(?:\[[0-9;]*)?$/;
 /** `bootstrap` is the local path of runtime/bootstrap.mjs (see runtimeDir). */
 export function launchCommand(runtime, bootstrap, { executable, denoConfig } = {}) {
     // The CDP WebSocket has no authentication, so its URL must stay private:
@@ -41,6 +66,33 @@ export function launchCommand(runtime, bootstrap, { executable, denoConfig } = {
     const node = hostRuntime() === "node" ? process.execPath : "node";
     return { cmd: executable ?? node, args: [...inspect, bootstrap] };
 }
+/**
+ * The esbuild binary this host's esbuild runs, for a Node target to compile
+ * imported TypeScript Node can't strip (#73); null when it can't be found.
+ * Resolved from esbuild's own location, so it's found in a node_modules
+ * install and in Deno's npm cache alike.
+ */
+export function esbuildBinary(resolve = import.meta.resolve, platform = process.platform, arch = process.arch) {
+    if (process.env.ESBUILD_BINARY_PATH)
+        return process.env.ESBUILD_BINARY_PATH;
+    const subpath = platform === "win32" ? "esbuild.exe" : "bin/esbuild";
+    try {
+        const main = fileURLToPath(resolve("esbuild"));
+        return createRequire(main).resolve(`@esbuild/${platform}-${arch}/${subpath}`);
+    }
+    catch {
+        return null;
+    }
+}
+/** The parsed value, or undefined for text that isn't JSON. */
+export function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
 export function isTargetMessage(value) {
     if (typeof value !== "object" || value === null)
         return false;
@@ -49,6 +101,10 @@ export function isTargetMessage(value) {
         typeof value.barrier === "number";
 }
 const MARKER_PREFIX = "\x1b[cdpk:";
+// A message record: the message's JSON, which never holds a raw ESC, between
+// "\x1b[cdpk:<" and "\x1b]" (#271).
+const RECORD_PREFIX = "\x1b[cdpk:<";
+const RECORD_RE = /\x1b\[cdpk:<([^\x1b]*)\x1b\]/;
 function isPartialMarker(tail) {
     if (tail.length >= MAX_MARKER_LEN)
         return false;
@@ -56,10 +112,13 @@ function isPartialMarker(tail) {
 }
 /**
  * Splits one output pipe into text and barrier markers, and releases them
- * in order. A gated marker (one that announces a binding message) pauses
+ * in order. A gated marker (one that announces a message) pauses
  * the pipe until `gate(n)` resolves, i.e. until that message has been
  * delivered, so later output can't overtake it. A possible partial marker
  * at the end of a chunk is held back until the next chunk decides it.
+ *
+ * With `onMessage`, the pipe also carries message records. A record stands
+ * where its gated marker would, and pauses the pipe the same way.
  */
 export class PipeDemux {
     #buffer = "";
@@ -68,28 +127,49 @@ export class PipeDemux {
     #closed = false;
     #reached = 0;
     #waiters = [];
+    /** The gated marker the pipe is paused on, if any. */
+    #gatedOn = null;
     onText;
     gate;
-    constructor(onText, gate = () => Promise.resolve()) {
+    onMessage;
+    constructor(onText, gate = () => Promise.resolve(), onMessage = null) {
         this.onText = onText;
         this.gate = gate;
+        this.onMessage = onMessage;
     }
     push(chunk) {
         this.#buffer += chunk;
         for (;;) {
             const m = MARKER_RE.exec(this.#buffer);
-            if (!m)
+            const r = this.onMessage ? RECORD_RE.exec(this.#buffer) : null;
+            const first = m && r ? (m.index < r.index ? m : r) : m ?? r;
+            if (!first)
                 break;
-            if (m.index > 0)
-                this.#items.push({ text: this.#buffer.slice(0, m.index) });
-            this.#items.push({ barrier: Number(m[1]), gated: m[2] === "m" });
-            this.#buffer = this.#buffer.slice(m.index + m[0].length);
+            if (first.index > 0)
+                this.#items.push({ text: this.#buffer.slice(0, first.index) });
+            if (first === m) {
+                this.#items.push({ barrier: Number(m[1]), gated: m[2] === "m" });
+            }
+            else {
+                // Anything else a cell prints in this shape is dropped (#122).
+                const msg = parseJson(first[1]);
+                if (isTargetMessage(msg))
+                    this.#items.push({ message: msg });
+            }
+            this.#buffer = this.#buffer.slice(first.index + first[0].length);
         }
         // Hold back a tail that could still grow into a marker, including one
-        // cut inside the "\x1b[cdpk:" prefix itself.
+        // cut inside the "\x1b[cdpk:" prefix itself, or into a record: one
+        // whose only ESC after its prefix is a final one.
         const esc = this.#buffer.lastIndexOf("\x1b");
         const tail = esc === -1 ? "" : this.#buffer.slice(esc);
-        const holdFrom = esc !== -1 && isPartialMarker(tail) ? esc : this.#buffer.length;
+        let holdFrom = esc !== -1 && isPartialMarker(tail) ? esc : this.#buffer.length;
+        const record = this.onMessage ? this.#buffer.lastIndexOf(RECORD_PREFIX) : -1;
+        if (record !== -1) {
+            const next = this.#buffer.indexOf("\x1b", record + RECORD_PREFIX.length);
+            if (next === -1 || next === this.#buffer.length - 1)
+                holdFrom = Math.min(holdFrom, record);
+        }
         if (holdFrom > 0) {
             this.#items.push({ text: this.#buffer.slice(0, holdFrom) });
             this.#buffer = this.#buffer.slice(holdFrom);
@@ -106,9 +186,22 @@ export class PipeDemux {
                     this.onText(item.text);
                     continue;
                 }
+                if ("message" in item) {
+                    this.#reach(item.message.barrier);
+                    this.onMessage?.(item.message);
+                    if (!this.#closed) {
+                        this.#gatedOn = item.message.barrier;
+                        await this.gate(item.message.barrier);
+                        this.#gatedOn = null;
+                    }
+                    continue;
+                }
                 this.#reach(item.barrier);
-                if (item.gated && !this.#closed)
+                if (item.gated && !this.#closed) {
+                    this.#gatedOn = item.barrier;
                     await this.gate(item.barrier);
+                    this.#gatedOn = null;
+                }
             }
         }
         finally {
@@ -129,6 +222,16 @@ export class PipeDemux {
             return Promise.resolve();
         return new Promise((resolve) => this.#waiters.push({ n, resolve }));
     }
+    /** Where the pipe stands, for a state dump (#237). */
+    state() {
+        return {
+            reached: this.#reached,
+            waitingFor: this.#waiters.map((w) => w.n),
+            gatedOn: this.#gatedOn,
+            queued: this.#items.length,
+            held: this.#buffer.length,
+        };
+    }
     /** Release everything (the process died). */
     close() {
         this.#closed = true;
@@ -139,6 +242,66 @@ export class PipeDemux {
         void this.#pump();
     }
 }
+/**
+ * Removes the runtime's own stderr lines (see INSPECTOR_CHATTER) and passes
+ * everything else on. A chatter line can arrive split across chunks, so a
+ * trailing partial line that could still turn out to be one is held back
+ * until its newline arrives; any other partial line passes straight through.
+ */
+export class StderrFilter {
+    #starts;
+    #emit;
+    #held = "";
+    #atLineStart = true;
+    constructor(runtime, emit) {
+        this.#starts = runtime === "deno" ? DENO_CHATTER : INSPECTOR_CHATTER;
+        this.#emit = emit;
+    }
+    push(chunk) {
+        let text = this.#held + chunk;
+        this.#held = "";
+        let out = "";
+        if (!this.#atLineStart) {
+            // The rest of a line that already went out unfiltered.
+            const nl = text.indexOf("\n");
+            if (nl === -1) {
+                this.#emit(text);
+                return;
+            }
+            out = text.slice(0, nl + 1);
+            text = text.slice(nl + 1);
+        }
+        const lines = text.split("\n");
+        const last = lines.pop();
+        for (const line of lines)
+            if (!this.#isChatter(line, false))
+                out += line + "\n";
+        if (last && this.#isChatter(last, true))
+            this.#held = last;
+        else
+            out += last;
+        this.#atLineStart = last === "" || this.#held !== "";
+        if (out)
+            this.#emit(out);
+    }
+    /** Releases a held partial line (the process died). */
+    flush() {
+        if (this.#held)
+            this.#emit(this.#held);
+        this.#held = "";
+        this.#atLineStart = true;
+    }
+    /** Whether `line` is chatter or, when `partial`, could still become chatter. */
+    #isChatter(line, partial) {
+        let plain = line.replace(ANSI_SGR, "");
+        if (partial)
+            plain = plain.replace(PARTIAL_SGR, "");
+        // Any other escape may be a PipeDemux marker, which must never be dropped or held.
+        if (plain.includes("\x1b"))
+            return false;
+        return this.#starts.some((start) => plain.startsWith(start) || (partial && start.startsWith(plain)));
+    }
+}
 /** Promises keyed by barrier number, resolvable before or after first use. */
 export class Gates {
     #map = new Map();
@@ -167,6 +330,12 @@ export class Gates {
 export class Interrupted extends Error {
     name = "Interrupted";
 }
+/** A catch handler: a call interrupt() abandoned becomes Interrupted. */
+function interrupted(what) {
+    return (err) => {
+        throw err instanceof CdpAbandoned ? new Interrupted(`${what} interrupted`) : err;
+    };
+}
 export class Target {
     runtime;
     transform = transformCell;
@@ -178,13 +347,24 @@ export class Target {
     #gates;
     #contextId;
     #messages = Promise.resolve();
+    /** Messages received but not yet delivered. */
+    #undelivered = 0;
     #interrupted = false;
     #paused = false;
+    /** Set once the main context is gone: the runtime is exiting (#130). */
+    #exiting = false;
+    #exited;
     #baselineGlobals = new Set();
     versions;
     constructor(runtime, child, shell, control, stdout, stderr, gates, contextId, versions) {
         this.runtime = runtime;
         this.#child = child;
+        this.#exited = new Promise((resolve) => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                resolve();
+            else
+                child.once("exit", () => resolve());
+        });
         this.#shell = shell;
         this.#control = control;
         this.#stdout = stdout;
@@ -208,18 +388,49 @@ export class Target {
             env.CDPK_DENO_COMPAT = "1";
         if (runtime === "deno" && options.denoConfig !== undefined)
             env.CDPK_DENO_PROJECT = "1";
+        const esbuild = runtime === "node" ? esbuildBinary() : null;
+        if (esbuild !== null)
+            env.CDPK_ESBUILD_BINARY = esbuild;
         delete env.NO_COLOR;
         const child = spawn(cmd, args, { cwd: options.cwd, stdio: ["pipe", "pipe", "pipe"], env });
+        killOnExit(child);
+        // Prompt replies and comm messages go to stdin; one written as the
+        // runtime exits fails with EPIPE, and the exit is handled on its own.
+        child.stdin.on("error", () => { });
+        // A start that fails or stalls must not leave the runtime running: its
+        // pipes and inspector sockets would keep this process alive (#52).
+        const sessions = [];
+        const timeoutMs = options.startTimeoutMs ?? START_TIMEOUT_MS;
+        let timer;
+        const stalled = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`${cmd} did not start within ${timeoutMs / 1000}s`)), timeoutMs);
+        });
+        try {
+            return await Promise.race([Target.#start(runtime, events, cmd, child, sessions), stalled]);
+        }
+        catch (error) {
+            for (const session of sessions)
+                session.close();
+            child.kill();
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    static async #start(runtime, events, cmd, child, sessions) {
         child.stdout.setEncoding("utf8");
         child.stderr.setEncoding("utf8");
         const gates = new Gates();
-        const stdout = new PipeDemux((text) => events.stream("stdout", text), (n) => gates.wait(n));
+        // Messages come only after attach(), so the target exists by then.
+        let target;
+        const stdout = new PipeDemux((text) => events.stream("stdout", text), (n) => gates.wait(n), (msg) => {
+            if (target)
+                target.#deliver(msg, events);
+        });
         const stderr = new PipeDemux((text) => events.stream("stderr", text), (n) => gates.wait(n));
-        const pushStderr = (chunk) => {
-            const text = chunk.replace(INSPECTOR_CHATTER, "");
-            if (text)
-                stderr.push(text);
-        };
+        const filter = new StderrFilter(runtime, (text) => stderr.push(text));
+        const pushStderr = (chunk) => filter.push(chunk);
         // Until the inspector URL appears, stderr carries the runtime's banner.
         const wsUrl = await new Promise((resolve, reject) => {
             let banner = "";
@@ -240,12 +451,15 @@ export class Target {
         child.stdout.on("data", (c) => stdout.push(c));
         child.once("exit", (code) => {
             gates.openAll();
+            filter.flush();
             stdout.close();
             stderr.close();
             events.exit(code);
         });
         const shell = await CdpSession.connect(wsUrl);
+        sessions.push(shell);
         const control = await CdpSession.connect(wsUrl);
+        sessions.push(control);
         const contextReady = new Promise((resolve) => {
             shell.on("Runtime.executionContextCreated", (params) => {
                 const context = params.context;
@@ -254,24 +468,34 @@ export class Target {
             });
         });
         await shell.send("Runtime.enable");
-        await shell.send("Runtime.addBinding", { name: BINDING });
         const contextId = await contextReady;
-        const target = new Target(runtime, child, shell, control, stdout, stderr, gates, contextId, { runtime: "", engine: "" });
-        shell.on("Runtime.bindingCalled", (params) => {
-            if (params.name !== BINDING || typeof params.payload !== "string")
-                return;
-            const msg = JSON.parse(params.payload);
-            if (isTargetMessage(msg))
-                target.#deliver(msg, events);
+        // The inspector socket leaves Nagle's algorithm on, so an event written
+        // just before an evaluate's reply holds that reply until the event is
+        // acknowledged, ~40 ms on Linux (#271). So the shell session, which runs
+        // the cells, takes no Runtime events (console calls among them), and
+        // messages come over stdout. The control session watches for exit.
+        await shell.send("Runtime.disable");
+        await control.send("Runtime.enable");
+        target = new Target(runtime, child, shell, control, stdout, stderr, gates, contextId, { runtime: "", engine: "" });
+        // process.exit() or Deno.exit() destroys the context, then the runtime
+        // waits for its inspector clients to disconnect before it exits. Let go,
+        // so it exits and the kernel starts a fresh one (#130).
+        control.on("Runtime.executionContextDestroyed", (params) => {
+            if (params.executionContextId === contextId && target)
+                target.#onExit();
         });
-        // Wait for the bootstrap's top-level await to finish installing the shim.
-        for (let i = 0; i < 200; i++) {
-            const probe = await target.#evaluateRaw(`typeof globalThis.${SHIM}?.tick === "function"`);
+        // Wait for the bootstrap's top-level await to finish installing the
+        // shim. There is no cap here: launch's start timeout bounds the wait and
+        // kills the child, so a slow bootstrap never yields a target without
+        // the shim (#134).
+        for (;;) {
+            const probe = await target.#evaluateSync(`typeof globalThis.${SHIM}?.tick === "function"`);
             if (probe.result.value === true)
                 break;
             await new Promise((r) => setTimeout(r, 25));
         }
-        const versions = await target.#evaluateRaw(`JSON.stringify(typeof Deno !== "undefined" ? { runtime: Deno.version.deno, engine: "V8 " + Deno.version.v8 } : { runtime: process.versions.node, engine: "V8 " + process.versions.v8 })`);
+        await target.#evaluateSync(`${SHIM}.attach()`);
+        const versions = await target.#evaluateSync(`JSON.stringify(typeof Deno !== "undefined" ? { runtime: Deno.version.deno, engine: "V8 " + Deno.version.v8 } : { runtime: process.versions.node, engine: "V8 " + process.versions.v8 })`);
         Object.assign(target.versions, JSON.parse(String(versions.result.value)));
         // The runtime's own enumerable globals, before any cell: the debugger's
         // variable views show only what cells added (#18).
@@ -293,25 +517,93 @@ export class Target {
             baselineGlobals: this.#baselineGlobals,
         };
     }
-    // Binding messages wait until both pipes have caught up to their marker,
+    // Messages wait until both pipes have caught up to their marker,
     // and are delivered strictly in order.
     #deliver(msg, events) {
+        this.#undelivered++;
         this.#messages = this.#messages.then(async () => {
             await Promise.all([this.#stdout.waitFor(msg.barrier), this.#stderr.waitFor(msg.barrier)]);
+            this.#undelivered--;
             events.message(msg);
             this.#gates.open(msg.barrier);
         });
     }
+    /**
+     * What the host is waiting on, whether the runtime still evaluates, runs
+     * immediates and runs timers, and where its JavaScript is if it is
+     * running any, for a kernel that has stopped answering (#237). The probes
+     * go over the control session, which no cell holds.
+     */
+    async diagnose() {
+        const within = (promise, fallback) => Promise.race([promise, new Promise((resolve) => setTimeout(() => resolve(fallback), 2000).unref())]);
+        const probe = (expression, awaitPromise) => within(this.#control.send("Runtime.evaluate", { expression, contextId: this.#contextId, awaitPromise, returnByValue: true })
+            .then((res) => res.exceptionDetails ? `threw: ${JSON.stringify(res.exceptionDetails)}` : String(res.result?.value), (err) => `failed: ${err}`), "no answer in 2 s");
+        const [evaluates, immediates, timers] = await Promise.all([
+            probe("'yes'", false),
+            probe("new Promise((resolve) => setImmediate(() => resolve('yes')))", true),
+            probe("new Promise((resolve) => setTimeout(() => resolve('yes'), 0))", true),
+        ]);
+        // A runtime whose event loop is stuck may be stuck in JavaScript: say
+        // where. (An idle one would take the pause in whatever runs next.)
+        let running = "event loop runs";
+        if (immediates !== "yes") {
+            try {
+                const paused = new Promise((resolve) => this.#control.on("Debugger.paused", resolve));
+                await this.#control.send("Debugger.enable");
+                await this.#control.send("Debugger.pause");
+                const event = await within(paused, null);
+                running = event === null ? "no" : event.callFrames
+                    .slice(0, 10)
+                    .map((f) => `${f.functionName || "(anonymous)"} ${f.url || "(no url)"}:${f.location.lineNumber + 1}`);
+                await this.#control.send("Debugger.resume").catch(() => { });
+                await this.#control.send("Debugger.disable");
+            }
+            catch (err) {
+                running = `failed: ${err}`;
+            }
+        }
+        return {
+            pid: this.#child.pid ?? null,
+            calls: { shell: this.#shell.pendingCalls(), control: this.#control.pendingCalls() },
+            stdout: this.#stdout.state(),
+            stderr: this.#stderr.state(),
+            undelivered: this.#undelivered,
+            paused: this.#paused,
+            exiting: this.#exiting,
+            evaluates,
+            immediates,
+            timers,
+            running,
+        };
+    }
     /** Resolves once all output and messages sent so far have been delivered. */
     async flush() {
-        const n = await this.#evaluateRaw(`${SHIM}.barrier()`);
+        const n = await this.#evaluateSync(`${SHIM}.barrier()`).catch(interrupted("Execution"));
         const barrier = Number(n.result.value);
         await Promise.all([this.#stdout.waitFor(barrier), this.#stderr.waitFor(barrier)]);
         await this.#messages;
     }
+    /**
+     * For expressions that return a value without awaiting. With replMode or
+     * awaitPromise, the inspector holds the result promise only weakly until
+     * its then-callback runs, even when the expression returns a plain value:
+     * a GC in that window fails the call with "Promise was collected" (#50).
+     * A plain evaluate returns the value directly.
+     */
+    #evaluateSync(expression) {
+        return this.#shell
+            .send("Runtime.evaluate", { expression, contextId: this.#contextId, returnByValue: true })
+            .then(asEvaluateResult);
+    }
     #evaluateRaw(expression, session = this.#shell) {
         return session
-            .send("Runtime.evaluate", { expression, contextId: this.#contextId, replMode: true, awaitPromise: true })
+            .send("Runtime.evaluate", {
+            expression,
+            contextId: this.#contextId,
+            replMode: true,
+            awaitPromise: true,
+            objectGroup: CELL_GROUP,
+        })
             .then(asEvaluateResult);
     }
     /** Runs transformed cell code. Rejects with Interrupted after interrupt(). */
@@ -323,9 +615,36 @@ export class Target {
         catch (err) {
             if (err instanceof CdpAbandoned || this.#interrupted)
                 throw new Interrupted("Execution interrupted");
+            // The control session's executionContextDestroyed event can arrive
+            // after the shell session's error reply (#271 moved it there).
+            if (err instanceof CdpError && err.message.includes("Execution context was destroyed"))
+                this.#onExit();
+            if (this.#exiting) {
+                // The child's exit, which drops this target in the kernel, comes
+                // first, so the next cell starts a fresh one.
+                await this.#exited;
+                throw new Error(`${this.runtime} exited`);
+            }
             throw err;
         }
     }
+    async releaseResults() {
+        if (this.#exiting)
+            return;
+        await this.#shell.send("Runtime.releaseObjectGroup", { objectGroup: CELL_GROUP }).catch(() => { });
+    }
+    #onExit() {
+        if (this.#exiting)
+            return;
+        this.#exiting = true;
+        this.#shell.close();
+        this.#control.close();
+        // In case it still doesn't exit once both sessions are gone.
+        setTimeout(() => {
+            if (this.#child.exitCode === null && this.#child.signalCode === null)
+                this.#child.kill("SIGKILL");
+        }, 2000).unref();
+    }
     /**
      * Deno calls IsolateHandle::terminate_execution from another thread. The
      * CDP equivalent is Runtime.terminateExecution, sent on a second session
@@ -341,11 +660,27 @@ export class Target {
         await this.#control.send("Runtime.terminateExecution");
         this.#shell.abandonPending();
     }
+    /**
+     * For synchronous functions. With awaitPromise the inspector would wrap
+     * even a plain return value in a promise it holds only weakly (#55).
+     */
     callFunctionOn(functionDeclaration, args) {
         return this.#shell.send("Runtime.callFunctionOn", {
             functionDeclaration,
             arguments: args,
             executionContextId: this.#contextId,
+            returnByValue: true,
+        });
+    }
+    /**
+     * For functions that return a promise. The target holds it until after
+     * the inspector's then-callback has run, so a GC can't collect it first.
+     */
+    #callAsyncFunctionOn(functionDeclaration, args) {
+        return this.#shell.send("Runtime.callFunctionOn", {
+            functionDeclaration: `function (...args) { return globalThis.${SHIM}.hold((${functionDeclaration}).apply(this, args)); }`,
+            arguments: args,
+            executionContextId: this.#contextId,
             awaitPromise: true,
             returnByValue: true,
         });
@@ -357,10 +692,12 @@ export class Target {
             : result.unserializableValue !== undefined
                 ? { unserializableValue: result.unserializableValue }
                 : { value: result.value };
-        await this.callFunctionOn(`function (n, r) { return globalThis.${SHIM}.broadcastResult(n, r); }`, [
+        // An async $display method can still be running when interrupt()
+        // abandons the call (#135).
+        await this.#callAsyncFunctionOn(`function (n, r) { return globalThis.${SHIM}.broadcastResult(n, r); }`, [
             { value: executionCount },
             arg,
-        ]);
+        ]).catch(interrupted("Execution"));
     }
     /**
      * Hands a frontend comm message to the target's comms. Resolves to
@@ -369,20 +706,19 @@ export class Target {
      */
     async dispatchComm(msgType, content, metadata, buffers) {
         this.#interrupted = false;
+        // Over stdin, not as call arguments: V8 caches an argument's source,
+        // so the data would stay in the target's memory (#287).
+        const record = Buffer.from(JSON.stringify({
+            msgType,
+            content,
+            metadata,
+            buffers: buffers.map((b) => Buffer.from(b).toString("base64")),
+        }));
+        this.#child.stdin.write(`comm ${record.length}\n`);
+        this.#child.stdin.write(record);
         let res;
         try {
-            res = await this.#shell.send("Runtime.callFunctionOn", {
-                functionDeclaration: `function (t, c, m, b) { return globalThis.${SHIM}.commDispatch(t, c, m, b); }`,
-                arguments: [
-                    { value: msgType },
-                    { value: content },
-                    { value: metadata },
-                    { value: buffers.map((b) => Buffer.from(b).toString("base64")) },
-                ],
-                executionContextId: this.#contextId,
-                awaitPromise: true,
-                returnByValue: true,
-            });
+            res = await this.#callAsyncFunctionOn(`function () { return globalThis.${SHIM}.commDispatchFromStdin(); }`, []);
         }
         catch (err) {
             if (err instanceof CdpAbandoned || this.#interrupted)
@@ -407,14 +743,28 @@ export class Target {
     /**
      * Evaluates without side effects: V8 throws instead of running anything
      * that would change state (a call, a getter that writes), so completing
-     * or inspecting `obj.` never runs user code (#10).
+     * or inspecting `obj.` never runs user code (#10). Not replMode, which
+     * returns a promise the inspector holds only weakly (#55); a plain
+     * evaluate sees the cells' let and const too.
      */
     #evaluatePure(expression) {
         return this.#shell
-            .send("Runtime.evaluate", { expression, contextId: this.#contextId, replMode: true, throwOnSideEffect: true })
-            .then(asEvaluateResult, () => null);
+            .send("Runtime.evaluate", { expression, contextId: this.#contextId, throwOnSideEffect: true, objectGroup: LOOKUP_GROUP })
+            .then(asEvaluateResult)
+            .catch(() => null);
+    }
+    #releaseLookup() {
+        return this.#shell.send("Runtime.releaseObjectGroup", { objectGroup: LOOKUP_GROUP }).then(() => { }, () => { });
     }
     async propertyNames(expression) {
+        try {
+            return await this.#propertyNames(expression);
+        }
+        finally {
+            await this.#releaseLookup();
+        }
+    }
+    async #propertyNames(expression) {
         const evaluated = await this.#evaluatePure(`(${expression})`);
         const objectId = evaluated?.result.objectId;
         if (!objectId || evaluated?.exceptionDetails)
@@ -424,6 +774,14 @@ export class Target {
         return (list ?? []).map((p) => p.name);
     }
     async inspect(path, detail) {
+        try {
+            return await this.#inspect(path, detail);
+        }
+        finally {
+            await this.#releaseLookup();
+        }
+    }
+    async #inspect(path, detail) {
         const found = await this.#evaluatePure(path);
         if (!found || found.exceptionDetails)
             return null;
@@ -444,8 +802,8 @@ export class Target {
         const res = await this.#shell.send("Runtime.globalLexicalScopeNames", { executionContextId: this.#contextId });
         return res.names ?? [];
     }
-    replyInput(value) {
-        this.#child.stdin.write(JSON.stringify({ value }) + "\n");
+    replyInput(value, interrupted = false) {
+        this.#child.stdin.write(JSON.stringify({ value, interrupted }) + "\n");
     }
     kill() {
         this.#shell.close();