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

package/dist/chunk-OZI2FYPF.mjs

@@ -0,0 +1,2061 @@
+import { createRequire } from 'module';
+import { openCliDb, nodeFs, sqliteIndexStore, sqliteEffortStore, sqliteBlockStore, sqliteNoteStore, sqliteEventStore, getNoteBundle, getSessionBundle, getEffortBySlug, listTagsByType, nodePath, loadSql, uuid5, CLI_UUID_NAMESPACE, stableNoteId, randomId } from './chunk-EUQWEX6Z.mjs';
+import { __require } from './chunk-6L5ZDZJ7.mjs';
+import { createParser, frozenNow, createCompiler, createMockClock, RuntimeStack, EventBus, ScriptRuntime, createAnalyticsEngineForBlock, StartSessionAction, NextEvent, toStoredOutputStatement, bundledEfforts, parseScript } from '@bitcobblers/wod-wiki-lang';
+import { buildStatementTree, createIRFile, registerLanguagePack, extractNoteIdentity, extractTypedTags, composeNoteMarkdown, sessionToCsv, effortToMarkdown, equipmentToCsv, markdownToEffort, csvToEquipmentLabels, csvToSessionRows, isIRFile, inMemoryEventStore, assertSeedManifest, seedMetaKey, SEED_SCHEMA, emptySeedMeta, CANVAS_CHUNK_ID, assertSeedRows, seedNoteId, applySeedChunk } from '@bitcobblers/wod-wiki-engine';
+import { toEventRows, toSummaryEventRows, parseQuery, QueryService, isPipelineQuery, isFindQuery } from '@bitcobblers/wod-wiki-wql';
+import { validateNoteBlocks, parseDocumentSections, blockContentId, reconcileNoteBlocks, KNOWN_SECTION_WIDGETS } from '@bitcobblers/wod-wiki-core';
+import { rowsEqual } from '@bitcobblers/wod-wiki-storage';
+
+if (typeof globalThis.require === 'undefined') {
+  try { globalThis.require = createRequire(import.meta.url); } catch {}
+}
+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 = createParser();
+  const script = parser.read(source, options.sport);
+  if (script.errors && script.errors.length > 0) {
+    throw new ParseSyntaxError(script.errors);
+  }
+  const tree = buildStatementTree(script);
+  return 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(toStoredOutputStatement)
+  };
+}
+async function runExecution(source, options = {}) {
+  const parser = 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 ?? frozenNow(new Date(startTime));
+  const compiler = createCompiler();
+  const clock = createMockClock(new Date(startTime));
+  const stack = new RuntimeStack();
+  const eventBus = new EventBus();
+  const runtime = new ScriptRuntime(
+    script,
+    compiler,
+    { stack, clock, eventBus },
+    {},
+    now
+  );
+  const { engine, analyticsContext } = 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 StartSessionAction());
+  const maxSteps = options.maxIterations ?? 5e3;
+  let steps = 0;
+  while (stack.count > 0 && steps < maxSteps) {
+    runtime.handle(new 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(toStoredOutputStatement);
+  return 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 (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 = 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: [...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 = [...toEventRows(corpus.logs, identity), ...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 = [
+      ...toEventRows(executionLog.logs, identity),
+      ...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");
+    }
+    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 = 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: 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 = parseQuery(wqlString);
+  if (parsed.error) {
+    throw new WqlSyntaxError(wqlString, parsed.error);
+  }
+  const stores = options.stores ?? buildStoresFromData(loadQueryData(options));
+  const service = new QueryService(stores);
+  if (isPipelineQuery(parsed)) {
+    const result2 = await service.runPipeline(wqlString, {
+      preferredUnit: options.preferredUnit
+    });
+    return createIRFile("pipeline-result", result2, { source: options.sourceLabel ?? "cli:wod query" });
+  }
+  if (isFindQuery(parsed)) {
+    const result2 = await service.runFind(parsed);
+    const kind = parsed.target === "session" ? "rows-result" : "find-result";
+    return createIRFile(kind, result2, { source: options.sourceLabel ?? "cli:wod query" });
+  }
+  const result = await service.runQuery(wqlString, {
+    preferredUnit: options.preferredUnit
+  });
+  return createIRFile("query-result", result, { source: options.sourceLabel ?? "cli:wod query" });
+}
+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, pathToFileURL } = getPathUtils();
+      const resolved = resolve(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;
+    registerLanguagePack(pack);
+    return pack;
+  } catch (error) {
+    if (error instanceof PackLoadError) throw error;
+    throw new PackLoadError(moduleSpec, error);
+  }
+}
+
+// src/cli/config.ts
+function nodeRequire() {
+  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 = () => nodeRequire()("node:path");
+var nodeFs2 = () => nodeRequire()("node:fs");
+function parseEnvFile(content) {
+  return nodeRequire()("node:util").parseEnv(content);
+}
+function loadCliEnvironment(envFile) {
+  const fs = nodeFs2();
+  const path = nodePath2();
+  let file;
+  if (envFile !== void 0) {
+    file = path.resolve(process.cwd(), envFile);
+    if (!fs.existsSync(file)) throw new Error(`[wod] --env-file: file not found: ${envFile}`);
+  } else {
+    let dir = process.cwd();
+    for (; ; ) {
+      const candidate = path.join(dir, ".env");
+      if (fs.existsSync(candidate)) {
+        file = candidate;
+        break;
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return file !== void 0 ? parseEnvFile(fs.readFileSync(file, "utf-8")) : {};
+}
+var SQLITE_URL_SCHEMES = /^(libsql|https?|wss?|file):\/\//;
+var PG_URL_SCHEMES = /^postgres(ql)?:\/\//;
+var TURSO_URL_SCHEMES = /^(libsql|https?|wss?):\/\//;
+var PG_FLAG_KEYS = [
+  "postgresHost",
+  "postgresPort",
+  "postgresUser",
+  "postgresPassword",
+  "postgresDatabase",
+  "postgresSsl"
+];
+var PG_ENV_KEYS = [
+  "POSTGRES_HOST",
+  "POSTGRES_PORT",
+  "POSTGRES_USER",
+  "POSTGRES_PASSWORD",
+  "POSTGRES_DATABASE",
+  "POSTGRES_SSL"
+];
+var isBackend = (v) => v === "sqlite" || v === "postgres" || v === "turso";
+function setEnv(v) {
+  return v !== void 0 && v.trim() !== "" ? v : void 0;
+}
+function fail(message) {
+  throw new Error(`[wod] ${message}`);
+}
+function parsePort(v, source) {
+  if (!/^\d+$/.test(v)) fail(`${source} must be an integer 1..65535, got ${JSON.stringify(v)}`);
+  const port = Number(v);
+  if (port < 1 || port > 65535) fail(`${source} must be an integer 1..65535, got ${v}`);
+  return port;
+}
+function sslMode(v, source) {
+  if (v === void 0 || v === "") return "prefer";
+  if (typeof v === "boolean") return v ? "require" : "disable";
+  const s = v.trim().toLowerCase();
+  if (["true", "1", "yes", "require"].includes(s)) return "require";
+  if (["false", "0", "no", "disable", "disabled"].includes(s)) return "disable";
+  if (s === "prefer" || s === "verify-ca" || s === "verify-full") return s;
+  fail(`${source} must be disable|prefer|require|verify-ca|verify-full, got ${JSON.stringify(v)}`);
+}
+function safeUrlLabel(raw) {
+  try {
+    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/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");
+}
+var registeredWidgets = 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 = reconcileNoteBlocks(options.source, {
+      sourceRevision,
+      blocks: options.blocks ?? (existing?.rawContent === options.source ? existing.blocks : void 0),
+      registeredWidgets,
+      createId: randomId
+    });
+    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 && !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 = parseDocumentSections(rawContent, { registeredWidgets })[0]?.displayContent ?? rawContent;
+      const fingerprint = block.kind === "wod" ? 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(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 (!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: blockContentId(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 (!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 (!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 (!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 = toEventRows(executionLog.logs, identity);
+  const summaries = 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 || !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 && !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 && !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;
+  });
+}
+async function importSeedDir(db, dir, sourceId) {
+  const fs = nodeFs(), path = nodePath();
+  const source = sourceId || path.basename(dir);
+  const manifest = assertSeedManifest(JSON.parse(fs.readFileSync(path.resolve(dir, "manifest.json"), "utf-8")));
+  const key = seedMetaKey(source);
+  let expected = await db.storage.readonly("meta").get(key);
+  if (expected && expected.schema !== SEED_SCHEMA) throw new Error("Incompatible seed checkpoint; recreate storage");
+  let meta = expected ?? 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 === CANVAS_CHUNK_ID) - Number(a.id === 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 = 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) => seedNoteId(r.path))) } }, importedAt: Date.now() };
+    accumulate(await 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 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: SEED_SCHEMA, seedVersion: manifest.version, builtAt: manifest.builtAt, importedAt: Date.now() };
+    await 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/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) || 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 bun = g.Bun;
+    if (bun && typeof bun === "object" && "stdin" in bun) {
+      const stdin = bun.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((resolve, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    process.stdin.on("end", () => {
+      resolve(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 = extractNoteIdentity(source);
+      const tags = 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 = 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: extractTypedTags(source)
+        });
+        const section = 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) && !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 = 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 = 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 = 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 = 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 = extractNoteIdentity(source);
+        const tags = 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 = 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 = 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 } = 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 } = await import('./compiler-KT6P3AC6.mjs');
+      try {
+        const result = generateSeed({
+          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 } = await import('./server-Z2T7IGZX.mjs');
+      const options = { env: cliEnv() };
+      if (mode === "server") options.database = cliDb();
+      if (parsed.host !== void 0) options.host = parsed.host;
+      if (parsed.port !== void 0) options.port = parsed.port;
+      if (parsed.dist !== void 0) options.dist = parsed.dist;
+      await runCliServer(mode, options, writeOut);
+      return 0;
+    }
+    writeErr(`[wod] Unknown subcommand "${parsed.subcommand}"`);
+    return 1;
+  } catch (error) {
+    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;
+  }
+}
+
+export { PackLoadError, ParseSyntaxError, WqlSyntaxError, cliMain, formatExecutionOutput, formatParseOutput, formatQueryOutput, loadCliEnvironment, loadLanguagePack, loadQueryData, parseCliArgs, readStdin, resolveDatabaseConfig, runExecution, runParse, runQueryCli };
+//# sourceMappingURL=chunk-OZI2FYPF.mjs.map
+//# sourceMappingURL=chunk-OZI2FYPF.mjs.map