datasette-ts 0.0.15 → 0.0.17

package/dist/cli.js

@@ -6372,7 +6372,7 @@ function openNodeSqlite(options) {
         sql: sql2,
         args: params ?? []
       });
-      const rows = normalizeLibsqlRows2(result);
+      const rows = normalizeLibsqlRows(result);
       const columns = normalizeLibsqlColumns(result, rows);
       return { rows, columns };
     },
@@ -6409,7 +6409,7 @@ function normalizeLibsqlColumns(result, rows) {
   }
   return rows[0] ? Object.keys(rows[0]) : [];
 }
-function normalizeLibsqlRows2(result) {
+function normalizeLibsqlRows(result) {
   const rows = Array.isArray(result.rows) ? result.rows : [];
   if (!rows.length) {
     return [];
@@ -6471,7 +6471,7 @@ var init_sqlite = __esm({
 });
 
 // src/db/introspection.ts
-function asString2(value, fallback = "") {
+function asString(value, fallback = "") {
   if (typeof value === "string") {
     return value;
   }
@@ -6480,7 +6480,7 @@ function asString2(value, fallback = "") {
   }
   return String(value);
 }
-function asNumber2(value, fallback = 0) {
+function asNumber(value, fallback = 0) {
   if (typeof value === "number") {
     return value;
   }
@@ -6490,7 +6490,7 @@ function asNumber2(value, fallback = 0) {
   }
   return fallback;
 }
-function asNullableString2(value) {
+function asNullableString(value) {
   if (value == null) {
     return null;
   }
@@ -6516,7 +6516,7 @@ async function listTables(client) {
     "select name, type, sql from sqlite_master where type in ('table', 'view') order by name"
   );
   return rows.filter((row) => {
-    const name = asString2(row.name);
+    const name = asString(row.name);
     return !name.startsWith(SQLITE_INTERNAL_PREFIX);
   });
 }
@@ -6525,12 +6525,12 @@ async function tableColumns2(client, tableName) {
     `pragma table_info(${escapeIdentifier2(tableName)})`
   );
   return rows.map((row) => ({
-    name: asString2(row.name),
-    type: asString2(row.type),
-    notNull: asNumber2(row.notnull) === 1,
-    defaultValue: asNullableString2(row.dflt_value),
-    primaryKey: asNumber2(row.pk) > 0,
-    primaryKeyIndex: asNumber2(row.pk)
+    name: asString(row.name),
+    type: asString(row.type),
+    notNull: asNumber(row.notnull) === 1,
+    defaultValue: asNullableString(row.dflt_value),
+    primaryKey: asNumber(row.pk) > 0,
+    primaryKeyIndex: asNumber(row.pk)
   }));
 }
 async function tableForeignKeys2(client, tableName) {
@@ -6538,23 +6538,23 @@ async function tableForeignKeys2(client, tableName) {
     `pragma foreign_key_list(${escapeIdentifier2(tableName)})`
   );
   return rows.map((row) => ({
-    table: asString2(row.table),
-    from: asString2(row.from),
-    to: asString2(row.to),
-    onUpdate: asString2(row.on_update),
-    onDelete: asString2(row.on_delete),
-    match: asString2(row.match),
-    seq: asNumber2(row.seq),
-    id: asNumber2(row.id)
+    table: asString(row.table),
+    from: asString(row.from),
+    to: asString(row.to),
+    onUpdate: asString(row.on_update),
+    onDelete: asString(row.on_delete),
+    match: asString(row.match),
+    seq: asNumber(row.seq),
+    id: asNumber(row.id)
   }));
 }
 async function introspectDatabase2(client) {
   const rows = await listTables(client);
   const tables = {};
   for (const row of rows) {
-    const name = asString2(row.name);
-    const type = asString2(row.type);
-    const sql2 = asNullableString2(row.sql);
+    const name = asString(row.name);
+    const type = asString(row.type);
+    const sql2 = asNullableString(row.sql);
     const virtual = type === "table" && isVirtualTable2(sql2);
     const infoType = type === "view" ? "view" : virtual ? "virtual" : "table";
     const columns = await tableColumns2(client, name);
@@ -23689,38 +23689,117 @@ var init_node4 = __esm({
 import { parseArgs as parseArgs2 } from "node:util";
 
 // src/cli/deploy-cloudflare.ts
-import { mkdir as mkdir2, stat as stat2, writeFile } from "node:fs/promises";
+import { mkdir as mkdir2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname, extname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import alchemy from "alchemy";
 import { Assets, D1Database, Worker } from "alchemy/cloudflare";
 
 // scripts/cloudflare-deploy-helpers.mjs
-import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { createReadStream, createWriteStream } from "node:fs";
-import { mkdir, stat, unlink } from "node:fs/promises";
-import { once } from "node:events";
+import { createReadStream } from "node:fs";
+import { mkdir, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { createInterface } from "node:readline";
-import { pipeline } from "node:stream/promises";
 import { pathToFileURL } from "node:url";
 import { createClient } from "@libsql/client";
 async function dumpSqliteForD1(options) {
   const baseName = options.outputName ?? path.basename(options.dbFile, path.extname(options.dbFile));
   const outputPath = path.join(options.outputDir, `${baseName}.sql`);
-  const rawPath = path.join(options.outputDir, `${baseName}.raw.sql`);
-  const log = typeof options.log === "function" ? options.log : null;
-  const progressIntervalMs = typeof options.progressIntervalMs === "number" && Number.isFinite(options.progressIntervalMs) ? options.progressIntervalMs : 5e3;
+  const log = options.log ?? null;
   await mkdir(options.outputDir, { recursive: true });
-  await dumpSqliteToFile(options.dbFile, rawPath, { log, progressIntervalMs });
+  log?.("Generating D1 import SQL");
+  const db = createReadonlyClient(options.dbFile);
   try {
-    await normalizeDumpFile(rawPath, outputPath, { log });
+    const sql2 = await generateD1Dump(db, log);
+    await writeFile(outputPath, sql2, "utf8");
+    const { size } = await stat(outputPath);
+    log?.(`D1 import SQL ready (${formatBytes(size)})`);
   } finally {
-    await unlink(rawPath).catch(() => void 0);
+    db.close();
   }
   return outputPath;
 }
+async function generateD1Dump(db, log) {
+  const chunks = [];
+  const objects = await executeRows(
+    db,
+    `SELECT type, name, sql, tbl_name
+     FROM sqlite_master
+     WHERE sql IS NOT NULL
+       AND name NOT LIKE 'sqlite_%'
+     ORDER BY
+       CASE type
+         WHEN 'table' THEN 1
+         WHEN 'index' THEN 2
+         WHEN 'trigger' THEN 3
+         WHEN 'view' THEN 4
+         ELSE 5
+       END,
+       name`
+  );
+  const tables = objects.filter((o) => o.type === "table" && !isVirtualTable(o.sql));
+  const views = objects.filter((o) => o.type === "view");
+  const indexes = objects.filter((o) => o.type === "index");
+  const triggers = objects.filter((o) => o.type === "trigger");
+  for (const view of [...views].reverse()) {
+    chunks.push(`DROP VIEW IF EXISTS ${escapeIdentifier(view.name)};`);
+  }
+  for (const table of [...tables].reverse()) {
+    chunks.push(`DROP TABLE IF EXISTS ${escapeIdentifier(table.name)};`);
+  }
+  for (const table of tables) {
+    chunks.push(`${normalizeSql(table.sql)};`);
+  }
+  let totalRows = 0;
+  for (const table of tables) {
+    const rowCount = await dumpTableData(db, table.name, chunks);
+    totalRows += rowCount;
+  }
+  log?.(`Exported ${totalRows.toLocaleString()} rows from ${tables.length} tables`);
+  for (const index of indexes) {
+    if (!index.sql) continue;
+    chunks.push(`${normalizeSql(index.sql)};`);
+  }
+  for (const view of views) {
+    chunks.push(`${normalizeSql(view.sql)};`);
+  }
+  for (const trigger of triggers) {
+    chunks.push(`${normalizeSql(trigger.sql)};`);
+  }
+  return chunks.join("\n") + "\n";
+}
+async function dumpTableData(db, tableName, chunks) {
+  const rows = await executeRows(db, `SELECT * FROM ${escapeIdentifier(tableName)}`);
+  if (rows.length === 0) return 0;
+  const columns = Object.keys(rows[0]);
+  const columnList = columns.map(escapeIdentifier).join(", ");
+  for (const row of rows) {
+    const values = columns.map((col) => escapeSqlValue(row[col])).join(", ");
+    chunks.push(`INSERT INTO ${escapeIdentifier(tableName)} (${columnList}) VALUES (${values});`);
+  }
+  return rows.length;
+}
+function escapeSqlValue(value) {
+  if (value === null || value === void 0) {
+    return "NULL";
+  }
+  if (typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : "NULL";
+  }
+  if (typeof value === "boolean") {
+    return value ? "1" : "0";
+  }
+  if (value instanceof Uint8Array || Buffer.isBuffer(value)) {
+    return `X'${Buffer.from(value).toString("hex")}'`;
+  }
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function normalizeSql(sql2) {
+  return sql2.replace(/\s+/g, " ").trim();
+}
 async function loadSchemaFromFile(dbFile) {
   const db = createReadonlyClient(dbFile);
   try {
@@ -23730,9 +23809,11 @@ async function loadSchemaFromFile(dbFile) {
   }
 }
 async function loadInspectDataFromFile(dbFile, databaseName) {
-  const stats = await stat(dbFile);
-  const hash = await hashFile(dbFile);
-  const tables = await countTables(dbFile);
+  const [stats, hash, tables] = await Promise.all([
+    stat(dbFile),
+    hashFile(dbFile),
+    countTables(dbFile)
+  ]);
   return {
     [databaseName]: {
       hash,
@@ -23745,22 +23826,21 @@ async function loadInspectDataFromFile(dbFile, databaseName) {
 async function introspectDatabase(db) {
   const rows = await executeRows(
     db,
-    "select name, type, sql from sqlite_master where type in ('table', 'view') order by name"
+    "SELECT name, type, sql FROM sqlite_master WHERE type IN ('table', 'view') ORDER BY name"
   );
   const tables = {};
   for (const row of rows) {
-    const name = asString(row.name);
-    if (name.startsWith("sqlite_")) {
-      continue;
-    }
-    const type = asString(row.type);
-    const sql2 = asNullableString(row.sql);
+    const name = String(row.name ?? "");
+    if (name.startsWith("sqlite_")) continue;
+    const type = String(row.type ?? "");
+    const sql2 = row.sql ? String(row.sql) : null;
     const virtual = type === "table" && isVirtualTable(sql2);
     const infoType = type === "view" ? "view" : virtual ? "virtual" : "table";
-    const columns = await tableColumns(db, name);
-    const foreignKeys = await tableForeignKeys(db, name);
-    const primaryKeys = columns.filter((column) => column.primaryKey).sort((a, b) => a.primaryKeyIndex - b.primaryKeyIndex).map((column) => column.name);
-    const isFts = isFtsTable(sql2);
+    const [columns, foreignKeys] = await Promise.all([
+      tableColumns(db, name),
+      tableForeignKeys(db, name)
+    ]);
+    const primaryKeys = columns.filter((col) => col.primaryKey).sort((a, b) => a.primaryKeyIndex - b.primaryKeyIndex).map((col) => col.name);
     tables[name] = {
       name,
       type: infoType,
@@ -23768,273 +23848,112 @@ async function introspectDatabase(db) {
       columns,
       primaryKeys,
       foreignKeys,
-      isFts
+      isFts: isFtsTable(sql2)
     };
   }
   return { tables };
 }
 async function tableColumns(db, tableName) {
-  const rows = await executeRows(db, `pragma table_info(${escapeIdentifier(tableName)})`);
+  const rows = await executeRows(db, `PRAGMA table_info(${escapeIdentifier(tableName)})`);
   return rows.map((row) => ({
-    name: asString(row.name),
-    type: asString(row.type),
-    notNull: asNumber(row.notnull) === 1,
-    defaultValue: asNullableString(row.dflt_value),
-    primaryKey: asNumber(row.pk) > 0,
-    primaryKeyIndex: asNumber(row.pk)
+    name: String(row.name ?? ""),
+    type: String(row.type ?? ""),
+    notNull: Number(row.notnull) === 1,
+    defaultValue: row.dflt_value != null ? String(row.dflt_value) : null,
+    primaryKey: Number(row.pk) > 0,
+    primaryKeyIndex: Number(row.pk)
   }));
 }
 async function tableForeignKeys(db, tableName) {
-  const rows = await executeRows(db, `pragma foreign_key_list(${escapeIdentifier(tableName)})`);
+  const rows = await executeRows(db, `PRAGMA foreign_key_list(${escapeIdentifier(tableName)})`);
   return rows.map((row) => ({
-    table: asString(row.table),
-    from: asString(row.from),
-    to: asString(row.to),
-    onUpdate: asString(row.on_update),
-    onDelete: asString(row.on_delete),
-    match: asString(row.match),
-    seq: asNumber(row.seq),
-    id: asNumber(row.id)
+    table: String(row.table ?? ""),
+    from: String(row.from ?? ""),
+    to: String(row.to ?? ""),
+    onUpdate: String(row.on_update ?? ""),
+    onDelete: String(row.on_delete ?? ""),
+    match: String(row.match ?? ""),
+    seq: Number(row.seq ?? 0),
+    id: Number(row.id ?? 0)
   }));
 }
-function asString(value, fallback = "") {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (value == null) {
-    return fallback;
-  }
-  return String(value);
-}
-function asNumber(value, fallback = 0) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value);
-    return Number.isNaN(parsed) ? fallback : parsed;
-  }
-  return fallback;
-}
-function asNullableString(value) {
-  if (value == null) {
-    return null;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  return String(value);
-}
 function isVirtualTable(sql2) {
-  if (!sql2) {
-    return false;
-  }
-  return /create\s+virtual\s+table/i.test(sql2);
+  return sql2 ? /create\s+virtual\s+table/i.test(sql2) : false;
 }
 function isFtsTable(sql2) {
-  if (!sql2) {
-    return false;
-  }
-  return /using\s+fts/i.test(sql2);
+  return sql2 ? /using\s+fts/i.test(sql2) : false;
 }
 function escapeIdentifier(name) {
-  const escaped = String(name).replace(/"/g, '""');
-  return `"${escaped}"`;
-}
-async function normalizeDumpFile(inputPath, outputPath, { log } = {}) {
-  const tablesInOrder = [];
-  const viewsInOrder = [];
-  if (log) {
-    log(`Normalizing D1 import SQL: ${outputPath}`);
-  }
-  await forEachLine(inputPath, (line) => {
-    const tableMatch = line.match(/^CREATE TABLE\s+("?[^"]+"?)/i);
-    if (tableMatch) {
-      tablesInOrder.push(tableMatch[1].replace(/\s*\($/, ""));
-      return;
-    }
-    const viewMatch = line.match(/^CREATE VIEW\s+("?[^"]+"?)/i);
-    if (viewMatch) {
-      viewsInOrder.push(viewMatch[1].replace(/\s*\($/, ""));
-    }
-  });
-  const outputStream = createWriteStream(outputPath, { encoding: "utf8" });
-  for (const viewName of viewsInOrder.reverse()) {
-    await writeLine(outputStream, `DROP VIEW IF EXISTS ${viewName};`);
-  }
-  for (const tableName of tablesInOrder.reverse()) {
-    await writeLine(outputStream, `DROP TABLE IF EXISTS ${tableName};`);
-  }
-  await forEachLine(inputPath, async (line) => {
-    if (line === "BEGIN TRANSACTION;" || line === "COMMIT;") {
-      return;
-    }
-    if (line.startsWith("PRAGMA foreign_keys=")) {
-      return;
-    }
-    await writeLine(outputStream, line);
-  });
-  outputStream.end();
-  await once(outputStream, "finish");
-  if (log) {
-    const { size } = await stat(outputPath);
-    log(`D1 import SQL ready (${formatBytes(size)})`);
-  }
-}
-async function dumpSqliteToFile(dbFile, outputPath, { log, progressIntervalMs } = {}) {
-  if (log) {
-    log(`Dumping SQLite database via sqlite3 .dump`);
-  }
-  const child = spawn("sqlite3", [dbFile, ".dump"], {
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  let stderr = "";
-  if (child.stderr) {
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-  }
-  const stdout = child.stdout;
-  if (!stdout) {
-    const [error] = await once(child, "error");
-    throw error ?? new Error("sqlite3 stdout is unavailable.");
-  }
-  const outputStream = createWriteStream(outputPath, { encoding: "utf8" });
-  child.once("error", (error) => {
-    stdout.destroy(error);
-    outputStream.destroy(error);
-  });
-  const stopProgress = log ? startProgressLogger(outputPath, log, progressIntervalMs) : () => void 0;
-  try {
-    await pipeline(stdout, outputStream);
-  } finally {
-    stopProgress();
-  }
-  const [code, signal] = await once(child, "close");
-  if (code !== 0) {
-    const suffix = signal ? ` (signal ${signal})` : "";
-    const message = stderr.trim() || `sqlite3 exited with code ${code ?? "unknown"}${suffix}`;
-    throw new Error(message);
-  }
-  if (log) {
-    const { size } = await stat(outputPath);
-    log(`SQLite dump completed (${formatBytes(size)})`);
-  }
-}
-async function forEachLine(filePath, handler) {
-  const stream = createReadStream(filePath, { encoding: "utf8" });
-  const rl = createInterface({ input: stream, crlfDelay: Infinity });
-  try {
-    for await (const line of rl) {
-      await handler(line);
-    }
-  } finally {
-    rl.close();
-    stream.close();
-  }
-}
-async function writeLine(stream, line) {
-  if (!stream.write(`${line}
-`)) {
-    await once(stream, "drain");
-  }
-}
-function startProgressLogger(filePath, log, intervalMs) {
-  const interval = setInterval(() => {
-    void stat(filePath).then((info) => {
-      log(`Dump size: ${formatBytes(info.size)}`);
-    }).catch(() => void 0);
-  }, intervalMs);
-  return () => clearInterval(interval);
+  return `"${String(name).replace(/"/g, '""')}"`;
 }
 function formatBytes(bytes) {
-  if (!Number.isFinite(bytes) || bytes < 0) {
-    return "0 B";
-  }
+  if (!Number.isFinite(bytes) || bytes < 0) return "0 B";
   const units = ["B", "KB", "MB", "GB", "TB"];
   let value = bytes;
-  let index = 0;
-  while (value >= 1024 && index < units.length - 1) {
+  let i = 0;
+  while (value >= 1024 && i < units.length - 1) {
     value /= 1024;
-    index += 1;
+    i++;
   }
-  const rounded = index === 0 ? value.toFixed(0) : value.toFixed(1);
-  return `${rounded} ${units[index]}`;
+  return `${i === 0 ? value.toFixed(0) : value.toFixed(1)} ${units[i]}`;
 }
 async function hashFile(filePath) {
-  return new Promise((resolve2, reject) => {
-    const hash = createHash("sha256");
-    const stream = createReadStream(filePath, { highWaterMark: 1024 * 1024 });
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("error", reject);
-    stream.on("end", () => resolve2(hash.digest("hex")));
-  });
+  const hash = createHash("sha256");
+  const stream = createReadStream(filePath, { highWaterMark: 1024 * 1024 });
+  for await (const chunk of stream) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
 }
 async function countTables(dbFile) {
   const db = createReadonlyClient(dbFile);
   try {
-    const rows = await executeRows(db, "select name from sqlite_master where type = 'table'");
+    const rows = await executeRows(db, "SELECT name FROM sqlite_master WHERE type = 'table'");
     const tables = {};
-    for (const row of rows) {
-      const tableName = asString(row.name);
-      try {
-        const countRows = await executeRows(
-          db,
-          `select count(*) as count from ${escapeIdentifier(tableName)}`
-        );
-        const countRow = countRows[0];
-        const countValue = countRow?.count;
-        const count = typeof countValue === "number" ? countValue : Number(countValue ?? 0);
-        tables[tableName] = { count: Number.isNaN(count) ? 0 : count };
-      } catch {
-        tables[tableName] = { count: 0 };
-      }
-    }
+    await Promise.all(
+      rows.map(async (row) => {
+        const tableName = String(row.name ?? "");
+        try {
+          const [countRow] = await executeRows(
+            db,
+            `SELECT count(*) as count FROM ${escapeIdentifier(tableName)}`
+          );
+          tables[tableName] = { count: Number(countRow?.count ?? 0) };
+        } catch {
+          tables[tableName] = { count: 0 };
+        }
+      })
+    );
     return tables;
   } finally {
     db.close();
   }
 }
 function createReadonlyClient(dbFile) {
-  const fileUrl = pathToFileURL(dbFile);
-  return createClient({ url: fileUrl.toString() });
+  return createClient({
+    url: pathToFileURL(dbFile).toString(),
+    intMode: "bigint"
+    // Handle integers > MAX_SAFE_INTEGER
+  });
 }
 async function executeRows(db, sql2, args = []) {
   const result = await db.execute({ sql: sql2, args });
-  return normalizeLibsqlRows(result);
-}
-function normalizeLibsqlRows(result) {
-  const rows = Array.isArray(result?.rows) ? result.rows : [];
-  if (!rows.length) {
-    return [];
-  }
-  const firstRow = rows[0];
-  if (firstRow && typeof firstRow === "object" && !Array.isArray(firstRow)) {
+  const rows = result?.rows ?? [];
+  if (!rows.length) return [];
+  const first = rows[0];
+  if (first && typeof first === "object" && !Array.isArray(first)) {
     return rows;
   }
-  const columns = Array.isArray(result?.columns) ? result.columns.map((column) => {
-    if (typeof column === "string") {
-      return column;
-    }
-    if (column && typeof column === "object" && "name" in column) {
-      return String(column.name ?? "");
-    }
-    return "";
-  }) : [];
-  if (!columns.length) {
-    return [];
-  }
+  const columns = result?.columns ?? [];
+  if (!columns.length) return [];
   return rows.map((row) => {
     const values = Array.isArray(row) ? row : [];
-    const mapped = {};
-    for (let index = 0; index < columns.length; index += 1) {
-      const column = columns[index];
-      if (column) {
-        mapped[column] = values[index];
-      }
+    const obj = {};
+    for (let i = 0; i < columns.length; i++) {
+      const col = typeof columns[i] === "string" ? columns[i] : columns[i]?.name ?? "";
+      if (col) obj[col] = values[i];
     }
-    return mapped;
+    return obj;
   });
 }
 
@@ -24056,25 +23975,14 @@ async function runCloudflareDeploy(args) {
   logStep(`Worker entrypoint: ${workerEntrypoint}`);
   const assetsPath = join(packageRoot, "public");
   await assertFileExists(assetsPath, "assets directory");
-  let importFile;
-  try {
-    logStep("Exporting SQLite for D1 import");
-    importFile = await dumpSqliteForD1({
-      dbFile: options.dbFile,
-      outputDir: options.importsDir,
-      outputName: options.d1Name,
-      log: logStep,
-      progressIntervalMs: 5e3
-    });
-    logStep(`D1 import file: ${importFile}`);
-  } catch (error) {
-    if (isSqliteCliMissing(error)) {
-      throw new Error(
-        "sqlite3 is required to export your database. Install sqlite3 and retry."
-      );
-    }
-    throw error;
-  }
+  logStep("Exporting SQLite for D1 import");
+  const importFile = await dumpSqliteForD1({
+    dbFile: options.dbFile,
+    outputDir: options.importsDir,
+    outputName: options.d1Name,
+    log: logStep
+  });
+  logStep(`D1 import file: ${importFile}`);
   logStep("Loading schema");
   const schema = await loadSchemaFromFile(options.dbFile);
   let inspectData = null;
@@ -24326,12 +24234,6 @@ async function assertFileExists(path7, label) {
     throw new Error(`${label} not found: ${path7}`);
   }
 }
-function isSqliteCliMissing(error) {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-  return "code" in error && error.code === "ENOENT";
-}
 function logStep(message) {
   console.log(`[datasette-ts] ${message}`);
 }
@@ -24390,7 +24292,7 @@ async function createEmbeddedWorkerEntrypoint(options) {
     "};",
     ""
   ].join("\n");
-  await writeFile(entrypointPath, contents, "utf8");
+  await writeFile2(entrypointPath, contents, "utf8");
   options.log(`Embedded worker entrypoint: ${entrypointPath}`);
   return entrypointPath;
 }
@@ -24400,7 +24302,7 @@ function toPosixPath(value) {
 
 // src/cli/serve.ts
 init_registry();
-import { stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
+import { stat as stat5, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 
 // src/core/inspect.ts
@@ -24573,7 +24475,7 @@ async function runInspectCommand(args) {
   const data = await inspectDatabases(databasePaths);
   const json = JSON.stringify(data, null, 2);
   if (inspectFile) {
-    await writeFile2(inspectFile, json, "utf8");
+    await writeFile3(inspectFile, json, "utf8");
     return;
   }
   process.stdout.write(`${json}