@bitcobblers/wod-wiki-engine 0.11.43 → 0.35.2115

package/dist/chunk-B2OYLNEZ.mjs

@@ -0,0 +1,2722 @@
+import { createRequire } from 'module';
+import { __require } from './chunk-6L5ZDZJ7.mjs';
+import { dialectRegistry, realtimeProcessorRegistry, summaryProcessorRegistry, getHints, createParser, toStoredOutputStatement, frozenNow, createCompiler, createMockClock, RuntimeStack, EventBus, ScriptRuntime, createAnalyticsEngineForBlock, StartSessionAction, NextEvent, bundledEfforts, parseScript } from '@bitcobblers/wod-wiki-lang';
+import { MetricType, parseDocumentSections } from '@bitcobblers/wod-wiki-core';
+import { WQL_TYPED_TAG_KEYS, toEventRows, parseQuery, QueryService, isPipelineQuery, isFindQuery, toSummaryEventRows } from '@bitcobblers/wod-wiki-wql';
+
+if (typeof globalThis.require === 'undefined') {
+  try { globalThis.require = createRequire(import.meta.url); } catch {}
+}
+var activePacks = /* @__PURE__ */ new Map();
+function defineLanguagePack(pack) {
+  return pack;
+}
+function registerLanguagePack(pack) {
+  const packId = pack.identity?.id ?? pack.identity?.name ?? "anonymous-pack";
+  activePacks.set(packId, pack);
+  if (pack.lang?.analyzer) {
+    const AnalyzerCtor = pack.lang.analyzer;
+    const instance = new AnalyzerCtor();
+    dialectRegistry.register(instance);
+  }
+  if (pack.lang?.analytics) {
+    for (const ProcessorCtor of pack.lang.analytics) {
+      const instance = new ProcessorCtor();
+      if ("processOutput" in instance) {
+        realtimeProcessorRegistry.register(instance);
+      }
+      if ("processSummary" in instance) {
+        summaryProcessorRegistry.register(instance);
+      }
+    }
+  }
+}
+function unregisterLanguagePack(packOrId) {
+  const packId = typeof packOrId === "string" ? packOrId : packOrId.identity?.id ?? packOrId.identity?.name ?? "anonymous-pack";
+  const pack = activePacks.get(packId);
+  activePacks.delete(packId);
+  if (pack?.lang?.analyzer) {
+    const instance = new pack.lang.analyzer();
+    dialectRegistry.unregister(instance.id);
+  } else if (typeof packOrId === "string") {
+    dialectRegistry.unregister(packOrId);
+  }
+  if (pack?.lang?.analytics) {
+    for (const ProcessorCtor of pack.lang.analytics) {
+      const instance = new ProcessorCtor();
+      if ("processOutput" in instance) {
+        realtimeProcessorRegistry.unregister(instance.id);
+      }
+      if ("processSummary" in instance) {
+        summaryProcessorRegistry.unregister(instance.id);
+      }
+    }
+  }
+}
+function listLanguagePacks() {
+  return Array.from(activePacks.values());
+}
+function getRegisteredLanguagePacks() {
+  return Array.from(activePacks.values());
+}
+
+// src/store.ts
+function inMemoryEventStore(events) {
+  const rows = [...events];
+  return {
+    getEventsByTimeRange: async (start, end) => rows.filter((r) => r.timestamp >= start && r.timestamp <= end),
+    getEventsByResult: async (resultId) => rows.filter((r) => r.resultId === resultId),
+    getEventsForNote: async (noteId) => rows.filter((r) => r.noteId === noteId),
+    getEventsByContent: async (blockContentId) => rows.filter((r) => r.blockContentId === blockContentId),
+    scanAll: async () => rows,
+    appendEvents: async (appended) => {
+      rows.push(...appended);
+    },
+    finalizeSummaries: async (resultId, finals) => {
+      for (let i = rows.length - 1; i >= 0; i--) {
+        const row = rows[i];
+        if (row.resultId === resultId && row.grain === "summary" && row.origin !== "user") rows.splice(i, 1);
+      }
+      rows.push(...finals);
+    },
+    deleteEvents: async (ids) => {
+      const doomed = new Set(ids);
+      for (let i = rows.length - 1; i >= 0; i--) {
+        if (doomed.has(rows[i].id)) rows.splice(i, 1);
+      }
+    }
+  };
+}
+function createIRFile(kind, data, optionsOrSource, generatedAt) {
+  let source = "wod:headless";
+  let genAt = Date.now();
+  if (typeof optionsOrSource === "string") {
+    source = optionsOrSource;
+    if (generatedAt !== void 0) genAt = generatedAt;
+  } else if (optionsOrSource && typeof optionsOrSource === "object") {
+    if (optionsOrSource.source) source = optionsOrSource.source;
+    if (optionsOrSource.generatedAt !== void 0) genAt = optionsOrSource.generatedAt;
+  }
+  return {
+    $schema: "https://wod-wiki.dev/ir/v1.json",
+    kind,
+    generatedAt: genAt,
+    source,
+    data
+  };
+}
+function isIRFile(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const cand = obj;
+  return cand.$schema === "https://wod-wiki.dev/ir/v1.json" && typeof cand.kind === "string" && typeof cand.generatedAt === "number" && typeof cand.source === "string" && "data" in cand;
+}
+function statementToNode(stmt, idMap) {
+  const meta = stmt.meta;
+  const metrics = stmt.metrics.toArray().map((m) => ({
+    type: m.type,
+    ...m.image !== void 0 ? { image: m.image } : {},
+    ...m.value !== void 0 ? { value: m.value } : {},
+    ...m.origin !== void 0 ? { origin: m.origin } : {}
+  }));
+  const raw = meta?.raw ?? "";
+  const from = meta?.startOffset ?? 0;
+  const to = meta?.endOffset ?? from + raw.length;
+  const durationFrag = stmt.metrics.find((m) => m.type === MetricType.Duration || m.type === "duration");
+  const roundsFrag = stmt.metrics.find((m) => m.type === MetricType.Rounds || m.type === "rounds");
+  const type = durationFrag ? "duration" : roundsFrag ? "rounds" : "statement";
+  const hints = getHints(stmt);
+  const childIds = (stmt.children ?? []).flat();
+  const children = childIds.map((cid) => idMap.get(cid)).filter((c) => c !== void 0).map((c) => statementToNode(c, idMap));
+  return {
+    id: stmt.id,
+    type,
+    raw,
+    from,
+    to,
+    metrics,
+    ...hints.length > 0 ? { hints } : {},
+    ...children.length > 0 ? { children } : {}
+  };
+}
+function buildStatementTree(script) {
+  const idMap = new Map(script.statements.map((s) => [s.id, s]));
+  const topLevel = script.statements.filter((s) => s.parent === void 0 || !idMap.has(s.parent));
+  if (topLevel.length === 1 && topLevel[0].children.length > 0) {
+    return statementToNode(topLevel[0], idMap);
+  }
+  return {
+    id: 0,
+    type: "root",
+    raw: script.source,
+    from: 0,
+    to: script.source.length,
+    metrics: [],
+    children: topLevel.map((s) => statementToNode(s, idMap))
+  };
+}
+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: "cli-block",
+    content: source,
+    statements: script.statements,
+    sport: options.sport,
+    version: 1,
+    startLine: 0,
+    endLine: 0,
+    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
+    },
+    { 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 legacyLogsOf(result) {
+  const legacy = result;
+  return legacy.data?.logs ?? [];
+}
+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 identity = (r) => ({
+    noteId: r.noteId,
+    resultId: r.id,
+    segmentId: r.segmentId,
+    segmentVersion: r.segmentVersion,
+    blockContentId: r.blockContentId,
+    origin: r.origin,
+    pageId: r.pageId,
+    workoutTimestamp: r.createdAt
+  });
+  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"
+      }],
+      segmentId: f.segmentId,
+      segmentVersion: f.segmentVersion
+    })),
+    ...data.results.flatMap((r) => {
+      const logs = legacyLogsOf(r);
+      return [...toEventRows(logs, identity(r)), ...toSummaryEventRows(logs, identity(r))];
+    })
+  ];
+  const eventStore = inMemoryEventStore(events);
+  const noteStore = {
+    getAllNotes: async () => [...data.notes],
+    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: [],
+    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 (obj.kind === "event-journal" || Array.isArray(obj.records)) {
+        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 (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.tags) data.noteTags = corpus.tags;
+        if (corpus.logs && (!corpus.results || corpus.results.length === 0)) {
+          const syntheticResult = {
+            id: "corpus-result-1",
+            noteId: "corpus-note-1",
+            blockContentId: "corpus-block-1",
+            origin: "journal",
+            createdAt: corpus.logs[0]?.timeSpan?.started ?? Date.now(),
+            startTime: corpus.logs[0]?.timeSpan?.started ?? Date.now(),
+            endTime: corpus.logs[corpus.logs.length - 1]?.timeSpan?.ended ?? Date.now(),
+            duration: 0,
+            completed: true
+          };
+          data.results = [syntheticResult];
+        }
+      } 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 resultId = "stdin-result-1";
+    const workoutResult = {
+      id: resultId,
+      noteId: "stdin-note-1",
+      blockContentId: "stdin-block-1",
+      origin: "journal",
+      createdAt: executionLog.results.startTime,
+      startTime: executionLog.results.startTime,
+      endTime: executionLog.results.endTime,
+      duration: executionLog.results.duration ?? 0,
+      completed: executionLog.results.completed
+    };
+    data.results = [workoutResult];
+    data.eventRecords = toEventRows(executionLog.logs, {
+      noteId: workoutResult.noteId,
+      resultId: workoutResult.id,
+      segmentId: workoutResult.segmentId,
+      segmentVersion: workoutResult.segmentVersion,
+      blockContentId: workoutResult.blockContentId,
+      origin: workoutResult.origin,
+      pageId: workoutResult.pageId,
+      workoutTimestamp: workoutResult.createdAt
+    });
+  } 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.");
+  }
+  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" });
+}
+
+// src/cli/loader.ts
+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);
+  }
+}
+var NOTE_ID_FRONTMATTER_KEY = "wod-note-id";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function extractNoteIdentity(markdown) {
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
+  if (!block) return void 0;
+  let noteId;
+  let title;
+  for (const line of block[1].split(/\r?\n/)) {
+    const kv = line.match(/^([^:]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1].trim();
+    const value = kv[2].trim();
+    if (key === NOTE_ID_FRONTMATTER_KEY && UUID_RE.test(value)) noteId = value;
+    if (key === "title" && value) title = value;
+  }
+  return noteId ? { noteId, title } : void 0;
+}
+var FRONTMATTER_SAFE = /^[^:#\[\]{}'"*&,!?|>%@`\s][^:#\[\]{}"']*$/;
+function injectIdentityFrontmatter(markdown, identity) {
+  const stamp = (lines2) => {
+    const replaceOrInsert = (key, value) => {
+      if (value === void 0 || !FRONTMATTER_SAFE.test(value)) return;
+      const idx = lines2.findIndex((l) => l.startsWith(`${key}:`));
+      if (idx >= 0) lines2[idx] = `${key}: ${value}`;
+      else lines2.push(`${key}: ${value}`);
+    };
+    replaceOrInsert("title", identity.title);
+    replaceOrInsert(NOTE_ID_FRONTMATTER_KEY, identity.noteId);
+    return lines2;
+  };
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
+  if (block) {
+    const lines2 = stamp(block[1].split(/\r?\n/));
+    return `---
+${lines2.join("\n")}
+---${markdown.slice(block[0].length)}`;
+  }
+  const lines = stamp([]);
+  return `---
+${lines.join("\n")}
+---
+
+${markdown}`;
+}
+function segmentToFragment(segment) {
+  if (segment.sourceContent !== void 0) return segment.sourceContent;
+  if (segment.dataType === "wod") {
+    const block = segment.data;
+    const dialect = block?.dialect ?? "time";
+    const fenceTag = block?.sport ? `${dialect}:${block.sport}` : dialect;
+    return `\`\`\`${fenceTag}
+${segment.rawContent}
+\`\`\``;
+  }
+  if (segment.dataType === "frontmatter") {
+    return `---
+${segment.rawContent}
+---`;
+  }
+  return segment.rawContent;
+}
+function composeNoteMarkdown(note, segments, version) {
+  const pool = version === void 0 ? segments.filter((s) => s.isHistory !== true) : segments;
+  const cap = version ?? Number.MAX_SAFE_INTEGER;
+  const bySegmentId = {};
+  for (const segment of pool) {
+    if (segment.version > cap) continue;
+    const current = bySegmentId[segment.id];
+    if (!current || segment.version > current.version) bySegmentId[segment.id] = segment;
+  }
+  const picked = Object.values(bySegmentId).sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
+  const markdown = picked.map(segmentToFragment).join("");
+  return injectIdentityFrontmatter(markdown, { noteId: note.id, title: note.title });
+}
+var FRONTMATTER_BLOCK_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+function readFrontmatterMeta(markdown) {
+  const match = FRONTMATTER_BLOCK_RE.exec(markdown);
+  if (!match) return {};
+  const meta = {};
+  const lines = match[1].split(/\r?\n/);
+  let currentListKey;
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    const item = line.match(/^\s+-\s+(.*)$/);
+    if (item && currentListKey) {
+      meta[currentListKey].push(item[1].trim());
+      continue;
+    }
+    const kv = line.match(/^([^:]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1].trim().toLowerCase();
+    const value = kv[2].trim();
+    if (value === "") {
+      meta[key] = [];
+      currentListKey = key;
+    } else if (value.startsWith("[") && value.endsWith("]")) {
+      meta[key] = value.slice(1, -1).split(",").map((v) => v.trim().replace(/^['"]|['"]$/g, "")).filter((v) => v.length > 0);
+      currentListKey = void 0;
+    } else {
+      meta[key] = value;
+      currentListKey = void 0;
+    }
+  }
+  return meta;
+}
+var asList = (value) => Array.isArray(value) ? value : typeof value === "string" ? value.split(",").map((v) => v.trim()).filter((v) => v.length > 0) : [];
+function extractTypedTags(markdown, typedKeys = WQL_TYPED_TAG_KEYS) {
+  const meta = readFrontmatterMeta(markdown);
+  const results = asList(meta["tags"]).map((label) => ({ label }));
+  const metaKeys = Object.keys(meta);
+  for (const typeName of typedKeys) {
+    if (typeName === "tags") continue;
+    const matchedKey = metaKeys.find((k) => k === typeName.toLowerCase());
+    if (!matchedKey) continue;
+    for (const label of asList(meta[matchedKey])) {
+      results.push({ label, type: typeName });
+    }
+  }
+  return results.filter((t) => t.label.length > 0);
+}
+function markdownToEffort(raw) {
+  const match = FRONTMATTER_BLOCK_RE.exec(raw);
+  if (!match) return null;
+  const meta = readFrontmatterMeta(raw);
+  const body = raw.slice(match[0].length).trim();
+  const id = scalarOf(meta["id"]);
+  const slug = scalarOf(meta["slug"]);
+  const label = scalarOf(meta["label"]);
+  if (!id || !slug || !label) return null;
+  const baseAttributes = {};
+  const blockRe = /^\s{2,}([^:]+):\s*(.+)$/;
+  let inAttrs = false;
+  for (const line of match[1].split(/\r?\n/)) {
+    if (/^baseAttributes:/.test(line)) {
+      inAttrs = true;
+      continue;
+    }
+    if (inAttrs) {
+      const attr = blockRe.exec(line);
+      if (attr && /^ {2,}/.test(line)) {
+        const v = attr[2].trim();
+        baseAttributes[attr[1].trim()] = /^\d+(\.\d+)?$/.test(v) ? Number(v) : v;
+      } else if (/^\S/.test(line)) {
+        inAttrs = false;
+      }
+    }
+  }
+  if (typeof baseAttributes["met"] !== "number") return null;
+  return {
+    id,
+    slug,
+    label,
+    aliases: asList(meta["aliases"]),
+    baseAttributes,
+    ...body ? { body } : {}
+  };
+}
+function effortToMarkdown(effort) {
+  const lines = ["---", `id: ${effort.id}`, `slug: ${effort.slug}`, `label: ${effort.label}`];
+  if (effort.aliases && effort.aliases.length > 0) {
+    lines.push("aliases:");
+    for (const alias of effort.aliases) lines.push(`  - ${alias}`);
+  }
+  const attrs = Object.entries(effort.baseAttributes).filter(([, v]) => typeof v === "number" || typeof v === "string");
+  if (attrs.length > 0) {
+    lines.push("baseAttributes:");
+    for (const [k, v] of attrs) lines.push(`  ${k}: ${String(v)}`);
+  }
+  lines.push("---", "");
+  return `${lines.join("\n")}
+${(effort.body ?? "").trim()}`.trimEnd() + "\n";
+}
+function scalarOf(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function equipmentToCsv(labels) {
+  return ["label", ...labels].map((l) => escapeCsvField(l)).join("\n") + "\n";
+}
+function csvToEquipmentLabels(csv) {
+  const lines = splitCsvRecords(csv);
+  if (lines.length === 0) return [];
+  const header = parseCsvLine(lines[0]);
+  const labelIdx = header[0] === "label" ? 0 : -1;
+  const start = labelIdx >= 0 ? 1 : 0;
+  const labels = [];
+  for (const line of lines.slice(start)) {
+    const cells = parseCsvLine(line);
+    const label = (labelIdx >= 0 ? cells[0] : cells.join(",")).trim();
+    if (label) labels.push(label);
+  }
+  return [...new Set(labels)];
+}
+var SESSION_HEADER = [
+  "sessionId",
+  "noteId",
+  "segmentId",
+  "segmentVersion",
+  "blockId",
+  "blockContentId",
+  "origin",
+  "status",
+  "startTime",
+  "endTime",
+  "duration",
+  "completed",
+  "sessionCreatedAt"
+];
+var EVENT_HEADER = [
+  "eventId",
+  "grain",
+  "outputType",
+  "timestamp",
+  "pageId",
+  "effortSlug",
+  "eventSegmentId",
+  "eventSegmentVersion",
+  "eventBlockContentId",
+  "eventOrigin",
+  "timeSpan",
+  "sourceBlockKey",
+  "sourceStatementId",
+  "line",
+  "text",
+  "dialect",
+  "stackLevel",
+  "completionReason",
+  "representationKind",
+  "metricType",
+  "metricValue",
+  "metricUnit",
+  "metricImage",
+  "metricOrigin",
+  "metricMetadata",
+  "metricTemporal",
+  // Verbatim JSON backstops: make the machine round-trip lossless across
+  // schema fields that have no dedicated spreadsheet column. Explicit cells
+  // above still win on import, so hand-edited values are honored.
+  "metricJson",
+  "eventExtraJson"
+];
+var SESSION_CSV_HEADER = [...SESSION_HEADER, ...EVENT_HEADER];
+function escapeCsvField(field) {
+  if (field === void 0 || field === null) return "";
+  const str = typeof field === "object" ? JSON.stringify(field) : String(field);
+  if (str.includes(",") || str.includes('"') || str.includes("\n") || str.includes("\r")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+var metricValueToCell = (value) => {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+};
+var metricValueFromCell = (cell) => {
+  if (cell === "") return void 0;
+  if (/^-?\d+(\.\d+)?$/.test(cell)) return Number(cell);
+  if (cell === "true" || cell === "false") return cell === "true";
+  if (cell.startsWith("{") || cell.startsWith("[")) {
+    try {
+      return JSON.parse(cell);
+    } catch {
+      return cell;
+    }
+  }
+  return cell;
+};
+function sessionCells(session) {
+  return [
+    session.id,
+    session.noteId,
+    session.segmentId,
+    session.segmentVersion,
+    session.blockId,
+    session.blockContentId,
+    session.origin,
+    session.status,
+    session.startTime,
+    session.endTime,
+    session.duration,
+    session.completed,
+    session.createdAt
+  ].map(escapeCsvField);
+}
+function metricCells(event, metric, index) {
+  return [
+    event.id,
+    event.grain,
+    event.outputType,
+    event.timestamp,
+    event.pageId,
+    event.effortSlug,
+    event.segmentId,
+    event.segmentVersion,
+    event.blockContentId,
+    event.origin,
+    event.timeSpan,
+    event.sourceBlockKey,
+    event.sourceStatementId,
+    event.line,
+    event.text,
+    event.dialect,
+    event.stackLevel,
+    event.completionReason,
+    event.representationKind,
+    metric.type,
+    metricValueToCell(metric.value),
+    metric.unit,
+    metric.image,
+    metric.origin,
+    metric.metadata === void 0 ? "" : JSON.stringify(metric.metadata),
+    event.metricTemporal?.[index] === void 0 ? "" : JSON.stringify(event.metricTemporal[index]),
+    JSON.stringify(metric)
+  ].map(escapeCsvField);
+}
+function eventExtraCells(event) {
+  const { metrics: _metrics, ...rest } = event;
+  return escapeCsvField(JSON.stringify(rest));
+}
+function sessionToCsv(session, events) {
+  const lines = [SESSION_CSV_HEADER.join(",")];
+  lines.push([...sessionCells(session), ...EVENT_HEADER.map(() => "")].join(","));
+  const ordered = [...events].sort((a, b) => a.id.localeCompare(b.id));
+  for (const event of ordered) {
+    const extra = eventExtraCells(event);
+    const metrics = event.metrics ?? [];
+    if (metrics.length === 0) {
+      lines.push([...sessionCells(session), ...metricCells(event, { type: "" }, 0), extra].join(","));
+      continue;
+    }
+    for (let i = 0; i < metrics.length; i++) {
+      lines.push([...sessionCells(session), ...metricCells(event, metrics[i], i), extra].join(","));
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function parseCsvLine(line) {
+  const cells = [];
+  let current = "";
+  let quoted = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (quoted) {
+      if (ch === '"') {
+        if (line[i + 1] === '"') {
+          current += '"';
+          i += 1;
+        } else {
+          quoted = false;
+        }
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"' && current === "") {
+      quoted = true;
+    } else if (ch === ",") {
+      cells.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  cells.push(current);
+  return cells;
+}
+function splitCsvRecords(csv) {
+  const records = [];
+  let current = "";
+  let quoted = false;
+  for (let i = 0; i < csv.length; i++) {
+    const ch = csv[i];
+    if (ch === '"') {
+      if (quoted && csv[i + 1] === '"') {
+        current += '""';
+        i += 1;
+        continue;
+      }
+      quoted = !quoted;
+      current += ch;
+    } else if (!quoted && (ch === "\n" || ch === "\r")) {
+      if (ch === "\r" && csv[i + 1] === "\n") i += 1;
+      if (current.length > 0) records.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.length > 0) records.push(current);
+  return records;
+}
+var num = (cell) => cell === "" ? void 0 : Number(cell);
+var nonempty = (cell) => cell === "" ? void 0 : cell;
+function jsonCell(cell) {
+  if (!cell) return void 0;
+  try {
+    return JSON.parse(cell);
+  } catch {
+    return void 0;
+  }
+}
+function csvToSessionRows(csv) {
+  const lines = splitCsvRecords(csv);
+  if (lines.length < 2) throw new Error("[wod import] Session CSV has no data rows");
+  const header = parseCsvLine(lines[0]);
+  const col = (name) => {
+    const idx = header.indexOf(name);
+    if (idx < 0) throw new Error(`[wod import] Session CSV missing column "${name}"`);
+    return idx;
+  };
+  const at = (cells, name) => cells[col(name)] ?? "";
+  const eventRows = /* @__PURE__ */ new Map();
+  let session;
+  const ensureSession = (cells) => {
+    if (session) return session;
+    session = {
+      id: at(cells, "sessionId"),
+      noteId: at(cells, "noteId"),
+      segmentId: at(cells, "segmentId") || void 0,
+      segmentVersion: num(at(cells, "segmentVersion")),
+      blockId: at(cells, "blockId") || void 0,
+      blockContentId: at(cells, "blockContentId") || void 0,
+      origin: at(cells, "origin") || void 0,
+      status: at(cells, "status") || void 0,
+      startTime: Number(at(cells, "startTime") || 0),
+      endTime: Number(at(cells, "endTime") || 0),
+      duration: Number(at(cells, "duration") || 0),
+      completed: at(cells, "completed") === "true",
+      createdAt: Number(at(cells, "sessionCreatedAt") || 0)
+    };
+    return session;
+  };
+  for (const line of lines.slice(1)) {
+    const cells = parseCsvLine(line);
+    if (cells.length === 1 && cells[0] === "") continue;
+    const currentSession = ensureSession(cells);
+    const eventId = at(cells, "eventId");
+    if (!eventId) continue;
+    let event = eventRows.get(eventId);
+    if (!event) {
+      const extra = jsonCell(at(cells, "eventExtraJson")) ?? {};
+      event = {
+        ...extra,
+        id: eventId,
+        resultId: currentSession.id,
+        noteId: nonempty(at(cells, "noteId")) ?? extra.noteId ?? currentSession.noteId,
+        blockContentId: nonempty(at(cells, "eventBlockContentId")) ?? extra.blockContentId,
+        pageId: nonempty(at(cells, "pageId")) ?? extra.pageId,
+        origin: nonempty(at(cells, "eventOrigin")) ?? extra.origin,
+        timestamp: Number(at(cells, "timestamp") || extra.timestamp || 0),
+        grain: nonempty(at(cells, "grain")) ?? extra.grain ?? "event",
+        effortSlug: nonempty(at(cells, "effortSlug")) ?? extra.effortSlug,
+        outputType: nonempty(at(cells, "outputType")) ?? extra.outputType ?? "event",
+        segmentId: nonempty(at(cells, "eventSegmentId")) ?? extra.segmentId,
+        segmentVersion: num(at(cells, "eventSegmentVersion")) ?? extra.segmentVersion,
+        timeSpan: jsonCell(at(cells, "timeSpan")) ?? extra.timeSpan,
+        sourceBlockKey: nonempty(at(cells, "sourceBlockKey")) ?? extra.sourceBlockKey,
+        sourceStatementId: num(at(cells, "sourceStatementId")) ?? extra.sourceStatementId,
+        line: num(at(cells, "line")) ?? extra.line,
+        text: nonempty(at(cells, "text")) ?? extra.text,
+        dialect: nonempty(at(cells, "dialect")) ?? extra.dialect,
+        stackLevel: num(at(cells, "stackLevel")) ?? extra.stackLevel,
+        completionReason: nonempty(at(cells, "completionReason")) ?? extra.completionReason,
+        representationKind: nonempty(at(cells, "representationKind")) ?? extra.representationKind,
+        metrics: [],
+        // Rebuilt per-row from the metricTemporal column below — never
+        // inherited from the backstop, or rows would double-collect.
+        metricTemporal: void 0
+      };
+      eventRows.set(eventId, event);
+    }
+    const metricType = at(cells, "metricType");
+    if (!metricType) continue;
+    const baseMetric = jsonCell(at(cells, "metricJson")) ?? {};
+    const metric = {
+      ...baseMetric,
+      type: metricType,
+      ...at(cells, "metricValue") !== "" ? { value: metricValueFromCell(at(cells, "metricValue")) } : {},
+      ...nonempty(at(cells, "metricUnit")) ? { unit: at(cells, "metricUnit") } : {},
+      ...nonempty(at(cells, "metricImage")) ? { image: at(cells, "metricImage") } : {},
+      ...nonempty(at(cells, "metricOrigin")) ? { origin: at(cells, "metricOrigin") } : {},
+      ...at(cells, "metricMetadata") !== "" ? { metadata: jsonCell(at(cells, "metricMetadata")) } : {}
+    };
+    event.metrics.push(metric);
+    const temporal = jsonCell(at(cells, "metricTemporal"));
+    if (temporal !== void 0) {
+      (event.metricTemporal ??= []).push(temporal);
+    }
+  }
+  if (!session) throw new Error("[wod import] Session CSV did not contain session columns");
+  return { session, events: [...eventRows.values()] };
+}
+
+// src/cli/formatters.ts
+function escapeCsvField2(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,
+        escapeCsvField2(n.raw),
+        escapeCsvField2(n.metrics.map(formatMetric).join("; ")),
+        escapeCsvField2(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 ?? "",
+        escapeCsvField2(s.sourceBlockKey),
+        s.stackLevel,
+        escapeCsvField2(s.completionReason ?? ""),
+        escapeCsvField2(s.metrics.map(formatMetric).join("; ")),
+        escapeCsvField2(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,
+              escapeCsvField2(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, escapeCsvField2(n.title), escapeCsvField2(n.sourceId ?? "")].join(","));
+      }
+      for (const b of data2.blocks) {
+        rows.push(["block", b.id, escapeCsvField2(b.noteTitle), escapeCsvField2(b.sourceId ?? "")].join(","));
+      }
+      for (const e of data2.efforts ?? []) {
+        rows.push(["effort", e.id, escapeCsvField2(e.label), escapeCsvField2(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(
+            [
+              escapeCsvField2(s.label || s.key),
+              pt.ts,
+              formatDate(pt.ts),
+              pt.value,
+              escapeCsvField2(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
+${escapeCsvField2(data.parsed.metric)},${data.scalar},${escapeCsvField2(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(
+          [
+            escapeCsvField2(s.label || s.key),
+            pt.ts,
+            formatDate(pt.ts),
+            pt.value,
+            escapeCsvField2(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 nodePath = () => nodeRequire()("node:path");
+var nodeFs = () => nodeRequire()("node:fs");
+var nodeCrypto = () => nodeRequire()("node:crypto");
+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;
+}
+var sqlModulePromise;
+function loadSql() {
+  sqlModulePromise ??= import(
+    /* @vite-ignore */
+    '@bitcobblers/wod-wiki-storage/sql'
+  );
+  return sqlModulePromise;
+}
+function resolveDbPath(dbPath) {
+  const chosen = dbPath ?? process.env.WOD_WIKI_DB ?? "./wodwiki.db";
+  return nodePath().resolve(process.cwd(), chosen);
+}
+async function openCliDb(dbPath) {
+  const [{ createClient }, sql] = await Promise.all([
+    import(
+      /* @vite-ignore */
+      '@libsql/client'
+    ),
+    loadSql()
+  ]);
+  const resolved = resolveDbPath(dbPath);
+  nodeFs().mkdirSync(nodePath().dirname(resolved), { recursive: true });
+  const db = sql.libsqlDatabase(createClient({ url: `file:${resolved}` }));
+  await sql.initializeStore(db);
+  await sql.initializeDomain(db);
+  return { db, path: resolved, 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());
+}
+var CLI_UUID_NAMESPACE = "c0ffee00-8b1a-4e2c-9d3f-5a6b7c8d9e0f";
+function stableNoteId(sourceLabel, content) {
+  if (sourceLabel && sourceLabel !== "-") {
+    return uuid5(CLI_UUID_NAMESPACE, `wod-cli:${nodePath().resolve(process.cwd(), sourceLabel)}`);
+  }
+  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 (blockContentId) => (await all()).filter((r) => r.blockContentId === blockContentId),
+    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"),
+    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 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 notes = await allRows(sql, db, "notes");
+  const note = notes.find((n) => n.id === noteId);
+  const segments = await rowsByIndex(sql, db, "segments", "by-note", noteId);
+  return { note, segments };
+}
+async function getSessionBundle(db, resultId) {
+  const sql = await loadSql();
+  const sessions = await allRows(sql, db, "sessions");
+  const session = sessions.find((s) => s.id === resultId);
+  if (!session) return void 0;
+  const events = (await allRows(sql, db, "events")).filter((e) => e.resultId === resultId);
+  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);
+}
+function toSegmentDataType(section) {
+  switch (section.type) {
+    case "time":
+    case "log":
+      return "wod";
+    case "title": {
+      const level = Math.min(6, Math.max(1, section.level ?? 1));
+      return `h${level}`;
+    }
+    case "frontmatter":
+      return "frontmatter";
+    case "markdown":
+    default:
+      return "markdown";
+  }
+}
+function sectionSourceFragments(content, sections) {
+  const starts = [0];
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") starts.push(i + 1);
+  }
+  return sections.map((section, index) => content.slice(
+    starts[section.startLine],
+    index + 1 < sections.length ? starts[sections[index + 1].startLine] : content.length
+  ));
+}
+function scriptBlockContentId(data) {
+  if (data && typeof data === "object" && "contentId" in data && typeof data.contentId === "string") {
+    return data.contentId;
+  }
+  return void 0;
+}
+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];
+}
+async function rowsByNote(sql, db, store, noteId) {
+  return sql.listRows(db, sql.storeDefinition(store), { only: noteId }, void 0, "by-note");
+}
+function titleFromLabel(sourceLabel) {
+  if (!sourceLabel || sourceLabel === "-") return "stdin";
+  const stem = sourceLabel.split("/").pop() ?? sourceLabel;
+  return stem.replace(/\.[^.]+$/, "") || sourceLabel;
+}
+async function persistNote(db, options) {
+  const sql = await loadSql();
+  const now = options.now ?? Date.now();
+  const noteId = options.noteId ?? stableNoteId(options.sourceLabel, options.source);
+  const title = options.title ?? titleFromLabel(options.sourceLabel);
+  const sections = parseDocumentSections(options.source);
+  const fragments = sectionSourceFragments(options.source, sections);
+  const existingNote = await noteById(sql, db.db, noteId);
+  const priorSegments = await rowsByNote(sql, db.db, "segments", noteId);
+  const versionBySegmentId = {};
+  for (const segment of priorSegments) {
+    versionBySegmentId[segment.id] = Math.max(versionBySegmentId[segment.id] ?? 0, segment.version);
+  }
+  const createdAt = existingNote?.createdAt ?? now;
+  const note = {
+    id: noteId,
+    title,
+    type: existingNote?.type ?? "note",
+    date: existingNote?.date ?? now,
+    createdAt
+  };
+  const ops = [];
+  const segments = sections.map((section, position) => {
+    const id = `${noteId}:${section.id}`;
+    const version = (versionBySegmentId[id] ?? 0) + 1;
+    return {
+      id,
+      version,
+      noteId,
+      position,
+      dataType: toSegmentDataType(section),
+      data: section.scriptBlock || null,
+      rawContent: section.displayContent,
+      sourceContent: fragments[position],
+      createdAt: version === 1 ? createdAt : now,
+      updatedAt: now,
+      isHistory: false
+    };
+  });
+  for (const segment of priorSegments) {
+    if (segment.isHistory !== true) {
+      ops.push({ op: "put", store: "segments", value: { ...segment, isHistory: true, updatedAt: now } });
+    }
+  }
+  ops.push({ op: "put", store: "notes", value: note });
+  for (const segment of segments) ops.push({ op: "put", store: "segments", value: segment });
+  const priorBlocks = await rowsByNote(sql, db.db, "block_index", noteId);
+  const priorBlockEfforts = await rowsByNote(sql, db.db, "block_efforts", noteId);
+  for (const row of priorBlocks) ops.push({ op: "delete", store: "block_index", key: row.id });
+  for (const row of priorBlockEfforts) ops.push({ op: "delete", store: "block_efforts", key: row.id });
+  let blockCount = 0;
+  let effortCount = 0;
+  for (const segment of segments) {
+    const blockContentId = segment.dataType === "wod" ? scriptBlockContentId(segment.data) : void 0;
+    ops.push({
+      op: "put",
+      store: "block_index",
+      value: {
+        id: `${noteId}:${segment.id}:${segment.version}`,
+        noteId,
+        segmentId: segment.id,
+        segmentVersion: segment.version,
+        position: segment.position,
+        dataType: segment.dataType,
+        blockContentId,
+        rawContent: segment.rawContent,
+        noteTitle: title,
+        createdAt: segment.createdAt
+      }
+    });
+    blockCount += 1;
+    if (segment.dataType === "wod" && segment.rawContent) {
+      const script = parseScript(segment.rawContent);
+      for (const effortSlug of extractEffortSlugs(script.statements)) {
+        ops.push({
+          op: "put",
+          store: "block_efforts",
+          value: {
+            id: `${noteId}:${segment.id}:${effortSlug}`,
+            noteId,
+            blockId: segment.id,
+            blockContentId,
+            effortSlug,
+            createdAt: segment.createdAt
+          }
+        });
+        effortCount += 1;
+      }
+    }
+  }
+  let tagCount = 0;
+  if (options.tags) {
+    const priorLinks = await rowsByNote(sql, db.db, "note_tags", noteId);
+    for (const link of priorLinks) ops.push({ op: "delete", store: "note_tags", key: link.id });
+    const tagByLabel = new Map(
+      (await sql.listRows(db.db, sql.storeDefinition("tags"))).map((t) => [t.label, t])
+    );
+    for (const item of options.tags) {
+      const label = item.label.trim();
+      if (!label) continue;
+      let tag = tagByLabel.get(label);
+      if (!tag) {
+        tag = { id: randomId(), label, type: item.type, createdAt: now };
+        tagByLabel.set(label, tag);
+        ops.push({ op: "put", store: "tags", value: tag });
+      } else if (item.type && !tag.type) {
+        tag = { ...tag, type: item.type };
+        tagByLabel.set(label, tag);
+        ops.push({ op: "put", store: "tags", value: tag });
+      }
+      tagCount += 1;
+      ops.push({
+        op: "put",
+        store: "note_tags",
+        // Deterministic junction id (unique [noteId, tagId] index).
+        value: { id: uuid5(CLI_UUID_NAMESPACE, `note-tag:${noteId}:${tag.id}`), noteId, tagId: tag.id }
+      });
+    }
+  }
+  await db.db.transaction(async (tx) => {
+    await sql.refreshDomain(tx, ops);
+  });
+  return {
+    noteId,
+    note,
+    segments: segments.length,
+    blocks: blockCount,
+    efforts: effortCount,
+    tags: tagCount,
+    created: !existingNote
+  };
+}
+async function noteById(sql, db, noteId) {
+  const rows = await sql.listRows(db, sql.storeDefinition("notes"));
+  return rows.find((row) => row.id === noteId);
+}
+async function persistRun(db, options) {
+  const sql = await loadSql();
+  const results = options.executionLog.results;
+  const logs = options.executionLog.logs ?? [];
+  const noteState = await persistNote(db, {
+    source: options.source,
+    sourceLabel: options.sourceLabel,
+    title: options.title,
+    now: options.now
+  });
+  const segments = (await rowsByNote(sql, db.db, "segments", noteState.noteId)).filter((s) => s.isHistory !== true && s.dataType === "wod").sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
+  const runSegment = segments[0];
+  const blockContentId = runSegment ? scriptBlockContentId(runSegment.data) : void 0;
+  const resultId = randomId();
+  const session = {
+    id: resultId,
+    segmentId: runSegment?.id,
+    segmentVersion: runSegment?.version,
+    noteId: noteState.noteId,
+    blockId: runSegment?.id,
+    blockContentId,
+    origin: "journal",
+    status: results.completed === false ? "in-progress" : "completed",
+    startTime: results.startTime,
+    endTime: results.endTime,
+    duration: results.duration ?? 0,
+    completed: results.completed,
+    createdAt: results.endTime || Date.now()
+  };
+  const identity = {
+    noteId: noteState.noteId,
+    resultId,
+    segmentId: session.segmentId,
+    segmentVersion: session.segmentVersion,
+    blockContentId,
+    origin: session.origin,
+    pageId: session.pageId,
+    workoutTimestamp: session.createdAt
+  };
+  const eventRows = toEventRows(logs, identity);
+  const summaryRows = toSummaryEventRows(logs, identity);
+  await db.db.transaction(async (tx) => {
+    await sql.putRow(tx, sql.storeDefinition("sessions"), session);
+    const eventsDef = sql.storeDefinition("events");
+    for (const row of [...eventRows, ...summaryRows]) await sql.putRow(tx, eventsDef, row);
+  });
+  return {
+    noteId: noteState.noteId,
+    resultId,
+    session,
+    events: eventRows.length,
+    summaries: summaryRows.length,
+    noteCreated: noteState.created
+  };
+}
+async function persistSessionBundle(db, session, events) {
+  const sql = await loadSql();
+  const existing = await noteById(sql, db.db, session.noteId);
+  let noteCreated = false;
+  if (!existing) {
+    noteCreated = true;
+    const now = session.createdAt || Date.now();
+    await db.db.transaction(async (tx) => {
+      await sql.putRow(tx, sql.storeDefinition("notes"), {
+        id: session.noteId,
+        title: `imported-${session.noteId.slice(0, 8)}`,
+        createdAt: now,
+        type: "note"
+      });
+    });
+  }
+  await db.db.transaction(async (tx) => {
+    await sql.putRow(tx, sql.storeDefinition("sessions"), session);
+    const eventsDef = sql.storeDefinition("events");
+    for (const row of events) await sql.putRow(tx, eventsDef, row);
+  });
+  return { events: events.length, noteCreated };
+}
+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) {
+  const sql = await loadSql();
+  const now = Date.now();
+  const tagByLabel = new Map(
+    (await sql.listRows(db.db, sql.storeDefinition("tags"))).map((t) => [t.label, t])
+  );
+  const ops = [];
+  let added = 0;
+  for (const raw of labels) {
+    const label = raw.trim();
+    if (!label) continue;
+    const tag = tagByLabel.get(label);
+    if (!tag) {
+      ops.push({ op: "put", store: "tags", value: { id: randomId(), label, type, createdAt: now } });
+      added += 1;
+    } else if (!tag.type) {
+      ops.push({ op: "put", store: "tags", value: { ...tag, type } });
+    }
+  }
+  if (ops.length > 0) {
+    await db.db.transaction(async (tx) => {
+      await sql.refreshDomain(tx, ops);
+    });
+  }
+  return added;
+}
+
+// src/cli/seed.ts
+var SEED_NAMESPACE = "1b671a64-40d5-491e-99b0-da01ff1f3341";
+var SEED_SCHEMA = 7;
+var CANVAS_CHUNK_ID = "canvas";
+var DASHBOARDS_CHUNK_ID = "dashboards";
+var EFFORTS_CHUNK_ID = "efforts";
+var TEMPLATE_CHUNK_ID = "template";
+var scalarOf2 = (value) => typeof value === "string" ? value : void 0;
+function seedNoteId(path) {
+  return formatV5Digest(nodeCrypto().createHash("sha1").update(`${SEED_NAMESPACE}:${path}`).digest());
+}
+function titleFromPath(path) {
+  const stem = path.split("/").pop() ?? path;
+  return stem.replace(/\.md$/, "").replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function catalogForChunkId(chunkId) {
+  const match = /^(?:collection|feed)\.(.+)$/.exec(chunkId);
+  const value = match?.[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;
+  const route = fm?.[1]?.match(/^route:\s*(\S+)\s*$/m)?.[1];
+  if (!route) return null;
+  return route.replace(/^\//, "") || null;
+}
+function seedNoteSourceId(path, content, chunkId) {
+  const parts = path.split("/");
+  const stem = (parts[parts.length - 1] ?? "").replace(/\.md$/i, "");
+  const under = parts.slice(2).map((p) => p.replace(/\.md$/i, "")).join("/");
+  if (chunkId === CANVAS_CHUNK_ID) {
+    const route = canvasRouteSlug(content);
+    return route ? `guides:${route}` : `guides:${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);
+    if (!catalog) return "collection:_root";
+    return stem.toLowerCase() === "readme" ? `collection:${catalog}` : `collection:${catalog}/${stem}`;
+  }
+  if (chunkId.startsWith("feed.")) return `feed:feeds/${under}`;
+  return void 0;
+}
+function buildNoteRecord(row, chunkId, seedVersion) {
+  const id = seedNoteId(row.path);
+  const createdAt = seedVersion;
+  const meta = readFrontmatterMeta(row.content);
+  const tags = extractTypedTags(row.content);
+  let date;
+  let page;
+  let pageNote;
+  const rawDate = scalarOf2(meta["date"]);
+  if (rawDate && /^\d{4}-\d{2}-\d{2}$/.test(rawDate)) {
+    date = (/* @__PURE__ */ new Date(`${rawDate}T12:00:00Z`)).getTime();
+  }
+  const slug = scalarOf2(meta["slug"]);
+  if (slug) {
+    const pageId = seedNoteId(`page:${slug}`);
+    page = { id: pageId, slug, title: titleFromPath(row.path), createdAt };
+    pageNote = { id: seedNoteId(`pagenote:${slug}:${row.path}`), pageId, noteId: id, createdAt };
+  }
+  const sourceId = seedNoteSourceId(row.path, row.content, chunkId);
+  if (!sourceId) {
+    throw new Error(`[wod seed] chunk "${chunkId}" row "${row.path}" has no source family \u2014 refusing to import it as journal`);
+  }
+  const metaTitle = scalarOf2(meta["title"]);
+  return {
+    note: {
+      id,
+      title: metaTitle?.trim() || titleFromPath(row.path),
+      date,
+      createdAt,
+      type: chunkId === DASHBOARDS_CHUNK_ID ? "dashboard" : "note",
+      sourceId,
+      catalog: catalogForChunkId(chunkId),
+      seedOrigin: "seed",
+      seedVersion,
+      seedChunkId: chunkId,
+      sourcePath: row.path
+    },
+    segment: {
+      id: `seed:${id}`,
+      version: 1,
+      noteId: id,
+      position: 0,
+      dataType: "markdown",
+      data: null,
+      rawContent: row.content,
+      createdAt
+    },
+    tags,
+    page,
+    pageNote,
+    rawContent: row.content,
+    sourcePath: row.path
+  };
+}
+async function metaRecord(sql, db, sourceId) {
+  const rows = await sql.listRows(db, sql.storeDefinition("meta"));
+  const existing = rows.find((r) => r.key === `seed:${sourceId}`);
+  return existing ?? {
+    key: `seed:${sourceId}`,
+    schema: SEED_SCHEMA,
+    seedVersion: 0,
+    builtAt: "",
+    importedAt: 0,
+    chunks: {},
+    claim: null
+  };
+}
+async function applyOps(db, ops) {
+  if (ops.length === 0) return;
+  const sql = await loadSql();
+  await db.db.transaction(async (tx) => {
+    await sql.refreshDomain(tx, ops);
+  });
+}
+async function importSeedDir(db, dir, sourceId) {
+  const sql = await loadSql();
+  const fs = nodeFs();
+  const source = sourceId || nodePath().basename(dir);
+  const manifest = JSON.parse(fs.readFileSync(nodePath().resolve(dir, "manifest.json"), "utf-8"));
+  const prior = await metaRecord(sql, db.db, source);
+  const notesById = new Map(
+    (await sql.listRows(db.db, sql.storeDefinition("notes"))).map((row) => [row.id, row])
+  );
+  const tagRowByLabel = new Map(
+    (await sql.listRows(db.db, sql.storeDefinition("tags"))).map((t) => [t.label, t])
+  );
+  const summary = {
+    sourceId: source,
+    version: manifest.version,
+    notes: 0,
+    efforts: 0,
+    blocks: 0,
+    blockEfforts: 0,
+    deleted: 0,
+    skippedUserOwned: 0
+  };
+  const nextMeta = {
+    ...prior,
+    schema: SEED_SCHEMA,
+    seedVersion: manifest.version,
+    builtAt: manifest.builtAt,
+    importedAt: Date.now(),
+    chunks: {}
+  };
+  const ordered = [
+    ...manifest.chunks.filter((c) => (c.kind ?? "notes") === "notes"),
+    ...manifest.chunks.filter((c) => c.kind === "block-index"),
+    ...manifest.chunks.filter((c) => c.kind === "block-efforts")
+  ];
+  const bySourcePath = /* @__PURE__ */ new Map();
+  const noteIdsByChunk = {};
+  const blockIdsByChunk = {};
+  for (const chunk of ordered) {
+    const payload = JSON.parse(fs.readFileSync(nodePath().resolve(dir, chunk.path), "utf-8"));
+    const ops = [];
+    if ((chunk.kind ?? "notes") === "notes") {
+      const rows2 = payload;
+      const built = rows2.map((row) => buildNoteRecord(row, chunk.id, manifest.version));
+      const noteIds = [];
+      for (const record of built) {
+        bySourcePath.set(record.sourcePath, record.note.id);
+        const existing = notesById.get(record.note.id);
+        if (existing && existing.seedOrigin !== "seed") {
+          summary.skippedUserOwned += 1;
+          continue;
+        }
+        noteIds.push(record.note.id);
+        ops.push({ op: "put", store: "notes", value: record.note });
+        ops.push({ op: "put", store: "segments", value: record.segment });
+        if (record.page) ops.push({ op: "put", store: "page", value: record.page });
+        if (record.pageNote) ops.push({ op: "put", store: "page_notes", value: record.pageNote });
+        for (const item of record.tags) {
+          const label = item.label;
+          let tag = tagRowByLabel.get(label);
+          if (!tag) {
+            tag = { id: randomId(), label, type: item.type, createdAt: Date.now() };
+            tagRowByLabel.set(label, tag);
+            ops.push({ op: "put", store: "tags", value: tag });
+          } else if (item.type && !tag.type) {
+            tag = { ...tag, type: item.type };
+            tagRowByLabel.set(label, tag);
+            ops.push({ op: "put", store: "tags", value: tag });
+          }
+          const tagId = tag.id;
+          ops.push({
+            op: "put",
+            store: "note_tags",
+            // Deterministic junction id — re-seeds must upsert the same row
+            // (note_tags has a unique [noteId, tagId] index).
+            value: { id: uuid5(CLI_UUID_NAMESPACE, `note-tag:${record.note.id}:${tagId}`), noteId: record.note.id, tagId }
+          });
+        }
+        if (chunk.id === EFFORTS_CHUNK_ID) {
+          const effort = markdownToEffort(record.rawContent);
+          if (effort) {
+            ops.push({ op: "put", store: "efforts", value: { ...effort, registrySource: "bundled" } });
+            summary.efforts += 1;
+          }
+        }
+      }
+      const priorIds = prior.chunks[chunk.id]?.noteIds ?? [];
+      const goneIds = priorIds.filter((id) => !noteIds.includes(id) && notesById.get(id)?.seedOrigin === "seed");
+      for (const id of goneIds) {
+        ops.push(...await noteCascadeOps(sql, db, id));
+        summary.deleted += 1;
+      }
+      noteIdsByChunk[chunk.id] = rows2.map((row) => seedNoteId(row.path));
+      nextMeta.chunks[chunk.id] = { sha256: chunk.sha256, noteIds: noteIdsByChunk[chunk.id] };
+      summary.notes += noteIds.length;
+      await applyOps(db, ops);
+      continue;
+    }
+    const rows = payload.filter((row) => row.isStatic === true);
+    const rekeyed = rows.map((row) => {
+      const noteId = row.sourcePath ? bySourcePath.get(row.sourcePath) : void 0;
+      if (!noteId) {
+        throw new Error(
+          `[wod seed] static row ${row.id}: sourcePath "${row.sourcePath ?? ""}" has no imported note \u2014 chunk aborted`
+        );
+      }
+      return chunk.kind === "block-efforts" ? { ...row, noteId } : { ...row, noteId, routeId: row.noteId };
+    });
+    const store = chunk.kind === "block-index" ? "block_index" : "block_efforts";
+    for (const row of rekeyed) ops.push({ op: "put", store, value: row });
+    const priorBlockIds = prior.chunks[chunk.id]?.blockIds ?? [];
+    const writtenIds = new Set(rekeyed.map((row) => row.id));
+    const goneBlocks = priorBlockIds.filter((id) => !writtenIds.has(id));
+    for (const id of goneBlocks) ops.push({ op: "delete", store, key: id });
+    summary.deleted += goneBlocks.length;
+    blockIdsByChunk[chunk.id] = payload.map((row) => row.id);
+    nextMeta.chunks[chunk.id] = { sha256: chunk.sha256, blockIds: blockIdsByChunk[chunk.id] };
+    if (chunk.kind === "block-index") summary.blocks += rekeyed.length;
+    else summary.blockEfforts += rekeyed.length;
+    await applyOps(db, ops);
+  }
+  const manifestIds = new Set(manifest.chunks.map((c) => c.id));
+  for (const [chunkId, checkpoint] of Object.entries(prior.chunks)) {
+    if (manifestIds.has(chunkId)) continue;
+    const sweep = [];
+    for (const id of checkpoint.noteIds ?? []) {
+      if (notesById.get(id)?.seedOrigin === "seed") {
+        sweep.push(...await noteCascadeOps(sql, db, id));
+        summary.deleted += 1;
+      }
+    }
+    for (const id of checkpoint.blockIds ?? []) {
+      sweep.push({ op: "delete", store: "block_index", key: id });
+      summary.deleted += 1;
+    }
+    await applyOps(db, sweep);
+  }
+  await applyOps(db, [{ op: "put", store: "meta", value: nextMeta }]);
+  return summary;
+}
+async function noteCascadeOps(sql, db, noteId) {
+  const ops = [{ op: "delete", store: "notes", key: noteId }];
+  for (const store of ["segments", "block_index", "block_efforts", "note_tags"]) {
+    const rows = await sql.listRows(db.db, sql.storeDefinition(store), { only: noteId }, void 0, "by-note");
+    for (const row of rows) {
+      ops.push({ op: "delete", store, key: store === "segments" ? [row.id, row.version ?? 1] : row.id });
+    }
+  }
+  return ops;
+}
+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/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");
+}
+var VERSION = "0.6.0";
+function parseCliArgs(args) {
+  const result = {
+    format: "json",
+    packs: [],
+    sources: []
+  };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    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 === "--db") {
+      result.db = args[++i];
+      i++;
+    } else if (arg.startsWith("--db=")) {
+      result.db = arg.slice("--db=".length);
+      i++;
+    } else if (arg === "--debug") {
+      result.debug = "";
+      i++;
+    } else if (arg.startsWith("--debug=")) {
+      result.debug = arg.slice("--debug=".length);
+      i++;
+    } else if (arg === "--at") {
+      result.at = args[++i];
+      i++;
+    } else if (arg.startsWith("--at=")) {
+      result.at = arg.slice("--at=".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 === "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++;
+    }
+  }
+  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]
+
+SUBCOMMANDS:
+  parse <file | ->    Parse Whiteboard Script, create a note in the database
+                     (segments + 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>  Compose the note's markdown from its segment rows and
+                     write it to <id>.md. Use --at <version> to compose
+                     as-of a segment version (default: latest). The stamp
+                     in the frontmatter makes 'wod parse' re-import it.
+                     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>
+                     Recreate a session + its events from a downloaded CSV
+                     into the same or a clean database (id-keyed upsert).
+  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/ +
+                     block-parent-map.json + report.html to <dir>/dist
+                     (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 (parse / run / query / download / import / seed / reset):
+  --db <path>         SQLite database file (default: $WOD_WIKI_DB or
+                      ./wodwiki.db). Created on demand by parse/run/seed.
+
+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
+  --at <version>      With 'download note': compose the markdown as-of the
+                      given segment version (default: latest)
+  --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
+
+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;
+  const parsed = parseCliArgs(argv);
+  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) {
+      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 ir = runParse(source, { sport: parsed.sport, sourceLabel: `cli:wod parse ${parsed.target}` });
+      const identity = extractNoteIdentity(source);
+      const tags = extractTypedTags(source);
+      const db = await openCliDb(parsed.db);
+      try {
+        const persisted = await persistNote(db, {
+          source,
+          sourceLabel: parsed.target,
+          noteId: identity?.noteId,
+          title: identity?.title,
+          tags
+        });
+        writeOut(
+          `[wod parse] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.segments} segments, ${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 ir = await runExecution(source, { sport: parsed.sport, sourceLabel: `cli:wod run ${parsed.target}` });
+      const db = await openCliDb(parsed.db);
+      try {
+        const persisted = await persistRun(db, {
+          source,
+          sourceLabel: parsed.target,
+          executionLog: 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 dbPath = resolveDbPath(parsed.db);
+        if (!nodeFs().existsSync(dbPath)) {
+          writeErr(
+            `[wod query] No input dataset and no database at ${dbPath}. Specify --corpus <file>, --stdin-log, --stdin-facts, or run \`wod seed\` first.`
+          );
+          return 1;
+        }
+        const db = await openCliDb(parsed.db);
+        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> [--at <version>] [-o <path>]");
+        return 1;
+      }
+      const targetId = id;
+      const db = await openCliDb(parsed.db);
+      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 at = parsed.at === void 0 ? void 0 : Number(parsed.at);
+          if (parsed.at !== void 0 && (!Number.isInteger(at) || at < 1)) {
+            writeErr(`[wod download] Invalid --at version: ${parsed.at}`);
+            return 1;
+          }
+          const markdown = composeNoteMarkdown(bundle.note, bundle.segments, at);
+          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}${at ? `.v${at}` : ""}.md`;
+          if (parsed.output === "-") {
+            writeOut(markdown);
+          } else {
+            nodeFs().writeFileSync(target, markdown, "utf-8");
+          }
+          writeOut(
+            `[wod download] note ${id}${at ? ` v${at}` : ""} \u2192 ${target} (${bundle.segments.length} segment rows)`
+          );
+        } 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");
+          }
+          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(parsed.db);
+        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.segments} segments${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(parsed.db);
+        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(parsed.db);
+        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(parsed.db);
+      try {
+        const result = await persistSessionBundle(db, session, events);
+        writeOut(
+          `[wod import] session ${session.id} \u2014 ${result.events} events${result.noteCreated ? " (stub note created)" : ""} \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-KTBR6OEL.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)} ${c.kind === "block-index" ? "rows " : "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(parsed.db);
+      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 target = resolveDbPath(parsed.db);
+      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;
+    }
+    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 { NOTE_ID_FRONTMATTER_KEY, PackLoadError, ParseSyntaxError, SESSION_CSV_HEADER, WqlSyntaxError, buildStatementTree, buildWorkoutResults, cliMain, composeNoteMarkdown, createIRFile, csvToEquipmentLabels, csvToSessionRows, defineLanguagePack, effortToMarkdown, equipmentToCsv, extractNoteIdentity, extractTypedTags, formatExecutionOutput, formatParseOutput, formatQueryOutput, getRegisteredLanguagePacks, inMemoryEventStore, injectIdentityFrontmatter, isIRFile, listLanguagePacks, loadLanguagePack, loadQueryData, markdownToEffort, parseCliArgs, parseCsvLine, readFrontmatterMeta, readStdin, registerLanguagePack, runExecution, runParse, runQueryCli, sessionToCsv, splitCsvRecords, statementToNode, unregisterLanguagePack };
+//# sourceMappingURL=chunk-B2OYLNEZ.mjs.map
+//# sourceMappingURL=chunk-B2OYLNEZ.mjs.map