@tlockney/cdp-kernel 0.0.0-stage → 0.1.0

package/dist/target.d.ts

@@ -0,0 +1,84 @@
+import { type CdpParams, type EvaluateResult, type RemoteObject } from "./cdp.ts";
+export type RuntimeName = "node" | "deno";
+/** `bootstrap` is the local path of runtime/bootstrap.mjs (see runtimeDir). */
+export declare function launchCommand(runtime: RuntimeName, bootstrap: string, executable?: string): {
+    cmd: string;
+    args: string[];
+};
+/** Messages the bootstrap sends through the CDP binding. */
+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;
+};
+/**
+ * Splits one output pipe into text and barrier markers, and releases them
+ * in order. A gated marker (one that announces a binding message) pauses
+ * the pipe until `gate(n)` resolves, i.e. until that message has been
+ * delivered, so later output can't overtake it. A possible partial marker
+ * at the end of a chunk is held back until the next chunk decides it.
+ */
+export declare class PipeDemux {
+    #private;
+    readonly onText: (text: string) => void;
+    readonly gate: (n: number) => Promise<void>;
+    constructor(onText: (text: string) => void, gate?: (n: number) => Promise<void>);
+    push(chunk: string): void;
+    waitFor(n: number): Promise<void>;
+    /** Release everything (the process died). */
+    close(): void;
+}
+export interface TargetEvents {
+    stream(name: "stdout" | "stderr", text: string): void;
+    message(msg: TargetMessage): void;
+    exit(code: number | null): void;
+}
+export declare class Interrupted extends Error {
+    name: string;
+}
+export declare class Target {
+    #private;
+    readonly runtime: RuntimeName;
+    readonly versions: {
+        runtime: string;
+        v8: string;
+    };
+    private constructor();
+    static launch(runtime: RuntimeName, events: TargetEvents, options?: {
+        cwd?: string;
+        executable?: string;
+        denoCompat?: boolean;
+    }): Promise<Target>;
+    /** Resolves once all output and messages sent so far have been delivered. */
+    flush(): Promise<void>;
+    /** Runs transformed cell code. Rejects with Interrupted after interrupt(). */
+    evaluate(script: string): Promise<EvaluateResult>;
+    /**
+     * Deno calls IsolateHandle::terminate_execution from another thread. The
+     * CDP equivalent is Runtime.terminateExecution, sent on a second session
+     * because the shell session is the one blocked on the running evaluate.
+     * Terminated code never settles the awaited promise, so the pending
+     * evaluate is abandoned here and the session stays usable.
+     */
+    interrupt(): Promise<void>;
+    callFunctionOn(functionDeclaration: string, args: CdpParams[]): Promise<CdpParams>;
+    /** The broadcastResult step of Deno's execute flow (jupyter/mod.rs). */
+    broadcastResult(executionCount: number, result: RemoteObject): Promise<void>;
+    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;
+}

package/dist/target.js

@@ -0,0 +1,350 @@
+// A target runtime driven over CDP: the stand-in for Deno's REPL isolate and
+// the ops in cli/ops/jupyter.rs. Any runtime whose --inspect speaks CDP and
+// can load runtime/bootstrap.mjs works; Node and Deno are wired up here.
+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 { hostRuntime, runtimeDir } from "./package.js";
+const BINDING = "__cdpk_send";
+const MARKER_RE = /\x1b\[cdpk:(\d+)(m?)\]\x1b/;
+const MAX_MARKER_LEN = 24;
+// Lines the runtimes print to stderr on their own: inspector notices, and
+// Deno's npm/jsr "Download https://..." progress (which `deno jupyter`
+// sends to the server log rather than the notebook).
+const INSPECTOR_CHATTER = /^(?:\x1b\[[0-9;]*m)*(Debugger listening on |Debugger attached\.|For help, see: |Visit chrome:\/\/inspect|Waiting for the debugger to disconnect|Download(?:\x1b\[[0-9;]*m)* https?:\/\/).*\n/gm;
+/** `bootstrap` is the local path of runtime/bootstrap.mjs (see runtimeDir). */
+export function launchCommand(runtime, bootstrap, executable) {
+    const inspect = "--inspect=127.0.0.1:0";
+    if (runtime === "deno") {
+        // Deno discovers config from the main module's location, which would
+        // put npm: imports in BYONM mode against this package's own
+        // package.json. `none` gives the global-cache behaviour `deno jupyter`
+        // has in a plain directory; --no-lock stops it writing a deno.lock
+        // into this package.
+        return {
+            cmd: executable ?? "deno",
+            args: ["run", "--allow-all", "--node-modules-dir=none", "--no-lock", inspect, bootstrap],
+        };
+    }
+    // Under a Deno host, process.execPath is deno; find node on PATH instead.
+    const node = hostRuntime() === "node" ? process.execPath : "node";
+    return { cmd: executable ?? node, args: [inspect, bootstrap] };
+}
+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:";
+function isPartialMarker(tail) {
+    if (tail.length >= MAX_MARKER_LEN)
+        return false;
+    return MARKER_PREFIX.startsWith(tail) || /^\x1b\[cdpk:\d*m?\]?$/.test(tail);
+}
+/**
+ * Splits one output pipe into text and barrier markers, and releases them
+ * in order. A gated marker (one that announces a binding message) pauses
+ * the pipe until `gate(n)` resolves, i.e. until that message has been
+ * delivered, so later output can't overtake it. A possible partial marker
+ * at the end of a chunk is held back until the next chunk decides it.
+ */
+export class PipeDemux {
+    #buffer = "";
+    #items = [];
+    #pumping = false;
+    #closed = false;
+    #reached = 0;
+    #waiters = [];
+    onText;
+    gate;
+    constructor(onText, gate = () => Promise.resolve()) {
+        this.onText = onText;
+        this.gate = gate;
+    }
+    push(chunk) {
+        this.#buffer += chunk;
+        for (;;) {
+            const m = MARKER_RE.exec(this.#buffer);
+            if (!m)
+                break;
+            if (m.index > 0)
+                this.#items.push({ text: this.#buffer.slice(0, m.index) });
+            this.#items.push({ barrier: Number(m[1]), gated: m[2] === "m" });
+            this.#buffer = this.#buffer.slice(m.index + m[0].length);
+        }
+        // Hold back a tail that could still grow into a marker, including one
+        // cut inside the "\x1b[cdpk:" prefix itself.
+        const esc = this.#buffer.lastIndexOf("\x1b");
+        const tail = esc === -1 ? "" : this.#buffer.slice(esc);
+        const holdFrom = esc !== -1 && isPartialMarker(tail) ? esc : this.#buffer.length;
+        if (holdFrom > 0) {
+            this.#items.push({ text: this.#buffer.slice(0, holdFrom) });
+            this.#buffer = this.#buffer.slice(holdFrom);
+        }
+        void this.#pump();
+    }
+    async #pump() {
+        if (this.#pumping)
+            return;
+        this.#pumping = true;
+        try {
+            for (let item = this.#items.shift(); item; item = this.#items.shift()) {
+                if ("text" in item) {
+                    this.onText(item.text);
+                    continue;
+                }
+                this.#reach(item.barrier);
+                if (item.gated && !this.#closed)
+                    await this.gate(item.barrier);
+            }
+        }
+        finally {
+            this.#pumping = false;
+        }
+    }
+    #reach(n) {
+        this.#reached = Math.max(this.#reached, n);
+        this.#waiters = this.#waiters.filter((w) => {
+            if (w.n > this.#reached)
+                return true;
+            w.resolve();
+            return false;
+        });
+    }
+    waitFor(n) {
+        if (n <= this.#reached)
+            return Promise.resolve();
+        return new Promise((resolve) => this.#waiters.push({ n, resolve }));
+    }
+    /** Release everything (the process died). */
+    close() {
+        this.#closed = true;
+        if (this.#buffer)
+            this.#items.push({ text: this.#buffer });
+        this.#buffer = "";
+        this.#items.push({ barrier: Number.MAX_SAFE_INTEGER, gated: false });
+        void this.#pump();
+    }
+}
+/** Promises keyed by barrier number, resolvable before or after first use. */
+class Gates {
+    #map = new Map();
+    #entry(n) {
+        let entry = this.#map.get(n);
+        if (!entry) {
+            let resolve = () => { };
+            const promise = new Promise((r) => (resolve = r));
+            entry = { promise, resolve };
+            this.#map.set(n, entry);
+        }
+        return entry;
+    }
+    wait(n) {
+        return this.#entry(n).promise;
+    }
+    open(n) {
+        this.#entry(n).resolve();
+    }
+    openAll() {
+        for (const entry of this.#map.values())
+            entry.resolve();
+        this.#map.clear();
+    }
+}
+export class Interrupted extends Error {
+    name = "Interrupted";
+}
+export class Target {
+    runtime;
+    #child;
+    #shell;
+    #control;
+    #stdout;
+    #stderr;
+    #gates;
+    #contextId;
+    #messages = Promise.resolve();
+    #interrupted = false;
+    versions;
+    constructor(runtime, child, shell, control, stdout, stderr, gates, contextId, versions) {
+        this.runtime = runtime;
+        this.#child = child;
+        this.#shell = shell;
+        this.#control = control;
+        this.#stdout = stdout;
+        this.#stderr = stderr;
+        this.#gates = gates;
+        this.#contextId = contextId;
+        this.versions = versions;
+    }
+    static async launch(runtime, events, options = {}) {
+        const bootstrap = join(await runtimeDir(new URL("../runtime/", import.meta.url).href), "bootstrap.mjs");
+        const { cmd, args } = launchCommand(runtime, bootstrap, options.executable);
+        const env = { ...process.env, FORCE_COLOR: "1" };
+        if (options.denoCompat)
+            env.CDPK_DENO_COMPAT = "1";
+        delete env.NO_COLOR;
+        const child = spawn(cmd, args, { cwd: options.cwd, stdio: ["pipe", "pipe", "pipe"], env });
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        const gates = new Gates();
+        const stdout = new PipeDemux((text) => events.stream("stdout", text), (n) => gates.wait(n));
+        const stderr = new PipeDemux((text) => events.stream("stderr", text), (n) => gates.wait(n));
+        const pushStderr = (chunk) => {
+            const text = chunk.replace(INSPECTOR_CHATTER, "");
+            if (text)
+                stderr.push(text);
+        };
+        // Until the inspector URL appears, stderr carries the runtime's banner.
+        const wsUrl = await new Promise((resolve, reject) => {
+            let banner = "";
+            const onData = (chunk) => {
+                banner += chunk;
+                const m = /ws:\/\/\S+/.exec(banner);
+                if (!m)
+                    return;
+                child.stderr.off("data", onData);
+                pushStderr(banner.slice(m.index + m[0].length).replace(/^.*\n?/, ""));
+                child.stderr.on("data", pushStderr);
+                resolve(m[0]);
+            };
+            child.stderr.on("data", onData);
+            child.once("error", reject);
+            child.once("exit", (code) => reject(new Error(`${cmd} exited (${code}) before its inspector came up:\n${banner}`)));
+        });
+        child.stdout.on("data", (c) => stdout.push(c));
+        child.once("exit", (code) => {
+            gates.openAll();
+            stdout.close();
+            stderr.close();
+            events.exit(code);
+        });
+        const shell = await CdpSession.connect(wsUrl);
+        const control = await CdpSession.connect(wsUrl);
+        const contextReady = new Promise((resolve) => {
+            shell.on("Runtime.executionContextCreated", (params) => {
+                const context = params.context;
+                if (context.auxData?.isDefault !== false)
+                    resolve(context.id);
+            });
+        });
+        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: "" });
+        shell.on("Runtime.bindingCalled", (params) => {
+            if (params.name !== BINDING || typeof params.payload !== "string")
+                return;
+            const msg = JSON.parse(params.payload);
+            if (isTargetMessage(msg))
+                target.#deliver(msg, events);
+        });
+        // Wait for the bootstrap's top-level await to finish installing the shim.
+        for (let i = 0; i < 200; i++) {
+            const probe = await target.#evaluateRaw(`typeof globalThis.${SHIM}?.tick === "function"`);
+            if (probe.result.value === true)
+                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 })`);
+        Object.assign(target.versions, JSON.parse(String(versions.result.value)));
+        return target;
+    }
+    // Binding messages wait until both pipes have caught up to their marker,
+    // and are delivered strictly in order.
+    #deliver(msg, events) {
+        this.#messages = this.#messages.then(async () => {
+            await Promise.all([this.#stdout.waitFor(msg.barrier), this.#stderr.waitFor(msg.barrier)]);
+            events.message(msg);
+            this.#gates.open(msg.barrier);
+        });
+    }
+    /** Resolves once all output and messages sent so far have been delivered. */
+    async flush() {
+        const n = await this.#evaluateRaw(`${SHIM}.barrier()`);
+        const barrier = Number(n.result.value);
+        await Promise.all([this.#stdout.waitFor(barrier), this.#stderr.waitFor(barrier)]);
+        await this.#messages;
+    }
+    #evaluateRaw(expression, session = this.#shell) {
+        return session
+            .send("Runtime.evaluate", { expression, contextId: this.#contextId, replMode: true, awaitPromise: true })
+            .then(asEvaluateResult);
+    }
+    /** Runs transformed cell code. Rejects with Interrupted after interrupt(). */
+    async evaluate(script) {
+        this.#interrupted = false;
+        try {
+            return await this.#evaluateRaw(script);
+        }
+        catch (err) {
+            if (err instanceof CdpAbandoned || this.#interrupted)
+                throw new Interrupted("Execution interrupted");
+            throw err;
+        }
+    }
+    /**
+     * Deno calls IsolateHandle::terminate_execution from another thread. The
+     * CDP equivalent is Runtime.terminateExecution, sent on a second session
+     * because the shell session is the one blocked on the running evaluate.
+     * Terminated code never settles the awaited promise, so the pending
+     * evaluate is abandoned here and the session stays usable.
+     */
+    async interrupt() {
+        this.#interrupted = true;
+        await this.#control.send("Runtime.terminateExecution");
+        this.#shell.abandonPending();
+    }
+    callFunctionOn(functionDeclaration, args) {
+        return this.#shell.send("Runtime.callFunctionOn", {
+            functionDeclaration,
+            arguments: args,
+            executionContextId: this.#contextId,
+            awaitPromise: true,
+            returnByValue: true,
+        });
+    }
+    /** The broadcastResult step of Deno's execute flow (jupyter/mod.rs). */
+    async broadcastResult(executionCount, result) {
+        const arg = result.objectId
+            ? { objectId: result.objectId }
+            : result.unserializableValue !== undefined
+                ? { unserializableValue: result.unserializableValue }
+                : { value: result.value };
+        await this.callFunctionOn(`function (n, r) { return globalThis.${SHIM}.broadcastResult(n, r); }`, [
+            { value: executionCount },
+            arg,
+        ]);
+    }
+    async describeError(exception) {
+        const arg = exception.objectId ? { objectId: exception.objectId } : { value: exception.value };
+        const res = await this.callFunctionOn(`function (e) { return globalThis.${SHIM}.describeError(e); }`, [arg]);
+        const value = res.result?.value;
+        return JSON.parse(typeof value === "string" ? value : '{"name":"Error","message":"","stack":""}');
+    }
+    async propertyNames(expression) {
+        const evaluated = await this.#evaluateRaw(`(${expression})`).catch(() => null);
+        const objectId = evaluated?.result.objectId;
+        if (!objectId || evaluated?.exceptionDetails)
+            return [];
+        const props = await this.#shell.send("Runtime.getProperties", { objectId, nonIndexedPropertiesOnly: true });
+        const list = props.result;
+        return (list ?? []).map((p) => p.name);
+    }
+    async lexicalNames() {
+        const res = await this.#shell.send("Runtime.globalLexicalScopeNames", { executionContextId: this.#contextId });
+        return res.names ?? [];
+    }
+    replyInput(value) {
+        this.#child.stdin.write(JSON.stringify({ value }) + "\n");
+    }
+    kill() {
+        this.#shell.close();
+        this.#control.close();
+        this.#child.kill();
+    }
+}

package/dist/text.d.ts

@@ -0,0 +1,14 @@
+export type IsCompleteReply = {
+    status: "complete";
+} | {
+    status: "incomplete";
+    indent: string;
+} | {
+    status: "invalid";
+};
+/** Bracket/quote/comment scanner deciding whether a cell is finished. */
+export declare function checkIsComplete(code: string): IsCompleteReply;
+/** The dotted expression ending at the cursor, e.g. "Math.fl". */
+export declare function exprAtCursor(code: string, cursor: number): string;
+export declare function codePointToUtf16Index(str: string, cpOffset: number): number;
+export declare function utf16ToCodePointIndex(str: string, utf16Offset: number): number;

package/dist/text.js

@@ -0,0 +1,69 @@
+// Text helpers for is_complete and complete requests.
+//
+// Ported from Deno's cli/js/jupyter_kernel.js (v2.9.6), which is
+// Copyright 2018-2026 the Deno authors, MIT license.
+/** Bracket/quote/comment scanner deciding whether a cell is finished. */
+export function checkIsComplete(code) {
+    const stack = [];
+    const closers = { ")": "(", "]": "[", "}": "{" };
+    let i = 0;
+    while (i < code.length) {
+        const ch = code[i];
+        if (ch === "/" && code[i + 1] === "/") {
+            while (i < code.length && code[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (ch === "/" && code[i + 1] === "*") {
+            const end = code.indexOf("*/", i + 2);
+            if (end === -1)
+                return { status: "incomplete", indent: "" };
+            i = end + 2;
+            continue;
+        }
+        if (ch === "'" || ch === '"' || ch === "`") {
+            i++;
+            let closed = false;
+            while (i < code.length) {
+                if (code[i] === "\\" && ch !== "`") {
+                    i += 2;
+                    continue;
+                }
+                if (code[i++] === ch) {
+                    closed = true;
+                    break;
+                }
+            }
+            if (!closed)
+                return { status: "incomplete", indent: "" };
+            continue;
+        }
+        if (ch === "(" || ch === "[" || ch === "{")
+            stack.push(ch);
+        else if (ch in closers && stack.pop() !== closers[ch])
+            return { status: "invalid" };
+        i++;
+    }
+    return stack.length === 0 ? { status: "complete" } : { status: "incomplete", indent: "  " };
+}
+/** The dotted expression ending at the cursor, e.g. "Math.fl". */
+export function exprAtCursor(code, cursor) {
+    const m = /[\w$.]+$/.exec(code.slice(0, cursor));
+    return m ? m[0] : "";
+}
+// Jupyter measures cursor_pos in Unicode codepoints; JS strings index UTF-16
+// code units (denoland/deno#22771).
+export function codePointToUtf16Index(str, cpOffset) {
+    let utf16 = 0;
+    for (let cp = 0; cp < cpOffset && utf16 < str.length; cp++) {
+        utf16 += (str.codePointAt(utf16) ?? 0) > 0xffff ? 2 : 1;
+    }
+    return utf16;
+}
+export function utf16ToCodePointIndex(str, utf16Offset) {
+    let cp = 0;
+    for (let utf16 = 0; utf16 < utf16Offset && utf16 < str.length; cp++) {
+        utf16 += (str.codePointAt(utf16) ?? 0) > 0xffff ? 2 : 1;
+    }
+    return cp;
+}

package/dist/transform.d.ts

@@ -0,0 +1,13 @@
+export declare const SHIM = "__cdpk";
+export declare class CellSyntaxError extends Error {
+    name: string;
+}
+/** Rewrites module-only syntax in plain JavaScript into script syntax. */
+export declare function rewriteModuleSyntax(js: string): string;
+export declare function transformCell(code: string): 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
+ * null when no wrapping applies.
+ */
+export declare function objectLiteralCandidate(code: string): string | null;

package/dist/transform.js

@@ -0,0 +1,145 @@
+// Turns a notebook cell (TypeScript/TSX, ES module syntax) into a script that
+// CDP's Runtime.evaluate can run with replMode: true.
+//
+// Deno does this with deno_ast (swc) and `var_decl_imports: true`
+// (cli/tools/repl/session.rs, evaluate_ts_expression). Here esbuild does the
+// TypeScript/JSX part and acorn finds the module syntax that a script can't
+// contain:
+//   import x, { y as z } from "m"  ->  var __cdpk_m0 = await __cdpk.import("m");
+//                                     var x = __cdpk_m0.default, z = __cdpk_m0.y;
+//   import("m")                    ->  __cdpk.import("m")
+//   import.meta                    ->  __cdpk.meta
+//   export const a = 1             ->  const a = 1
+// `__cdpk` is installed in the target by runtime/bootstrap.mjs. Routing
+// import() through it matters: code evaluated over the inspector has no
+// module referrer, so Node rejects a bare import() ("A dynamic import
+// callback was not specified").
+import { transformSync } from "esbuild";
+import { parse } from "acorn";
+import { full } from "acorn-walk";
+export const SHIM = "__cdpk";
+// Each cell first yields one macrotask. User code then runs as an ordinary
+// task instead of nested inside the inspector's dispatch of Runtime.evaluate,
+// which is what lets a Runtime.terminateExecution from the control session
+// interrupt a busy loop. (Within that dispatch the inspector processes no
+// other messages, so an interrupt would never be seen.)
+const PRELUDE = `'use strict'; await ${SHIM}.tick();\n`;
+export class CellSyntaxError extends Error {
+    name = "SyntaxError";
+}
+function stripTypes(code) {
+    // Like Deno: prefer TSX, fall back to TS for `<T>x` assertions.
+    let firstError;
+    for (const loader of ["tsx", "ts"]) {
+        try {
+            return transformSync(code, {
+                loader,
+                target: "esnext",
+                jsx: "transform",
+                tsconfigRaw: { compilerOptions: { verbatimModuleSyntax: true } },
+                logLevel: "silent",
+            }).code;
+        }
+        catch (err) {
+            firstError ??= err;
+        }
+    }
+    const message = firstError instanceof Error ? firstError.message : String(firstError);
+    throw new CellSyntaxError(message.replace(/^Transform failed with \d+ errors?:\n/, ""));
+}
+function importedName(spec) {
+    const imported = spec.imported;
+    if (!imported)
+        return "default";
+    return imported.type === "Literal" ? String(imported.value) : String(imported.name);
+}
+function rewriteImport(code, node, index) {
+    const source = JSON.stringify(node.source.value);
+    const attrs = node.attributes && node.attributes.length > 0
+        ? `, { with: { ${node.attributes.map((a) => code.slice(a.start, a.end)).join(", ")} } }`
+        : "";
+    const load = `await ${SHIM}.import(${source}${attrs})`;
+    if (node.specifiers.length === 0)
+        return `${load};`;
+    const ns = `${SHIM}_m${index}`;
+    const bindings = node.specifiers.map((spec) => {
+        const local = String(spec.local.name);
+        if (spec.type === "ImportNamespaceSpecifier")
+            return `${local} = ${ns}`;
+        return `${local} = ${ns}[${JSON.stringify(importedName(spec))}]`;
+    });
+    return `var ${ns} = ${load}; var ${bindings.join(", ")};`;
+}
+/** Rewrites module-only syntax in plain JavaScript into script syntax. */
+export function rewriteModuleSyntax(js) {
+    let program;
+    try {
+        program = parse(js, {
+            ecmaVersion: "latest",
+            sourceType: "module",
+            allowAwaitOutsideFunction: true,
+            allowReturnOutsideFunction: false,
+        });
+    }
+    catch (err) {
+        throw new CellSyntaxError(err instanceof Error ? err.message : String(err));
+    }
+    const edits = [];
+    let importIndex = 0;
+    full(program, (node) => {
+        switch (node.type) {
+            case "ImportDeclaration": {
+                const decl = node;
+                edits.push({ start: decl.start, end: decl.end, text: rewriteImport(js, decl, importIndex++) });
+                break;
+            }
+            case "ImportExpression":
+                // Replace just the `import` keyword; arguments stay as written.
+                edits.push({ start: node.start, end: node.start + "import".length, text: `${SHIM}.import` });
+                break;
+            case "MetaProperty":
+                if (js.slice(node.start, node.end).startsWith("import")) {
+                    edits.push({ start: node.start, end: node.end, text: `${SHIM}.meta` });
+                }
+                break;
+            case "ExportNamedDeclaration": {
+                const decl = node;
+                if (decl.declaration) {
+                    edits.push({ start: decl.start, end: decl.declaration.start, text: "" });
+                }
+                else if (!decl.source) {
+                    edits.push({ start: decl.start, end: decl.end, text: "" }); // export { a, b }
+                }
+                else {
+                    throw new CellSyntaxError("re-exports (export ... from) are not supported in a cell");
+                }
+                break;
+            }
+            case "ExportDefaultDeclaration": {
+                const decl = node;
+                edits.push({ start: decl.start, end: decl.declaration.start, text: "" });
+                break;
+            }
+            case "ExportAllDeclaration":
+                throw new CellSyntaxError("re-exports (export * from) are not supported in a cell");
+        }
+    });
+    // Nested edits can't occur (imports/exports are top level, import()'s
+    // keyword edit doesn't overlap its arguments), so apply back to front.
+    edits.sort((a, b) => b.start - a.start);
+    let out = js;
+    for (const edit of edits)
+        out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+    return out;
+}
+export function transformCell(code) {
+    return PRELUDE + rewriteModuleSyntax(stripTypes(code));
+}
+/**
+ * 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
+ * null when no wrapping applies.
+ */
+export function objectLiteralCandidate(code) {
+    return code.trimStart().startsWith("{") && !code.trimEnd().endsWith(";") ? `(${code})` : null;
+}