@tlockney/cdp-kernel 0.4.0 → 0.6.0

package/dist/notebook-types.js

@@ -0,0 +1,310 @@
+// TypeScript's language service over a notebook (#263): completion from
+// declared types, where the runtime only knows values. Runs in a worker
+// (src/language-service-worker.ts); see probes/ts-language-service.md for
+// the design and its measurements.
+//
+// The service sees one virtual file, never written to disk, in the
+// notebook's directory (so relative imports resolve from there): the cells
+// executed so far, then the cell being edited. REPL cells redeclare names
+// all the time (`const x = 1`, later `const x = "s"`), which in one file is
+// an error that keeps the first type, so a declaration is dropped from the
+// history when a later cell, or the one being edited, declares all of its
+// names again.
+import { join } from "node:path";
+import { findLockFile, installedPackageDir, jsrToNpm, parsePackageSpecifier } from "../runtime/node-hooks.mjs";
+// The document is a module, so top-level await in a cell isn't an error.
+const PREFIX = "export {};\n";
+export class NotebookTypes {
+    #ts;
+    #options;
+    #file;
+    #globalsFile;
+    #service;
+    #compilerOptions;
+    #resolutionCache;
+    /** ts.sys, plus the remote modules a Deno target fetched (virtual paths). */
+    #resolutionHost;
+    #cells = [];
+    /** Specifiers executed cells imported: the target has fetched them. */
+    #imported = new Set();
+    /** Declaration files that exist only in memory, e.g. `deno types`. */
+    #virtualTypes = new Map();
+    #typeFiles;
+    #text = PREFIX;
+    #version = 0;
+    #projectVersion = 0;
+    constructor(ts, options) {
+        this.#ts = ts;
+        this.#options = options;
+        this.#typeFiles = [...options.typeFiles];
+        this.#file = join(options.notebookDir, "__cdpk_notebook__.ts");
+        this.#globalsFile = join(options.notebookDir, "__cdpk_globals__.d.ts");
+        this.#compilerOptions = {
+            target: ts.ScriptTarget.ESNext,
+            module: ts.ModuleKind.Preserve,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+            allowImportingTsExtensions: true,
+            allowJs: true,
+            strict: true,
+            noEmit: true,
+            skipLibCheck: true,
+            lib: ["lib.esnext.d.ts"],
+            types: options.types,
+        };
+        const deno = options.deno;
+        this.#resolutionHost = {
+            ...ts.sys,
+            fileExists: (f) => deno?.localFile(f) !== undefined || ts.sys.fileExists(f),
+            readFile: (f) => {
+                const local = deno?.localFile(f);
+                return ts.sys.readFile(local ?? f);
+            },
+            directoryExists: (d) => (deno !== undefined && d.startsWith(deno.root)) || ts.sys.directoryExists(d),
+            getCurrentDirectory: () => options.notebookDir,
+        };
+        const host = this.#host();
+        this.#resolutionCache = ts.createModuleResolutionCache(options.notebookDir, (f) => f, this.#compilerOptions);
+        this.#service = ts.createLanguageService(host, ts.createDocumentRegistry());
+    }
+    /** An executed cell: its declarations are in scope for later ones. */
+    addCell(code) {
+        this.#cells.push({ code, statements: this.#statements(code) });
+        const ts = this.#ts;
+        const sf = ts.createSourceFile("cell.ts", code, ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+        for (const stmt of sf.statements) {
+            if ((ts.isImportDeclaration(stmt) || ts.isExportDeclaration(stmt)) && stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier)) {
+                this.#imported.add(stmt.moduleSpecifier.text);
+            }
+        }
+    }
+    /** The runtime restarted and lost its state. */
+    reset() {
+        this.#cells.length = 0;
+    }
+    /** Adds declaration files, e.g. runtime types installed after startup. */
+    addTypeFiles(files) {
+        this.#typeFiles.push(...files.filter((f) => !this.#typeFiles.includes(f)));
+        this.#projectVersion++;
+    }
+    /** Adds a declaration file held in memory, e.g. the output of `deno types`. */
+    addVirtualTypeFile(name, text) {
+        this.#virtualTypes.set(join(this.#options.notebookDir, name), text);
+        this.#projectVersion++;
+    }
+    /** Adds type packages (compilerOptions.types) that resolve from the notebook. */
+    addTypeNames(names) {
+        const current = this.#compilerOptions.types ?? [];
+        // A new object: the service compares options by identity first.
+        this.#compilerOptions = { ...this.#compilerOptions, types: [...current, ...names.filter((n) => !current.includes(n))] };
+        this.#projectVersion++;
+    }
+    /** Whether a type package (compilerOptions.types) resolves from the notebook. */
+    resolvesTypes(name) {
+        // Default type roots are found up from the current directory.
+        const host = { ...this.#ts.sys, getCurrentDirectory: () => this.#options.notebookDir };
+        const resolved = this.#ts.resolveTypeReferenceDirective(name, this.#file, this.#compilerOptions, host);
+        return resolved.resolvedTypeReferenceDirective !== undefined;
+    }
+    /** Completions at `cursor` (a UTF-16 index) in `code`, the cell being edited. */
+    complete(code, cursor) {
+        const offset = this.#setDocument(code);
+        const prefix = /[\w$]*$/.exec(code.slice(0, cursor))?.[0] ?? "";
+        const info = this.#service.getCompletionsAtPosition(this.#file, offset + cursor, {
+            includeCompletionsForModuleExports: false,
+            includeCompletionsWithInsertText: true,
+        });
+        const ts = this.#ts;
+        const entries = (info?.entries ?? [])
+            .filter((e) => e.kind !== ts.ScriptElementKind.keyword &&
+            // Entries that would edit more than the name (`?.x`, `["a-b"]`).
+            e.insertText === undefined && e.replacementSpan === undefined &&
+            e.name.startsWith(prefix) && !e.name.startsWith("__cdpk"))
+            .sort((a, b) => (a.sortText < b.sortText ? -1 : a.sortText > b.sortText ? 1 : a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+            .map((e) => ({ name: e.name, kind: e.kind }));
+        return { start: cursor - prefix.length, entries };
+    }
+    /**
+     * The type, signature and JSDoc of the name at `cursor`: the one the
+     * cursor is in or just after, or, right after "name(", that callee.
+     */
+    quickInfo(code, cursor) {
+        const offset = this.#setDocument(code);
+        const before = code.slice(0, cursor);
+        const call = /[\w$]\(\s*$/.exec(before);
+        // The name's last character when the cursor is just past it.
+        const position = call ? call.index : /[\w$]/.test(code[cursor - 1] ?? "") ? cursor - 1 : cursor;
+        const info = this.#service.getQuickInfoAtPosition(this.#file, offset + position);
+        if (info === undefined)
+            return null;
+        const ts = this.#ts;
+        // An imported name's "import x" line repeats the cell; alone, the import
+        // didn't resolve. "any" alone is what an undeclared name gets, e.g. a
+        // global a library set at runtime.
+        const display = ts.displayPartsToString(info.displayParts).split("\n").filter((l) => !/^import [\w$]+$/.test(l)).join("\n");
+        if (display === "" || display === "any")
+            return null;
+        const lines = [display];
+        const docs = ts.displayPartsToString(info.documentation);
+        if (docs !== "")
+            lines.push(docs);
+        for (const tag of info.tags ?? []) {
+            const text = ts.displayPartsToString(tag.text);
+            lines.push(`@${tag.name}${text === "" ? "" : ` ${text}`}`);
+        }
+        return lines.join("\n");
+    }
+    /** Sets the virtual file to the history plus `code`; returns where `code` starts. */
+    #setDocument(code) {
+        const history = this.#history(new Set(this.#statements(code).flatMap((s) => s.names)));
+        const text = `${PREFIX}${history}\n`;
+        this.#text = text + code;
+        this.#version++;
+        return text.length;
+    }
+    /** The executed cells, minus declarations a later cell (or `seen`) makes again. */
+    #history(seen) {
+        const kept = [];
+        for (let i = this.#cells.length - 1; i >= 0; i--) {
+            const { code, statements } = this.#cells[i];
+            let text = code;
+            // Back to front, so earlier offsets stay valid.
+            for (let j = statements.length - 1; j >= 0; j--) {
+                const { start, end, names } = statements[j];
+                if (names.length > 0 && names.every((n) => seen.has(n)))
+                    text = text.slice(0, start) + text.slice(end);
+            }
+            for (const s of statements)
+                for (const n of s.names)
+                    seen.add(n);
+            kept.push(text);
+        }
+        return kept.reverse().join("\n");
+    }
+    #statements(code) {
+        const ts = this.#ts;
+        const sf = ts.createSourceFile("cell.ts", code, ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+        return sf.statements.map((stmt) => ({ start: stmt.pos, end: stmt.end, names: this.#declaredNames(stmt) }));
+    }
+    #declaredNames(stmt) {
+        const ts = this.#ts;
+        const bound = (name) => ts.isIdentifier(name)
+            ? [name.text]
+            : name.elements.flatMap((e) => (ts.isOmittedExpression(e) ? [] : bound(e.name)));
+        if (ts.isVariableStatement(stmt))
+            return stmt.declarationList.declarations.flatMap((d) => bound(d.name));
+        if ((ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt) || ts.isInterfaceDeclaration(stmt) ||
+            ts.isTypeAliasDeclaration(stmt) || ts.isEnumDeclaration(stmt)) && stmt.name) {
+            return [stmt.name.text];
+        }
+        if (ts.isImportDeclaration(stmt) && stmt.importClause) {
+            const clause = stmt.importClause;
+            const names = clause.name ? [clause.name.text] : [];
+            const bindings = clause.namedBindings;
+            if (bindings && ts.isNamedImports(bindings))
+                names.push(...bindings.elements.map((e) => e.name.text));
+            if (bindings && ts.isNamespaceImport(bindings))
+                names.push(bindings.name.text);
+            return names;
+        }
+        return [];
+    }
+    /** Where an npm:/jsr: import is installed in the kernel's npm cache, if it is. */
+    #cachedPackage(specifier) {
+        try {
+            const pkg = specifier.startsWith("npm:")
+                ? parsePackageSpecifier(specifier.slice(4))
+                : jsrToNpm(specifier.slice(4));
+            const installer = this.#options.npmCache ?? "npm";
+            const installed = installedPackageDir(pkg, installer, { lockFile: findLockFile(this.#options.notebookDir) });
+            return installed === null ? null : { ...installed, subpath: pkg.subpath };
+        }
+        catch {
+            return null;
+        }
+    }
+    #resolve(name, containingFile) {
+        const ts = this.#ts;
+        const deno = this.#options.deno;
+        // Only what an executed cell imported (or a fetched module imports):
+        // looking a specifier up never makes Deno fetch something new.
+        if (deno !== undefined && !/^(?:\.{0,2}\/|node:)/.test(name) && (this.#imported.has(name) || containingFile.startsWith(deno.root))) {
+            const found = deno.lookup(name);
+            if (found?.kind === "npm") {
+                return ts.resolveModuleName(join(found.dir, found.subpath), containingFile, this.#compilerOptions, this.#resolutionHost, this.#resolutionCache);
+            }
+            const extension = found?.kind === "remote" ? extensionOf(ts, found.path) : undefined;
+            if (found?.kind === "remote" && extension !== undefined) {
+                return { resolvedModule: { resolvedFileName: found.path, extension, isExternalLibraryImport: false } };
+            }
+        }
+        if (this.#options.npmCache !== null && /^(?:npm|jsr):/.test(name)) {
+            const cached = this.#cachedPackage(name);
+            // Resolved as its alias from the cache directory, so package.json
+            // "exports" and "types" apply as for any package.
+            if (cached !== null) {
+                const from = join(cached.dir, "__cdpk__.ts");
+                return ts.resolveModuleName(cached.alias + cached.subpath, from, this.#compilerOptions, this.#resolutionHost, this.#resolutionCache);
+            }
+        }
+        return ts.resolveModuleName(name, containingFile, this.#compilerOptions, this.#resolutionHost, this.#resolutionCache);
+    }
+    #host() {
+        const ts = this.#ts;
+        const file = this.#file;
+        const globalsFile = this.#globalsFile;
+        const deno = this.#options.deno;
+        const virtual = (f) => {
+            if (f === file)
+                return this.#text;
+            if (f === globalsFile)
+                return this.#options.globals;
+            const local = deno?.localFile(f);
+            return local !== undefined ? ts.sys.readFile(local) : this.#virtualTypes.get(f);
+        };
+        return {
+            getCompilationSettings: () => this.#compilerOptions,
+            getProjectVersion: () => `${this.#projectVersion}.${this.#version}`,
+            getScriptFileNames: () => [file, globalsFile, ...this.#virtualTypes.keys(), ...this.#typeFiles],
+            getScriptVersion: (f) => (f === file ? String(this.#version) : "0"),
+            getScriptSnapshot: (f) => {
+                const text = virtual(f) ?? ts.sys.readFile(f);
+                return text === undefined ? undefined : ts.ScriptSnapshot.fromString(text);
+            },
+            getCurrentDirectory: () => this.#options.notebookDir,
+            getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
+            fileExists: (f) => f === file || f === globalsFile || this.#virtualTypes.has(f) || deno?.localFile(f) !== undefined || ts.sys.fileExists(f),
+            readFile: (f) => virtual(f) ?? ts.sys.readFile(f),
+            readDirectory: ts.sys.readDirectory,
+            directoryExists: ts.sys.directoryExists,
+            getDirectories: ts.sys.getDirectories,
+            resolveModuleNameLiterals: (literals, containingFile) => literals.map((literal) => this.#resolve(literal.text, containingFile)),
+        };
+    }
+}
+/** The extension TypeScript should load a remote module's path as, if it's one it can. */
+function extensionOf(ts, path) {
+    for (const ext of [ts.Extension.Dts, ts.Extension.Dmts, ts.Extension.Ts, ts.Extension.Mts, ts.Extension.Tsx, ts.Extension.Js, ts.Extension.Mjs, ts.Extension.Jsx]) {
+        if (path.endsWith(ext))
+            return ext;
+    }
+    return undefined;
+}
+/**
+ * Declarations for the names the kernel adds to every target, as in
+ * src/globals.ts. `display` is runtime/display.mjs's path; its sibling
+ * display.d.mts types `jupyter`. Without it (a kernel run from JSR, whose
+ * runtime files aren't local), `jupyter` is untyped.
+ */
+export function kernelGlobals(display) {
+    const jupyter = display === null ? "any" : `import(${JSON.stringify(display)}).JupyterNamespace`;
+    return `declare global {
+  /** The notebook display API: display, md/html/svg templates, image, format, broadcast. */
+  var jupyter: ${jupyter};
+  /** Asks the frontend for a line of input. Null when the frontend didn't allow input for this cell. */
+  function prompt(message?: string, defaultValue?: string, options?: { password?: boolean }): string | null;
+  /** Asks a yes/no question over the Jupyter stdin channel. */
+  function confirm(message?: string): boolean;
+}
+export {};
+`;
+}

package/dist/package.d.ts

@@ -1,11 +1,11 @@
 /** Kept equal to package.json and deno.jsonc by test/package.test.ts. */
-export declare const VERSION = "0.4.0";
+export declare const VERSION = "0.6.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";
+export declare const RELEASE_DATE = "2026-10-18";
 /**
  * Deno blocks packages less than 24 hours old (minimum dependency age), so
  * a kernelspec relaunching a release from JSR would fail on release day. It

package/dist/package.js

@@ -14,13 +14,13 @@ import { join, sep } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 /** Kept equal to package.json and deno.jsonc by test/package.test.ts. */
-export const VERSION = "0.4.0";
+export const VERSION = "0.6.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";
+export const RELEASE_DATE = "2026-10-18";
 /**
  * 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
@@ -82,7 +82,7 @@ export function kernelArgv(host, execPath, origin, args) {
     return [execPath, "run", "--allow-all", ...flags, entry, ...args];
 }
 export function cacheRoot() {
-    const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
+    const base = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
     return join(base, "cdp-kernel");
 }
 async function fetchText(url) {

package/dist/parent.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Calls `onGone` once the parent named by JPY_PARENT_PID has exited: its pid
+ * is gone, or this process was reparented. A no-op when the variable is
+ * unset, so a kernel started by hand keeps running; and on Windows, where
+ * ipykernel's variable is a handle, not a pid. A pid that doesn't exist at
+ * start (the server is in another pid namespace) is ignored, leaving only
+ * the reparenting check.
+ */
+export declare function watchParent(onGone: () => void, { env, intervalMs }?: {
+    env?: NodeJS.ProcessEnv | undefined;
+    intervalMs?: number | undefined;
+}): () => void;

package/dist/parent.js

@@ -0,0 +1,39 @@
+// The server that started the kernel, watched so a server that dies without
+// shutting the kernel down (SIGKILL, a crash) doesn't leave it running with
+// its runtime and ports (#254). jupyter_server and Ganymede put their pid in
+// JPY_PARENT_PID; ipykernel's ParentPollerUnix polls for the same thing.
+import process from "node:process";
+function exists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM: it exists, under another user.
+        return err.code === "EPERM";
+    }
+}
+/**
+ * Calls `onGone` once the parent named by JPY_PARENT_PID has exited: its pid
+ * is gone, or this process was reparented. A no-op when the variable is
+ * unset, so a kernel started by hand keeps running; and on Windows, where
+ * ipykernel's variable is a handle, not a pid. A pid that doesn't exist at
+ * start (the server is in another pid namespace) is ignored, leaving only
+ * the reparenting check.
+ */
+export function watchParent(onGone, { env = process.env, intervalMs = 1000 } = {}) {
+    const parent = Number(env.JPY_PARENT_PID);
+    if (process.platform === "win32" || !Number.isInteger(parent) || parent <= 1)
+        return () => { };
+    const ppid = process.ppid;
+    const checkPid = exists(parent);
+    const timer = setInterval(() => {
+        if (process.ppid === ppid && (!checkPid || exists(parent)))
+            return;
+        clearInterval(timer);
+        onGone();
+    }, intervalMs);
+    // The kernel's sockets keep it running; this mustn't.
+    timer.unref();
+    return () => clearInterval(timer);
+}

package/dist/port-holder.d.ts

@@ -0,0 +1,13 @@
+export interface PortSocket {
+    /** The remote end as hex `address:port`, as /proc prints it. */
+    remote: string;
+    state: string;
+    inode: string;
+}
+/** The sockets in a /proc/net/tcp table whose local port is `port`. */
+export declare function socketsOnPort(table: string, port: number): PortSocket[];
+/**
+ * One line per socket on `port`: its state, remote end and owning process,
+ * or an empty list when it can't be told (not Linux, or nothing found).
+ */
+export declare function portHolders(port: number): string[];

package/dist/port-holder.js

@@ -0,0 +1,105 @@
+// Who holds a local TCP port, for the error when a connection-file port
+// stays taken past the startup retry (#257). Linux only: it reads
+// /proc/net/tcp{,6} and matches socket inodes against /proc/<pid>/fd.
+import { readdirSync, readFileSync, readlinkSync } from "node:fs";
+const STATES = {
+    "01": "ESTABLISHED",
+    "02": "SYN_SENT",
+    "03": "SYN_RECV",
+    "04": "FIN_WAIT1",
+    "05": "FIN_WAIT2",
+    "06": "TIME_WAIT",
+    "07": "CLOSE",
+    "08": "CLOSE_WAIT",
+    "09": "LAST_ACK",
+    "0A": "LISTEN",
+    "0B": "CLOSING",
+};
+/** The sockets in a /proc/net/tcp table whose local port is `port`. */
+export function socketsOnPort(table, port) {
+    const found = [];
+    for (const line of table.split("\n").slice(1)) {
+        const fields = line.trim().split(/\s+/);
+        if (fields.length < 10)
+            continue;
+        const [, local, remote, state] = fields;
+        if (parseInt(local.slice(local.lastIndexOf(":") + 1), 16) !== port)
+            continue;
+        found.push({ remote, state: STATES[state] ?? state, inode: fields[9] });
+    }
+    return found;
+}
+function describePid(pid) {
+    let cmdline = "?";
+    let ppid = "?";
+    try {
+        cmdline = readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean).join(" ");
+    }
+    catch {
+        // Exited since.
+    }
+    try {
+        // The command name in parentheses may hold spaces; ppid is the second field after it.
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        ppid = stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1];
+    }
+    catch {
+        // Exited since.
+    }
+    return `pid ${pid} (ppid ${ppid}): ${cmdline}`;
+}
+/**
+ * One line per socket on `port`: its state, remote end and owning process,
+ * or an empty list when it can't be told (not Linux, or nothing found).
+ */
+export function portHolders(port) {
+    const sockets = [];
+    for (const table of ["/proc/net/tcp", "/proc/net/tcp6"]) {
+        try {
+            sockets.push(...socketsOnPort(readFileSync(table, "utf8"), port));
+        }
+        catch {
+            // No /proc, or no IPv6.
+        }
+    }
+    if (sockets.length === 0)
+        return [];
+    const owners = new Map();
+    const wanted = new Set(sockets.map((s) => `socket:[${s.inode}]`));
+    let pids = [];
+    try {
+        pids = readdirSync("/proc").filter((name) => /^\d+$/.test(name));
+    }
+    catch {
+        // Leave owners unknown.
+    }
+    for (const pid of pids) {
+        let fds;
+        try {
+            fds = readdirSync(`/proc/${pid}/fd`);
+        }
+        catch {
+            continue; // Another user's, or exited.
+        }
+        for (const fd of fds) {
+            let link;
+            try {
+                link = readlinkSync(`/proc/${pid}/fd/${fd}`);
+            }
+            catch {
+                continue;
+            }
+            if (!wanted.has(link))
+                continue;
+            const list = owners.get(link) ?? [];
+            if (!list.includes(pid))
+                list.push(pid);
+            owners.set(link, list);
+        }
+    }
+    return sockets.map((s) => {
+        const pidsOf = owners.get(`socket:[${s.inode}]`) ?? [];
+        const who = pidsOf.length > 0 ? pidsOf.map(describePid).join("; ") : s.inode === "0" ? "no process" : "owner not visible";
+        return `${s.state} to ${s.remote}, ${who}`;
+    });
+}

package/dist/sourcemap.d.ts

@@ -9,8 +9,13 @@ 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);
+    /**
+     * `offset`: lines the script adds before esbuild's output (the prelude).
+     * `generated`: that output. A stripper that keeps lines blanks a
+     * type-only line in place and still maps it; with the output given, a
+     * blank line counts as unmapped, so a breakpoint there moves down (#239).
+     */
+    constructor(mappings: string, offset?: number, generated?: string);
     /** The cell line a script line came from: its own mapping, or the nearest one above. */
     toOriginal(generated: number): number;
     /**

package/dist/sourcemap.js

@@ -52,9 +52,15 @@ export function generatedToOriginalLines(mappings) {
 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);
+    /**
+     * `offset`: lines the script adds before esbuild's output (the prelude).
+     * `generated`: that output. A stripper that keeps lines blanks a
+     * type-only line in place and still maps it; with the output given, a
+     * blank line counts as unmapped, so a breakpoint there moves down (#239).
+     */
+    constructor(mappings, offset = 0, generated) {
+        const blank = generated?.split("\n").map((line) => line.trim() === "");
+        const fromEsbuild = generatedToOriginalLines(mappings).map((original, line) => blank?.[line] ? -1 : original);
         this.#toOriginal = [...Array(offset).fill(-1), ...fromEsbuild];
         this.#toOriginal.forEach((original, generated) => {
             if (original !== -1 && !this.#toGenerated.has(original))

package/dist/strip-esbuild.d.ts

@@ -0,0 +1,2 @@
+import { type TypeStripper } from "./transform.ts";
+export declare const stripTypes: TypeStripper;

package/dist/strip-esbuild.js

@@ -0,0 +1,44 @@
+// The default type stripper: esbuild. Loaded by loadTypeStripper (see
+// src/transform.ts) only when a kernel uses it, so a host that can't run
+// esbuild's native binary never imports it (#238).
+import { transformSync } from "esbuild";
+import { CellSyntaxError } from "./transform.js";
+function jsxSettings(jsx) {
+    if (jsx?.mode === "automatic") {
+        return { jsx: "automatic", jsxImportSource: jsx.importSource, jsxDev: jsx.development };
+    }
+    return { jsx: "transform", jsxFactory: jsx?.factory, jsxFragment: jsx?.fragment };
+}
+export const stripTypes = (code, options, sourcemap) => {
+    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/, ""));
+};

package/dist/strip-sucrase.d.ts

@@ -0,0 +1,2 @@
+import { type TypeStripper } from "./transform.ts";
+export declare const stripTypes: TypeStripper;