@tlockney/cdp-kernel 0.4.0 → 0.6.0

package/dist/kernel.js

@@ -5,20 +5,25 @@
 // The thirteen op_jupyter_* calls into Deno's REPL isolate are replaced by
 // a Target driven over CDP (src/target.ts).
 import { Buffer } from "node:buffer";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
 import process from "node:process";
 import { randomUUID } from "node:crypto";
-import { decodeMessage, encodeMessage, PROTOCOL_VERSION, verify } from "./wire.js";
-import { PubSocket, RouterSocket, startHeartbeat } from "./zmtp.js";
+import { decodeMessage, encodeMessage, makeHeader, PROTOCOL_VERSION, verify } from "./wire.js";
+import { listening, PubSocket, RouterSocket, startHeartbeat } from "./zmtp.js";
 import { Interrupted, Target } from "./target.js";
 import { BunTarget } from "./bun-target.js";
 import { Debugger } from "./debugger.js";
 import { WorkerdTarget } from "./workerd-target.js";
 import { launchCelld } from "./celld-target.js";
-import { CellSyntaxError, objectLiteralCandidate } from "./transform.js";
+import { CellSyntaxError, loadTypeStripper, objectLiteralCandidate, } from "./transform.js";
 import { loadDenoProject } from "./deno-config.js";
 import { checkIsComplete, codePointToUtf16Index, exprAtCursor, inspectTarget, utf16ToCodePointIndex } from "./text.js";
 import { queryHistory } from "./history.js";
+import { LanguageService } from "./language-service.js";
+import { findWranglerConfig } from "./workers-project.js";
 import { VERSION } from "./package.js";
+import { watchParent } from "./parent.js";
 export function parseConnectionInfo(json) {
     const raw = JSON.parse(json);
     if (typeof raw !== "object" || raw === null)
@@ -28,6 +33,10 @@ export function parseConnectionInfo(json) {
         if (typeof info[port] !== "number")
             throw new Error(`connection file: missing ${port}`);
     }
+    for (const field of ["ip", "key"]) {
+        if (info[field] !== undefined && typeof info[field] !== "string")
+            throw new Error(`connection file: ${field} is not a string`);
+    }
     if (info.transport !== undefined && info.transport !== "tcp") {
         throw new Error(`unsupported transport ${info.transport}; only tcp is implemented`);
     }
@@ -46,16 +55,88 @@ export function parseConnectionInfo(json) {
         hb_port: info.hb_port,
     };
 }
+/**
+ * How long interrupt_request may wait on the target before it's answered
+ * anyway (#121). Under the 5 s clients allow control requests (#253).
+ */
+const INTERRUPT_REPLY_WAIT_MS = 1_000;
+const NO_INPUT = { value: null, interrupted: false };
+/** Shell requests other than execute_request, and their reply types. */
+const SHELL_REPLIES = {
+    kernel_info_request: "kernel_info_reply",
+    complete_request: "complete_reply",
+    is_complete_request: "is_complete_reply",
+    inspect_request: "inspect_reply",
+    history_request: "history_reply",
+    comm_info_request: "comm_info_reply",
+};
+/** The target Node's major version, for @types/node: the host's, which is usually the same binary. */
+function nodeMajor() {
+    return process.versions.node?.split(".")[0] ?? "*";
+}
+/**
+ * Where the language service gets each target's globals and imports from
+ * (#273, #275). A `--deno-compat` Node target gets Node's types only: its
+ * `Deno` namespace is partial, and Deno's declarations would promise
+ * members it doesn't have.
+ */
+function languageServiceOptions(runtime, notebookDir, project) {
+    const base = { notebookDir, npmCache: "npm", deno: null, denoTypes: false, typeFiles: [], typePackages: [] };
+    switch (runtime) {
+        case "node":
+            return { ...base, typePackages: [{ name: "@types/node", range: nodeMajor() }] };
+        case "deno":
+            return { ...base, npmCache: null, deno: { config: project?.configPath ?? null }, denoTypes: true };
+        case "bun":
+            return { ...base, npmCache: "bun", typePackages: [{ name: "@types/bun", range: "1" }] };
+        case "workerd":
+        case "celld": {
+            // A Workers project's own types (`wrangler types`) know its bindings.
+            const config = findWranglerConfig(notebookDir);
+            const generated = config === null ? null : join(dirname(config), "worker-configuration.d.ts");
+            return generated !== null && existsSync(generated)
+                ? { ...base, typeFiles: [generated] }
+                : { ...base, typePackages: [{ name: "@cloudflare/workers-types", range: "*" }] };
+        }
+    }
+}
+/** Runtime inspection text without its Type and Signature lines, which the declared type replaces. */
+function withoutSignature(text) {
+    return text.split("\n").filter((line) => !/^(?:Type|Signature): /.test(line)).join("\n");
+}
+/** A TypeScript completion kind as a Jupyter completion type (JupyterLab picks its icon by these). */
+function jupyterType(kind) {
+    switch (kind) {
+        case undefined:
+            return "<unknown>";
+        case "var":
+        case "let":
+        case "const":
+        case "local var":
+        case "parameter":
+            return "variable";
+        case "local function":
+            return "function";
+        case "type":
+        case "alias":
+            return "type";
+        default:
+            return kind;
+    }
+}
 export class Kernel {
     #conn;
     #runtime;
     #denoCompat;
+    #typeStrip;
     // A Deno target in a Deno project uses its config (#13).
     #project;
     #projectWarning = null;
     #noticeShownFor = null;
     /** JupyterLab's visual debugger, for targets driven over CDP (#18). */
     #debugger;
+    /** Typed completion from TypeScript's language service (#273). */
+    #types;
     /** Cells run with store_history, for history_request (#10). */
     #history = [];
     #session = randomUUID();
@@ -63,12 +144,26 @@ export class Kernel {
     #control;
     #stdin;
     #iopub;
+    /** Settles once all five ports are bound (#257). */
+    #bound;
     #target = null;
     #targetStarting = null;
     #executionCount = 0;
     #parent = {};
     #allowStdin = false;
     #executing = false;
+    /**
+     * stop_on_error (#123): how many of the shell messages queued when a cell
+     * failed are still to come, and whether the one being handled is one.
+     */
+    #abortQueued = 0;
+    #aborting = false;
+    /** The input_request waiting for its input_reply, if any. */
+    #input = null;
+    /** An interrupt is waiting on the target. */
+    #interrupting = false;
+    /** The shell message being handled, and since when. */
+    #handling = null;
     // Open comms, for comm_info_request: comm_id -> target_name (#9).
     #comms = new Map();
     #shuttingDown = false;
@@ -76,26 +171,68 @@ export class Kernel {
         this.#conn = conn;
         this.#runtime = runtime;
         this.#denoCompat = options.denoCompat ?? false;
-        this.#project = runtime === "deno" ? this.#loadProject(options.notebookDir ?? process.cwd()) : null;
+        this.#typeStrip = options.typeStrip ?? "esbuild";
+        const notebookDir = options.notebookDir ?? process.cwd();
+        this.#project = runtime === "deno" ? this.#loadProject(notebookDir) : null;
+        this.#types = options.languageService === false
+            ? null
+            : new LanguageService(languageServiceOptions(runtime, notebookDir, this.#project), { log: (text) => this.#log(text) });
         this.#debugger = runtime === "node" || runtime === "deno"
             ? new Debugger((event) => this.#publish("debug_event", event), () => this.#transformOptions())
             : null;
-        startHeartbeat(conn.hb_port, conn.ip);
+        const heartbeat = startHeartbeat(conn.hb_port, conn.ip);
         this.#shell = new RouterSocket(conn.shell_port, conn.ip);
         this.#control = new RouterSocket(conn.control_port, conn.ip);
         this.#stdin = new RouterSocket(conn.stdin_port, conn.ip);
         this.#iopub = new PubSocket(conn.iopub_port, conn.ip);
+        this.#bound = Promise.all([heartbeat, this.#shell.server, this.#control.server, this.#stdin.server, this.#iopub.server].map(listening));
     }
     async run() {
         // Start the runtime eagerly so the first cell doesn't pay for it.
         this.#ensureTarget().catch((err) => this.#log(`target failed to start: ${err}`));
         process.on("SIGINT", () => void this.#interrupt());
+        // Exiting runs the exit hook that kills the runtime (src/children.ts);
+        // these signals' default action would skip it (#218).
+        for (const [signal, code] of [["SIGTERM", 143], ["SIGHUP", 129]]) {
+            process.on(signal, () => {
+                this.#shuttingDown = true;
+                process.exit(code);
+            });
+        }
+        // A server killed before it could shut the kernel down (#254).
+        watchParent(() => {
+            this.#log(`parent ${process.env.JPY_PARENT_PID} exited; shutting down`);
+            this.#shuttingDown = true;
+            process.exit(1);
+        });
+        // A state dump on stderr, for a kernel that has stopped answering (#237).
+        if (process.platform !== "win32")
+            process.on("SIGUSR2", () => void this.#logState());
+        // Transforms are synchronous, so the stripper loads before any cell.
+        if (typeof this.#typeStrip === "string")
+            await loadTypeStripper(this.#typeStrip);
         await Promise.all([this.#loop(this.#shell, (m, p) => this.#handleShell(m, p)),
-            this.#loop(this.#control, (m, p) => this.#handleControl(m, p))]);
+            this.#loop(this.#control, (m, p) => this.#handleControl(m, p)),
+            this.#loop(this.#stdin, (m) => this.#handleStdin(m))]);
     }
     #log(text) {
         process.stderr.write(`[cdp-kernel] ${text}\n`);
     }
+    async #logState() {
+        const handling = this.#handling;
+        const target = this.#target;
+        let targetState = target === null ? (this.#targetStarting === null ? null : "starting") : target.runtime;
+        if (target?.diagnose)
+            targetState = await target.diagnose().catch((err) => `diagnose failed: ${err}`);
+        this.#log(`state: ${JSON.stringify({
+            shell: handling && { msgType: handling.msgType, msgId: handling.msgId, ms: Date.now() - handling.since },
+            queued: this.#shell.incoming.size,
+            executing: this.#executing,
+            interrupting: this.#interrupting,
+            awaitingInput: this.#input !== null,
+            target: targetState,
+        })}`);
+    }
     #loadProject(notebookDir) {
         try {
             return loadDenoProject(notebookDir);
@@ -110,7 +247,7 @@ export class Kernel {
         }
     }
     #transformOptions() {
-        return this.#project?.transform ?? {};
+        return { ...this.#project?.transform, typeStrip: this.#typeStrip };
     }
     // --- comms (#9) ------------------------------------------------------------
     #trackComm(msgType, content) {
@@ -190,7 +327,10 @@ export class Kernel {
     #ensureTarget() {
         if (this.#target)
             return Promise.resolve(this.#target);
-        this.#targetStarting ??= this.#launchTarget().then(async (target) => {
+        // Not before the kernel's own ports are bound: a Deno runtime binds its
+        // inspector to port 0 within milliseconds of starting and can take a
+        // connection-file port the kernel is still binding (#257).
+        this.#targetStarting ??= this.#bound.then(() => this.#launchTarget()).then(async (target) => {
             // Before any cell runs on it, so breakpoints already apply.
             await this.#debugger?.attachTarget(target.debug ?? null);
             this.#target = target;
@@ -205,9 +345,13 @@ export class Kernel {
     #targetEvents() {
         return {
             stream: (name, text) => this.#publish("stream", { name, text }),
-            message: (msg) => void this.#onTargetMessage(msg),
+            message: (msg) => void this.#onTargetMessage(msg).catch((err) => this.#log(`error handling target message: ${err}`)),
             exit: (code, note) => {
                 this.#target = null;
+                // What its cells declared died with it.
+                this.#types?.reset();
+                // Its prompt, if any, died with it; a late reply is dropped.
+                this.#input = null;
                 void this.#debugger?.attachTarget(null);
                 if (!this.#shuttingDown) {
                     const text = note ?? `[cdp-kernel] ${this.#runtime} exited (${code}); restarting on next cell`;
@@ -225,18 +369,37 @@ export class Kernel {
             });
             return;
         }
-        let value = null;
+        // The answer goes to the target that asked, not one started since.
+        const target = this.#target;
+        let answer = NO_INPUT;
         try {
-            value = await this.#requestInput(msg.prompt, msg.password);
+            answer = await this.#requestInput(msg.prompt, msg.password);
         }
         finally {
             // Always answer exactly once so the target's blocking read returns.
-            this.#target?.replyInput(value);
+            if (target !== null && target === this.#target)
+                target.replyInput(answer.value, answer.interrupted);
         }
     }
     async #interrupt() {
-        if (this.#target && this.#executing)
+        // A target blocked reading its prompt's answer can't run
+        // terminateExecution, and would never answer it. Make the prompt throw
+        // instead, which ends the cell (#121).
+        const input = this.#input;
+        if (input !== null) {
+            this.#input = null;
+            input.settle({ value: null, interrupted: true });
+            return;
+        }
+        if (!this.#target || !this.#executing)
+            return;
+        this.#interrupting = true;
+        try {
             await this.#target.interrupt();
+        }
+        finally {
+            this.#interrupting = false;
+        }
     }
     // --- messaging --------------------------------------------------------------
     #encode(msgType, content, parentHeader, extra = {}) {
@@ -254,16 +417,27 @@ export class Kernel {
     async #loop(socket, handle) {
         while (!this.#shuttingDown) {
             const { peer, frames } = await socket.recv();
+            if (socket === this.#shell) {
+                this.#aborting = this.#abortQueued > 0;
+                if (this.#aborting)
+                    this.#abortQueued--;
+            }
             try {
                 const msg = decodeMessage(frames);
                 // Unsigned or forged messages are dropped, as in Deno.
                 if (!verify(this.#conn.key, msg.signedParts, msg.sig))
                     continue;
+                if (socket === this.#shell)
+                    this.#handling = { msgType: msg.header.msg_type, msgId: msg.header.msg_id, since: Date.now() };
                 await handle(msg, peer);
             }
             catch (err) {
                 this.#log(`error handling message: ${err instanceof Error ? err.stack : err}`);
             }
+            finally {
+                if (socket === this.#shell)
+                    this.#handling = null;
+            }
         }
     }
     #kernelInfo() {
@@ -282,7 +456,8 @@ export class Kernel {
                 codemirror_mode: "typescript",
                 nbconvert_exporter: "script",
             },
-            banner: `cdp-kernel on ${this.#runtime} ${versions?.runtime ?? ""} (${versions?.engine || "?"})`,
+            // The runtime's versions are known once it is up.
+            banner: versions ? `cdp-kernel on ${this.#runtime} ${versions.runtime} (${versions.engine || "?"})` : `cdp-kernel on ${this.#runtime}`,
             help_links: [],
             debugger: this.#debugger !== null,
             // What current ipykernel advertises; JupyterLab itself goes by the
@@ -292,40 +467,48 @@ export class Kernel {
     }
     // --- control channel ------------------------------------------------------
     async #handleControl(msg, peer) {
+        // Every request is wrapped in busy/idle, as on shell (#124). JupyterLab
+        // treats a debug request as done only once the kernel reports idle for
+        // it. (Jupyter Server leaves debug_request out of the kernel's status.)
+        this.#status("busy", msg.header);
+        try {
+            await this.#controlRequest(this.#control, msg, peer);
+        }
+        finally {
+            this.#status("idle", msg.header);
+        }
+    }
+    /** Control requests; shutdown and interrupt may also arrive on shell (#124). */
+    async #controlRequest(socket, msg, peer) {
         switch (msg.header.msg_type) {
             case "kernel_info_request":
-                this.#reply(this.#control, peer, msg, "kernel_info_reply", this.#kernelInfo());
+                this.#reply(socket, peer, msg, "kernel_info_reply", this.#kernelInfo());
                 break;
             case "interrupt_request":
-                await this.#interrupt();
-                this.#reply(this.#control, peer, msg, "interrupt_reply", { status: "ok" });
+                // Answer even if the target doesn't (#121); the interrupt goes on.
+                await Promise.race([
+                    this.#interrupt().catch((err) => this.#log(`interrupt failed: ${err}`)),
+                    new Promise((r) => setTimeout(r, INTERRUPT_REPLY_WAIT_MS)),
+                ]);
+                this.#reply(socket, peer, msg, "interrupt_reply", { status: "ok" });
                 break;
             case "debug_request": {
-                // JupyterLab treats a debug request as done only once the kernel
-                // reports idle for it, as ipykernel does for control messages.
-                // (Jupyter Server leaves debug_request out of the kernel's status.)
-                this.#status("busy", msg.header);
                 let reply;
-                try {
-                    if (this.#debugger === null) {
-                        reply = { type: "response", request_seq: msg.content.seq, command: msg.content.command, success: false, message: `${this.#runtime} targets have no debugger`, body: {} };
-                    }
-                    else {
-                        // Everything but debugInfo talks to the target, so make sure there is one.
-                        if (msg.content.command !== "debugInfo")
-                            await this.#ensureTarget().catch(() => null);
-                        reply = await this.#debugger.handle(msg.content);
-                    }
-                    this.#reply(this.#control, peer, msg, "debug_reply", reply);
+                if (this.#debugger === null) {
+                    reply = { type: "response", request_seq: msg.content.seq, command: msg.content.command, success: false, message: `${this.#runtime} targets have no debugger`, body: {} };
                 }
-                finally {
-                    this.#status("idle", msg.header);
+                else {
+                    // Everything but debugInfo talks to the target, so make sure there is one.
+                    if (msg.content.command !== "debugInfo")
+                        await this.#ensureTarget().catch(() => null);
+                    reply = await this.#debugger.handle(msg.content);
                 }
+                this.#reply(socket, peer, msg, "debug_reply", reply);
                 break;
             }
             case "shutdown_request": {
                 const restart = msg.content.restart === true;
-                this.#reply(this.#control, peer, msg, "shutdown_reply", { status: "ok", restart });
+                this.#reply(socket, peer, msg, "shutdown_reply", { status: "ok", restart });
                 this.#shuttingDown = true;
                 this.#target?.kill();
                 // Frontends spawn a fresh kernel even on restart; exit after the
@@ -344,7 +527,8 @@ export class Kernel {
         try {
             switch (type) {
                 case "kernel_info_request":
-                    await this.#ensureTarget().catch(() => null);
+                    // Without waiting for the runtime: clients probe with kernel_info
+                    // while it starts, and re-send until answered (#253).
                     this.#reply(this.#shell, peer, msg, "kernel_info_reply", this.#kernelInfo());
                     break;
                 case "complete_request":
@@ -367,21 +551,49 @@ export class Kernel {
                 case "comm_close":
                     await this.#handleComm(msg);
                     break;
+                case "shutdown_request":
+                case "interrupt_request":
+                    // Deprecated on shell, but still allowed, and ipykernel takes them.
+                    await this.#controlRequest(this.#shell, msg, peer);
+                    break;
+                default:
+                    this.#log(`ignoring unknown shell message ${type}`);
             }
         }
+        catch (err) {
+            // E.g. the runtime failed to launch. Answer anyway, so the frontend
+            // doesn't wait on the request forever (#125).
+            const replyType = SHELL_REPLIES[type];
+            if (replyType !== undefined) {
+                const name = err instanceof Error ? err.name : "Error";
+                const message = err instanceof Error ? err.message : String(err);
+                const error = { ename: name, evalue: message, traceback: [`${name}: ${message}`] };
+                this.#reply(this.#shell, peer, msg, replyType, { status: "error", ...error });
+            }
+            throw err;
+        }
         finally {
             this.#status("idle", msg.header);
         }
     }
-    /** The tooltip (Shift-Tab) for the name at the cursor (#10). */
+    /**
+     * The tooltip (Shift-Tab) for the name at the cursor (#10): its declared
+     * type, signature and JSDoc when the language service knows them (#274),
+     * then what the runtime finds.
+     */
     async #inspect(msg) {
         const code = String(msg.content.code ?? "");
         const cursorCp = typeof msg.content.cursor_pos === "number"
             ? msg.content.cursor_pos
             : utf16ToCodePointIndex(code, code.length);
-        const path = inspectTarget(code, codePointToUtf16Index(code, cursorCp));
+        const cursor = codePointToUtf16Index(code, cursorCp);
+        const path = inspectTarget(code, cursor);
         const detail = msg.content.detail_level === 1 ? 1 : 0;
-        const text = path === null ? null : await (await this.#ensureTarget()).inspect(path, detail);
+        const [runtime, typed] = await Promise.all([
+            path === null ? null : (async () => (await this.#ensureTarget()).inspect(path, detail))(),
+            this.#types?.quickInfo(code, cursor) ?? null,
+        ]);
+        const text = typed === null ? runtime : runtime === null ? typed : `${typed}\n\n${withoutSignature(runtime)}`;
         return text === null
             ? { status: "ok", found: false, data: {}, metadata: {} }
             : { status: "ok", found: true, data: { "text/plain": text }, metadata: {} };
@@ -392,48 +604,96 @@ export class Kernel {
             ? msg.content.cursor_pos
             : utf16ToCodePointIndex(code, code.length);
         const cursor = codePointToUtf16Index(code, cursorCp);
-        const expr = exprAtCursor(code, cursor);
-        const target = await this.#ensureTarget();
-        let matches;
-        let start;
-        const dot = expr.lastIndexOf(".");
-        if (dot !== -1) {
-            const prefix = expr.slice(dot + 1);
-            matches = (await target.propertyNames(expr.slice(0, dot)))
-                .filter((name) => name.startsWith(prefix) && !name.startsWith("Symbol("));
-            start = cursor - prefix.length;
+        // Both at once: the language service may not answer within its budget.
+        const [runtime, typed] = await Promise.all([
+            this.#runtimeCompletions(code, cursor),
+            this.#types?.complete(code, cursor) ?? null,
+        ]);
+        // Declared types first, then what only the runtime knows (a property
+        // added at runtime, a global defined by a library).
+        let matches = runtime.matches;
+        let start = runtime.start;
+        const kinds = new Map();
+        if (typed !== null && typed.start === runtime.start) {
+            for (const entry of typed.entries)
+                kinds.set(entry.name, entry.kind);
+            matches = [...kinds.keys(), ...runtime.matches.filter((name) => !kinds.has(name))];
         }
-        else {
-            const names = new Set([...(await target.propertyNames("globalThis")), ...(await target.lexicalNames())]);
-            matches = [...names].filter((name) => name.startsWith(expr) && !name.startsWith("__cdpk")).sort();
-            start = cursor - expr.length;
+        else if (typed !== null && typed.entries.length > 0 && runtime.matches.length === 0) {
+            // An expression the runtime can't complete, e.g. inside a call.
+            for (const entry of typed.entries)
+                kinds.set(entry.name, entry.kind);
+            matches = [...kinds.keys()];
+            start = typed.start;
         }
+        const cursorStart = utf16ToCodePointIndex(code, start);
         return {
             status: "ok",
             matches,
-            cursor_start: utf16ToCodePointIndex(code, start),
+            cursor_start: cursorStart,
             cursor_end: cursorCp,
-            metadata: {},
+            metadata: kinds.size === 0 ? {} : {
+                // JupyterLab shows each match's type as an icon.
+                _jupyter_types_experimental: matches.map((text) => ({
+                    start: cursorStart,
+                    end: cursorCp,
+                    text,
+                    type: jupyterType(kinds.get(text)),
+                })),
+            },
         };
     }
+    /** Completion from the runtime's values: property names, globals, lexical names. */
+    async #runtimeCompletions(code, cursor) {
+        const expr = exprAtCursor(code, cursor);
+        const target = await this.#ensureTarget();
+        const dot = expr.lastIndexOf(".");
+        if (dot !== -1) {
+            const prefix = expr.slice(dot + 1);
+            const matches = (await target.propertyNames(expr.slice(0, dot)))
+                .filter((name) => name.startsWith(prefix) && !name.startsWith("Symbol("));
+            return { matches, start: cursor - prefix.length };
+        }
+        const names = new Set([...(await target.propertyNames("globalThis")), ...(await target.lexicalNames())]);
+        const matches = [...names].filter((name) => name.startsWith(expr) && !name.startsWith("__cdpk")).sort();
+        return { matches, start: cursor - expr.length };
+    }
     async #requestInput(prompt, password) {
+        // The target asked while an interrupt was already waiting on it.
+        if (this.#interrupting)
+            return { value: null, interrupted: true };
         const parent = this.#parent;
         if (!this.#allowStdin || typeof parent.msg_id !== "string")
-            return null;
+            return NO_INPUT;
         if (this.#stdin.peers.size === 0)
             await new Promise((r) => setTimeout(r, 100));
         if (this.#stdin.peers.size === 0)
-            return null;
-        this.#stdin.sendAll(this.#encode("input_request", { prompt, password }, parent));
-        for (;;) {
-            const { frames } = await this.#stdin.recv();
-            const reply = decodeMessage(frames);
-            if (!verify(this.#conn.key, reply.signedParts, reply.sig))
-                continue;
-            if (reply.header.msg_type === "input_reply") {
-                return typeof reply.content.value === "string" ? reply.content.value : null;
-            }
-        }
+            return NO_INPUT;
+        const header = makeHeader(this.#session, "input_request");
+        const answer = new Promise((settle) => (this.#input = { msgId: header.msg_id, settle }));
+        this.#stdin.sendAll(encodeMessage(this.#session, this.#conn.key, "input_request", { prompt, password }, {
+            header,
+            parentHeader: parent,
+        }));
+        return answer;
+    }
+    /** stdin carries only input_replys. */
+    async #handleStdin(reply) {
+        if (reply.header.msg_type !== "input_reply")
+            return;
+        const input = this.#input;
+        // A reply with nothing waiting is late (its prompt was interrupted), and
+        // one naming another request is for an earlier prompt: drop both rather
+        // than answer the next prompt with them (#121). Some clients
+        // (jupyter_client's input()) send no parent header, so only a present
+        // one is checked.
+        if (input === null)
+            return;
+        const parentId = reply.parentHeader.msg_id;
+        if (typeof parentId === "string" && parentId !== "" && parentId !== input.msgId)
+            return;
+        this.#input = null;
+        input.settle({ value: typeof reply.content.value === "string" ? reply.content.value : null, interrupted: false });
     }
     async #evaluateCell(target, code) {
         // Object-literal wrapping (Deno's evaluate_line_with_object_wrapping):
@@ -458,6 +718,13 @@ export class Kernel {
     }
     async #execute(msg, peer) {
         const parent = msg.header;
+        if (this.#aborting) {
+            // Queued behind a failed cell: not run, not counted (#123).
+            this.#status("busy", parent);
+            this.#reply(this.#shell, peer, msg, "execute_reply", { status: "aborted" });
+            this.#status("idle", parent);
+            return;
+        }
         const code = String(msg.content.code ?? "");
         const silent = msg.content.silent === true;
         if (!silent && msg.content.store_history !== false) {
@@ -468,7 +735,9 @@ export class Kernel {
         this.#parent = parent;
         this.#allowStdin = msg.content.allow_stdin === true;
         this.#status("busy", parent);
-        this.#publish("execute_input", { code, execution_count: count });
+        // Silent requests broadcast nothing on iopub but status (#124).
+        if (!silent)
+            this.#publish("execute_input", { code, execution_count: count });
         if (this.#projectWarning !== null) {
             // Shown once, in the first cell, where the user will see it.
             this.#publish("stream", { name: "stderr", text: `[cdp-kernel] ${this.#projectWarning}\n` });
@@ -484,6 +753,8 @@ export class Kernel {
                 this.#publish("stream", { name: "stderr", text: `${target.notice}\n` });
             }
             const result = await this.#evaluateCell(target, code);
+            // It ran, so its declarations exist, even if it threw part way.
+            this.#types?.addCell(code);
             if (result.exceptionDetails) {
                 const exception = result.exceptionDetails.exception;
                 const described = exception
@@ -517,7 +788,16 @@ export class Kernel {
         finally {
             this.#executing = false;
         }
+        // The result and error are shown: nothing refers to them any more (#286).
+        await this.#target?.releaseResults?.();
         if (error) {
+            if (!silent && msg.content.stop_on_error !== false) {
+                // Abort what was queued behind this cell (JupyterLab's Run All sends
+                // every cell at once), but nothing sent after the client sees the
+                // error. A macrotask first lets bytes already received be parsed.
+                await new Promise((r) => setTimeout(r, 0));
+                this.#abortQueued = this.#shell.incoming.size;
+            }
             this.#publish("error", error);
             this.#reply(this.#shell, peer, msg, "execute_reply", { status: "error", execution_count: count, ...error });
         }

package/dist/language-service-worker.d.ts

@@ -0,0 +1 @@
+export {};