@bitcobblers/wod-wiki-engine 0.35.2128 → 0.36.2130

package/dist/{chunk-N4KFWY6Z.mjs → chunk-UKBQ36RW.mjs}

@@ -1,5 +1,7 @@
 import { createRequire } from 'module';
-import { SEED_SCHEMA, SEED_REGISTERED_WIDGETS, seedNoteSourceId, catalogForChunkId, DASHBOARDS_CHUNK_ID, EFFORTS_CHUNK_ID, parseEffortFile, __require, seedMetaKey, emptySeedMeta, CANVAS_CHUNK_ID } from './chunk-Y6WO6MXS.mjs';
+import { SEED_SCHEMA, SEED_REGISTERED_WIDGETS, seedNoteSourceId, catalogForChunkId, DASHBOARDS_CHUNK_ID, EFFORTS_CHUNK_ID, parseEffortFile, seedMetaKey, emptySeedMeta, CANVAS_CHUNK_ID } from './chunk-BMHE7DDG.mjs';
+import { openCliDb, nodeFs, sqliteIndexStore, sqliteEffortStore, sqliteBlockStore, sqliteNoteStore, sqliteEventStore, getNoteBundle, getSessionBundle, getEffortBySlug, listTagsByType, nodePath, loadSql, uuid5, CLI_UUID_NAMESPACE, stableNoteId, randomId } from './chunk-EUQWEX6Z.mjs';
+import { __require } from './chunk-6L5ZDZJ7.mjs';
 import { dialectRegistry, realtimeProcessorRegistry, summaryProcessorRegistry, getHints, createParser, toStoredOutputStatement, frozenNow, createCompiler, createMockClock, RuntimeStack, EventBus, ScriptRuntime, createAnalyticsEngineForBlock, StartSessionAction, NextEvent, bundledEfforts, parseScript } from '@bitcobblers/wod-wiki-lang';
 import { MetricType, validateNoteBlocks, parseDocumentSections, blockContentId, reconcileNoteBlocks, mapNoteBlockChanges, KNOWN_SECTION_WIDGETS } from '@bitcobblers/wod-wiki-core';
 import { WQL_TYPED_TAG_KEYS, toEventRows, toSummaryEventRows, parseQuery, QueryService, isPipelineQuery, isFindQuery } from '@bitcobblers/wod-wiki-wql';
@@ -360,7 +362,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;
@@ -1580,192 +1582,249 @@ ${escapeCsvField2(data.parsed.metric)},${data.scalar},${escapeCsvField2(data.uni
   }
   return lines.join("\n");
 }
-var nodePath = () => nodeRequire()("node:path");
-var nodeFs = () => nodeRequire()("node:fs");
-var nodeCrypto = () => nodeRequire()("node:crypto");
+
+// src/cli/config.ts
 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");
+    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 = () => nodeRequire()("node:path");
+var nodeFs2 = () => nodeRequire()("node:fs");
+function parseEnvFile(content) {
+  return nodeRequire()("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 (blockContentId4) => (await all()).filter((r) => r.blockContentId === blockContentId4),
-    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 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");
+    }
+    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 sqliteBlockStore(db) {
+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 {
-    getAllBlocks: async () => await allRows(await loadSql(), db, "block_index"),
-    queryDomain: async (request) => {
-      const result = await (await loadSql()).handleDomainQuery(db, { ...request, plan: "blocks" });
-      return result;
-    }
+    kind: "turso",
+    label: safeUrlLabel(url),
+    url,
+    authToken: options.tursoAuthToken ?? setEnv(e.TURSO_AUTH_TOKEN) ?? setEnv(e.LIBSQL_AUTH_TOKEN)
   };
 }
-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 bundledEfforts) {
-        bySlug[effort.slug] ??= effort;
+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";
+}
+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)`);
       }
-      return Object.values(bySlug);
+      backend = envDriver;
+    } else {
+      backend = envBackend(e);
     }
-  };
-}
-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);
+  }
+  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);
+  }
 }
 var registeredWidgets = KNOWN_SECTION_WIDGETS;
 var saveStores = ["notes", "block_revisions", "block_index", "block_efforts", "tags", "note_tags", "sessions"];
@@ -2103,16 +2162,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++;
@@ -2159,12 +2255,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++;
@@ -2200,7 +2290,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;
@@ -2216,6 +2306,11 @@ 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() {
@@ -2261,6 +2356,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
@@ -2314,9 +2414,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);
@@ -2336,6 +2474,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
@@ -2355,6 +2502,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);
@@ -2421,7 +2572,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,
@@ -2460,7 +2611,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, {
@@ -2511,14 +2662,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,
@@ -2564,7 +2715,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);
@@ -2641,7 +2792,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,
@@ -2664,7 +2815,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}`);
@@ -2679,7 +2830,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}`);
@@ -2689,7 +2840,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(
@@ -2707,7 +2858,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         writeErr(`[wod build] No markdown/ corpus under ${root} \u2014 run from the content repo root (or pass its directory).`);
         return 1;
       }
-      const { generateSeed } = await import('./compiler-SXUCF7AU.mjs');
+      const { generateSeed } = await import('./compiler-NODHKWJJ.mjs');
       try {
         const result = generateSeed({
           corpusRoot: root,
@@ -2736,7 +2887,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, "");
@@ -2750,7 +2901,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}`);
@@ -2759,6 +2917,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 } = await import('./server-4P6AJAGT.mjs');
+      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 runCliServer(mode, options, writeOut);
+      return 0;
+    }
     writeErr(`[wod] Unknown subcommand "${parsed.subcommand}"`);
     return 1;
   } catch (error) {
@@ -2776,5 +2960,5 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
 }
 
 export { NOTE_ID_FRONTMATTER_KEY, PackLoadError, ParseSyntaxError, SESSION_CSV_HEADER, WqlSyntaxError, applySeedChunk, assertSeedManifest, assertSeedRows, buildStatementTree, buildWorkoutResults, cliMain, composeNoteMarkdown, createIRFile, csvToEquipmentLabels, csvToSessionRows, defineLanguagePack, effortToMarkdown, equipmentToCsv, extractNoteIdentity, extractTypedTags, formatExecutionOutput, formatParseOutput, formatQueryOutput, getRegisteredLanguagePacks, inMemoryEventStore, injectIdentityFrontmatter, isIRFile, listLanguagePacks, loadLanguagePack, loadQueryData, markdownToEffort, parseCliArgs, parseCsvLine, readFrontmatterMeta, readStdin, registerLanguagePack, runExecution, runParse, runQueryCli, seedNoteId, sessionToCsv, splitCsvRecords, statementToNode, unregisterLanguagePack };
-//# sourceMappingURL=chunk-N4KFWY6Z.mjs.map
-//# sourceMappingURL=chunk-N4KFWY6Z.mjs.map
+//# sourceMappingURL=chunk-UKBQ36RW.mjs.map
+//# sourceMappingURL=chunk-UKBQ36RW.mjs.map