@tlockney/cdp-kernel 0.2.0 → 0.3.0

package/dist/celld-target.js

@@ -0,0 +1,274 @@
+// The celld target (#25). celld (denoland/celld) runs Workers and Durable
+// Objects on its own storage; like workerd it has no I/O outside a request,
+// so it runs the same driver Worker (runtime/workerd-worker.mjs) over the
+// same WebSocket session (src/workerd-target.ts). The differences:
+//   - celld has no UnsafeEval binding and doesn't need one: the driver uses
+//     a plain global eval.
+//   - It listens only on TCP, so the session is a loopback WebSocket opened
+//     with a per-launch token (in the query string: the host's built-in
+//     WebSocket can't set headers).
+//   - It takes one module, so the host bundles the driver (and a project's
+//     main) with esbuild and hands celld the result with `no_bundle`.
+// In a celld project (a wrangler.jsonc or wrangler.json at or above the
+// notebook), its bindings come along: the generated config copies them, and
+// lives in the project's .celld/cdp-kernel, so state stays beside, not in,
+// `celld dev`'s own.
+import process from "node:process";
+import { execFileSync, spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { build } from "esbuild";
+import { parseJsonc } from "./deno-config.js";
+import { runtimeDir } from "./package.js";
+import { cellMeta, WorkerdTarget } from "./workerd-target.js";
+import { builtinAliases, findWranglerConfig } from "./workers-project.js";
+/** The project keys the generated config keeps: bindings and compatibility. */
+export const PROJECT_KEYS = [
+    "compatibility_date",
+    "compatibility_flags",
+    "durable_objects",
+    "migrations",
+    "vars",
+    "d1_databases",
+    "kv_namespaces",
+    "r2_buckets",
+    "queues",
+    "workflows",
+    "services",
+    "worker_loaders",
+];
+/**
+ * The celld config for the driver: the project's bindings (or none), the
+ * pre-built driver as its one module, and the kernel's token and import.meta
+ * as vars, which the driver hides from cells' `env`.
+ */
+export function celldConfig(project, { token, meta }) {
+    const config = { name: "cdpk", main: "driver.mjs", no_bundle: true, compatibility_date: "2026-09-01" };
+    for (const key of PROJECT_KEYS)
+        if (project && project[key] !== undefined)
+            config[key] = project[key];
+    const vars = project && typeof project.vars === "object" && project.vars !== null ? project.vars : {};
+    config.vars = { ...vars, TOKEN: token, META: JSON.stringify(meta) };
+    return config;
+}
+/**
+ * celld's installer puts it in ~/.local/bin, which a Jupyter server's PATH
+ * often lacks, so look there before falling back to PATH.
+ */
+export function findCelld(home = homedir()) {
+    const installed = join(home, ".local", "bin", "celld");
+    return existsSync(installed) ? installed : "celld";
+}
+/** The version in `celld --version`'s output ("celld X.Y.Z"). */
+export function celldVersionOf(output) {
+    return /\bcelld (\d+\.\d+\.\d+\S*)/.exec(output)?.[1] ?? "";
+}
+/** The driver, and a project's main, as the single module celld runs. */
+export async function bundleDriver(runtime, projectMain, define = {}) {
+    const driver = JSON.stringify(join(runtime, "workerd-worker.mjs"));
+    const contents = projectMain === undefined ? `export { default } from ${driver};\n` : [
+        `import * as project from ${JSON.stringify(projectMain)};`,
+        `export * from ${JSON.stringify(projectMain)};`,
+        `export { default } from ${driver};`,
+        "globalThis.worker = project.default;",
+        "",
+    ].join("\n");
+    const result = await build({
+        stdin: { contents, resolveDir: runtime, loader: "js" },
+        bundle: true,
+        write: false,
+        format: "esm",
+        platform: "browser",
+        conditions: ["workerd", "worker", "browser"],
+        mainFields: ["browser", "module", "main"],
+        alias: builtinAliases(),
+        external: ["node:*", "cloudflare:*"],
+        define,
+        target: "es2024",
+        logLevel: "silent",
+    });
+    return result.outputFiles[0].text;
+}
+/** A free loopback port: celld dev needs a number, and rejects 0. */
+export function freePort() {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            const port = typeof address === "object" && address !== null ? address.port : 0;
+            server.close(() => resolve(port));
+        });
+    });
+}
+/** The host's built-in WebSocket as the session channel. */
+function channelOf(ws) {
+    return {
+        send: (text) => ws.send(text),
+        onMessage: (listener) => ws.addEventListener("message", (event) => listener(String(event.data))),
+        onClose: (listener) => ws.addEventListener("close", () => listener()),
+        close() {
+            try {
+                ws.close();
+            }
+            catch {
+                // Already closed.
+            }
+        },
+    };
+}
+/** celld dev's own children, which run in their own process groups. */
+function childPids(pid) {
+    try {
+        return execFileSync("pgrep", ["-P", String(pid)], { encoding: "utf8" }).split(/\s+/).filter(Boolean).map(Number);
+    }
+    catch {
+        return []; // none
+    }
+}
+/** Kills celld dev's node, then the supervisor itself. */
+function killTree(child) {
+    for (const pid of childPids(child.pid ?? -1)) {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // Gone already.
+        }
+    }
+    child.kill("SIGKILL");
+}
+/** The driver on `celld dev`. */
+class CelldHost {
+    runtime;
+    project;
+    channel;
+    #child;
+    constructor(child, channel, runtime, project) {
+        this.#child = child;
+        this.channel = channel;
+        this.runtime = runtime;
+        this.project = project;
+    }
+    static async start(cwd, projectConfig, executable) {
+        const celld = executable ?? findCelld();
+        const version = celldVersionOf(execFileSync(celld, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }));
+        const source = await runtimeDir(new URL("../runtime/", import.meta.url).href);
+        let project = null;
+        let dir;
+        if (projectConfig !== null) {
+            if (projectConfig.endsWith(".toml"))
+                throw new Error("celld reads wrangler.jsonc or wrangler.json, not wrangler.toml");
+            const parsed = parseJsonc(readFileSync(projectConfig, "utf8"));
+            if (typeof parsed !== "object" || parsed === null)
+                throw new Error(`${projectConfig} is not an object`);
+            project = parsed;
+            dir = join(dirname(projectConfig), ".celld", "cdp-kernel");
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        }
+        else {
+            dir = mkdtempSync(join(tmpdir(), "cdpk-celld-"));
+        }
+        const main = project && typeof project.main === "string" ? resolve(dirname(projectConfig ?? cwd), project.main) : undefined;
+        const define = project && typeof project.define === "object" && project.define !== null
+            ? project.define
+            : {};
+        const token = randomBytes(32).toString("hex");
+        // 0600: the config carries this launch's token.
+        writeFileSync(join(dir, "driver.mjs"), await bundleDriver(source, main, define));
+        writeFileSync(join(dir, "wrangler.jsonc"), JSON.stringify(celldConfig(project, { token, meta: cellMeta(cwd) }), null, 2), {
+            mode: 0o600,
+        });
+        const port = await freePort();
+        const child = spawn(celld, ["dev", dir, "--host", "127.0.0.1", "--port", String(port), "--no-watch"], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        child.once("exit", () => {
+            if (projectConfig === null)
+                rmSync(dir, { recursive: true, force: true });
+            else
+                for (const name of ["driver.mjs", "wrangler.jsonc"])
+                    rmSync(join(dir, name), { force: true });
+        });
+        // Cell output is captured in the driver; celld's own lines go to the
+        // server log.
+        let early = "";
+        const log = (chunk) => {
+            early += chunk.toString();
+            process.stderr.write(`[cdp-kernel celld] ${chunk}`);
+        };
+        child.stdout?.on("data", log);
+        child.stderr?.on("data", log);
+        const exited = new Promise((_, reject) => {
+            child.once("error", reject);
+            child.once("exit", (code) => reject(new Error(`celld exited (${code}) before it was ready:\n${early}`)));
+        });
+        exited.catch(() => { });
+        const url = `127.0.0.1:${port}/?token=${token}`;
+        const ready = (async () => {
+            // The driver answers 426 to a plain request once celld serves it.
+            for (let i = 0;; i++) {
+                const status = await fetch(`http://${url}`).then((r) => r.status, () => 0);
+                if (status === 426)
+                    break;
+                if (i >= 600)
+                    throw new Error(`celld never served the driver (last status ${status}):\n${early}`);
+                await new Promise((r) => setTimeout(r, 50));
+            }
+            const ws = new WebSocket(`ws://${url}`);
+            await new Promise((resolve, reject) => {
+                ws.addEventListener("open", () => resolve(), { once: true });
+                ws.addEventListener("error", () => reject(new Error("the session WebSocket didn't open")), { once: true });
+            });
+            return channelOf(ws);
+        })();
+        try {
+            return new CelldHost(child, await Promise.race([ready, exited]), `celld ${version}`.trim(), projectConfig ?? undefined);
+        }
+        catch (err) {
+            killTree(child);
+            throw err;
+        }
+    }
+    /**
+     * celld dev's graceful stop waits for the app, which a busy cell never
+     * lets go, and its node runs in its own process group. So a forced stop
+     * kills the node, then the supervisor; a graceful one falls back to that.
+     */
+    stop(now) {
+        if (now)
+            return killTree(this.#child);
+        this.#child.kill("SIGTERM");
+        setTimeout(() => {
+            if (this.#child.exitCode === null && this.#child.signalCode === null)
+                killTree(this.#child);
+        }, 3000).unref();
+    }
+    onExit(listener) {
+        this.#child.once("exit", listener);
+    }
+}
+/**
+ * A celld target. In a celld project its bindings come along; a project
+ * that can't load is reported in the first cell, and the driver runs alone.
+ */
+export async function launchCelld(events, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const project = findWranglerConfig(cwd);
+    let host = null;
+    let notice;
+    if (project !== null) {
+        try {
+            host = await CelldHost.start(cwd, project, options.executable);
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            notice = `[cdp-kernel] couldn't load the celld project at ${project}: ${reason}; running without its bindings`;
+        }
+    }
+    host ??= await CelldHost.start(cwd, null, options.executable);
+    return await WorkerdTarget.open(host, cwd, events, "celld", notice);
+}

package/dist/kernel.js

@@ -10,7 +10,10 @@ 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 { 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 { VERSION } from "./package.js";
@@ -48,6 +51,7 @@ export class Kernel {
     // A Deno target in a Deno project uses its config (#13).
     #project;
     #projectWarning = null;
+    #noticeShownFor = null;
     #session = randomUUID();
     #shell;
     #control;
@@ -162,13 +166,22 @@ 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((target) => {
             this.#target = target;
             this.#targetStarting = null;
             return target;
@@ -182,10 +195,11 @@ 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;
                 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,7 +270,7 @@ 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,
         };
@@ -376,7 +390,7 @@ export class Kernel {
         const wrapped = objectLiteralCandidate(code);
         if (wrapped !== null) {
             try {
-                const result = await target.evaluate(transformCell(wrapped, this.#transformOptions()));
+                const result = await target.evaluate(target.transform(wrapped, this.#transformOptions()));
                 if (!result.exceptionDetails)
                     return result;
             }
@@ -385,7 +399,7 @@ export class Kernel {
                     throw err;
             }
         }
-        return target.evaluate(transformCell(code, this.#transformOptions()));
+        return target.evaluate(target.transform(code, this.#transformOptions()));
     }
     async #execute(msg, peer) {
         const parent = msg.header;
@@ -407,6 +421,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)
@@ -59,7 +59,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 +83,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/package.d.ts

@@ -1,6 +1,6 @@
 /** 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.3.0";
+export declare const RUNTIME_FILES: readonly ["bootstrap.mjs", "bun-channel.mjs", "evaluator.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,12 @@ 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.3.0";
 export const RUNTIME_FILES = [
     "bootstrap.mjs",
+    "bun-channel.mjs",
+    "evaluator.mjs",
+    "workerd-worker.mjs",
     "display.mjs",
     "comm.mjs",
     "widget.mjs",

package/dist/target.d.ts

@@ -1,5 +1,45 @@
 import { type CdpParams, type EvaluateResult, type RemoteObject } from "./cdp.ts";
-export type RuntimeName = "node" | "deno";
+import { type CellTransformOptions, transformCell } from "./transform.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[]>;
+    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 +47,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 +65,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,23 +83,32 @@ 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;

package/dist/target.js

@@ -6,7 +6,7 @@ import process from "node:process";
 import { spawn } from "node:child_process";
 import { join } from "node:path";
 import { asEvaluateResult, CdpAbandoned, CdpSession } from "./cdp.js";
-import { SHIM } from "./transform.js";
+import { SHIM, transformCell } from "./transform.js";
 import { hostRuntime, isInsideNodeModules, runtimeDir } from "./package.js";
 const BINDING = "__cdpk_send";
 const MARKER_RE = /\x1b\[cdpk:(\d+)(m?)\]\x1b/;
@@ -41,7 +41,7 @@ export function launchCommand(runtime, bootstrap, { executable, denoConfig } = {
     const node = hostRuntime() === "node" ? process.execPath : "node";
     return { cmd: executable ?? node, args: [...inspect, bootstrap] };
 }
-function isTargetMessage(value) {
+export function isTargetMessage(value) {
     if (typeof value !== "object" || value === null)
         return false;
     const kind = value.kind;
@@ -140,7 +140,7 @@ export class PipeDemux {
     }
 }
 /** Promises keyed by barrier number, resolvable before or after first use. */
-class Gates {
+export class Gates {
     #map = new Map();
     #entry(n) {
         let entry = this.#map.get(n);
@@ -169,6 +169,7 @@ export class Interrupted extends Error {
 }
 export class Target {
     runtime;
+    transform = transformCell;
     #child;
     #shell;
     #control;
@@ -253,7 +254,7 @@ export class Target {
         await shell.send("Runtime.enable");
         await shell.send("Runtime.addBinding", { name: BINDING });
         const contextId = await contextReady;
-        const target = new Target(runtime, child, shell, control, stdout, stderr, gates, contextId, { runtime: "", v8: "" });
+        const target = new Target(runtime, child, shell, control, stdout, stderr, gates, contextId, { runtime: "", engine: "" });
         shell.on("Runtime.bindingCalled", (params) => {
             if (params.name !== BINDING || typeof params.payload !== "string")
                 return;
@@ -268,7 +269,7 @@ export class Target {
                 break;
             await new Promise((r) => setTimeout(r, 25));
         }
-        const versions = await target.#evaluateRaw(`JSON.stringify(typeof Deno !== "undefined" ? { runtime: Deno.version.deno, v8: Deno.version.v8 } : { runtime: process.versions.node, v8: process.versions.v8 })`);
+        const versions = await target.#evaluateRaw(`JSON.stringify(typeof Deno !== "undefined" ? { runtime: Deno.version.deno, engine: "V8 " + Deno.version.v8 } : { runtime: process.versions.node, engine: "V8 " + process.versions.v8 })`);
         Object.assign(target.versions, JSON.parse(String(versions.result.value)));
         return target;
     }

package/dist/transform.d.ts

@@ -23,6 +23,12 @@ export interface CellTransformOptions {
 /** Rewrites module-only syntax in plain JavaScript into script syntax. */
 export declare function rewriteModuleSyntax(js: string): string;
 export declare function transformCell(code: string, options?: CellTransformOptions): string;
+/**
+ * Like transformCell, for a target that evaluates cells itself, as global
+ * code (an indirect eval), instead of through the inspector's replMode: see
+ * hoistForEval. The script's value is a promise of the boxed result.
+ */
+export declare function transformCellForEval(code: string, options?: CellTransformOptions): string;
 /**
  * Deno treats a cell like `{ "a": 1 }` as an object literal rather than a
  * block, as browser consoles do. Returns the wrapped form to try first, or