@tlockney/cdp-kernel 0.10.0 → 0.12.0

package/dist/browser/worker.js

@@ -306,10 +306,10 @@ var Widget = class {
   #state;
   #listeners = /* @__PURE__ */ new Map();
   // event -> Set<listener>
-  constructor(comm, state, $display2) {
+  constructor(comm, state, $display4) {
     this.#comm = comm;
     this.#state = state;
-    this[$display2] = () => ({
+    this[$display4] = () => ({
       [VIEW_MIME]: { version_major: 2, version_minor: 1, model_id: this.id },
       "text/plain": `Widget(${this.id})`
     });
@@ -374,7 +374,7 @@ var Widget = class {
     }
   }
 };
-function createWidgetFactory(commApi, $display2) {
+function createWidgetFactory(commApi, $display4) {
   const live = /* @__PURE__ */ new Map();
   commApi.registerTarget(CONTROL_TARGET, (control) => {
     control.onMsg((msg) => {
@@ -408,7 +408,7 @@ function createWidgetFactory(commApi, $display2) {
       metadata: { version: WIDGET_PROTOCOL_VERSION },
       buffers
     });
-    const instance = new Widget(comm, { ...full }, $display2);
+    const instance = new Widget(comm, { ...full }, $display4);
     live.set(comm.id, instance);
     comm.onMsg((msg) => instance._receive(msg));
     comm.onClose(() => {
@@ -418,19 +418,1097 @@ function createWidgetFactory(commApi, $display2) {
   };
 }
 
-// runtime/display.mjs
+// runtime/table.mjs
+var TABLE_MIME = "application/vnd.dataresource+json";
+var DEFAULT_LIMIT = 1e3;
+var MAX_LIMIT = 1e4;
+var MAX_BYTES = 1e6;
+var MAX_CELL = 1e3;
+var HTML_ALL = 20;
+var HTML_HEAD = 10;
+var HTML_TAIL = 5;
+var TEXT_HEAD = 3;
+var TEXT_TAIL = 2;
+var TEXT_COLUMNS = 20;
+var TEXT_MAX = 4096;
+var rawToEntity = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+var escapeHTML = (s) => s.replace(/[&<>"']/g, (c) => rawToEntity[c]);
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function isArrowTable(value) {
+  return isObject(value) && isObject(value.schema) && Array.isArray(value.schema.fields) && typeof value.numRows === "number" && typeof value.getChild === "function";
+}
+function isPolarsFrame(value) {
+  return isObject(value) && isObject(value.schema) && typeof value.head === "function" && typeof value.toRecords === "function";
+}
+function isDuckDBShaped(value) {
+  return isObject(value) && typeof value.columnNames === "function" && typeof value.columnTypes === "function" && typeof value.getRowObjectsJS === "function";
+}
+function isDuckDBResult(value) {
+  return isDuckDBShaped(value) && typeof value.currentRowCount === "number" && typeof value.getRowsJS === "function" && value.done === true;
+}
+function isTableLike(value) {
+  return isArrowTable(value) || isPolarsFrame(value) || isDuckDBResult(value);
+}
+function schemaType(declared) {
+  const t = String(declared ?? "");
+  if (t === "") return void 0;
+  if (/^(list|large_?list|fixed_?size_?list|array)\b|\[\d*\]$/i.test(t)) return "array";
+  if (/^(struct|map|union|json)\b/i.test(t)) return "object";
+  if (/^(u?int\d*|u?(tiny|small|big|huge)?int(eger)?)\b/i.test(t)) return "integer";
+  if (/^(float\d*|double|real|decimal|numeric)\b/i.test(t)) return "number";
+  if (/^bool/i.test(t)) return "boolean";
+  if (/^date(32|64)?(<|$|\b(?!time))/i.test(t) && !/^datetime/i.test(t)) return "date";
+  if (/^(timestamp|datetime)/i.test(t)) return "datetime";
+  if (/^time/i.test(t)) return "time";
+  if (/^(interval|duration)/i.test(t)) return "duration";
+  if (/^(utf8|large_?utf8|string|varchar|char|text|categorical|enum|uuid|null)\b/i.test(t)) return "string";
+  return void 0;
+}
+function polarsDeclared(dtype) {
+  if (typeof dtype?.toJSON === "function") {
+    const json = dtype.toJSON();
+    const name = isObject(json) ? json.DataType ?? Object.keys(json)[0] : json;
+    if (typeof name === "string") return name;
+    if (isObject(name)) return Object.keys(name)[0];
+  }
+  return typeof dtype === "string" ? dtype : void 0;
+}
+function inferType(values) {
+  let type;
+  for (const v of values) {
+    if (v === null || v === void 0) continue;
+    let t;
+    if (typeof v === "bigint") t = "integer";
+    else if (typeof v === "number") t = Number.isInteger(v) ? "integer" : "number";
+    else if (typeof v === "boolean") t = "boolean";
+    else if (typeof v === "string") t = "string";
+    else if (v instanceof Date) t = v.getTime() % 864e5 === 0 ? "date" : "datetime";
+    else if (Array.isArray(v) || ArrayBuffer.isView(v)) t = ArrayBuffer.isView(v) && !(v instanceof DataView) && v.BYTES_PER_ELEMENT === 1 ? "string" : "array";
+    else t = "object";
+    if (type === void 0) type = t;
+    else if (type !== t) {
+      if (type === "integer" && t === "number" || type === "number" && t === "integer") type = "number";
+      else if (type === "date" && t === "datetime" || type === "datetime" && t === "date") type = "datetime";
+      else return "string";
+    }
+  }
+  return type ?? "string";
+}
+function clipString(s, max = MAX_CELL) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+function toDate(value) {
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+  if (typeof value === "number" || typeof value === "bigint") {
+    const d = new Date(Number(value));
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  return null;
+}
+function plain(value, depth = 0) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "bigint") return Number.isSafeInteger(Number(value)) ? Number(value) : String(value);
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (typeof value === "string") return clipString(value);
+  if (typeof value !== "object") return value;
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value.toISOString();
+  if (depth > 8) return "\u2026";
+  if (ArrayBuffer.isView(value) && !(value instanceof DataView) && value.BYTES_PER_ELEMENT === 1) {
+    return `<${value.byteLength} bytes>`;
+  }
+  if (Array.isArray(value) || ArrayBuffer.isView(value)) return Array.from(value, (v) => plain(v, depth + 1));
+  if (typeof value.toJSON === "function") return plain(value.toJSON(), depth + 1);
+  if (typeof value.toArray === "function") return plain(value.toArray(), depth + 1);
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = plain(v, depth + 1);
+  return out;
+}
+function encodeValue(value, type, declared) {
+  if (value === null || value === void 0) return null;
+  if (type === "time" && (typeof value === "bigint" || typeof value === "number")) return timeText(value, declared);
+  if (type === "date" || type === "datetime") {
+    const d = toDate(value);
+    if (d) return type === "date" ? d.toISOString().slice(0, 10) : d.toISOString();
+  }
+  if (typeof value === "bigint") return Number.isSafeInteger(Number(value)) ? Number(value) : String(value);
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) return "NaN";
+    if (!Number.isFinite(value)) return value > 0 ? "Infinity" : "-Infinity";
+    return value;
+  }
+  if (typeof value === "string") return clipString(value);
+  if (typeof value === "boolean") return value;
+  return plain(value);
+}
+function timeText(value, declared = "") {
+  const d = String(declared);
+  const unit = /NANOSECOND|^Time$/.test(d) || /_NS$/i.test(d) ? 1000000000n : /MILLISECOND/i.test(d) ? 1000n : /<SECOND/i.test(d) ? 1n : 1000000n;
+  const total = typeof value === "bigint" ? value : BigInt(Math.trunc(value));
+  const seconds = total / unit;
+  const fraction = total % unit;
+  const pad = (n) => String(n).padStart(2, "0");
+  const text = `${pad(seconds / 3600n)}:${pad(seconds / 60n % 60n)}:${pad(seconds % 60n)}`;
+  if (fraction === 0n) return text;
+  return `${text}.${String(fraction).padStart(String(unit).length - 1, "0").replace(/0+$/, "")}`;
+}
+function uniqueNames(names) {
+  const seen = /* @__PURE__ */ new Set();
+  return names.map((name) => {
+    let unique = name;
+    for (let i = 1; seen.has(unique); i++) unique = `${name}_${i}`;
+    seen.add(unique);
+    return unique;
+  });
+}
+function fromObjects(rows, names) {
+  let columns = names;
+  if (!columns) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const row of rows.slice(0, DEFAULT_LIMIT)) {
+      if (isObject(row)) for (const key2 of Object.keys(row)) seen.add(key2);
+    }
+    columns = [...seen];
+  }
+  return {
+    columns: columns.map((name) => ({ name: String(name) })),
+    total: rows.length,
+    read: (start, end) => rows.slice(start, end).map((row) => columns.map((c) => isObject(row) ? row[c] : void 0))
+  };
+}
+function fromArrays(rows, names) {
+  const width = names?.length ?? Math.max(0, ...rows.slice(0, DEFAULT_LIMIT).map((r) => Array.isArray(r) ? r.length : 0));
+  const columns = names ?? Array.from({ length: width }, (_, i) => String(i));
+  return {
+    columns: columns.map((name) => ({ name: String(name) })),
+    total: rows.length,
+    read: (start, end) => rows.slice(start, end).map((row) => columns.map((_, i) => Array.isArray(row) ? row[i] : void 0))
+  };
+}
+function fromArrow(table, names) {
+  const fields = table.schema.fields.filter((f) => !names || names.includes(f.name));
+  const vectors = fields.map((f) => table.getChild(f.name));
+  return {
+    columns: fields.map((f) => ({ name: String(f.name), declared: String(f.type) })),
+    total: table.numRows,
+    read(start, end) {
+      const out = [];
+      for (let i = start; i < Math.min(end, table.numRows); i++) out.push(vectors.map((v) => v?.get(i)));
+      return out;
+    }
+  };
+}
+function fromPolars(df, names) {
+  const columns = Object.entries(df.schema).filter(([name]) => !names || names.includes(name)).map(([name, dtype]) => ({ name, declared: polarsDeclared(dtype) }));
+  const total = Number.isInteger(df.height) ? df.height : df.toRecords().length;
+  const records = (start, end) => typeof df.slice === "function" ? df.slice(start, end - start).toRecords() : df.toRecords().slice(start, end);
+  return {
+    columns,
+    total,
+    read: (start, end) => records(start, Math.min(end, total)).map((row) => columns.map((c) => row[c.name]))
+  };
+}
+function fromDuckDB(result, names) {
+  const types = result.columnTypes();
+  const all = result.columnNames().map((name, i) => ({ name, declared: String(types[i]) }));
+  const columns = names ? all.filter((c) => names.includes(c.name)) : all;
+  const at = columns.map((c) => all.indexOf(c));
+  let rows;
+  const get = () => rows ??= result.getRowsJS();
+  return {
+    columns,
+    total: result.currentRowCount,
+    read: (start, end) => get().slice(start, end).map((row) => at.map((i) => row[i]))
+  };
+}
+function tableSource(value, options = {}) {
+  const names = Array.isArray(options.columns) ? options.columns.map(String) : void 0;
+  if (isObject(value) && typeof value.toTableSource === "function") return value.toTableSource(names);
+  if (isArrowTable(value)) return fromArrow(value, names);
+  if (isPolarsFrame(value)) return fromPolars(value, names);
+  if (isDuckDBResult(value)) return fromDuckDB(value, names);
+  if (isDuckDBShaped(value)) {
+    throw new TypeError(typeof value.currentRowCount === "number" ? "jupyter.table: this DuckDB reader hasn't read all its rows; call readAll() first, or use runAndReadAll()" : "jupyter.table: a DuckDB run() result reads its rows asynchronously; use runAndReadAll(), or jupyter.sql");
+  }
+  if (Array.isArray(value)) {
+    const first = value.find((row) => row !== null && row !== void 0);
+    return Array.isArray(first) ? fromArrays(value, names) : fromObjects(value, names);
+  }
+  throw new TypeError(
+    "jupyter.table takes an array of rows, an Arrow table, a Polars DataFrame or a DuckDB result"
+  );
+}
+function fieldsOf(source, rows) {
+  const names = uniqueNames(source.columns.map((c) => c.name));
+  return source.columns.map((c, i) => ({
+    name: names[i],
+    type: schemaType(c.declared) ?? inferType(rows.map((r) => r[i]))
+  }));
+}
+function count(n, noun) {
+  return `${n.toLocaleString("en-US")} ${n === 1 ? noun : `${noun}s`}`;
+}
+function shortValue(v) {
+  if (v === null || v === void 0) return "";
+  const s = typeof v === "string" ? v : JSON.stringify(v);
+  return clipString(s.replace(/\s+/g, " "), 30);
+}
+function columnStats(rows, i, type) {
+  let nulls = 0;
+  const values = [];
+  for (const row of rows) {
+    const v = row[i];
+    if (v === null) nulls++;
+    else values.push(v);
+  }
+  let range = "";
+  if (values.length) {
+    if (type === "integer" || type === "number") {
+      const nums = values.map(Number).filter(Number.isFinite);
+      if (nums.length) {
+        const min = Math.min(...nums);
+        const max = Math.max(...nums);
+        const fmt = (n) => Number.isInteger(n) && Math.abs(n) >= 1e4 ? n.toLocaleString("en-US") : String(Number(n.toPrecision(6)));
+        range = min === max ? fmt(min) : `${fmt(min)} to ${fmt(max)}`;
+      }
+    } else if (type === "date" || type === "datetime" || type === "time") {
+      const sorted = values.map(String).sort();
+      range = sorted[0] === sorted.at(-1) ? sorted[0] : `${sorted[0]} to ${sorted.at(-1)}`;
+    } else if (type === "boolean") {
+      const t = values.filter((v) => v === true).length;
+      range = `${t} true, ${values.length - t} false`;
+    } else {
+      const distinct = new Set(values.map((v) => typeof v === "string" ? v : JSON.stringify(v))).size;
+      range = count(distinct, "value");
+    }
+  }
+  return [range, nulls ? count(nulls, "null") : ""].filter(Boolean).join(", ");
+}
+function htmlTable(fields, head, tail, total, title) {
+  let html = "<table>";
+  if (title) html += `<caption>${escapeHTML(title)}</caption>`;
+  html += "<thead><tr>";
+  for (const f of fields) {
+    html += `<th>${escapeHTML(f.name)}<br><small>${escapeHTML(f.type)}</small></th>`;
+  }
+  html += "</tr></thead><tbody>";
+  const row = (r) => {
+    let s = "<tr>";
+    fields.forEach((f, i) => {
+      const v = r[i];
+      const text = v === null ? "" : typeof v === "string" ? v : JSON.stringify(v);
+      const align = f.type === "integer" || f.type === "number" ? ' style="text-align:right"' : "";
+      s += `<td${align}>${escapeHTML(text)}</td>`;
+    });
+    return `${s}</tr>`;
+  };
+  for (const r of head) html += row(r);
+  const hidden = total - head.length - tail.length;
+  if (hidden > 0) html += `<tr><td colspan="${Math.max(1, fields.length)}">\u2026 ${count(hidden, "more row")}</td></tr>`;
+  for (const r of tail) html += row(r);
+  return `${html}</tbody></table>`;
+}
+function textTable(fields, numbered) {
+  const cells = numbered.map(([n, r]) => [String(n), ...r.map(shortValue)]);
+  const widths = [0, ...fields.map(() => 0)];
+  for (const row of cells) row.forEach((c, i) => widths[i] = Math.max(widths[i], c.length));
+  return cells.map((row) => `  ${row.map((c, i) => c.padEnd(widths[i])).join(" | ").trimEnd()}`);
+}
+var PAGEABLE = /* @__PURE__ */ Symbol("cdpk.table.pageable");
+function encodeRow(source, fields, row) {
+  return fields.map((f, i) => encodeValue(row[i], f.type, source.columns[i].declared));
+}
+function pageTable(bundle, pager, key2) {
+  const resource = bundle?.[TABLE_MIME];
+  const pending = resource?.[PAGEABLE];
+  if (!pending || !pager || resource.ganymede?.page !== void 0) return bundle;
+  resource.ganymede.page = pager.register(pending.source, pending.fields, key2);
+  return bundle;
+}
+function tableBundle(source, options = {}) {
+  const requested = options.limit ?? DEFAULT_LIMIT;
+  if (!Number.isInteger(requested) || requested < 0) throw new TypeError("jupyter.table: limit must be a whole number");
+  const limit = Math.min(requested, MAX_LIMIT);
+  const title = typeof options.title === "string" && options.title !== "" ? options.title : void 0;
+  const total = source.total;
+  const raw = source.read(0, Math.min(limit, total));
+  const fields = fieldsOf(source, raw);
+  const encode = (r) => encodeRow(source, fields, r);
+  const utf8 = new TextEncoder();
+  const encoded = [];
+  const data = [];
+  let bytes = 0;
+  for (const r of raw) {
+    const values = encode(r);
+    const obj = {};
+    fields.forEach((f, i) => Object.defineProperty(obj, f.name, { value: values[i], enumerable: true, writable: true, configurable: true }));
+    bytes += utf8.encode(JSON.stringify(obj)).length + 1;
+    if (bytes > MAX_BYTES && data.length > 0) break;
+    encoded.push(values);
+    data.push(obj);
+  }
+  const shown = data.length;
+  const split = total > HTML_ALL;
+  const htmlHead = split ? encoded.slice(0, HTML_HEAD) : encoded.slice(0, total);
+  const htmlTail = split ? source.read(total - HTML_TAIL, total).map(encode) : [];
+  const textSplit = total > TEXT_HEAD + TEXT_TAIL;
+  const textHeadRows = encoded.slice(0, textSplit ? TEXT_HEAD : total);
+  const textTail = !textSplit ? [] : htmlTail.length ? htmlTail.slice(-TEXT_TAIL) : source.read(total - TEXT_TAIL, total).map(encode);
+  const lines = [];
+  const name = title ? `Table "${clipString(title, 80)}"` : "Table";
+  const shape = `${count(total, "row")}, ${count(fields.length, "column")}`;
+  lines.push(`${name} (${shape}${shown < total ? `; ${shown.toLocaleString("en-US")} shown` : ""})`);
+  if (fields.length) {
+    lines.push(shown < total ? `Columns (ranges over the first ${shown.toLocaleString("en-US")} of ${total.toLocaleString("en-US")} rows):` : "Columns:");
+    const nameWidth = Math.min(30, Math.max(...fields.slice(0, TEXT_COLUMNS).map((f) => f.name.length)));
+    const typeWidth = Math.max(...fields.slice(0, TEXT_COLUMNS).map((f) => f.type.length));
+    fields.slice(0, TEXT_COLUMNS).forEach((f, i) => {
+      const stats = columnStats(encoded, i, f.type);
+      lines.push(`  ${clipString(f.name, 30).padEnd(nameWidth)}  ${f.type.padEnd(typeWidth)}  ${stats}`.trimEnd());
+    });
+    if (fields.length > TEXT_COLUMNS) lines.push(`  \u2026 ${count(fields.length - TEXT_COLUMNS, "more column")}`);
+    const numbered = [
+      ...textHeadRows.map((r, i) => [i, r]),
+      ...textTail.map((r, i) => [total - textTail.length + i, r])
+    ];
+    if (numbered.length) {
+      lines.push("Rows:");
+      const table = textTable(fields.slice(0, TEXT_COLUMNS), numbered.map(([n, r]) => [n, r.slice(0, TEXT_COLUMNS)]));
+      if (textTail.length) table.splice(textHeadRows.length, 0, "  \u2026");
+      lines.push(...table);
+    }
+  }
+  let text = lines.join("\n");
+  if (text.length > TEXT_MAX) text = `${text.slice(0, TEXT_MAX - 1)}\u2026`;
+  const resource = { schema: { fields }, data, ganymede: { rows: total, shown } };
+  if (title) resource.ganymede.title = title;
+  if (shown < total) {
+    Object.defineProperty(resource, PAGEABLE, { value: { source, fields } });
+    if (options.pager) pageTable({ [TABLE_MIME]: resource }, options.pager);
+  }
+  return {
+    [TABLE_MIME]: resource,
+    "text/html": htmlTable(fields, htmlHead, htmlTail, total, title),
+    "text/plain": text
+  };
+}
+
+// runtime/sql.mjs
+var NODE_API = "npm:@duckdb/node-api@1.5.6-r.2";
+var DUCKDB_WASM = "npm:@duckdb/duckdb-wasm@1.29.0";
 var $display = /* @__PURE__ */ Symbol.for("Jupyter.display");
-var rawToEntity = /* @__PURE__ */ new Map([
+var RAW = /* @__PURE__ */ Symbol("cdpk.sql.raw");
+function jsValue(value, declared) {
+  if (/^time(?!stamp)/i.test(declared ?? "") && (typeof value === "bigint" || typeof value === "number")) {
+    return timeText(value, declared);
+  }
+  if (typeof value === "bigint") return Number.isSafeInteger(Number(value)) ? Number(value) : value;
+  if (typeof value === "number" && /^(date|timestamp)/i.test(declared ?? "")) return new Date(value);
+  if (Array.isArray(value)) return value.map((v) => jsValue(v));
+  if (value !== null && typeof value === "object" && !(value instanceof Date) && !ArrayBuffer.isView(value)) {
+    if (typeof value.toJSON === "function" && !(Symbol.iterator in value) && Object.getPrototypeOf(value) !== Object.prototype) {
+      return jsValue(value.toJSON());
+    }
+    if (typeof value.toArray === "function") return jsValue(Array.from(value.toArray()));
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = jsValue(v);
+    return out;
+  }
+  return value;
+}
+function decimalValue(words, scale) {
+  if (typeof words === "bigint" && scale === 0) return jsValue(words);
+  if (typeof words === "number" || typeof words === "bigint") return Number(words) / 10 ** scale;
+  const list2 = Array.from(words);
+  let big = 0n;
+  list2.forEach((w, i) => big |= BigInt(w >>> 0) << BigInt(32 * i));
+  const bits = BigInt(32 * list2.length);
+  if (list2.length && list2.at(-1) >>> 31) big -= 1n << bits;
+  return scale === 0 ? jsValue(big) : Number(big) / 10 ** scale;
+}
+var SqlResult = class {
+  /**
+   * @param {{ name: string, type: string }[]} columns
+   * @param {Record<string, unknown>[]} rows
+   */
+  constructor(columns, rows) {
+    this.columns = columns;
+    this.rows = rows;
+  }
+  /** table.mjs reads this instead of guessing at the shape. */
+  toTableSource(names) {
+    const columns = names ? this.columns.filter((c) => names.includes(c.name)) : this.columns;
+    return {
+      columns: columns.map((c) => ({ name: c.name, declared: c.type })),
+      total: this.rows.length,
+      read: (start, end) => this.rows.slice(start, end).map((row) => columns.map((c) => row[c.name]))
+    };
+  }
+  [$display]() {
+    return tableBundle(tableSource(this));
+  }
+};
+function toParam(value) {
+  if (value === void 0) return null;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "object" && value !== null && !ArrayBuffer.isView(value)) return JSON.stringify(value);
+  return value;
+}
+function compose(strings, values) {
+  let text = strings[0];
+  const params = [];
+  values.forEach((value, i) => {
+    if (value !== null && typeof value === "object" && RAW in value) text += value[RAW];
+    else {
+      text += "?";
+      params.push(toParam(value));
+    }
+    text += strings[i + 1];
+  });
+  return { text, params };
+}
+function quoteIdent(name) {
+  return `"${String(name).replaceAll('"', '""')}"`;
+}
+function quoteString(text) {
+  return `'${String(text).replaceAll("'", "''")}'`;
+}
+function sqlLiteral(value) {
+  const text = literalText(value);
+  return text.startsWith("-") ? `(${text})` : text;
+}
+function literalText(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (typeof value === "bigint") return `${value}`;
+  if (typeof value === "number") {
+    if (Number.isSafeInteger(value)) return String(value);
+    return Number.isFinite(value) ? `${value}::DOUBLE` : `'${value}'::DOUBLE`;
+  }
+  if (value instanceof Uint8Array) {
+    return `'${Array.from(value, (b) => `\\x${b.toString(16).padStart(2, "0")}`).join("")}'::BLOB`;
+  }
+  if (ArrayBuffer.isView(value)) return `[${Array.from(value, (v) => sqlLiteral(v)).join(", ")}]`;
+  return quoteString(value);
+}
+function inlineParams(text, params) {
+  if (params.length === 0) return text;
+  let out = "";
+  let next = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    const end = c === "'" || c === '"' ? text.indexOf(c, i + 1) : c === "-" && text[i + 1] === "-" ? text.indexOf("\n", i) : c === "/" && text[i + 1] === "*" ? text.indexOf("*/", i + 2) + 1 : void 0;
+    if (end !== void 0) {
+      const stop = end < 0 || end === 0 ? text.length : end + 1;
+      out += text.slice(i, stop);
+      i = stop - 1;
+    } else if (c === "?") {
+      if (next >= params.length) throw new RangeError("jupyter.sql: more ? placeholders than parameters");
+      if (out.endsWith("'") || out.endsWith('"')) out += " ";
+      out += sqlLiteral(params[next++]);
+    } else out += c;
+  }
+  if (next < params.length) throw new RangeError("jupyter.sql: more parameters than ? placeholders");
+  return out;
+}
+var DUCK_TYPES = {
+  integer: "BIGINT",
+  number: "DOUBLE",
+  boolean: "BOOLEAN",
+  string: "VARCHAR",
+  date: "DATE",
+  datetime: "TIMESTAMP",
+  time: "TIME",
+  array: "JSON",
+  object: "JSON",
+  duration: "VARCHAR"
+};
+function createSql({ importModule, signal, openEngine }) {
+  let engine = null;
+  const open = () => engine ??= (openEngine ?? (() => defaultEngine(importModule)))().catch((err) => {
+    engine = null;
+    throw err;
+  });
+  async function run(text, params) {
+    const s = signal?.();
+    const e = await open();
+    if (s?.aborted) throw s.reason;
+    const onAbort = () => e.interrupt?.();
+    s?.addEventListener("abort", onAbort, { once: true });
+    try {
+      return await e.query(text, params);
+    } finally {
+      s?.removeEventListener("abort", onAbort);
+    }
+  }
+  function sql(strings, ...values) {
+    if (!Array.isArray(strings) || !Array.isArray(strings.raw)) {
+      return Promise.reject(new TypeError("jupyter.sql is a tag: jupyter.sql`select ...`; for a string, use jupyter.sql.query(text, params)"));
+    }
+    const { text, params } = compose(strings, values);
+    return run(text, params);
+  }
+  sql.query = (text, params = []) => {
+    if (typeof text !== "string") return Promise.reject(new TypeError("jupyter.sql.query: text must be a string"));
+    return run(text, params.map(toParam));
+  };
+  sql.raw = (text) => ({ [RAW]: String(text) });
+  sql.load = async (name, source) => {
+    if (typeof name !== "string" || name === "") throw new TypeError("jupyter.sql.load: name must be a non-empty string");
+    const table = quoteIdent(name);
+    if (typeof source === "string") {
+      await run(`create or replace table ${table} as select * from ${quoteString(source)}`, []);
+      return;
+    }
+    const { structure, json } = rowsAsJson(source);
+    if (structure === null) {
+      throw new TypeError("jupyter.sql.load: the rows have no columns");
+    }
+    await run(
+      `create or replace table ${table} as select unnest(from_json(?, ?), recursive := true)`,
+      [json, structure]
+    );
+  };
+  sql.close = async () => {
+    const e = engine;
+    engine = null;
+    if (e) await (await e).close();
+  };
+  sql.connection = async () => (await open()).connection;
+  return sql;
+}
+function loadValue(value, type, depth = 0) {
+  if (value === null || value === void 0) return null;
+  if (type === "date" || type === "datetime") {
+    const d = value instanceof Date ? value : typeof value === "number" || typeof value === "bigint" ? new Date(Number(value)) : null;
+    if (d) return Number.isNaN(d.getTime()) ? null : type === "date" ? d.toISOString().slice(0, 10) : d.toISOString();
+  }
+  if (typeof value === "bigint") return Number.isSafeInteger(Number(value)) ? Number(value) : String(value);
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "object") return value;
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value.toISOString();
+  if (depth > 64) throw new TypeError("jupyter.sql.load: a value is nested more than 64 levels deep");
+  if (ArrayBuffer.isView(value) && !(value instanceof DataView) && value.BYTES_PER_ELEMENT === 1) {
+    let text = "";
+    for (const byte of value) text += String.fromCharCode(byte);
+    return btoa(text);
+  }
+  if (Array.isArray(value) || ArrayBuffer.isView(value)) return Array.from(value, (v) => loadValue(v, void 0, depth + 1));
+  if (typeof value.toJSON === "function" && Object.getPrototypeOf(value) !== Object.prototype) {
+    return loadValue(value.toJSON(), void 0, depth + 1);
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = loadValue(v, void 0, depth + 1);
+  return out;
+}
+function rowsAsJson(source) {
+  const src = tableSource(source);
+  const raw = src.read(0, src.total);
+  const fields = fieldsOf(src, raw);
+  if (fields.length === 0) return { structure: null, json: "[]" };
+  const rows = raw.map((r) => {
+    const obj = {};
+    fields.forEach((f, i) => {
+      obj[f.name] = loadValue(r[i], f.type);
+    });
+    return obj;
+  });
+  const structure = {};
+  for (const f of fields) structure[f.name] = DUCK_TYPES[f.type] ?? "VARCHAR";
+  return { structure: JSON.stringify([structure]), json: JSON.stringify(rows) };
+}
+function inWorker() {
+  return typeof globalThis.WorkerGlobalScope === "function" && globalThis instanceof globalThis.WorkerGlobalScope;
+}
+function hasNativeRuntime() {
+  return typeof globalThis.Deno?.version?.deno === "string" || typeof globalThis.Bun?.version === "string" || typeof globalThis.process?.versions?.node === "string" && !inWorker();
+}
+async function defaultEngine(importModule) {
+  if (hasNativeRuntime()) return nativeEngine(importModule);
+  if (inWorker() && typeof Worker === "function") return wasmEngine(importModule);
+  throw new Error("jupyter.sql needs Node, Deno, Bun or the browser target; workerd and celld have no DuckDB");
+}
+async function nativeEngine(importModule) {
+  const { DuckDBInstance, blobValue } = await importModule(NODE_API);
+  const db = await DuckDBInstance.create(":memory:");
+  const conn = await db.connect();
+  return {
+    connection: conn,
+    interrupt: () => conn.interrupt?.(),
+    async query(text, params) {
+      const bound = params.map((p) => p instanceof Uint8Array && blobValue ? blobValue(p) : p);
+      const result = await conn.runAndReadAll(text, bound);
+      const types = result.columnTypes();
+      const columns = uniqueNames(result.columnNames()).map((name, i) => ({ name, type: String(types[i]) }));
+      const rows = result.getRowsJS().map((row) => {
+        const out = {};
+        columns.forEach((c, j) => out[c.name] = jsValue(row[j], c.type));
+        return out;
+      });
+      return new SqlResult(columns, rows);
+    },
+    async close() {
+      conn.closeSync?.();
+      db.closeSync?.();
+    }
+  };
+}
+async function wasmEngine(importModule) {
+  const duckdb = await importModule(DUCKDB_WASM);
+  const bundle = await duckdb.selectBundle(duckdb.getJsDelivrBundles());
+  const loader = URL.createObjectURL(new Blob([`importScripts(${JSON.stringify(bundle.mainWorker)});`], { type: "text/javascript" }));
+  const worker = new Worker(loader);
+  const db = new duckdb.AsyncDuckDB(new duckdb.VoidLogger(), worker);
+  await db.instantiate(bundle.mainModule, bundle.pthreadWorker);
+  URL.revokeObjectURL(loader);
+  const conn = await db.connect();
+  let cancelled = false;
+  return {
+    connection: conn,
+    interrupt: () => {
+      cancelled = true;
+      void conn.cancelSent?.();
+    },
+    async query(text, params) {
+      cancelled = false;
+      const reader = await conn.send(inlineParams(text, params), true);
+      const stop = () => {
+        if (cancelled) throw new DOMException("The query was interrupted", "AbortError");
+      };
+      try {
+        stop();
+        const columns = [];
+        const rows = [];
+        let decimal = [];
+        for await (const batch of reader) {
+          if (columns.length === 0 && batch.schema.fields.length) {
+            const fields = batch.schema.fields;
+            uniqueNames(fields.map((f) => f.name)).forEach((name, j) => columns.push({ name, type: String(fields[j].type) }));
+            decimal = fields.map((f) => /^decimal/i.test(String(f.type)) ? f.type.scale ?? 0 : null);
+          }
+          stop();
+          const vectors = columns.map((_, j) => batch.getChildAt(j));
+          for (let i = 0; i < batch.numRows; i++) {
+            const row = {};
+            columns.forEach((c, j) => {
+              const v = vectors[j]?.get(i);
+              row[c.name] = decimal[j] !== null && v != null ? decimalValue(v, decimal[j]) : jsValue(v, c.type);
+            });
+            rows.push(row);
+          }
+        }
+        if (columns.length === 0 && reader.schema?.fields) {
+          const fields = reader.schema.fields;
+          uniqueNames(fields.map((f) => f.name)).forEach((name, j) => columns.push({ name, type: String(fields[j].type) }));
+        }
+        return new SqlResult(columns, rows);
+      } catch (err) {
+        await Promise.resolve((reader.cancel ?? reader.return)?.call(reader)).catch(() => {
+        });
+        throw err;
+      }
+    },
+    async close() {
+      await conn.close();
+      await db.terminate();
+      worker.terminate();
+    }
+  };
+}
+
+// runtime/chart.mjs
+var VEGA = "npm:vega@6";
+var VEGA_LITE = "npm:vega-lite@6";
+var LINKEDOM = "npm:linkedom@0.18";
+var WARN_BYTES = 2e6;
+var $display2 = /* @__PURE__ */ Symbol.for("Jupyter.display");
+var OTHER_LEGENDS = ["opacity", "r", "symbol"];
+var FONT = "system-ui, sans-serif";
+var rawToEntity2 = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+var esc = (s) => String(s).replace(/[&<>"']/g, (c) => rawToEntity2[c]);
+function isObject2(value) {
+  return value !== null && typeof value === "object";
+}
+function isPlotModule(value) {
+  return (isObject2(value) || typeof value === "function") && typeof value.plot === "function" && typeof value.barY === "function";
+}
+var SPEC_KEYS = ["$schema", "mark", "marks", "layer", "spec", "concat", "hconcat", "vconcat", "facet", "repeat"];
+function specOf(value) {
+  const spec = isObject2(value) && typeof value.toSpec === "function" ? value.toSpec() : value;
+  if (!isObject2(spec) || Array.isArray(spec) || !SPEC_KEYS.some((key2) => key2 in spec)) {
+    throw new TypeError(
+      "jupyter.chart takes a Vega-Lite or Vega spec, the Plot module and Plot options, or an SVG element"
+    );
+  }
+  return spec;
+}
+function isSvgElement(value) {
+  return isObject2(value) && typeof value.outerHTML === "string" && /^<svg\b/i.test(value.outerHTML);
+}
+function isVegaSpec(spec) {
+  return typeof spec.$schema === "string" && /\/schema\/vega\/v\d/.test(spec.$schema);
+}
+function svgSize(svg) {
+  const open = /<svg\b[^>]*>/i.exec(svg)?.[0] ?? "";
+  const attr = (name) => {
+    const m = new RegExp(`\\s${name}="([^"]*)"`, "i").exec(open);
+    return m ? m[1] : void 0;
+  };
+  let width = parseFloat(attr("width") ?? "");
+  let height = parseFloat(attr("height") ?? "");
+  const box = attr("viewBox")?.trim().split(/[\s,]+/).map(Number);
+  if (!Number.isFinite(width) && box?.length === 4) width = box[2];
+  if (!Number.isFinite(height) && box?.length === 4) height = box[3];
+  return { width: Number.isFinite(width) ? width : 640, height: Number.isFinite(height) ? height : 400 };
+}
+function withNamespace(svg) {
+  return /<svg\b[^>]*\sxmlns=/i.test(svg) ? svg : svg.replace(/<svg\b/i, '<svg xmlns="http://www.w3.org/2000/svg"');
+}
+function hash(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 16777619);
+  return (h >>> 0).toString(36);
+}
+var textWidth = (text, size) => String(text).length * size * 0.6;
+function legendSVG(scale, width, form) {
+  if (!isObject2(scale) || typeof scale.apply !== "function" || !Array.isArray(scale.domain)) return { svg: "", height: 0 };
+  const label = typeof scale.label === "string" && scale.label ? scale.label : "";
+  const parts = [];
+  let y = 0;
+  if (label) {
+    parts.push(`<text x="0" y="10" font-weight="bold">${esc(label)}</text>`);
+    y = 16;
+  }
+  const continuous = form === "ramp" || form !== "swatches" && /^(linear|log|pow|sqrt|symlog|utc|time|sequential|diverging|quantize|threshold|quantile)/.test(String(scale.type));
+  if (!continuous) {
+    let x = 0;
+    let row = y;
+    for (const value of scale.domain) {
+      const text = String(value);
+      const w = 14 + textWidth(text, 10) + 12;
+      if (x > 0 && x + w > width) {
+        x = 0;
+        row += 16;
+      }
+      parts.push(
+        `<rect x="${x}" y="${row}" width="10" height="10" fill="${esc(scale.apply(value))}"/><text x="${x + 14}" y="${row + 9}">${esc(text)}</text>`
+      );
+      x += w;
+    }
+    return { svg: parts.join(""), height: row + 14 };
+  }
+  const [lo, hi] = [scale.domain[0], scale.domain.at(-1)];
+  const n = 16;
+  const stops = [];
+  const range = Array.isArray(scale.range) && scale.range.length >= 2 && scale.range.every((r) => typeof r === "number") ? [scale.range[0], scale.range.at(-1)] : void 0;
+  const numeric = (v) => v instanceof Date ? v.getTime() : typeof v === "number" ? v : NaN;
+  const [a, b] = [numeric(lo), numeric(hi)];
+  for (let i = 0; i <= n; i++) {
+    const t = i / n;
+    let color;
+    if (typeof scale.interpolate === "function" && range) color = scale.interpolate(range[0] + (range[1] - range[0]) * t);
+    else if (Number.isFinite(a) && Number.isFinite(b)) {
+      const v = a + (b - a) * t;
+      color = scale.apply(lo instanceof Date ? new Date(v) : v);
+    } else color = scale.apply(i === 0 ? lo : hi);
+    stops.push(`<stop offset="${t * 100}%" stop-color="${esc(color)}"/>`);
+  }
+  const id = `ramp-${hash(stops.join(""))}`;
+  const rampWidth = Math.min(240, width);
+  const fmt = (v) => v instanceof Date ? v.toISOString().slice(0, 10) : typeof v === "number" ? String(Number(v.toPrecision(4))) : String(v);
+  parts.push(
+    `<defs><linearGradient id="${id}">${stops.join("")}</linearGradient></defs><rect x="0" y="${y}" width="${rampWidth}" height="10" fill="url(#${id})"/><text x="0" y="${y + 22}">${esc(fmt(lo))}</text><text x="${rampWidth}" y="${y + 22}" text-anchor="end">${esc(fmt(hi))}</text>`
+  );
+  return { svg: parts.join(""), height: y + 26 };
+}
+function composeSVG(inner, { title, subtitle, caption, legend }) {
+  const { width, height } = svgSize(inner);
+  const head = [];
+  let y = 0;
+  if (title) {
+    head.push(`<text x="0" y="${y + 16}" font-size="16" font-weight="bold">${esc(title)}</text>`);
+    y += 24;
+  }
+  if (subtitle) {
+    head.push(`<text x="0" y="${y + 13}" font-size="13">${esc(subtitle)}</text>`);
+    y += 20;
+  }
+  if (legend?.svg) {
+    head.push(`<g transform="translate(0,${y})" font-size="10">${legend.svg}</g>`);
+    y += legend.height + 8;
+  }
+  const body = withNamespace(inner).replace(/<svg\b/i, `<svg x="0" y="${y}"`);
+  let total = y + height;
+  let foot = "";
+  if (caption) {
+    foot = `<text x="0" y="${total + 16}" font-size="12">${esc(caption)}</text>`;
+    total += 24;
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${total}" viewBox="0 0 ${width} ${total}" font-family="${FONT}" fill="currentColor">${head.join("")}${body}${foot}</svg>`;
+}
+function markName(mark) {
+  if (typeof mark?.ariaLabel === "string" && mark.ariaLabel) return mark.ariaLabel;
+  return mark?.constructor?.name?.toLowerCase() ?? "mark";
+}
+function describeScale(name, scale) {
+  if (!isObject2(scale)) return null;
+  const label = typeof scale.label === "string" && scale.label ? scale.label : "";
+  const domain = Array.isArray(scale.domain) ? scale.domain : [];
+  let range = "";
+  if (domain.length && domain.every((v) => typeof v === "number" || v instanceof Date) && !/ordinal|band|point/.test(scale.type)) {
+    const fmt = (v) => v instanceof Date ? v.toISOString().slice(0, 10) : String(Number(v.toPrecision(4)));
+    range = `${fmt(domain[0])} to ${fmt(domain.at(-1))}`;
+  } else if (domain.length) {
+    range = `${domain.length} ${domain.length === 1 ? "value" : "values"}`;
+  }
+  const details = [scale.type, range].filter(Boolean).join(", ");
+  return `${name}${label ? `=${label}` : ""}${details ? ` (${details})` : ""}`;
+}
+function summarizePlot(element, options) {
+  const marks = (Array.isArray(options.marks) ? options.marks.flat(Infinity) : []).filter(isObject2);
+  const names = [...new Set(marks.map(markName))];
+  const scales = ["x", "y", "fx", "fy", "color", "r", "opacity", "symbol"].map((name) => typeof element?.scale === "function" ? describeScale(name, element.scale(name)) : null).filter(Boolean);
+  const rows = marks.map((m) => Array.isArray(m.data) ? m.data.length : typeof m.data?.length === "number" ? m.data.length : 0);
+  const most = rows.length ? Math.max(...rows) : 0;
+  const title = typeof options.title === "string" && options.title ? ` "${options.title}"` : "";
+  const parts = [...scales];
+  if (most) parts.push(`${most} ${most === 1 ? "row" : "rows"}`);
+  return `Plot ${names.length ? `${names.join(", ")} ` : ""}chart${title}${parts.length ? `: ${parts.join(", ")}` : ""}`;
+}
+var INK = "currentColor";
+var VEGA_CONFIG = {
+  background: "transparent",
+  axis: { labelColor: INK, titleColor: INK, domainColor: INK, tickColor: INK, gridColor: INK, gridOpacity: 0.15 },
+  legend: { labelColor: INK, titleColor: INK },
+  title: { color: INK, subtitleColor: INK },
+  header: { labelColor: INK, titleColor: INK },
+  view: { stroke: null }
+};
+function mergeConfig(base, own) {
+  if (!isObject2(own)) return base;
+  const out = { ...base };
+  for (const [key2, value] of Object.entries(own)) {
+    out[key2] = isObject2(value) && isObject2(base[key2]) && !Array.isArray(value) ? mergeConfig(base[key2], value) : value;
+  }
+  return out;
+}
+function createChart({ importModule, summarizeSpec, warn = (m) => console.warn(m) }) {
+  let dom;
+  async function document() {
+    if (globalThis.document && typeof globalThis.document.createElementNS === "function") return globalThis.document;
+    dom ??= importModule(LINKEDOM).then(({ parseHTML }) => parseHTML("<!doctype html><html><body></body></html>").document).catch((err) => {
+      dom = void 0;
+      throw err;
+    });
+    return dom;
+  }
+  async function renderVega(spec, options) {
+    const keepSpec = isObject2(options) && options.spec === true;
+    const [vega, vl] = await Promise.all([importModule(VEGA), isVegaSpec(spec) ? null : importModule(VEGA_LITE)]);
+    const config = mergeConfig(VEGA_CONFIG, spec.config);
+    const vgSpec = vl ? vl.compile({ ...spec, config }).spec : { ...spec, config };
+    const view = new vega.View(vega.parse(vgSpec), { renderer: "none" });
+    let svg;
+    try {
+      svg = await view.toSVG();
+    } finally {
+      view.finalize();
+    }
+    const bundle = { "image/svg+xml": withNamespace(svg) };
+    const summary = summarizeSpec?.({ $schema: "https://vega.github.io/schema/vega-lite/v5.json", ...spec });
+    if (summary) bundle["text/plain"] = summary;
+    if (keepSpec) {
+      const v4 = /\/schema\/vega-lite\/v4/.test(String(spec.$schema));
+      bundle[vl ? v4 ? "application/vnd.vegalite.v4+json" : "application/vnd.vegalite.v5+json" : "application/vnd.vega.v5+json"] = spec;
+    }
+    return bundle;
+  }
+  async function renderPlot(Plot, options) {
+    if (!isObject2(options)) throw new TypeError("jupyter.chart(Plot, options): options must be Plot's options object");
+    const { title, subtitle, caption, ...rest } = options;
+    const color = isObject2(rest.color) ? rest.color : void 0;
+    const wantLegend = Boolean(color?.legend);
+    const plotOptions = { ...rest, document: await document(), figure: false };
+    if (color) plotOptions.color = { ...color, legend: false };
+    const others = OTHER_LEGENDS.filter((name) => isObject2(rest[name]) && rest[name].legend);
+    if (others.length) {
+      warn(`jupyter.chart draws only a color legend; the ${others.join(", ")} legend is left out`);
+    }
+    const element = Plot.plot(plotOptions);
+    const inner = element.outerHTML;
+    const { width } = svgSize(inner);
+    const scale = wantLegend && typeof element.scale === "function" ? element.scale("color") : void 0;
+    const form = color?.legend === "ramp" || color?.legend === "swatches" ? color.legend : void 0;
+    const legend = scale ? legendSVG({ ...scale, label: scale.label ?? color.label }, width, form) : void 0;
+    const svg = composeSVG(inner, { title, subtitle, caption, legend });
+    return { "image/svg+xml": withNamespace(svg), "text/plain": summarizePlot(element, options) };
+  }
+  function chart(first, second) {
+    const spec = isPlotModule(first) || isSvgElement(first) ? void 0 : specOf(first);
+    if (isPlotModule(first) && !isObject2(second)) {
+      throw new TypeError("jupyter.chart(Plot, options): options must be Plot's options object");
+    }
+    if (isSvgElement(first)) {
+      const bundle = { "image/svg+xml": withNamespace(first.outerHTML) };
+      return { [$display2]: () => bundle };
+    }
+    let pending;
+    const render = () => pending ??= (async () => {
+      const bundle = spec ? await renderVega(spec, second) : await renderPlot(first, second);
+      const size = bundle["image/svg+xml"].length;
+      if (size > WARN_BYTES) {
+        warn(
+          `jupyter.chart: the SVG is ${(size / 1e6).toFixed(1)} MB, which makes the notebook large; aggregate or sample the data first`
+        );
+      }
+      return bundle;
+    })().catch((err) => {
+      pending = void 0;
+      throw err;
+    });
+    return { [$display2]: render };
+  }
+  return chart;
+}
+
+// runtime/table-paging.mjs
+var PAGE_TARGET = "ganymede.table.v1";
+var KEEP = 16;
+var MAX_PAGE = 1e3;
+var MAX_SORT = 1e6;
+var CHUNK = 1e4;
+var SORTS = 2;
+var NUMERIC = /* @__PURE__ */ new Set(["integer", "number"]);
+var INTEGER_TEXT = /^-?\d+$/;
+function sortNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.trim() !== "") return Number(value);
+  return Number.NaN;
+}
+function textOf(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+var collator = new Intl.Collator(void 0, { numeric: true });
+function compareEncoded(a, b, type, descending = false) {
+  const numeric = NUMERIC.has(type) || typeof a === "number" && typeof b === "number";
+  const last = (v) => v === null || v === void 0 || numeric && Number.isNaN(sortNumber(v));
+  const aLast = last(a);
+  const bLast = last(b);
+  if (aLast || bLast) return aLast === bLast ? 0 : aLast ? 1 : -1;
+  const sign = descending ? -1 : 1;
+  if (numeric) {
+    if (typeof a === "string" && typeof b === "string" && INTEGER_TEXT.test(a) && INTEGER_TEXT.test(b)) {
+      const x = BigInt(a);
+      const y = BigInt(b);
+      return sign * (x < y ? -1 : x > y ? 1 : 0);
+    }
+    return sign * (sortNumber(a) - sortNumber(b));
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") return sign * (Number(a) - Number(b));
+  return sign * collator.compare(textOf(a), textOf(b));
+}
+function createTablePager(commApi, { keep = KEEP, newId = () => crypto.randomUUID() } = {}) {
+  const tables = /* @__PURE__ */ new Map();
+  const keyed = /* @__PURE__ */ new Map();
+  function register(source, fields, key2) {
+    let id = key2 === void 0 ? void 0 : keyed.get(key2);
+    if (id === void 0 || !tables.has(id)) id = newId();
+    if (key2 !== void 0) keyed.set(key2, id);
+    tables.delete(id);
+    tables.set(id, { source, fields, key: key2, orders: /* @__PURE__ */ new Map() });
+    while (tables.size > keep) {
+      const [oldest, entry] = tables.entries().next().value;
+      tables.delete(oldest);
+      if (entry.key !== void 0 && keyed.get(entry.key) === oldest) keyed.delete(entry.key);
+    }
+    return id;
+  }
+  function encodeRows(entry, raw) {
+    return raw.map((r) => encodeRow(entry.source, entry.fields, r));
+  }
+  function orderFor(entry, column, descending) {
+    const key2 = `${column}\0${descending}`;
+    const kept = entry.orders.get(key2);
+    if (kept) return kept;
+    const { source, fields } = entry;
+    const c = fields.findIndex((f) => f.name === column);
+    if (c < 0) throw new Error(`no column ${JSON.stringify(column)}`);
+    if (source.total > MAX_SORT) throw new Error(`sorting is offered up to ${MAX_SORT.toLocaleString("en-US")} rows`);
+    const type = fields[c].type;
+    const declared = source.columns[c].declared;
+    const values = new Array(source.total);
+    for (let start = 0; start < source.total; start += CHUNK) {
+      const raw = source.read(start, Math.min(start + CHUNK, source.total));
+      raw.forEach((r, i) => values[start + i] = encodeValue(r[c], type, declared));
+    }
+    const index = Array.from({ length: source.total }, (_, i) => i);
+    index.sort((i, j) => compareEncoded(values[i], values[j], type, descending));
+    entry.orders.set(key2, index);
+    while (entry.orders.size > SORTS) entry.orders.delete(entry.orders.keys().next().value);
+    return index;
+  }
+  function page(entry, { offset, limit, sort }) {
+    const { source } = entry;
+    const start = Math.max(0, Math.min(offset, source.total));
+    const end = Math.min(source.total, start + Math.min(limit, MAX_PAGE));
+    if (!sort) return encodeRows(entry, source.read(start, end));
+    const index = orderFor(entry, String(sort.column), sort.descending === true).slice(start, end);
+    const rows = [];
+    for (let i = 0; i < index.length; ) {
+      let j = i + 1;
+      while (j < index.length && index[j] === index[j - 1] + 1) j++;
+      rows.push(...source.read(index[i], index[j - 1] + 1));
+      i = j;
+    }
+    return encodeRows(entry, rows);
+  }
+  const gone = "The kernel no longer has this table: run the cell again to page through it.";
+  commApi.registerTarget(PAGE_TARGET, (comm, msg) => {
+    const id = msg.data?.id;
+    if (typeof id !== "string" || !tables.has(id)) {
+      comm.send({ error: gone });
+      comm.close();
+      return;
+    }
+    comm.onMsg(({ data }) => {
+      const request = data?.request;
+      const entry = tables.get(id);
+      if (!entry) {
+        comm.send({ request, error: gone });
+        comm.close();
+        return;
+      }
+      const offset = data?.offset;
+      const limit = data?.limit ?? MAX_PAGE;
+      if (!Number.isInteger(offset) || offset < 0 || !Number.isInteger(limit) || limit < 1) {
+        comm.send({ request, error: "offset and limit must be whole numbers" });
+        return;
+      }
+      try {
+        const rows = page(entry, { offset, limit, sort: data?.sort ?? void 0 });
+        comm.send({ request, offset, total: entry.source.total, rows });
+      } catch (err) {
+        comm.send({ request, error: err instanceof Error ? err.message : String(err) });
+      }
+    });
+  });
+  return { register, size: () => tables.size };
+}
+
+// runtime/display.mjs
+var $display3 = /* @__PURE__ */ Symbol.for("Jupyter.display");
+var rawToEntity3 = /* @__PURE__ */ new Map([
   ["&", "&amp;"],
   ["<", "&lt;"],
   [">", "&gt;"],
   ['"', "&quot;"],
   ["'", "&#39;"]
 ]);
-var rawRe = new RegExp(`[${[...rawToEntity.keys()].join("")}]`, "g");
-function escapeHTML(str) {
-  return str.replaceAll(rawRe, (m) => rawToEntity.get(m) ?? m);
-}
+var rawRe = new RegExp(`[${[...rawToEntity3.keys()].join("")}]`, "g");
 function isVegaLike(obj) {
   return obj !== null && typeof obj === "object" && "toSpec" in obj;
 }
@@ -617,59 +1695,6 @@ function summarizeChart(spec) {
     return void 0;
   }
 }
-function isDataFrameLike(obj) {
-  return obj !== null && typeof obj === "object" && obj.schema !== void 0 && typeof obj.schema === "object" && typeof obj.head === "function" && typeof obj.toRecords === "function";
-}
-function mapPolarsTypeToJSONSchema(colType) {
-  const typeMapping = {
-    Null: "null",
-    Bool: "boolean",
-    Int8: "integer",
-    Int16: "integer",
-    Int32: "integer",
-    Int64: "integer",
-    UInt8: "integer",
-    UInt16: "integer",
-    UInt32: "integer",
-    UInt64: "integer",
-    Float32: "number",
-    Float64: "number",
-    Date: "string",
-    Datetime: "string",
-    Utf8: "string",
-    Categorical: "string",
-    List: "array",
-    Struct: "object"
-  };
-  const dataType = typeof colType?.toJSON === "function" ? colType.toJSON()["DataType"] : void 0;
-  return typeMapping[dataType] || "string";
-}
-function extractDataFrame(df) {
-  const fields = [];
-  for (const [name, colType] of Object.entries(df.schema)) {
-    fields.push({ name, type: mapPolarsTypeToJSONSchema(colType) });
-  }
-  const data = df.head(50).toRecords();
-  let html = "<table><thead><tr>";
-  for (const field of fields) html += `<th>${escapeHTML(String(field.name))}</th>`;
-  html += "</tr></thead><tbody>";
-  for (const row of df.head(10).toRecords()) {
-    html += "<tr>";
-    for (const field of fields) html += `<td>${escapeHTML(String(row[field.name]))}</td>`;
-    html += "</tr>";
-  }
-  html += "</tbody></table>";
-  const size = [];
-  if (Number.isInteger(df.height)) size.push(`${df.height} ${df.height === 1 ? "row" : "rows"}`);
-  size.push(`${fields.length} ${fields.length === 1 ? "column" : "columns"}`);
-  const columns = fields.slice(0, 20).map((field) => `${clip(String(field.name), 40)} (${field.type})`);
-  if (fields.length > 20) columns.push(`\u2026 ${fields.length - 20} more`);
-  return {
-    "application/vnd.dataresource+json": { data, schema: { fields } },
-    "text/html": html,
-    "text/plain": `DataFrame (${size.join(", ")})${columns.length ? `: ${columns.join(", ")}` : ""}`
-  };
-}
 function isCanvasLike(obj) {
   return obj !== null && typeof obj === "object" && "toDataURL" in obj;
 }
@@ -687,7 +1712,7 @@ function isHTMLElementLike(obj) {
   return obj !== null && typeof obj === "object" && typeof obj.outerHTML === "string";
 }
 function hasDisplaySymbol(obj) {
-  return obj !== null && typeof obj === "object" && typeof obj[$display] === "function";
+  return obj !== null && typeof obj === "object" && typeof obj[$display3] === "function";
 }
 function isMediaBundle(obj) {
   return obj !== null && typeof obj === "object" && !Array.isArray(obj);
@@ -705,7 +1730,7 @@ function createJupyter(host2) {
     return await formatNow(obj);
   }
   function formatNow(obj) {
-    if (hasDisplaySymbol(obj)) return obj[$display]();
+    if (hasDisplaySymbol(obj)) return obj[$display3]();
     if (typeof obj !== "object" || obj === null) return { "text/plain": host2.inspect(obj) };
     if (isCanvasLike(obj)) {
       const [prefix, data] = obj.toDataURL().split(",");
@@ -715,7 +1740,7 @@ function createJupyter(host2) {
       const vega = extractVega(obj);
       if (vega) return vega;
     }
-    if (isDataFrameLike(obj)) return extractDataFrame(obj);
+    if (isTableLike(obj)) return tableBundle(tableSource(obj));
     if (isJpg(obj)) return { "image/jpeg": host2.base64(obj) };
     if (isPng(obj)) return { "image/png": host2.base64(obj) };
     if (isSVGElementLike(obj)) return { "image/svg+xml": obj.outerHTML };
@@ -725,7 +1750,7 @@ function createJupyter(host2) {
   function taggedTemplate(mediatype) {
     return (strings, ...values) => {
       const payload = strings.reduce((acc, string, i) => acc + string + (values[i] !== void 0 ? values[i] : ""), "");
-      return { [$display]: () => ({ [mediatype]: payload }) };
+      return { [$display3]: () => ({ [mediatype]: payload }) };
     };
   }
   function image(obj) {
@@ -735,19 +1760,24 @@ function createJupyter(host2) {
       } catch {
       }
     }
-    if (isJpg(obj)) return { [$display]: () => ({ "image/jpeg": host2.base64(obj) }) };
-    if (isPng(obj)) return { [$display]: () => ({ "image/png": host2.base64(obj) }) };
+    if (isJpg(obj)) return { [$display3]: () => ({ "image/jpeg": host2.base64(obj) }) };
+    if (isPng(obj)) return { [$display3]: () => ({ "image/png": host2.base64(obj) }) };
     throw new TypeError(
       "Object is not a valid image or a path to an image. `jupyter.image` supports displaying JPG or PNG images."
     );
   }
+  function table(value, options = {}) {
+    const bundle = tableBundle(tableSource(value, options), options);
+    return { [$display3]: () => bundle };
+  }
   function broadcast(msgType, content, { metadata = {}, buffers = [] } = {}) {
     host2.send(msgType, content, metadata, buffers);
   }
+  let pager;
   async function display(obj, options = { raw: false, update: false }) {
     const bundle = options.raw && isMediaBundle(obj) ? obj : await format2(obj);
     broadcast(options.update ? "update_display_data" : "display_data", {
-      data: bundle,
+      data: pageTable(bundle, pager, options.display_id),
       metadata: {},
       transient: options.display_id ? { display_id: options.display_id } : {}
     });
@@ -757,7 +1787,7 @@ function createJupyter(host2) {
     try {
       broadcast("execute_result", {
         execution_count: executionCount,
-        data: await format2(result2),
+        data: pageTable(await format2(result2), pager),
         metadata: {},
         // nbclient crashes on a null `transient`; Deno learned this too.
         transient: {}
@@ -811,7 +1841,15 @@ function createJupyter(host2) {
       transient: {}
     });
   }
+  const cellImport = (what) => (specifier) => {
+    const load = globalThis.__cdpk?.import;
+    if (typeof load !== "function") return Promise.reject(new Error(`${what}: no module loader in this runtime`));
+    return load(specifier);
+  };
+  const sql = createSql({ importModule: cellImport("jupyter.sql"), signal: () => current.signal });
+  const chart = createChart({ importModule: cellImport("jupyter.chart"), summarizeSpec: summarizeChart });
   const comms = createComms((msgType, content, metadata, buffers) => host2.send(msgType, content, metadata, buffers));
+  pager = createTablePager(comms.api);
   let cell = new AbortController();
   let current = cell;
   const handlers = /* @__PURE__ */ new Map();
@@ -848,15 +1886,18 @@ function createJupyter(host2) {
         return readParams();
       },
       result,
+      table,
+      sql,
+      chart,
       format: format2,
       md: taggedTemplate("text/markdown"),
       html: taggedTemplate("text/html"),
       svg: taggedTemplate("image/svg+xml"),
       image,
-      $display,
+      $display: $display3,
       comm: comms.api,
       host: hostApi.host,
-      widget: createWidgetFactory(comms.api, $display)
+      widget: createWidgetFactory(comms.api, $display3)
     },
     broadcastResult,
     formatNow,
@@ -1155,7 +2196,8 @@ ${resolved.name} has a getter, which isn't called for inspection: it could have
 
 // runtime/cdn.mjs
 var DEFAULT_CDN = "https://esm.sh/";
-function resolveSpecifier(specifier, base, cdn2 = DEFAULT_CDN) {
+function resolveSpecifier(specifier, base, cdn2 = DEFAULT_CDN, modules2 = void 0) {
+  if (modules2 && Object.hasOwn(modules2, specifier)) return new URL(modules2[specifier], base).href;
   if (/^(?:https?|data|blob):/.test(specifier)) return specifier;
   if (/^\.{0,2}\//.test(specifier)) return new URL(specifier, base).href;
   if (specifier.startsWith("npm:")) return cdn2 + specifier.slice(4);
@@ -1210,6 +2252,7 @@ var jupyter = createJupyter({
 });
 var paramsText;
 var cdn = DEFAULT_CDN;
+var modules;
 var hostCalls = /* @__PURE__ */ new Map();
 var hostListeners = /* @__PURE__ */ new Set();
 var nextHostId = 0;
@@ -1276,13 +2319,14 @@ async function preload(urls, base) {
   }
 }
 var handle = null;
-function install({ base, cdn: cdnBase, params }) {
+function install({ base, cdn: cdnBase, modules: moduleMap, params }) {
   if (typeof params === "string") paramsText = params;
   if (typeof cdnBase === "string") cdn = cdnBase.endsWith("/") ? cdnBase : cdnBase + "/";
+  if (moduleMap !== null && typeof moduleMap === "object") modules = { ...moduleMap };
   const url = new URL("$cdpk$repl.mjs", base).href;
   globalThis.__cdpk = {
-    import: (specifier, options) => import(resolveSpecifier(specifier, url, cdn)),
-    meta: { url, resolve: (specifier) => resolveSpecifier(specifier, url, cdn) },
+    import: (specifier, options) => import(resolveSpecifier(specifier, url, cdn, modules)),
+    meta: { url, resolve: (specifier) => resolveSpecifier(specifier, url, cdn, modules) },
     // 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 }),