@tlockney/cdp-kernel 0.12.0 → 0.12.1

package/dist/package.d.ts

@@ -1,5 +1,5 @@
 /** Kept equal to package.json and deno.jsonc by test/package.test.ts. */
-export declare const VERSION = "0.12.0";
+export declare const VERSION = "0.12.1";
 /**
  * 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

package/dist/package.js

@@ -14,7 +14,7 @@ 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.12.0";
+export const VERSION = "0.12.1";
 /**
  * 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tlockney/cdp-kernel",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Deno's Jupyter kernel, extracted to run notebooks on Node, Deno, Bun, workerd and celld",
   "license": "MIT",
   "author": "Thomas Lockney <thomas@lockney.net>",

package/runtime/browser-worker.mjs

@@ -163,6 +163,9 @@ function install({ base, cdn: cdnBase, modules: moduleMap, params }) {
   globalThis.__cdpk = {
     import: (specifier, options) => import(resolveSpecifier(specifier, url, cdn, modules), options),
     meta: { url, resolve: (specifier) => resolveSpecifier(specifier, url, cdn, modules) },
+    // The URL `modules` maps a specifier to, or null: jupyter.sql's DuckDB
+    // files load from the page this way.
+    mapped: (specifier) => (modules && Object.hasOwn(modules, specifier) ? new URL(modules[specifier], url).href : null),
     // inspect_request (#10): by descriptor, so nothing runs.
     describeForInspect: (value, detail) => describeValue(value, { inspect: (v) => inspect(v, { depth: 2 }), detail }),
     inspectPath: (path, detail) => inspectPath(path, { inspect: (v) => inspect(v, { depth: 2 }), detail }),

package/runtime/display.mjs

@@ -462,7 +462,11 @@ export function createJupyter(host) {
 
   // jupyter.sql (#477): DuckDB, loaded on the first query; an interrupt
   // (jupyter.signal) interrupts the query.
-  const sql = createSql({ importModule: cellImport("jupyter.sql"), signal: () => current.signal });
+  const sql = createSql({
+    importModule: cellImport("jupyter.sql"),
+    mapped: (specifier) => globalThis.__cdpk?.mapped?.(specifier) ?? null,
+    signal: () => current.signal,
+  });
 
   // jupyter.chart (#479): vega, vega-lite or linkedom, loaded on first use.
   const chart = createChart({ importModule: cellImport("jupyter.chart"), summarizeSpec: summarizeChart });

package/runtime/sql.d.mts

@@ -2,6 +2,19 @@ import type { Displayable } from "./display.d.mts";
 
 export const NODE_API: string;
 export const DUCKDB_WASM: string;
+export interface DuckDBBundle {
+  mainModule: string;
+  mainWorker: string;
+  pthreadWorker?: string | null;
+}
+export const DUCKDB_FILES: {
+  readonly mvp: { readonly mainModule: string; readonly mainWorker: string };
+  readonly eh: { readonly mainModule: string; readonly mainWorker: string };
+};
+export function duckdbBundles(
+  jsDelivr: Record<string, DuckDBBundle>,
+  mapped?: (specifier: string) => string | null | undefined,
+): Record<string, DuckDBBundle>;
 
 /** One column of a query's result. */
 export interface SqlColumn {
@@ -142,6 +155,7 @@ export interface SqlEngine {
 
 export function createSql(options: {
   importModule: (specifier: string) => Promise<any>;
+  mapped?: (specifier: string) => string | null | undefined;
   signal?: () => AbortSignal | undefined;
   openEngine?: () => Promise<SqlEngine>;
 }): Sql;

package/runtime/sql.mjs

@@ -21,6 +21,35 @@ export { timeText, uniqueNames };
 export const NODE_API = "npm:@duckdb/node-api@1.5.6-r.2";
 export const DUCKDB_WASM = "npm:@duckdb/duckdb-wasm@1.29.0";
 
+/**
+ * The files duckdb-wasm runs from besides its module, by the specifier a
+ * browser kernel's `modules` option maps to a URL the page serves. A
+ * variant whose wasm and worker are both mapped loads from those URLs;
+ * the others load from jsDelivr, as duckdb-wasm's own list has them.
+ */
+export const DUCKDB_FILES = {
+  mvp: { mainModule: `${DUCKDB_WASM}/dist/duckdb-mvp.wasm`, mainWorker: `${DUCKDB_WASM}/dist/duckdb-browser-mvp.worker.js` },
+  eh: { mainModule: `${DUCKDB_WASM}/dist/duckdb-eh.wasm`, mainWorker: `${DUCKDB_WASM}/dist/duckdb-browser-eh.worker.js` },
+};
+
+/**
+ * duckdb-wasm's bundles: jsDelivr's, with each variant `mapped` gives
+ * both files for in their place.
+ *
+ * @param {Record<string, { mainModule: string, mainWorker: string, pthreadWorker?: string | null }>} jsDelivr
+ * @param {(specifier: string) => string | null | undefined} [mapped]
+ */
+export function duckdbBundles(jsDelivr, mapped) {
+  const bundles = { ...jsDelivr };
+  if (!mapped) return bundles;
+  for (const [variant, files] of Object.entries(DUCKDB_FILES)) {
+    const mainModule = mapped(files.mainModule);
+    const mainWorker = mapped(files.mainWorker);
+    if (mainModule && mainWorker) bundles[variant] = { mainModule, mainWorker, pthreadWorker: null };
+  }
+  return bundles;
+}
+
 const $display = Symbol.for("Jupyter.display");
 const RAW = Symbol("cdpk.sql.raw");
 
@@ -190,6 +219,7 @@ const DUCK_TYPES = {
 /**
  * @param {{
  *   importModule: (specifier: string) => Promise<any>,
+ *   mapped?: (specifier: string) => string | null | undefined,
  *   signal?: () => AbortSignal | undefined,
  *   openEngine?: () => Promise<Engine>,
  * }} options
@@ -201,9 +231,9 @@ const DUCK_TYPES = {
  *   connection: unknown,
  * }} Engine
  */
-export function createSql({ importModule, signal, openEngine }) {
+export function createSql({ importModule, mapped, signal, openEngine }) {
   let engine = null;
-  const open = () => (engine ??= (openEngine ?? (() => defaultEngine(importModule)))().catch((err) => {
+  const open = () => (engine ??= (openEngine ?? (() => defaultEngine(importModule, mapped)))().catch((err) => {
     engine = null;
     throw err;
   }));
@@ -321,9 +351,9 @@ function hasNativeRuntime() {
     typeof globalThis.process?.versions?.node === "string" && !inWorker();
 }
 
-async function defaultEngine(importModule) {
+async function defaultEngine(importModule, mapped) {
   if (hasNativeRuntime()) return nativeEngine(importModule);
-  if (inWorker() && typeof Worker === "function") return wasmEngine(importModule);
+  if (inWorker() && typeof Worker === "function") return wasmEngine(importModule, mapped);
   throw new Error("jupyter.sql needs Node, Deno, Bun or the browser target; workerd and celld have no DuckDB");
 }
 
@@ -355,9 +385,10 @@ async function nativeEngine(importModule) {
   };
 }
 
-async function wasmEngine(importModule) {
+async function wasmEngine(importModule, mapped) {
   const duckdb = await importModule(DUCKDB_WASM);
-  const bundle = await duckdb.selectBundle(duckdb.getJsDelivrBundles());
+  // An app that serves the files (DUCKDB_FILES) runs SQL offline.
+  const bundle = await duckdb.selectBundle(duckdbBundles(duckdb.getJsDelivrBundles(), mapped));
   // A Worker can only start from its own origin's scripts, so a Blob
   // script loads DuckDB's.
   const loader = URL.createObjectURL(new Blob([`importScripts(${JSON.stringify(bundle.mainWorker)});`], { type: "text/javascript" }));