@tlockney/cdp-kernel 0.5.0 → 0.6.0

package/dist/target.js

@@ -7,11 +7,18 @@ import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { asEvaluateResult, CdpAbandoned, CdpSession } from "./cdp.js";
+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";
-const BINDING = "__cdpk_send";
+/**
+ * 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).
+ * Cells and lookups put theirs in these groups, which are released once the
+ * kernel is done with them.
+ */
+const CELL_GROUP = "cdpk-cell";
+const LOOKUP_GROUP = "cdpk-lookup";
 /** How long a target may take from spawn to a usable session. */
 const START_TIMEOUT_MS = 60_000;
 const MARKER_RE = /\x1b\[cdpk:(\d+)(m?)\]\x1b/;
@@ -27,7 +34,9 @@ const INSPECTOR_CHATTER = [
     "Visit chrome://inspect",
     "Waiting for the debugger to disconnect",
 ];
-const DENO_CHATTER = [...INSPECTOR_CHATTER, "Download http://", "Download https://"];
+// Deno prints "Debugger session started." for each session the host opens
+// (#281).
+const DENO_CHATTER = [...INSPECTOR_CHATTER, "Debugger session started.", "Download http://", "Download https://"];
 const ANSI_SGR = /\x1b\[[0-9;]*m/g;
 /** A colour code cut off at the end of a chunk. */
 const PARTIAL_SGR = /\x1b(?:\[[0-9;]*)?$/;
@@ -92,6 +101,10 @@ export function isTargetMessage(value) {
         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).
+const RECORD_PREFIX = "\x1b[cdpk:<";
+const RECORD_RE = /\x1b\[cdpk:<([^\x1b]*)\x1b\]/;
 function isPartialMarker(tail) {
     if (tail.length >= MAX_MARKER_LEN)
         return false;
@@ -99,10 +112,13 @@ function isPartialMarker(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
+ * in order. A gated marker (one that announces a 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.
+ *
+ * With `onMessage`, the pipe also carries message records. A record stands
+ * where its gated marker would, and pauses the pipe the same way.
  */
 export class PipeDemux {
     #buffer = "";
@@ -111,28 +127,49 @@ export class PipeDemux {
     #closed = false;
     #reached = 0;
     #waiters = [];
+    /** The gated marker the pipe is paused on, if any. */
+    #gatedOn = null;
     onText;
     gate;
-    constructor(onText, gate = () => Promise.resolve()) {
+    onMessage;
+    constructor(onText, gate = () => Promise.resolve(), onMessage = null) {
         this.onText = onText;
         this.gate = gate;
+        this.onMessage = onMessage;
     }
     push(chunk) {
         this.#buffer += chunk;
         for (;;) {
             const m = MARKER_RE.exec(this.#buffer);
-            if (!m)
+            const r = this.onMessage ? RECORD_RE.exec(this.#buffer) : null;
+            const first = m && r ? (m.index < r.index ? m : r) : m ?? r;
+            if (!first)
                 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);
+            if (first.index > 0)
+                this.#items.push({ text: this.#buffer.slice(0, first.index) });
+            if (first === m) {
+                this.#items.push({ barrier: Number(m[1]), gated: m[2] === "m" });
+            }
+            else {
+                // Anything else a cell prints in this shape is dropped (#122).
+                const msg = parseJson(first[1]);
+                if (isTargetMessage(msg))
+                    this.#items.push({ message: msg });
+            }
+            this.#buffer = this.#buffer.slice(first.index + first[0].length);
         }
         // Hold back a tail that could still grow into a marker, including one
-        // cut inside the "\x1b[cdpk:" prefix itself.
+        // cut inside the "\x1b[cdpk:" prefix itself, or into a record: one
+        // whose only ESC after its prefix is a final one.
         const esc = this.#buffer.lastIndexOf("\x1b");
         const tail = esc === -1 ? "" : this.#buffer.slice(esc);
-        const holdFrom = esc !== -1 && isPartialMarker(tail) ? esc : this.#buffer.length;
+        let holdFrom = esc !== -1 && isPartialMarker(tail) ? esc : this.#buffer.length;
+        const record = this.onMessage ? this.#buffer.lastIndexOf(RECORD_PREFIX) : -1;
+        if (record !== -1) {
+            const next = this.#buffer.indexOf("\x1b", record + RECORD_PREFIX.length);
+            if (next === -1 || next === this.#buffer.length - 1)
+                holdFrom = Math.min(holdFrom, record);
+        }
         if (holdFrom > 0) {
             this.#items.push({ text: this.#buffer.slice(0, holdFrom) });
             this.#buffer = this.#buffer.slice(holdFrom);
@@ -149,9 +186,22 @@ export class PipeDemux {
                     this.onText(item.text);
                     continue;
                 }
+                if ("message" in item) {
+                    this.#reach(item.message.barrier);
+                    this.onMessage?.(item.message);
+                    if (!this.#closed) {
+                        this.#gatedOn = item.message.barrier;
+                        await this.gate(item.message.barrier);
+                        this.#gatedOn = null;
+                    }
+                    continue;
+                }
                 this.#reach(item.barrier);
-                if (item.gated && !this.#closed)
+                if (item.gated && !this.#closed) {
+                    this.#gatedOn = item.barrier;
                     await this.gate(item.barrier);
+                    this.#gatedOn = null;
+                }
             }
         }
         finally {
@@ -172,6 +222,16 @@ export class PipeDemux {
             return Promise.resolve();
         return new Promise((resolve) => this.#waiters.push({ n, resolve }));
     }
+    /** Where the pipe stands, for a state dump (#237). */
+    state() {
+        return {
+            reached: this.#reached,
+            waitingFor: this.#waiters.map((w) => w.n),
+            gatedOn: this.#gatedOn,
+            queued: this.#items.length,
+            held: this.#buffer.length,
+        };
+    }
     /** Release everything (the process died). */
     close() {
         this.#closed = true;
@@ -287,6 +347,8 @@ export class Target {
     #gates;
     #contextId;
     #messages = Promise.resolve();
+    /** Messages received but not yet delivered. */
+    #undelivered = 0;
     #interrupted = false;
     #paused = false;
     /** Set once the main context is gone: the runtime is exiting (#130). */
@@ -332,6 +394,9 @@ export class Target {
         delete env.NO_COLOR;
         const child = spawn(cmd, args, { cwd: options.cwd, stdio: ["pipe", "pipe", "pipe"], env });
         killOnExit(child);
+        // Prompt replies and comm messages go to stdin; one written as the
+        // runtime exits fails with EPIPE, and the exit is handled on its own.
+        child.stdin.on("error", () => { });
         // A start that fails or stalls must not leave the runtime running: its
         // pipes and inspector sockets would keep this process alive (#52).
         const sessions = [];
@@ -357,7 +422,12 @@ export class Target {
         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));
+        // Messages come only after attach(), so the target exists by then.
+        let target;
+        const stdout = new PipeDemux((text) => events.stream("stdout", text), (n) => gates.wait(n), (msg) => {
+            if (target)
+                target.#deliver(msg, events);
+        });
         const stderr = new PipeDemux((text) => events.stream("stderr", text), (n) => gates.wait(n));
         const filter = new StderrFilter(runtime, (text) => stderr.push(text));
         const pushStderr = (chunk) => filter.push(chunk);
@@ -398,25 +468,22 @@ 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: "", engine: "" });
+        // The inspector socket leaves Nagle's algorithm on, so an event written
+        // just before an evaluate's reply holds that reply until the event is
+        // acknowledged, ~40 ms on Linux (#271). So the shell session, which runs
+        // the cells, takes no Runtime events (console calls among them), and
+        // messages come over stdout. The control session watches for exit.
+        await shell.send("Runtime.disable");
+        await control.send("Runtime.enable");
+        target = new Target(runtime, child, shell, control, stdout, stderr, gates, contextId, { runtime: "", engine: "" });
         // process.exit() or Deno.exit() destroys the context, then the runtime
         // waits for its inspector clients to disconnect before it exits. Let go,
         // so it exits and the kernel starts a fresh one (#130).
-        shell.on("Runtime.executionContextDestroyed", (params) => {
-            if (params.executionContextId === contextId)
+        control.on("Runtime.executionContextDestroyed", (params) => {
+            if (params.executionContextId === contextId && target)
                 target.#onExit();
         });
-        shell.on("Runtime.bindingCalled", (params) => {
-            if (params.name !== BINDING || typeof params.payload !== "string")
-                return;
-            // __cdpk_send is an ordinary global, so a cell can call it with
-            // anything; that mustn't take the host down (#122).
-            const msg = parseJson(params.payload);
-            if (isTargetMessage(msg))
-                target.#deliver(msg, events);
-        });
         // Wait for the bootstrap's top-level await to finish installing the
         // shim. There is no cap here: launch's start timeout bounds the wait and
         // kills the child, so a slow bootstrap never yields a target without
@@ -427,6 +494,7 @@ export class Target {
                 break;
             await new Promise((r) => setTimeout(r, 25));
         }
+        await target.#evaluateSync(`${SHIM}.attach()`);
         const versions = await target.#evaluateSync(`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)));
         // The runtime's own enumerable globals, before any cell: the debugger's
@@ -449,15 +517,65 @@ export class Target {
             baselineGlobals: this.#baselineGlobals,
         };
     }
-    // Binding messages wait until both pipes have caught up to their marker,
+    // Messages wait until both pipes have caught up to their marker,
     // and are delivered strictly in order.
     #deliver(msg, events) {
+        this.#undelivered++;
         this.#messages = this.#messages.then(async () => {
             await Promise.all([this.#stdout.waitFor(msg.barrier), this.#stderr.waitFor(msg.barrier)]);
+            this.#undelivered--;
             events.message(msg);
             this.#gates.open(msg.barrier);
         });
     }
+    /**
+     * What the host is waiting on, whether the runtime still evaluates, runs
+     * immediates and runs timers, and where its JavaScript is if it is
+     * running any, for a kernel that has stopped answering (#237). The probes
+     * go over the control session, which no cell holds.
+     */
+    async diagnose() {
+        const within = (promise, fallback) => Promise.race([promise, new Promise((resolve) => setTimeout(() => resolve(fallback), 2000).unref())]);
+        const probe = (expression, awaitPromise) => within(this.#control.send("Runtime.evaluate", { expression, contextId: this.#contextId, awaitPromise, returnByValue: true })
+            .then((res) => res.exceptionDetails ? `threw: ${JSON.stringify(res.exceptionDetails)}` : String(res.result?.value), (err) => `failed: ${err}`), "no answer in 2 s");
+        const [evaluates, immediates, timers] = await Promise.all([
+            probe("'yes'", false),
+            probe("new Promise((resolve) => setImmediate(() => resolve('yes')))", true),
+            probe("new Promise((resolve) => setTimeout(() => resolve('yes'), 0))", true),
+        ]);
+        // A runtime whose event loop is stuck may be stuck in JavaScript: say
+        // where. (An idle one would take the pause in whatever runs next.)
+        let running = "event loop runs";
+        if (immediates !== "yes") {
+            try {
+                const paused = new Promise((resolve) => this.#control.on("Debugger.paused", resolve));
+                await this.#control.send("Debugger.enable");
+                await this.#control.send("Debugger.pause");
+                const event = await within(paused, null);
+                running = event === null ? "no" : event.callFrames
+                    .slice(0, 10)
+                    .map((f) => `${f.functionName || "(anonymous)"} ${f.url || "(no url)"}:${f.location.lineNumber + 1}`);
+                await this.#control.send("Debugger.resume").catch(() => { });
+                await this.#control.send("Debugger.disable");
+            }
+            catch (err) {
+                running = `failed: ${err}`;
+            }
+        }
+        return {
+            pid: this.#child.pid ?? null,
+            calls: { shell: this.#shell.pendingCalls(), control: this.#control.pendingCalls() },
+            stdout: this.#stdout.state(),
+            stderr: this.#stderr.state(),
+            undelivered: this.#undelivered,
+            paused: this.#paused,
+            exiting: this.#exiting,
+            evaluates,
+            immediates,
+            timers,
+            running,
+        };
+    }
     /** Resolves once all output and messages sent so far have been delivered. */
     async flush() {
         const n = await this.#evaluateSync(`${SHIM}.barrier()`).catch(interrupted("Execution"));
@@ -479,7 +597,13 @@ export class Target {
     }
     #evaluateRaw(expression, session = this.#shell) {
         return session
-            .send("Runtime.evaluate", { expression, contextId: this.#contextId, replMode: true, awaitPromise: true })
+            .send("Runtime.evaluate", {
+            expression,
+            contextId: this.#contextId,
+            replMode: true,
+            awaitPromise: true,
+            objectGroup: CELL_GROUP,
+        })
             .then(asEvaluateResult);
     }
     /** Runs transformed cell code. Rejects with Interrupted after interrupt(). */
@@ -491,6 +615,10 @@ export class Target {
         catch (err) {
             if (err instanceof CdpAbandoned || this.#interrupted)
                 throw new Interrupted("Execution interrupted");
+            // The control session's executionContextDestroyed event can arrive
+            // after the shell session's error reply (#271 moved it there).
+            if (err instanceof CdpError && err.message.includes("Execution context was destroyed"))
+                this.#onExit();
             if (this.#exiting) {
                 // The child's exit, which drops this target in the kernel, comes
                 // first, so the next cell starts a fresh one.
@@ -500,6 +628,11 @@ export class Target {
             throw err;
         }
     }
+    async releaseResults() {
+        if (this.#exiting)
+            return;
+        await this.#shell.send("Runtime.releaseObjectGroup", { objectGroup: CELL_GROUP }).catch(() => { });
+    }
     #onExit() {
         if (this.#exiting)
             return;
@@ -573,14 +706,19 @@ export class Target {
      */
     async dispatchComm(msgType, content, metadata, buffers) {
         this.#interrupted = false;
+        // Over stdin, not as call arguments: V8 caches an argument's source,
+        // so the data would stay in the target's memory (#287).
+        const record = Buffer.from(JSON.stringify({
+            msgType,
+            content,
+            metadata,
+            buffers: buffers.map((b) => Buffer.from(b).toString("base64")),
+        }));
+        this.#child.stdin.write(`comm ${record.length}\n`);
+        this.#child.stdin.write(record);
         let res;
         try {
-            res = await this.#callAsyncFunctionOn(`function (t, c, m, b) { return globalThis.${SHIM}.commDispatch(t, c, m, b); }`, [
-                { value: msgType },
-                { value: content },
-                { value: metadata },
-                { value: buffers.map((b) => Buffer.from(b).toString("base64")) },
-            ]);
+            res = await this.#callAsyncFunctionOn(`function () { return globalThis.${SHIM}.commDispatchFromStdin(); }`, []);
         }
         catch (err) {
             if (err instanceof CdpAbandoned || this.#interrupted)
@@ -611,11 +749,22 @@ export class Target {
      */
     #evaluatePure(expression) {
         return this.#shell
-            .send("Runtime.evaluate", { expression, contextId: this.#contextId, throwOnSideEffect: true })
+            .send("Runtime.evaluate", { expression, contextId: this.#contextId, throwOnSideEffect: true, objectGroup: LOOKUP_GROUP })
             .then(asEvaluateResult)
             .catch(() => null);
     }
+    #releaseLookup() {
+        return this.#shell.send("Runtime.releaseObjectGroup", { objectGroup: LOOKUP_GROUP }).then(() => { }, () => { });
+    }
     async propertyNames(expression) {
+        try {
+            return await this.#propertyNames(expression);
+        }
+        finally {
+            await this.#releaseLookup();
+        }
+    }
+    async #propertyNames(expression) {
         const evaluated = await this.#evaluatePure(`(${expression})`);
         const objectId = evaluated?.result.objectId;
         if (!objectId || evaluated?.exceptionDetails)
@@ -625,6 +774,14 @@ export class Target {
         return (list ?? []).map((p) => p.name);
     }
     async inspect(path, detail) {
+        try {
+            return await this.#inspect(path, detail);
+        }
+        finally {
+            await this.#releaseLookup();
+        }
+    }
+    async #inspect(path, detail) {
         const found = await this.#evaluatePure(path);
         if (!found || found.exceptionDetails)
             return null;

package/dist/transform.d.ts

@@ -29,14 +29,34 @@ export type JsxOptions = {
 export interface CellTransformOptions {
     jsx?: JsxOptions;
     experimentalDecorators?: boolean;
+    /** What removes a cell's types and compiles its JSX; esbuild by default (#238, #234). */
+    typeStrip?: TypeStripperName | TypeStripper;
 }
+/**
+ * Turns a TypeScript/TSX cell into JavaScript with ES module syntax left in
+ * place, and with `mappings` (a source map's field, lines are enough) when
+ * `sourcemap` is set, for the debugger. Throws CellSyntaxError for code it
+ * rejects.
+ */
+export type TypeStripper = (code: string, options: CellTransformOptions, sourcemap: boolean) => {
+    code: string;
+    mappings: string;
+};
+export type TypeStripperName = "esbuild" | "sucrase";
+export declare function isTypeStripperName(value: unknown): value is TypeStripperName;
+/**
+ * Loads a built-in type stripper. Transforms are synchronous, so a kernel
+ * loads the one it uses before its first cell; only that one's module is
+ * imported (#238).
+ */
+export declare function loadTypeStripper(name: TypeStripperName): Promise<TypeStripper>;
 /** 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;
 /**
  * transformCell, plus the map between the cell's lines and the script's,
  * for the debugger (#18). The rewrite keeps lines (see applyEdits), so the
- * script's lines are esbuild's, after the prelude's one.
+ * script's lines are the stripper's, after the prelude's one.
  */
 export declare function transformCellWithLines(code: string, options?: CellTransformOptions): {
     script: string;

package/dist/transform.js

@@ -2,9 +2,9 @@
 // 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:
+// (cli/tools/repl/session.rs, evaluate_ts_expression). Here a type stripper
+// (esbuild by default) 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")
@@ -14,7 +14,6 @@
 // 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, recursive } from "acorn-walk";
 import { LineMap } from "./sourcemap.js";
@@ -37,51 +36,48 @@ export const SETTLE = `\n;let ${SHIM}_settled = await ${SHIM}.tick();`;
 export class CellSyntaxError extends Error {
     name = "SyntaxError";
 }
-function jsxSettings(jsx) {
-    if (jsx?.mode === "automatic") {
-        return { jsx: "automatic", jsxImportSource: jsx.importSource, jsxDev: jsx.development };
+export function isTypeStripperName(value) {
+    return value === "esbuild" || value === "sucrase";
+}
+const strippers = new Map();
+/**
+ * Loads a built-in type stripper. Transforms are synchronous, so a kernel
+ * loads the one it uses before its first cell; only that one's module is
+ * imported (#238).
+ */
+export async function loadTypeStripper(name) {
+    let stripper = strippers.get(name);
+    if (stripper === undefined) {
+        try {
+            stripper = name === "sucrase"
+                ? (await import("./strip-sucrase.js")).stripTypes
+                : (await import("./strip-esbuild.js")).stripTypes;
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            throw new Error(`cannot load the ${name} type stripper (is the ${name} package installed?): ${reason}`);
+        }
+        strippers.set(name, stripper);
     }
-    return { jsx: "transform", jsxFactory: jsx?.factory, jsxFragment: jsx?.fragment };
+    return stripper;
+}
+function typeStripper(choice = "esbuild") {
+    if (typeof choice === "function")
+        return choice;
+    const stripper = strippers.get(choice);
+    if (stripper === undefined)
+        throw new Error(`the ${choice} type stripper isn't loaded (see loadTypeStripper)`);
+    return stripper;
 }
 // esbuild compiles `import x = require("m")` to a `require` call, which a
 // cell doesn't have (#143); `import type x = require("m")` is erased.
 const IMPORT_REQUIRE = /^\s*(?:export\s+)?import\s+(?!type\s)[\w$]+\s*=\s*require\s*\(/m;
-/** esbuild's output, with its source map's `mappings` when asked for. */
+/** The stripper's output, with its source map's `mappings` when asked for. */
 function stripTypesMapped(code, options, sourcemap) {
     if (IMPORT_REQUIRE.test(code)) {
         throw new CellSyntaxError('import x = require("m") is not supported in a cell; use import x from "m"');
     }
-    const compilerOptions = {
-        verbatimModuleSyntax: true,
-        ...(options.experimentalDecorators ? { experimentalDecorators: true } : {}),
-    };
-    // Like Deno: prefer TSX, fall back to TS for `<T>x` assertions.
-    let firstError;
-    for (const loader of ["tsx", "ts"]) {
-        try {
-            const result = transformSync(code, {
-                loader,
-                target: "esnext",
-                // Neither acorn nor V8 parses standard (TC39) decorators or
-                // `accessor` yet, so esbuild lowers them (#142).
-                supported: { decorators: false },
-                ...jsxSettings(options.jsx),
-                tsconfigRaw: { compilerOptions },
-                logLevel: "silent",
-                ...(sourcemap ? { sourcemap: "external" } : {}),
-            });
-            const map = sourcemap ? JSON.parse(result.map) : null;
-            const mappings = typeof map?.mappings === "string"
-                ? map.mappings
-                : "";
-            return { code: result.code, mappings };
-        }
-        catch (err) {
-            firstError ??= err;
-        }
-    }
-    const message = firstError instanceof Error ? firstError.message : String(firstError);
-    throw new CellSyntaxError(message.replace(/^Transform failed with \d+ errors?:\n/, ""));
+    return typeStripper(options.typeStrip)(code, options, sourcemap);
 }
 function stripTypes(code, options) {
     return stripTypesMapped(code, options, false).code;
@@ -321,11 +317,11 @@ export function transformCell(code, options = {}) {
 /**
  * transformCell, plus the map between the cell's lines and the script's,
  * for the debugger (#18). The rewrite keeps lines (see applyEdits), so the
- * script's lines are esbuild's, after the prelude's one.
+ * script's lines are the stripper's, after the prelude's one.
  */
 export function transformCellWithLines(code, options = {}) {
     const stripped = stripTypesMapped(code, options, true);
-    return { script: PRELUDE + rewriteModuleSyntax(stripped.code) + SETTLE, lines: new LineMap(stripped.mappings, newlines(PRELUDE)) };
+    return { script: PRELUDE + rewriteModuleSyntax(stripped.code) + SETTLE, lines: new LineMap(stripped.mappings, newlines(PRELUDE), stripped.code) };
 }
 /**
  * Like transformCell, for a target that evaluates cells itself, as global

package/dist/workerd-target.js

@@ -263,7 +263,7 @@ export class RawWorkerd {
         killOnExit(child, () => {
             child.kill("SIGKILL");
             rmSync(dir, { recursive: true, force: true });
-        });
+        }, { dir });
         // Cell output is captured inside the Worker; what workerd itself prints
         // (its own warnings, errors from background work) goes to the server log.
         // `early` keeps that output for a startup error only, and stops growing

package/dist/workers-project.js

@@ -9,11 +9,13 @@
 // bundled next to the driver, so its Durable Object classes are exported
 // from the same Worker. Neither wrangler nor Miniflare is a dependency of
 // cdp-kernel: they're loaded from the project, so they match its version.
+import process from "node:process";
 import { builtinModules, createRequire } from "node:module";
 import { randomBytes } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { build } from "esbuild";
+import { childPids, reap } from "./children.js";
 import { runtimeDir } from "./package.js";
 import { cellMeta, WORKER_MODULES } from "./workerd-target.js";
 export const WRANGLER_CONFIGS = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"];
@@ -128,8 +130,12 @@ class MiniflareHost {
     #mf;
     #exitListeners = [];
     #stopped = false;
-    constructor(mf, channel, version, project) {
+    #forget;
+    constructor(mf, channel, version, project, workerd) {
         this.#mf = mf;
+        // Miniflare kills its workerd only on a normal exit; the helper in
+        // src/children.ts kills it if this process is SIGKILLed (#241).
+        this.#forget = workerd.map(reap);
         this.channel = channel;
         this.runtime = `miniflare ${version}`.trim();
         this.project = project;
@@ -140,6 +146,8 @@ class MiniflareHost {
         this.#stopped = true;
         // dispose() ends workerd even mid-cell.
         void this.#mf.dispose().catch(() => { }).finally(() => {
+            for (const forget of this.#forget)
+                forget();
             for (const listener of this.#exitListeners)
                 listener(null);
         });
@@ -178,6 +186,8 @@ export async function startMiniflare(configPath, cwd) {
         // Miniflare 5 renamed Miniflare 4's defaultPersistRoot.
         ...(v5 ? { resourcePersistencePath: state } : { defaultPersistRoot: state }),
     };
+    // Miniflare's workerd is this process's child; it doesn't say which.
+    const before = new Set(childPids(process.pid, "workerd"));
     const mf = new miniflare.Miniflare(v5 && miniflare.convertV4MiniflareOptions ? miniflare.convertV4MiniflareOptions(options) : options);
     try {
         await mf.ready;
@@ -186,7 +196,8 @@ export async function startMiniflare(configPath, cwd) {
         const res = await mf.dispatchFetch("http://cdpk/", { headers: { Upgrade: "websocket", "x-cdpk-token": token } });
         if (res.status !== 101 || res.webSocket === null)
             throw new Error(`the driver answered ${res.status}: ${await res.text()}`);
-        return new MiniflareHost(mf, channelOf(res.webSocket), version, configPath);
+        const workerd = childPids(process.pid, "workerd").filter((pid) => !before.has(pid));
+        return new MiniflareHost(mf, channelOf(res.webSocket), version, configPath, workerd);
     }
     catch (err) {
         await mf.dispose().catch(() => { });

package/dist/zmtp.d.ts

@@ -25,6 +25,8 @@ export declare class Queue<T> {
     push(item: T): void;
     pop(): Promise<T>;
 }
+/** Resolves once `server` is listening, after any retries. */
+export declare function listening(server: Server): Promise<void>;
 /** REP socket for the heartbeat channel: echo everything. */
 export declare function startHeartbeat(port: number, host: string): Server;
 export interface RoutedMessage {

package/dist/zmtp.js

@@ -8,6 +8,8 @@
 import { Buffer } from "node:buffer";
 import { createServer } from "node:net";
 import { randomBytes } from "node:crypto";
+import process from "node:process";
+import { portHolders } from "./port-holder.js";
 const ENC = new TextEncoder();
 /** Pull-style reader over a socket's 'data' events. */
 export class SocketReader {
@@ -154,6 +156,12 @@ function listen(port, host, onConn) {
     const deadline = Date.now() + LISTEN_RETRY_MS;
     const onError = (err) => {
         if (err.code !== "EADDRINUSE" || Date.now() >= deadline) {
+            // Who kept it, for a port that never came free (#257).
+            if (err.code === "EADDRINUSE") {
+                const holders = portHolders(port).map((line) => `  ${line}\n`).join("") || "  unknown\n";
+                process.stderr.write(`[cdp-kernel] port ${port} still in use after ${LISTEN_RETRY_MS} ms; this kernel is pid ${process.pid} ` +
+                    `(ppid ${process.ppid}, ${process.execPath} ${process.version}); the port's sockets:\n${holders}`);
+            }
             server.off("error", onError);
             server.emit("error", err);
             return;
@@ -187,6 +195,10 @@ export class Queue {
         return new Promise((resolve) => this.#waiters.push(resolve));
     }
 }
+/** Resolves once `server` is listening, after any retries. */
+export function listening(server) {
+    return server.listening ? Promise.resolve() : new Promise((resolve) => server.once("listening", () => resolve()));
+}
 /** REP socket for the heartbeat channel: echo everything. */
 export function startHeartbeat(port, host) {
     return listen(port, host, (socket) => {