@tlockney/cdp-kernel 0.6.0 → 0.7.0

package/dist/message.d.ts

@@ -0,0 +1,34 @@
+export declare const PROTOCOL_VERSION = "5.3";
+export type JsonObject = {
+    [key: string]: unknown;
+};
+export interface Header extends JsonObject {
+    msg_id: string;
+    session: string;
+    date: string;
+    username: string;
+    msg_type: string;
+    version: string;
+}
+/** A header as received: the fields the kernel relies on, plus whatever else came. */
+export interface ReceivedHeader extends JsonObject {
+    msg_id: string;
+    msg_type: string;
+}
+/** A message from a frontend, decoded (and on ZeroMQ, verified). */
+export interface KernelMessage {
+    header: ReceivedHeader;
+    parentHeader: JsonObject;
+    metadata: JsonObject;
+    content: JsonObject;
+    buffers: Uint8Array[];
+}
+/** A message the kernel sends. */
+export interface OutgoingMessage {
+    header: Header;
+    parentHeader: JsonObject;
+    metadata: JsonObject;
+    content: JsonObject;
+    buffers: Uint8Array[];
+}
+export declare function makeHeader(session: string, msgType: string): Header;

package/dist/message.js

@@ -0,0 +1,14 @@
+// Jupyter message shapes and headers, without the wire format: what the
+// kernel's message handling (src/kernel-core.ts) builds and reads. The
+// framing and HMAC signing that ZeroMQ peers need are in src/wire.ts.
+export const PROTOCOL_VERSION = "5.3";
+export function makeHeader(session, msgType) {
+    return {
+        msg_id: crypto.randomUUID(),
+        session,
+        date: new Date().toISOString(),
+        username: "kernel",
+        msg_type: msgType,
+        version: PROTOCOL_VERSION,
+    };
+}

package/dist/package.d.ts

@@ -1,11 +1,11 @@
 /** Kept equal to package.json and deno.jsonc by test/package.test.ts. */
-export declare const VERSION = "0.6.0";
+export declare const VERSION = "0.7.0";
 /**
  * The UTC day this version was released, set with VERSION. The publish
  * workflow refuses a tag unless it's today or yesterday, so it can't go
  * stale: see dependencyCutoff.
  */
-export declare const RELEASE_DATE = "2026-10-18";
+export declare const RELEASE_DATE = "2026-10-19";
 /**
  * Deno blocks packages less than 24 hours old (minimum dependency age), so
  * a kernelspec relaunching a release from JSR would fail on release day. It

package/dist/package.js

@@ -14,13 +14,13 @@ import { join, sep } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 /** Kept equal to package.json and deno.jsonc by test/package.test.ts. */
-export const VERSION = "0.6.0";
+export const VERSION = "0.7.0";
 /**
  * The UTC day this version was released, set with VERSION. The publish
  * workflow refuses a tag unless it's today or yesterday, so it can't go
  * stale: see dependencyCutoff.
  */
-export const RELEASE_DATE = "2026-10-18";
+export const RELEASE_DATE = "2026-10-19";
 /**
  * Deno blocks packages less than 24 hours old (minimum dependency age), so
  * a kernelspec relaunching a release from JSR would fail on release day. It

package/dist/target-api.d.ts

@@ -0,0 +1,80 @@
+import type { CdpParams, EvaluateResult, RemoteObject } from "./cdp.ts";
+import type { DebugChannel } from "./debugger.ts";
+import type { CellTransformOptions } from "./transform.ts";
+/** Targets driven over CDP. */
+export type CdpRuntime = "node" | "deno";
+/** Bun, workerd and celld have their own backends: src/bun-target.ts, src/workerd-target.ts, src/celld-target.ts. */
+export type RuntimeName = CdpRuntime | "bun" | "workerd" | "celld";
+/** Every target: the runtimes a kernelspec names, and the browser's Worker (src/browser/). */
+export type TargetRuntime = RuntimeName | "browser";
+/** What the kernel needs from a target runtime. */
+export interface KernelTarget {
+    readonly runtime: TargetRuntime;
+    readonly versions: {
+        runtime: string;
+        engine: string;
+    };
+    /** Shown once, in the first cell: e.g. which project's bindings loaded. */
+    readonly notice?: string;
+    /** Turns a cell into the script evaluate() takes. */
+    transform(code: string, options: CellTransformOptions): string;
+    /** Runs a transformed cell. Rejects with Interrupted after interrupt(). */
+    evaluate(script: string): Promise<EvaluateResult>;
+    interrupt(): Promise<void>;
+    /** Resolves once all output and messages sent so far have been delivered. */
+    flush(): Promise<void>;
+    broadcastResult(executionCount: number, result: RemoteObject): Promise<void>;
+    dispatchComm(msgType: string, content: CdpParams, metadata: CdpParams, buffers: Uint8Array[]): Promise<{
+        handled: boolean;
+    } | {
+        error: {
+            name: string;
+            message: string;
+            stack: string;
+        };
+    }>;
+    describeError(exception: RemoteObject): Promise<{
+        name: string;
+        message: string;
+        stack: string;
+    }>;
+    propertyNames(expression: string): Promise<string[]>;
+    lexicalNames(): Promise<string[]>;
+    /** inspect_request (#10): text describing a dotted path's value, without running anything. */
+    inspect(path: string, detail: number): Promise<string | null>;
+    /** The Debugger domain, on targets driven over CDP (#18). */
+    readonly debug?: DebugChannel;
+    /** Answers the target's pending prompt; `interrupted` makes it throw instead (#121). */
+    replyInput(value: string | null, interrupted?: boolean): void;
+    /** What the host waits on, for a kernel that has stopped answering (#237). */
+    diagnose?(): Promise<CdpParams>;
+    /** Lets go of the last cell's result and error, once they are shown (#286). */
+    releaseResults?(): Promise<void>;
+    kill(): void;
+}
+/** Messages the bootstrap sends: message records on stdout, or Bun's channel. */
+export type TargetMessage = {
+    kind: "iopub";
+    msg_type: string;
+    content: CdpParams;
+    metadata: CdpParams;
+    buffers: string[];
+    barrier: number;
+} | {
+    kind: "input_request";
+    prompt: string;
+    password: boolean;
+    barrier: number;
+};
+/** The parsed value, or undefined for text that isn't JSON. */
+export declare function parseJson(text: string): unknown;
+export declare function isTargetMessage(value: unknown): value is TargetMessage;
+export interface TargetEvents {
+    stream(name: "stdout" | "stderr", text: string): void;
+    message(msg: TargetMessage): void;
+    /** `note` says why, when the target was stopped on purpose. */
+    exit(code: number | null, note?: string): void;
+}
+export declare class Interrupted extends Error {
+    name: string;
+}

package/dist/target-api.js

@@ -0,0 +1,22 @@
+// What the kernel needs from a target runtime, and what a target sends
+// back: the part of src/target.ts with no Node imports, so the kernel's
+// message handling (src/kernel-core.ts) also loads in a browser.
+/** 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;
+    const kind = value.kind;
+    return (kind === "iopub" || kind === "input_request") &&
+        typeof value.barrier === "number";
+}
+export class Interrupted extends Error {
+    name = "Interrupted";
+}

package/dist/target.d.ts

@@ -1,55 +1,9 @@
 import { type CdpParams, type EvaluateResult, type RemoteObject } from "./cdp.ts";
-import { type CellTransformOptions, transformCell } from "./transform.ts";
+import { transformCell } from "./transform.ts";
 import type { DebugChannel } from "./debugger.ts";
-/** Targets driven over CDP. */
-export type CdpRuntime = "node" | "deno";
-/** Bun, workerd and celld have their own backends: src/bun-target.ts, src/workerd-target.ts, src/celld-target.ts. */
-export type RuntimeName = CdpRuntime | "bun" | "workerd" | "celld";
-/** What the kernel needs from a target runtime. */
-export interface KernelTarget {
-    readonly runtime: RuntimeName;
-    readonly versions: {
-        runtime: string;
-        engine: string;
-    };
-    /** Shown once, in the first cell: e.g. which project's bindings loaded. */
-    readonly notice?: string;
-    /** Turns a cell into the script evaluate() takes. */
-    transform(code: string, options: CellTransformOptions): string;
-    /** Runs a transformed cell. Rejects with Interrupted after interrupt(). */
-    evaluate(script: string): Promise<EvaluateResult>;
-    interrupt(): Promise<void>;
-    /** Resolves once all output and messages sent so far have been delivered. */
-    flush(): Promise<void>;
-    broadcastResult(executionCount: number, result: RemoteObject): Promise<void>;
-    dispatchComm(msgType: string, content: CdpParams, metadata: CdpParams, buffers: Uint8Array[]): Promise<{
-        handled: boolean;
-    } | {
-        error: {
-            name: string;
-            message: string;
-            stack: string;
-        };
-    }>;
-    describeError(exception: RemoteObject): Promise<{
-        name: string;
-        message: string;
-        stack: string;
-    }>;
-    propertyNames(expression: string): Promise<string[]>;
-    lexicalNames(): Promise<string[]>;
-    /** inspect_request (#10): text describing a dotted path's value, without running anything. */
-    inspect(path: string, detail: number): Promise<string | null>;
-    /** The Debugger domain, on targets driven over CDP (#18). */
-    readonly debug?: DebugChannel;
-    /** Answers the target's pending prompt; `interrupted` makes it throw instead (#121). */
-    replyInput(value: string | null, interrupted?: boolean): void;
-    /** What the host waits on, for a kernel that has stopped answering (#237). */
-    diagnose?(): Promise<CdpParams>;
-    /** Lets go of the last cell's result and error, once they are shown (#286). */
-    releaseResults?(): Promise<void>;
-    kill(): void;
-}
+import { type CdpRuntime, Interrupted, isTargetMessage, type KernelTarget, parseJson, type TargetEvents, type TargetMessage } from "./target-api.ts";
+export { Interrupted, isTargetMessage, parseJson };
+export type { CdpRuntime, KernelTarget, RuntimeName, TargetEvents, TargetMessage } from "./target-api.ts";
 export interface LaunchOptions {
     /** Runtime binary; defaults to `deno`, or `node` (this one when hosted by Node). */
     executable?: string;
@@ -68,23 +22,6 @@ export declare function launchCommand(runtime: CdpRuntime, bootstrap: string, {
  * install and in Deno's npm cache alike.
  */
 export declare function esbuildBinary(resolve?: (specifier: string) => string, platform?: string, arch?: string): string | null;
-/** Messages the bootstrap sends: message records on stdout, or Bun's channel. */
-export type TargetMessage = {
-    kind: "iopub";
-    msg_type: string;
-    content: CdpParams;
-    metadata: CdpParams;
-    buffers: string[];
-    barrier: number;
-} | {
-    kind: "input_request";
-    prompt: string;
-    password: boolean;
-    barrier: number;
-};
-/** The parsed value, or undefined for text that isn't JSON. */
-export declare function parseJson(text: string): unknown;
-export declare function isTargetMessage(value: unknown): value is TargetMessage;
 /**
  * Splits one output pipe into text and barrier markers, and releases them
  * in order. A gated marker (one that announces a message) pauses
@@ -134,15 +71,6 @@ export declare class Gates {
     open(n: number): void;
     openAll(): void;
 }
-export interface TargetEvents {
-    stream(name: "stdout" | "stderr", text: string): void;
-    message(msg: TargetMessage): void;
-    /** `note` says why, when the target was stopped on purpose. */
-    exit(code: number | null, note?: string): void;
-}
-export declare class Interrupted extends Error {
-    name: string;
-}
 export declare class Target implements KernelTarget {
     #private;
     readonly runtime: CdpRuntime;

package/dist/target.js

@@ -11,6 +11,8 @@ import { asEvaluateResult, CdpAbandoned, CdpError, CdpSession } from "./cdp.js";
 import { SHIM, transformCell } from "./transform.js";
 import { hostRuntime, isInsideNodeModules, runtimeDir } from "./package.js";
 import { killOnExit } from "./children.js";
+import { Interrupted, isTargetMessage, parseJson } from "./target-api.js";
+export { Interrupted, isTargetMessage, parseJson };
 /**
  * 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).
@@ -84,22 +86,6 @@ export function esbuildBinary(resolve = import.meta.resolve, platform = process.
         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;
-    const kind = value.kind;
-    return (kind === "iopub" || kind === "input_request") &&
-        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).
@@ -327,9 +313,6 @@ export class Gates {
         this.#map.clear();
     }
 }
-export class Interrupted extends Error {
-    name = "Interrupted";
-}
 /** A catch handler: a call interrupt() abandoned becomes Interrupted. */
 function interrupted(what) {
     return (err) => {
@@ -351,6 +334,9 @@ export class Target {
     #undelivered = 0;
     #interrupted = false;
     #paused = false;
+    /** What the debugger asked to pause on (#307), and how many kernel calls hold it off. */
+    #pauseOnExceptions = "none";
+    #unpausable = 0;
     /** Set once the main context is gone: the runtime is exiting (#130). */
     #exiting = false;
     #exited;
@@ -511,12 +497,43 @@ export class Target {
     /** The Debugger domain on this target's session, for src/debugger.ts. */
     get debug() {
         return {
-            send: (method, params = {}) => this.#shell.send(method, params),
+            send: (method, params = {}) => {
+                if (method === "Debugger.setPauseOnExceptions") {
+                    this.#pauseOnExceptions = String(params.state ?? "none");
+                    // Applied when the kernel's own call in flight finishes.
+                    if (this.#unpausable > 0)
+                        return Promise.resolve({});
+                }
+                if (method === "Debugger.disable")
+                    this.#pauseOnExceptions = "none";
+                return this.#shell.send(method, params);
+            },
             on: (method, listener) => this.#shell.on(method, listener),
             contextId: this.#contextId,
             baselineGlobals: this.#baselineGlobals,
+            withoutPausing: (call) => this.#withoutPausing(call),
         };
     }
+    /**
+     * Runs the kernel's own inspector call with pausing on exceptions off. A
+     * pause inside a call the inspector dispatches holds that call (Node), or
+     * resumes by itself and leaves Deno's event loop stopped for good, so no
+     * later cell runs (#307). A cell that throws meanwhile doesn't pause.
+     */
+    async #withoutPausing(call) {
+        if (this.#pauseOnExceptions === "none" || this.#paused)
+            return call();
+        if (this.#unpausable++ === 0)
+            await this.#shell.send("Debugger.setPauseOnExceptions", { state: "none" });
+        try {
+            return await call();
+        }
+        finally {
+            if (--this.#unpausable === 0 && !this.#exiting) {
+                await this.#shell.send("Debugger.setPauseOnExceptions", { state: this.#pauseOnExceptions }).catch(() => { });
+            }
+        }
+    }
     // Messages wait until both pipes have caught up to their marker,
     // and are delivered strictly in order.
     #deliver(msg, events) {
@@ -665,12 +682,12 @@ export class Target {
      * even a plain return value in a promise it holds only weakly (#55).
      */
     callFunctionOn(functionDeclaration, args) {
-        return this.#shell.send("Runtime.callFunctionOn", {
+        return this.#withoutPausing(() => 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

package/dist/traceback.d.ts

@@ -0,0 +1,75 @@
+import type { LineMap } from "./sourcemap.ts";
+export declare const TRACEBACK_MIME = "application/vnd.nteract.traceback+json";
+/** The //# sourceURL a cell's script runs under while not debugging. */
+export declare function cellName(code: string): string;
+/** A cell that ran: its code, and where the notebook knows it from. */
+export interface CellRecord {
+    code: string;
+    executionCount: number | null;
+    cellId: string | null;
+}
+export interface SourceLine extends Record<string, string | number | boolean> {
+    lineno: number;
+    source: string;
+}
+export interface TracebackFrame extends Record<string, unknown> {
+    filename: string;
+    lineno: number;
+    colno?: number;
+    name: string;
+    library: boolean;
+    lines: SourceLine[];
+    execution_count?: number;
+    cell_id?: string;
+}
+/** A frame of CDP's exceptionDetails.stackTrace (0-based positions). */
+export interface CallFrame {
+    url: string;
+    lineNumber: number;
+    columnNumber: number;
+}
+/** A frame as parsed from one line of a stack. */
+export interface StackFrame {
+    name: string;
+    file: string;
+    line: number | null;
+    column: number | null;
+}
+/** One line of a stack as a frame, or null for a line that isn't one (the message). */
+export declare function parseFrame(text: string): StackFrame | null;
+/**
+ * Frames from packages, runtimes and the kernel itself, which a frontend
+ * can dim or fold: a hint, not a boundary.
+ */
+export declare function isLibraryFile(file: string, kernelFiles?: readonly string[]): boolean;
+export interface TracebackSources {
+    /** The cell a script name belongs to, if it is one. */
+    cell(file: string): (CellRecord & {
+        lines: LineMap | null;
+    }) | undefined;
+    /** Another file's source, when it can be read. */
+    readFile?(file: string): string | undefined;
+    /** Path or URL prefixes of the kernel's own runtime files. */
+    kernelFiles?: readonly string[];
+}
+export interface Traceback {
+    /** The classic traceback lines, with cell frames pointing at the cell. */
+    lines: string[];
+    /** The structured payload. */
+    payload: Record<string, unknown>;
+}
+/**
+ * `stack` is the error's stack as the target describes it (src/target.ts's
+ * describeError), message lines included. `callFrames`, from CDP, name the
+ * scripts of frames the stack shows as "<anonymous>": Deno formats stacks
+ * itself and doesn't use a script's //# sourceURL.
+ */
+export declare function buildTraceback(error: {
+    ename: string;
+    evalue: string;
+    stack: string;
+    callFrames?: readonly CallFrame[];
+}, sources: TracebackSources, execution: {
+    executionCount: number | null;
+    cellId: string | null;
+}): Traceback;

package/dist/traceback.js

@@ -0,0 +1,200 @@
+// Structured tracebacks (#322): an error's stack as frames a frontend can
+// render, link to cells and fold, alongside the classic `traceback` lines.
+// The payload follows nteract's application/vnd.nteract.traceback+json
+// (runtimed/runt, docs/adr/traceback-output-protocol.md): ename, evalue,
+// frames with a source window and a `library` flag, and a plain `text`
+// rendering. Building it must never cost the user their traceback: callers
+// fall back to the classic lines if it throws.
+//
+// Cells run under a //# sourceURL naming them (cellName), so a frame in a
+// cell, including one in a function an earlier cell defined, says which
+// cell. Its line goes through the cell's source map, as for the debugger
+// (src/sourcemap.ts), so it is the line the user wrote, not the line of the
+// stripped JavaScript. Only lines are mapped: a cell frame has no column.
+//
+// Nothing here imports Node; reading other files' source is the caller's.
+import { murmur2 } from "./murmur2.js";
+export const TRACEBACK_MIME = "application/vnd.nteract.traceback+json";
+/** Lines of source shown around a frame's line. */
+const CONTEXT_BEFORE = 2;
+const CONTEXT_AFTER = 2;
+/** Longer stacks keep their first and last frames. */
+const HEAD_FRAMES = 20;
+const TAIL_FRAMES = 10;
+/** The //# sourceURL a cell's script runs under while not debugging. */
+export function cellName(code) {
+    return `$cdpk$cell-${murmur2(code, 0).toString(36)}.ts`;
+}
+// V8: "    at fn (file:1:2)", "    at file:1:2", "    at async fn (file:1:2)",
+// "    at new Promise (<anonymous>)".
+const V8_FRAME = /^\s*at (?:(.*?) \((.*?)(?::(\d+):(\d+))?\)|(.*?)(?::(\d+):(\d+))?)$/;
+// JavaScriptCore and SpiderMonkey: "fn@file:1:2", "@file:1:2", "fn@[native code]".
+const AT_FRAME = /^([^\s@]*)@(.+?)(?::(\d+):(\d+))?$/;
+/** One line of a stack as a frame, or null for a line that isn't one (the message). */
+export function parseFrame(text) {
+    const v8 = /^\s*at /.test(text) ? V8_FRAME.exec(text) : null;
+    if (v8) {
+        const named = v8[2] !== undefined;
+        const line = named ? v8[3] : v8[6];
+        const column = named ? v8[4] : v8[7];
+        return {
+            name: named ? v8[1] : "",
+            file: named ? v8[2] : v8[5],
+            line: line === undefined ? null : Number(line),
+            column: column === undefined ? null : Number(column),
+        };
+    }
+    const at = !/^\s/.test(text) && text.includes("@") ? AT_FRAME.exec(text) : null;
+    if (at) {
+        return {
+            name: at[1],
+            file: at[2],
+            line: at[3] === undefined ? null : Number(at[3]),
+            column: at[4] === undefined ? null : Number(at[4]),
+        };
+    }
+    return null;
+}
+/**
+ * Frames from packages, runtimes and the kernel itself, which a frontend
+ * can dim or fold: a hint, not a boundary.
+ */
+export function isLibraryFile(file, kernelFiles = []) {
+    if (["", "<anonymous>", "native", "[native code]", "unknown"].includes(file))
+        return true;
+    if (/^(?:node|ext|deno|bun|jsr|npm|internal):/.test(file))
+        return true;
+    if (/^https?:\/\/(?:jsr\.io|esm\.sh|cdn\.jsdelivr\.net|unpkg\.com|deno\.land)\//.test(file))
+        return true;
+    const path = file.replaceAll("\\", "/");
+    if (path.includes("/node_modules/") || path.includes("/npm/registry.npmjs.org/"))
+        return true;
+    return kernelFiles.some((prefix) => path.startsWith(prefix));
+}
+function window(source, line) {
+    const all = source.split("\n");
+    if (all.length > 1 && all[all.length - 1] === "")
+        all.pop();
+    const out = [];
+    for (let n = Math.max(1, line - CONTEXT_BEFORE); n <= Math.min(all.length, line + CONTEXT_AFTER); n++) {
+        const entry = { lineno: n, source: all[n - 1].replace(/\r$/, "") };
+        if (n === line)
+            entry.highlight = true;
+        out.push(entry);
+    }
+    return out;
+}
+/** How a cell frame's location reads in the classic traceback. */
+function cellLabel(cell) {
+    return cell.executionCount === null ? "cell" : `In[${cell.executionCount}]`;
+}
+/**
+ * `stack` is the error's stack as the target describes it (src/target.ts's
+ * describeError), message lines included. `callFrames`, from CDP, name the
+ * scripts of frames the stack shows as "<anonymous>": Deno formats stacks
+ * itself and doesn't use a script's //# sourceURL.
+ */
+export function buildTraceback(error, sources, execution) {
+    const raw = error.stack || `${error.ename}: ${error.evalue}`;
+    const lines = [];
+    const frames = [];
+    const callFrames = error.callFrames ?? [];
+    let next = 0;
+    for (const text of raw.split("\n")) {
+        const parsed = parseFrame(text);
+        if (parsed === null) {
+            lines.push(text);
+            continue;
+        }
+        let file = parsed.file;
+        if (parsed.line !== null) {
+            // CDP lists only frames with a position, in the same order.
+            const at = callFrames.findIndex((frame, i) => i >= next && frame.lineNumber + 1 === parsed.line && frame.columnNumber + 1 === parsed.column);
+            if (at !== -1) {
+                next = at + 1;
+                if (file === "<anonymous>" && callFrames[at].url)
+                    file = callFrames[at].url;
+            }
+        }
+        const cell = sources.cell(file);
+        if (cell !== undefined && parsed.line !== null) {
+            // Script lines are 1-based; the map's are 0-based.
+            const lineno = cell.lines ? cell.lines.toOriginal(parsed.line - 1) + 1 : parsed.line;
+            const frame = {
+                filename: cellLabel(cell),
+                lineno,
+                name: parsed.name,
+                library: false,
+                lines: window(cell.code, lineno),
+            };
+            if (cell.executionCount !== null)
+                frame.execution_count = cell.executionCount;
+            if (cell.cellId !== null)
+                frame.cell_id = cell.cellId;
+            frame.source_ref = {
+                kind: "notebook_execution",
+                ...(cell.executionCount !== null ? { execution_count: cell.executionCount } : {}),
+                ...(cell.cellId !== null ? { cell_id: cell.cellId } : {}),
+            };
+            frames.push(frame);
+            const location = `${cellLabel(cell)}:${lineno}`;
+            lines.push(rewriteLocation(text, parsed, location));
+            continue;
+        }
+        lines.push(text);
+        const library = isLibraryFile(file, sources.kernelFiles);
+        const frame = {
+            filename: file,
+            lineno: parsed.line ?? 0,
+            name: parsed.name,
+            library,
+            lines: [],
+        };
+        if (parsed.column !== null)
+            frame.colno = parsed.column;
+        if (!library && parsed.line !== null) {
+            const source = sources.readFile?.(file);
+            if (source !== undefined)
+                frame.lines = window(source, parsed.line);
+        }
+        frames.push(frame);
+    }
+    // What ran the cell (the kernel's evaluator, the runtime's own frames)
+    // comes after the cell's last frame and is never the user's.
+    const lastCell = frames.findLastIndex((frame) => frame.source_ref !== undefined);
+    let end = frames.length;
+    while (end > lastCell + 1 && lastCell !== -1 && frames[end - 1].library)
+        end--;
+    const kept = clip(frames.slice(0, end));
+    const payload = {
+        ename: error.ename,
+        evalue: error.evalue,
+        language: "typescript",
+        frames: kept,
+        syntax: null,
+        text: lines.join("\n"),
+        raw_text: raw,
+    };
+    if (execution.executionCount !== null || execution.cellId !== null) {
+        payload.execution = {
+            ...(execution.executionCount !== null ? { execution_count: execution.executionCount } : {}),
+            ...(execution.cellId !== null ? { cell_id: execution.cellId } : {}),
+        };
+    }
+    return { lines, payload };
+}
+function rewriteLocation(text, frame, location) {
+    const original = `${frame.file}:${frame.line}${frame.column === null ? "" : `:${frame.column}`}`;
+    const at = text.lastIndexOf(original);
+    return at === -1 ? text : text.slice(0, at) + location + text.slice(at + original.length);
+}
+function clip(frames) {
+    if (frames.length <= HEAD_FRAMES + TAIL_FRAMES)
+        return frames;
+    const omitted = frames.length - HEAD_FRAMES - TAIL_FRAMES;
+    return [
+        ...frames.slice(0, HEAD_FRAMES),
+        { filename: "", lineno: 0, name: `… ${omitted} frames omitted …`, library: true, lines: [] },
+        ...frames.slice(-TAIL_FRAMES),
+    ];
+}

package/dist/transform.d.ts

@@ -1,5 +1,6 @@
 import { LineMap } from "./sourcemap.ts";
 export declare const SHIM = "__cdpk";
+export declare const YIELD = "await __cdpk.tick();\n";
 /**
  * Each replMode cell also ends by yielding one macrotask, so the script
  * settles with no other microtasks queued ahead of the inspector's