@bitcobblers/wod-wiki-engine 0.35.2128 → 0.36.2130

package/dist/bin/wod.cjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S bun --no-env-file
 'use strict';
 
 var wodWikiLang = require('@bitcobblers/wod-wiki-lang');
@@ -10,6 +10,7 @@ var wodWikiWql = require('@bitcobblers/wod-wiki-wql');
 var crypto$1 = require('crypto');
 var wodWikiStorage = require('@bitcobblers/wod-wiki-storage');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -25,6 +26,252 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+function nodeRequire() {
+  const g = globalThis;
+  if (typeof g.process?.versions?.node === "undefined" && typeof g.Bun === "undefined") {
+    throw new Error("SQLite operations are only supported in Node / Bun environments");
+  }
+  const req = g.require ?? (typeof __require === "function" ? __require : void 0);
+  if (!req) throw new Error("SQLite operations require a CJS require shim (missing tsup banner?)");
+  return req;
+}
+function loadSql() {
+  sqlModulePromise ??= import(
+    /* @vite-ignore */
+    '@bitcobblers/wod-wiki-storage/sql'
+  );
+  return sqlModulePromise;
+}
+function resolveDbPath(dbPath) {
+  const chosen = dbPath ?? process.env.WOD_WIKI_DB ?? "./wodwiki.db";
+  return nodePath().resolve(process.cwd(), chosen);
+}
+async function openCliDb(target, opts) {
+  if (target === void 0 || typeof target === "string") {
+    return openSqliteDb(resolveDbPath(target), opts);
+  }
+  switch (target.kind) {
+    case "sqlite":
+      return openSqliteDb(target.path, opts);
+    case "turso":
+      return openRemoteDb(
+        { DB_DRIVER: "turso", DATABASE_URL: target.url, LIBSQL_AUTH_TOKEN: target.authToken },
+        target.label,
+        opts
+      );
+    case "postgres":
+      return openRemoteDb({ DB_DRIVER: "postgres", DATABASE_URL: target.url }, target.label, opts);
+  }
+}
+async function openSqliteDb(resolved, opts) {
+  const [{ createClient }, sql] = await Promise.all([
+    import(
+      /* @vite-ignore */
+      '@libsql/client'
+    ),
+    loadSql()
+  ]);
+  const initialize = opts?.initialize ?? true;
+  if (!initialize && !nodeFs().existsSync(resolved)) {
+    throw new Error(`[wod] no database at ${resolved} \u2014 run \`wod init\` to create and initialize it`);
+  }
+  if (initialize) nodeFs().mkdirSync(nodePath().dirname(resolved), { recursive: true });
+  const db = sql.libsqlDatabase(createClient({ url: `file:${resolved}` }));
+  try {
+    if (initialize) {
+      await sql.initializeStore(db);
+      await sql.initializeDomain(db);
+    } else {
+      await sql.verifyReadiness(db).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`${message} \u2014 run \`wod init\` to initialize it`, { cause: error });
+      });
+    }
+    return { db, storage: new sql.SqlStorage(db), path: resolved, close: () => db.close() };
+  } catch (error) {
+    await db.close();
+    throw error;
+  }
+}
+async function openRemoteDb(env, label, opts) {
+  const [{ openDatabase }, sql] = await Promise.all([
+    import(
+      /* @vite-ignore */
+      '@bitcobblers/wod-wiki-storage/sql/node'
+    ),
+    loadSql()
+  ]);
+  let db;
+  try {
+    db = await openDatabase(env, { create: opts?.create });
+    if (opts?.initialize === false) {
+      await sql.verifyReadiness(db);
+    } else {
+      await sql.initializeStore(db);
+      await sql.initializeDomain(db);
+    }
+  } catch (error) {
+    await db?.close().catch(() => {
+    });
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `[wod] ${label}: ${message}${opts?.initialize === false ? " \u2014 run `wod init` to initialize it" : ""}`,
+      { cause: error }
+    );
+  }
+  return { db, storage: new sql.SqlStorage(db), path: label, close: () => db.close() };
+}
+function formatV5Digest(digest) {
+  const bytes = digest.slice(0, 16);
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+}
+function uuid5(namespace, name) {
+  return formatV5Digest(nodeCrypto().createHash("sha1").update(namespace).update(name).digest());
+}
+function stableNoteId(sourceLabel, content) {
+  if (sourceLabel && sourceLabel !== "-") {
+    return uuid5(CLI_UUID_NAMESPACE, `wod-cli:${nodePath().resolve(process.cwd(), sourceLabel)}`);
+  }
+  return uuid5(CLI_UUID_NAMESPACE, `wod-cli:stdin:${content.length}:${content.slice(0, 256)}`);
+}
+function randomId() {
+  return nodeCrypto().randomUUID();
+}
+async function allRows(sql, db, store) {
+  return sql.listRows(db, sql.storeDefinition(store));
+}
+async function rowsByIndex(sql, db, store, index, only) {
+  return sql.listRows(db, sql.storeDefinition(store), { only }, void 0, index);
+}
+function sqliteEventStore(db) {
+  const all = async () => await allRows(await loadSql(), db, "events");
+  return {
+    getEventsByTimeRange: async (start, end) => (await all()).filter((r) => r.timestamp >= start && r.timestamp <= end),
+    getEventsByResult: async (resultId) => (await all()).filter((r) => r.resultId === resultId),
+    getEventsForNote: async (noteId) => (await all()).filter((r) => r.noteId === noteId),
+    getEventsByContent: async (blockContentId5) => (await all()).filter((r) => r.blockContentId === blockContentId5),
+    scanAll: all,
+    appendEvents: async (appended) => {
+      const sql = await loadSql();
+      await db.transaction(async (tx) => {
+        const eventsDef = sql.storeDefinition("events");
+        for (const row of appended) await sql.putRow(tx, eventsDef, row);
+      });
+    },
+    finalizeSummaries: async (resultId, finals) => {
+      const sql = await loadSql();
+      await db.transaction(async (tx) => {
+        const eventsDef = sql.storeDefinition("events");
+        const existing = (await sql.listRows(tx, eventsDef)).filter(
+          (r) => r.resultId === resultId && r.grain === "summary" && r.origin !== "user"
+        );
+        for (const row of existing) await sql.deleteRows(tx, eventsDef, row.id);
+        for (const row of finals) await sql.putRow(tx, eventsDef, row);
+      });
+    },
+    deleteEvents: async (ids) => {
+      const sql = await loadSql();
+      await db.transaction(async (tx) => {
+        const eventsDef = sql.storeDefinition("events");
+        for (const id of ids) await sql.deleteRows(tx, eventsDef, id);
+      });
+    }
+  };
+}
+function sqliteNoteStore(db) {
+  return {
+    getAllNotes: async () => await allRows(await loadSql(), db, "notes"),
+    getNotesByIds: async (noteIds) => {
+      const sql = await loadSql();
+      const rows = await sql.getRows(db, sql.storeDefinition("notes"), [...noteIds]);
+      return rows.filter((row) => row !== void 0);
+    },
+    getNoteIdsForTag: async (label) => {
+      const sql = await loadSql();
+      const tags = (await allRows(sql, db, "tags")).filter((t) => t.label === label);
+      const ids = {};
+      for (const tag of tags) {
+        for (const row of await rowsByIndex(sql, db, "note_tags", "by-tag", tag.id)) {
+          ids[row.noteId] = true;
+        }
+      }
+      return new Set(Object.keys(ids));
+    },
+    getNoteTagLabels: async (noteId) => {
+      const sql = await loadSql();
+      const tagRows = await allRows(sql, db, "tags");
+      const labelById = {};
+      for (const t of tagRows) labelById[t.id] = t.label;
+      const links = await rowsByIndex(sql, db, "note_tags", "by-note", noteId);
+      return links.map((l) => labelById[l.tagId]).filter((l) => typeof l === "string");
+    },
+    queryDomain: async (request) => {
+      const result = await (await loadSql()).handleDomainQuery(db, request);
+      return result;
+    }
+  };
+}
+function sqliteBlockStore(db) {
+  return {
+    getAllBlocks: async () => await allRows(await loadSql(), db, "block_index"),
+    queryDomain: async (request) => {
+      const result = await (await loadSql()).handleDomainQuery(db, { ...request, plan: "blocks" });
+      return result;
+    }
+  };
+}
+function sqliteEffortStore(db) {
+  return {
+    getAllEfforts: async () => {
+      const stored = await allRows(await loadSql(), db, "efforts");
+      const bySlug = {};
+      for (const effort of stored) bySlug[effort.slug] = effort;
+      for (const effort of wodWikiLang.bundledEfforts) {
+        bySlug[effort.slug] ??= effort;
+      }
+      return Object.values(bySlug);
+    }
+  };
+}
+function sqliteIndexStore(db, store) {
+  return {
+    getAllFromIndex: async (index, key) => rowsByIndex(await loadSql(), db, store, index, key)
+  };
+}
+async function getNoteBundle(db, noteId) {
+  const sql = await loadSql();
+  const note = await sql.getRow(db, sql.storeDefinition("notes"), noteId);
+  return { note };
+}
+async function getSessionBundle(db, resultId) {
+  const sql = await loadSql();
+  const session = await sql.getRow(db, sql.storeDefinition("sessions"), resultId);
+  if (!session) return void 0;
+  const events = await sql.listRows(db, sql.storeDefinition("events"), { only: resultId }, void 0, "by-result-grain");
+  return { session, events };
+}
+async function getEffortBySlug(db, slug) {
+  const sql = await loadSql();
+  const efforts = await allRows(sql, db, "efforts");
+  return efforts.find((e) => e.slug === slug);
+}
+async function listTagsByType(db, type) {
+  const sql = await loadSql();
+  const tags = await allRows(sql, db, "tags");
+  return tags.filter((t) => t.type === type);
+}
+var nodePath, nodeFs, nodeCrypto, sqlModulePromise, CLI_UUID_NAMESPACE;
+var init_db = __esm({
+  "src/cli/db.ts"() {
+    nodePath = () => nodeRequire()("node:path");
+    nodeFs = () => nodeRequire()("node:fs");
+    nodeCrypto = () => nodeRequire()("node:crypto");
+    CLI_UUID_NAMESPACE = "c0ffee00-8b1a-4e2c-9d3f-5a6b7c8d9e0f";
+  }
+});
 
 // src/cli/seedbuild/frontmatter.ts
 function unquote(value) {
@@ -805,6 +1052,132 @@ var init_compiler = __esm({
     };
   }
 });
+
+// src/cli/server.ts
+var server_exports = {};
+__export(server_exports, {
+  runCliServer: () => runCliServer
+});
+function bun() {
+  const b = globalThis.Bun;
+  if (!b) {
+    throw new Error("wod server/playground requires the Bun runtime \u2014 start with: bun wod server");
+  }
+  return b;
+}
+function moduleDir() {
+  const p = nodePath();
+  const meta = ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('wod.cjs', document.baseURI).href)) });
+  if (typeof meta.dir === "string") return p.resolve(meta.dir);
+  if (typeof meta.url === "string" && meta.url.startsWith("file:")) {
+    return p.resolve(p.dirname(decodeURIComponent(new URL(".", meta.url).pathname)));
+  }
+  throw new Error("wod server/playground: cannot determine the installed engine module directory");
+}
+function engineRoot() {
+  const p = nodePath();
+  const fs = nodeFs();
+  for (let dir = moduleDir(); ; dir = p.dirname(dir)) {
+    try {
+      if (JSON.parse(fs.readFileSync(p.resolve(dir, "package.json"), "utf8")).name === "@bitcobblers/wod-wiki-engine") return dir;
+    } catch {
+    }
+    const parent = p.dirname(dir);
+    if (parent === dir) break;
+  }
+  throw new Error("wod server/playground: cannot locate the installed @bitcobblers/wod-wiki-engine package");
+}
+function resolveDist(mode, options) {
+  const p = nodePath();
+  const explicit = options.dist?.trim() || options.env.PLAYGROUND_DIST?.trim() || void 0;
+  if (explicit) {
+    const dist2 = p.resolve(explicit);
+    if (!nodeFs().existsSync(p.resolve(dist2, "index.html"))) {
+      throw new Error(
+        `wod ${mode}: no built frontend (index.html) at ${dist2} \u2014 --dist/PLAYGROUND_DIST must point at an already-built directory (the CLI never builds frontends at runtime)`
+      );
+    }
+    return dist2;
+  }
+  const dist = p.resolve(engineRoot(), "dist", "web", mode === "playground" ? "playground" : "server");
+  if (!nodeFs().existsSync(p.resolve(dist, "index.html"))) {
+    throw new Error(
+      `wod ${mode}: packaged frontend missing \u2014 expected ${dist}/index.html. Reinstall @bitcobblers/wod-wiki-engine (bun add @bitcobblers/wod-wiki-engine), or rebuild the release assets from a checkout (bun run build:cli) and reinstall the package.`
+    );
+  }
+  return dist;
+}
+function resolveBind(mode, options) {
+  const host = options.host?.trim() || options.env.HOST?.trim() || "127.0.0.1";
+  const rawPort = options.port?.trim() || options.env.PORT?.trim() || "3000";
+  const port = Number(rawPort);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`wod ${mode}: invalid port ${JSON.stringify(rawPort)} (need integer 1..65535)`);
+  }
+  return { host, port };
+}
+async function runCliServer(mode, options, writeOut) {
+  const runtime = bun();
+  const { host, port } = resolveBind(mode, options);
+  let db;
+  let dbLabel = "no database";
+  if (mode === "server") {
+    const database = options.database;
+    if (!database) {
+      throw new Error("wod server: no database configuration resolved \u2014 this is a runner bug (expected resolveDatabaseConfig output)");
+    }
+    try {
+      db = await openCliDb(database, { initialize: false });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      throw new Error(`wod server: database not ready \u2014 run \`wod init\` first. ${message}`, { cause: e });
+    }
+    dbLabel = db.path;
+  }
+  let server;
+  try {
+    const dist = resolveDist(mode, options);
+    const handlerModule = "@bitcobblers/wod-wiki-engine/server";
+    const { createHandler } = await import(
+      /* @vite-ignore */
+      handlerModule
+    );
+    const handler = createHandler(db?.db ?? null, { playgroundDist: dist });
+    server = runtime.serve({ port, hostname: host, fetch: handler });
+    if (mode === "server") {
+      writeOut(`wod server: http://${host}:${port} \u2014 ${dbLabel} \xB7 dist ${dist}`);
+    } else {
+      writeOut(`wod playground: http://${host}:${port} \u2014 in-browser storage (no database) \xB7 dist ${dist}`);
+    }
+  } catch (e) {
+    if (db) await db.close();
+    throw e;
+  }
+  let closing = false;
+  const shutdown = async () => {
+    if (closing) process.exit(0);
+    closing = true;
+    try {
+      await server.stop();
+    } finally {
+      if (db) await db.close();
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", () => {
+    void shutdown();
+  });
+  process.on("SIGTERM", () => {
+    void shutdown();
+  });
+  await new Promise(() => {
+  });
+}
+var init_server = __esm({
+  "src/cli/server.ts"() {
+    init_db();
+  }
+});
 var activePacks = /* @__PURE__ */ new Map();
 function registerLanguagePack(pack) {
   const packId = pack.identity?.id ?? pack.identity?.name ?? "anonymous-pack";
@@ -1175,7 +1548,7 @@ function loadQueryData(options) {
       } else if (obj.facts || obj.results || obj.notes || obj.blocks || obj.efforts || obj.tags || obj.logs) {
         const corpus = payload;
         if (corpus.facts) data.facts = corpus.facts;
-        if (corpus.results) data.results = corpus.results;
+        if (Array.isArray(corpus.results)) data.results = corpus.results;
         if (corpus.notes) data.notes = corpus.notes;
         if (corpus.blocks) data.blocks = corpus.blocks;
         if (corpus.efforts) data.efforts = corpus.efforts;
@@ -1302,193 +1675,256 @@ async function runQueryCli(wqlString, options = {}) {
   });
   return createIRFile("query-result", result, { source: options.sourceLabel ?? "cli:wod query" });
 }
-var nodePath = () => nodeRequire()("node:path");
-var nodeFs = () => nodeRequire()("node:fs");
-var nodeCrypto = () => nodeRequire()("node:crypto");
-function nodeRequire() {
+
+// src/cli/runner.ts
+init_db();
+
+// src/cli/config.ts
+function nodeRequire2() {
   const g = globalThis;
   if (typeof g.process?.versions?.node === "undefined" && typeof g.Bun === "undefined") {
-    throw new Error("SQLite operations are only supported in Node / Bun environments");
+    throw new Error("database configuration is only supported in Node / Bun environments");
   }
   const req = g.require ?? (typeof __require === "function" ? __require : void 0);
-  if (!req) throw new Error("SQLite operations require a CJS require shim (missing tsup banner?)");
+  if (!req) throw new Error("database configuration requires a CJS require shim (missing tsup banner?)");
   return req;
 }
-var sqlModulePromise;
-function loadSql() {
-  sqlModulePromise ??= import(
-    /* @vite-ignore */
-    '@bitcobblers/wod-wiki-storage/sql'
-  );
-  return sqlModulePromise;
-}
-function resolveDbPath(dbPath) {
-  const chosen = dbPath ?? process.env.WOD_WIKI_DB ?? "./wodwiki.db";
-  return nodePath().resolve(process.cwd(), chosen);
-}
-async function openCliDb(dbPath) {
-  const [{ createClient }, sql] = await Promise.all([
-    import(
-      /* @vite-ignore */
-      '@libsql/client'
-    ),
-    loadSql()
-  ]);
-  const resolved = resolveDbPath(dbPath);
-  nodeFs().mkdirSync(nodePath().dirname(resolved), { recursive: true });
-  const db = sql.libsqlDatabase(createClient({ url: `file:${resolved}` }));
+var nodePath2 = () => nodeRequire2()("node:path");
+var nodeFs2 = () => nodeRequire2()("node:fs");
+function parseEnvFile(content) {
+  return nodeRequire2()("node:util").parseEnv(content);
+}
+function loadCliEnvironment(envFile) {
+  const fs = nodeFs2();
+  const path = nodePath2();
+  let file;
+  if (envFile !== void 0) {
+    file = path.resolve(process.cwd(), envFile);
+    if (!fs.existsSync(file)) throw new Error(`[wod] --env-file: file not found: ${envFile}`);
+  } else {
+    let dir = process.cwd();
+    for (; ; ) {
+      const candidate = path.join(dir, ".env");
+      if (fs.existsSync(candidate)) {
+        file = candidate;
+        break;
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return file !== void 0 ? parseEnvFile(fs.readFileSync(file, "utf-8")) : {};
+}
+var SQLITE_URL_SCHEMES = /^(libsql|https?|wss?|file):\/\//;
+var PG_URL_SCHEMES = /^postgres(ql)?:\/\//;
+var TURSO_URL_SCHEMES = /^(libsql|https?|wss?):\/\//;
+var PG_FLAG_KEYS = [
+  "postgresHost",
+  "postgresPort",
+  "postgresUser",
+  "postgresPassword",
+  "postgresDatabase",
+  "postgresSsl"
+];
+var PG_ENV_KEYS = [
+  "POSTGRES_HOST",
+  "POSTGRES_PORT",
+  "POSTGRES_USER",
+  "POSTGRES_PASSWORD",
+  "POSTGRES_DATABASE",
+  "POSTGRES_SSL"
+];
+var isBackend = (v) => v === "sqlite" || v === "postgres" || v === "turso";
+function setEnv(v) {
+  return v !== void 0 && v.trim() !== "" ? v : void 0;
+}
+function fail(message) {
+  throw new Error(`[wod] ${message}`);
+}
+function parsePort(v, source) {
+  if (!/^\d+$/.test(v)) fail(`${source} must be an integer 1..65535, got ${JSON.stringify(v)}`);
+  const port = Number(v);
+  if (port < 1 || port > 65535) fail(`${source} must be an integer 1..65535, got ${v}`);
+  return port;
+}
+function sslMode(v, source) {
+  if (v === void 0 || v === "") return "prefer";
+  if (typeof v === "boolean") return v ? "require" : "disable";
+  const s = v.trim().toLowerCase();
+  if (["true", "1", "yes", "require"].includes(s)) return "require";
+  if (["false", "0", "no", "disable", "disabled"].includes(s)) return "disable";
+  if (s === "prefer" || s === "verify-ca" || s === "verify-full") return s;
+  fail(`${source} must be disable|prefer|require|verify-ca|verify-full, got ${JSON.stringify(v)}`);
+}
+function safeUrlLabel(raw) {
   try {
-    await sql.initializeStore(db);
-    await sql.initializeDomain(db);
-    return { db, storage: new sql.SqlStorage(db), path: resolved, close: () => db.close() };
-  } catch (error) {
-    await db.close();
-    throw error;
+    const u = new URL(raw);
+    return `${u.protocol}//${u.host}${u.pathname}`;
+  } catch {
+    return "<unparsable-url>";
   }
 }
-function formatV5Digest(digest) {
-  const bytes = digest.slice(0, 16);
-  bytes[6] = bytes[6] & 15 | 80;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0"));
-  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
-}
-function uuid5(namespace, name) {
-  return formatV5Digest(nodeCrypto().createHash("sha1").update(namespace).update(name).digest());
-}
-var CLI_UUID_NAMESPACE = "c0ffee00-8b1a-4e2c-9d3f-5a6b7c8d9e0f";
-function stableNoteId(sourceLabel, content) {
-  if (sourceLabel && sourceLabel !== "-") {
-    return uuid5(CLI_UUID_NAMESPACE, `wod-cli:${nodePath().resolve(process.cwd(), sourceLabel)}`);
+function postgresFromUrl(url, source) {
+  if (!PG_URL_SCHEMES.test(url)) {
+    fail(`${source} must start with postgres:// or postgresql://`);
   }
-  return uuid5(CLI_UUID_NAMESPACE, `wod-cli:stdin:${content.length}:${content.slice(0, 256)}`);
-}
-function randomId() {
-  return nodeCrypto().randomUUID();
-}
-async function allRows(sql, db, store) {
-  return sql.listRows(db, sql.storeDefinition(store));
-}
-async function rowsByIndex(sql, db, store, index, only) {
-  return sql.listRows(db, sql.storeDefinition(store), { only }, void 0, index);
-}
-function sqliteEventStore(db) {
-  const all = async () => await allRows(await loadSql(), db, "events");
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    fail(`${source} is not a parseable URL`);
+  }
+  const database = decodeURIComponent(u.pathname.replace(/^\/+|\/+$/g, ""));
+  if (database === "") fail(`${source} has no database name`);
   return {
-    getEventsByTimeRange: async (start, end) => (await all()).filter((r) => r.timestamp >= start && r.timestamp <= end),
-    getEventsByResult: async (resultId) => (await all()).filter((r) => r.resultId === resultId),
-    getEventsForNote: async (noteId) => (await all()).filter((r) => r.noteId === noteId),
-    getEventsByContent: async (blockContentId5) => (await all()).filter((r) => r.blockContentId === blockContentId5),
-    scanAll: all,
-    appendEvents: async (appended) => {
-      const sql = await loadSql();
-      await db.transaction(async (tx) => {
-        const eventsDef = sql.storeDefinition("events");
-        for (const row of appended) await sql.putRow(tx, eventsDef, row);
-      });
-    },
-    finalizeSummaries: async (resultId, finals) => {
-      const sql = await loadSql();
-      await db.transaction(async (tx) => {
-        const eventsDef = sql.storeDefinition("events");
-        const existing = (await sql.listRows(tx, eventsDef)).filter(
-          (r) => r.resultId === resultId && r.grain === "summary" && r.origin !== "user"
-        );
-        for (const row of existing) await sql.deleteRows(tx, eventsDef, row.id);
-        for (const row of finals) await sql.putRow(tx, eventsDef, row);
-      });
-    },
-    deleteEvents: async (ids) => {
-      const sql = await loadSql();
-      await db.transaction(async (tx) => {
-        const eventsDef = sql.storeDefinition("events");
-        for (const id of ids) await sql.deleteRows(tx, eventsDef, id);
-      });
-    }
+    kind: "postgres",
+    label: safeUrlLabel(url),
+    url,
+    host: u.hostname,
+    port: u.port !== "" ? parsePort(u.port, `${source} port`) : 5432,
+    database,
+    user: u.username !== "" ? decodeURIComponent(u.username) : void 0,
+    password: u.password !== "" ? decodeURIComponent(u.password) : void 0,
+    ssl: sslMode(u.searchParams.get("sslmode") ?? u.searchParams.get("ssl") ?? void 0, `${source} ssl parameter`)
   };
 }
-function sqliteNoteStore(db) {
-  return {
-    getAllNotes: async () => await allRows(await loadSql(), db, "notes"),
-    getNotesByIds: async (noteIds) => {
-      const sql = await loadSql();
-      const rows = await sql.getRows(db, sql.storeDefinition("notes"), [...noteIds]);
-      return rows.filter((row) => row !== void 0);
-    },
-    getNoteIdsForTag: async (label) => {
-      const sql = await loadSql();
-      const tags = (await allRows(sql, db, "tags")).filter((t) => t.label === label);
-      const ids = {};
-      for (const tag of tags) {
-        for (const row of await rowsByIndex(sql, db, "note_tags", "by-tag", tag.id)) {
-          ids[row.noteId] = true;
-        }
-      }
-      return new Set(Object.keys(ids));
-    },
-    getNoteTagLabels: async (noteId) => {
-      const sql = await loadSql();
-      const tagRows = await allRows(sql, db, "tags");
-      const labelById = {};
-      for (const t of tagRows) labelById[t.id] = t.label;
-      const links = await rowsByIndex(sql, db, "note_tags", "by-note", noteId);
-      return links.map((l) => labelById[l.tagId]).filter((l) => typeof l === "string");
-    },
-    queryDomain: async (request) => {
-      const result = await (await loadSql()).handleDomainQuery(db, request);
-      return result;
-    }
-  };
-}
-function sqliteBlockStore(db) {
-  return {
-    getAllBlocks: async () => await allRows(await loadSql(), db, "block_index"),
-    queryDomain: async (request) => {
-      const result = await (await loadSql()).handleDomainQuery(db, { ...request, plan: "blocks" });
-      return result;
+function resolvePostgres(options, e, databaseUrl) {
+  const flagProps = PG_FLAG_KEYS.some((k) => options[k] !== void 0);
+  const envProps = PG_ENV_KEYS.some((k) => setEnv(e[k]) !== void 0);
+  if (flagProps || envProps && databaseUrl === void 0) {
+    const host = options.postgresHost ?? setEnv(e.POSTGRES_HOST) ?? "127.0.0.1";
+    const port = parsePort(options.postgresPort ?? setEnv(e.POSTGRES_PORT) ?? "5432", "--postgres-port/POSTGRES_PORT");
+    const database = options.postgresDatabase ?? setEnv(e.POSTGRES_DATABASE);
+    if (database === void 0) {
+      fail("--postgres-database (or POSTGRES_DATABASE) is required for per-property PostgreSQL configuration");
     }
-  };
-}
-function sqliteEffortStore(db) {
-  return {
-    getAllEfforts: async () => {
-      const stored = await allRows(await loadSql(), db, "efforts");
-      const bySlug = {};
-      for (const effort of stored) bySlug[effort.slug] = effort;
-      for (const effort of wodWikiLang.bundledEfforts) {
-        bySlug[effort.slug] ??= effort;
-      }
-      return Object.values(bySlug);
+    const user = options.postgresUser ?? setEnv(e.POSTGRES_USER);
+    const password = options.postgresPassword ?? setEnv(e.POSTGRES_PASSWORD);
+    const ssl = sslMode(options.postgresSsl ?? setEnv(e.POSTGRES_SSL), "--postgres-ssl/POSTGRES_SSL");
+    try {
+      const u = new URL(`postgresql://${host}`);
+      u.port = String(port);
+      u.pathname = `/${database}`;
+      if (user !== void 0) u.username = user;
+      if (password !== void 0) u.password = password;
+      u.searchParams.set("sslmode", ssl);
+      return {
+        kind: "postgres",
+        label: `postgresql://${u.host}${u.pathname}`,
+        url: u.toString(),
+        host,
+        port,
+        database,
+        user,
+        password,
+        ssl
+      };
+    } catch {
+      fail("invalid PostgreSQL host/database in per-property configuration");
     }
-  };
+  }
+  if (databaseUrl !== void 0) return postgresFromUrl(databaseUrl, "DB_DRIVER=postgres DATABASE_URL");
+  fail("DB_DRIVER=postgres requires DATABASE_URL starting with postgres:// or postgresql:// \u2014 or per-property --postgres-host/--postgres-database flags");
 }
-function sqliteIndexStore(db, store) {
+function resolveTurso(options, e, databaseUrl) {
+  const url = options.tursoUrl ?? setEnv(e.TURSO_DATABASE_URL) ?? databaseUrl;
+  if (url === void 0) {
+    fail("DB_DRIVER=turso requires --turso-url / TURSO_DATABASE_URL or DATABASE_URL (libsql:// or https://)");
+  }
+  if (PG_URL_SCHEMES.test(url)) fail("DB_DRIVER=turso cannot use a postgres:// URL");
+  if (!TURSO_URL_SCHEMES.test(url)) fail("DB_DRIVER=turso requires a libsql://, https://, http:// or wss:// URL");
   return {
-    getAllFromIndex: async (index, key) => rowsByIndex(await loadSql(), db, store, index, key)
+    kind: "turso",
+    label: safeUrlLabel(url),
+    url,
+    authToken: options.tursoAuthToken ?? setEnv(e.TURSO_AUTH_TOKEN) ?? setEnv(e.LIBSQL_AUTH_TOKEN)
   };
 }
-async function getNoteBundle(db, noteId) {
-  const sql = await loadSql();
-  const note = await sql.getRow(db, sql.storeDefinition("notes"), noteId);
-  return { note };
-}
-async function getSessionBundle(db, resultId) {
-  const sql = await loadSql();
-  const session = await sql.getRow(db, sql.storeDefinition("sessions"), resultId);
-  if (!session) return void 0;
-  const events = await sql.listRows(db, sql.storeDefinition("events"), { only: resultId }, void 0, "by-result-grain");
-  return { session, events };
-}
-async function getEffortBySlug(db, slug) {
-  const sql = await loadSql();
-  const efforts = await allRows(sql, db, "efforts");
-  return efforts.find((e) => e.slug === slug);
+function resolveSqlite(options, e, databaseUrl) {
+  if (options.db !== void 0) {
+    const path2 = nodePath2().resolve(process.cwd(), options.db);
+    return { kind: "sqlite", label: path2, path: path2 };
+  }
+  if (databaseUrl !== void 0) {
+    if (PG_URL_SCHEMES.test(databaseUrl)) fail("DB_DRIVER=sqlite cannot use a postgres:// DATABASE_URL");
+    if (databaseUrl.startsWith("file:")) {
+      const path2 = nodePath2().resolve(process.cwd(), decodeURIComponent(databaseUrl.slice("file:".length).split("?")[0]));
+      return { kind: "sqlite", label: path2, path: path2 };
+    }
+    if (!SQLITE_URL_SCHEMES.test(databaseUrl)) {
+      fail("DB_DRIVER=sqlite requires a libsql://, https://, http://, wss:// or file:// DATABASE_URL");
+    }
+    return { kind: "turso", label: safeUrlLabel(databaseUrl), url: databaseUrl, authToken: setEnv(e.LIBSQL_AUTH_TOKEN) };
+  }
+  const path = nodePath2().resolve(process.cwd(), setEnv(e.WOD_WIKI_DB) ?? setEnv(e.SQLITE_PATH) ?? "./wodwiki.db");
+  return { kind: "sqlite", label: path, path };
+}
+function envBackend(e) {
+  const kinds = /* @__PURE__ */ new Set();
+  if (setEnv(e.WOD_WIKI_DB) !== void 0 || setEnv(e.SQLITE_PATH) !== void 0) kinds.add("sqlite");
+  const dbUrl = setEnv(e.DATABASE_URL);
+  if (PG_ENV_KEYS.some((k) => setEnv(e[k]) !== void 0) || dbUrl !== void 0 && PG_URL_SCHEMES.test(dbUrl)) {
+    kinds.add("postgres");
+  } else if (dbUrl !== void 0 && SQLITE_URL_SCHEMES.test(dbUrl)) {
+    kinds.add("sqlite");
+  }
+  if (setEnv(e.TURSO_DATABASE_URL) !== void 0) kinds.add("turso");
+  if (kinds.size > 1) {
+    fail(`ambiguous database configuration: ${[...kinds].join(" + ")} env vars are both set \u2014 set DB_DRIVER (or pass explicit flags) to choose`);
+  }
+  return kinds.values().next().value ?? "sqlite";
 }
-async function listTagsByType(db, type) {
-  const sql = await loadSql();
-  const tags = await allRows(sql, db, "tags");
-  return tags.filter((t) => t.type === type);
+function resolveDatabaseConfig(options = {}, env) {
+  const e = env ?? { ...loadCliEnvironment(options.envFile), ...process.env };
+  const driverFlag = options.dbDriver;
+  if (driverFlag !== void 0 && !isBackend(driverFlag)) {
+    fail(`--db-driver must be sqlite|postgres|turso, got ${JSON.stringify(driverFlag)}`);
+  }
+  const pinned = [];
+  if (options.db !== void 0) pinned.push(["--db", "sqlite"]);
+  if (driverFlag !== void 0) pinned.push([`--db-driver ${driverFlag}`, driverFlag]);
+  if (options.tursoUrl !== void 0) pinned.push(["--turso-url", "turso"]);
+  if (options.tursoAuthToken !== void 0) pinned.push(["--turso-auth-token", "turso"]);
+  if (PG_FLAG_KEYS.some((k) => options[k] !== void 0)) pinned.push(["--postgres-*", "postgres"]);
+  const kinds = new Set(pinned.map(([, kind]) => kind));
+  if (kinds.size > 1) {
+    fail(`conflicting database selectors: ${pinned.map(([flag, kind]) => `${flag} (${kind})`).join(", ")}`);
+  }
+  if (options.databaseUrl !== void 0) {
+    if (options.db !== void 0) fail("conflicting database selectors: --db and --database-url are both set");
+    if (options.tursoUrl !== void 0) fail("conflicting database selectors: --turso-url and --database-url are both set");
+    if (PG_FLAG_KEYS.some((k) => options[k] !== void 0)) {
+      fail("conflicting database selectors: --database-url and --postgres-* flags are both set");
+    }
+  }
+  let backend;
+  if (pinned.length > 0) {
+    backend = pinned[0][1];
+  } else {
+    const envDriver = setEnv(e.DB_DRIVER);
+    if (envDriver !== void 0) {
+      if (!isBackend(envDriver)) {
+        fail(`Unsupported DB_DRIVER: ${envDriver} (expected sqlite|turso|postgres)`);
+      }
+      backend = envDriver;
+    } else {
+      backend = envBackend(e);
+    }
+  }
+  const databaseUrl = options.databaseUrl ?? setEnv(e.DATABASE_URL);
+  switch (backend) {
+    case "postgres":
+      return resolvePostgres(options, e, databaseUrl);
+    case "turso":
+      return resolveTurso(options, e, databaseUrl);
+    case "sqlite":
+      return resolveSqlite(options, e, databaseUrl);
+  }
 }
+
+// src/cli/persist.ts
+init_db();
 var registeredWidgets = wodWikiCore.KNOWN_SECTION_WIDGETS;
 var saveStores = ["notes", "block_revisions", "block_index", "block_efforts", "tags", "note_tags", "sessions"];
 function extractEffortSlugs(statements) {
@@ -1758,6 +2194,9 @@ async function persistTypedTags(db, labels, type) {
     return added;
   });
 }
+
+// src/cli/seed.ts
+init_db();
 var NOTE_ID_FRONTMATTER_KEY = "wod-note-id";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function extractNoteIdentity(markdown) {
@@ -2880,16 +3319,53 @@ ${source}
 ${fence}
 `;
 }
+var VALUE_FLAGS = [
+  ["--db", "db"],
+  ["--db-driver", "dbDriver"],
+  ["--database-url", "databaseUrl"],
+  ["--postgres-host", "postgresHost"],
+  ["--postgres-port", "postgresPort"],
+  ["--postgres-user", "postgresUser"],
+  ["--postgres-password", "postgresPassword"],
+  ["--postgres-database", "postgresDatabase"],
+  ["--postgres-ssl", "postgresSsl"],
+  ["--turso-url", "tursoUrl"],
+  ["--turso-auth-token", "tursoAuthToken"],
+  ["--env-file", "envFile"],
+  ["--host", "host"],
+  ["--port", "port"],
+  ["--dist", "dist"]
+];
+function readValueFlag(args, i, flag) {
+  const inline = args[i].startsWith(`${flag}=`);
+  if (inline) {
+    const value2 = args[i].slice(flag.length + 1);
+    if (!value2) throw new Error(`Missing value for ${flag}`);
+    return { value: value2, next: i + 1 };
+  }
+  const value = args[i + 1];
+  if (value === void 0 || value === "" || value.startsWith("--")) throw new Error(`Missing value for ${flag}`);
+  return { value, next: i + 2 };
+}
 function parseCliArgs(args) {
   const result = {
     format: "json",
     packs: [],
     sources: []
   };
+  const valueArgs = result;
   let i = 0;
   while (i < args.length) {
     const arg = args[i];
     if (arg === "--at" || arg.startsWith("--at=")) throw new Error("Unknown option --at; whole Note exports have no as-of version");
+    const valueFlag = VALUE_FLAGS.find(([flag]) => arg === flag || arg.startsWith(`${flag}=`));
+    if (valueFlag) {
+      const [flag, key] = valueFlag;
+      const { value, next } = readValueFlag(args, i, flag);
+      valueArgs[key] = value;
+      i = next;
+      continue;
+    }
     if (arg === "--help" || arg === "-h") {
       result.help = true;
       i++;
@@ -2936,12 +3412,6 @@ function parseCliArgs(args) {
     } else if (arg === "--unit") {
       result.unit = args[++i];
       i++;
-    } else if (arg === "--db") {
-      result.db = args[++i];
-      i++;
-    } else if (arg.startsWith("--db=")) {
-      result.db = arg.slice("--db=".length);
-      i++;
     } else if (arg === "--debug") {
       result.debug = "";
       i++;
@@ -2977,7 +3447,7 @@ function parseCliArgs(args) {
       result.dir = arg.slice("--dir=".length);
       i++;
     } else if (!result.subcommand) {
-      if (arg === "parse" || arg === "run" || arg === "query" || arg === "download" || arg === "import" || arg === "build" || arg === "seed" || arg === "reset" || arg === "help" || arg === "version") {
+      if (arg === "parse" || arg === "run" || arg === "query" || arg === "download" || arg === "import" || arg === "build" || arg === "seed" || arg === "reset" || arg === "init" || arg === "server" || arg === "serve" || arg === "playground" || arg === "help" || arg === "version") {
         result.subcommand = arg;
       } else {
         result.target = arg;
@@ -2993,14 +3463,19 @@ function parseCliArgs(args) {
       i++;
     }
   }
+  for (const [flag, value] of [["--port", result.port], ["--postgres-port", result.postgresPort]]) {
+    if (value !== void 0 && (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > 65535)) {
+      throw new Error(`Invalid value for ${flag}: "${value}" is not a TCP port (1-65535)`);
+    }
+  }
   return result;
 }
 function readBunStdinText() {
   const g = globalThis;
   if (g && typeof g === "object" && "Bun" in g) {
-    const bun = g.Bun;
-    if (bun && typeof bun === "object" && "stdin" in bun) {
-      const stdin = bun.stdin;
+    const bun2 = g.Bun;
+    if (bun2 && typeof bun2 === "object" && "stdin" in bun2) {
+      const stdin = bun2.stdin;
       if (stdin && typeof stdin === "object" && "text" in stdin) {
         const text = stdin.text;
         if (typeof text === "function") return text;
@@ -3038,6 +3513,11 @@ USAGE:
   wod build [dir] [options]
   wod seed [options]
   wod reset [options]
+  wod init            Initialize the configured database (idempotent)
+  wod server [options]
+                      Serve the app (HTTP API + packaged frontend; alias: serve)
+  wod playground [options]
+                      Serve the local playground (browser IndexedDB build)
 
 SUBCOMMANDS:
   parse <file | ->    Parse Whiteboard Script, create a note in the database
@@ -3091,9 +3571,47 @@ INPUT SOURCING (for 'query'; without these, the database is queried):
   --stdin-log         Read kind: 'execution-log' JSON payload from stdin
   --stdin-facts       Read raw kind: 'fact-set' JSON payload from stdin
 
-DATABASE (parse / run / query / download / import / seed / reset):
-  --db <path>         SQLite database file (default: $WOD_WIKI_DB or
-                      ./wodwiki.db). Created on demand by parse/run/seed.
+DATABASE (init / parse / run / query / download / import / seed / reset / server):
+  Pick one backend; explicit flags win over the process environment, the
+  process environment wins over .env files. Run 'wod init' once first: it
+  creates the SQLite file + schema, creates the PostgreSQL database when
+  your role is authorized to (otherwise use an existing/provisioned one),
+  or installs the schema in your provisioned Turso database \u2014 idempotently,
+  preserving existing notes. 'wod server' refuses an uninitialized database.
+  --db <path>                Local SQLite database file (default: $WOD_WIKI_DB
+                      or ./wodwiki.db). Passing --db always selects SQLite,
+                      even when the environment names a remote backend.
+                      Created on demand by parse/run/seed.
+  --db-driver <name>         Backend driver: sqlite (default), postgres, or
+                      turso ($DB_DRIVER)
+  --database-url <url>       Database connection URL ($DATABASE_URL); accepts
+                      PostgreSQL, local SQLite, and remote libSQL URLs.
+  --postgres-host <host>     PostgreSQL host ($POSTGRES_HOST)
+  --postgres-port <port>     PostgreSQL port ($POSTGRES_PORT)
+  --postgres-user <user>     PostgreSQL user ($POSTGRES_USER)
+  --postgres-password <pw>   PostgreSQL password ($POSTGRES_PASSWORD)
+  --postgres-database <db>   PostgreSQL database name ($POSTGRES_DATABASE)
+  --postgres-ssl <mode>      PostgreSQL SSL mode, e.g. disable/prefer/require
+                      ($POSTGRES_SSL)
+  --turso-url <url>          Turso/libSQL database URL (libsql://\u2026). The
+                      hosted database must already exist (provisioned on
+                      Turso); only its schema is installed.
+  --turso-auth-token <token> Turso authentication token (never printed)
+  --env-file <path>          Load variables from this file; a missing file is
+                      an error. Without it: ./.env when present, otherwise
+                      the workspace-root .env. Credentials are never logged.
+
+HOSTING (for 'server' / 'playground'; requires the Bun runtime):
+  server               HTTP API over the configured database plus the frontend
+                       packaged inside the engine module. Requires an
+                       initialized database. ('serve' is an accepted alias.)
+  playground           Serves the playground app backed by browser IndexedDB;
+                       the configured database is not touched.
+  --host <host>        Bind address (default 127.0.0.1, $HOST)
+  --port <port>        TCP port (default 3000, $PORT)
+  --dist <dir>         Serve this prebuilt frontend directory instead of the
+                       packaged one ($PLAYGROUND_DIST); must already contain
+                       index.html.
 
 SEED SOURCING (for 'seed'):
   --source <dir>      Extra compiled seed directory (manifest.json + chunks);
@@ -3113,6 +3631,15 @@ OPTIONS:
   -h, --help          Show help message
   -v, --version       Show version number
 
+ENVIRONMENT (flags > process env > .env):
+  WOD_WIKI_DB, SQLITE_PATH          SQLite file path
+  DB_DRIVER                         sqlite | postgres | turso
+  DATABASE_URL                      PostgreSQL connection URL
+  POSTGRES_HOST, POSTGRES_PORT, POSTGRES_USER,
+  POSTGRES_PASSWORD, POSTGRES_DATABASE, POSTGRES_SSL
+  TURSO_DATABASE_URL, TURSO_AUTH_TOKEN, LIBSQL_AUTH_TOKEN
+  HOST, PORT, PLAYGROUND_DIST       server / playground defaults
+
 EXIT CODES:
   0 - OK / Success
   1 - General / Runtime error
@@ -3132,6 +3659,10 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
   const writeOut = io.stdout ?? ((t) => process.stdout.write(t + "\n"));
   const writeErr = io.stderr ?? ((t) => process.stderr.write(t + "\n"));
   const getStdin = io.readStdinFn ?? readStdin;
+  let envLoaded;
+  const cliEnv = () => envLoaded ??= { ...loadCliEnvironment(parsed.envFile), ...process.env };
+  let dbResolved;
+  const cliDb = () => dbResolved ??= resolveDatabaseConfig(parsed, cliEnv());
   let parsed;
   try {
     parsed = parseCliArgs(argv);
@@ -3198,7 +3729,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       const ir = runParse(source, { sport: parsed.sport, sourceLabel: `cli:wod parse ${parsed.target}` });
       const identity = extractNoteIdentity(source);
       const tags = extractTypedTags(source);
-      const db = await openCliDb(parsed.db);
+      const db = await openCliDb(cliDb());
       try {
         const persisted = await persistNote(db, {
           source: noteSource,
@@ -3237,7 +3768,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         source = fs.readFileSync(parsed.target, "utf-8");
       }
       const identity = extractNoteIdentity(source);
-      const db = await openCliDb(parsed.db);
+      const db = await openCliDb(cliDb());
       let ir;
       try {
         const started = await startRun(db, {
@@ -3288,14 +3819,14 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       }
       let ir;
       if (useDb) {
-        const dbPath = resolveDbPath(parsed.db);
-        if (!nodeFs().existsSync(dbPath)) {
+        const config = cliDb();
+        if (config.kind === "sqlite" && !nodeFs().existsSync(config.path)) {
           writeErr(
-            `[wod query] No input dataset and no database at ${dbPath}. Specify --corpus <file>, --stdin-log, --stdin-facts, or run \`wod seed\` first.`
+            `[wod query] No input dataset and no database at ${config.path}. Specify --corpus <file>, --stdin-log, --stdin-facts, or run \`wod seed\` first.`
           );
           return 1;
         }
-        const db = await openCliDb(parsed.db);
+        const db = await openCliDb(config, config.kind === "sqlite" ? void 0 : { initialize: false });
         try {
           ir = await runQueryCli(parsed.target, {
             preferredUnit: parsed.unit,
@@ -3341,7 +3872,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         return 1;
       }
       const targetId = id;
-      const db = await openCliDb(parsed.db);
+      const db = await openCliDb(cliDb());
       try {
         if (kind === "note") {
           const bundle = await getNoteBundle(db.db, targetId);
@@ -3418,7 +3949,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         const source = fs.readFileSync(file, "utf-8");
         const identity = extractNoteIdentity(source);
         const tags = extractTypedTags(source);
-        const db2 = await openCliDb(parsed.db);
+        const db2 = await openCliDb(cliDb());
         try {
           const persisted = await persistNote(db2, {
             source,
@@ -3441,7 +3972,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
           writeErr(`[wod import] Unparseable effort file (need frontmatter id/slug/label + numeric baseAttributes.met): ${file}`);
           return 1;
         }
-        const db2 = await openCliDb(parsed.db);
+        const db2 = await openCliDb(cliDb());
         try {
           await persistEffort(db2, { ...effort, registrySource: "user" });
           writeOut(`[wod import] effort ${effort.slug} \u2014 ${effort.label} \u2192 ${db2.path}`);
@@ -3456,7 +3987,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
           writeErr(`[wod import] No equipment labels found in ${file}`);
           return 1;
         }
-        const db2 = await openCliDb(parsed.db);
+        const db2 = await openCliDb(cliDb());
         try {
           const added = await persistTypedTags(db2, labels, "equipment");
           writeOut(`[wod import] equipment \u2014 ${labels.length} labels (${added} new) \u2192 ${db2.path}`);
@@ -3466,7 +3997,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         return 0;
       }
       const { session, events } = csvToSessionRows(fs.readFileSync(file, "utf-8"));
-      const db = await openCliDb(parsed.db);
+      const db = await openCliDb(cliDb());
       try {
         const result = await persistSessionBundle(db, session, events);
         writeOut(
@@ -3513,7 +4044,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         );
         return 1;
       }
-      const db = await openCliDb(parsed.db);
+      const db = await openCliDb(cliDb());
       try {
         for (const dir of dirs) {
           const summary = await importSeedDir(db, dir, "");
@@ -3527,7 +4058,14 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       return 0;
     }
     if (parsed.subcommand === "reset") {
-      const target = resolveDbPath(parsed.db);
+      const config = cliDb();
+      if (config.kind !== "sqlite") {
+        writeErr(
+          `[wod reset] refusing to reset the configured ${config.kind} database \u2014 reset only removes a local SQLite file. Clear remote databases through their provider.`
+        );
+        return 1;
+      }
+      const target = config.path;
       if (nodeFs().existsSync(target)) {
         nodeFs().unlinkSync(target);
         writeOut(`[wod reset] removed ${target}`);
@@ -3536,6 +4074,32 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       }
       return 0;
     }
+    if (parsed.subcommand === "init") {
+      const db = await openCliDb(cliDb(), { create: true });
+      try {
+        writeOut(`[wod init] database ready at ${db.path}`);
+      } finally {
+        await db.close();
+      }
+      return 0;
+    }
+    if (parsed.subcommand === "server" || parsed.subcommand === "serve" || parsed.subcommand === "playground") {
+      if (!("Bun" in globalThis)) {
+        writeErr(
+          `[wod ${parsed.subcommand}] Error: hosting requires the Bun runtime (https://bun.sh) \u2014 run \`bun wod server\` / \`bun wod playground\`.`
+        );
+        return 1;
+      }
+      const mode = parsed.subcommand === "playground" ? "playground" : "server";
+      const { runCliServer: runCliServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+      const options = { env: cliEnv() };
+      if (mode === "server") options.database = cliDb();
+      if (parsed.host !== void 0) options.host = parsed.host;
+      if (parsed.port !== void 0) options.port = parsed.port;
+      if (parsed.dist !== void 0) options.dist = parsed.dist;
+      await runCliServer2(mode, options, writeOut);
+      return 0;
+    }
     writeErr(`[wod] Unknown subcommand "${parsed.subcommand}"`);
     return 1;
   } catch (error) {