@bitcobblers/wod-wiki-engine 0.11.43 → 0.35.2116

package/dist/chunk-QFWJKM45.mjs

@@ -1,1041 +0,0 @@
-import { dialectRegistry, realtimeProcessorRegistry, summaryProcessorRegistry, getHints, createParser, toStoredOutputStatement, frozenNow, createCompiler, createMockClock, RuntimeStack, EventBus, ScriptRuntime, createAnalyticsEngineForBlock, StartSessionAction, NextEvent, bundledEfforts } from '@bitcobblers/wod-wiki-lang';
-import { MetricType } from '@bitcobblers/wod-wiki-core';
-import { parseQuery, QueryService, isFindQuery, isRowsQuery, toEventRows, toSummaryEventRows } from '@bitcobblers/wod-wiki-wql';
-
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var 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 factRowsToEventRows(facts) {
-  return facts.map((f, i) => {
-    const metricKey = f.metricKey ?? f.type;
-    return {
-      id: `fact:${f.resultId}:${metricKey}:${i}`,
-      resultId: f.resultId,
-      noteId: f.noteId,
-      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: metricKey,
-        value: f.value,
-        ...f.unit ? { unit: f.unit } : {},
-        metadata: {
-          canonicalKey: metricKey,
-          ...f.effortSlug ? { effortSlug: f.effortSlug } : {},
-          ...f.discipline ? { effortDiscipline: f.discipline } : {},
-          ...f.intensityTier ? { effortIntensityTier: f.intensityTier } : {}
-        }
-      }],
-      segmentId: f.segmentId,
-      segmentVersion: f.segmentVersion
-    };
-  });
-}
-function inMemoryEventStore(events) {
-  const rows = [...events];
-  return {
-    getEventsByTimeRange: async (start, end) => rows.filter((r) => r.timestamp >= start && r.timestamp <= end),
-    getEventsByResult: async (resultId) => rows.filter((r) => r.resultId === resultId),
-    getEventsForNote: async (noteId) => rows.filter((r) => r.noteId === noteId),
-    getEventsByContent: async (blockContentId) => rows.filter((r) => r.blockContentId === blockContentId),
-    scanAll: async () => rows,
-    appendEvents: async (appended) => {
-      rows.push(...appended);
-    },
-    finalizeSummaries: async (resultId, finals) => {
-      for (let i = rows.length - 1; i >= 0; i--) {
-        const row = rows[i];
-        if (row.resultId === resultId && row.grain === "summary" && row.origin !== "user") rows.splice(i, 1);
-      }
-      rows.push(...finals);
-    },
-    deleteEvents: async (ids) => {
-      const doomed = new Set(ids);
-      for (let i = rows.length - 1; i >= 0; i--) {
-        if (doomed.has(rows[i].id)) rows.splice(i, 1);
-      }
-    }
-  };
-}
-function inMemoryEventStoreFromFacts(facts) {
-  return inMemoryEventStore(factRowsToEventRows(facts));
-}
-var inMemoryFactStore = inMemoryEventStoreFromFacts;
-function createIRFile(kind, data, optionsOrSource, generatedAt) {
-  let source = "wod:headless";
-  let genAt = Date.now();
-  if (typeof optionsOrSource === "string") {
-    source = optionsOrSource;
-    if (generatedAt !== void 0) genAt = generatedAt;
-  } else if (optionsOrSource && typeof optionsOrSource === "object") {
-    if (optionsOrSource.source) source = optionsOrSource.source;
-    if (optionsOrSource.generatedAt !== void 0) genAt = optionsOrSource.generatedAt;
-  }
-  return {
-    $schema: "https://wod-wiki.dev/ir/v1.json",
-    kind,
-    generatedAt: genAt,
-    source,
-    data
-  };
-}
-function isIRFile(obj) {
-  if (!obj || typeof obj !== "object") return false;
-  const cand = obj;
-  return cand.$schema === "https://wod-wiki.dev/ir/v1.json" && typeof cand.kind === "string" && typeof cand.generatedAt === "number" && typeof cand.source === "string" && "data" in cand;
-}
-function statementToNode(stmt, idMap) {
-  const meta = stmt.meta;
-  const metrics = stmt.metrics.toArray().map((m) => ({
-    type: m.type,
-    ...m.image !== void 0 ? { image: m.image } : {},
-    ...m.value !== void 0 ? { value: m.value } : {},
-    ...m.origin !== void 0 ? { origin: m.origin } : {}
-  }));
-  const raw = meta?.raw ?? "";
-  const from = meta?.startOffset ?? 0;
-  const to = meta?.endOffset ?? from + raw.length;
-  const durationFrag = stmt.metrics.find((m) => m.type === MetricType.Duration || m.type === "duration");
-  const roundsFrag = stmt.metrics.find((m) => m.type === MetricType.Rounds || m.type === "rounds");
-  const type = durationFrag ? "duration" : roundsFrag ? "rounds" : "statement";
-  const hints = getHints(stmt);
-  const childIds = (stmt.children ?? []).flat();
-  const children = childIds.map((cid) => idMap.get(cid)).filter((c) => c !== void 0).map((c) => statementToNode(c, idMap));
-  return {
-    id: stmt.id,
-    type,
-    raw,
-    from,
-    to,
-    metrics,
-    ...hints.length > 0 ? { hints } : {},
-    ...children.length > 0 ? { children } : {}
-  };
-}
-function buildStatementTree(script) {
-  const idMap = new Map(script.statements.map((s) => [s.id, s]));
-  const topLevel = script.statements.filter((s) => s.parent === void 0 || !idMap.has(s.parent));
-  if (topLevel.length === 1 && topLevel[0].children.length > 0) {
-    return statementToNode(topLevel[0], idMap);
-  }
-  return {
-    id: 0,
-    type: "root",
-    raw: script.source,
-    from: 0,
-    to: script.source.length,
-    metrics: [],
-    children: topLevel.map((s) => statementToNode(s, idMap))
-  };
-}
-var ParseSyntaxError = class extends Error {
-  constructor(errors, message = "Parse error in Whiteboard Script") {
-    const details = errors.map((e) => e.message).join("; ");
-    super(`${message}: ${details}`);
-    this.errors = errors;
-    this.name = "ParseSyntaxError";
-  }
-  errors;
-};
-function runParse(source, options = {}) {
-  const parser = createParser();
-  const script = parser.read(source, options.sport);
-  if (script.errors && script.errors.length > 0) {
-    throw new ParseSyntaxError(script.errors);
-  }
-  const tree = buildStatementTree(script);
-  return createIRFile("parse-tree", tree, { source: options.sourceLabel ?? "cli:wod parse" });
-}
-function buildWorkoutResults(outputs, options) {
-  return {
-    startTime: options.startTime ?? options.now.nowMs(),
-    endTime: options.now.nowMs(),
-    duration: options.elapsedTime,
-    completed: options.completed,
-    logs: outputs.map(toStoredOutputStatement)
-  };
-}
-async function runExecution(source, options = {}) {
-  const parser = createParser();
-  const script = parser.read(source, options.sport);
-  if (script.errors && script.errors.length > 0) {
-    throw new ParseSyntaxError(script.errors);
-  }
-  const startTime = options.startTime ?? Date.now();
-  const now = options.now ?? frozenNow(new Date(startTime));
-  const compiler = createCompiler();
-  const clock = createMockClock(new Date(startTime));
-  const stack = new RuntimeStack();
-  const eventBus = new EventBus();
-  const runtime = new ScriptRuntime(
-    script,
-    compiler,
-    { stack, clock, eventBus },
-    {},
-    now
-  );
-  const { engine, analyticsContext } = createAnalyticsEngineForBlock({
-    id: "cli-block",
-    content: source,
-    statements: script.statements,
-    sport: options.sport,
-    version: 1,
-    startLine: 0,
-    endLine: 0,
-    dialect: "time",
-    state: "idle",
-    createdAt: Date.now()
-  });
-  runtime.analyticsContext = analyticsContext;
-  runtime.setAnalyticsEngine(engine);
-  const outputs = [];
-  runtime.subscribeToOutput((out) => {
-    outputs.push(out);
-  });
-  runtime.do(new StartSessionAction());
-  const maxSteps = options.maxIterations ?? 5e3;
-  let steps = 0;
-  while (stack.count > 0 && steps < maxSteps) {
-    runtime.handle(new NextEvent(void 0, runtime.nowProvider));
-    clock.advance(1e3);
-    steps++;
-  }
-  const workoutResults = buildWorkoutResults(outputs, {
-    startTime,
-    elapsedTime: steps * 1e3,
-    completed: stack.count === 0,
-    now
-  });
-  const logs = outputs.map(toStoredOutputStatement);
-  return createIRFile(
-    "execution-log",
-    {
-      results: workoutResults,
-      logs,
-      statements: logs
-    },
-    { source: options.sourceLabel ?? "cli:wod run" }
-  );
-}
-function getFs() {
-  if (typeof globalThis.process?.versions?.node === "undefined" && typeof globalThis.Bun === "undefined") {
-    throw new Error("File system operations are only supported in Node / Bun environments");
-  }
-  return __require("fs");
-}
-var WqlSyntaxError = class extends Error {
-  constructor(query, syntaxError) {
-    super(`WQL Syntax Error in "${query}": ${syntaxError}`);
-    this.query = query;
-    this.syntaxError = syntaxError;
-    this.name = "WqlSyntaxError";
-  }
-  query;
-  syntaxError;
-};
-function factsFromExecutionLog(log, resultId = "stdin-result-1") {
-  const facts = [];
-  for (const s of log.logs) {
-    const started = s.timeSpan?.started ?? s.timestamp ?? Date.now();
-    for (const m of s.metrics) {
-      const mType = m.type || "metric";
-      const numVal = typeof m.value === "number" ? m.value : Number(m.value);
-      facts.push({
-        id: `fact-${s.id ?? 0}-${mType}-${facts.length + 1}`,
-        noteId: "stdin-note-1",
-        blockContentId: s.sourceBlockKey || "stdin-block-1",
-        segmentId: s.sourceBlockKey || "stdin-seg-1",
-        segmentVersion: 1,
-        resultId,
-        grain: s.outputType === "analytics" ? "summary" : "event",
-        type: mType,
-        value: Number.isNaN(numVal) ? 0 : numVal,
-        unit: m.unit,
-        label: m.label || mType,
-        metricKey: mType,
-        metricLabel: m.label || mType,
-        timestamp: started,
-        createdAt: started
-      });
-    }
-  }
-  return facts;
-}
-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)}`);
-  }
-}
-function buildStoresFromData(data) {
-  const identity = (r) => ({
-    noteId: r.noteId,
-    resultId: r.id,
-    segmentId: r.segmentId,
-    segmentVersion: r.segmentVersion,
-    blockContentId: r.blockContentId,
-    origin: r.origin,
-    pageId: r.pageId,
-    workoutTimestamp: r.createdAt
-  });
-  const events = [
-    ...factRowsToEventRows(data.facts),
-    ...data.results.flatMap((r) => {
-      const logs = r.data.logs ?? [];
-      return [...toEventRows(logs, identity(r)), ...toSummaryEventRows(logs, identity(r))];
-    })
-  ];
-  const eventStore = inMemoryEventStore(events);
-  const noteStore = {
-    getAllNotes: async () => [...data.notes],
-    getNoteIdsForTag: async (tag) => {
-      const matching = /* @__PURE__ */ new Set();
-      for (const [noteId, tags] of Object.entries(data.noteTags)) {
-        if (tags.includes(tag)) matching.add(noteId);
-      }
-      return matching;
-    },
-    getNoteTagLabels: async (noteId) => [...data.noteTags[noteId] ?? []]
-  };
-  const blockStore = {
-    getAllBlocks: async () => [...data.blocks]
-  };
-  const effortStore = {
-    getAllEfforts: async () => [...data.efforts]
-  };
-  return { eventStore, noteStore, blockStore, effortStore };
-}
-function loadQueryData(options) {
-  const data = {
-    facts: [],
-    results: [],
-    notes: [],
-    blocks: [],
-    efforts: [...bundledEfforts],
-    noteTags: {}
-  };
-  if (options.corpusPath) {
-    const fs = getFs();
-    if (!fs.existsSync(options.corpusPath)) {
-      throw new Error(`Corpus file not found at path: ${options.corpusPath}`);
-    }
-    const raw = fs.readFileSync(options.corpusPath, "utf-8");
-    const payload = extractPayload(raw);
-    if (Array.isArray(payload)) {
-      data.facts = payload;
-    } else if (payload && typeof payload === "object") {
-      const corpus = payload;
-      if (corpus.facts) data.facts = corpus.facts;
-      if (corpus.results) data.results = corpus.results;
-      if (corpus.notes) data.notes = corpus.notes;
-      if (corpus.blocks) data.blocks = corpus.blocks;
-      if (corpus.efforts) data.efforts = corpus.efforts;
-      if (corpus.tags) data.noteTags = corpus.tags;
-      if (corpus.logs && (!corpus.results || corpus.results.length === 0)) {
-        const syntheticResult = {
-          id: "corpus-result-1",
-          noteId: "corpus-note-1",
-          blockContentId: "corpus-block-1",
-          origin: "journal",
-          createdAt: corpus.logs[0]?.timeSpan?.started ?? Date.now(),
-          data: {
-            startTime: corpus.logs[0]?.timeSpan?.started ?? Date.now(),
-            endTime: corpus.logs[corpus.logs.length - 1]?.timeSpan?.ended ?? Date.now(),
-            duration: 0,
-            completed: true,
-            logs: corpus.logs
-          }
-        };
-        data.results = [syntheticResult];
-      }
-    }
-  } else if (options.stdinLog) {
-    const payload = extractPayload(options.stdinLog);
-    let executionLog;
-    const rawLogs = payload.logs ?? payload.statements ?? [];
-    if ("results" in payload) {
-      executionLog = { results: payload.results, logs: rawLogs, statements: rawLogs };
-    } else {
-      executionLog = { results: payload, logs: rawLogs, statements: rawLogs };
-    }
-    const resultId = "stdin-result-1";
-    const workoutResult = {
-      id: resultId,
-      noteId: "stdin-note-1",
-      blockContentId: "stdin-block-1",
-      origin: "journal",
-      createdAt: executionLog.results.startTime,
-      data: {
-        ...executionLog.results,
-        logs: executionLog.logs
-      }
-    };
-    data.results = [workoutResult];
-    data.facts = factsFromExecutionLog(executionLog, resultId);
-  } else if (options.stdinFacts) {
-    const payload = extractPayload(options.stdinFacts);
-    if (Array.isArray(payload)) {
-      data.facts = payload;
-    } else if (payload && typeof payload === "object" && "facts" in payload) {
-      data.facts = payload.facts;
-    }
-  } else {
-    throw new Error("No input dataset provided. Specify --corpus <path>, --stdin-log, or --stdin-facts.");
-  }
-  return data;
-}
-async function runQueryCli(wqlString, options = {}) {
-  const parsed = parseQuery(wqlString);
-  if (parsed.error) {
-    throw new WqlSyntaxError(wqlString, parsed.error);
-  }
-  const stores = buildStoresFromData(loadQueryData(options));
-  const service = new QueryService(
-    stores.eventStore,
-    stores.noteStore,
-    stores.blockStore,
-    stores.effortStore
-  );
-  if (isFindQuery(parsed)) {
-    const result2 = await service.runFind(parsed);
-    return createIRFile("find-result", result2, { source: options.sourceLabel ?? "cli:wod query" });
-  }
-  if (isRowsQuery(parsed)) {
-    const result2 = await service.runRows(parsed);
-    return createIRFile("rows-result", 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" && typeof globalThis.Bun === "undefined") {
-    throw new Error("Path resolution is only supported in Node / Bun environments");
-  }
-  return {
-    resolve: __require("path").resolve,
-    pathToFileURL: __require("url").pathToFileURL
-  };
-}
-var PackLoadError = class extends Error {
-  constructor(spec, originalError) {
-    const msg = originalError instanceof Error ? originalError.message : String(originalError);
-    super(`Failed to load Language Pack "${spec}": ${msg}`);
-    this.spec = spec;
-    this.originalError = originalError;
-    this.name = "PackLoadError";
-  }
-  spec;
-  originalError;
-};
-async function loadLanguagePack(moduleSpec) {
-  try {
-    let importPath = moduleSpec;
-    if (moduleSpec.startsWith(".") || moduleSpec.startsWith("/") || moduleSpec.includes("\\") || moduleSpec.endsWith(".ts") || moduleSpec.endsWith(".js") || moduleSpec.endsWith(".mjs")) {
-      const { resolve, pathToFileURL } = getPathUtils();
-      const resolved = resolve(process.cwd(), moduleSpec);
-      importPath = pathToFileURL(resolved).href;
-    }
-    const imported = await import(
-      /* @vite-ignore */
-      importPath
-    );
-    const candidate = imported.default ?? imported.pack ?? imported;
-    if (!candidate || typeof candidate !== "object") {
-      throw new Error(`Module "${moduleSpec}" does not export a valid LanguagePack object`);
-    }
-    const pack = candidate;
-    registerLanguagePack(pack);
-    return pack;
-  } catch (error) {
-    if (error instanceof PackLoadError) throw error;
-    throw new PackLoadError(moduleSpec, error);
-  }
-}
-
-// src/cli/formatters.ts
-function escapeCsvField(field) {
-  if (field === void 0 || field === null) return "";
-  const str = String(field);
-  if (str.includes(",") || str.includes('"') || str.includes("\n") || str.includes("\r")) {
-    return `"${str.replace(/"/g, '""')}"`;
-  }
-  return str;
-}
-function formatDate(ts) {
-  if (!ts) return "-";
-  try {
-    return new Date(ts).toISOString();
-  } catch {
-    return String(ts);
-  }
-}
-function formatMetricValue(m) {
-  if (m.image) return m.image;
-  if (m.value === void 0 || m.value === null) return "";
-  if (typeof m.value === "object") return JSON.stringify(m.value);
-  return String(m.value);
-}
-function formatMetric(m) {
-  const t = m.type || "metric";
-  return `${t}:${formatMetricValue(m)}`;
-}
-function formatParseOutput(ir, format, pretty = true) {
-  if (format === "json") {
-    return JSON.stringify(ir, null, pretty ? 2 : void 0);
-  }
-  const flatNodes = [];
-  const walk = (node) => {
-    flatNodes.push(node);
-    for (const child of node.children ?? []) {
-      walk(child);
-    }
-  };
-  walk(ir.data);
-  if (format === "csv") {
-    const header = "id,type,from,to,raw,metrics,hints";
-    const rows = flatNodes.map(
-      (n) => [
-        n.id,
-        n.type,
-        n.from,
-        n.to,
-        escapeCsvField(n.raw),
-        escapeCsvField(n.metrics.map(formatMetric).join("; ")),
-        escapeCsvField(n.hints?.join("; ") ?? "")
-      ].join(",")
-    );
-    return [header, ...rows].join("\n");
-  }
-  const lines = [];
-  lines.push(`Parse Tree (${flatNodes.length} statements):`);
-  lines.push("\u2500".repeat(80));
-  lines.push(
-    ["ID".padEnd(6), "Type".padEnd(12), "Span".padEnd(12), "Hints".padEnd(20), "Raw Text"].join(" | ")
-  );
-  lines.push("\u2500".repeat(80));
-  for (const n of flatNodes) {
-    const span = `${n.from}-${n.to}`;
-    const hints = (n.hints ?? []).join(", ");
-    lines.push(
-      [
-        String(n.id).padEnd(6),
-        n.type.padEnd(12),
-        span.padEnd(12),
-        (hints.length > 18 ? hints.slice(0, 15) + "..." : hints).padEnd(20),
-        n.raw.replace(/\n/g, "\\n")
-      ].join(" | ")
-    );
-  }
-  return lines.join("\n");
-}
-function formatExecutionOutput(ir, format, pretty = true) {
-  if (format === "json") {
-    return JSON.stringify(ir, null, pretty ? 2 : void 0);
-  }
-  const { results, logs } = ir.data;
-  const statements = logs;
-  if (format === "csv") {
-    const header = "id,outputType,started,ended,sourceBlockKey,stackLevel,completionReason,metrics,hints";
-    const rows = statements.map(
-      (s) => [
-        s.id,
-        s.outputType,
-        s.timeSpan?.started ?? s.timestamp ?? 0,
-        s.timeSpan?.ended ?? "",
-        escapeCsvField(s.sourceBlockKey),
-        s.stackLevel,
-        escapeCsvField(s.completionReason ?? ""),
-        escapeCsvField(s.metrics.map(formatMetric).join("; ")),
-        escapeCsvField(s.hints?.join("; ") ?? "")
-      ].join(",")
-    );
-    return [header, ...rows].join("\n");
-  }
-  const lines = [];
-  lines.push(`Workout Execution Results:`);
-  lines.push(`  Duration:  ${results.duration}ms`);
-  lines.push(`  Completed: ${results.completed ? "yes" : "no"}`);
-  lines.push(`  Start:     ${formatDate(results.startTime)}`);
-  lines.push(`  End:       ${formatDate(results.endTime)}`);
-  lines.push(`  Logs:      ${statements.length} statements emitted`);
-  lines.push("\u2500".repeat(80));
-  lines.push(
-    ["ID".padEnd(8), "Type".padEnd(12), "Block".padEnd(18), "Reason".padEnd(15), "Metrics"].join(" | ")
-  );
-  lines.push("\u2500".repeat(80));
-  for (const s of statements) {
-    const metricsStr = s.metrics.map(formatMetric).join(", ");
-    lines.push(
-      [
-        String(s.id).padEnd(8),
-        (s.outputType ?? "segment").padEnd(12),
-        (s.sourceBlockKey ?? "-").padEnd(18),
-        (s.completionReason ?? "-").padEnd(15),
-        metricsStr
-      ].join(" | ")
-    );
-  }
-  return lines.join("\n");
-}
-function formatQueryOutput(ir, format, pretty = true) {
-  if (format === "json") {
-    return JSON.stringify(ir, null, pretty ? 2 : void 0);
-  }
-  const kind = ir.kind;
-  if (kind === "rows-result") {
-    const data2 = ir.data;
-    if (format === "csv") {
-      const header = "resultId,timestamp,outputType,eventId,metrics";
-      const rows = [];
-      for (const run of data2.runs) {
-        for (const event of run.events) {
-          rows.push(
-            [
-              run.resultId,
-              run.timestamp,
-              event.outputType,
-              event.id,
-              escapeCsvField(event.metrics.map(formatMetric).join("; "))
-            ].join(",")
-          );
-        }
-      }
-      return [header, ...rows].join("\n");
-    }
-    const lines2 = [];
-    lines2.push(`Rows Query Result (${data2.runs.length} runs):`);
-    if (data2.error) lines2.push(`Error: ${data2.error}`);
-    lines2.push("\u2500".repeat(80));
-    lines2.push(
-      ["Result ID".padEnd(20), "Date".padEnd(24), "Events"].join(" | ")
-    );
-    lines2.push("\u2500".repeat(80));
-    for (const run of data2.runs) {
-      lines2.push(
-        [
-          run.resultId.padEnd(20),
-          formatDate(run.timestamp).padEnd(24),
-          String(run.events.length)
-        ].join(" | ")
-      );
-    }
-    return lines2.join("\n");
-  }
-  if (kind === "find-result") {
-    const data2 = ir.data;
-    if (format === "csv") {
-      const header = "target,id,title_or_label,sourceId";
-      const rows = [];
-      for (const n of data2.notes) {
-        rows.push(["note", n.id, escapeCsvField(n.title), escapeCsvField(n.sourceId ?? "")].join(","));
-      }
-      for (const b of data2.blocks) {
-        rows.push(["block", b.id, escapeCsvField(b.noteTitle), escapeCsvField(b.sourceId ?? "")].join(","));
-      }
-      for (const e of data2.efforts ?? []) {
-        rows.push(["effort", e.id, escapeCsvField(e.label), escapeCsvField(e.slug)].join(","));
-      }
-      return [header, ...rows].join("\n");
-    }
-    const lines2 = [];
-    const matchedCount2 = data2.stages?.matched ?? 0;
-    const selectedCount = data2.stages?.selected ?? 0;
-    lines2.push(`Find Result (matched: ${matchedCount2} / selected: ${selectedCount}):`);
-    lines2.push("\u2500".repeat(80));
-    lines2.push(["Type".padEnd(8), "ID".padEnd(24), "Title / Label".padEnd(30), "Source ID"].join(" | "));
-    lines2.push("\u2500".repeat(80));
-    for (const n of data2.notes) {
-      lines2.push(["note".padEnd(8), n.id.padEnd(24), n.title.padEnd(30), n.sourceId ?? "-"].join(" | "));
-    }
-    for (const b of data2.blocks) {
-      lines2.push(["block".padEnd(8), b.id.padEnd(24), b.noteTitle.padEnd(30), b.sourceId ?? "-"].join(" | "));
-    }
-    for (const e of data2.efforts ?? []) {
-      lines2.push(["effort".padEnd(8), e.id.padEnd(24), e.label.padEnd(30), e.slug].join(" | "));
-    }
-    return lines2.join("\n");
-  }
-  const data = ir.data;
-  if (data.scalar !== void 0 && data.series.length === 0) {
-    if (format === "csv") {
-      return `metric,scalar,unit
-${escapeCsvField(data.parsed.metric)},${data.scalar},${escapeCsvField(data.unit ?? "")}`;
-    }
-    return `Scalar Result: ${data.scalar}${data.unit ? " " + data.unit : ""}`;
-  }
-  if (format === "csv") {
-    const header = "series,timestamp,date,value,unit";
-    const rows = [];
-    for (const s of data.series) {
-      for (const pt of s.points) {
-        rows.push(
-          [
-            escapeCsvField(s.label || s.key),
-            pt.ts,
-            formatDate(pt.ts),
-            pt.value,
-            escapeCsvField(s.unit ?? data.unit ?? "")
-          ].join(",")
-        );
-      }
-    }
-    return [header, ...rows].join("\n");
-  }
-  const lines = [];
-  const matchedCount = data.stages?.matched ?? data.stages?.selected ?? data.matched?.length ?? 0;
-  lines.push(`Query Result (${data.series.length} series, ${matchedCount} matched facts):`);
-  lines.push(
-    ["Series / Group".padEnd(20), "Timestamp".padEnd(16), "Date".padEnd(24), "Value".padEnd(12), "Unit"].join(" | ")
-  );
-  lines.push("\u2500".repeat(80));
-  for (const s of data.series) {
-    for (const pt of s.points) {
-      lines.push(
-        [
-          (s.label || s.key).padEnd(20),
-          String(pt.ts).padEnd(16),
-          formatDate(pt.ts).padEnd(24),
-          String(pt.value).padEnd(12),
-          s.unit ?? data.unit ?? "-"
-        ].join(" | ")
-      );
-    }
-  }
-  return lines.join("\n");
-}
-
-// src/cli/runner.ts
-function getFs2() {
-  if (typeof globalThis.process?.versions?.node === "undefined" && typeof globalThis.Bun === "undefined") {
-    throw new Error("File system operations are only supported in Node / Bun environments");
-  }
-  return __require("fs");
-}
-var VERSION = "0.6.0";
-function parseCliArgs(args) {
-  const result = {
-    format: "json",
-    packs: []
-  };
-  let i = 0;
-  while (i < args.length) {
-    const arg = args[i];
-    if (arg === "--help" || arg === "-h") {
-      result.help = true;
-      i++;
-    } else if (arg === "--version" || arg === "-v") {
-      result.version = true;
-      i++;
-    } else if (arg === "--corpus" || arg === "-c") {
-      result.corpus = args[++i];
-      i++;
-    } else if (arg === "--stdin-log") {
-      result.stdinLog = true;
-      i++;
-    } else if (arg === "--stdin-facts") {
-      result.stdinFacts = true;
-      i++;
-    } else if (arg === "--format") {
-      const fmt = args[++i];
-      if (fmt === "json" || fmt === "table" || fmt === "csv") {
-        result.format = fmt;
-      }
-      i++;
-    } else if (arg.startsWith("--format=")) {
-      const fmt = arg.slice("--format=".length);
-      if (fmt === "json" || fmt === "table" || fmt === "csv") {
-        result.format = fmt;
-      }
-      i++;
-    } else if (arg === "-o" || arg === "--output") {
-      result.output = args[++i];
-      i++;
-    } else if (arg.startsWith("--output=")) {
-      result.output = arg.slice("--output=".length);
-      i++;
-    } else if (arg === "--pack") {
-      const packSpec = args[++i];
-      if (packSpec) result.packs.push(packSpec);
-      i++;
-    } else if (arg.startsWith("--pack=")) {
-      result.packs.push(arg.slice("--pack=".length));
-      i++;
-    } else if (arg === "--sport") {
-      result.sport = args[++i];
-      i++;
-    } else if (arg === "--unit") {
-      result.unit = args[++i];
-      i++;
-    } else if (!result.subcommand) {
-      if (arg === "parse" || arg === "run" || arg === "query" || arg === "help" || arg === "version") {
-        result.subcommand = arg;
-      } else {
-        result.target = arg;
-      }
-      i++;
-    } else if (!result.target) {
-      result.target = arg;
-      i++;
-    } else {
-      i++;
-    }
-  }
-  return result;
-}
-async function readStdin() {
-  if (typeof globalThis.Bun?.stdin?.text === "function") {
-    return globalThis.Bun.stdin.text();
-  }
-  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]
-
-SUBCOMMANDS:
-  parse <file | ->    Parse Whiteboard Script into AST StatementNode IR (kind: 'parse-tree')
-  run <file | ->      Execute Whiteboard Script state machine and emit ExecutionLog IR (kind: 'execution-log')
-  query '<wql>'       Evaluate WQL query and emit QueryResult / RowsQueryResult / FindQueryResult IR
-
-INPUT SOURCING (for 'query'):
-  -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
-
-OPTIONS:
-  --format <fmt>      Output format: json (default), table, csv
-  -o, --output <path> Write output to a file instead of stdout
-  --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 {
-    console.log(text);
-  }
-}
-async function cliMain(argv = process.argv.slice(2), io = {}) {
-  const writeOut = io.stdout ?? ((t) => process.stdout.write(t + "\n"));
-  const writeErr = io.stderr ?? ((t) => process.stderr.write(t + "\n"));
-  const getStdin = io.readStdinFn ?? readStdin;
-  const parsed = parseCliArgs(argv);
-  if (parsed.version || parsed.subcommand === "version") {
-    writeOut(`wod v${VERSION}`);
-    return 0;
-  }
-  if (parsed.help || parsed.subcommand === "help") {
-    printUsage(writeOut);
-    return 0;
-  }
-  if (!parsed.subcommand) {
-    printUsage(writeErr);
-    return 1;
-  }
-  for (const packSpec of parsed.packs) {
-    try {
-      await loadLanguagePack(packSpec);
-    } catch (err) {
-      if (err instanceof PackLoadError) {
-        writeErr(err.message);
-      } else {
-        writeErr(`[wod] Language pack load error: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      return 3;
-    }
-  }
-  const deliverOutput = (formattedText) => {
-    if (parsed.output) {
-      getFs2().writeFileSync(parsed.output, formattedText, "utf-8");
-    } else {
-      writeOut(formattedText);
-    }
-  };
-  try {
-    if (parsed.subcommand === "parse") {
-      if (!parsed.target) {
-        writeErr('[wod parse] Error: Missing input file or "-" for stdin');
-        return 1;
-      }
-      let source;
-      if (parsed.target === "-") {
-        source = await getStdin();
-      } else {
-        const fs = getFs2();
-        if (!fs.existsSync(parsed.target)) {
-          writeErr(`[wod parse] File not found: ${parsed.target}`);
-          return 1;
-        }
-        source = fs.readFileSync(parsed.target, "utf-8");
-      }
-      const ir = runParse(source, { sport: parsed.sport, sourceLabel: `cli:wod parse ${parsed.target}` });
-      const pretty = !parsed.output && Boolean(process.stdout.isTTY);
-      const formatted = formatParseOutput(ir, parsed.format, pretty);
-      deliverOutput(formatted);
-      return 0;
-    }
-    if (parsed.subcommand === "run") {
-      if (!parsed.target) {
-        writeErr('[wod run] Error: Missing input file or "-" for stdin');
-        return 1;
-      }
-      let source;
-      if (parsed.target === "-") {
-        source = await getStdin();
-      } else {
-        const fs = getFs2();
-        if (!fs.existsSync(parsed.target)) {
-          writeErr(`[wod run] File not found: ${parsed.target}`);
-          return 1;
-        }
-        source = fs.readFileSync(parsed.target, "utf-8");
-      }
-      const ir = await runExecution(source, { sport: parsed.sport, sourceLabel: `cli:wod run ${parsed.target}` });
-      const pretty = !parsed.output && Boolean(process.stdout.isTTY);
-      const formatted = formatExecutionOutput(ir, parsed.format, pretty);
-      deliverOutput(formatted);
-      return 0;
-    }
-    if (parsed.subcommand === "query") {
-      if (!parsed.target) {
-        writeErr("[wod query] Error: Missing WQL query argument");
-        return 1;
-      }
-      let stdinLogContent;
-      let stdinFactsContent;
-      if (parsed.stdinLog) {
-        stdinLogContent = await getStdin();
-      } else if (parsed.stdinFacts) {
-        stdinFactsContent = await getStdin();
-      } else if (!parsed.corpus) {
-        writeErr("[wod query] Error: Query requires input data. Specify --corpus <file>, --stdin-log, or --stdin-facts.");
-        return 1;
-      }
-      const 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);
-      return 0;
-    }
-    writeErr(`[wod] Unknown subcommand "${parsed.subcommand}"`);
-    return 1;
-  } catch (error) {
-    if (error instanceof ParseSyntaxError || error instanceof WqlSyntaxError) {
-      writeErr(error.message);
-      return 2;
-    }
-    if (error instanceof PackLoadError) {
-      writeErr(error.message);
-      return 3;
-    }
-    writeErr(`[wod] Error: ${error instanceof Error ? error.message : String(error)}`);
-    return 1;
-  }
-}
-
-export { PackLoadError, ParseSyntaxError, WqlSyntaxError, buildStatementTree, buildWorkoutResults, cliMain, createIRFile, defineLanguagePack, factRowsToEventRows, formatExecutionOutput, formatParseOutput, formatQueryOutput, getRegisteredLanguagePacks, inMemoryEventStore, inMemoryEventStoreFromFacts, inMemoryFactStore, isIRFile, listLanguagePacks, loadLanguagePack, loadQueryData, parseCliArgs, readStdin, registerLanguagePack, runExecution, runParse, runQueryCli, statementToNode, unregisterLanguagePack };
-//# sourceMappingURL=chunk-QFWJKM45.mjs.map
-//# sourceMappingURL=chunk-QFWJKM45.mjs.map