@bitcobblers/wod-wiki-engine 0.35.2129 → 0.36.2133

package/dist/chunk-N4KFWY6Z.mjs

@@ -1,2780 +0,0 @@
-import { createRequire } from 'module';
-import { SEED_SCHEMA, SEED_REGISTERED_WIDGETS, seedNoteSourceId, catalogForChunkId, DASHBOARDS_CHUNK_ID, EFFORTS_CHUNK_ID, parseEffortFile, __require, seedMetaKey, emptySeedMeta, CANVAS_CHUNK_ID } from './chunk-Y6WO6MXS.mjs';
-import { dialectRegistry, realtimeProcessorRegistry, summaryProcessorRegistry, getHints, createParser, toStoredOutputStatement, frozenNow, createCompiler, createMockClock, RuntimeStack, EventBus, ScriptRuntime, createAnalyticsEngineForBlock, StartSessionAction, NextEvent, bundledEfforts, parseScript } from '@bitcobblers/wod-wiki-lang';
-import { MetricType, validateNoteBlocks, parseDocumentSections, blockContentId, reconcileNoteBlocks, mapNoteBlockChanges, KNOWN_SECTION_WIDGETS } from '@bitcobblers/wod-wiki-core';
-import { WQL_TYPED_TAG_KEYS, toEventRows, toSummaryEventRows, parseQuery, QueryService, isPipelineQuery, isFindQuery } from '@bitcobblers/wod-wiki-wql';
-import { rowsEqual } from '@bitcobblers/wod-wiki-storage';
-
-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 (blockContentId4) => rows.filter((r) => r.blockContentId === blockContentId4),
-    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: options.blockId ?? "cli-block",
-    content: source,
-    statements: script.statements,
-    sport: options.sport,
-    version: options.blockVersion ?? 1,
-    startLine: 0,
-    endLine: 0,
-    dialect: options.dialect ?? "time",
-    state: "idle",
-    createdAt: Date.now()
-  });
-  runtime.analyticsContext = analyticsContext;
-  runtime.setAnalyticsEngine(engine);
-  const outputs = [];
-  runtime.subscribeToOutput((out) => {
-    outputs.push(out);
-  });
-  runtime.do(new StartSessionAction());
-  const maxSteps = options.maxIterations ?? 5e3;
-  let steps = 0;
-  while (stack.count > 0 && steps < maxSteps) {
-    runtime.handle(new NextEvent(void 0, runtime.nowProvider));
-    clock.advance(1e3);
-    steps++;
-  }
-  const workoutResults = buildWorkoutResults(outputs, {
-    startTime,
-    elapsedTime: steps * 1e3,
-    completed: stack.count === 0,
-    now
-  });
-  const logs = outputs.map(toStoredOutputStatement);
-  return createIRFile(
-    "execution-log",
-    {
-      results: workoutResults,
-      logs,
-      statements: logs,
-      sourceScript: source
-    },
-    { source: options.sourceLabel ?? "cli:wod run" }
-  );
-}
-function getFs() {
-  if (typeof globalThis.process?.versions?.node === "undefined" && typeof globalThis.Bun === "undefined") {
-    throw new Error("File system operations are only supported in Node / Bun environments");
-  }
-  return __require("fs");
-}
-var WqlSyntaxError = class extends Error {
-  constructor(query, syntaxError) {
-    super(`WQL Syntax Error in "${query}": ${syntaxError}`);
-    this.query = query;
-    this.syntaxError = syntaxError;
-    this.name = "WqlSyntaxError";
-  }
-  query;
-  syntaxError;
-};
-function extractPayload(rawJson) {
-  try {
-    const parsed = JSON.parse(rawJson);
-    if (isIRFile(parsed)) {
-      return parsed.data;
-    }
-    return parsed;
-  } catch (err) {
-    throw new Error(`Failed to parse JSON input: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
-  }
-}
-function buildStoresFromData(data) {
-  const events = [
-    ...data.eventRecords,
-    ...data.facts.map((f, i) => ({
-      id: `fact:${f.resultId ?? "stdin"}:${f.metricKey ?? f.type}:${i}`,
-      resultId: f.resultId ?? "stdin-result-1",
-      noteId: f.noteId ?? "stdin-note-1",
-      blockContentId: f.blockContentId,
-      pageId: f.pageId,
-      origin: f.origin,
-      timestamp: f.timestamp,
-      grain: f.grain === "event" ? "event" : "summary",
-      outputType: "analytics",
-      effortSlug: f.effortSlug,
-      metrics: [{
-        type: f.metricKey ?? f.type,
-        value: f.value,
-        ...f.unit ? { unit: f.unit } : {},
-        origin: "engine"
-      }],
-      blockId: f.blockId,
-      blockVersion: f.blockVersion
-    }))
-  ];
-  const eventStore = inMemoryEventStore(events);
-  const noteStore = {
-    getAllNotes: async () => [...data.notes],
-    getNotesByIds: async (ids) => {
-      const selected = new Set(ids);
-      return data.notes.filter((note) => selected.has(note.id));
-    },
-    getNoteIdsForTag: async (tag) => {
-      const matching = /* @__PURE__ */ new Set();
-      for (const [noteId, tags] of Object.entries(data.noteTags)) {
-        if (tags.includes(tag)) matching.add(noteId);
-      }
-      return matching;
-    },
-    getNoteTagLabels: async (noteId) => [...data.noteTags[noteId] ?? []]
-  };
-  const blockStore = {
-    getAllBlocks: async () => [...data.blocks]
-  };
-  const effortStore = {
-    getAllEfforts: async () => [...data.efforts]
-  };
-  return { eventStore, noteStore, blockStore, effortStore };
-}
-function loadQueryData(options) {
-  const data = {
-    eventRecords: [],
-    facts: [],
-    results: [],
-    notes: [],
-    blocks: [],
-    revisions: [],
-    efforts: [...bundledEfforts],
-    noteTags: {}
-  };
-  if (options.corpusPath) {
-    const fs = getFs();
-    if (!fs.existsSync(options.corpusPath)) {
-      throw new Error(`Corpus file not found at path: ${options.corpusPath}`);
-    }
-    const raw = fs.readFileSync(options.corpusPath, "utf-8");
-    const payload = extractPayload(raw);
-    if (Array.isArray(payload)) {
-      data.facts = payload;
-    } else if (payload && typeof payload === "object") {
-      const obj = payload;
-      if ("segments" in obj) throw new Error("Incompatible corpus segments; whole Notes and block revisions are required");
-      if (obj.kind === "event-journal" || Array.isArray(obj.records)) {
-        if (Array.isArray(obj.blockRevisions)) data.revisions = obj.blockRevisions;
-        if (Array.isArray(obj.sessions)) data.results = obj.sessions;
-        if (Array.isArray(obj.records)) {
-          data.eventRecords = obj.records;
-        }
-        if (Array.isArray(obj.notes)) {
-          data.notes = obj.notes;
-          for (const n of obj.notes) {
-            if (n && typeof n === "object" && n.id && Array.isArray(n.tags)) {
-              data.noteTags[n.id] = n.tags;
-            }
-          }
-        }
-      } else if (obj.facts || obj.results || obj.notes || obj.blocks || obj.efforts || obj.tags || obj.logs) {
-        const corpus = payload;
-        if (corpus.facts) data.facts = corpus.facts;
-        if (corpus.results) data.results = corpus.results;
-        if (corpus.notes) data.notes = corpus.notes;
-        if (corpus.blocks) data.blocks = corpus.blocks;
-        if (corpus.efforts) data.efforts = corpus.efforts;
-        if (corpus.revisions) data.revisions = corpus.revisions;
-        if (corpus.tags) data.noteTags = corpus.tags;
-        if (corpus.logs) {
-          const identity = {
-            noteId: "corpus-note-1",
-            resultId: "corpus-result-1",
-            origin: "journal",
-            workoutTimestamp: corpus.logs[0]?.timeSpan?.started ?? Date.now()
-          };
-          data.eventRecords = [...toEventRows(corpus.logs, identity), ...toSummaryEventRows(corpus.logs, identity)];
-        }
-      } else {
-        throw new Error(`Unrecognized corpus payload shape in "${options.corpusPath}" (expected event-journal, fact-set, or CorpusIRData)`);
-      }
-    }
-  } else if (options.stdinLog) {
-    const payload = extractPayload(options.stdinLog);
-    let executionLog;
-    const rawLogs = payload.logs ?? ("statements" in payload ? payload.statements : void 0) ?? [];
-    if ("results" in payload) {
-      executionLog = { results: payload.results, logs: rawLogs, statements: rawLogs };
-    } else {
-      executionLog = { results: payload, logs: rawLogs, statements: rawLogs };
-    }
-    const identity = {
-      noteId: "stdin-note-1",
-      resultId: "stdin-result-1",
-      origin: "journal",
-      workoutTimestamp: executionLog.results.startTime
-    };
-    data.eventRecords = [
-      ...toEventRows(executionLog.logs, identity),
-      ...toSummaryEventRows(executionLog.logs, identity)
-    ];
-  } else if (options.stdinFacts) {
-    const payload = extractPayload(options.stdinFacts);
-    if (Array.isArray(payload)) {
-      data.facts = payload;
-    } else if (payload && typeof payload === "object" && "facts" in payload) {
-      data.facts = payload.facts;
-    }
-  } else {
-    throw new Error("No input dataset provided. Specify --corpus <path>, --stdin-log, or --stdin-facts.");
-  }
-  for (const note of data.notes) {
-    if (typeof note.rawContent !== "string" || !Number.isSafeInteger(note.sourceRevision) || note.sourceRevision < 1) {
-      throw new Error("Incompatible corpus Note; exact rawContent and sourceRevision are required");
-    }
-    validateNoteBlocks(note.rawContent, note.blocks, note.sourceRevision);
-    if (!data.blocks.some((row) => row.noteId === note.id)) {
-      for (const [position, block] of Object.values(note.blocks).sort((a, b) => a.from - b.from).entries()) {
-        const rawContent = note.rawContent.slice(block.from, block.to);
-        const body = parseDocumentSections(rawContent)[0]?.displayContent ?? rawContent;
-        data.blocks.push({
-          id: `${note.id}:${block.id}`,
-          noteId: note.id,
-          blockId: block.id,
-          blockVersion: block.version,
-          sourceRevision: note.sourceRevision,
-          from: block.from,
-          to: block.to,
-          position,
-          dataType: block.kind,
-          rawContent,
-          noteTitle: note.title,
-          createdAt: note.createdAt,
-          ...block.kind === "wod" ? { blockContentId: blockContentId(body) } : {}
-        });
-      }
-    }
-  }
-  for (const session of data.results) {
-    if ("segmentId" in session || "segmentVersion" in session || "data" in session || "version" in session || "rawContent" in session || !session.blockId || !Number.isSafeInteger(session.blockVersion) || session.blockVersion < 1) {
-      throw new Error("Incompatible corpus Session; exact blockId/blockVersion pin required");
-    }
-    if (!data.revisions.some((row) => row.noteId === session.noteId && row.blockId === session.blockId && row.version === session.blockVersion && row.kind === "wod")) {
-      throw new Error("Corpus Session immutable revision is unavailable");
-    }
-  }
-  for (const row of [...data.eventRecords, ...data.facts, ...data.blocks]) {
-    if ("segmentId" in row || "segmentVersion" in row) throw new Error("Incompatible corpus segment pin");
-  }
-  const revisions = new Map(data.revisions.map((row) => [JSON.stringify([row.noteId, row.blockId, row.version]), row]));
-  for (const row of data.eventRecords) {
-    if (row.blockId !== void 0 || row.blockVersion !== void 0) {
-      if (!row.blockId || !Number.isSafeInteger(row.blockVersion) || !revisions.has(JSON.stringify([row.noteId, row.blockId, row.blockVersion]))) {
-        throw new Error("Corpus Event immutable revision is unavailable");
-      }
-    }
-  }
-  for (const row of data.blocks) {
-    const note = data.notes.find((candidate) => candidate.id === row.noteId);
-    const block = note?.blocks[row.blockId];
-    if (!note || !block || row.blockVersion !== block.version || row.sourceRevision !== note.sourceRevision || row.from !== block.from || row.to !== block.to || row.dataType !== block.kind) {
-      throw new Error("Corpus block projection does not match current Note source");
-    }
-    row.rawContent = note.rawContent.slice(block.from, block.to);
-  }
-  return data;
-}
-async function runQueryCli(wqlString, options = {}) {
-  const parsed = parseQuery(wqlString);
-  if (parsed.error) {
-    throw new WqlSyntaxError(wqlString, parsed.error);
-  }
-  const stores = options.stores ?? buildStoresFromData(loadQueryData(options));
-  const service = new QueryService(stores);
-  if (isPipelineQuery(parsed)) {
-    const result2 = await service.runPipeline(wqlString, {
-      preferredUnit: options.preferredUnit
-    });
-    return createIRFile("pipeline-result", result2, { source: options.sourceLabel ?? "cli:wod query" });
-  }
-  if (isFindQuery(parsed)) {
-    const result2 = await service.runFind(parsed);
-    const kind = parsed.target === "session" ? "rows-result" : "find-result";
-    return createIRFile(kind, result2, { source: options.sourceLabel ?? "cli:wod query" });
-  }
-  const result = await service.runQuery(wqlString, {
-    preferredUnit: options.preferredUnit
-  });
-  return createIRFile("query-result", result, { source: options.sourceLabel ?? "cli:wod query" });
-}
-
-// 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 newline = markdown.startsWith("---\r\n") ? "\r\n" : "\n";
-    const lines2 = stamp(block[1].split(/\r?\n/));
-    return `---${newline}${lines2.join(newline)}${newline}---${markdown.slice(block[0].length)}`;
-  }
-  const lines = stamp([]);
-  return `---
-${lines.join("\n")}
----
-
-${markdown}`;
-}
-function composeNoteMarkdown(note) {
-  return injectIdentityFrontmatter(note.rawContent, { 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",
-  "blockId",
-  "blockVersion",
-  "blockContentId",
-  "origin",
-  "status",
-  "startTime",
-  "endTime",
-  "duration",
-  "completed",
-  "sessionCreatedAt",
-  "sessionExtraJson"
-];
-var EVENT_HEADER = [
-  "eventId",
-  "grain",
-  "outputType",
-  "timestamp",
-  "pageId",
-  "effortSlug",
-  "eventBlockId",
-  "eventBlockVersion",
-  "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.blockId,
-    session.blockVersion,
-    session.blockContentId,
-    session.origin,
-    session.status,
-    session.startTime,
-    session.endTime,
-    session.duration,
-    session.completed,
-    session.createdAt,
-    JSON.stringify(session)
-  ].map(escapeCsvField);
-}
-function metricCells(event, metric, index) {
-  return [
-    event.id,
-    event.grain,
-    event.outputType,
-    event.timestamp,
-    event.pageId,
-    event.effortSlug,
-    event.blockId,
-    event.blockVersion,
-    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]);
-  if (header.some((name) => /segment/i.test(name))) {
-    throw new Error("[wod import] Incompatible Session CSV segment pins; blockId/blockVersion are required");
-  }
-  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) => {
-    const id = at(cells, "sessionId");
-    const noteId = at(cells, "noteId");
-    const blockId = at(cells, "blockId");
-    const blockVersion = Number(at(cells, "blockVersion"));
-    if (!id || !noteId || !blockId || !Number.isSafeInteger(blockVersion) || blockVersion < 1) {
-      throw new Error("[wod import] Session CSV requires sessionId, noteId, blockId and positive blockVersion");
-    }
-    if (session) {
-      if (session.id !== id || session.noteId !== noteId || session.blockId !== blockId || session.blockVersion !== blockVersion) {
-        throw new Error("[wod import] Session CSV contains inconsistent source pins");
-      }
-      return session;
-    }
-    const extra = jsonCell(at(cells, "sessionExtraJson")) ?? {};
-    if ("segmentId" in extra || "segmentVersion" in extra || "version" in extra || "rawContent" in extra || "data" in extra) {
-      throw new Error("[wod import] Incompatible Session CSV source snapshot or segment pin");
-    }
-    session = {
-      ...extra,
-      id,
-      noteId,
-      blockId,
-      blockVersion,
-      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)
-    };
-    if (![session.startTime, session.endTime, session.duration, session.createdAt].every(Number.isFinite)) {
-      throw new Error("[wod import] Session CSV lifecycle values must be finite numbers");
-    }
-    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")) ?? {};
-      if ("segmentId" in extra || "segmentVersion" in extra) {
-        throw new Error("[wod import] Incompatible Session CSV event segment pins");
-      }
-      const blockId = nonempty(at(cells, "eventBlockId"));
-      const blockVersion = num(at(cells, "eventBlockVersion"));
-      if (blockId !== currentSession.blockId || blockVersion !== currentSession.blockVersion) {
-        throw new Error("[wod import] Event source pin differs from Session source pin");
-      }
-      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",
-        blockId,
-        blockVersion,
-        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: [],
-        // Rebuild anchors from metric rows while preserving an authored empty array.
-        metricTemporal: Array.isArray(extra.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()] };
-}
-function object(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function positive(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-}
-function nonnegative(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function assertSeedManifest(value) {
-  if (!object(value) || value.schema !== SEED_SCHEMA) throw new Error("Incompatible seed schema; rebuild seed artifacts");
-  if (!nonnegative(value.version) || typeof value.builtAt !== "string" || !Number.isFinite(Date.parse(value.builtAt)) || !Array.isArray(value.chunks)) throw new Error("seed manifest failed shape validation");
-  for (const key of ["versionLabel", "commit"]) if (value[key] !== void 0 && typeof value[key] !== "string") throw new Error("invalid seed manifest metadata");
-  if (value.dirty !== void 0 && typeof value.dirty !== "boolean") throw new Error("invalid seed manifest metadata");
-  const ids = /* @__PURE__ */ new Set(), paths = /* @__PURE__ */ new Set();
-  for (const chunk of value.chunks) {
-    if (!object(chunk) || typeof chunk.id !== "string" || !chunk.id || typeof chunk.path !== "string" || !/^chunks\/[a-zA-Z0-9._-]+\.json$/.test(chunk.path) || typeof chunk.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(chunk.sha256) || !nonnegative(chunk.bytes) || !nonnegative(chunk.count) || chunk.kind !== void 0 && chunk.kind !== "notes" || ids.has(chunk.id) || paths.has(chunk.path)) throw new Error("seed manifest failed shape validation");
-    ids.add(chunk.id);
-    paths.add(chunk.path);
-  }
-  return value;
-}
-function assertSeedRows(value) {
-  if (!Array.isArray(value)) throw new Error("seed chunk is not an array");
-  const paths = /* @__PURE__ */ new Set();
-  for (const row of value) {
-    if (!object(row) || typeof row.path !== "string" || !row.path || row.path.startsWith("/") || row.path.split("/").includes("..") || paths.has(row.path) || typeof row.content !== "string" || !object(row.blocks) || !Array.isArray(row.blockIndex) || !Array.isArray(row.blockEfforts)) throw new Error("seed chunk row failed shape validation");
-    paths.add(row.path);
-    for (const [id, block] of Object.entries(row.blocks)) {
-      if (!object(block) || block.id !== id || !id || block.version !== 1 || block.sourceRevision !== 1 || !nonnegative(block.from) || !positive(block.to) || block.from >= block.to || block.to > row.content.length || !["wod", "query", "widget", "embed"].includes(String(block.kind)) || (block.kind === "wod" ? !["time", "log"].includes(String(block.dialect)) : block.dialect !== void 0) || block.sport !== void 0 && typeof block.sport !== "string") throw new Error("invalid seed block range or revision");
-    }
-    validateNoteBlocks(row.content, row.blocks, 1, { registeredWidgets: SEED_REGISTERED_WIDGETS });
-    const indexed = /* @__PURE__ */ new Set();
-    const sections = parseDocumentSections(row.content, { registeredWidgets: SEED_REGISTERED_WIDGETS });
-    for (const projection of row.blockIndex) {
-      if (!object(projection) || typeof projection.blockId !== "string") throw new Error("invalid seed projection");
-      const block = row.blocks[projection.blockId];
-      if (!object(block) || indexed.has(projection.blockId) || typeof projection.id !== "string" || typeof projection.noteId !== "string" || projection.id !== `${projection.noteId}:${projection.blockId}` || projection.blockVersion !== 1 || projection.sourceRevision !== 1 || projection.from !== block.from || projection.to !== block.to || projection.dataType !== block.kind || projection.rawContent !== row.content.slice(Number(block.from), Number(block.to)) || typeof projection.noteTitle !== "string" || typeof projection.createdAt !== "number" || !Number.isFinite(projection.createdAt) || projection.sourcePath !== row.path || projection.isStatic !== true) throw new Error("orphan or incompatible seed projection");
-      if ("segmentId" in projection || "segmentVersion" in projection) throw new Error("incompatible seed projection");
-      for (const key of ["sourceId", "routeId", "blockContentId"]) if (projection[key] !== void 0 && typeof projection[key] !== "string") throw new Error("invalid seed projection metadata");
-      if (projection.position !== void 0 && !nonnegative(projection.position)) throw new Error("invalid seed projection position");
-      if (block.kind === "wod") {
-        const section = sections.find((s) => s.from === block.from && s.to === block.to);
-        if (projection.blockContentId !== blockContentId(section?.scriptBlock?.content ?? row.content.slice(Number(block.from), Number(block.to)))) throw new Error("invalid seed workout fingerprint");
-      } else if (projection.blockContentId !== void 0) throw new Error("non-workout seed fingerprint");
-      indexed.add(projection.blockId);
-    }
-    if (indexed.size !== Object.keys(row.blocks).length) throw new Error("missing actionable seed projection");
-    const links = /* @__PURE__ */ new Set();
-    for (const link of row.blockEfforts) {
-      if (!object(link) || typeof link.blockId !== "string" || typeof link.noteId !== "string" || typeof link.effortSlug !== "string" || !link.effortSlug) throw new Error("invalid seed effort identity");
-      const block = row.blocks[link.blockId];
-      if (link.id !== `${link.noteId}:${link.blockId}:${link.effortSlug}` || links.has(String(link.id)) || !object(block) || block.kind !== "wod" || !indexed.has(link.blockId) || link.sourcePath !== row.path || link.isStatic !== true || typeof link.createdAt !== "number") throw new Error("orphan or incompatible seed effort link");
-      const projection = row.blockIndex.find((p) => object(p) && p.blockId === link.blockId);
-      if (!object(projection) || link.noteId !== projection.noteId || link.blockContentId !== projection.blockContentId || !Number.isFinite(link.createdAt)) throw new Error("invalid seed effort metadata");
-      links.add(String(link.id));
-    }
-  }
-  return value;
-}
-var SEED_NAMESPACE = "1b671a64-40d5-491e-99b0-da01ff1f3341";
-async function seedNoteId(path) {
-  const digest = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(`${SEED_NAMESPACE}:${path}`));
-  const bytes = new Uint8Array(digest.slice(0, 16));
-  bytes[6] = bytes[6] & 15 | 80;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-function equal(a, b) {
-  if (Object.is(a, b)) return true;
-  if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
-  const ak = Object.keys(a).filter((key) => Reflect.get(a, key) !== void 0), bk = Object.keys(b).filter((key) => Reflect.get(b, key) !== void 0);
-  return ak.length === bk.length && ak.every((key) => key in b && equal(Reflect.get(a, key), Reflect.get(b, key)));
-}
-function titleFromPath(path) {
-  return (path.split("/").at(-1) ?? path).replace(/\.md$/, "").replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
-function refreshedBlocks(existing, rawContent, sourceRevision) {
-  const old = existing.rawContent;
-  let from = 0, endOld = old.length, endNew = rawContent.length;
-  while (from < endOld && from < endNew && old[from] === rawContent[from]) from++;
-  while (endOld > from && endNew > from && old[endOld - 1] === rawContent[endNew - 1]) {
-    endOld--;
-    endNew--;
-  }
-  const intersect = Object.values(existing.blocks).filter((b) => from < b.to && endOld > b.from);
-  const trusted = intersect.length <= 1 ? existing.blocks : Object.fromEntries(Object.entries(existing.blocks).filter(([, b]) => !intersect.includes(b)));
-  const mapped = mapNoteBlockChanges(trusted, [{ from, to: endOld, insert: rawContent.slice(from, endNew) }]);
-  let ordinal = 0;
-  return reconcileNoteBlocks(rawContent, { sourceRevision, blocks: mapped, registeredWidgets: SEED_REGISTERED_WIDGETS, createId: () => `seed:${existing.id}:r${sourceRevision}:${ordinal++}` });
-}
-async function putChanged(store, values, keys) {
-  if (!values.length) return;
-  const prior = await store.getMany(keys);
-  const changed = values.filter((value, i) => !equal(value, prior[i]));
-  if (changed.length) await store.putMany(changed);
-}
-async function applySeedChunk(storage, write) {
-  assertSeedManifest(write.manifest);
-  assertSeedRows(write.rows);
-  const result = { totalNotes: 0, totalEfforts: 0, totalBlocks: 0, skippedUserOwned: 0, deleted: 0, addedNotes: 0, updatedNotes: 0 };
-  const ids = await Promise.all(write.rows.map((row) => seedNoteId(row.path)));
-  const pagesBySlug = /* @__PURE__ */ new Map();
-  const linkIds = /* @__PURE__ */ new Map();
-  const tagIds = /* @__PURE__ */ new Map();
-  for (const [i, row] of write.rows.entries()) {
-    const slug = readFrontmatterMeta(row.content)["slug"];
-    if (typeof slug === "string" && slug.trim()) {
-      pagesBySlug.set(slug, await seedNoteId(`page:${slug}`));
-      linkIds.set(ids[i], await seedNoteId(`pagenote:${slug}:${row.path}`));
-    }
-    for (const { label } of extractTypedTags(row.content)) {
-      if (!tagIds.has(label)) tagIds.set(label, await seedNoteId(`tag:${label}`));
-    }
-  }
-  return storage.transaction(["notes", "block_revisions", "block_index", "block_efforts", "page", "page_notes", "tags", "note_tags", "efforts", "meta"], "readwrite", async (tx) => {
-    const metaStore = tx.readwrite("meta");
-    const actualMeta = await metaStore.get(write.meta.key);
-    if (!equal(actualMeta, write.expectedMeta)) throw new Error("Seed checkpoint changed during import");
-    if (write.meta.schema !== SEED_SCHEMA || write.manifest.schema !== SEED_SCHEMA) throw new Error("Incompatible seed schema; recreate artifacts");
-    const noteStore = tx.readwrite("notes");
-    const priorIds = write.chunkId ? write.expectedMeta?.chunks[write.chunkId]?.noteIds ?? [] : [];
-    const declared = new Set(ids);
-    const goneIds = priorIds.filter((id) => !declared.has(id));
-    const allIds = [.../* @__PURE__ */ new Set([...ids, ...goneIds])];
-    const stored = await noteStore.getMany(allIds);
-    const existingById = new Map(allIds.map((id, i) => [id, stored[i]]));
-    const ownedIds = allIds.filter((id) => {
-      const note = existingById.get(id);
-      return !note || note.seedOrigin === "seed" && (declared.has(id) || note.seedChunkId === write.chunkId);
-    });
-    const owned = new Set(ownedIds);
-    const revisionStore = tx.readwrite("block_revisions");
-    const historyIds = ids.filter((id, i) => owned.has(id) && existingById.get(id)?.rawContent !== write.rows[i].content);
-    const histories = await revisionStore.getAllFromIndexMany("by-note", historyIds);
-    const history = new Map(historyIds.map((id, i) => [id, histories[i]]));
-    const indexStore = tx.readwrite("block_index"), effortLinks = tx.readwrite("block_efforts");
-    const tagLinks = tx.readwrite("note_tags"), pageLinks = tx.readwrite("page_notes");
-    const currentIndexes = await indexStore.getAllFromIndexMany("by-note", ownedIds);
-    const currentEfforts = await effortLinks.getAllFromIndexMany("by-note", ownedIds);
-    const currentTags = await tagLinks.getAllFromIndexMany("by-note", ownedIds);
-    const currentPages = await pageLinks.getAllFromIndexMany("by-note", ownedIds);
-    const slot = new Map(ownedIds.map((id, i) => [id, i]));
-    const tagsStore = tx.readwrite("tags");
-    const labels = [...tagIds.keys()];
-    const matches = await tagsStore.getAllFromIndexMany("by-label", labels);
-    const tagsByLabel = new Map(labels.map((label, i) => [label, matches[i][0]]));
-    const changedTags = [], changedNotes = [], revisions = [], pages = [], pageNotes = [], noteTags = [];
-    const blocks = [], blockEfforts = [];
-    for (const [i, row] of write.rows.entries()) {
-      const id = ids[i], existing = existingById.get(id);
-      if (!owned.has(id)) {
-        result.skippedUserOwned++;
-        continue;
-      }
-      if (!existing) result.addedNotes++;
-      else if (existing.rawContent !== row.content) result.updatedNotes++;
-      validateNoteBlocks(row.content, row.blocks, 1, { registeredWidgets: SEED_REGISTERED_WIDGETS });
-      const sourceRevision = existing ? existing.sourceRevision + (existing.rawContent === row.content ? 0 : 1) : 1;
-      let ordinal = 0;
-      const retainedHistory = history.get(id) ?? [];
-      const map = !existing ? retainedHistory.length ? reconcileNoteBlocks(row.content, { sourceRevision, registeredWidgets: SEED_REGISTERED_WIDGETS, createId: () => `seed:${id}:new${retainedHistory.length}:${ordinal++}` }) : structuredClone(row.blocks) : existing.rawContent === row.content ? structuredClone(existing.blocks) : refreshedBlocks(existing, row.content, sourceRevision);
-      for (const block of Object.values(map)) {
-        const saved = (history.get(id) ?? []).filter((r) => r.blockId === block.id).sort((a, b) => b.version - a.version)[0];
-        const source = row.content.slice(block.from, block.to);
-        if (existing?.rawContent === row.content) continue;
-        const same = saved && saved.kind === block.kind && saved.rawContent === source && saved.dialect === block.dialect && saved.sport === block.sport;
-        block.version = !existing ? 1 : same ? saved.version : (saved?.version ?? 0) + 1;
-        if (!existing || !same) revisions.push({ noteId: id, blockId: block.id, version: block.version, kind: block.kind, rawContent: source, savedAt: write.meta.importedAt, ...block.dialect ? { dialect: block.dialect } : {}, ...block.sport ? { sport: block.sport } : {} });
-      }
-      validateNoteBlocks(row.content, map, sourceRevision, { registeredWidgets: SEED_REGISTERED_WIDGETS });
-      const fm = readFrontmatterMeta(row.content);
-      const title = typeof fm["title"] === "string" && fm["title"].trim() ? fm["title"].trim() : titleFromPath(row.path);
-      const sourceId = write.chunkId ? seedNoteSourceId(row.path, row.content, write.chunkId) : void 0;
-      if (!sourceId) throw new Error(`Unknown seed source family ${write.chunkId}`);
-      const date = typeof fm["date"] === "string" && /^\d{4}-\d{2}-\d{2}$/.test(fm["date"]) ? Date.parse(`${fm["date"]}T12:00:00Z`) : void 0;
-      const note = { ...existing, id, title, rawContent: row.content, sourceRevision, blocks: map, createdAt: write.manifest.version, ...date === void 0 ? {} : { date }, type: write.chunkId === DASHBOARDS_CHUNK_ID ? "dashboard" : "note", sourceId, catalog: catalogForChunkId(write.chunkId ?? ""), seedOrigin: "seed", seedVersion: write.manifest.version, seedChunkId: write.chunkId ?? void 0, sourcePath: row.path };
-      if (date === void 0) delete note.date;
-      if (!equal(note, existing)) changedNotes.push(note);
-      const byRange = new Map(Object.values(map).map((b) => [`${b.from}:${b.to}`, b]));
-      const compiledById = new Map(row.blockIndex.map((b) => [b.blockId, b]));
-      const remap = /* @__PURE__ */ new Map();
-      for (const compiled of row.blockIndex) {
-        const block = byRange.get(`${compiled.from}:${compiled.to}`);
-        if (!block || block.kind !== compiled.dataType) throw new Error("Orphan seed projection");
-        remap.set(compiled.blockId, block.id);
-        const projection = { ...compiled, id: `${id}:${block.id}`, noteId: id, blockId: block.id, blockVersion: block.version, sourceRevision, noteTitle: title, sourceId, sourcePath: row.path, rawContent: row.content.slice(block.from, block.to) };
-        const prior = currentIndexes[slot.get(id)].find((b) => b.id === projection.id);
-        if (!prior || prior.isStatic === true) blocks.push(projection);
-      }
-      for (const compiled of row.blockEfforts) {
-        const blockId = remap.get(compiled.blockId);
-        if (!blockId || compiledById.get(compiled.blockId)?.dataType !== "wod") throw new Error("Orphan seed effort link");
-        const link = { ...compiled, id: `${id}:${blockId}:${compiled.effortSlug}`, noteId: id, blockId, sourcePath: row.path };
-        const prior = currentEfforts[slot.get(id)].find((b) => b.id === link.id);
-        if (!prior || prior.isStatic === true) blockEfforts.push(prior ? { ...link, createdAt: prior.createdAt } : link);
-      }
-      const n = slot.get(id);
-      const wantedTags = /* @__PURE__ */ new Set();
-      for (const item of extractTypedTags(row.content)) {
-        let tag = tagsByLabel.get(item.label);
-        if (!tag) {
-          tag = { id: tagIds.get(item.label), label: item.label, type: item.type, createdAt: write.meta.importedAt };
-          changedTags.push(tag);
-          tagsByLabel.set(item.label, tag);
-        } else if (item.type && !tag.type) {
-          tag = { ...tag, type: item.type };
-          changedTags.push(tag);
-          tagsByLabel.set(item.label, tag);
-        }
-        if (wantedTags.has(tag.id)) continue;
-        wantedTags.add(tag.id);
-        const link = currentTags[n].find((l) => l.tagId === tag.id);
-        if (!link) noteTags.push({ id: `${id}:${tag.id}`, noteId: id, tagId: tag.id });
-      }
-      for (const link of currentTags[n]) if (!wantedTags.has(link.tagId)) await tagLinks.delete(link.id);
-      const slug = fm["slug"];
-      if (typeof slug === "string" && pagesBySlug.has(slug)) {
-        const pageId = pagesBySlug.get(slug);
-        pages.push({ id: pageId, slug, title: titleFromPath(row.path), createdAt: write.manifest.version });
-        pageNotes.push({ id: linkIds.get(id), pageId, noteId: id, createdAt: write.manifest.version });
-      }
-      result.totalNotes++;
-      result.totalBlocks += Object.keys(map).length;
-    }
-    const wantedBlocks = new Set(blocks.map((b) => b.id)), wantedEfforts = new Set(blockEfforts.map((b) => b.id));
-    for (const rows of currentIndexes) for (const row of rows) if (row.isStatic === true && !wantedBlocks.has(row.id)) await indexStore.delete(row.id);
-    for (const rows of currentEfforts) for (const row of rows) if (row.isStatic === true && !wantedEfforts.has(row.id)) await effortLinks.delete(row.id);
-    for (const id of goneIds) {
-      if (!owned.has(id) || !existingById.get(id)) continue;
-      const n = slot.get(id);
-      await noteStore.delete(id);
-      for (const link of currentTags[n]) await tagLinks.delete(link.id);
-      for (const link of currentPages[n]) await pageLinks.delete(link.id);
-      result.deleted++;
-    }
-    const effortStore = tx.readwrite("efforts");
-    if (write.chunkId === EFFORTS_CHUNK_ID) {
-      const efforts = write.rows.filter((_row, i) => owned.has(ids[i])).map((r) => parseEffortFile(r.content)).filter((e) => e !== null).map((e) => ({ ...e, registrySource: "bundled" }));
-      const prior = await effortStore.getMany(efforts.map((e) => e.slug));
-      const changed = efforts.filter((e, i) => (!prior[i] || prior[i]?.registrySource === "bundled") && !equal(e, prior[i]));
-      if (changed.length) await effortStore.putMany(changed);
-      result.totalEfforts = changed.length;
-      const wantedSlugs = new Set(efforts.map((effort) => effort.slug));
-      const removed = allIds.map((id) => {
-        const note = existingById.get(id);
-        return owned.has(id) && note ? parseEffortFile(note.rawContent)?.slug : void 0;
-      }).filter((slug) => !!slug && !wantedSlugs.has(slug));
-      const old = await effortStore.getMany(removed);
-      for (const [i, effort] of old.entries()) if (effort?.registrySource === "bundled") await effortStore.delete(removed[i]);
-    }
-    if (changedNotes.length) await noteStore.putMany(changedNotes);
-    if (revisions.length) await revisionStore.putMany(revisions);
-    await putChanged(indexStore, blocks, blocks.map((b) => b.id));
-    await putChanged(effortLinks, blockEfforts, blockEfforts.map((b) => b.id));
-    if (changedTags.length) await tagsStore.putMany([...new Map(changedTags.map((t) => [t.id, t])).values()]);
-    if (noteTags.length) await tagLinks.putMany(noteTags);
-    await putChanged(tx.readwrite("page"), pages, pages.map((p) => p.id));
-    await putChanged(pageLinks, pageNotes, pageNotes.map((p) => p.id));
-    await metaStore.put(write.meta);
-    return result;
-  });
-}
-
-// 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}` }));
-  try {
-    await sql.initializeStore(db);
-    await sql.initializeDomain(db);
-    return { db, storage: new sql.SqlStorage(db), path: resolved, close: () => db.close() };
-  } catch (error) {
-    await db.close();
-    throw error;
-  }
-}
-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 (blockContentId4) => (await all()).filter((r) => r.blockContentId === blockContentId4),
-    scanAll: all,
-    appendEvents: async (appended) => {
-      const sql = await loadSql();
-      await db.transaction(async (tx) => {
-        const eventsDef = sql.storeDefinition("events");
-        for (const row of appended) await sql.putRow(tx, eventsDef, row);
-      });
-    },
-    finalizeSummaries: async (resultId, finals) => {
-      const sql = await loadSql();
-      await db.transaction(async (tx) => {
-        const eventsDef = sql.storeDefinition("events");
-        const existing = (await sql.listRows(tx, eventsDef)).filter(
-          (r) => r.resultId === resultId && r.grain === "summary" && r.origin !== "user"
-        );
-        for (const row of existing) await sql.deleteRows(tx, eventsDef, row.id);
-        for (const row of finals) await sql.putRow(tx, eventsDef, row);
-      });
-    },
-    deleteEvents: async (ids) => {
-      const sql = await loadSql();
-      await db.transaction(async (tx) => {
-        const eventsDef = sql.storeDefinition("events");
-        for (const id of ids) await sql.deleteRows(tx, eventsDef, id);
-      });
-    }
-  };
-}
-function sqliteNoteStore(db) {
-  return {
-    getAllNotes: async () => await allRows(await loadSql(), db, "notes"),
-    getNotesByIds: async (noteIds) => {
-      const sql = await loadSql();
-      const rows = await sql.getRows(db, sql.storeDefinition("notes"), [...noteIds]);
-      return rows.filter((row) => row !== void 0);
-    },
-    getNoteIdsForTag: async (label) => {
-      const sql = await loadSql();
-      const tags = (await allRows(sql, db, "tags")).filter((t) => t.label === label);
-      const ids = {};
-      for (const tag of tags) {
-        for (const row of await rowsByIndex(sql, db, "note_tags", "by-tag", tag.id)) {
-          ids[row.noteId] = true;
-        }
-      }
-      return new Set(Object.keys(ids));
-    },
-    getNoteTagLabels: async (noteId) => {
-      const sql = await loadSql();
-      const tagRows = await allRows(sql, db, "tags");
-      const labelById = {};
-      for (const t of tagRows) labelById[t.id] = t.label;
-      const links = await rowsByIndex(sql, db, "note_tags", "by-note", noteId);
-      return links.map((l) => labelById[l.tagId]).filter((l) => typeof l === "string");
-    },
-    queryDomain: async (request) => {
-      const result = await (await loadSql()).handleDomainQuery(db, request);
-      return result;
-    }
-  };
-}
-function sqliteBlockStore(db) {
-  return {
-    getAllBlocks: async () => await allRows(await loadSql(), db, "block_index"),
-    queryDomain: async (request) => {
-      const result = await (await loadSql()).handleDomainQuery(db, { ...request, plan: "blocks" });
-      return result;
-    }
-  };
-}
-function sqliteEffortStore(db) {
-  return {
-    getAllEfforts: async () => {
-      const stored = await allRows(await loadSql(), db, "efforts");
-      const bySlug = {};
-      for (const effort of stored) bySlug[effort.slug] = effort;
-      for (const effort of bundledEfforts) {
-        bySlug[effort.slug] ??= effort;
-      }
-      return Object.values(bySlug);
-    }
-  };
-}
-function sqliteIndexStore(db, store) {
-  return {
-    getAllFromIndex: async (index, key) => rowsByIndex(await loadSql(), db, store, index, key)
-  };
-}
-async function getNoteBundle(db, noteId) {
-  const sql = await loadSql();
-  const note = await sql.getRow(db, sql.storeDefinition("notes"), noteId);
-  return { note };
-}
-async function getSessionBundle(db, resultId) {
-  const sql = await loadSql();
-  const session = await sql.getRow(db, sql.storeDefinition("sessions"), resultId);
-  if (!session) return void 0;
-  const events = await sql.listRows(db, sql.storeDefinition("events"), { only: resultId }, void 0, "by-result-grain");
-  return { session, events };
-}
-async function getEffortBySlug(db, slug) {
-  const sql = await loadSql();
-  const efforts = await allRows(sql, db, "efforts");
-  return efforts.find((e) => e.slug === slug);
-}
-async function listTagsByType(db, type) {
-  const sql = await loadSql();
-  const tags = await allRows(sql, db, "tags");
-  return tags.filter((t) => t.type === type);
-}
-var registeredWidgets = KNOWN_SECTION_WIDGETS;
-var saveStores = ["notes", "block_revisions", "block_index", "block_efforts", "tags", "note_tags", "sessions"];
-function extractEffortSlugs(statements) {
-  const slugs = /* @__PURE__ */ new Set();
-  for (const statement of statements) {
-    if (statement.exerciseId) {
-      slugs.add(statement.exerciseId);
-    } else {
-      const effortMetric = statement.metrics?.getMetric?.("effort");
-      const effort = effortMetric && "effort" in effortMetric ? effortMetric.effort : void 0;
-      if (typeof effort === "string") {
-        const slug = effort.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-        if (slug) slugs.add(slug);
-      }
-    }
-  }
-  return [...slugs];
-}
-function titleFromLabel(sourceLabel) {
-  if (!sourceLabel || sourceLabel === "-") return "stdin";
-  const stem = sourceLabel.split("/").pop() ?? sourceLabel;
-  return stem.replace(/\.[^.]+$/, "") || sourceLabel;
-}
-async function saveSource(db, options, startTime) {
-  const noteId = options.noteId ?? stableNoteId(options.sourceLabel, options.source);
-  const observed = await db.storage.readonly("notes").get(noteId);
-  const expected = options.expectedSourceRevision ?? observed?.sourceRevision ?? 0;
-  const now = options.now ?? Date.now();
-  return db.storage.transaction([...saveStores], "readwrite", async (tx) => {
-    const existing = await tx.readonly("notes").get(noteId);
-    if ((existing?.sourceRevision ?? 0) !== expected) {
-      throw new Error(`Stale Note source revision for ${noteId}; expected ${expected}`);
-    }
-    let sourceRevision = existing?.rawContent === options.source ? existing.sourceRevision : (existing?.sourceRevision ?? 0) + 1;
-    const blocks = reconcileNoteBlocks(options.source, {
-      sourceRevision,
-      blocks: options.blocks ?? (existing?.rawContent === options.source ? existing.blocks : void 0),
-      registeredWidgets,
-      createId: randomId
-    });
-    validateNoteBlocks(options.source, blocks, sourceRevision, { registeredWidgets });
-    const history = await tx.readonly("block_revisions").getAllFromIndex("by-note", noteId);
-    const latest = /* @__PURE__ */ new Map();
-    for (const row of history) {
-      if ((latest.get(row.blockId)?.version ?? 0) < row.version) latest.set(row.blockId, row);
-    }
-    const revisions = [];
-    for (const block of Object.values(blocks)) {
-      const saved = latest.get(block.id);
-      const rawContent = options.source.slice(block.from, block.to);
-      const unchanged = saved && saved.rawContent === rawContent && saved.kind === block.kind && saved.dialect === block.dialect && saved.sport === block.sport;
-      block.version = unchanged ? saved.version : (saved?.version ?? 0) + 1;
-      if (!unchanged) revisions.push({
-        noteId,
-        blockId: block.id,
-        version: block.version,
-        kind: block.kind,
-        rawContent,
-        savedAt: now,
-        ...block.dialect ? { dialect: block.dialect } : {},
-        ...block.sport ? { sport: block.sport } : {}
-      });
-    }
-    if (existing?.rawContent === options.source && !rowsEqual(existing.blocks, blocks)) {
-      sourceRevision++;
-      for (const block of Object.values(blocks)) block.sourceRevision = sourceRevision;
-    }
-    const note = {
-      ...existing,
-      id: noteId,
-      title: options.title ?? existing?.title ?? titleFromLabel(options.sourceLabel),
-      type: existing?.type ?? "note",
-      date: existing?.date ?? now,
-      createdAt: existing?.createdAt ?? now,
-      rawContent: options.source,
-      sourceRevision,
-      blocks
-    };
-    const priorRows = await tx.readonly("block_index").getAllFromIndex("by-note", noteId);
-    const priorEfforts = await tx.readonly("block_efforts").getAllFromIndex("by-note", noteId);
-    const priorById = new Map(priorRows.map((row) => [row.id, row]));
-    const nextRows = [];
-    const nextEfforts = [];
-    for (const [position, block] of Object.values(blocks).sort((a, b) => a.from - b.from).entries()) {
-      const id = `${noteId}:${block.id}`;
-      const prior = priorById.get(id);
-      const rawContent = options.source.slice(block.from, block.to);
-      const body = parseDocumentSections(rawContent, { registeredWidgets })[0]?.displayContent ?? rawContent;
-      const fingerprint = block.kind === "wod" ? blockContentId(body) : void 0;
-      nextRows.push({
-        ...prior,
-        id,
-        noteId,
-        blockId: block.id,
-        blockVersion: block.version,
-        dataType: block.kind,
-        sourceRevision,
-        from: block.from,
-        to: block.to,
-        position,
-        rawContent,
-        noteTitle: note.title,
-        createdAt: prior?.createdAt ?? now,
-        blockContentId: fingerprint,
-        ...note.sourceId ? { sourceId: note.sourceId } : {}
-      });
-      if (block.kind === "wod") {
-        for (const effortSlug of extractEffortSlugs(parseScript(body, { sport: block.sport, dialect: block.dialect }).statements)) {
-          const effortId = `${noteId}:${block.id}:${effortSlug}`;
-          const previous = priorEfforts.find((row) => row.id === effortId);
-          nextEfforts.push({
-            ...previous,
-            id: effortId,
-            noteId,
-            blockId: block.id,
-            blockContentId: fingerprint,
-            effortSlug,
-            createdAt: previous?.createdAt ?? now
-          });
-        }
-      }
-    }
-    if (!rowsEqual(existing, note)) await tx.readwrite("notes").put(note);
-    if (revisions.length) await tx.readwrite("block_revisions").putMany(revisions);
-    await diffProjection(tx, "block_index", priorRows, nextRows);
-    await diffProjection(tx, "block_efforts", priorEfforts, nextEfforts);
-    const tags = await saveTags(tx, noteId, options.tags, now);
-    let session;
-    let revision;
-    if (startTime !== void 0) {
-      const block = Object.values(blocks).filter((row) => row.kind === "wod").sort((a, b) => a.from - b.from)[0];
-      if (!block) throw new Error("[wod run] Note has no actionable workout block");
-      revision = revisions.find((row) => row.blockId === block.id) ?? latest.get(block.id);
-      if (!revision) throw new Error("[wod run] Saved workout revision is unavailable");
-      session = {
-        id: randomId(),
-        noteId,
-        blockId: block.id,
-        blockVersion: block.version,
-        blockContentId: blockContentId(parseDocumentSections(revision.rawContent)[0]?.displayContent ?? revision.rawContent),
-        origin: "journal",
-        status: "in-progress",
-        startTime,
-        endTime: startTime,
-        duration: 0,
-        completed: false,
-        createdAt: startTime
-      };
-      await tx.readwrite("sessions").put(session);
-    }
-    return { noteId, note, blocks: nextRows.length, efforts: nextEfforts.length, tags, created: !existing, session, revision };
-  });
-}
-async function diffProjection(tx, store, previous, next) {
-  const nextIds = new Set(next.map((row) => row.id));
-  for (const row of previous) if (!nextIds.has(row.id)) await tx.readwrite(store).delete(row.id);
-  const old = new Map(previous.map((row) => [row.id, row]));
-  for (const row of next) {
-    if (!rowsEqual(old.get(row.id), row)) {
-      if (store === "block_index" && "blockVersion" in row) await tx.readwrite("block_index").put(row);
-      if (store === "block_efforts" && "effortSlug" in row) await tx.readwrite("block_efforts").put(row);
-    }
-  }
-}
-async function saveTags(tx, noteId, items, now) {
-  const previous = await tx.readonly("note_tags").getAllFromIndex("by-note", noteId);
-  if (!items) return previous.length;
-  const next = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const label = item.label.trim();
-    if (!label) continue;
-    const found = (await tx.readonly("tags").getAllFromIndex("by-label", label))[0];
-    const tag = found ? { ...found, ...!found.type && item.type ? { type: item.type } : {} } : { id: uuid5(CLI_UUID_NAMESPACE, `tag:${label}`), label, type: item.type, createdAt: now };
-    if (!rowsEqual(found, tag)) await tx.readwrite("tags").put(tag);
-    const id = previous.find((link) => link.tagId === tag.id)?.id ?? uuid5(CLI_UUID_NAMESPACE, `note-tag:${noteId}:${tag.id}`);
-    next.set(id, { ...previous.find((link) => link.id === id), id, noteId, tagId: tag.id });
-  }
-  for (const link of previous) if (!next.has(link.id)) await tx.readwrite("note_tags").delete(link.id);
-  const old = new Map(previous.map((row) => [row.id, row]));
-  for (const link of next.values()) if (!rowsEqual(old.get(link.id), link)) await tx.readwrite("note_tags").put(link);
-  return next.size;
-}
-function persistNote(db, options) {
-  return saveSource(db, options);
-}
-async function startRun(db, options, startTime = Date.now()) {
-  const saved = await saveSource(db, options, startTime);
-  if (!saved.session || !saved.revision) throw new Error("[wod run] Atomic run capture failed");
-  return { session: saved.session, revision: saved.revision, noteCreated: saved.created };
-}
-async function persistRun(db, started, executionLog) {
-  const results = executionLog.results;
-  const session = {
-    ...started.session,
-    status: results.completed ? "completed" : "in-progress",
-    endTime: results.endTime,
-    duration: results.duration ?? 0,
-    completed: results.completed
-  };
-  const identity = {
-    noteId: session.noteId,
-    resultId: session.id,
-    blockId: session.blockId,
-    blockVersion: session.blockVersion,
-    blockContentId: session.blockContentId,
-    origin: session.origin,
-    pageId: session.pageId,
-    workoutTimestamp: session.createdAt
-  };
-  const events = toEventRows(executionLog.logs, identity);
-  const summaries = toSummaryEventRows(executionLog.logs, identity);
-  await db.storage.transaction(["sessions", "events", "block_revisions"], "readwrite", async (tx) => {
-    const saved = await tx.readonly("sessions").get(session.id);
-    if (!saved || saved.noteId !== session.noteId || saved.blockId !== session.blockId || saved.blockVersion !== session.blockVersion) {
-      throw new Error("[wod run] Captured Session source pin changed");
-    }
-    const revision = await tx.readonly("block_revisions").get([session.noteId, session.blockId, session.blockVersion]);
-    if (!revision || !rowsEqual(revision, started.revision)) throw new Error("[wod run] Captured revision is unavailable");
-    await tx.readwrite("sessions").put(session);
-    await tx.readwrite("events").putMany([...events, ...summaries]);
-  });
-  return { noteId: session.noteId, resultId: session.id, session, events: events.length, summaries: summaries.length, noteCreated: started.noteCreated };
-}
-async function persistSessionBundle(db, session, events) {
-  if ("segmentId" in session || "segmentVersion" in session || "version" in session || "rawContent" in session || "data" in session || !session.noteId || !session.blockId || !Number.isSafeInteger(session.blockVersion) || session.blockVersion < 1) {
-    throw new Error("[wod import] Session requires an exact block revision pin");
-  }
-  await db.storage.transaction(["sessions", "events", "block_revisions"], "readwrite", async (tx) => {
-    const revision = await tx.readonly("block_revisions").get([session.noteId, session.blockId, session.blockVersion]);
-    if (!revision || revision.kind !== "wod") throw new Error("[wod import] Exact immutable workout revision is unavailable");
-    for (const event of events) {
-      if (event.resultId !== session.id || event.noteId !== session.noteId || event.blockId !== session.blockId || event.blockVersion !== session.blockVersion) {
-        throw new Error("[wod import] Event source pin differs from Session source pin");
-      }
-    }
-    const existing = await tx.readonly("sessions").get(session.id);
-    if (existing && !rowsEqual(existing, session)) throw new Error("[wod import] Session identity conflicts with existing row");
-    if (!existing) await tx.readwrite("sessions").put(session);
-    for (const event of events) {
-      const old = await tx.readonly("events").get(event.id);
-      if (old && !rowsEqual(old, event)) throw new Error("[wod import] Event identity conflicts with existing row");
-      if (!old) await tx.readwrite("events").put(event);
-    }
-  });
-  return { events: events.length };
-}
-async function persistEffort(db, effort) {
-  const sql = await loadSql();
-  await db.db.transaction(async (tx) => {
-    await sql.putRow(tx, sql.storeDefinition("efforts"), effort);
-  });
-}
-async function persistTypedTags(db, labels, type) {
-  return db.storage.transaction(["tags"], "readwrite", async (tx) => {
-    let added = 0;
-    for (const raw of labels) {
-      const label = raw.trim();
-      if (!label) continue;
-      const tag = (await tx.readonly("tags").getAllFromIndex("by-label", label))[0];
-      if (!tag) {
-        await tx.readwrite("tags").put({ id: uuid5(CLI_UUID_NAMESPACE, `tag:${label}`), label, type, createdAt: Date.now() });
-        added++;
-      } else if (!tag.type) {
-        await tx.readwrite("tags").put({ ...tag, type });
-      }
-    }
-    return added;
-  });
-}
-
-// src/cli/seed.ts
-async function importSeedDir(db, dir, sourceId) {
-  const fs = nodeFs(), path = nodePath();
-  const source = sourceId || path.basename(dir);
-  const manifest = assertSeedManifest(JSON.parse(fs.readFileSync(path.resolve(dir, "manifest.json"), "utf-8")));
-  const key = seedMetaKey(source);
-  let expected = await db.storage.readonly("meta").get(key);
-  if (expected && expected.schema !== SEED_SCHEMA) throw new Error("Incompatible seed checkpoint; recreate storage");
-  let meta = expected ?? emptySeedMeta(key);
-  if (manifest.version < meta.seedVersion) throw new Error("Seed manifest is older than stored checkpoint");
-  const summary = { sourceId: source, version: manifest.version, notes: 0, efforts: 0, blocks: 0, blockEfforts: 0, deleted: 0, skippedUserOwned: 0 };
-  const metadataChanged = manifest.version !== meta.seedVersion || manifest.builtAt !== meta.builtAt;
-  const plan = manifest.chunks.filter((c) => metadataChanged || meta.chunks[c.id]?.sha256 !== c.sha256);
-  plan.sort((a, b) => Number(b.id === CANVAS_CHUNK_ID) - Number(a.id === CANVAS_CHUNK_ID));
-  const accumulate = (result) => {
-    summary.notes += result.totalNotes;
-    summary.efforts += result.totalEfforts;
-    summary.blocks += result.totalBlocks;
-    summary.deleted += result.deleted;
-    summary.skippedUserOwned += result.skippedUserOwned;
-  };
-  for (const chunk of plan) {
-    const rows = assertSeedRows(JSON.parse(fs.readFileSync(path.resolve(dir, chunk.path), "utf-8")));
-    if (rows.length !== chunk.count) throw new Error("Seed chunk count mismatch");
-    const next = { ...meta, chunks: { ...meta.chunks, [chunk.id]: { sha256: chunk.sha256, noteIds: await Promise.all(rows.map((r) => seedNoteId(r.path))) } }, importedAt: Date.now() };
-    accumulate(await applySeedChunk(db.storage, { chunkId: chunk.id, rows, manifest, expectedMeta: expected, meta: next }));
-    summary.blockEfforts += rows.reduce((count, row) => count + row.blockEfforts.length, 0);
-    meta = next;
-    expected = next;
-  }
-  for (const chunkId of Object.keys(meta.chunks)) {
-    if (manifest.chunks.some((c) => c.id === chunkId)) continue;
-    const chunks = { ...meta.chunks };
-    delete chunks[chunkId];
-    const next = { ...meta, chunks, importedAt: Date.now() };
-    accumulate(await applySeedChunk(db.storage, { chunkId, rows: [], manifest, expectedMeta: expected, meta: next }));
-    meta = next;
-    expected = next;
-  }
-  if (plan.length || metadataChanged || Object.keys(meta.chunks).length !== Object.keys(expected?.chunks ?? {}).length) {
-    const next = { ...meta, schema: SEED_SCHEMA, seedVersion: manifest.version, builtAt: manifest.builtAt, importedAt: Date.now() };
-    await applySeedChunk(db.storage, { chunkId: null, rows: [], manifest, expectedMeta: expected, meta: next });
-  }
-  return summary;
-}
-function defaultSeedDirs(cwd) {
-  const base = nodePath().resolve(cwd, "apps", "playground", "public", "seed");
-  return ["core", "community"].map((id) => nodePath().resolve(base, id)).filter((dir) => nodeFs().existsSync(nodePath().resolve(dir, "manifest.json")));
-}
-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 cliNoteSource(source, label, sport) {
-  if (/\.(?:md|markdown)$/i.test(label) || parseDocumentSections(source).some((section) => section.scriptBlock)) return source;
-  let length = 3;
-  for (const match of source.matchAll(/`+/g)) length = Math.max(length, match[0].length + 1);
-  const fence = "`".repeat(length);
-  return `${fence}time${sport ? `:${sport}` : ""}
-${source}
-${fence}
-`;
-}
-function parseCliArgs(args) {
-  const result = {
-    format: "json",
-    packs: [],
-    sources: []
-  };
-  let i = 0;
-  while (i < args.length) {
-    const arg = args[i];
-    if (arg === "--at" || arg.startsWith("--at=")) throw new Error("Unknown option --at; whole Note exports have no as-of version");
-    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 === "--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
-                     (whole source + saved revisions + sparse block index), optionally emit parse-tree IR.
-                     Markdown carrying a 'wod-note-id' frontmatter stamp
-                     (see download) imports back into that same note.
-  run <file | ->      Execute the script state machine, record a session +
-                     event/summary rows in the database, optionally emit
-                     execution-log IR
-  query '<wql>'       Evaluate WQL against the database (or an explicit
-                     dataset) and emit QueryResult / RowsQueryResult IR
-  download note <id>  Export the note's authored markdown to <id>.md.
-                     The frontmatter identity stamp allows re-import.
-                     Frontmatter tags (general + typed equipment/quality/\u2026)
-                     are materialized into the tag graph on parse/import.
-  download session <id>
-                     Write the session's generated metrics (event + summary
-                     rows, one CSV row per metric) to <id>.csv. Import back
-                     with 'wod import session'.
-  download effort <slug>
-                     Write the effort registry row as corpus-style markdown
-                     (frontmatter id/slug/label/aliases/baseAttributes + body)
-                     to <slug>.md. Import back with 'wod import effort'.
-  download equipment
-                     Write every equipment tag as a one-column CSV to
-                     equipment.csv. Import back with 'wod import equipment'.
-  import note <file>  Re-import exported note markdown (same as parse with
-                     the stamped identity).
-  import session <file>
-                     Import a session + its events from a downloaded CSV.
-                     The exact saved block revision must already exist.
-  import effort <file>
-                     Upsert an effort registry row from corpus-style markdown.
-  import equipment <file>
-                     Create/upgrade equipment tags (CSV, one label per row).
-  build [dir]         Compile a seed corpus: validate every .md under
-                     <dir>/markdown (parity gate + dashboard format gate) and
-                     write manifest.json + content-hashed chunks/ +
-                     report.html to <dir>/dist with source/maps/projections bundled
-                     (override with -o/--output). Version stamps derive from
-                     <dir>'s git history (full checkout required).
-
-BUILD OPTIONS (for 'build'):
-  --scaffold          Also scaffold markdown/efforts/discovered/*.md stubs for
-                      workout effort labels missing from the registry.
-  --template <file>   Compile an extra markdown file as the 'template' chunk
-                      (the host's playground intake template).
-
-INPUT SOURCING (for 'query'; without these, the database is queried):
-  -c, --corpus <path> Load historical corpus dataset from a versioned JSON file
-  --stdin-log         Read kind: 'execution-log' JSON payload from stdin
-  --stdin-facts       Read raw kind: 'fact-set' JSON payload from stdin
-
-DATABASE (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
-  --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;
-  let parsed;
-  try {
-    parsed = parseCliArgs(argv);
-  } catch (error) {
-    writeErr(error instanceof Error ? error.message : String(error));
-    return 1;
-  }
-  if (parsed.version || parsed.subcommand === "version") {
-    writeOut(`wod v${VERSION}`);
-    return 0;
-  }
-  if (parsed.help || parsed.subcommand === "help") {
-    printUsage(writeOut);
-    return 0;
-  }
-  if (!parsed.subcommand) {
-    printUsage(writeErr);
-    return 1;
-  }
-  for (const packSpec of parsed.packs) {
-    try {
-      await loadLanguagePack(packSpec);
-    } catch (err) {
-      if (err instanceof PackLoadError) {
-        writeErr(err.message);
-      } else {
-        writeErr(`[wod] Language pack load error: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      return 3;
-    }
-  }
-  const deliverOutput = (formattedText) => {
-    if (parsed.output && parsed.output !== "-") {
-      getFs2().writeFileSync(parsed.output, formattedText, "utf-8");
-    } else {
-      writeOut(formattedText);
-    }
-  };
-  const debugTarget = (subcommand) => parsed.debug === void 0 ? void 0 : parsed.debug || `wod-${subcommand}-debug.json`;
-  const writeDebugFile = (subcommand, ir) => {
-    const target = debugTarget(subcommand);
-    if (target !== void 0) {
-      getFs2().writeFileSync(target, JSON.stringify(ir, null, 2) + "\n", "utf-8");
-    }
-  };
-  try {
-    if (parsed.subcommand === "parse") {
-      if (!parsed.target) {
-        writeErr('[wod parse] Error: Missing input file or "-" for stdin');
-        return 1;
-      }
-      let source;
-      if (parsed.target === "-") {
-        source = await getStdin();
-      } else {
-        const fs = getFs2();
-        if (!fs.existsSync(parsed.target)) {
-          writeErr(`[wod parse] File not found: ${parsed.target}`);
-          return 1;
-        }
-        source = fs.readFileSync(parsed.target, "utf-8");
-      }
-      const noteSource = cliNoteSource(source, parsed.target, parsed.sport);
-      const ir = runParse(source, { sport: parsed.sport, sourceLabel: `cli:wod parse ${parsed.target}` });
-      const identity = extractNoteIdentity(source);
-      const tags = extractTypedTags(source);
-      const db = await openCliDb(parsed.db);
-      try {
-        const persisted = await persistNote(db, {
-          source: noteSource,
-          sourceLabel: parsed.target,
-          noteId: identity?.noteId,
-          title: identity?.title,
-          tags
-        });
-        writeOut(
-          `[wod parse] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.blocks} blocks, ${persisted.efforts} efforts${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db.path}`
-        );
-      } finally {
-        await db.close();
-      }
-      if (parsed.output) {
-        const pretty = Boolean(process.stdout.isTTY);
-        deliverOutput(formatParseOutput(ir, parsed.format, pretty));
-      }
-      writeDebugFile("parse", ir);
-      return 0;
-    }
-    if (parsed.subcommand === "run") {
-      if (!parsed.target) {
-        writeErr('[wod run] Error: Missing input file or "-" for stdin');
-        return 1;
-      }
-      let source;
-      if (parsed.target === "-") {
-        source = await getStdin();
-      } else {
-        const fs = getFs2();
-        if (!fs.existsSync(parsed.target)) {
-          writeErr(`[wod run] File not found: ${parsed.target}`);
-          return 1;
-        }
-        source = fs.readFileSync(parsed.target, "utf-8");
-      }
-      const identity = extractNoteIdentity(source);
-      const db = await openCliDb(parsed.db);
-      let ir;
-      try {
-        const started = await startRun(db, {
-          source: cliNoteSource(source, parsed.target, parsed.sport),
-          sourceLabel: parsed.target,
-          noteId: identity?.noteId,
-          title: identity?.title,
-          tags: extractTypedTags(source)
-        });
-        const section = parseDocumentSections(started.revision.rawContent).find((row) => row.scriptBlock);
-        if (!section?.scriptBlock) throw new Error("[wod run] Captured workout source cannot be parsed");
-        const bare = !/\.(?:md|markdown)$/i.test(parsed.target) && !parseDocumentSections(source).some((row) => row.scriptBlock);
-        const frozenBody = bare ? section.scriptBlock.content.slice(0, -1) : section.scriptBlock.content;
-        ir = await runExecution(frozenBody, {
-          sport: started.revision.sport,
-          dialect: started.revision.dialect,
-          blockId: started.session.blockId,
-          blockVersion: started.session.blockVersion,
-          startTime: started.session.startTime,
-          sourceLabel: `cli:wod run ${parsed.target}`
-        });
-        const persisted = await persistRun(db, started, ir.data);
-        writeOut(
-          `[wod run] session ${persisted.resultId} \u2014 ${persisted.events} events, ${persisted.summaries} summaries on note ${persisted.noteId} \u2192 ${db.path}`
-        );
-      } finally {
-        await db.close();
-      }
-      if (parsed.output) {
-        const pretty = Boolean(process.stdout.isTTY);
-        deliverOutput(formatExecutionOutput(ir, parsed.format, pretty));
-      }
-      writeDebugFile("run", ir);
-      return 0;
-    }
-    if (parsed.subcommand === "query") {
-      if (!parsed.target) {
-        writeErr("[wod query] Error: Missing WQL query argument");
-        return 1;
-      }
-      const useDb = !parsed.corpus && !parsed.stdinLog && !parsed.stdinFacts;
-      let stdinLogContent;
-      let stdinFactsContent;
-      if (parsed.stdinLog) {
-        stdinLogContent = await getStdin();
-      } else if (parsed.stdinFacts) {
-        stdinFactsContent = await getStdin();
-      }
-      let ir;
-      if (useDb) {
-        const 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> [-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 markdown = composeNoteMarkdown(bundle.note);
-          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}.md`;
-          if (parsed.output === "-") {
-            writeOut(markdown);
-          } else {
-            nodeFs().writeFileSync(target, markdown, "utf-8");
-          }
-          if (parsed.output !== "-") writeOut(`[wod download] note ${id} \u2192 ${target}`);
-        } else if (kind === "session") {
-          const bundle = await getSessionBundle(db.db, targetId);
-          if (!bundle) {
-            writeErr(`[wod download] Session not found in ${db.path}: ${id}`);
-            return 1;
-          }
-          const csv = sessionToCsv(bundle.session, bundle.events);
-          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}.csv`;
-          if (parsed.output === "-") {
-            writeOut(csv);
-          } else {
-            nodeFs().writeFileSync(target, csv, "utf-8");
-          }
-          if (parsed.output !== "-") writeOut(`[wod download] session ${id} \u2192 ${target} (${bundle.events.length} events)`);
-        } else if (kind === "effort") {
-          const effort = await getEffortBySlug(db.db, targetId);
-          if (!effort) {
-            writeErr(`[wod download] Effort not found in ${db.path}: ${id}`);
-            return 1;
-          }
-          const markdown = effortToMarkdown(effort);
-          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}.md`;
-          if (parsed.output === "-") {
-            writeOut(markdown);
-          } else {
-            nodeFs().writeFileSync(target, markdown, "utf-8");
-          }
-          writeOut(`[wod download] effort ${id} \u2192 ${target}`);
-        } else {
-          const labels = (await listTagsByType(db.db, "equipment")).map((t) => t.label).sort();
-          const csv = equipmentToCsv(labels);
-          const target = parsed.output && parsed.output !== "-" ? parsed.output : "equipment.csv";
-          if (parsed.output === "-") {
-            writeOut(csv);
-          } else {
-            nodeFs().writeFileSync(target, csv, "utf-8");
-          }
-          writeOut(`[wod download] equipment \u2192 ${target} (${labels.length} labels)`);
-        }
-      } finally {
-        await db.close();
-      }
-      return 0;
-    }
-    if (parsed.subcommand === "import") {
-      const kind = parsed.target;
-      const file = parsed.target2;
-      const IMPORT_KINDS = ["note", "session", "effort", "equipment"];
-      if (!file || !IMPORT_KINDS.includes(kind ?? "")) {
-        writeErr("[wod import] Usage: wod import <note|session|effort|equipment> <file>");
-        return 1;
-      }
-      const fs = nodeFs();
-      if (!fs.existsSync(file)) {
-        writeErr(`[wod import] File not found: ${file}`);
-        return 1;
-      }
-      if (kind === "note") {
-        const source = fs.readFileSync(file, "utf-8");
-        const identity = extractNoteIdentity(source);
-        const tags = extractTypedTags(source);
-        const db2 = await openCliDb(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.blocks} blocks${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db2.path}`
-          );
-        } finally {
-          await db2.close();
-        }
-        return 0;
-      }
-      if (kind === "effort") {
-        const effort = markdownToEffort(fs.readFileSync(file, "utf-8"));
-        if (!effort) {
-          writeErr(`[wod import] Unparseable effort file (need frontmatter id/slug/label + numeric baseAttributes.met): ${file}`);
-          return 1;
-        }
-        const db2 = await openCliDb(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 \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-SXUCF7AU.mjs');
-      try {
-        const result = generateSeed({
-          corpusRoot: root,
-          ...parsed.output ? { outDir: nodePath().resolve(cwd, parsed.output) } : {},
-          ...parsed.template ? { templateFile: nodePath().resolve(cwd, parsed.template) } : {},
-          scaffoldDiscoveredEfforts: parsed.scaffold === true
-        });
-        const kb = (n) => `${(n / 1024).toFixed(0)} KB`;
-        const totalBytes = result.manifest.chunks.reduce((s, c) => s + c.bytes, 0);
-        writeOut(`[wod build] schema v${result.manifest.schema} version ${result.manifest.version} (${result.manifest.versionLabel}) \u2192 ${result.outDir}`);
-        for (const c of result.manifest.chunks) {
-          writeOut(`  ${c.id.padEnd(48)} ${String(c.count).padStart(4)} files  ${kb(c.bytes).padStart(8)}`);
-        }
-        writeOut(`[wod build] ${result.manifest.chunks.length} chunks, ${result.totalFiles} files, ${kb(totalBytes)} total \u2014 scan ${result.passMs.scan}ms, block-index ${result.passMs.blockIndex}ms, block-efforts ${result.passMs.blockEfforts}ms, write ${result.passMs.write}ms`);
-        return 0;
-      } catch (error) {
-        writeErr(`[wod build] ${error.message}`);
-        return 1;
-      }
-    }
-    if (parsed.subcommand === "seed") {
-      const dirs = parsed.sources.length > 0 ? parsed.sources.map((s) => nodePath().resolve(process.cwd(), s)) : defaultSeedDirs(process.cwd());
-      if (dirs.length === 0) {
-        writeErr(
-          "[wod seed] No seed sources found. Run `bun scripts/sync-seed.ts` to build the bundled artifacts, or pass --source <dir> pointing at a compiled seed directory (manifest.json + chunks)."
-        );
-        return 1;
-      }
-      const db = await openCliDb(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, applySeedChunk, assertSeedManifest, assertSeedRows, buildStatementTree, buildWorkoutResults, cliMain, composeNoteMarkdown, createIRFile, csvToEquipmentLabels, csvToSessionRows, defineLanguagePack, effortToMarkdown, equipmentToCsv, extractNoteIdentity, extractTypedTags, formatExecutionOutput, formatParseOutput, formatQueryOutput, getRegisteredLanguagePacks, inMemoryEventStore, injectIdentityFrontmatter, isIRFile, listLanguagePacks, loadLanguagePack, loadQueryData, markdownToEffort, parseCliArgs, parseCsvLine, readFrontmatterMeta, readStdin, registerLanguagePack, runExecution, runParse, runQueryCli, seedNoteId, sessionToCsv, splitCsvRecords, statementToNode, unregisterLanguagePack };
-//# sourceMappingURL=chunk-N4KFWY6Z.mjs.map
-//# sourceMappingURL=chunk-N4KFWY6Z.mjs.map