@bitcobblers/wod-wiki-tools 0.0.0-stage → 0.36.2133

package/dist/bin/wod.cjs

@@ -0,0 +1,3532 @@
+#!/usr/bin/env node
+'use strict';
+
+var wodWikiLang = require('@bitcobblers/wod-wiki-lang');
+var wodWikiCore = require('@bitcobblers/wod-wiki-core');
+var child_process = require('child_process');
+var fs = require('fs');
+var path = require('path');
+var wodWikiWql = require('@bitcobblers/wod-wiki-wql');
+var crypto = require('crypto');
+var promises = require('fs/promises');
+var sql = require('@bitcobblers/wod-wiki-storage/sql');
+var wodWikiStorage = require('@bitcobblers/wod-wiki-storage');
+var wodWikiEngine = require('@bitcobblers/wod-wiki-engine');
+
+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, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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 (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);
+      });
+    }
+  };
+}
+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";
+  }
+});
+function catalogForChunkId(chunkId) {
+  const value = /^(?:collection|feed)\.(.+)$/.exec(chunkId)?.[1];
+  return value && value !== "_root" ? value : void 0;
+}
+function canvasRouteSlug(content) {
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  if (fm?.[1] && !/^template:\s*canvas\s*$/m.test(fm[1])) return null;
+  return fm?.[1]?.match(/^route:\s*(\S+)\s*$/m)?.[1]?.replace(/^\//, "") || null;
+}
+function seedNoteSourceId(path, content, chunkId) {
+  const parts = path.split("/");
+  const stem = (parts.at(-1) ?? "").replace(/\.md$/i, "");
+  const under = parts.slice(2).map((p) => p.replace(/\.md$/i, "")).join("/");
+  if (chunkId === CANVAS_CHUNK_ID2) return `guides:${canvasRouteSlug(content) ?? under}`;
+  if (chunkId === DASHBOARDS_CHUNK_ID) return "dashboards";
+  if (chunkId === EFFORTS_CHUNK_ID) return "efforts";
+  if (chunkId === TEMPLATE_CHUNK_ID) return "playground";
+  if (chunkId.startsWith("collection.")) {
+    const catalog = catalogForChunkId(chunkId);
+    return !catalog ? "collection:_root" : stem.toLowerCase() === "readme" ? `collection:${catalog}` : `collection:${catalog}/${stem}`;
+  }
+  if (chunkId.startsWith("feed.")) return `feed:feeds/${under}`;
+  return void 0;
+}
+var SEED_SCHEMA2, SEED_REGISTERED_WIDGETS, EFFORTS_CHUNK_ID, CANVAS_CHUNK_ID2, DASHBOARDS_CHUNK_ID, TEMPLATE_CHUNK_ID;
+var init_contract = __esm({
+  "src/seedbuild/contract.ts"() {
+    SEED_SCHEMA2 = 8;
+    SEED_REGISTERED_WIDGETS = wodWikiCore.KNOWN_SECTION_WIDGETS;
+    EFFORTS_CHUNK_ID = "efforts";
+    CANVAS_CHUNK_ID2 = "canvas";
+    DASHBOARDS_CHUNK_ID = "dashboards";
+    TEMPLATE_CHUNK_ID = "template";
+  }
+});
+
+// src/seedbuild/effort-slugs.ts
+function extractEffortSlugs2(statements) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const statement of statements) {
+    if (statement.exerciseId) {
+      slugs.add(statement.exerciseId);
+    } else {
+      const effortMetric = statement.metrics?.getMetric?.("effort");
+      const effort = effortMetric && typeof effortMetric.value === "string" ? effortMetric.value : void 0;
+      if (effort) {
+        const slug = effort.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+        if (slug) slugs.add(slug);
+      }
+    }
+  }
+  return Array.from(slugs);
+}
+var init_effort_slugs = __esm({
+  "src/seedbuild/effort-slugs.ts"() {
+  }
+});
+
+// src/seedbuild/filename.ts
+function fileToDisplayName(filename) {
+  const base = filename.replace(/\.md$/, "");
+  if (base.toUpperCase() === "README") return "Overview";
+  const cleaned = base.replace(/^day-\d+-/, "");
+  const tokens = cleaned.split(/[-_]/);
+  const titled = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const next = tokens[i + 1];
+    const after = tokens[i + 2];
+    const prev = tokens[i - 1];
+    if (/^\d{1,2}$/.test(token) && /^\d{1,2}$/.test(next ?? "") && !/^\d+$/.test(prev ?? "") && !/^\d+$/.test(after ?? "")) {
+      titled.push(`${token}.${next}`);
+      i++;
+      continue;
+    }
+    if (titled.length > 0 && FILE_TITLE_STOP_WORDS[token.toLowerCase()]) {
+      titled.push(token.toLowerCase());
+      continue;
+    }
+    titled.push(token.charAt(0).toUpperCase() + token.slice(1));
+  }
+  return titled.join(" ");
+}
+var FILE_TITLE_STOP_WORDS;
+var init_filename = __esm({
+  "src/seedbuild/filename.ts"() {
+    FILE_TITLE_STOP_WORDS = {
+      and: true,
+      or: true,
+      of: true,
+      for: true,
+      to: true,
+      in: true,
+      on: true,
+      at: true,
+      by: true,
+      with: true,
+      the: true,
+      a: true,
+      an: true
+    };
+  }
+});
+
+// src/seedbuild/frontmatter.ts
+function unquote(value) {
+  return value.replace(
+    /^(['"])(.*)\1$/,
+    (_match, quote, inner) => quote === '"' ? inner.replace(/\\(["\\])/g, "$1") : inner
+  );
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(FRONTMATTER_RE);
+  if (!match) return { meta: {}, body: raw };
+  return { meta: parseMetaLines(match[1].split(/\r?\n/)), body: raw.slice(match[0].length) };
+}
+function parseMetaLines(lines) {
+  const meta = {};
+  for (let i = 0; i < lines.length; i++) {
+    const keyMatch = lines[i].match(/^([A-Za-z][\w.-]*)\s*:(.*)$/);
+    if (!keyMatch) continue;
+    const key = keyMatch[1];
+    const rawVal = keyMatch[2].trim();
+    if (rawVal === "") {
+      const items = [];
+      while (i + 1 < lines.length) {
+        const itemMatch = lines[i + 1].match(/^\s+-\s+(.+)$/);
+        if (!itemMatch) break;
+        items.push(itemMatch[1].trim());
+        i++;
+      }
+      meta[key] = items.length > 0 ? items : "";
+    } else {
+      const wasQuoted = /^(['"])(.*)\1$/.test(rawVal);
+      const value = unquote(rawVal);
+      const num = Number(value);
+      meta[key] = !wasQuoted && value !== "" && !isNaN(num) ? num : value;
+    }
+  }
+  return meta;
+}
+function getScalar(meta, key) {
+  const value = meta[key];
+  return typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function getList(meta, key) {
+  const value = meta[key];
+  return Array.isArray(value) ? value : [];
+}
+var FRONTMATTER_RE;
+var init_frontmatter = __esm({
+  "src/seedbuild/frontmatter.ts"() {
+    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+  }
+});
+function parseDiscipline(val) {
+  if (!val) return void 0;
+  const normalized = unquoteYaml(val.trim()).toLowerCase();
+  if (wodWikiLang.isEffortDiscipline(normalized)) return normalized;
+  console.warn(`[effort-file] unknown discipline '${val}' \u2014 treating as unset`);
+  return void 0;
+}
+function unquoteYaml(val) {
+  if (val.startsWith('"') && val.endsWith('"')) {
+    return val.slice(1, -1).replace(/\\(["\\])/g, "$1");
+  }
+  if (val.startsWith("'") && val.endsWith("'")) {
+    return val.slice(1, -1).replace(/\\'/g, "'");
+  }
+  return val;
+}
+function coerceNestedScalar(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw !== "" && !Number.isNaN(Number(raw))) return Number(raw);
+  return raw;
+}
+function readNestedSection(lines, key) {
+  const start = lines.findIndex((l) => new RegExp(`^${key}:\\s*$`).test(l));
+  if (start === -1) return void 0;
+  const result = {};
+  let subKey = null;
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\S/.test(line)) break;
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const m = trimmed.match(/^([\w.-]+):\s*(.*)$/);
+    if (!m) continue;
+    const [, k, rawVal] = m;
+    if (indent === 2) {
+      if (rawVal === "") {
+        subKey = k;
+        result[k] = {};
+      } else {
+        subKey = null;
+        result[k] = coerceNestedScalar(rawVal);
+      }
+    } else if (indent >= 4 && subKey !== null) {
+      result[subKey][k] = coerceNestedScalar(rawVal);
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseEffortFile(raw) {
+  const blockMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!blockMatch) return null;
+  const { meta, body } = parseFrontmatter(raw);
+  const innerLines = blockMatch[1].split(/\r?\n/);
+  const id = getScalar(meta, "id");
+  const slug = getScalar(meta, "slug");
+  const label = getScalar(meta, "label");
+  const aliases = getList(meta, "aliases");
+  const baseAttrs = readNestedSection(innerLines, "baseAttributes");
+  const hints = readNestedSection(innerLines, "hints");
+  const derivation = readNestedSection(innerLines, "derivation");
+  const metRaw = baseAttrs?.met;
+  const met = typeof metRaw === "number" ? metRaw : Number(metRaw);
+  if (!id || !slug || !label || metRaw === void 0 || Number.isNaN(met)) return null;
+  const discipline = parseDiscipline(
+    typeof baseAttrs?.discipline === "string" ? baseAttrs.discipline : void 0
+  );
+  const intensityTier = baseAttrs?.intensityTier;
+  const trimmedBody = body.trim();
+  return {
+    id: String(id),
+    slug: String(slug),
+    label: String(label),
+    aliases,
+    baseAttributes: {
+      met,
+      ...discipline ? { discipline } : {},
+      ...intensityTier ? { intensityTier } : {}
+    },
+    registrySource: "bundled",
+    ...trimmedBody ? { body: trimmedBody } : {},
+    ...hints ? { hints } : {},
+    ...derivation ? { derivation } : {}
+  };
+}
+var init_effort_file = __esm({
+  "src/seedbuild/effort-file.ts"() {
+    init_frontmatter();
+  }
+});
+function resolveGitVersion(repoRoot) {
+  try {
+    const run = (args) => child_process.execSync(`git ${args}`, { cwd: repoRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const count = Number(run("rev-list --count HEAD"));
+    return {
+      version: Number.isFinite(count) && count > 0 ? count : 0,
+      versionLabel: run("describe --tags --long --always --dirty"),
+      commit: run("rev-parse HEAD"),
+      dirty: run("status --porcelain") !== ""
+    };
+  } catch {
+    return UNKNOWN_GIT_VERSION;
+  }
+}
+var UNKNOWN_GIT_VERSION;
+var init_git_version = __esm({
+  "src/seedbuild/git-version.ts"() {
+    UNKNOWN_GIT_VERSION = {
+      version: 0,
+      versionLabel: "unknown",
+      commit: "",
+      dirty: false
+    };
+  }
+});
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function rowHtml(c) {
+  const kind = c.kind ?? "notes";
+  return `<tr><td>${escapeHtml(c.id)}</td><td>${kind}</td><td>${c.count}</td><td>${(c.bytes / 1024).toFixed(1)} KB</td><td><code>${c.sha256.slice(0, 8)}</code></td></tr>`;
+}
+function writeBuildReport(outDir, data) {
+  const { manifest, totalMs, passMs, fileCount } = data;
+  const totalBytes = manifest.chunks.reduce((s, c) => s + c.bytes, 0);
+  const dirtyBadge = manifest.dirty ? ' <strong style="color:#b45309">(dirty working tree \u2014 not reproducible from <code>' + escapeHtml(manifest.commit ?? "") + "</code>)</strong>" : "";
+  const html = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<title>Seed build report</title>
+<style>
+  body { font-family: system-ui, sans-serif; max-width: 960px; margin: 2rem auto; padding: 0 1rem; color: #1f2937; }
+  h1 { font-size: 1.4rem; } h2 { font-size: 1.1rem; margin-top: 2rem; }
+  table { border-collapse: collapse; width: 100%; font-size: 0.9rem; }
+  th, td { text-align: left; padding: 0.3rem 0.6rem; border-bottom: 1px solid #e5e7eb; }
+  code { font-size: 0.85em; }
+  dl { display: grid; grid-template-columns: max-content 1fr; gap: 0.2rem 1rem; font-size: 0.95rem; }
+  dt { font-weight: 600; }
+</style>
+</head>
+<body>
+<h1>Seed build report</h1>
+<h2>Version</h2>
+<dl>
+  <dt>version</dt><dd>${manifest.version} <code>${escapeHtml(manifest.versionLabel ?? "")}</code>${dirtyBadge}</dd>
+  <dt>commit</dt><dd><code>${escapeHtml(manifest.commit ?? "unknown")}</code></dd>
+  <dt>built at</dt><dd>${escapeHtml(manifest.builtAt)}</dd>
+  <dt>schema</dt><dd>v${manifest.schema}</dd>
+</dl>
+<h2>Benchmarks</h2>
+<dl>
+  <dt>total</dt><dd>${totalMs} ms</dd>
+  <dt>corpus scan + partition</dt><dd>${passMs.scan} ms (${fileCount} files)</dd>
+  <dt>block-index derivation</dt><dd>${passMs.blockIndex} ms</dd>
+  <dt>block syntax gate</dt><dd>${passMs.parseGate} ms</dd>
+  <dt>block-efforts derivation</dt><dd>${passMs.blockEfforts} ms</dd>
+  <dt>chunk writes</dt><dd>${passMs.write} ms</dd>
+</dl>
+<h2>Chunks (${manifest.chunks.length}, ${(totalBytes / 1024).toFixed(0)} KB total)</h2>
+<table>
+<thead><tr><th>id</th><th>kind</th><th>rows</th><th>size</th><th>sha256</th></tr></thead>
+<tbody>
+${manifest.chunks.map(rowHtml).join("\n")}
+</tbody>
+</table>
+</body>
+</html>
+`;
+  const file = path.join(outDir, "report.html");
+  fs.writeFileSync(file, html, "utf8");
+  return file;
+}
+var init_report = __esm({
+  "src/seedbuild/report.ts"() {
+  }
+});
+
+// src/seedbuild/compiler.ts
+var compiler_exports = {};
+__export(compiler_exports, {
+  buildBlockEffortRows: () => buildBlockEffortRows,
+  buildBlockIndexRows: () => buildBlockIndexRows,
+  chunkIdFor: () => chunkIdFor,
+  collectCorpusMarkdown: () => collectCorpusMarkdown,
+  compileSeedRow: () => compileSeedRow,
+  discoverUncatalogedEfforts: () => discoverUncatalogedEfforts,
+  feedDateToCreatedAt: () => feedDateToCreatedAt,
+  generateSeed: () => generateSeed,
+  loadExistingEffortMap: () => loadExistingEffortMap,
+  partitionIntoChunks: () => partitionIntoChunks,
+  scaffoldDiscoveredEfforts: () => scaffoldDiscoveredEfforts,
+  validateDashboardNote: () => validateDashboardNote,
+  validateWodBlockSyntax: () => validateWodBlockSyntax
+});
+function listMarkdownFiles(dir, prefix = "") {
+  if (!fs.existsSync(dir)) return [];
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) out.push(...listMarkdownFiles(path.join(dir, entry.name), rel));
+    else if (entry.isFile() && entry.name.endsWith(".md")) out.push(rel);
+  }
+  return out.sort();
+}
+function chunkIdFor(relPath) {
+  const parts = relPath.split("/");
+  if (parts[0] !== "markdown" || parts.length < 2) return null;
+  const corpus = parts[1];
+  if (parts.length === 2) return null;
+  const slug = parts[2]?.replace(/\.md$/, "");
+  switch (corpus) {
+    case "canvas":
+    case "dashboards":
+    case "efforts":
+      return corpus;
+    case "collections":
+      return parts.length === 3 ? `collection._root` : `collection.${slug}`;
+    case "feeds":
+      return parts.length === 3 ? `feed._root` : `feed.${slug}`;
+    default:
+      return null;
+  }
+}
+function collectCorpusMarkdown(markdownDir) {
+  return listMarkdownFiles(markdownDir).map((p) => `markdown/${p}`);
+}
+function partitionIntoChunks(paths) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const id = chunkIdFor(p);
+    if (id === null) {
+      throw new Error(
+        `[generate-seed] Parity failure: '${p}' is not part of any known corpus (canvas | dashboards | efforts | collections | feeds). Extend chunkIdFor() if this is a new corpus.`
+      );
+    }
+    const list = byId.get(id);
+    if (list) list.push(p);
+    else byId.set(id, [p]);
+  }
+  return [...byId.entries()].sort(([a], [b]) => a < b ? -1 : 1).map(([id, files]) => ({ id, files }));
+}
+function validateDashboardNote(raw) {
+  const problems = [];
+  const { meta } = parseFrontmatter(raw);
+  const { sections } = wodWikiWql.parseDashboardNote(raw);
+  const doc = wodWikiWql.buildDashboardDocument(sections, meta);
+  if (!doc.isDashboard) return ["file is not a dashboard note (missing dashboard frontmatter)"];
+  if (doc.title === void 0) problems.push("dashboard has no title");
+  if (doc.widgets.length < 3) problems.push(`dashboard has only ${doc.widgets.length} widgets (the locked format has \u2265 3)`);
+  const declared = new Set(doc.tokens.map((t) => t.name));
+  for (const widget of doc.widgets) {
+    const where = `widget '${widget.title ?? widget.body.slice(0, 40)}'`;
+    if (widget.title === void 0) problems.push(`${where}: missing title`);
+    if (!wodWikiWql.isDashboardWidgetType(wodWikiWql.resolveWidgetType(widget.type))) {
+      problems.push(`${where}: unknown widget type '${widget.type}'`);
+    }
+    const parsed = wodWikiWql.parseQuery(widget.body);
+    if (parsed.error !== void 0) problems.push(`${where}: WQL parse error: ${parsed.error}`);
+    for (const ref of [
+      ...widget.body.matchAll(/\$([A-Za-z][\w-]*)/g),
+      ...Object.values(widget.attributes).flatMap((v) => [...String(v).matchAll(/\$([A-Za-z][\w-]*)/g)])
+    ]) {
+      if (!declared.has(ref[1])) problems.push(`${where}: undeclared token $${ref[1]}`);
+    }
+  }
+  return problems;
+}
+function gateDashboards(groups, corpusRoot) {
+  for (const group of groups) {
+    if (group.id !== DASHBOARDS_CHUNK_ID) continue;
+    for (const p of group.files) {
+      const problems = validateDashboardNote(fs.readFileSync(path.join(corpusRoot, p), "utf8"));
+      if (problems.length > 0) {
+        throw new Error(`[generate-seed] Dashboard validation failed for '${p}':
+  - ${problems.join("\n  - ")}`);
+      }
+    }
+  }
+}
+function getFileCreatedAt(file, repoRoot) {
+  try {
+    const out = child_process.execSync(`git log -1 --format=%ct -- '${file}'`, { cwd: repoRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const ts = Number(out) * 1e3;
+    return Number.isFinite(ts) && ts > 0 ? ts : 0;
+  } catch {
+    return 0;
+  }
+}
+function feedDateToCreatedAt(dateKey) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(dateKey)) return 0;
+  const ts = Date.parse(`${dateKey}T00:00:00Z`);
+  return Number.isNaN(ts) ? 0 : ts;
+}
+function compileSeedRow(path, content, metadata = {}) {
+  let ordinal = 0;
+  const blocks = wodWikiCore.reconcileNoteBlocks(content, { sourceRevision: 1, registeredWidgets: SEED_REGISTERED_WIDGETS, createId: () => `seed:${path}:${ordinal++}` });
+  const noteId = metadata.routeId ?? path;
+  const sections = wodWikiCore.parseDocumentSections(content);
+  const blockIndex = Object.values(blocks).map((block, position) => {
+    const section = sections.find((section2) => section2.from === block.from && section2.to === block.to);
+    return { id: `${noteId}:${block.id}`, noteId, blockId: block.id, blockVersion: 1, sourceRevision: 1, from: block.from, to: block.to, position, dataType: block.kind, ...block.kind === "wod" ? { blockContentId: wodWikiCore.blockContentId(section?.scriptBlock?.content ?? content.slice(block.from, block.to)) } : {}, rawContent: content.slice(block.from, block.to), noteTitle: metadata.noteTitle ?? fileToDisplayName(path.split("/").at(-1) ?? path), createdAt: metadata.createdAt ?? 0, isStatic: true, sourceId: metadata.sourceId, sourcePath: path, routeId: metadata.routeId };
+  });
+  return { path, content, blocks, blockIndex, blockEfforts: [] };
+}
+function buildBlockIndexRows(markdownDir, corpusRoot) {
+  const rows = [];
+  for (const path$1 of collectCorpusMarkdown(markdownDir)) {
+    const chunkId = chunkIdFor(path$1);
+    if (!chunkId) continue;
+    const content = fs.readFileSync(path.join(corpusRoot, path$1), "utf8");
+    const parts = path$1.split("/");
+    const stem = (parts.at(-1) ?? "").replace(/\.md$/, "");
+    const catalog = parts[2];
+    const routeId = chunkId === "canvas" ? canvasRouteSlug(content) ?? void 0 : chunkId.startsWith("collection.") ? stem.toLowerCase() === "readme" ? catalog : `${catalog}/${stem}` : chunkId.startsWith("feed.") ? parts.slice(1).join("/").replace(/\.md$/, "") : void 0;
+    const sourceId = seedNoteSourceId(path$1, content, chunkId);
+    const createdAt = chunkId.startsWith("feed.") ? feedDateToCreatedAt(parts.at(-2) ?? "") : getFileCreatedAt(path$1, corpusRoot);
+    rows.push(...compileSeedRow(path$1, content, { routeId, sourceId, createdAt }).blockIndex);
+  }
+  return rows;
+}
+function validateWodBlockSyntax(blocks) {
+  const problems = [];
+  for (const block of blocks) {
+    if (block.dataType !== "wod" || !block.rawContent?.trim()) continue;
+    const section = wodWikiCore.parseDocumentSections(block.rawContent, { registeredWidgets: SEED_REGISTERED_WIDGETS }).find((s) => s.scriptBlock);
+    const source = section?.scriptBlock?.content ?? block.rawContent;
+    if (!source.trim()) continue;
+    const where = block.sourcePath ?? block.noteId;
+    if (section?.sport) {
+      const parsed = wodWikiLang.parseScript(source, { sport: section.sport });
+      for (const error of parsed.errors ?? []) {
+        problems.push(`${where}: ${error.message}`);
+      }
+      continue;
+    }
+    const doc = source.endsWith("\n") ? source : source + "\n";
+    const tree = wodWikiLang.whiteboardParser.parse(doc);
+    tree.iterate({
+      enter: (node) => {
+        if (!node.type.isError) return;
+        const line = doc.slice(0, node.from).split("\n").length;
+        const snippet = source.slice(node.from, Math.min(node.to, node.from + 60)).split("\n")[0];
+        problems.push(`${where}:${line} \`${snippet}\``);
+      }
+    });
+  }
+  return problems;
+}
+function formatDiscoveredLabel(raw) {
+  const clean = raw.replace(/[-_]+/g, " ").trim();
+  return clean.split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+function loadExistingEffortMap(markdownDir) {
+  const slugs = /* @__PURE__ */ new Set();
+  const aliasToCanonical = /* @__PURE__ */ new Map();
+  const effortsDir = path.join(markdownDir, "efforts");
+  for (const file of listMarkdownFiles(effortsDir)) {
+    const raw = fs.readFileSync(path.join(effortsDir, file), "utf8");
+    const parsed = parseEffortFile(raw);
+    if (!parsed) continue;
+    slugs.add(parsed.slug);
+    aliasToCanonical.set(parsed.slug, parsed.slug);
+    aliasToCanonical.set(parsed.label.toLowerCase(), parsed.slug);
+    aliasToCanonical.set(parsed.slug.replace(/-/g, " "), parsed.slug);
+    for (const alias of parsed.aliases) {
+      aliasToCanonical.set(alias.toLowerCase(), parsed.slug);
+      aliasToCanonical.set(alias.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, ""), parsed.slug);
+    }
+  }
+  return { slugs, aliasToCanonical };
+}
+function discoverUncatalogedEfforts(markdownDir, corpusRoot) {
+  const { slugs, aliasToCanonical } = loadExistingEffortMap(markdownDir);
+  const blocks = buildBlockIndexRows(markdownDir, corpusRoot);
+  const discovered = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (block.dataType !== "wod" || !block.rawContent) continue;
+    const section = wodWikiCore.parseDocumentSections(block.rawContent, { registeredWidgets: SEED_REGISTERED_WIDGETS }).find((section2) => section2.scriptBlock);
+    const script = wodWikiLang.parseScript(section?.scriptBlock?.content ?? block.rawContent);
+    for (const statement of script.statements) {
+      const effortMetric = statement.metrics?.getMetric?.("effort");
+      const effortLabel = (effortMetric && typeof effortMetric.value === "string" ? effortMetric.value : void 0) ?? statement.exerciseId;
+      if (!effortLabel) continue;
+      const slugified = effortLabel.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+      if (!slugified || NON_EFFORT_SLUGS[slugified]) continue;
+      const canonical = aliasToCanonical.get(slugified) ?? aliasToCanonical.get(effortLabel.toLowerCase());
+      if (canonical && slugs.has(canonical)) continue;
+      const existing = discovered.get(slugified);
+      if (existing) {
+        existing.rawLabels.add(effortLabel);
+      } else {
+        discovered.set(slugified, {
+          label: formatDiscoveredLabel(effortLabel),
+          rawLabels: /* @__PURE__ */ new Set([effortLabel])
+        });
+      }
+    }
+  }
+  return Array.from(discovered.entries()).map(([slug, data]) => ({
+    slug,
+    label: data.label,
+    rawLabels: Array.from(data.rawLabels)
+  }));
+}
+function scaffoldDiscoveredEfforts(discovered, markdownDir) {
+  const targetDir = path.join(markdownDir, "efforts", "discovered");
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+  const createdPaths = [];
+  for (const effort of discovered) {
+    const filePath = path.join(targetDir, `${effort.slug}.md`);
+    if (fs.existsSync(filePath)) continue;
+    const aliases = effort.rawLabels.filter((l) => l.toLowerCase() !== effort.label.toLowerCase()).map((l) => `  - "${l.replace(/"/g, '\\"')}"`);
+    const content = [
+      "---",
+      `id: effort-bundled-${effort.slug}`,
+      `slug: ${effort.slug}`,
+      `label: "${effort.label.replace(/"/g, '\\"')}"`,
+      aliases.length > 0 ? `aliases:
+${aliases.join("\n")}` : "aliases: []",
+      "baseAttributes:",
+      "  met: 5.0",
+      "  discipline: general",
+      "  intensityTier: moderate",
+      "registrySource: bundled",
+      "---",
+      ""
+    ].join("\n");
+    fs.writeFileSync(filePath, content, "utf8");
+    createdPaths.push(filePath);
+  }
+  return createdPaths;
+}
+function buildBlockEffortRows(markdownDir, corpusRoot, blocks = buildBlockIndexRows(markdownDir, corpusRoot)) {
+  const efforts = [];
+  const { aliasToCanonical } = loadExistingEffortMap(markdownDir);
+  for (const block of blocks) {
+    if (block.dataType !== "wod" || !block.rawContent) continue;
+    const section = wodWikiCore.parseDocumentSections(block.rawContent, { registeredWidgets: SEED_REGISTERED_WIDGETS }).find((section2) => section2.scriptBlock);
+    const script = wodWikiLang.parseScript(section?.scriptBlock?.content ?? block.rawContent);
+    const effortSlugs = extractEffortSlugs2(script.statements);
+    const linked = /* @__PURE__ */ new Set();
+    for (const rawSlug of effortSlugs) {
+      const norm = rawSlug.toLowerCase().trim();
+      const canonicalSlug = aliasToCanonical.get(norm) ?? aliasToCanonical.get(norm.replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "")) ?? norm.replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+      if (!canonicalSlug || NON_EFFORT_SLUGS[canonicalSlug] || NON_EFFORT_SLUGS[norm]) {
+        continue;
+      }
+      if (linked.has(canonicalSlug)) continue;
+      linked.add(canonicalSlug);
+      efforts.push({
+        id: `${block.id}:${canonicalSlug}`,
+        noteId: block.noteId,
+        blockId: block.blockId,
+        blockContentId: block.blockContentId,
+        effortSlug: canonicalSlug,
+        isStatic: block.isStatic,
+        sourcePath: block.sourcePath,
+        createdAt: block.createdAt
+      });
+    }
+  }
+  return efforts;
+}
+function sha256Hex(data) {
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+function generateSeed(options = {}) {
+  const t0 = Date.now();
+  const passMs = { scan: 0, blockIndex: 0, parseGate: 0, blockEfforts: 0, write: 0 };
+  const corpusRoot = options.corpusRoot ?? process.cwd();
+  const markdownDir = options.markdownDir ?? path.join(corpusRoot, "markdown");
+  const outDir = options.outDir ?? path.join(corpusRoot, "dist");
+  const gitVersion = options.version !== void 0 ? { ...resolveGitVersion(corpusRoot), version: options.version } : resolveGitVersion(corpusRoot);
+  if (options.scaffoldDiscoveredEfforts) {
+    const discovered = discoverUncatalogedEfforts(markdownDir, corpusRoot);
+    if (discovered.length > 0) {
+      scaffoldDiscoveredEfforts(discovered, markdownDir);
+    }
+  }
+  const tScan = Date.now();
+  const paths = collectCorpusMarkdown(markdownDir);
+  const groups = partitionIntoChunks(paths);
+  gateDashboards(groups, corpusRoot);
+  if (options.templateFile && fs.existsSync(options.templateFile)) {
+    const templateRowPath = options.templateRowPath ?? path.relative(corpusRoot, options.templateFile).split("\\").join("/");
+    groups.push({ id: TEMPLATE_CHUNK_ID, files: [templateRowPath] });
+  }
+  passMs.scan = Date.now() - tScan;
+  const tBlockIndex = Date.now();
+  const blockRows = buildBlockIndexRows(markdownDir, corpusRoot);
+  passMs.blockIndex = Date.now() - tBlockIndex;
+  const tParseGate = Date.now();
+  const syntaxProblems = validateWodBlockSyntax(blockRows);
+  passMs.parseGate = Date.now() - tParseGate;
+  if (syntaxProblems.length > 0) {
+    const shown = syntaxProblems.slice(0, 20).map((p) => `  ${p}`).join("\n");
+    const more = syntaxProblems.length > 20 ? `
+  \u2026 and ${syntaxProblems.length - 20} more` : "";
+    throw new Error(`[wod build] block syntax gate failed \u2014 ${syntaxProblems.length} block(s) do not parse:
+${shown}${more}`);
+  }
+  const chunksDir = path.join(outDir, "chunks");
+  fs.rmSync(outDir, { recursive: true, force: true });
+  fs.mkdirSync(chunksDir, { recursive: true });
+  const manifestChunks = [];
+  const tBlockEfforts = Date.now();
+  const effortRows = buildBlockEffortRows(markdownDir, corpusRoot, blockRows);
+  passMs.blockEfforts = Date.now() - tBlockEfforts;
+  const blocksByPath = /* @__PURE__ */ new Map();
+  const effortsByPath = /* @__PURE__ */ new Map();
+  for (const row of blockRows) {
+    const rows = blocksByPath.get(row.sourcePath) ?? [];
+    rows.push(row);
+    blocksByPath.set(row.sourcePath, rows);
+  }
+  for (const row of effortRows) {
+    const rows = effortsByPath.get(row.sourcePath) ?? [];
+    rows.push(row);
+    effortsByPath.set(row.sourcePath, rows);
+  }
+  let totalFiles = 0;
+  const tWrite = Date.now();
+  for (const { id, files } of groups) {
+    const templateSource = id === TEMPLATE_CHUNK_ID ? options.templateFile : void 0;
+    const rows = files.map((p) => {
+      const raw = fs.readFileSync(templateSource ?? path.join(corpusRoot, p), "utf8");
+      const content = id === TEMPLATE_CHUNK_ID ? raw.replace(/\$CURSOR/g, "") : raw;
+      const compiled = compileSeedRow(p, content);
+      compiled.blockIndex = blocksByPath.get(p) ?? compiled.blockIndex;
+      compiled.blockEfforts = effortsByPath.get(p) ?? [];
+      return compiled;
+    });
+    const bytes = Buffer.from(JSON.stringify(rows), "utf8");
+    const sha = sha256Hex(bytes);
+    const file = `chunks/${id}.${sha.slice(0, 8)}.json`;
+    fs.writeFileSync(path.join(outDir, file), bytes);
+    manifestChunks.push({ id, path: file, sha256: sha, bytes: bytes.length, count: rows.length });
+    totalFiles += rows.length;
+  }
+  passMs.write = Date.now() - tWrite;
+  const manifest = {
+    schema: SEED_SCHEMA2,
+    version: gitVersion.version,
+    versionLabel: gitVersion.versionLabel,
+    commit: gitVersion.commit,
+    dirty: gitVersion.dirty,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    chunks: manifestChunks
+  };
+  fs.writeFileSync(path.join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+  const reportPath = writeBuildReport(outDir, {
+    manifest,
+    totalMs: Date.now() - t0,
+    passMs,
+    fileCount: paths.length});
+  return { manifest, outDir, totalFiles, reportPath, passMs };
+}
+var NON_EFFORT_SLUGS;
+var init_compiler = __esm({
+  "src/seedbuild/compiler.ts"() {
+    init_contract();
+    init_effort_slugs();
+    init_filename();
+    init_effort_file();
+    init_git_version();
+    init_report();
+    init_frontmatter();
+    NON_EFFORT_SLUGS = {
+      "amrap": true,
+      "emom": true,
+      "tabata": true,
+      "for-time": true,
+      "rounds": true,
+      "sets": true,
+      "repetitions": true,
+      "count-down": true,
+      "total-reps": true,
+      "warmup": true,
+      "cooldown": true,
+      "cool-down": true,
+      "transition": true,
+      "rest": true,
+      "break": true,
+      "work": true,
+      "i-suck-at-this": true,
+      "isuckatthis": true,
+      "movement": true,
+      "movement-you": true,
+      "selected-exercise": true,
+      "training-setup": true,
+      "grade-system": true,
+      "hangs": true,
+      "warm-light-wind": true,
+      "basin": true,
+      "rock-canyon": true,
+      "b-onsight": true,
+      "a-redpoint": true,
+      "d-redpoint": true,
+      "v0-flash": true,
+      "v2-flash": true,
+      "v7-redpoint": true,
+      "avgrpe-mean": true,
+      "calculate": true,
+      "totalload-sum": true,
+      "query": true,
+      "by": true,
+      "": true,
+      "-": true,
+      "...": true,
+      "x": true,
+      "s": true,
+      "bw": true
+    };
+  }
+});
+
+// src/server/errors.ts
+var HttpError;
+var init_errors = __esm({
+  "src/server/errors.ts"() {
+    HttpError = class extends Error {
+      constructor(status, message, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "HttpError";
+      }
+      status;
+      code;
+    };
+  }
+});
+function bunFile(path) {
+  const bun2 = globalThis;
+  if (!bun2.Bun) throw new Error("the wod-wiki server handler requires the Bun runtime (https://bun.sh)");
+  return bun2.Bun.file(path);
+}
+function jsonParam(url, name) {
+  const raw = qget(url, name);
+  if (raw === void 0) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new HttpError(400, `invalid JSON in ?${name}`);
+  }
+}
+function rangeParam(url) {
+  const v = jsonParam(url, "range");
+  if (v === void 0) return void 0;
+  if (v !== null && typeof v === "object" && !Array.isArray(v)) return v;
+  return { only: v };
+}
+function countParam(url) {
+  const raw = qget(url, "count");
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) throw new HttpError(400, "invalid ?count");
+  return Math.trunc(n);
+}
+async function readJsonBody(req, maxBytes) {
+  const body = await req.text();
+  if (maxBytes !== void 0 && body.length > maxBytes) {
+    throw new HttpError(413, `domain query body exceeds ${maxBytes} bytes`);
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    throw new HttpError(400, "body must be valid JSON");
+  }
+}
+function txOps(value) {
+  if (!Array.isArray(value)) throw new HttpError(400, "tx body must be {ops: []}");
+  return value.map((op) => {
+    if (op === null || typeof op !== "object" || Array.isArray(op) || !("store" in op) || typeof op.store !== "string" || !("op" in op)) {
+      throw new HttpError(400, "tx op must have a store and operation");
+    }
+    const def = sql.storeDefinition(op.store);
+    const store = def.name;
+    switch (op.op) {
+      case "put":
+        if (!("value" in op)) throw new HttpError(400, "put requires value");
+        return { op: "put", store, value: op.value };
+      case "delete":
+        if (!("key" in op)) throw new HttpError(400, "delete requires key");
+        return { op: "delete", store, key: op.key };
+      case "clear":
+        return { op: "clear", store };
+      case "check": {
+        if (!("key" in op) || !("value" in op)) throw new HttpError(400, "check requires key and value");
+        const scalar = (key) => typeof key === "string" || typeof key === "number" && Number.isFinite(key);
+        if (!scalar(op.key) && !(Array.isArray(op.key) && op.key.length > 0 && op.key.every(scalar))) {
+          throw new HttpError(400, "check requires a scalar key or non-empty scalar tuple");
+        }
+        if (op.value !== null && (typeof op.value !== "object" || Array.isArray(op.value))) {
+          throw new HttpError(400, "check value must be a row or null");
+        }
+        const parts = Array.isArray(op.key) ? op.key : [op.key];
+        if (parts.length !== def.keyPath.length) throw new HttpError(400, "check key arity must match the store");
+        if (op.value !== null) {
+          let rowKey;
+          try {
+            rowKey = wodWikiStorage.keyFromValue(def, op.value);
+          } catch {
+            throw new HttpError(400, "check row must have its primary key");
+          }
+          if (JSON.stringify(rowKey) !== JSON.stringify(op.key)) throw new HttpError(400, "check row primary key must match key");
+        }
+        return { op: "check", store, key: op.key, value: op.value };
+      }
+      default:
+        throw new HttpError(400, "tx op must be put | delete | clear | check");
+    }
+  });
+}
+async function realpathSafe(path) {
+  try {
+    return await promises.realpath(path);
+  } catch {
+    return void 0;
+  }
+}
+async function serveFile(real, rel) {
+  const cache = rel.includes("seed/chunks/") ? "public, max-age=31536000, immutable" : "no-cache";
+  const ext = rel.slice(rel.lastIndexOf(".") + 1).toLowerCase();
+  return new Response(bunFile(real), {
+    headers: { "content-type": MIME[ext] ?? "application/octet-stream", "cache-control": cache }
+  });
+}
+async function serveSpaShell(distRoot) {
+  const index = await realpathSafe(path.join(distRoot, "index.html"));
+  if (index && (index === distRoot || index.startsWith(distRoot + path.sep)) && await promises.stat(index).then((s) => s.isFile(), () => false)) {
+    return new Response(bunFile(index), {
+      headers: { "content-type": MIME.html, "cache-control": "no-cache" }
+    });
+  }
+  return void 0;
+}
+async function staticResponse(distRoot, method, pathname) {
+  if (method !== "GET") return plain("method not allowed", 405);
+  if (!distRoot) {
+    return plain("wod-wiki-api: playground dist not found. Set PLAYGROUND_DIST or run the playground server build.", 503);
+  }
+  let rel;
+  try {
+    rel = decodeURIComponent(pathname).replace(/^\/+/, "");
+  } catch {
+    return plain("bad request", 400);
+  }
+  if (rel === "") rel = "index.html";
+  const parts = rel.split("/");
+  if (parts.some((p) => p === "..")) return plain("forbidden", 403);
+  const base = parts[parts.length - 1] ?? "";
+  const hasExtension = base.includes(".");
+  const abs = path.resolve(distRoot, ...parts);
+  const real = await realpathSafe(abs);
+  if (real && (real === distRoot || real.startsWith(distRoot + path.sep))) {
+    const info = await promises.stat(real).then((s) => s.isFile(), () => false);
+    if (info) return serveFile(real, rel);
+  }
+  if (!hasExtension) {
+    const shell = await serveSpaShell(distRoot);
+    if (shell) return shell;
+  }
+  return plain("not found", 404);
+}
+async function storeRoutes(db, method, sub, url, req) {
+  let inner = sub.slice("/v1/".length);
+  if (inner.endsWith("/")) inner = inner.slice(0, -1);
+  if (inner === "") return notFound();
+  const segments = inner.split("/");
+  let name;
+  let action;
+  if (segments.length === 1) {
+    name = segments[0];
+  } else if (segments.length === 2) {
+    [name, action] = segments;
+  } else if (segments.length === 3 && segments[1] === "index" && segments[2] !== "") {
+    [name, , action] = segments;
+    action = `index/${action}`;
+  } else {
+    return notFound();
+  }
+  const def = sql.storeDefinition(name);
+  const range = rangeParam(url);
+  const count = countParam(url);
+  if (action === "get" && method === "GET") {
+    const key = jsonParam(url, "key");
+    if (key === void 0) throw new HttpError(400, "missing ?key");
+    const row = await sql.getRow(db, def, key);
+    return row === void 0 ? notFound() : json(row, 200);
+  }
+  if (action === "all" && method === "GET") {
+    return json(await sql.listRows(db, def, range, count), 200);
+  }
+  if (action === "count" && method === "GET") {
+    const indexName = qget(url, "index");
+    const n = indexName ? await sql.countRows(db, def, range, indexName) : await sql.countRows(db, def, range);
+    return json({ count: Number(n) }, 200);
+  }
+  if (action === "clear" && method === "POST") {
+    await db.transaction((tx) => sql.refreshDomain(tx, [{ op: "clear", store: def.name }]));
+    return noContent();
+  }
+  if (action?.startsWith("index/") && method === "GET") {
+    return json(await sql.listRows(db, def, range, count, action.slice("index/".length)), 200);
+  }
+  if (action === void 0 && method === "PUT") {
+    const parsed = await readJsonBody(req);
+    const value = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "value" in parsed ? parsed.value : void 0;
+    if (value === void 0) throw new HttpError(400, "body must be {value: ...}");
+    const [key] = await db.transaction((tx) => sql.refreshDomain(tx, [{ op: "put", store: def.name, value }]));
+    return json({ key }, 200);
+  }
+  if (action === void 0 && method === "DELETE") {
+    const keyParam = jsonParam(url, "key");
+    const target = keyParam !== void 0 ? keyParam : range;
+    if (target === void 0 || target === null) throw new HttpError(400, "DELETE requires ?key or ?range");
+    await db.transaction((tx) => sql.refreshDomain(tx, [{ op: "delete", store: def.name, key: target }]));
+    return noContent();
+  }
+  return methodNotAllowed();
+}
+async function apiRoutes(db, req, method, sub, url) {
+  if (sub === "/health") {
+    return json({ ok: true, driver: db.dialect }, 200);
+  }
+  if (sub === "/v1/wipe" && method === "POST") {
+    await db.transaction(async (tx) => {
+      await sql.wipeRows(tx);
+      await sql.wipeDomain(tx);
+    });
+    return noContent();
+  }
+  if (sub === "/v1/tx" && method === "POST") {
+    const parsed = await readJsonBody(req);
+    const ops = typeof parsed === "object" && parsed !== null && "ops" in parsed ? parsed.ops : void 0;
+    const parsedOps = txOps(ops);
+    const results = await db.transaction((tx) => sql.refreshDomain(tx, parsedOps));
+    return json({ results }, 200);
+  }
+  if (sub === "/v1/query") {
+    if (method !== "POST") return methodNotAllowed();
+    const body = await readJsonBody(req, sql.MAX_BODY);
+    return json(await sql.handleDomainQuery(db, body), 200);
+  }
+  if (sub.startsWith("/v1/")) return storeRoutes(db, method, sub, url, req);
+  return notFound();
+}
+function distRootOf(playgroundDist) {
+  if (!playgroundDist) return void 0;
+  try {
+    return fs.realpathSync(playgroundDist);
+  } catch {
+    return void 0;
+  }
+}
+function createHandler(db, options) {
+  const distRoot = distRootOf(options.playgroundDist);
+  return async (request) => {
+    try {
+      const url = new URL(request.url);
+      const method = request.method === "HEAD" ? "GET" : request.method;
+      const path = url.pathname;
+      const response = path === "/api" || path.startsWith("/api/") ? db ? await apiRoutes(db, request, method, path.slice("/api".length) || "/", url) : notFound() : await staticResponse(distRoot, method, path);
+      return response;
+    } catch (e) {
+      if (e instanceof HttpError || e instanceof sql.StorageError) {
+        const status = e.status;
+        if (status >= 500) console.error("[wod-wiki-api]", e.message);
+        const body = { error: status >= 500 ? "internal error" : e.message };
+        if (e.code) body.code = e.code;
+        return json(body, status);
+      }
+      console.error("[wod-wiki-api]", e);
+      return json({ error: "internal error" }, 500);
+    }
+  };
+}
+var json, plain, notFound, methodNotAllowed, noContent, qget, MIME;
+var init_app = __esm({
+  "src/server/app.ts"() {
+    init_errors();
+    json = (value, status) => new Response(JSON.stringify(value), { status, headers: { "content-type": "application/json" } });
+    plain = (body, status) => new Response(body, { status, headers: { "content-type": "text/plain; charset=utf-8" } });
+    notFound = () => json({ error: "not found" }, 404);
+    methodNotAllowed = () => json({ error: "method not allowed" }, 405);
+    noContent = () => new Response(null, { status: 204 });
+    qget = (url, name) => url.searchParams.get(name) ?? void 0;
+    MIME = {
+      html: "text/html; charset=utf-8",
+      js: "text/javascript; charset=utf-8",
+      mjs: "text/javascript; charset=utf-8",
+      css: "text/css; charset=utf-8",
+      json: "application/json; charset=utf-8",
+      map: "application/json; charset=utf-8",
+      svg: "image/svg+xml",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      webp: "image/webp",
+      ico: "image/x-icon",
+      woff: "font/woff",
+      woff2: "font/woff2",
+      ttf: "font/ttf",
+      mp3: "audio/mpeg",
+      wav: "audio/wav",
+      webmanifest: "application/manifest+json",
+      xml: "application/xml",
+      txt: "text/plain; charset=utf-8"
+    };
+  }
+});
+
+// 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-tools") 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-tools 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-tools (bun add @bitcobblers/wod-wiki-tools), 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 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();
+    init_app();
+  }
+});
+function getPathUtils() {
+  if (typeof globalThis.process?.versions?.node === "undefined" && !("Bun" in globalThis)) {
+    throw new Error("Path resolution is only supported in Node / Bun environments");
+  }
+  return {
+    // eslint-disable-next-line no-restricted-syntax -- lazy CJS require keeps node builtins out of browser bundles
+    resolve: __require("path").resolve,
+    // eslint-disable-next-line no-restricted-syntax -- lazy CJS require keeps node builtins out of browser bundles
+    pathToFileURL: __require("url").pathToFileURL
+  };
+}
+var PackLoadError = class extends Error {
+  constructor(spec, originalError) {
+    const msg = originalError instanceof Error ? originalError.message : String(originalError);
+    super(`Failed to load Language Pack "${spec}": ${msg}`);
+    this.spec = spec;
+    this.originalError = originalError;
+    this.name = "PackLoadError";
+  }
+  spec;
+  originalError;
+};
+async function loadLanguagePack(moduleSpec) {
+  try {
+    let importPath = moduleSpec;
+    if (moduleSpec.startsWith(".") || moduleSpec.startsWith("/") || moduleSpec.includes("\\") || moduleSpec.endsWith(".ts") || moduleSpec.endsWith(".js") || moduleSpec.endsWith(".mjs")) {
+      const { resolve: resolve2, pathToFileURL } = getPathUtils();
+      const resolved = resolve2(process.cwd(), moduleSpec);
+      importPath = pathToFileURL(resolved).href;
+    }
+    const imported = await import(
+      /* @vite-ignore */
+      importPath
+    );
+    const candidate = imported.default ?? imported.pack ?? imported;
+    if (!candidate || typeof candidate !== "object") {
+      throw new Error(`Module "${moduleSpec}" does not export a valid LanguagePack object`);
+    }
+    const pack = candidate;
+    wodWikiEngine.registerLanguagePack(pack);
+    return pack;
+  } catch (error) {
+    if (error instanceof PackLoadError) throw error;
+    throw new PackLoadError(moduleSpec, error);
+  }
+}
+var ParseSyntaxError = class extends Error {
+  constructor(errors, message = "Parse error in Whiteboard Script") {
+    const details = errors.map((e) => e.message).join("; ");
+    super(`${message}: ${details}`);
+    this.errors = errors;
+    this.name = "ParseSyntaxError";
+  }
+  errors;
+};
+function runParse(source, options = {}) {
+  const parser = wodWikiLang.createParser();
+  const script = parser.read(source, options.sport);
+  if (script.errors && script.errors.length > 0) {
+    throw new ParseSyntaxError(script.errors);
+  }
+  const tree = wodWikiEngine.buildStatementTree(script);
+  return wodWikiEngine.createIRFile("parse-tree", tree, { source: options.sourceLabel ?? "cli:wod parse" });
+}
+function buildWorkoutResults(outputs, options) {
+  return {
+    startTime: options.startTime ?? options.now.nowMs(),
+    endTime: options.now.nowMs(),
+    duration: options.elapsedTime,
+    completed: options.completed,
+    logs: outputs.map(wodWikiLang.toStoredOutputStatement)
+  };
+}
+async function runExecution(source, options = {}) {
+  const parser = wodWikiLang.createParser();
+  const script = parser.read(source, options.sport);
+  if (script.errors && script.errors.length > 0) {
+    throw new ParseSyntaxError(script.errors);
+  }
+  const startTime = options.startTime ?? Date.now();
+  const now = options.now ?? wodWikiLang.frozenNow(new Date(startTime));
+  const compiler = wodWikiLang.createCompiler();
+  const clock = wodWikiLang.createMockClock(new Date(startTime));
+  const stack = new wodWikiLang.RuntimeStack();
+  const eventBus = new wodWikiLang.EventBus();
+  const runtime = new wodWikiLang.ScriptRuntime(
+    script,
+    compiler,
+    { stack, clock, eventBus },
+    {},
+    now
+  );
+  const { engine, analyticsContext } = wodWikiLang.createAnalyticsEngineForBlock({
+    id: options.blockId ?? "cli-block",
+    content: source,
+    statements: script.statements,
+    sport: options.sport,
+    version: options.blockVersion ?? 1,
+    startLine: 0,
+    endLine: 0,
+    dialect: options.dialect ?? "time",
+    state: "idle",
+    createdAt: Date.now()
+  });
+  runtime.analyticsContext = analyticsContext;
+  runtime.setAnalyticsEngine(engine);
+  const outputs = [];
+  runtime.subscribeToOutput((out) => {
+    outputs.push(out);
+  });
+  runtime.do(new wodWikiLang.StartSessionAction());
+  const maxSteps = options.maxIterations ?? 5e3;
+  let steps = 0;
+  while (stack.count > 0 && steps < maxSteps) {
+    runtime.handle(new wodWikiLang.NextEvent(void 0, runtime.nowProvider));
+    clock.advance(1e3);
+    steps++;
+  }
+  const workoutResults = buildWorkoutResults(outputs, {
+    startTime,
+    elapsedTime: steps * 1e3,
+    completed: stack.count === 0,
+    now
+  });
+  const logs = outputs.map(wodWikiLang.toStoredOutputStatement);
+  return wodWikiEngine.createIRFile(
+    "execution-log",
+    {
+      results: workoutResults,
+      logs,
+      statements: logs,
+      sourceScript: source
+    },
+    { source: options.sourceLabel ?? "cli:wod run" }
+  );
+}
+function getFs() {
+  if (typeof globalThis.process?.versions?.node === "undefined" && typeof globalThis.Bun === "undefined") {
+    throw new Error("File system operations are only supported in Node / Bun environments");
+  }
+  return __require("fs");
+}
+var WqlSyntaxError = class extends Error {
+  constructor(query, syntaxError) {
+    super(`WQL Syntax Error in "${query}": ${syntaxError}`);
+    this.query = query;
+    this.syntaxError = syntaxError;
+    this.name = "WqlSyntaxError";
+  }
+  query;
+  syntaxError;
+};
+function extractPayload(rawJson) {
+  try {
+    const parsed = JSON.parse(rawJson);
+    if (wodWikiEngine.isIRFile(parsed)) {
+      return parsed.data;
+    }
+    return parsed;
+  } catch (err) {
+    throw new Error(`Failed to parse JSON input: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+  }
+}
+function buildStoresFromData(data) {
+  const events = [
+    ...data.eventRecords,
+    ...data.facts.map((f, i) => ({
+      id: `fact:${f.resultId ?? "stdin"}:${f.metricKey ?? f.type}:${i}`,
+      resultId: f.resultId ?? "stdin-result-1",
+      noteId: f.noteId ?? "stdin-note-1",
+      blockContentId: f.blockContentId,
+      pageId: f.pageId,
+      origin: f.origin,
+      timestamp: f.timestamp,
+      grain: f.grain === "event" ? "event" : "summary",
+      outputType: "analytics",
+      effortSlug: f.effortSlug,
+      metrics: [{
+        type: f.metricKey ?? f.type,
+        value: f.value,
+        ...f.unit ? { unit: f.unit } : {},
+        origin: "engine"
+      }],
+      blockId: f.blockId,
+      blockVersion: f.blockVersion
+    }))
+  ];
+  const eventStore = wodWikiEngine.inMemoryEventStore(events);
+  const noteStore = {
+    getAllNotes: async () => [...data.notes],
+    getNotesByIds: async (ids) => {
+      const selected = new Set(ids);
+      return data.notes.filter((note) => selected.has(note.id));
+    },
+    getNoteIdsForTag: async (tag) => {
+      const matching = /* @__PURE__ */ new Set();
+      for (const [noteId, tags] of Object.entries(data.noteTags)) {
+        if (tags.includes(tag)) matching.add(noteId);
+      }
+      return matching;
+    },
+    getNoteTagLabels: async (noteId) => [...data.noteTags[noteId] ?? []]
+  };
+  const blockStore = {
+    getAllBlocks: async () => [...data.blocks]
+  };
+  const effortStore = {
+    getAllEfforts: async () => [...data.efforts]
+  };
+  return { eventStore, noteStore, blockStore, effortStore };
+}
+function loadQueryData(options) {
+  const data = {
+    eventRecords: [],
+    facts: [],
+    results: [],
+    notes: [],
+    blocks: [],
+    revisions: [],
+    efforts: [...wodWikiLang.bundledEfforts],
+    noteTags: {}
+  };
+  if (options.corpusPath) {
+    const fs = getFs();
+    if (!fs.existsSync(options.corpusPath)) {
+      throw new Error(`Corpus file not found at path: ${options.corpusPath}`);
+    }
+    const raw = fs.readFileSync(options.corpusPath, "utf-8");
+    const payload = extractPayload(raw);
+    if (Array.isArray(payload)) {
+      data.facts = payload;
+    } else if (payload && typeof payload === "object") {
+      const obj = payload;
+      if ("segments" in obj) throw new Error("Incompatible corpus segments; whole Notes and block revisions are required");
+      if (obj.kind === "event-journal" || Array.isArray(obj.records)) {
+        if (Array.isArray(obj.blockRevisions)) data.revisions = obj.blockRevisions;
+        if (Array.isArray(obj.sessions)) data.results = obj.sessions;
+        if (Array.isArray(obj.records)) {
+          data.eventRecords = obj.records;
+        }
+        if (Array.isArray(obj.notes)) {
+          data.notes = obj.notes;
+          for (const n of obj.notes) {
+            if (n && typeof n === "object" && n.id && Array.isArray(n.tags)) {
+              data.noteTags[n.id] = n.tags;
+            }
+          }
+        }
+      } 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 (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;
+        if (corpus.revisions) data.revisions = corpus.revisions;
+        if (corpus.tags) data.noteTags = corpus.tags;
+        if (corpus.logs) {
+          const identity = {
+            noteId: "corpus-note-1",
+            resultId: "corpus-result-1",
+            origin: "journal",
+            workoutTimestamp: corpus.logs[0]?.timeSpan?.started ?? Date.now()
+          };
+          data.eventRecords = [...wodWikiWql.toEventRows(corpus.logs, identity), ...wodWikiWql.toSummaryEventRows(corpus.logs, identity)];
+        }
+      } else {
+        throw new Error(`Unrecognized corpus payload shape in "${options.corpusPath}" (expected event-journal, fact-set, or CorpusIRData)`);
+      }
+    }
+  } else if (options.stdinLog) {
+    const payload = extractPayload(options.stdinLog);
+    let executionLog;
+    const rawLogs = payload.logs ?? ("statements" in payload ? payload.statements : void 0) ?? [];
+    if ("results" in payload) {
+      executionLog = { results: payload.results, logs: rawLogs, statements: rawLogs };
+    } else {
+      executionLog = { results: payload, logs: rawLogs, statements: rawLogs };
+    }
+    const identity = {
+      noteId: "stdin-note-1",
+      resultId: "stdin-result-1",
+      origin: "journal",
+      workoutTimestamp: executionLog.results.startTime
+    };
+    data.eventRecords = [
+      ...wodWikiWql.toEventRows(executionLog.logs, identity),
+      ...wodWikiWql.toSummaryEventRows(executionLog.logs, identity)
+    ];
+  } else if (options.stdinFacts) {
+    const payload = extractPayload(options.stdinFacts);
+    if (Array.isArray(payload)) {
+      data.facts = payload;
+    } else if (payload && typeof payload === "object" && "facts" in payload) {
+      data.facts = payload.facts;
+    }
+  } else {
+    throw new Error("No input dataset provided. Specify --corpus <path>, --stdin-log, or --stdin-facts.");
+  }
+  for (const note of data.notes) {
+    if (typeof note.rawContent !== "string" || !Number.isSafeInteger(note.sourceRevision) || note.sourceRevision < 1) {
+      throw new Error("Incompatible corpus Note; exact rawContent and sourceRevision are required");
+    }
+    wodWikiCore.validateNoteBlocks(note.rawContent, note.blocks, note.sourceRevision);
+    if (!data.blocks.some((row) => row.noteId === note.id)) {
+      for (const [position, block] of Object.values(note.blocks).sort((a, b) => a.from - b.from).entries()) {
+        const rawContent = note.rawContent.slice(block.from, block.to);
+        const body = wodWikiCore.parseDocumentSections(rawContent)[0]?.displayContent ?? rawContent;
+        data.blocks.push({
+          id: `${note.id}:${block.id}`,
+          noteId: note.id,
+          blockId: block.id,
+          blockVersion: block.version,
+          sourceRevision: note.sourceRevision,
+          from: block.from,
+          to: block.to,
+          position,
+          dataType: block.kind,
+          rawContent,
+          noteTitle: note.title,
+          createdAt: note.createdAt,
+          ...block.kind === "wod" ? { blockContentId: wodWikiCore.blockContentId(body) } : {}
+        });
+      }
+    }
+  }
+  for (const session of data.results) {
+    if ("segmentId" in session || "segmentVersion" in session || "data" in session || "version" in session || "rawContent" in session || !session.blockId || !Number.isSafeInteger(session.blockVersion) || session.blockVersion < 1) {
+      throw new Error("Incompatible corpus Session; exact blockId/blockVersion pin required");
+    }
+    if (!data.revisions.some((row) => row.noteId === session.noteId && row.blockId === session.blockId && row.version === session.blockVersion && row.kind === "wod")) {
+      throw new Error("Corpus Session immutable revision is unavailable");
+    }
+  }
+  for (const row of [...data.eventRecords, ...data.facts, ...data.blocks]) {
+    if ("segmentId" in row || "segmentVersion" in row) throw new Error("Incompatible corpus segment pin");
+  }
+  const revisions = new Map(data.revisions.map((row) => [JSON.stringify([row.noteId, row.blockId, row.version]), row]));
+  for (const row of data.eventRecords) {
+    if (row.blockId !== void 0 || row.blockVersion !== void 0) {
+      if (!row.blockId || !Number.isSafeInteger(row.blockVersion) || !revisions.has(JSON.stringify([row.noteId, row.blockId, row.blockVersion]))) {
+        throw new Error("Corpus Event immutable revision is unavailable");
+      }
+    }
+  }
+  for (const row of data.blocks) {
+    const note = data.notes.find((candidate) => candidate.id === row.noteId);
+    const block = note?.blocks[row.blockId];
+    if (!note || !block || row.blockVersion !== block.version || row.sourceRevision !== note.sourceRevision || row.from !== block.from || row.to !== block.to || row.dataType !== block.kind) {
+      throw new Error("Corpus block projection does not match current Note source");
+    }
+    row.rawContent = note.rawContent.slice(block.from, block.to);
+  }
+  return data;
+}
+async function runQueryCli(wqlString, options = {}) {
+  const parsed = wodWikiWql.parseQuery(wqlString);
+  if (parsed.error) {
+    throw new WqlSyntaxError(wqlString, parsed.error);
+  }
+  const stores = options.stores ?? buildStoresFromData(loadQueryData(options));
+  const service = new wodWikiWql.QueryService(stores);
+  if (wodWikiWql.isPipelineQuery(parsed)) {
+    const result2 = await service.runPipeline(wqlString, {
+      preferredUnit: options.preferredUnit
+    });
+    return wodWikiEngine.createIRFile("pipeline-result", result2, { source: options.sourceLabel ?? "cli:wod query" });
+  }
+  if (wodWikiWql.isFindQuery(parsed)) {
+    const result2 = await service.runFind(parsed);
+    const kind = parsed.target === "session" ? "rows-result" : "find-result";
+    return wodWikiEngine.createIRFile(kind, result2, { source: options.sourceLabel ?? "cli:wod query" });
+  }
+  const result = await service.runQuery(wqlString, {
+    preferredUnit: options.preferredUnit
+  });
+  return wodWikiEngine.createIRFile("query-result", result, { source: options.sourceLabel ?? "cli:wod query" });
+}
+
+// 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("database configuration is only supported in Node / Bun environments");
+  }
+  const req = g.require ?? (typeof __require === "function" ? __require : void 0);
+  if (!req) throw new Error("database configuration requires a CJS require shim (missing tsup banner?)");
+  return req;
+}
+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 {
+    const u = new URL(raw);
+    return `${u.protocol}//${u.host}${u.pathname}`;
+  } catch {
+    return "<unparsable-url>";
+  }
+}
+function postgresFromUrl(url, source) {
+  if (!PG_URL_SCHEMES.test(url)) {
+    fail(`${source} must start with postgres:// or postgresql://`);
+  }
+  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 {
+    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 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 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 {
+    kind: "turso",
+    label: safeUrlLabel(url),
+    url,
+    authToken: options.tursoAuthToken ?? setEnv(e.TURSO_AUTH_TOKEN) ?? setEnv(e.LIBSQL_AUTH_TOKEN)
+  };
+}
+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)`);
+      }
+      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) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const statement of statements) {
+    if (statement.exerciseId) {
+      slugs.add(statement.exerciseId);
+    } else {
+      const effortMetric = statement.metrics?.getMetric?.("effort");
+      const effort = effortMetric && "effort" in effortMetric ? effortMetric.effort : void 0;
+      if (typeof effort === "string") {
+        const slug = effort.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+        if (slug) slugs.add(slug);
+      }
+    }
+  }
+  return [...slugs];
+}
+function titleFromLabel(sourceLabel) {
+  if (!sourceLabel || sourceLabel === "-") return "stdin";
+  const stem = sourceLabel.split("/").pop() ?? sourceLabel;
+  return stem.replace(/\.[^.]+$/, "") || sourceLabel;
+}
+async function saveSource(db, options, startTime) {
+  const noteId = options.noteId ?? stableNoteId(options.sourceLabel, options.source);
+  const observed = await db.storage.readonly("notes").get(noteId);
+  const expected = options.expectedSourceRevision ?? observed?.sourceRevision ?? 0;
+  const now = options.now ?? Date.now();
+  return db.storage.transaction([...saveStores], "readwrite", async (tx) => {
+    const existing = await tx.readonly("notes").get(noteId);
+    if ((existing?.sourceRevision ?? 0) !== expected) {
+      throw new Error(`Stale Note source revision for ${noteId}; expected ${expected}`);
+    }
+    let sourceRevision = existing?.rawContent === options.source ? existing.sourceRevision : (existing?.sourceRevision ?? 0) + 1;
+    const blocks = wodWikiCore.reconcileNoteBlocks(options.source, {
+      sourceRevision,
+      blocks: options.blocks ?? (existing?.rawContent === options.source ? existing.blocks : void 0),
+      registeredWidgets,
+      createId: randomId
+    });
+    wodWikiCore.validateNoteBlocks(options.source, blocks, sourceRevision, { registeredWidgets });
+    const history = await tx.readonly("block_revisions").getAllFromIndex("by-note", noteId);
+    const latest = /* @__PURE__ */ new Map();
+    for (const row of history) {
+      if ((latest.get(row.blockId)?.version ?? 0) < row.version) latest.set(row.blockId, row);
+    }
+    const revisions = [];
+    for (const block of Object.values(blocks)) {
+      const saved = latest.get(block.id);
+      const rawContent = options.source.slice(block.from, block.to);
+      const unchanged = saved && saved.rawContent === rawContent && saved.kind === block.kind && saved.dialect === block.dialect && saved.sport === block.sport;
+      block.version = unchanged ? saved.version : (saved?.version ?? 0) + 1;
+      if (!unchanged) revisions.push({
+        noteId,
+        blockId: block.id,
+        version: block.version,
+        kind: block.kind,
+        rawContent,
+        savedAt: now,
+        ...block.dialect ? { dialect: block.dialect } : {},
+        ...block.sport ? { sport: block.sport } : {}
+      });
+    }
+    if (existing?.rawContent === options.source && !wodWikiStorage.rowsEqual(existing.blocks, blocks)) {
+      sourceRevision++;
+      for (const block of Object.values(blocks)) block.sourceRevision = sourceRevision;
+    }
+    const note = {
+      ...existing,
+      id: noteId,
+      title: options.title ?? existing?.title ?? titleFromLabel(options.sourceLabel),
+      type: existing?.type ?? "note",
+      date: existing?.date ?? now,
+      createdAt: existing?.createdAt ?? now,
+      rawContent: options.source,
+      sourceRevision,
+      blocks
+    };
+    const priorRows = await tx.readonly("block_index").getAllFromIndex("by-note", noteId);
+    const priorEfforts = await tx.readonly("block_efforts").getAllFromIndex("by-note", noteId);
+    const priorById = new Map(priorRows.map((row) => [row.id, row]));
+    const nextRows = [];
+    const nextEfforts = [];
+    for (const [position, block] of Object.values(blocks).sort((a, b) => a.from - b.from).entries()) {
+      const id = `${noteId}:${block.id}`;
+      const prior = priorById.get(id);
+      const rawContent = options.source.slice(block.from, block.to);
+      const body = wodWikiCore.parseDocumentSections(rawContent, { registeredWidgets })[0]?.displayContent ?? rawContent;
+      const fingerprint = block.kind === "wod" ? wodWikiCore.blockContentId(body) : void 0;
+      nextRows.push({
+        ...prior,
+        id,
+        noteId,
+        blockId: block.id,
+        blockVersion: block.version,
+        dataType: block.kind,
+        sourceRevision,
+        from: block.from,
+        to: block.to,
+        position,
+        rawContent,
+        noteTitle: note.title,
+        createdAt: prior?.createdAt ?? now,
+        blockContentId: fingerprint,
+        ...note.sourceId ? { sourceId: note.sourceId } : {}
+      });
+      if (block.kind === "wod") {
+        for (const effortSlug of extractEffortSlugs(wodWikiLang.parseScript(body, { sport: block.sport, dialect: block.dialect }).statements)) {
+          const effortId = `${noteId}:${block.id}:${effortSlug}`;
+          const previous = priorEfforts.find((row) => row.id === effortId);
+          nextEfforts.push({
+            ...previous,
+            id: effortId,
+            noteId,
+            blockId: block.id,
+            blockContentId: fingerprint,
+            effortSlug,
+            createdAt: previous?.createdAt ?? now
+          });
+        }
+      }
+    }
+    if (!wodWikiStorage.rowsEqual(existing, note)) await tx.readwrite("notes").put(note);
+    if (revisions.length) await tx.readwrite("block_revisions").putMany(revisions);
+    await diffProjection(tx, "block_index", priorRows, nextRows);
+    await diffProjection(tx, "block_efforts", priorEfforts, nextEfforts);
+    const tags = await saveTags(tx, noteId, options.tags, now);
+    let session;
+    let revision;
+    if (startTime !== void 0) {
+      const block = Object.values(blocks).filter((row) => row.kind === "wod").sort((a, b) => a.from - b.from)[0];
+      if (!block) throw new Error("[wod run] Note has no actionable workout block");
+      revision = revisions.find((row) => row.blockId === block.id) ?? latest.get(block.id);
+      if (!revision) throw new Error("[wod run] Saved workout revision is unavailable");
+      session = {
+        id: randomId(),
+        noteId,
+        blockId: block.id,
+        blockVersion: block.version,
+        blockContentId: wodWikiCore.blockContentId(wodWikiCore.parseDocumentSections(revision.rawContent)[0]?.displayContent ?? revision.rawContent),
+        origin: "journal",
+        status: "in-progress",
+        startTime,
+        endTime: startTime,
+        duration: 0,
+        completed: false,
+        createdAt: startTime
+      };
+      await tx.readwrite("sessions").put(session);
+    }
+    return { noteId, note, blocks: nextRows.length, efforts: nextEfforts.length, tags, created: !existing, session, revision };
+  });
+}
+async function diffProjection(tx, store, previous, next) {
+  const nextIds = new Set(next.map((row) => row.id));
+  for (const row of previous) if (!nextIds.has(row.id)) await tx.readwrite(store).delete(row.id);
+  const old = new Map(previous.map((row) => [row.id, row]));
+  for (const row of next) {
+    if (!wodWikiStorage.rowsEqual(old.get(row.id), row)) {
+      if (store === "block_index" && "blockVersion" in row) await tx.readwrite("block_index").put(row);
+      if (store === "block_efforts" && "effortSlug" in row) await tx.readwrite("block_efforts").put(row);
+    }
+  }
+}
+async function saveTags(tx, noteId, items, now) {
+  const previous = await tx.readonly("note_tags").getAllFromIndex("by-note", noteId);
+  if (!items) return previous.length;
+  const next = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const label = item.label.trim();
+    if (!label) continue;
+    const found = (await tx.readonly("tags").getAllFromIndex("by-label", label))[0];
+    const tag = found ? { ...found, ...!found.type && item.type ? { type: item.type } : {} } : { id: uuid5(CLI_UUID_NAMESPACE, `tag:${label}`), label, type: item.type, createdAt: now };
+    if (!wodWikiStorage.rowsEqual(found, tag)) await tx.readwrite("tags").put(tag);
+    const id = previous.find((link) => link.tagId === tag.id)?.id ?? uuid5(CLI_UUID_NAMESPACE, `note-tag:${noteId}:${tag.id}`);
+    next.set(id, { ...previous.find((link) => link.id === id), id, noteId, tagId: tag.id });
+  }
+  for (const link of previous) if (!next.has(link.id)) await tx.readwrite("note_tags").delete(link.id);
+  const old = new Map(previous.map((row) => [row.id, row]));
+  for (const link of next.values()) if (!wodWikiStorage.rowsEqual(old.get(link.id), link)) await tx.readwrite("note_tags").put(link);
+  return next.size;
+}
+function persistNote(db, options) {
+  return saveSource(db, options);
+}
+async function startRun(db, options, startTime = Date.now()) {
+  const saved = await saveSource(db, options, startTime);
+  if (!saved.session || !saved.revision) throw new Error("[wod run] Atomic run capture failed");
+  return { session: saved.session, revision: saved.revision, noteCreated: saved.created };
+}
+async function persistRun(db, started, executionLog) {
+  const results = executionLog.results;
+  const session = {
+    ...started.session,
+    status: results.completed ? "completed" : "in-progress",
+    endTime: results.endTime,
+    duration: results.duration ?? 0,
+    completed: results.completed
+  };
+  const identity = {
+    noteId: session.noteId,
+    resultId: session.id,
+    blockId: session.blockId,
+    blockVersion: session.blockVersion,
+    blockContentId: session.blockContentId,
+    origin: session.origin,
+    pageId: session.pageId,
+    workoutTimestamp: session.createdAt
+  };
+  const events = wodWikiWql.toEventRows(executionLog.logs, identity);
+  const summaries = wodWikiWql.toSummaryEventRows(executionLog.logs, identity);
+  await db.storage.transaction(["sessions", "events", "block_revisions"], "readwrite", async (tx) => {
+    const saved = await tx.readonly("sessions").get(session.id);
+    if (!saved || saved.noteId !== session.noteId || saved.blockId !== session.blockId || saved.blockVersion !== session.blockVersion) {
+      throw new Error("[wod run] Captured Session source pin changed");
+    }
+    const revision = await tx.readonly("block_revisions").get([session.noteId, session.blockId, session.blockVersion]);
+    if (!revision || !wodWikiStorage.rowsEqual(revision, started.revision)) throw new Error("[wod run] Captured revision is unavailable");
+    await tx.readwrite("sessions").put(session);
+    await tx.readwrite("events").putMany([...events, ...summaries]);
+  });
+  return { noteId: session.noteId, resultId: session.id, session, events: events.length, summaries: summaries.length, noteCreated: started.noteCreated };
+}
+async function persistSessionBundle(db, session, events) {
+  if ("segmentId" in session || "segmentVersion" in session || "version" in session || "rawContent" in session || "data" in session || !session.noteId || !session.blockId || !Number.isSafeInteger(session.blockVersion) || session.blockVersion < 1) {
+    throw new Error("[wod import] Session requires an exact block revision pin");
+  }
+  await db.storage.transaction(["sessions", "events", "block_revisions"], "readwrite", async (tx) => {
+    const revision = await tx.readonly("block_revisions").get([session.noteId, session.blockId, session.blockVersion]);
+    if (!revision || revision.kind !== "wod") throw new Error("[wod import] Exact immutable workout revision is unavailable");
+    for (const event of events) {
+      if (event.resultId !== session.id || event.noteId !== session.noteId || event.blockId !== session.blockId || event.blockVersion !== session.blockVersion) {
+        throw new Error("[wod import] Event source pin differs from Session source pin");
+      }
+    }
+    const existing = await tx.readonly("sessions").get(session.id);
+    if (existing && !wodWikiStorage.rowsEqual(existing, session)) throw new Error("[wod import] Session identity conflicts with existing row");
+    if (!existing) await tx.readwrite("sessions").put(session);
+    for (const event of events) {
+      const old = await tx.readonly("events").get(event.id);
+      if (old && !wodWikiStorage.rowsEqual(old, event)) throw new Error("[wod import] Event identity conflicts with existing row");
+      if (!old) await tx.readwrite("events").put(event);
+    }
+  });
+  return { events: events.length };
+}
+async function persistEffort(db, effort) {
+  const sql = await loadSql();
+  await db.db.transaction(async (tx) => {
+    await sql.putRow(tx, sql.storeDefinition("efforts"), effort);
+  });
+}
+async function persistTypedTags(db, labels, type) {
+  return db.storage.transaction(["tags"], "readwrite", async (tx) => {
+    let added = 0;
+    for (const raw of labels) {
+      const label = raw.trim();
+      if (!label) continue;
+      const tag = (await tx.readonly("tags").getAllFromIndex("by-label", label))[0];
+      if (!tag) {
+        await tx.readwrite("tags").put({ id: uuid5(CLI_UUID_NAMESPACE, `tag:${label}`), label, type, createdAt: Date.now() });
+        added++;
+      } else if (!tag.type) {
+        await tx.readwrite("tags").put({ ...tag, type });
+      }
+    }
+    return added;
+  });
+}
+
+// src/cli/seed.ts
+init_db();
+async function importSeedDir(db, dir, sourceId) {
+  const fs = nodeFs(), path = nodePath();
+  const source = sourceId || path.basename(dir);
+  const manifest = wodWikiEngine.assertSeedManifest(JSON.parse(fs.readFileSync(path.resolve(dir, "manifest.json"), "utf-8")));
+  const key = wodWikiEngine.seedMetaKey(source);
+  let expected = await db.storage.readonly("meta").get(key);
+  if (expected && expected.schema !== wodWikiEngine.SEED_SCHEMA) throw new Error("Incompatible seed checkpoint; recreate storage");
+  let meta = expected ?? wodWikiEngine.emptySeedMeta(key);
+  if (manifest.version < meta.seedVersion) throw new Error("Seed manifest is older than stored checkpoint");
+  const summary = { sourceId: source, version: manifest.version, notes: 0, efforts: 0, blocks: 0, blockEfforts: 0, deleted: 0, skippedUserOwned: 0 };
+  const metadataChanged = manifest.version !== meta.seedVersion || manifest.builtAt !== meta.builtAt;
+  const plan = manifest.chunks.filter((c) => metadataChanged || meta.chunks[c.id]?.sha256 !== c.sha256);
+  plan.sort((a, b) => Number(b.id === wodWikiEngine.CANVAS_CHUNK_ID) - Number(a.id === wodWikiEngine.CANVAS_CHUNK_ID));
+  const accumulate = (result) => {
+    summary.notes += result.totalNotes;
+    summary.efforts += result.totalEfforts;
+    summary.blocks += result.totalBlocks;
+    summary.deleted += result.deleted;
+    summary.skippedUserOwned += result.skippedUserOwned;
+  };
+  for (const chunk of plan) {
+    const rows = wodWikiEngine.assertSeedRows(JSON.parse(fs.readFileSync(path.resolve(dir, chunk.path), "utf-8")));
+    if (rows.length !== chunk.count) throw new Error("Seed chunk count mismatch");
+    const next = { ...meta, chunks: { ...meta.chunks, [chunk.id]: { sha256: chunk.sha256, noteIds: await Promise.all(rows.map((r) => wodWikiEngine.seedNoteId(r.path))) } }, importedAt: Date.now() };
+    accumulate(await wodWikiEngine.applySeedChunk(db.storage, { chunkId: chunk.id, rows, manifest, expectedMeta: expected, meta: next }));
+    summary.blockEfforts += rows.reduce((count, row) => count + row.blockEfforts.length, 0);
+    meta = next;
+    expected = next;
+  }
+  for (const chunkId of Object.keys(meta.chunks)) {
+    if (manifest.chunks.some((c) => c.id === chunkId)) continue;
+    const chunks = { ...meta.chunks };
+    delete chunks[chunkId];
+    const next = { ...meta, chunks, importedAt: Date.now() };
+    accumulate(await wodWikiEngine.applySeedChunk(db.storage, { chunkId, rows: [], manifest, expectedMeta: expected, meta: next }));
+    meta = next;
+    expected = next;
+  }
+  if (plan.length || metadataChanged || Object.keys(meta.chunks).length !== Object.keys(expected?.chunks ?? {}).length) {
+    const next = { ...meta, schema: wodWikiEngine.SEED_SCHEMA, seedVersion: manifest.version, builtAt: manifest.builtAt, importedAt: Date.now() };
+    await wodWikiEngine.applySeedChunk(db.storage, { chunkId: null, rows: [], manifest, expectedMeta: expected, meta: next });
+  }
+  return summary;
+}
+function defaultSeedDirs(cwd) {
+  const base = nodePath().resolve(cwd, "apps", "playground", "public", "seed");
+  return ["core", "community"].map((id) => nodePath().resolve(base, id)).filter((dir) => nodeFs().existsSync(nodePath().resolve(dir, "manifest.json")));
+}
+
+// src/cli/formatters.ts
+function escapeCsvField(field) {
+  if (field === void 0 || field === null) return "";
+  const str = String(field);
+  if (str.includes(",") || str.includes('"') || str.includes("\n") || str.includes("\r")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function formatDate(ts) {
+  if (!ts) return "-";
+  try {
+    return new Date(ts).toISOString();
+  } catch {
+    return String(ts);
+  }
+}
+function formatMetricValue(m) {
+  if (m.image) return m.image;
+  if (m.value === void 0 || m.value === null) return "";
+  if (typeof m.value === "object") return JSON.stringify(m.value);
+  return String(m.value);
+}
+function formatMetric(m) {
+  const t = m.type || "metric";
+  return `${t}:${formatMetricValue(m)}`;
+}
+function formatParseOutput(ir, format, pretty = true) {
+  if (format === "json") {
+    return JSON.stringify(ir, null, pretty ? 2 : void 0);
+  }
+  const flatNodes = [];
+  const walk = (node) => {
+    flatNodes.push(node);
+    for (const child of node.children ?? []) {
+      walk(child);
+    }
+  };
+  walk(ir.data);
+  if (format === "csv") {
+    const header = "id,type,from,to,raw,metrics,hints";
+    const rows = flatNodes.map(
+      (n) => [
+        n.id,
+        n.type,
+        n.from,
+        n.to,
+        escapeCsvField(n.raw),
+        escapeCsvField(n.metrics.map(formatMetric).join("; ")),
+        escapeCsvField(n.hints?.join("; ") ?? "")
+      ].join(",")
+    );
+    return [header, ...rows].join("\n");
+  }
+  const lines = [];
+  lines.push(`Parse Tree (${flatNodes.length} statements):`);
+  lines.push("\u2500".repeat(80));
+  lines.push(
+    ["ID".padEnd(6), "Type".padEnd(12), "Span".padEnd(12), "Hints".padEnd(20), "Raw Text"].join(" | ")
+  );
+  lines.push("\u2500".repeat(80));
+  for (const n of flatNodes) {
+    const span = `${n.from}-${n.to}`;
+    const hints = (n.hints ?? []).join(", ");
+    lines.push(
+      [
+        String(n.id).padEnd(6),
+        n.type.padEnd(12),
+        span.padEnd(12),
+        (hints.length > 18 ? hints.slice(0, 15) + "..." : hints).padEnd(20),
+        n.raw.replace(/\n/g, "\\n")
+      ].join(" | ")
+    );
+  }
+  return lines.join("\n");
+}
+function formatExecutionOutput(ir, format, pretty = true) {
+  if (format === "json") {
+    return JSON.stringify(ir, null, pretty ? 2 : void 0);
+  }
+  const { results, logs } = ir.data;
+  const statements = logs;
+  if (format === "csv") {
+    const header = "id,outputType,started,ended,sourceBlockKey,stackLevel,completionReason,metrics,hints";
+    const rows = statements.map(
+      (s) => [
+        s.id,
+        s.outputType,
+        s.timeSpan?.started ?? s.timestamp ?? 0,
+        s.timeSpan?.ended ?? "",
+        escapeCsvField(s.sourceBlockKey),
+        s.stackLevel,
+        escapeCsvField(s.completionReason ?? ""),
+        escapeCsvField(s.metrics.map(formatMetric).join("; ")),
+        escapeCsvField(s.hints?.join("; ") ?? "")
+      ].join(",")
+    );
+    return [header, ...rows].join("\n");
+  }
+  const lines = [];
+  lines.push(`Workout Execution Results:`);
+  lines.push(`  Duration:  ${results.duration}ms`);
+  lines.push(`  Completed: ${results.completed ? "yes" : "no"}`);
+  lines.push(`  Start:     ${formatDate(results.startTime)}`);
+  lines.push(`  End:       ${formatDate(results.endTime)}`);
+  lines.push(`  Logs:      ${statements.length} statements emitted`);
+  lines.push("\u2500".repeat(80));
+  lines.push(
+    ["ID".padEnd(8), "Type".padEnd(12), "Block".padEnd(18), "Reason".padEnd(15), "Metrics"].join(" | ")
+  );
+  lines.push("\u2500".repeat(80));
+  for (const s of statements) {
+    const metricsStr = s.metrics.map(formatMetric).join(", ");
+    lines.push(
+      [
+        String(s.id).padEnd(8),
+        (s.outputType ?? "segment").padEnd(12),
+        (s.sourceBlockKey ?? "-").padEnd(18),
+        (s.completionReason ?? "-").padEnd(15),
+        metricsStr
+      ].join(" | ")
+    );
+  }
+  return lines.join("\n");
+}
+function formatQueryOutput(ir, format, pretty = true) {
+  if (format === "json") {
+    return JSON.stringify(ir, null, pretty ? 2 : void 0);
+  }
+  const kind = ir.kind;
+  if (kind === "rows-result") {
+    const data2 = ir.data;
+    if (format === "csv") {
+      const header = "resultId,timestamp,outputType,eventId,metrics";
+      const rows = [];
+      for (const run of data2.runs) {
+        for (const event of run.events) {
+          rows.push(
+            [
+              run.resultId,
+              run.timestamp,
+              event.outputType,
+              event.id,
+              escapeCsvField(event.metrics.map(formatMetric).join("; "))
+            ].join(",")
+          );
+        }
+      }
+      return [header, ...rows].join("\n");
+    }
+    const lines2 = [];
+    lines2.push(`Rows Query Result (${data2.runs.length} runs):`);
+    if (data2.error) lines2.push(`Error: ${data2.error}`);
+    lines2.push("\u2500".repeat(80));
+    lines2.push(
+      ["Result ID".padEnd(20), "Date".padEnd(24), "Events"].join(" | ")
+    );
+    lines2.push("\u2500".repeat(80));
+    for (const run of data2.runs) {
+      lines2.push(
+        [
+          run.resultId.padEnd(20),
+          formatDate(run.timestamp).padEnd(24),
+          String(run.events.length)
+        ].join(" | ")
+      );
+    }
+    return lines2.join("\n");
+  }
+  if (kind === "find-result") {
+    const data2 = ir.data;
+    if (format === "csv") {
+      const header = "target,id,title_or_label,sourceId";
+      const rows = [];
+      for (const n of data2.notes) {
+        rows.push(["note", n.id, escapeCsvField(n.title), escapeCsvField(n.sourceId ?? "")].join(","));
+      }
+      for (const b of data2.blocks) {
+        rows.push(["block", b.id, escapeCsvField(b.noteTitle), escapeCsvField(b.sourceId ?? "")].join(","));
+      }
+      for (const e of data2.efforts ?? []) {
+        rows.push(["effort", e.id, escapeCsvField(e.label), escapeCsvField(e.slug)].join(","));
+      }
+      return [header, ...rows].join("\n");
+    }
+    const lines2 = [];
+    const matchedCount2 = data2.stages?.matched ?? 0;
+    const selectedCount = data2.stages?.selected ?? 0;
+    lines2.push(`Find Result (matched: ${matchedCount2} / selected: ${selectedCount}):`);
+    lines2.push("\u2500".repeat(80));
+    lines2.push(["Type".padEnd(8), "ID".padEnd(24), "Title / Label".padEnd(30), "Source ID"].join(" | "));
+    lines2.push("\u2500".repeat(80));
+    for (const n of data2.notes) {
+      lines2.push(["note".padEnd(8), n.id.padEnd(24), n.title.padEnd(30), n.sourceId ?? "-"].join(" | "));
+    }
+    for (const b of data2.blocks) {
+      lines2.push(["block".padEnd(8), b.id.padEnd(24), b.noteTitle.padEnd(30), b.sourceId ?? "-"].join(" | "));
+    }
+    for (const e of data2.efforts ?? []) {
+      lines2.push(["effort".padEnd(8), e.id.padEnd(24), e.label.padEnd(30), e.slug].join(" | "));
+    }
+    return lines2.join("\n");
+  }
+  if (kind === "pipeline-result") {
+    const data2 = ir.data;
+    const sink = data2.chart ? `:${data2.chart.head}` : "data";
+    if (format === "csv") {
+      const header = "series,timestamp,date,value,unit";
+      const rows = [];
+      for (const s of data2.series ?? []) {
+        for (const pt of s.points) {
+          rows.push(
+            [
+              escapeCsvField(s.label || s.key),
+              pt.ts,
+              formatDate(pt.ts),
+              pt.value,
+              escapeCsvField(s.unit ?? data2.unit ?? "")
+            ].join(",")
+          );
+        }
+      }
+      return [header, ...rows].join("\n");
+    }
+    const lines2 = [];
+    if (data2.error) lines2.push(`Pipeline Error: ${data2.error}`);
+    lines2.push(`Pipeline Result (\u2192 ${sink}):`);
+    lines2.push("\u2500".repeat(80));
+    if (data2.table) {
+      lines2.push(`Table: ${data2.table.rows.length} of ${data2.table.totalCount} rows`);
+    }
+    for (const s of data2.series ?? []) {
+      lines2.push(`${s.label || s.key}: ${s.points.length} points${s.unit ? ` (${s.unit})` : ""}`);
+    }
+    if (data2.notes?.length) lines2.push(`notes: ${data2.notes.length}`);
+    if (data2.blocks?.length) lines2.push(`blocks: ${data2.blocks.length}`);
+    if (data2.efforts?.length) lines2.push(`efforts: ${data2.efforts.length}`);
+    if (data2.runs?.length) lines2.push(`runs: ${data2.runs.length}`);
+    return lines2.join("\n");
+  }
+  const data = ir.data;
+  if (data.scalar !== void 0 && data.series.length === 0) {
+    if (format === "csv") {
+      return `metric,scalar,unit
+${escapeCsvField(data.parsed.metric)},${data.scalar},${escapeCsvField(data.unit ?? "")}`;
+    }
+    return `Scalar Result: ${data.scalar}${data.unit ? " " + data.unit : ""}`;
+  }
+  if (format === "csv") {
+    const header = "series,timestamp,date,value,unit";
+    const rows = [];
+    for (const s of data.series) {
+      for (const pt of s.points) {
+        rows.push(
+          [
+            escapeCsvField(s.label || s.key),
+            pt.ts,
+            formatDate(pt.ts),
+            pt.value,
+            escapeCsvField(s.unit ?? data.unit ?? "")
+          ].join(",")
+        );
+      }
+    }
+    return [header, ...rows].join("\n");
+  }
+  const lines = [];
+  const matchedCount = data.stages?.matched ?? data.stages?.selected ?? data.matched?.length ?? 0;
+  lines.push(`Query Result (${data.series.length} series, ${matchedCount} matched facts):`);
+  lines.push(
+    ["Series / Group".padEnd(20), "Timestamp".padEnd(16), "Date".padEnd(24), "Value".padEnd(12), "Unit"].join(" | ")
+  );
+  lines.push("\u2500".repeat(80));
+  for (const s of data.series) {
+    for (const pt of s.points) {
+      lines.push(
+        [
+          (s.label || s.key).padEnd(20),
+          String(pt.ts).padEnd(16),
+          formatDate(pt.ts).padEnd(24),
+          String(pt.value).padEnd(12),
+          s.unit ?? data.unit ?? "-"
+        ].join(" | ")
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/version.ts
+var VERSION = "0.36.2133";
+
+// src/cli/runner.ts
+function getFs2() {
+  if (typeof globalThis.process?.versions?.node === "undefined" && typeof globalThis.Bun === "undefined") {
+    throw new Error("File system operations are only supported in Node / Bun environments");
+  }
+  return __require("fs");
+}
+function cliNoteSource(source, label, sport) {
+  if (/\.(?:md|markdown)$/i.test(label) || wodWikiCore.parseDocumentSections(source).some((section) => section.scriptBlock)) return source;
+  let length = 3;
+  for (const match of source.matchAll(/`+/g)) length = Math.max(length, match[0].length + 1);
+  const fence = "`".repeat(length);
+  return `${fence}time${sport ? `:${sport}` : ""}
+${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++;
+    } else if (arg === "--version" || arg === "-v") {
+      result.version = true;
+      i++;
+    } else if (arg === "--corpus" || arg === "-c") {
+      result.corpus = args[++i];
+      i++;
+    } else if (arg === "--stdin-log") {
+      result.stdinLog = true;
+      i++;
+    } else if (arg === "--stdin-facts") {
+      result.stdinFacts = true;
+      i++;
+    } else if (arg === "--format") {
+      const fmt = args[++i];
+      if (fmt === "json" || fmt === "table" || fmt === "csv") {
+        result.format = fmt;
+      }
+      i++;
+    } else if (arg.startsWith("--format=")) {
+      const fmt = arg.slice("--format=".length);
+      if (fmt === "json" || fmt === "table" || fmt === "csv") {
+        result.format = fmt;
+      }
+      i++;
+    } else if (arg === "-o" || arg === "--output") {
+      result.output = args[++i];
+      i++;
+    } else if (arg.startsWith("--output=")) {
+      result.output = arg.slice("--output=".length);
+      i++;
+    } else if (arg === "--pack") {
+      const packSpec = args[++i];
+      if (packSpec) result.packs.push(packSpec);
+      i++;
+    } else if (arg.startsWith("--pack=")) {
+      result.packs.push(arg.slice("--pack=".length));
+      i++;
+    } else if (arg === "--sport") {
+      result.sport = args[++i];
+      i++;
+    } else if (arg === "--unit") {
+      result.unit = args[++i];
+      i++;
+    } else if (arg === "--debug") {
+      result.debug = "";
+      i++;
+    } else if (arg.startsWith("--debug=")) {
+      result.debug = arg.slice("--debug=".length);
+      i++;
+    } else if (arg === "--source") {
+      const source = args[++i];
+      if (source) result.sources.push(source);
+      i++;
+    } else if (arg.startsWith("--source=")) {
+      result.sources.push(arg.slice("--source=".length));
+      i++;
+    } else if (arg === "--scaffold") {
+      result.scaffold = true;
+      i++;
+    } else if (arg === "--template") {
+      result.template = args[++i];
+      i++;
+    } else if (arg.startsWith("--template=")) {
+      result.template = arg.slice("--template=".length);
+      i++;
+    } else if (arg === "--out") {
+      result.output = args[++i];
+      i++;
+    } else if (arg.startsWith("--out=")) {
+      result.output = arg.slice("--out=".length);
+      i++;
+    } else if (arg === "--dir") {
+      result.dir = args[++i];
+      i++;
+    } else if (arg.startsWith("--dir=")) {
+      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 === "init" || arg === "server" || arg === "serve" || arg === "playground" || arg === "help" || arg === "version") {
+        result.subcommand = arg;
+      } else {
+        result.target = arg;
+      }
+      i++;
+    } else if (!result.target) {
+      result.target = arg;
+      i++;
+    } else if (!result.target2) {
+      result.target2 = arg;
+      i++;
+    } else {
+      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 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;
+      }
+    }
+  }
+  return void 0;
+}
+async function readStdin() {
+  const bunText = readBunStdinText();
+  if (bunText) return bunText();
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    process.stdin.on("end", () => {
+      resolve2(Buffer.concat(chunks).toString("utf-8"));
+    });
+    process.stdin.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+function getUsageText() {
+  return `
+wod CLI \u2014 Headless Whiteboard Language & WQL Engine runner (v${VERSION})
+
+USAGE:
+  wod parse <file | -> [options]
+  wod run <file | -> [options]
+  wod query '<wql-string>' [options]
+  wod download <note|session|effort|equipment> <id> [options]
+  wod import <note|session|effort|equipment> <file> [options]
+  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
+                     (whole source + saved revisions + sparse block index), optionally emit parse-tree IR.
+                     Markdown carrying a 'wod-note-id' frontmatter stamp
+                     (see download) imports back into that same note.
+  run <file | ->      Execute the script state machine, record a session +
+                     event/summary rows in the database, optionally emit
+                     execution-log IR
+  query '<wql>'       Evaluate WQL against the database (or an explicit
+                     dataset) and emit QueryResult / RowsQueryResult IR
+  download note <id>  Export the note's authored markdown to <id>.md.
+                     The frontmatter identity stamp allows re-import.
+                     Frontmatter tags (general + typed equipment/quality/\u2026)
+                     are materialized into the tag graph on parse/import.
+  download session <id>
+                     Write the session's generated metrics (event + summary
+                     rows, one CSV row per metric) to <id>.csv. Import back
+                     with 'wod import session'.
+  download effort <slug>
+                     Write the effort registry row as corpus-style markdown
+                     (frontmatter id/slug/label/aliases/baseAttributes + body)
+                     to <slug>.md. Import back with 'wod import effort'.
+  download equipment
+                     Write every equipment tag as a one-column CSV to
+                     equipment.csv. Import back with 'wod import equipment'.
+  import note <file>  Re-import exported note markdown (same as parse with
+                     the stamped identity).
+  import session <file>
+                     Import a session + its events from a downloaded CSV.
+                     The exact saved block revision must already exist.
+  import effort <file>
+                     Upsert an effort registry row from corpus-style markdown.
+  import equipment <file>
+                     Create/upgrade equipment tags (CSV, one label per row).
+  build [dir]         Compile a seed corpus: validate every .md under
+                     <dir>/markdown (parity gate + dashboard format gate) and
+                     write manifest.json + content-hashed chunks/ +
+                     report.html to <dir>/dist with source/maps/projections bundled
+                     (override with -o/--output). Version stamps derive from
+                     <dir>'s git history (full checkout required).
+
+BUILD OPTIONS (for 'build'):
+  --scaffold          Also scaffold markdown/efforts/discovered/*.md stubs for
+                      workout effort labels missing from the registry.
+  --template <file>   Compile an extra markdown file as the 'template' chunk
+                      (the host's playground intake template).
+
+INPUT SOURCING (for 'query'; without these, the database is queried):
+  -c, --corpus <path> Load historical corpus dataset from a versioned JSON file
+  --stdin-log         Read kind: 'execution-log' JSON payload from stdin
+  --stdin-facts       Read raw kind: 'fact-set' JSON payload from stdin
+
+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);
+                      repeatable. Defaults to the bundled core + community
+                      artifacts under apps/playground/public/seed.
+
+OPTIONS:
+  --format <fmt>      Output format: json (default), table, csv
+  -o, --output <path> Write the IR payload (or download) to a path instead of
+                      the default; '-' writes to stdout
+  --debug[=name]      Also write the IR payload to <name> (default
+                      wod-<subcommand>-debug.json); without it, parse/run
+                      print a one-line summary of what was persisted
+  --pack <module>     Dynamically load and register a Language Pack (repeatable)
+  --sport <sport>     Target sport fence dialect (e.g. climbing, crossfit)
+  --unit <unit>       Preferred display unit for queries (e.g. lb, kg)
+  -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
+  2 - Parse / Syntax error
+  3 - Language Pack load error
+`;
+}
+function printUsage(writer) {
+  const text = getUsageText();
+  if (writer) {
+    writer(text);
+  } else {
+    process.stdout.write(text.endsWith("\n") ? text : text + "\n");
+  }
+}
+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);
+  } catch (error) {
+    writeErr(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (parsed.version || parsed.subcommand === "version") {
+    writeOut(`wod v${VERSION}`);
+    return 0;
+  }
+  if (parsed.help || parsed.subcommand === "help") {
+    printUsage(writeOut);
+    return 0;
+  }
+  if (!parsed.subcommand) {
+    printUsage(writeErr);
+    return 1;
+  }
+  for (const packSpec of parsed.packs) {
+    try {
+      await loadLanguagePack(packSpec);
+    } catch (err) {
+      if (err instanceof PackLoadError) {
+        writeErr(err.message);
+      } else {
+        writeErr(`[wod] Language pack load error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      return 3;
+    }
+  }
+  const deliverOutput = (formattedText) => {
+    if (parsed.output && parsed.output !== "-") {
+      getFs2().writeFileSync(parsed.output, formattedText, "utf-8");
+    } else {
+      writeOut(formattedText);
+    }
+  };
+  const debugTarget = (subcommand) => parsed.debug === void 0 ? void 0 : parsed.debug || `wod-${subcommand}-debug.json`;
+  const writeDebugFile = (subcommand, ir) => {
+    const target = debugTarget(subcommand);
+    if (target !== void 0) {
+      getFs2().writeFileSync(target, JSON.stringify(ir, null, 2) + "\n", "utf-8");
+    }
+  };
+  try {
+    if (parsed.subcommand === "parse") {
+      if (!parsed.target) {
+        writeErr('[wod parse] Error: Missing input file or "-" for stdin');
+        return 1;
+      }
+      let source;
+      if (parsed.target === "-") {
+        source = await getStdin();
+      } else {
+        const fs = getFs2();
+        if (!fs.existsSync(parsed.target)) {
+          writeErr(`[wod parse] File not found: ${parsed.target}`);
+          return 1;
+        }
+        source = fs.readFileSync(parsed.target, "utf-8");
+      }
+      const noteSource = cliNoteSource(source, parsed.target, parsed.sport);
+      const ir = runParse(source, { sport: parsed.sport, sourceLabel: `cli:wod parse ${parsed.target}` });
+      const identity = wodWikiEngine.extractNoteIdentity(source);
+      const tags = wodWikiEngine.extractTypedTags(source);
+      const db = await openCliDb(cliDb());
+      try {
+        const persisted = await persistNote(db, {
+          source: noteSource,
+          sourceLabel: parsed.target,
+          noteId: identity?.noteId,
+          title: identity?.title,
+          tags
+        });
+        writeOut(
+          `[wod parse] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.blocks} blocks, ${persisted.efforts} efforts${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db.path}`
+        );
+      } finally {
+        await db.close();
+      }
+      if (parsed.output) {
+        const pretty = Boolean(process.stdout.isTTY);
+        deliverOutput(formatParseOutput(ir, parsed.format, pretty));
+      }
+      writeDebugFile("parse", ir);
+      return 0;
+    }
+    if (parsed.subcommand === "run") {
+      if (!parsed.target) {
+        writeErr('[wod run] Error: Missing input file or "-" for stdin');
+        return 1;
+      }
+      let source;
+      if (parsed.target === "-") {
+        source = await getStdin();
+      } else {
+        const fs = getFs2();
+        if (!fs.existsSync(parsed.target)) {
+          writeErr(`[wod run] File not found: ${parsed.target}`);
+          return 1;
+        }
+        source = fs.readFileSync(parsed.target, "utf-8");
+      }
+      const identity = wodWikiEngine.extractNoteIdentity(source);
+      const db = await openCliDb(cliDb());
+      let ir;
+      try {
+        const started = await startRun(db, {
+          source: cliNoteSource(source, parsed.target, parsed.sport),
+          sourceLabel: parsed.target,
+          noteId: identity?.noteId,
+          title: identity?.title,
+          tags: wodWikiEngine.extractTypedTags(source)
+        });
+        const section = wodWikiCore.parseDocumentSections(started.revision.rawContent).find((row) => row.scriptBlock);
+        if (!section?.scriptBlock) throw new Error("[wod run] Captured workout source cannot be parsed");
+        const bare = !/\.(?:md|markdown)$/i.test(parsed.target) && !wodWikiCore.parseDocumentSections(source).some((row) => row.scriptBlock);
+        const frozenBody = bare ? section.scriptBlock.content.slice(0, -1) : section.scriptBlock.content;
+        ir = await runExecution(frozenBody, {
+          sport: started.revision.sport,
+          dialect: started.revision.dialect,
+          blockId: started.session.blockId,
+          blockVersion: started.session.blockVersion,
+          startTime: started.session.startTime,
+          sourceLabel: `cli:wod run ${parsed.target}`
+        });
+        const persisted = await persistRun(db, started, ir.data);
+        writeOut(
+          `[wod run] session ${persisted.resultId} \u2014 ${persisted.events} events, ${persisted.summaries} summaries on note ${persisted.noteId} \u2192 ${db.path}`
+        );
+      } finally {
+        await db.close();
+      }
+      if (parsed.output) {
+        const pretty = Boolean(process.stdout.isTTY);
+        deliverOutput(formatExecutionOutput(ir, parsed.format, pretty));
+      }
+      writeDebugFile("run", ir);
+      return 0;
+    }
+    if (parsed.subcommand === "query") {
+      if (!parsed.target) {
+        writeErr("[wod query] Error: Missing WQL query argument");
+        return 1;
+      }
+      const useDb = !parsed.corpus && !parsed.stdinLog && !parsed.stdinFacts;
+      let stdinLogContent;
+      let stdinFactsContent;
+      if (parsed.stdinLog) {
+        stdinLogContent = await getStdin();
+      } else if (parsed.stdinFacts) {
+        stdinFactsContent = await getStdin();
+      }
+      let ir;
+      if (useDb) {
+        const config = cliDb();
+        if (config.kind === "sqlite" && !nodeFs().existsSync(config.path)) {
+          writeErr(
+            `[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(config, config.kind === "sqlite" ? void 0 : { initialize: false });
+        try {
+          ir = await runQueryCli(parsed.target, {
+            preferredUnit: parsed.unit,
+            sourceLabel: `cli:wod query "${parsed.target}"`,
+            stores: {
+              eventStore: sqliteEventStore(db.db),
+              noteStore: sqliteNoteStore(db.db),
+              blockStore: sqliteBlockStore(db.db),
+              effortStore: sqliteEffortStore(db.db),
+              blockEffortsStore: sqliteIndexStore(db.db, "block_efforts"),
+              tagsStore: sqliteIndexStore(db.db, "tags"),
+              noteTagsStore: sqliteIndexStore(db.db, "note_tags")
+            }
+          });
+        } finally {
+          await db.close();
+        }
+      } else {
+        if (!parsed.corpus && !stdinLogContent && !stdinFactsContent) {
+          writeErr("[wod query] Error: Query requires input data. Specify --corpus <file>, --stdin-log, or --stdin-facts.");
+          return 1;
+        }
+        ir = await runQueryCli(parsed.target, {
+          corpusPath: parsed.corpus,
+          stdinLog: stdinLogContent,
+          stdinFacts: stdinFactsContent,
+          preferredUnit: parsed.unit,
+          sourceLabel: `cli:wod query "${parsed.target}"`
+        });
+      }
+      const pretty = !parsed.output && Boolean(process.stdout.isTTY);
+      const formatted = formatQueryOutput(ir, parsed.format, pretty);
+      deliverOutput(formatted);
+      writeDebugFile("query", ir);
+      return 0;
+    }
+    if (parsed.subcommand === "download") {
+      const kind = parsed.target;
+      const id = parsed.target2;
+      const DOWNLOAD_KINDS = ["note", "session", "effort", "equipment"];
+      if (!id && kind !== "equipment" || !DOWNLOAD_KINDS.includes(kind ?? "")) {
+        writeErr("[wod download] Usage: wod download <note|session|effort|equipment> <id> [-o <path>]");
+        return 1;
+      }
+      const targetId = id;
+      const db = await openCliDb(cliDb());
+      try {
+        if (kind === "note") {
+          const bundle = await getNoteBundle(db.db, targetId);
+          if (!bundle.note) {
+            writeErr(`[wod download] Note not found in ${db.path}: ${id}`);
+            return 1;
+          }
+          const markdown = wodWikiEngine.composeNoteMarkdown(bundle.note);
+          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}.md`;
+          if (parsed.output === "-") {
+            writeOut(markdown);
+          } else {
+            nodeFs().writeFileSync(target, markdown, "utf-8");
+          }
+          if (parsed.output !== "-") writeOut(`[wod download] note ${id} \u2192 ${target}`);
+        } else if (kind === "session") {
+          const bundle = await getSessionBundle(db.db, targetId);
+          if (!bundle) {
+            writeErr(`[wod download] Session not found in ${db.path}: ${id}`);
+            return 1;
+          }
+          const csv = wodWikiEngine.sessionToCsv(bundle.session, bundle.events);
+          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}.csv`;
+          if (parsed.output === "-") {
+            writeOut(csv);
+          } else {
+            nodeFs().writeFileSync(target, csv, "utf-8");
+          }
+          if (parsed.output !== "-") writeOut(`[wod download] session ${id} \u2192 ${target} (${bundle.events.length} events)`);
+        } else if (kind === "effort") {
+          const effort = await getEffortBySlug(db.db, targetId);
+          if (!effort) {
+            writeErr(`[wod download] Effort not found in ${db.path}: ${id}`);
+            return 1;
+          }
+          const markdown = wodWikiEngine.effortToMarkdown(effort);
+          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}.md`;
+          if (parsed.output === "-") {
+            writeOut(markdown);
+          } else {
+            nodeFs().writeFileSync(target, markdown, "utf-8");
+          }
+          writeOut(`[wod download] effort ${id} \u2192 ${target}`);
+        } else {
+          const labels = (await listTagsByType(db.db, "equipment")).map((t) => t.label).sort();
+          const csv = wodWikiEngine.equipmentToCsv(labels);
+          const target = parsed.output && parsed.output !== "-" ? parsed.output : "equipment.csv";
+          if (parsed.output === "-") {
+            writeOut(csv);
+          } else {
+            nodeFs().writeFileSync(target, csv, "utf-8");
+          }
+          writeOut(`[wod download] equipment \u2192 ${target} (${labels.length} labels)`);
+        }
+      } finally {
+        await db.close();
+      }
+      return 0;
+    }
+    if (parsed.subcommand === "import") {
+      const kind = parsed.target;
+      const file = parsed.target2;
+      const IMPORT_KINDS = ["note", "session", "effort", "equipment"];
+      if (!file || !IMPORT_KINDS.includes(kind ?? "")) {
+        writeErr("[wod import] Usage: wod import <note|session|effort|equipment> <file>");
+        return 1;
+      }
+      const fs = nodeFs();
+      if (!fs.existsSync(file)) {
+        writeErr(`[wod import] File not found: ${file}`);
+        return 1;
+      }
+      if (kind === "note") {
+        const source = fs.readFileSync(file, "utf-8");
+        const identity = wodWikiEngine.extractNoteIdentity(source);
+        const tags = wodWikiEngine.extractTypedTags(source);
+        const db2 = await openCliDb(cliDb());
+        try {
+          const persisted = await persistNote(db2, {
+            source,
+            sourceLabel: file,
+            noteId: identity?.noteId,
+            title: identity?.title,
+            tags
+          });
+          writeOut(
+            `[wod import] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.blocks} blocks${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db2.path}`
+          );
+        } finally {
+          await db2.close();
+        }
+        return 0;
+      }
+      if (kind === "effort") {
+        const effort = wodWikiEngine.markdownToEffort(fs.readFileSync(file, "utf-8"));
+        if (!effort) {
+          writeErr(`[wod import] Unparseable effort file (need frontmatter id/slug/label + numeric baseAttributes.met): ${file}`);
+          return 1;
+        }
+        const db2 = await openCliDb(cliDb());
+        try {
+          await persistEffort(db2, { ...effort, registrySource: "user" });
+          writeOut(`[wod import] effort ${effort.slug} \u2014 ${effort.label} \u2192 ${db2.path}`);
+        } finally {
+          await db2.close();
+        }
+        return 0;
+      }
+      if (kind === "equipment") {
+        const labels = wodWikiEngine.csvToEquipmentLabels(fs.readFileSync(file, "utf-8"));
+        if (labels.length === 0) {
+          writeErr(`[wod import] No equipment labels found in ${file}`);
+          return 1;
+        }
+        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}`);
+        } finally {
+          await db2.close();
+        }
+        return 0;
+      }
+      const { session, events } = wodWikiEngine.csvToSessionRows(fs.readFileSync(file, "utf-8"));
+      const db = await openCliDb(cliDb());
+      try {
+        const result = await persistSessionBundle(db, session, events);
+        writeOut(
+          `[wod import] session ${session.id} \u2014 ${result.events} events \u2192 ${db.path}`
+        );
+      } finally {
+        await db.close();
+      }
+      return 0;
+    }
+    if (parsed.subcommand === "build") {
+      const cwd = process.cwd();
+      const root = nodePath().resolve(cwd, parsed.dir ?? parsed.target ?? ".");
+      if (!nodeFs().existsSync(nodePath().resolve(root, "markdown"))) {
+        writeErr(`[wod build] No markdown/ corpus under ${root} \u2014 run from the content repo root (or pass its directory).`);
+        return 1;
+      }
+      const { generateSeed: generateSeed2 } = await Promise.resolve().then(() => (init_compiler(), compiler_exports));
+      try {
+        const result = generateSeed2({
+          corpusRoot: root,
+          ...parsed.output ? { outDir: nodePath().resolve(cwd, parsed.output) } : {},
+          ...parsed.template ? { templateFile: nodePath().resolve(cwd, parsed.template) } : {},
+          scaffoldDiscoveredEfforts: parsed.scaffold === true
+        });
+        const kb = (n) => `${(n / 1024).toFixed(0)} KB`;
+        const totalBytes = result.manifest.chunks.reduce((s, c) => s + c.bytes, 0);
+        writeOut(`[wod build] schema v${result.manifest.schema} version ${result.manifest.version} (${result.manifest.versionLabel}) \u2192 ${result.outDir}`);
+        for (const c of result.manifest.chunks) {
+          writeOut(`  ${c.id.padEnd(48)} ${String(c.count).padStart(4)} files  ${kb(c.bytes).padStart(8)}`);
+        }
+        writeOut(`[wod build] ${result.manifest.chunks.length} chunks, ${result.totalFiles} files, ${kb(totalBytes)} total \u2014 scan ${result.passMs.scan}ms, block-index ${result.passMs.blockIndex}ms, block-efforts ${result.passMs.blockEfforts}ms, write ${result.passMs.write}ms`);
+        return 0;
+      } catch (error) {
+        writeErr(`[wod build] ${error.message}`);
+        return 1;
+      }
+    }
+    if (parsed.subcommand === "seed") {
+      const dirs = parsed.sources.length > 0 ? parsed.sources.map((s) => nodePath().resolve(process.cwd(), s)) : defaultSeedDirs(process.cwd());
+      if (dirs.length === 0) {
+        writeErr(
+          "[wod seed] No seed sources found. Run `bun scripts/sync-seed.ts` to build the bundled artifacts, or pass --source <dir> pointing at a compiled seed directory (manifest.json + chunks)."
+        );
+        return 1;
+      }
+      const db = await openCliDb(cliDb());
+      try {
+        for (const dir of dirs) {
+          const summary = await importSeedDir(db, dir, "");
+          writeOut(
+            `[wod seed] ${summary.sourceId}: v${summary.version} \u2014 ${summary.notes} notes, ${summary.efforts} efforts, ${summary.blocks} blocks, ${summary.blockEfforts} block-efforts (${summary.deleted} deleted, ${summary.skippedUserOwned} user-owned skipped) \u2192 ${db.path}`
+          );
+        }
+      } finally {
+        await db.close();
+      }
+      return 0;
+    }
+    if (parsed.subcommand === "reset") {
+      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}`);
+      } else {
+        writeOut(`[wod reset] nothing to reset \u2014 ${target} does not exist`);
+      }
+      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) {
+    if (error instanceof ParseSyntaxError || error instanceof WqlSyntaxError) {
+      writeErr(error.message);
+      return 2;
+    }
+    if (error instanceof PackLoadError) {
+      writeErr(error.message);
+      return 3;
+    }
+    writeErr(`[wod] Error: ${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  }
+}
+
+// src/bin/wod.ts
+void (async () => {
+  const exitCode = await cliMain(process.argv.slice(2));
+  process.exitCode = exitCode;
+})();
+//# sourceMappingURL=wod.cjs.map
+//# sourceMappingURL=wod.cjs.map