@tlockney/cdp-kernel 0.2.0 → 0.4.0

package/dist/kernel.js

@@ -10,9 +10,14 @@ import { randomUUID } from "node:crypto";
 import { decodeMessage, encodeMessage, PROTOCOL_VERSION, verify } from "./wire.js";
 import { PubSocket, RouterSocket, startHeartbeat } from "./zmtp.js";
 import { Interrupted, Target } from "./target.js";
-import { CellSyntaxError, objectLiteralCandidate, transformCell } from "./transform.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 { loadDenoProject } from "./deno-config.js";
-import { checkIsComplete, codePointToUtf16Index, exprAtCursor, utf16ToCodePointIndex } from "./text.js";
+import { checkIsComplete, codePointToUtf16Index, exprAtCursor, inspectTarget, utf16ToCodePointIndex } from "./text.js";
+import { queryHistory } from "./history.js";
 import { VERSION } from "./package.js";
 export function parseConnectionInfo(json) {
     const raw = JSON.parse(json);
@@ -48,6 +53,11 @@ export class Kernel {
     // 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;
+    /** Cells run with store_history, for history_request (#10). */
+    #history = [];
     #session = randomUUID();
     #shell;
     #control;
@@ -67,6 +77,9 @@ export class Kernel {
         this.#runtime = runtime;
         this.#denoCompat = options.denoCompat ?? false;
         this.#project = runtime === "deno" ? this.#loadProject(options.notebookDir ?? process.cwd()) : null;
+        this.#debugger = runtime === "node" || runtime === "deno"
+            ? new Debugger((event) => this.#publish("debug_event", event), () => this.#transformOptions())
+            : null;
         startHeartbeat(conn.hb_port, conn.ip);
         this.#shell = new RouterSocket(conn.shell_port, conn.ip);
         this.#control = new RouterSocket(conn.control_port, conn.ip);
@@ -162,13 +175,24 @@ export class Kernel {
         }
     }
     // --- target lifecycle -----------------------------------------------------
+    #launchTarget() {
+        if (this.#runtime === "bun")
+            return BunTarget.launch(this.#targetEvents());
+        if (this.#runtime === "workerd")
+            return WorkerdTarget.launch(this.#targetEvents());
+        if (this.#runtime === "celld")
+            return launchCelld(this.#targetEvents());
+        return Target.launch(this.#runtime, this.#targetEvents(), {
+            denoCompat: this.#denoCompat,
+            denoConfig: this.#project?.configPath,
+        });
+    }
     #ensureTarget() {
         if (this.#target)
             return Promise.resolve(this.#target);
-        this.#targetStarting ??= Target.launch(this.#runtime, this.#targetEvents(), {
-            denoCompat: this.#denoCompat,
-            denoConfig: this.#project?.configPath,
-        }).then((target) => {
+        this.#targetStarting ??= 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;
             this.#targetStarting = null;
             return target;
@@ -182,10 +206,12 @@ export class Kernel {
         return {
             stream: (name, text) => this.#publish("stream", { name, text }),
             message: (msg) => void this.#onTargetMessage(msg),
-            exit: (code) => {
+            exit: (code, note) => {
                 this.#target = null;
+                void this.#debugger?.attachTarget(null);
                 if (!this.#shuttingDown) {
-                    this.#publish("stream", { name: "stderr", text: `\n[cdp-kernel] ${this.#runtime} exited (${code}); restarting on next cell\n` });
+                    const text = note ?? `[cdp-kernel] ${this.#runtime} exited (${code}); restarting on next cell`;
+                    this.#publish("stream", { name: "stderr", text: `\n${text}\n` });
                 }
             },
         };
@@ -256,9 +282,12 @@ export class Kernel {
                 codemirror_mode: "typescript",
                 nbconvert_exporter: "script",
             },
-            banner: `cdp-kernel on ${this.#runtime} ${versions?.runtime ?? ""} (V8 ${versions?.v8 ?? "?"})`,
+            banner: `cdp-kernel on ${this.#runtime} ${versions?.runtime ?? ""} (${versions?.engine || "?"})`,
             help_links: [],
-            debugger: false,
+            debugger: this.#debugger !== null,
+            // What current ipykernel advertises; JupyterLab itself goes by the
+            // kernelspec's metadata.debugger.
+            supported_features: this.#debugger !== null ? ["debugger"] : [],
         };
     }
     // --- control channel ------------------------------------------------------
@@ -271,6 +300,29 @@ export class Kernel {
                 await this.#interrupt();
                 this.#reply(this.#control, 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);
+                }
+                finally {
+                    this.#status("idle", msg.header);
+                }
+                break;
+            }
             case "shutdown_request": {
                 const restart = msg.content.restart === true;
                 this.#reply(this.#control, peer, msg, "shutdown_reply", { status: "ok", restart });
@@ -302,10 +354,10 @@ export class Kernel {
                     this.#reply(this.#shell, peer, msg, "is_complete_reply", checkIsComplete(String(msg.content.code ?? "")));
                     break;
                 case "inspect_request":
-                    this.#reply(this.#shell, peer, msg, "inspect_reply", { status: "ok", found: false, data: {}, metadata: {} });
+                    this.#reply(this.#shell, peer, msg, "inspect_reply", await this.#inspect(msg));
                     break;
                 case "history_request":
-                    this.#reply(this.#shell, peer, msg, "history_reply", { status: "ok", history: [] });
+                    this.#reply(this.#shell, peer, msg, "history_reply", { status: "ok", history: queryHistory(this.#history, msg.content) });
                     break;
                 case "comm_info_request":
                     this.#reply(this.#shell, peer, msg, "comm_info_reply", { status: "ok", comms: this.#commInfo(msg.content) });
@@ -321,6 +373,19 @@ export class Kernel {
             this.#status("idle", msg.header);
         }
     }
+    /** The tooltip (Shift-Tab) for the name at the cursor (#10). */
+    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 detail = msg.content.detail_level === 1 ? 1 : 0;
+        const text = path === null ? null : await (await this.#ensureTarget()).inspect(path, detail);
+        return text === null
+            ? { status: "ok", found: false, data: {}, metadata: {} }
+            : { status: "ok", found: true, data: { "text/plain": text }, metadata: {} };
+    }
     async #complete(msg) {
         const code = String(msg.content.code ?? "");
         const cursorCp = typeof msg.content.cursor_pos === "number"
@@ -373,10 +438,14 @@ export class Kernel {
     async #evaluateCell(target, code) {
         // Object-literal wrapping (Deno's evaluate_line_with_object_wrapping):
         // try `({ ... })` first and fall back to the code as written.
+        // While debugging, cells carry the path JupyterLab gave them and keep a
+        // line map, so breakpoints bind and frames point at the cell (#18).
+        const debugging = this.#debugger?.started === true && target.debug !== undefined;
+        const transform = (source) => debugging && this.#debugger ? this.#debugger.cellScript(code, source) : target.transform(source, this.#transformOptions());
         const wrapped = objectLiteralCandidate(code);
         if (wrapped !== null) {
             try {
-                const result = await target.evaluate(transformCell(wrapped, this.#transformOptions()));
+                const result = await target.evaluate(transform(wrapped));
                 if (!result.exceptionDetails)
                     return result;
             }
@@ -385,14 +454,16 @@ export class Kernel {
                     throw err;
             }
         }
-        return target.evaluate(transformCell(code, this.#transformOptions()));
+        return target.evaluate(transform(code));
     }
     async #execute(msg, peer) {
         const parent = msg.header;
         const code = String(msg.content.code ?? "");
         const silent = msg.content.silent === true;
-        if (!silent && msg.content.store_history !== false)
+        if (!silent && msg.content.store_history !== false) {
             this.#executionCount++;
+            this.#history.push({ line: this.#executionCount, input: code });
+        }
         const count = this.#executionCount;
         this.#parent = parent;
         this.#allowStdin = msg.content.allow_stdin === true;
@@ -407,6 +478,11 @@ export class Kernel {
         this.#executing = true;
         try {
             const target = await this.#ensureTarget();
+            if (target.notice !== undefined && this.#noticeShownFor !== target) {
+                // Once per target, in the first cell it runs.
+                this.#noticeShownFor = target;
+                this.#publish("stream", { name: "stderr", text: `${target.notice}\n` });
+            }
             const result = await this.#evaluateCell(target, code);
             if (result.exceptionDetails) {
                 const exception = result.exceptionDetails.exception;

package/dist/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // cdp-kernel CLI.
-//   cdp-kernel install [--runtime node|deno] [--deno-compat] [--name NAME] [--display NAME]
-//   cdp-kernel kernel --runtime node|deno [--deno-compat] --conn CONNECTION_FILE
+//   cdp-kernel install [--runtime node|deno|bun|workerd|celld] [--deno-compat] [--name NAME] [--display NAME]
+//   cdp-kernel kernel --runtime node|deno|bun|workerd|celld [--deno-compat] --conn CONNECTION_FILE
 //   cdp-kernel version
 //
 // --deno-compat (Node only) adds a `Deno` namespace for notebooks written for
@@ -14,7 +14,7 @@ import { parseArgs } from "node:util";
 import { Kernel, parseConnectionInfo } from "./kernel.js";
 import { hostRuntime, kernelArgv, moduleOrigin, VERSION } from "./package.js";
 function isRuntime(value) {
-    return value === "node" || value === "deno";
+    return value === "node" || value === "deno" || value === "bun" || value === "workerd" || value === "celld";
 }
 function kernelsDir() {
     if (process.env.JUPYTER_DATA_DIR)
@@ -42,7 +42,9 @@ function install(runtime, denoCompat, name, display) {
         // Interrupts arrive as interrupt_request on the control channel rather
         // than as SIGINT to this process.
         interrupt_mode: "message",
-        metadata: { runtime, denoCompat, version: VERSION },
+        // JupyterLab enables its visual debugger from metadata.debugger (#18);
+        // only the targets driven over CDP have one.
+        metadata: { runtime, denoCompat, version: VERSION, debugger: runtime === "node" || runtime === "deno" },
     };
     writeFileSync(join(dir, "kernel.json"), JSON.stringify(spec, null, 2) + "\n");
     console.log(`installed kernelspec ${name} -> ${dir}`);
@@ -59,7 +61,7 @@ const { positionals, values } = parseArgs({
 });
 const runtime = values.runtime;
 if (!isRuntime(runtime)) {
-    console.error(`unknown runtime ${runtime}; expected node or deno`);
+    console.error(`unknown runtime ${runtime}; expected node, deno, bun, workerd or celld`);
     process.exit(2);
 }
 // Deno targets have the real namespace; the shim is for Node.
@@ -83,6 +85,6 @@ switch (positionals[0]) {
         console.log(VERSION);
         break;
     default:
-        console.error("usage: cdp-kernel install [--runtime node|deno] [--deno-compat] | kernel --runtime node|deno --conn FILE | version");
+        console.error("usage: cdp-kernel install [--runtime node|deno|bun|workerd|celld] [--deno-compat] | kernel --runtime node|deno|bun|workerd|celld --conn FILE | version");
         process.exit(2);
 }

package/dist/murmur2.d.ts

@@ -0,0 +1,2 @@
+/** The hash of a string's UTF-8 bytes. */
+export declare function murmur2(str: string, seed: number): number;

package/dist/murmur2.js

@@ -0,0 +1,41 @@
+// MurmurHash2 (32-bit), as the Jupyter debugger uses it to name a cell's
+// source (#18). JupyterLab computes a cell's path itself, as tmpFilePrefix +
+// murmur2(code, hashSeed) + tmpFileSuffix, and the kernel must name the
+// cell's script the same way, so this follows JupyterLab's
+// packages/debugger/src/hash.ts (Modified BSD License, Copyright (c) Jupyter
+// Development Team), itself adapted from Gary Court's murmurhash2_gc.js
+// (MIT License, Copyright (c) 2011 Gary Court).
+const M = 0x5bd1e995;
+const ENCODER = new TextEncoder();
+/** 32-bit multiply by M, without leaving the safe-integer range. */
+function mul(x) {
+    return (x & 0xffff) * M + ((((x >>> 16) * M) & 0xffff) << 16);
+}
+/** The hash of a string's UTF-8 bytes. */
+export function murmur2(str, seed) {
+    const data = ENCODER.encode(str);
+    let len = data.length;
+    let h = seed ^ len;
+    let i = 0;
+    while (len >= 4) {
+        let k = data[i] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3] << 24);
+        k = mul(k);
+        k ^= k >>> 24;
+        k = mul(k);
+        h = mul(h) ^ k;
+        len -= 4;
+        i += 4;
+    }
+    if (len === 3)
+        h ^= data[i + 2] << 16;
+    if (len >= 2)
+        h ^= data[i + 1] << 8;
+    if (len >= 1) {
+        h ^= data[i];
+        h = mul(h);
+    }
+    h ^= h >>> 13;
+    h = mul(h);
+    h ^= h >>> 15;
+    return h >>> 0;
+}

package/dist/package.d.ts

@@ -1,6 +1,20 @@
 /** Kept equal to package.json and deno.jsonc by test/package.test.ts. */
-export declare const VERSION = "0.2.0";
-export declare const RUNTIME_FILES: readonly ["bootstrap.mjs", "display.mjs", "comm.mjs", "widget.mjs", "node-hooks.mjs", "deno-compat.mjs", "node-modules-resolve.mjs"];
+export declare const VERSION = "0.4.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-15";
+/**
+ * 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
+ * relaunches with this cutoff instead (#12): anything published up to two
+ * days after the release is allowed (the release itself included, however
+ * late in the day its tag was pushed), and nothing newer ever is.
+ */
+export declare function dependencyCutoff(releaseDate?: string): string;
+export declare const RUNTIME_FILES: readonly ["bootstrap.mjs", "bun-channel.mjs", "evaluator.mjs", "introspect.mjs", "workerd-worker.mjs", "display.mjs", "comm.mjs", "widget.mjs", "node-hooks.mjs", "deno-compat.mjs", "node-modules-resolve.mjs"];
 export type HostRuntime = "node" | "deno";
 export declare function hostRuntime(): HostRuntime;
 /** Where the CLI module was loaded from. */

package/dist/package.js

@@ -14,9 +14,33 @@ 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.2.0";
+export const VERSION = "0.4.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-15";
+/**
+ * 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
+ * relaunches with this cutoff instead (#12): anything published up to two
+ * days after the release is allowed (the release itself included, however
+ * late in the day its tag was pushed), and nothing newer ever is.
+ */
+export function dependencyCutoff(releaseDate = RELEASE_DATE) {
+    const day = new Date(`${releaseDate}T00:00:00Z`);
+    if (Number.isNaN(day.getTime()))
+        throw new Error(`not a date: ${releaseDate}`);
+    day.setUTCDate(day.getUTCDate() + 2);
+    return day.toISOString().slice(0, 10);
+}
 export const RUNTIME_FILES = [
     "bootstrap.mjs",
+    "bun-channel.mjs",
+    "evaluator.mjs",
+    "introspect.mjs",
+    "workerd-worker.mjs",
     "display.mjs",
     "comm.mjs",
     "widget.mjs",
@@ -51,7 +75,9 @@ export function kernelArgv(host, execPath, origin, args) {
     }
     // Deno: a checkout needs its deno.jsonc import map; a JSR package brings
     // its own, so skip whatever config the notebook's directory has.
-    const flags = origin.kind === "jsr" ? ["--no-config", "--no-lock"] : ["--no-lock"];
+    const flags = origin.kind === "jsr"
+        ? ["--no-config", "--no-lock", `--min-dep-age=${dependencyCutoff()}`]
+        : ["--no-lock"];
     const entry = origin.kind === "jsr" ? origin.specifier : origin.path;
     return [execPath, "run", "--allow-all", ...flags, entry, ...args];
 }

package/dist/sourcemap.d.ts

@@ -0,0 +1,22 @@
+/** One segment's VLQ fields: generated column, source, line, column, name. */
+export declare function decodeVlq(segment: string): number[];
+/**
+ * For each generated line (0-based), the first original line (0-based) a
+ * segment on it maps to, or -1. Source-map fields are relative to the
+ * previous segment's; only the original line is tracked.
+ */
+export declare function generatedToOriginalLines(mappings: string): number[];
+/** Both directions between the lines of a cell and of its script (0-based). */
+export declare class LineMap {
+    #private;
+    /** `offset`: lines the script adds before esbuild's output (the prelude). */
+    constructor(mappings: string, offset?: number);
+    /** The cell line a script line came from: its own mapping, or the nearest one above. */
+    toOriginal(generated: number): number;
+    /**
+     * The script line for a cell line, or for the next cell line that has
+     * code (a breakpoint on a blank or comment line moves down, as debuggers
+     * do), or null past the end.
+     */
+    toGenerated(original: number): number | null;
+}

package/dist/sourcemap.js

@@ -0,0 +1,86 @@
+// Line mapping between a cell as written and the script that runs, for the
+// debugger (#18): a breakpoint set on a cell's line must land on the line
+// esbuild's output put it on, and a paused frame must report the line the
+// user wrote. Only lines: Jupyter's breakpoints are per line.
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const DIGIT = new Map([...BASE64].map((c, i) => [c, i]));
+/** One segment's VLQ fields: generated column, source, line, column, name. */
+export function decodeVlq(segment) {
+    const values = [];
+    let value = 0;
+    let shift = 0;
+    for (const char of segment) {
+        const digit = DIGIT.get(char);
+        if (digit === undefined)
+            throw new Error(`bad base64 VLQ digit ${JSON.stringify(char)}`);
+        value += (digit & 31) << shift;
+        if (digit & 32) {
+            shift += 5;
+            continue;
+        }
+        values.push(value & 1 ? -(value >>> 1) : value >>> 1);
+        value = 0;
+        shift = 0;
+    }
+    return values;
+}
+/**
+ * For each generated line (0-based), the first original line (0-based) a
+ * segment on it maps to, or -1. Source-map fields are relative to the
+ * previous segment's; only the original line is tracked.
+ */
+export function generatedToOriginalLines(mappings) {
+    const lines = [];
+    let original = 0;
+    for (const line of mappings.split(";")) {
+        let first = -1;
+        for (const segment of line.split(",")) {
+            if (!segment)
+                continue;
+            const fields = decodeVlq(segment);
+            if (fields.length >= 4) {
+                original += fields[2];
+                if (first === -1)
+                    first = original;
+            }
+        }
+        lines.push(first);
+    }
+    return lines;
+}
+/** Both directions between the lines of a cell and of its script (0-based). */
+export class LineMap {
+    #toOriginal;
+    #toGenerated = new Map();
+    /** `offset`: lines the script adds before esbuild's output (the prelude). */
+    constructor(mappings, offset = 0) {
+        const fromEsbuild = generatedToOriginalLines(mappings);
+        this.#toOriginal = [...Array(offset).fill(-1), ...fromEsbuild];
+        this.#toOriginal.forEach((original, generated) => {
+            if (original !== -1 && !this.#toGenerated.has(original))
+                this.#toGenerated.set(original, generated);
+        });
+    }
+    /** The cell line a script line came from: its own mapping, or the nearest one above. */
+    toOriginal(generated) {
+        for (let line = Math.min(generated, this.#toOriginal.length - 1); line >= 0; line--) {
+            if (this.#toOriginal[line] !== -1)
+                return this.#toOriginal[line];
+        }
+        return 0;
+    }
+    /**
+     * The script line for a cell line, or for the next cell line that has
+     * code (a breakpoint on a blank or comment line moves down, as debuggers
+     * do), or null past the end.
+     */
+    toGenerated(original) {
+        const last = Math.max(-1, ...this.#toGenerated.keys());
+        for (let line = original; line <= last; line++) {
+            const generated = this.#toGenerated.get(line);
+            if (generated !== undefined)
+                return generated;
+        }
+        return null;
+    }
+}

package/dist/target.d.ts

@@ -1,5 +1,50 @@
 import { type CdpParams, type EvaluateResult, type RemoteObject } from "./cdp.ts";
-export type RuntimeName = "node" | "deno";
+import { type CellTransformOptions, transformCell } from "./transform.ts";
+import type { DebugChannel } from "./debugger.ts";
+/** Targets driven over CDP. */
+export type CdpRuntime = "node" | "deno";
+/** Bun and workerd have their own backends: src/bun-target.ts, src/workerd-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;
+    replyInput(value: string | null): void;
+    kill(): void;
+}
 export interface LaunchOptions {
     /** Runtime binary; defaults to `deno`, or `node` (this one when hosted by Node). */
     executable?: string;
@@ -7,7 +52,7 @@ export interface LaunchOptions {
     denoConfig?: string;
 }
 /** `bootstrap` is the local path of runtime/bootstrap.mjs (see runtimeDir). */
-export declare function launchCommand(runtime: RuntimeName, bootstrap: string, { executable, denoConfig }?: LaunchOptions): {
+export declare function launchCommand(runtime: CdpRuntime, bootstrap: string, { executable, denoConfig }?: LaunchOptions): {
     cmd: string;
     args: string[];
 };
@@ -25,6 +70,7 @@ export type TargetMessage = {
     password: boolean;
     barrier: number;
 };
+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 binding message) pauses
@@ -42,28 +88,39 @@ export declare class PipeDemux {
     /** Release everything (the process died). */
     close(): void;
 }
+/** Promises keyed by barrier number, resolvable before or after first use. */
+export declare class Gates {
+    #private;
+    wait(n: number): Promise<void>;
+    open(n: number): void;
+    openAll(): void;
+}
 export interface TargetEvents {
     stream(name: "stdout" | "stderr", text: string): void;
     message(msg: TargetMessage): void;
-    exit(code: number | null): 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 {
+export declare class Target implements KernelTarget {
     #private;
-    readonly runtime: RuntimeName;
+    readonly runtime: CdpRuntime;
+    readonly transform: typeof transformCell;
     readonly versions: {
         runtime: string;
-        v8: string;
+        engine: string;
     };
     private constructor();
-    static launch(runtime: RuntimeName, events: TargetEvents, options?: {
+    static launch(runtime: CdpRuntime, events: TargetEvents, options?: {
         cwd?: string;
         executable?: string;
         denoCompat?: boolean;
         denoConfig?: string;
     }): Promise<Target>;
+    /** The Debugger domain on this target's session, for src/debugger.ts. */
+    get debug(): DebugChannel;
     /** Resolves once all output and messages sent so far have been delivered. */
     flush(): Promise<void>;
     /** Runs transformed cell code. Rejects with Interrupted after interrupt(). */
@@ -99,6 +156,7 @@ export declare class Target {
         stack: string;
     }>;
     propertyNames(expression: string): Promise<string[]>;
+    inspect(path: string, detail: number): Promise<string | null>;
     lexicalNames(): Promise<string[]>;
     replyInput(value: string | null): void;
     kill(): void;