@tlockney/cdp-kernel 0.7.2 → 0.8.0

package/dist/crash-reports.d.ts

@@ -0,0 +1,47 @@
+/** The cdp-kernel project's DSN. It only lets a client send events. */
+export declare const DSN = "https://91c2265acb5b0b0115914a43375be9ba@o4512380800598016.ingest.us.sentry.io/4512380976168960";
+export interface Frame {
+    filename: string;
+    function?: string;
+    lineno?: number;
+    colno?: number;
+    in_app: boolean;
+}
+/** `text` with home directories as `~`, URLs cut to their path, and at most MAX_MESSAGE characters. */
+export declare function scrubText(text: string): string;
+/**
+ * A frame's file as cdp-kernel's own, `app:///src/kernel-core.ts`, or null
+ * when it isn't: its path from the package root (`src/`, `dist/` or
+ * `runtime/` and below), wherever the package is installed.
+ */
+export declare function packageFile(file: string): string | null;
+/** V8's stack lines as Sentry frames, oldest first. Files outside the package are dropped to `<other>`. */
+export declare function parseStack(stack: string | undefined): Frame[];
+export interface ReportContext {
+    /** Where it was caught, e.g. `shell handler`. */
+    where: string;
+    /** The target runtime: node, deno, bun, workerd or celld. */
+    target?: string;
+}
+/** The Sentry event for `err`. Pure but for the clock and the ids. */
+export declare function buildEvent(err: unknown, context: ReportContext): Record<string, unknown>;
+export interface Reporter {
+    /** Sends a report; resolves once sent or given up on. Never throws. */
+    report(err: unknown, where: string): Promise<void>;
+}
+/**
+ * The reporter for this process: a real one when CDP_KERNEL_CRASH_REPORTS
+ * is `1`, otherwise one that does nothing. `send` is for tests.
+ */
+export declare function crashReporter(options?: {
+    env?: Record<string, string | undefined>;
+    target?: string;
+    send?: typeof fetch;
+}): Reporter | null;
+/**
+ * Reports an exception that would end the process, then ends it as Node
+ * would have: the stack on stderr and exit code 1. Only installed when
+ * reporting is on, so with it off a crash is exactly as before. An
+ * unhandled rejection arrives here too (Node's default `throw` mode).
+ */
+export declare function reportUncaught(reporter: Reporter): void;

package/dist/crash-reports.js

@@ -0,0 +1,155 @@
+// Opt-in reports of faults in cdp-kernel's own code (#422,
+// tlockney/ganymede#384), sent to Sentry's cdp-kernel project.
+//
+// Off unless the host sets CDP_KERNEL_CRASH_REPORTS=1, which Ganymede does
+// when its user opted in. While off nothing here runs: no handler, no
+// request. Errors from user cells never come through here: the target
+// reports those to KernelCore as exception details, and KernelCore answers
+// them as cell errors. What does: an exception that escapes a message
+// handler, the target-message handler, or the process.
+//
+// No Sentry SDK: an event is a small JSON envelope, posted with fetch.
+// That keeps the npm and JSR packages free of a dependency and its
+// install-time cost for everyone who never opts in.
+//
+// Sent: the error's type, message (home directories as `~`, URLs cut to
+// their path, 300 characters at most) and stack (frames in cdp-kernel's
+// own files by their path in the package; others by name only), the
+// version, host and target runtime, OS and architecture. Not sent: cell
+// source, outputs, variables, file paths outside the package, env vars,
+// host name.
+import process from "node:process";
+import { arch, platform, release } from "node:os";
+import { hostRuntime, VERSION } from "./package.js";
+/** The cdp-kernel project's DSN. It only lets a client send events. */
+export const DSN = "https://91c2265acb5b0b0115914a43375be9ba@o4512380800598016.ingest.us.sentry.io/4512380976168960";
+/** At most this many reports per process: a fault in a loop sends a few, not thousands. */
+const MAX_REPORTS = 10;
+const MAX_MESSAGE = 300;
+const SEND_TIMEOUT_MS = 5000;
+/** `text` with home directories as `~`, URLs cut to their path, and at most MAX_MESSAGE characters. */
+export function scrubText(text) {
+    const out = text
+        .replace(/\b(?:https?|wss?|file):\/\/[^\s/'"`)]*([^\s?#'"`)]*)(?:[?#][^\s'"`)]*)?/g, "$1")
+        .replace(/(?:\/Users|\/home)\/[^/\s'"`)]+/g, "~")
+        .replace(/[A-Za-z]:\\Users\\[^\\\s'"`)]+/g, "~");
+    return out.length > MAX_MESSAGE ? `${out.slice(0, MAX_MESSAGE)}…` : out;
+}
+/**
+ * A frame's file as cdp-kernel's own, `app:///src/kernel-core.ts`, or null
+ * when it isn't: its path from the package root (`src/`, `dist/` or
+ * `runtime/` and below), wherever the package is installed.
+ */
+export function packageFile(file) {
+    const path = file.replace(/^file:\/\//, "").replaceAll("\\", "/");
+    // From npm, from JSR (jsr.io/@tlockney/cdp-kernel/<version>/src/…), or a checkout.
+    const match = /(?:^|\/)(?:@tlockney\/cdp-kernel(?:\/[^/]+)?|cdp-kernel)\/((?:src|dist|runtime)\/[^?#]+)$/.exec(path);
+    return match ? `app:///${match[1]}` : null;
+}
+const V8_FRAME = /^\s*at (?:(.+?) \()?(.+?):(\d+):(\d+)\)?$/;
+/** V8's stack lines as Sentry frames, oldest first. Files outside the package are dropped to `<other>`. */
+export function parseStack(stack) {
+    const frames = [];
+    for (const line of (stack ?? "").split("\n")) {
+        const m = V8_FRAME.exec(line);
+        if (!m)
+            continue;
+        const [, fn, file, lineno, colno] = m;
+        const own = packageFile(file);
+        const internal = file.startsWith("node:") || file.startsWith("ext:");
+        frames.push({
+            filename: own ?? (internal ? file : "<other>"),
+            function: fn,
+            lineno: own || internal ? Number(lineno) : undefined,
+            colno: own || internal ? Number(colno) : undefined,
+            in_app: own !== null,
+        });
+    }
+    return frames.reverse();
+}
+/** The Sentry event for `err`. Pure but for the clock and the ids. */
+export function buildEvent(err, context) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    return {
+        event_id: crypto.randomUUID().replaceAll("-", ""),
+        timestamp: Date.now() / 1000,
+        platform: "node",
+        level: "error",
+        release: `cdp-kernel@${VERSION}`,
+        environment: "production",
+        tags: { where: context.where, host: hostRuntime(), ...(context.target ? { target: context.target } : {}) },
+        contexts: {
+            os: { name: platform(), kernel_version: release() },
+            device: { arch: arch() },
+            runtime: { name: hostRuntime(), version: process.versions.deno ?? process.versions.node },
+        },
+        exception: {
+            values: [{
+                    type: error.name,
+                    value: scrubText(error.message),
+                    stacktrace: { frames: parseStack(error.stack) },
+                    mechanism: { type: context.where, handled: context.where !== "uncaught" },
+                }],
+        },
+    };
+}
+function parseDsn(dsn) {
+    const url = new URL(dsn);
+    const project = url.pathname.replace(/^\//, "");
+    return { key: url.username, envelope: `${url.protocol}//${url.host}/api/${project}/envelope/` };
+}
+/**
+ * The reporter for this process: a real one when CDP_KERNEL_CRASH_REPORTS
+ * is `1`, otherwise one that does nothing. `send` is for tests.
+ */
+export function crashReporter(options = {}) {
+    const env = options.env ?? process.env;
+    if (env.CDP_KERNEL_CRASH_REPORTS !== "1")
+        return null;
+    const dsn = parseDsn(env.CDP_KERNEL_SENTRY_DSN || DSN);
+    const send = options.send ?? fetch;
+    let sent = 0;
+    return {
+        async report(err, where) {
+            if (sent >= MAX_REPORTS)
+                return;
+            sent++;
+            try {
+                const event = buildEvent(err, { where, target: options.target });
+                const body = [
+                    JSON.stringify({ event_id: event.event_id, sent_at: new Date().toISOString() }),
+                    JSON.stringify({ type: "event" }),
+                    JSON.stringify(event),
+                ].join("\n");
+                await send(dsn.envelope, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/x-sentry-envelope",
+                        "x-sentry-auth": `Sentry sentry_version=7, sentry_key=${dsn.key}, sentry_client=cdp-kernel/${VERSION}`,
+                    },
+                    body,
+                    signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
+                });
+            }
+            catch {
+                // Reporting must never take the kernel down.
+            }
+        },
+    };
+}
+/**
+ * Reports an exception that would end the process, then ends it as Node
+ * would have: the stack on stderr and exit code 1. Only installed when
+ * reporting is on, so with it off a crash is exactly as before. An
+ * unhandled rejection arrives here too (Node's default `throw` mode).
+ */
+export function reportUncaught(reporter) {
+    let ending = false;
+    process.on("uncaughtException", (err) => {
+        if (ending)
+            return;
+        ending = true;
+        console.error(err instanceof Error ? err.stack ?? String(err) : err);
+        void reporter.report(err, "uncaught").finally(() => process.exit(1));
+    });
+}

package/dist/kernel-core.d.ts

@@ -52,11 +52,18 @@ export interface KernelHost {
     readonly capabilities?: JsonObject;
     /** JupyterLab's visual debugger, for targets driven over CDP (#18). */
     createDebugger?(publish: (event: JsonObject) => void, transformOptions: () => CellTransformOptions): Debugger;
+    /** usage_reply's content: the host's and the running target's (null while none runs) memory and CPU (#409). */
+    usage?(target: KernelTarget | null): Promise<JsonObject>;
     /** A file's source, for the lines around a traceback frame (#322). */
     readSource?(file: string): string | undefined;
     /** Path or URL prefixes of the kernel's own runtime files, whose frames a traceback marks as library code. */
     readonly kernelFiles?: readonly string[];
     log(text: string): void;
+    /**
+     * A fault in the kernel's own code, caught where it would otherwise only
+     * be logged: for opt-in crash reports (#422). Never a cell's error.
+     */
+    fault?(err: unknown, where: string): void;
     /** After shutdown_reply has gone out. */
     exit(): void;
 }

package/dist/kernel-core.js

@@ -19,6 +19,8 @@ import { buildTraceback, cellName, TRACEBACK_MIME } from "./traceback.js";
  * installed TypeScript's: the major version package.json depends on.
  */
 export const TYPESCRIPT_VERSION = "6";
+/** Errors from launching a target, which `KernelHost.fault` doesn't get. */
+const launchFailures = new WeakSet();
 function fromBase64(text) {
     return Uint8Array.from(atob(text), (c) => c.charCodeAt(0));
 }
@@ -28,8 +30,46 @@ function fromBase64(text) {
  */
 const INTERRUPT_REPLY_WAIT_MS = 1_000;
 const NO_INPUT = { value: null, interrupted: false };
+/**
+ * Shell messages handled one at a time, in order: the main shell, or a
+ * kernel subshell (JEP 91, #417), each with its own.
+ */
+class ShellQueue {
+    items = [];
+    #wake = null;
+    #closed = false;
+    push(item) {
+        if (this.#closed)
+            return;
+        this.items.push(item);
+        this.#wake?.();
+    }
+    /** The next message; null once closed. */
+    async next() {
+        for (;;) {
+            if (this.#closed)
+                return null;
+            const item = this.items.shift();
+            if (item !== undefined)
+                return item;
+            await new Promise((resolve) => (this.#wake = resolve));
+            this.#wake = null;
+        }
+    }
+    /** Stops taking messages; returns those still queued. */
+    close() {
+        this.#closed = true;
+        const dropped = this.items.splice(0);
+        this.#wake?.();
+        return dropped;
+    }
+}
 /** Cells remembered for tracebacks: a frame can be in a function any earlier cell defined. */
 const MAX_CELLS = 1000;
+/** The error reply for a subshell that doesn't exist (#417). */
+function subshellNotFound(evalue) {
+    return { status: "error", ename: "SubshellNotFound", evalue, traceback: [`SubshellNotFound: ${evalue}`] };
+}
 /** Shell requests other than execute_request, and their reply types. */
 const SHELL_REPLIES = {
     kernel_info_request: "kernel_info_reply",
@@ -84,13 +124,16 @@ export class KernelCore {
     #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;
+    /** Cells and comm handlers running in the target. */
+    #running = 0;
+    /** A cell is running: its parent header and allow_stdin hold until it ends (#417). */
+    #cellRunning = false;
+    /** stop_on_error (#123): the message being handled was queued behind a failed cell. */
     #aborting = false;
+    /** Messages without a subshell_id, in the order they came. */
+    #mainShell = new ShellQueue();
+    /** Kernel subshells (JEP 91, #417): subshell_id -> its queue. */
+    #subshells = new Map();
     /** The input_request waiting for its input_reply, if any. */
     #input = null;
     /** An interrupt is waiting on the target. */
@@ -117,7 +160,7 @@ export class KernelCore {
         // Transforms are synchronous, so the stripper loads before any cell.
         if (typeof this.#typeStrip === "string")
             await loadTypeStripper(this.#typeStrip);
-        await Promise.all([this.#loop("shell", (m, p) => this.#handleShell(m, p)),
+        await Promise.all([this.#readShell(), this.#runShell(this.#mainShell),
             this.#loop("control", (m, p) => this.#handleControl(m, p)),
             this.#loop("stdin", (m) => this.#handleStdin(m))]);
     }
@@ -141,8 +184,9 @@ export class KernelCore {
             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.#channels.shellQueued(),
-            executing: this.#executing,
+            queued: this.#mainShell.items.length + this.#channels.shellQueued(),
+            subshells: this.#subshells.size,
+            running: this.#running,
             interrupting: this.#interrupting,
             awaitingInput: this.#input !== null,
             target: targetState,
@@ -175,16 +219,21 @@ export class KernelCore {
         const type = msg.header.msg_type;
         const commId = String(msg.content.comm_id ?? "");
         const target = await this.#ensureTarget();
-        // Kernel messages the handlers send are replies to this message.
-        this.#parent = msg.header;
-        this.#allowStdin = false;
-        this.#executing = true;
+        // Kernel messages the handlers send are replies to this message, unless
+        // it came on a subshell while a cell runs (#417): the target's output
+        // doesn't say which it came from, so it stays the cell's.
+        if (!this.#cellRunning) {
+            this.#parent = msg.header;
+            this.#allowStdin = false;
+        }
+        const parent = msg.header;
         let handled = false;
+        this.#running++;
         try {
             const result = await target.dispatchComm(type, msg.content, msg.metadata, msg.buffers);
             if ("error" in result) {
                 const { name, message, stack } = result.error;
-                this.#publish("stream", { name: "stderr", text: `Error in ${type} handler: ${stack || `${name}: ${message}`}\n` });
+                this.#publish("stream", { name: "stderr", text: `Error in ${type} handler: ${stack || `${name}: ${message}`}\n` }, { parent });
             }
             else {
                 handled = result.handled;
@@ -193,10 +242,10 @@ export class KernelCore {
         catch (err) {
             if (!(err instanceof Interrupted))
                 throw err;
-            this.#publish("stream", { name: "stderr", text: `${type} handler interrupted\n` });
+            this.#publish("stream", { name: "stderr", text: `${type} handler interrupted\n` }, { parent });
         }
         finally {
-            this.#executing = false;
+            this.#running--;
         }
         await target.flush().catch(() => { });
         if (type === "comm_open") {
@@ -206,7 +255,7 @@ export class KernelCore {
             else {
                 // An unknown target, or a handler that failed: the protocol asks the
                 // kernel to close the comm so the frontend doesn't wait on it.
-                this.#publish("comm_close", { comm_id: commId, data: {} });
+                this.#publish("comm_close", { comm_id: commId, data: {} }, { parent });
             }
         }
         else if (type === "comm_close") {
@@ -228,6 +277,10 @@ export class KernelCore {
             return target;
         }, (err) => {
             this.#targetStarting = null;
+            // Usually the user's environment (a missing runtime, a bad config),
+            // not a kernel fault, and its message quotes the child's stderr.
+            if (typeof err === "object" && err !== null)
+                launchFailures.add(err);
             throw err;
         });
         return this.#targetStarting;
@@ -249,10 +302,19 @@ export class KernelCore {
             this.#interruptStart = null;
         }
     }
+    /** Tells the host of a fault in the kernel's own code; a target that failed to launch isn't one (#422). */
+    #fault(err, where) {
+        if (typeof err === "object" && err !== null && launchFailures.has(err))
+            return;
+        this.#host.fault?.(err, where);
+    }
     #targetEvents() {
         return {
             stream: (name, text) => this.#publish("stream", { name, text }),
-            message: (msg) => void this.#onTargetMessage(msg).catch((err) => this.#log(`error handling target message: ${err}`)),
+            message: (msg) => void this.#onTargetMessage(msg).catch((err) => {
+                this.#log(`error handling target message: ${err}`);
+                this.#fault(err, "target message");
+            }),
             exit: (code, note) => {
                 this.#target = null;
                 // What its cells declared died with it.
@@ -302,7 +364,7 @@ export class KernelCore {
             this.#interruptStart();
             return;
         }
-        if (!this.#target || !this.#executing)
+        if (!this.#target || this.#running === 0)
             return;
         this.#interrupting = true;
         try {
@@ -334,27 +396,85 @@ export class KernelCore {
     async #loop(channel, handle) {
         while (!this.#shuttingDown) {
             const received = await this.#channels.recv(channel);
-            // Before the drop below: shellQueued() counted this message too, so
-            // a dropped one takes its own abort slot, not a queued cell's (#340).
-            if (channel === "shell") {
-                this.#aborting = this.#abortQueued > 0;
-                if (this.#aborting)
-                    this.#abortQueued--;
+            // Malformed, or on ZeroMQ unsigned or forged: dropped, as in Deno.
+            if (received === null)
+                continue;
+            try {
+                await handle(received.msg, received.peer);
+            }
+            catch (err) {
+                this.#log(`error handling message: ${err instanceof Error ? err.stack : err}`);
+                this.#fault(err, `${channel} handler`);
             }
+        }
+    }
+    /**
+     * Takes every shell message as it comes and queues it for the main shell
+     * or its subshell, so a subshell's message isn't stuck behind a running
+     * cell (#417).
+     */
+    async #readShell() {
+        while (!this.#shuttingDown) {
+            const received = await this.#channels.recv("shell");
             // Malformed, or on ZeroMQ unsigned or forged: dropped, as in Deno.
             if (received === null)
                 continue;
-            const { peer, msg } = received;
+            const subshellId = received.msg.header.subshell_id;
+            if (typeof subshellId !== "string") {
+                this.#mainShell.push({ ...received, abort: false });
+                continue;
+            }
+            const queue = this.#subshells.get(subshellId);
+            if (queue === undefined) {
+                this.#refuseShell(received, `No subshell with id ${subshellId}`);
+            }
+            else if (received.msg.header.msg_type === "execute_request") {
+                // Cells share one target and one parent header, so a cell sent on
+                // a subshell waits its turn on the main shell.
+                this.#mainShell.push({ ...received, abort: false });
+            }
+            else {
+                queue.push({ ...received, abort: false });
+            }
+        }
+    }
+    /**
+     * Answers a shell message for a subshell that doesn't exist, or was
+     * deleted with the message queued, so the frontend doesn't wait on it.
+     */
+    #refuseShell({ peer, msg }, evalue) {
+        const type = msg.header.msg_type;
+        this.#log(`refusing ${type}: ${evalue}`);
+        this.#status("busy", msg.header);
+        const replyType = type === "execute_request" ? "execute_reply" : SHELL_REPLIES[type];
+        if (replyType !== undefined)
+            this.#reply("shell", peer, msg, replyType, subshellNotFound(evalue));
+        // As for an unknown target: the frontend shouldn't wait on the comm.
+        if (type === "comm_open")
+            this.#publish("comm_close", { comm_id: String(msg.content.comm_id ?? ""), data: {} }, { parent: msg.header });
+        this.#status("idle", msg.header);
+    }
+    /** Handles one queue's messages in turn. */
+    async #runShell(queue) {
+        const main = queue === this.#mainShell;
+        while (!this.#shuttingDown) {
+            const queued = await queue.next();
+            if (queued === null)
+                return;
+            const { peer, msg } = queued;
             try {
-                if (channel === "shell")
+                if (main) {
+                    this.#aborting = queued.abort;
                     this.#handling = { msgType: msg.header.msg_type, msgId: msg.header.msg_id, since: Date.now() };
-                await handle(msg, peer);
+                }
+                await this.#handleShell(msg, peer);
             }
             catch (err) {
                 this.#log(`error handling message: ${err instanceof Error ? err.stack : err}`);
+                this.#fault(err, "shell handler");
             }
             finally {
-                if (channel === "shell")
+                if (main)
                     this.#handling = null;
             }
         }
@@ -369,7 +489,12 @@ export class KernelCore {
             language_info: {
                 name: "typescript",
                 version: this.#host.languageVersion ?? TYPESCRIPT_VERSION,
-                mimetype: "text/x.typescript",
+                // JupyterLab's LSP adapter picks the language server by a language
+                // it derives from this MIME type, not from name: it drops the type
+                // and an "x-" prefix, so "text/x.typescript" became "x.typescript"
+                // and matched no server (#400). This is CodeMirror's MIME type for
+                // TypeScript and in jupyter-lsp's typescript-language-server spec.
+                mimetype: "application/typescript",
                 file_extension: ".ts",
                 pygments_lexer: "typescript",
                 codemirror_mode: "typescript",
@@ -381,12 +506,22 @@ export class KernelCore {
             debugger: this.#debugger !== null,
             // What current ipykernel advertises; JupyterLab itself goes by the
             // kernelspec's metadata.debugger.
-            supported_features: this.#debugger !== null ? ["debugger"] : [],
+            supported_features: [...(this.#debugger !== null ? ["debugger"] : []), "kernel subshells"],
             ...(this.#host.capabilities ? { capabilities: this.#host.capabilities } : {}),
         };
     }
     // --- control channel ------------------------------------------------------
     async #handleControl(msg, peer) {
+        // A frontend polls usage, and measuring can take a moment (`ps` on
+        // macOS): answer it beside the queue, so an interrupt or shutdown
+        // never waits behind a poll (#409).
+        if (msg.header.msg_type === "usage_request") {
+            void this.#handleControlRequest(msg, peer).catch((err) => this.#log(`usage_request failed: ${err}`));
+            return;
+        }
+        return this.#handleControlRequest(msg, peer);
+    }
+    async #handleControlRequest(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.)
@@ -412,6 +547,42 @@ export class KernelCore {
                 ]);
                 this.#reply(channel, peer, msg, "interrupt_reply", { status: "ok" });
                 break;
+            case "create_subshell_request": {
+                const subshellId = crypto.randomUUID();
+                const queue = new ShellQueue();
+                this.#subshells.set(subshellId, queue);
+                void this.#runShell(queue);
+                this.#reply(channel, peer, msg, "create_subshell_reply", { status: "ok", subshell_id: subshellId });
+                break;
+            }
+            case "delete_subshell_request": {
+                const subshellId = String(msg.content.subshell_id ?? "");
+                const queue = this.#subshells.get(subshellId);
+                if (queue === undefined) {
+                    this.#reply(channel, peer, msg, "delete_subshell_reply", subshellNotFound(`No subshell with id ${subshellId}`));
+                    break;
+                }
+                // A message it is handling finishes; what's queued is refused.
+                this.#subshells.delete(subshellId);
+                for (const dropped of queue.close())
+                    this.#refuseShell(dropped, `Subshell ${subshellId} was deleted`);
+                this.#reply(channel, peer, msg, "delete_subshell_reply", { status: "ok" });
+                break;
+            }
+            case "list_subshell_request":
+                this.#reply(channel, peer, msg, "list_subshell_reply", { status: "ok", subshell_id: [...this.#subshells.keys()] });
+                break;
+            case "usage_request": {
+                // Without starting a target: a frontend polls this (#409). A host
+                // that can't measure anything still answers, so the frontend
+                // doesn't wait out its timeout.
+                const usage = this.#host.usage?.(this.#target).catch((err) => {
+                    this.#log(`usage_request failed: ${err}`);
+                    return {};
+                });
+                this.#reply(channel, peer, msg, "usage_reply", (await usage) ?? {});
+                break;
+            }
             case "debug_request": {
                 let reply;
                 if (this.#debugger === null) {
@@ -745,7 +916,8 @@ export class KernelCore {
         let userExpressions = {};
         // nteract's structured traceback, sent as the error message's metadata (#322).
         let structured = null;
-        this.#executing = true;
+        this.#running++;
+        this.#cellRunning = true;
         try {
             const target = await this.#targetForCell();
             if (target.notice !== undefined && this.#noticeShownFor !== target) {
@@ -796,7 +968,8 @@ export class KernelCore {
             }
         }
         finally {
-            this.#executing = false;
+            this.#running--;
+            this.#cellRunning = false;
         }
         // The result and error are shown: nothing refers to them any more (#286).
         await this.#target?.releaseResults?.();
@@ -805,10 +978,14 @@ export class KernelCore {
                 // 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.
+                // Shell messages are queued as they're read, so by then each is.
                 await new Promise((r) => setTimeout(r, 0));
-                this.#abortQueued = this.#channels.shellQueued();
+                for (const queued of this.#mainShell.items)
+                    queued.abort = true;
             }
-            this.#publish("error", error, structured ? { metadata: { [TRACEBACK_MIME]: structured } } : {});
+            // With its parent: a subshell's comm handler may have taken #parent
+            // since the cell ended (#417).
+            this.#publish("error", error, { parent, ...(structured ? { metadata: { [TRACEBACK_MIME]: structured } } : {}) });
             this.#reply("shell", peer, msg, "execute_reply", { status: "error", execution_count: count, ...error });
         }
         else {

package/dist/kernel.js

@@ -18,6 +18,8 @@ import { cacheRoot, VERSION } from "./package.js";
 import { watchParent } from "./parent.js";
 import { KernelCore } from "./kernel-core.js";
 import { ZmqChannels } from "./zmq-channels.js";
+import { UsageMeter } from "./usage.js";
+import { crashReporter, reportUncaught } from "./crash-reports.js";
 /** The installed TypeScript's version, for kernel_info's language_info (#340). */
 function typescriptVersion() {
     try {
@@ -141,6 +143,12 @@ export class Kernel {
             }
         }
         const denoCompat = options.denoCompat ?? false;
+        const usage = new UsageMeter();
+        // Opt-in reports of the kernel's own faults (#422): null, and nothing
+        // installed, unless CDP_KERNEL_CRASH_REPORTS=1.
+        const reporter = crashReporter({ target: runtime });
+        if (reporter)
+            reportUncaught(reporter);
         this.#core = new KernelCore({
             runtime,
             version: VERSION,
@@ -164,9 +172,11 @@ export class Kernel {
             createDebugger: runtime === "node" || runtime === "deno"
                 ? (publish, transformOptions) => new Debugger(publish, transformOptions)
                 : undefined,
+            usage: (target) => usage.reply(target),
             readSource,
             kernelFiles: kernelFiles(),
             log,
+            fault: reporter ? (err, where) => void reporter.report(err, where) : undefined,
             exit: () => process.exit(0),
         });
     }