@bitcobblers/wod-wiki-engine 0.35.2115 → 0.35.2117

package/dist/{chunk-B2OYLNEZ.mjs → chunk-AKNXDA75.mjs}

@@ -1,8 +1,9 @@
 import { createRequire } from 'module';
-import { __require } from './chunk-6L5ZDZJ7.mjs';
+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, parseDocumentSections } from '@bitcobblers/wod-wiki-core';
-import { WQL_TYPED_TAG_KEYS, toEventRows, parseQuery, QueryService, isPipelineQuery, isFindQuery, toSummaryEventRows } from '@bitcobblers/wod-wiki-wql';
+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 {}
@@ -67,7 +68,7 @@ function inMemoryEventStore(events) {
     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),
+    getEventsByContent: async (blockContentId4) => rows.filter((r) => r.blockContentId === blockContentId4),
     scanAll: async () => rows,
     appendEvents: async (appended) => {
       rows.push(...appended);
@@ -201,14 +202,14 @@ async function runExecution(source, options = {}) {
     now
   );
   const { engine, analyticsContext } = createAnalyticsEngineForBlock({
-    id: "cli-block",
+    id: options.blockId ?? "cli-block",
     content: source,
     statements: script.statements,
     sport: options.sport,
-    version: 1,
+    version: options.blockVersion ?? 1,
     startLine: 0,
     endLine: 0,
-    dialect: "time",
+    dialect: options.dialect ?? "time",
     state: "idle",
     createdAt: Date.now()
   });
@@ -238,7 +239,8 @@ async function runExecution(source, options = {}) {
     {
       results: workoutResults,
       logs,
-      statements: logs
+      statements: logs,
+      sourceScript: source
     },
     { source: options.sourceLabel ?? "cli:wod run" }
   );
@@ -259,10 +261,6 @@ var WqlSyntaxError = class extends Error {
   query;
   syntaxError;
 };
-function legacyLogsOf(result) {
-  const legacy = result;
-  return legacy.data?.logs ?? [];
-}
 function extractPayload(rawJson) {
   try {
     const parsed = JSON.parse(rawJson);
@@ -275,16 +273,6 @@ function extractPayload(rawJson) {
   }
 }
 function buildStoresFromData(data) {
-  const identity = (r) => ({
-    noteId: r.noteId,
-    resultId: r.id,
-    segmentId: r.segmentId,
-    segmentVersion: r.segmentVersion,
-    blockContentId: r.blockContentId,
-    origin: r.origin,
-    pageId: r.pageId,
-    workoutTimestamp: r.createdAt
-  });
   const events = [
     ...data.eventRecords,
     ...data.facts.map((f, i) => ({
@@ -304,17 +292,17 @@ function buildStoresFromData(data) {
         ...f.unit ? { unit: f.unit } : {},
         origin: "engine"
       }],
-      segmentId: f.segmentId,
-      segmentVersion: f.segmentVersion
-    })),
-    ...data.results.flatMap((r) => {
-      const logs = legacyLogsOf(r);
-      return [...toEventRows(logs, identity(r)), ...toSummaryEventRows(logs, identity(r))];
-    })
+      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)) {
@@ -339,6 +327,7 @@ function loadQueryData(options) {
     results: [],
     notes: [],
     blocks: [],
+    revisions: [],
     efforts: [...bundledEfforts],
     noteTags: {}
   };
@@ -353,7 +342,10 @@ function loadQueryData(options) {
       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;
         }
@@ -372,20 +364,16 @@ function loadQueryData(options) {
         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 && (!corpus.results || corpus.results.length === 0)) {
-          const syntheticResult = {
-            id: "corpus-result-1",
+        if (corpus.logs) {
+          const identity = {
             noteId: "corpus-note-1",
-            blockContentId: "corpus-block-1",
+            resultId: "corpus-result-1",
             origin: "journal",
-            createdAt: corpus.logs[0]?.timeSpan?.started ?? Date.now(),
-            startTime: corpus.logs[0]?.timeSpan?.started ?? Date.now(),
-            endTime: corpus.logs[corpus.logs.length - 1]?.timeSpan?.ended ?? Date.now(),
-            duration: 0,
-            completed: true
+            workoutTimestamp: corpus.logs[0]?.timeSpan?.started ?? Date.now()
           };
-          data.results = [syntheticResult];
+          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)`);
@@ -400,29 +388,16 @@ function loadQueryData(options) {
     } else {
       executionLog = { results: payload, logs: rawLogs, statements: rawLogs };
     }
-    const resultId = "stdin-result-1";
-    const workoutResult = {
-      id: resultId,
+    const identity = {
       noteId: "stdin-note-1",
-      blockContentId: "stdin-block-1",
+      resultId: "stdin-result-1",
       origin: "journal",
-      createdAt: executionLog.results.startTime,
-      startTime: executionLog.results.startTime,
-      endTime: executionLog.results.endTime,
-      duration: executionLog.results.duration ?? 0,
-      completed: executionLog.results.completed
+      workoutTimestamp: executionLog.results.startTime
     };
-    data.results = [workoutResult];
-    data.eventRecords = toEventRows(executionLog.logs, {
-      noteId: workoutResult.noteId,
-      resultId: workoutResult.id,
-      segmentId: workoutResult.segmentId,
-      segmentVersion: workoutResult.segmentVersion,
-      blockContentId: workoutResult.blockContentId,
-      origin: workoutResult.origin,
-      pageId: workoutResult.pageId,
-      workoutTimestamp: workoutResult.createdAt
-    });
+    data.eventRecords = [
+      ...toEventRows(executionLog.logs, identity),
+      ...toSummaryEventRows(executionLog.logs, identity)
+    ];
   } else if (options.stdinFacts) {
     const payload = extractPayload(options.stdinFacts);
     if (Array.isArray(payload)) {
@@ -433,6 +408,60 @@ function loadQueryData(options) {
   } 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 = {}) {
@@ -538,10 +567,9 @@ function injectIdentityFrontmatter(markdown, identity) {
   };
   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 `---
-${lines2.join("\n")}
----${markdown.slice(block[0].length)}`;
+    return `---${newline}${lines2.join(newline)}${newline}---${markdown.slice(block[0].length)}`;
   }
   const lines = stamp([]);
   return `---
@@ -550,35 +578,8 @@ ${lines.join("\n")}
 
 ${markdown}`;
 }
-function segmentToFragment(segment) {
-  if (segment.sourceContent !== void 0) return segment.sourceContent;
-  if (segment.dataType === "wod") {
-    const block = segment.data;
-    const dialect = block?.dialect ?? "time";
-    const fenceTag = block?.sport ? `${dialect}:${block.sport}` : dialect;
-    return `\`\`\`${fenceTag}
-${segment.rawContent}
-\`\`\``;
-  }
-  if (segment.dataType === "frontmatter") {
-    return `---
-${segment.rawContent}
----`;
-  }
-  return segment.rawContent;
-}
-function composeNoteMarkdown(note, segments, version) {
-  const pool = version === void 0 ? segments.filter((s) => s.isHistory !== true) : segments;
-  const cap = version ?? Number.MAX_SAFE_INTEGER;
-  const bySegmentId = {};
-  for (const segment of pool) {
-    if (segment.version > cap) continue;
-    const current = bySegmentId[segment.id];
-    if (!current || segment.version > current.version) bySegmentId[segment.id] = segment;
-  }
-  const picked = Object.values(bySegmentId).sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
-  const markdown = picked.map(segmentToFragment).join("");
-  return injectIdentityFrontmatter(markdown, { noteId: note.id, title: note.title });
+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) {
@@ -701,9 +702,8 @@ function csvToEquipmentLabels(csv) {
 var SESSION_HEADER = [
   "sessionId",
   "noteId",
-  "segmentId",
-  "segmentVersion",
   "blockId",
+  "blockVersion",
   "blockContentId",
   "origin",
   "status",
@@ -711,7 +711,8 @@ var SESSION_HEADER = [
   "endTime",
   "duration",
   "completed",
-  "sessionCreatedAt"
+  "sessionCreatedAt",
+  "sessionExtraJson"
 ];
 var EVENT_HEADER = [
   "eventId",
@@ -720,8 +721,8 @@ var EVENT_HEADER = [
   "timestamp",
   "pageId",
   "effortSlug",
-  "eventSegmentId",
-  "eventSegmentVersion",
+  "eventBlockId",
+  "eventBlockVersion",
   "eventBlockContentId",
   "eventOrigin",
   "timeSpan",
@@ -777,9 +778,8 @@ function sessionCells(session) {
   return [
     session.id,
     session.noteId,
-    session.segmentId,
-    session.segmentVersion,
     session.blockId,
+    session.blockVersion,
     session.blockContentId,
     session.origin,
     session.status,
@@ -787,7 +787,8 @@ function sessionCells(session) {
     session.endTime,
     session.duration,
     session.completed,
-    session.createdAt
+    session.createdAt,
+    JSON.stringify(session)
   ].map(escapeCsvField);
 }
 function metricCells(event, metric, index) {
@@ -798,8 +799,8 @@ function metricCells(event, metric, index) {
     event.timestamp,
     event.pageId,
     event.effortSlug,
-    event.segmentId,
-    event.segmentVersion,
+    event.blockId,
+    event.blockVersion,
     event.blockContentId,
     event.origin,
     event.timeSpan,
@@ -910,6 +911,9 @@ 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}"`);
@@ -919,13 +923,29 @@ function csvToSessionRows(csv) {
   const eventRows = /* @__PURE__ */ new Map();
   let session;
   const ensureSession = (cells) => {
-    if (session) return session;
+    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 = {
-      id: at(cells, "sessionId"),
-      noteId: at(cells, "noteId"),
-      segmentId: at(cells, "segmentId") || void 0,
-      segmentVersion: num(at(cells, "segmentVersion")),
-      blockId: at(cells, "blockId") || void 0,
+      ...extra,
+      id,
+      noteId,
+      blockId,
+      blockVersion,
       blockContentId: at(cells, "blockContentId") || void 0,
       origin: at(cells, "origin") || void 0,
       status: at(cells, "status") || void 0,
@@ -935,6 +955,9 @@ function csvToSessionRows(csv) {
       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)) {
@@ -946,6 +969,14 @@ function csvToSessionRows(csv) {
     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,
@@ -958,8 +989,8 @@ function csvToSessionRows(csv) {
         grain: nonempty(at(cells, "grain")) ?? extra.grain ?? "event",
         effortSlug: nonempty(at(cells, "effortSlug")) ?? extra.effortSlug,
         outputType: nonempty(at(cells, "outputType")) ?? extra.outputType ?? "event",
-        segmentId: nonempty(at(cells, "eventSegmentId")) ?? extra.segmentId,
-        segmentVersion: num(at(cells, "eventSegmentVersion")) ?? extra.segmentVersion,
+        blockId,
+        blockVersion,
         timeSpan: jsonCell(at(cells, "timeSpan")) ?? extra.timeSpan,
         sourceBlockKey: nonempty(at(cells, "sourceBlockKey")) ?? extra.sourceBlockKey,
         sourceStatementId: num(at(cells, "sourceStatementId")) ?? extra.sourceStatementId,
@@ -970,9 +1001,8 @@ function csvToSessionRows(csv) {
         completionReason: nonempty(at(cells, "completionReason")) ?? extra.completionReason,
         representationKind: nonempty(at(cells, "representationKind")) ?? extra.representationKind,
         metrics: [],
-        // Rebuilt per-row from the metricTemporal column below — never
-        // inherited from the backstop, or rows would double-collect.
-        metricTemporal: void 0
+        // Rebuild anchors from metric rows while preserving an authored empty array.
+        metricTemporal: Array.isArray(extra.metricTemporal) ? [] : void 0
       };
       eventRows.set(eventId, event);
     }
@@ -997,6 +1027,268 @@ function csvToSessionRows(csv) {
   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 };
+  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;
+      }
+      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) {
@@ -1321,9 +1613,14 @@ async function openCliDb(dbPath) {
   const resolved = resolveDbPath(dbPath);
   nodeFs().mkdirSync(nodePath().dirname(resolved), { recursive: true });
   const db = sql.libsqlDatabase(createClient({ url: `file:${resolved}` }));
-  await sql.initializeStore(db);
-  await sql.initializeDomain(db);
-  return { db, path: resolved, close: () => db.close() };
+  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);
@@ -1357,7 +1654,7 @@ function sqliteEventStore(db) {
     getEventsByTimeRange: async (start, end) => (await all()).filter((r) => r.timestamp >= start && r.timestamp <= end),
     getEventsByResult: async (resultId) => (await all()).filter((r) => r.resultId === resultId),
     getEventsForNote: async (noteId) => (await all()).filter((r) => r.noteId === noteId),
-    getEventsByContent: async (blockContentId) => (await all()).filter((r) => r.blockContentId === blockContentId),
+    getEventsByContent: async (blockContentId4) => (await all()).filter((r) => r.blockContentId === blockContentId4),
     scanAll: all,
     appendEvents: async (appended) => {
       const sql = await loadSql();
@@ -1389,6 +1686,11 @@ function sqliteEventStore(db) {
 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);
@@ -1443,17 +1745,14 @@ function sqliteIndexStore(db, store) {
 }
 async function getNoteBundle(db, noteId) {
   const sql = await loadSql();
-  const notes = await allRows(sql, db, "notes");
-  const note = notes.find((n) => n.id === noteId);
-  const segments = await rowsByIndex(sql, db, "segments", "by-note", noteId);
-  return { note, segments };
+  const note = await sql.getRow(db, sql.storeDefinition("notes"), noteId);
+  return { note };
 }
 async function getSessionBundle(db, resultId) {
   const sql = await loadSql();
-  const sessions = await allRows(sql, db, "sessions");
-  const session = sessions.find((s) => s.id === resultId);
+  const session = await sql.getRow(db, sql.storeDefinition("sessions"), resultId);
   if (!session) return void 0;
-  const events = (await allRows(sql, db, "events")).filter((e) => e.resultId === resultId);
+  const events = await sql.listRows(db, sql.storeDefinition("events"), { only: resultId }, void 0, "by-result-grain");
   return { session, events };
 }
 async function getEffortBySlug(db, slug) {
@@ -1466,38 +1765,8 @@ async function listTagsByType(db, type) {
   const tags = await allRows(sql, db, "tags");
   return tags.filter((t) => t.type === type);
 }
-function toSegmentDataType(section) {
-  switch (section.type) {
-    case "time":
-    case "log":
-      return "wod";
-    case "title": {
-      const level = Math.min(6, Math.max(1, section.level ?? 1));
-      return `h${level}`;
-    }
-    case "frontmatter":
-      return "frontmatter";
-    case "markdown":
-    default:
-      return "markdown";
-  }
-}
-function sectionSourceFragments(content, sections) {
-  const starts = [0];
-  for (let i = 0; i < content.length; i++) {
-    if (content[i] === "\n") starts.push(i + 1);
-  }
-  return sections.map((section, index) => content.slice(
-    starts[section.startLine],
-    index + 1 < sections.length ? starts[sections[index + 1].startLine] : content.length
-  ));
-}
-function scriptBlockContentId(data) {
-  if (data && typeof data === "object" && "contentId" in data && typeof data.contentId === "string") {
-    return data.contentId;
-  }
-  return void 0;
-}
+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) {
@@ -1514,227 +1783,233 @@ function extractEffortSlugs(statements) {
   }
   return [...slugs];
 }
-async function rowsByNote(sql, db, store, noteId) {
-  return sql.listRows(db, sql.storeDefinition(store), { only: noteId }, void 0, "by-note");
-}
 function titleFromLabel(sourceLabel) {
   if (!sourceLabel || sourceLabel === "-") return "stdin";
   const stem = sourceLabel.split("/").pop() ?? sourceLabel;
   return stem.replace(/\.[^.]+$/, "") || sourceLabel;
 }
-async function persistNote(db, options) {
-  const sql = await loadSql();
-  const now = options.now ?? Date.now();
+async function saveSource(db, options, startTime) {
   const noteId = options.noteId ?? stableNoteId(options.sourceLabel, options.source);
-  const title = options.title ?? titleFromLabel(options.sourceLabel);
-  const sections = parseDocumentSections(options.source);
-  const fragments = sectionSourceFragments(options.source, sections);
-  const existingNote = await noteById(sql, db.db, noteId);
-  const priorSegments = await rowsByNote(sql, db.db, "segments", noteId);
-  const versionBySegmentId = {};
-  for (const segment of priorSegments) {
-    versionBySegmentId[segment.id] = Math.max(versionBySegmentId[segment.id] ?? 0, segment.version);
-  }
-  const createdAt = existingNote?.createdAt ?? now;
-  const note = {
-    id: noteId,
-    title,
-    type: existingNote?.type ?? "note",
-    date: existingNote?.date ?? now,
-    createdAt
-  };
-  const ops = [];
-  const segments = sections.map((section, position) => {
-    const id = `${noteId}:${section.id}`;
-    const version = (versionBySegmentId[id] ?? 0) + 1;
-    return {
-      id,
-      version,
-      noteId,
-      position,
-      dataType: toSegmentDataType(section),
-      data: section.scriptBlock || null,
-      rawContent: section.displayContent,
-      sourceContent: fragments[position],
-      createdAt: version === 1 ? createdAt : now,
-      updatedAt: now,
-      isHistory: false
+  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
     };
-  });
-  for (const segment of priorSegments) {
-    if (segment.isHistory !== true) {
-      ops.push({ op: "put", store: "segments", value: { ...segment, isHistory: true, updatedAt: now } });
-    }
-  }
-  ops.push({ op: "put", store: "notes", value: note });
-  for (const segment of segments) ops.push({ op: "put", store: "segments", value: segment });
-  const priorBlocks = await rowsByNote(sql, db.db, "block_index", noteId);
-  const priorBlockEfforts = await rowsByNote(sql, db.db, "block_efforts", noteId);
-  for (const row of priorBlocks) ops.push({ op: "delete", store: "block_index", key: row.id });
-  for (const row of priorBlockEfforts) ops.push({ op: "delete", store: "block_efforts", key: row.id });
-  let blockCount = 0;
-  let effortCount = 0;
-  for (const segment of segments) {
-    const blockContentId = segment.dataType === "wod" ? scriptBlockContentId(segment.data) : void 0;
-    ops.push({
-      op: "put",
-      store: "block_index",
-      value: {
-        id: `${noteId}:${segment.id}:${segment.version}`,
+    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,
-        segmentId: segment.id,
-        segmentVersion: segment.version,
-        position: segment.position,
-        dataType: segment.dataType,
-        blockContentId,
-        rawContent: segment.rawContent,
-        noteTitle: title,
-        createdAt: segment.createdAt
-      }
-    });
-    blockCount += 1;
-    if (segment.dataType === "wod" && segment.rawContent) {
-      const script = parseScript(segment.rawContent);
-      for (const effortSlug of extractEffortSlugs(script.statements)) {
-        ops.push({
-          op: "put",
-          store: "block_efforts",
-          value: {
-            id: `${noteId}:${segment.id}:${effortSlug}`,
+        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: segment.id,
-            blockContentId,
+            blockId: block.id,
+            blockContentId: fingerprint,
             effortSlug,
-            createdAt: segment.createdAt
-          }
-        });
-        effortCount += 1;
+            createdAt: previous?.createdAt ?? now
+          });
+        }
       }
     }
-  }
-  let tagCount = 0;
-  if (options.tags) {
-    const priorLinks = await rowsByNote(sql, db.db, "note_tags", noteId);
-    for (const link of priorLinks) ops.push({ op: "delete", store: "note_tags", key: link.id });
-    const tagByLabel = new Map(
-      (await sql.listRows(db.db, sql.storeDefinition("tags"))).map((t) => [t.label, t])
-    );
-    for (const item of options.tags) {
-      const label = item.label.trim();
-      if (!label) continue;
-      let tag = tagByLabel.get(label);
-      if (!tag) {
-        tag = { id: randomId(), label, type: item.type, createdAt: now };
-        tagByLabel.set(label, tag);
-        ops.push({ op: "put", store: "tags", value: tag });
-      } else if (item.type && !tag.type) {
-        tag = { ...tag, type: item.type };
-        tagByLabel.set(label, tag);
-        ops.push({ op: "put", store: "tags", value: tag });
-      }
-      tagCount += 1;
-      ops.push({
-        op: "put",
-        store: "note_tags",
-        // Deterministic junction id (unique [noteId, tagId] index).
-        value: { id: uuid5(CLI_UUID_NAMESPACE, `note-tag:${noteId}:${tag.id}`), noteId, tagId: tag.id }
-      });
+    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);
     }
-  }
-  await db.db.transaction(async (tx) => {
-    await sql.refreshDomain(tx, ops);
+    return { noteId, note, blocks: nextRows.length, efforts: nextEfforts.length, tags, created: !existing, session, revision };
   });
-  return {
-    noteId,
-    note,
-    segments: segments.length,
-    blocks: blockCount,
-    efforts: effortCount,
-    tags: tagCount,
-    created: !existingNote
-  };
 }
-async function noteById(sql, db, noteId) {
-  const rows = await sql.listRows(db, sql.storeDefinition("notes"));
-  return rows.find((row) => row.id === noteId);
+async function 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 persistRun(db, options) {
-  const sql = await loadSql();
-  const results = options.executionLog.results;
-  const logs = options.executionLog.logs ?? [];
-  const noteState = await persistNote(db, {
-    source: options.source,
-    sourceLabel: options.sourceLabel,
-    title: options.title,
-    now: options.now
-  });
-  const segments = (await rowsByNote(sql, db.db, "segments", noteState.noteId)).filter((s) => s.isHistory !== true && s.dataType === "wod").sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
-  const runSegment = segments[0];
-  const blockContentId = runSegment ? scriptBlockContentId(runSegment.data) : void 0;
-  const resultId = randomId();
+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 = {
-    id: resultId,
-    segmentId: runSegment?.id,
-    segmentVersion: runSegment?.version,
-    noteId: noteState.noteId,
-    blockId: runSegment?.id,
-    blockContentId,
-    origin: "journal",
-    status: results.completed === false ? "in-progress" : "completed",
-    startTime: results.startTime,
+    ...started.session,
+    status: results.completed ? "completed" : "in-progress",
     endTime: results.endTime,
     duration: results.duration ?? 0,
-    completed: results.completed,
-    createdAt: results.endTime || Date.now()
+    completed: results.completed
   };
   const identity = {
-    noteId: noteState.noteId,
-    resultId,
-    segmentId: session.segmentId,
-    segmentVersion: session.segmentVersion,
-    blockContentId,
+    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 eventRows = toEventRows(logs, identity);
-  const summaryRows = toSummaryEventRows(logs, identity);
-  await db.db.transaction(async (tx) => {
-    await sql.putRow(tx, sql.storeDefinition("sessions"), session);
-    const eventsDef = sql.storeDefinition("events");
-    for (const row of [...eventRows, ...summaryRows]) await sql.putRow(tx, eventsDef, row);
+  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: noteState.noteId,
-    resultId,
-    session,
-    events: eventRows.length,
-    summaries: summaryRows.length,
-    noteCreated: noteState.created
-  };
+  return { noteId: session.noteId, resultId: session.id, session, events: events.length, summaries: summaries.length, noteCreated: started.noteCreated };
 }
 async function persistSessionBundle(db, session, events) {
-  const sql = await loadSql();
-  const existing = await noteById(sql, db.db, session.noteId);
-  let noteCreated = false;
-  if (!existing) {
-    noteCreated = true;
-    const now = session.createdAt || Date.now();
-    await db.db.transaction(async (tx) => {
-      await sql.putRow(tx, sql.storeDefinition("notes"), {
-        id: session.noteId,
-        title: `imported-${session.noteId.slice(0, 8)}`,
-        createdAt: now,
-        type: "note"
-      });
-    });
-  }
-  await db.db.transaction(async (tx) => {
-    await sql.putRow(tx, sql.storeDefinition("sessions"), session);
-    const eventsDef = sql.storeDefinition("events");
-    for (const row of events) await sql.putRow(tx, eventsDef, row);
+  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, noteCreated };
+  return { events: events.length };
 }
 async function persistEffort(db, effort) {
   const sql = await loadSql();
@@ -1743,308 +2018,72 @@ async function persistEffort(db, effort) {
   });
 }
 async function persistTypedTags(db, labels, type) {
-  const sql = await loadSql();
-  const now = Date.now();
-  const tagByLabel = new Map(
-    (await sql.listRows(db.db, sql.storeDefinition("tags"))).map((t) => [t.label, t])
-  );
-  const ops = [];
-  let added = 0;
-  for (const raw of labels) {
-    const label = raw.trim();
-    if (!label) continue;
-    const tag = tagByLabel.get(label);
-    if (!tag) {
-      ops.push({ op: "put", store: "tags", value: { id: randomId(), label, type, createdAt: now } });
-      added += 1;
-    } else if (!tag.type) {
-      ops.push({ op: "put", store: "tags", value: { ...tag, type } });
+  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 });
+      }
     }
-  }
-  if (ops.length > 0) {
-    await db.db.transaction(async (tx) => {
-      await sql.refreshDomain(tx, ops);
-    });
-  }
-  return added;
+    return added;
+  });
 }
 
 // src/cli/seed.ts
-var SEED_NAMESPACE = "1b671a64-40d5-491e-99b0-da01ff1f3341";
-var SEED_SCHEMA = 7;
-var CANVAS_CHUNK_ID = "canvas";
-var DASHBOARDS_CHUNK_ID = "dashboards";
-var EFFORTS_CHUNK_ID = "efforts";
-var TEMPLATE_CHUNK_ID = "template";
-var scalarOf2 = (value) => typeof value === "string" ? value : void 0;
-function seedNoteId(path) {
-  return formatV5Digest(nodeCrypto().createHash("sha1").update(`${SEED_NAMESPACE}:${path}`).digest());
-}
-function titleFromPath(path) {
-  const stem = path.split("/").pop() ?? path;
-  return stem.replace(/\.md$/, "").replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
-function catalogForChunkId(chunkId) {
-  const match = /^(?:collection|feed)\.(.+)$/.exec(chunkId);
-  const value = match?.[1];
-  return value && value !== "_root" ? value : void 0;
-}
-function canvasRouteSlug(content) {
-  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
-  if (fm?.[1] && !/^template:\s*canvas\s*$/m.test(fm[1])) return null;
-  const route = fm?.[1]?.match(/^route:\s*(\S+)\s*$/m)?.[1];
-  if (!route) return null;
-  return route.replace(/^\//, "") || null;
-}
-function seedNoteSourceId(path, content, chunkId) {
-  const parts = path.split("/");
-  const stem = (parts[parts.length - 1] ?? "").replace(/\.md$/i, "");
-  const under = parts.slice(2).map((p) => p.replace(/\.md$/i, "")).join("/");
-  if (chunkId === CANVAS_CHUNK_ID) {
-    const route = canvasRouteSlug(content);
-    return route ? `guides:${route}` : `guides:${under}`;
-  }
-  if (chunkId === DASHBOARDS_CHUNK_ID) return "dashboards";
-  if (chunkId === EFFORTS_CHUNK_ID) return "efforts";
-  if (chunkId === TEMPLATE_CHUNK_ID) return "playground";
-  if (chunkId.startsWith("collection.")) {
-    const catalog = catalogForChunkId(chunkId);
-    if (!catalog) return "collection:_root";
-    return stem.toLowerCase() === "readme" ? `collection:${catalog}` : `collection:${catalog}/${stem}`;
-  }
-  if (chunkId.startsWith("feed.")) return `feed:feeds/${under}`;
-  return void 0;
-}
-function buildNoteRecord(row, chunkId, seedVersion) {
-  const id = seedNoteId(row.path);
-  const createdAt = seedVersion;
-  const meta = readFrontmatterMeta(row.content);
-  const tags = extractTypedTags(row.content);
-  let date;
-  let page;
-  let pageNote;
-  const rawDate = scalarOf2(meta["date"]);
-  if (rawDate && /^\d{4}-\d{2}-\d{2}$/.test(rawDate)) {
-    date = (/* @__PURE__ */ new Date(`${rawDate}T12:00:00Z`)).getTime();
-  }
-  const slug = scalarOf2(meta["slug"]);
-  if (slug) {
-    const pageId = seedNoteId(`page:${slug}`);
-    page = { id: pageId, slug, title: titleFromPath(row.path), createdAt };
-    pageNote = { id: seedNoteId(`pagenote:${slug}:${row.path}`), pageId, noteId: id, createdAt };
-  }
-  const sourceId = seedNoteSourceId(row.path, row.content, chunkId);
-  if (!sourceId) {
-    throw new Error(`[wod seed] chunk "${chunkId}" row "${row.path}" has no source family \u2014 refusing to import it as journal`);
-  }
-  const metaTitle = scalarOf2(meta["title"]);
-  return {
-    note: {
-      id,
-      title: metaTitle?.trim() || titleFromPath(row.path),
-      date,
-      createdAt,
-      type: chunkId === DASHBOARDS_CHUNK_ID ? "dashboard" : "note",
-      sourceId,
-      catalog: catalogForChunkId(chunkId),
-      seedOrigin: "seed",
-      seedVersion,
-      seedChunkId: chunkId,
-      sourcePath: row.path
-    },
-    segment: {
-      id: `seed:${id}`,
-      version: 1,
-      noteId: id,
-      position: 0,
-      dataType: "markdown",
-      data: null,
-      rawContent: row.content,
-      createdAt
-    },
-    tags,
-    page,
-    pageNote,
-    rawContent: row.content,
-    sourcePath: row.path
-  };
-}
-async function metaRecord(sql, db, sourceId) {
-  const rows = await sql.listRows(db, sql.storeDefinition("meta"));
-  const existing = rows.find((r) => r.key === `seed:${sourceId}`);
-  return existing ?? {
-    key: `seed:${sourceId}`,
-    schema: SEED_SCHEMA,
-    seedVersion: 0,
-    builtAt: "",
-    importedAt: 0,
-    chunks: {},
-    claim: null
-  };
-}
-async function applyOps(db, ops) {
-  if (ops.length === 0) return;
-  const sql = await loadSql();
-  await db.db.transaction(async (tx) => {
-    await sql.refreshDomain(tx, ops);
-  });
-}
 async function importSeedDir(db, dir, sourceId) {
-  const sql = await loadSql();
-  const fs = nodeFs();
-  const source = sourceId || nodePath().basename(dir);
-  const manifest = JSON.parse(fs.readFileSync(nodePath().resolve(dir, "manifest.json"), "utf-8"));
-  const prior = await metaRecord(sql, db.db, source);
-  const notesById = new Map(
-    (await sql.listRows(db.db, sql.storeDefinition("notes"))).map((row) => [row.id, row])
-  );
-  const tagRowByLabel = new Map(
-    (await sql.listRows(db.db, sql.storeDefinition("tags"))).map((t) => [t.label, t])
-  );
-  const summary = {
-    sourceId: source,
-    version: manifest.version,
-    notes: 0,
-    efforts: 0,
-    blocks: 0,
-    blockEfforts: 0,
-    deleted: 0,
-    skippedUserOwned: 0
+  const 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;
   };
-  const nextMeta = {
-    ...prior,
-    schema: SEED_SCHEMA,
-    seedVersion: manifest.version,
-    builtAt: manifest.builtAt,
-    importedAt: Date.now(),
-    chunks: {}
-  };
-  const ordered = [
-    ...manifest.chunks.filter((c) => (c.kind ?? "notes") === "notes"),
-    ...manifest.chunks.filter((c) => c.kind === "block-index"),
-    ...manifest.chunks.filter((c) => c.kind === "block-efforts")
-  ];
-  const bySourcePath = /* @__PURE__ */ new Map();
-  const noteIdsByChunk = {};
-  const blockIdsByChunk = {};
-  for (const chunk of ordered) {
-    const payload = JSON.parse(fs.readFileSync(nodePath().resolve(dir, chunk.path), "utf-8"));
-    const ops = [];
-    if ((chunk.kind ?? "notes") === "notes") {
-      const rows2 = payload;
-      const built = rows2.map((row) => buildNoteRecord(row, chunk.id, manifest.version));
-      const noteIds = [];
-      for (const record of built) {
-        bySourcePath.set(record.sourcePath, record.note.id);
-        const existing = notesById.get(record.note.id);
-        if (existing && existing.seedOrigin !== "seed") {
-          summary.skippedUserOwned += 1;
-          continue;
-        }
-        noteIds.push(record.note.id);
-        ops.push({ op: "put", store: "notes", value: record.note });
-        ops.push({ op: "put", store: "segments", value: record.segment });
-        if (record.page) ops.push({ op: "put", store: "page", value: record.page });
-        if (record.pageNote) ops.push({ op: "put", store: "page_notes", value: record.pageNote });
-        for (const item of record.tags) {
-          const label = item.label;
-          let tag = tagRowByLabel.get(label);
-          if (!tag) {
-            tag = { id: randomId(), label, type: item.type, createdAt: Date.now() };
-            tagRowByLabel.set(label, tag);
-            ops.push({ op: "put", store: "tags", value: tag });
-          } else if (item.type && !tag.type) {
-            tag = { ...tag, type: item.type };
-            tagRowByLabel.set(label, tag);
-            ops.push({ op: "put", store: "tags", value: tag });
-          }
-          const tagId = tag.id;
-          ops.push({
-            op: "put",
-            store: "note_tags",
-            // Deterministic junction id — re-seeds must upsert the same row
-            // (note_tags has a unique [noteId, tagId] index).
-            value: { id: uuid5(CLI_UUID_NAMESPACE, `note-tag:${record.note.id}:${tagId}`), noteId: record.note.id, tagId }
-          });
-        }
-        if (chunk.id === EFFORTS_CHUNK_ID) {
-          const effort = markdownToEffort(record.rawContent);
-          if (effort) {
-            ops.push({ op: "put", store: "efforts", value: { ...effort, registrySource: "bundled" } });
-            summary.efforts += 1;
-          }
-        }
-      }
-      const priorIds = prior.chunks[chunk.id]?.noteIds ?? [];
-      const goneIds = priorIds.filter((id) => !noteIds.includes(id) && notesById.get(id)?.seedOrigin === "seed");
-      for (const id of goneIds) {
-        ops.push(...await noteCascadeOps(sql, db, id));
-        summary.deleted += 1;
-      }
-      noteIdsByChunk[chunk.id] = rows2.map((row) => seedNoteId(row.path));
-      nextMeta.chunks[chunk.id] = { sha256: chunk.sha256, noteIds: noteIdsByChunk[chunk.id] };
-      summary.notes += noteIds.length;
-      await applyOps(db, ops);
-      continue;
-    }
-    const rows = payload.filter((row) => row.isStatic === true);
-    const rekeyed = rows.map((row) => {
-      const noteId = row.sourcePath ? bySourcePath.get(row.sourcePath) : void 0;
-      if (!noteId) {
-        throw new Error(
-          `[wod seed] static row ${row.id}: sourcePath "${row.sourcePath ?? ""}" has no imported note \u2014 chunk aborted`
-        );
-      }
-      return chunk.kind === "block-efforts" ? { ...row, noteId } : { ...row, noteId, routeId: row.noteId };
-    });
-    const store = chunk.kind === "block-index" ? "block_index" : "block_efforts";
-    for (const row of rekeyed) ops.push({ op: "put", store, value: row });
-    const priorBlockIds = prior.chunks[chunk.id]?.blockIds ?? [];
-    const writtenIds = new Set(rekeyed.map((row) => row.id));
-    const goneBlocks = priorBlockIds.filter((id) => !writtenIds.has(id));
-    for (const id of goneBlocks) ops.push({ op: "delete", store, key: id });
-    summary.deleted += goneBlocks.length;
-    blockIdsByChunk[chunk.id] = payload.map((row) => row.id);
-    nextMeta.chunks[chunk.id] = { sha256: chunk.sha256, blockIds: blockIdsByChunk[chunk.id] };
-    if (chunk.kind === "block-index") summary.blocks += rekeyed.length;
-    else summary.blockEfforts += rekeyed.length;
-    await applyOps(db, ops);
-  }
-  const manifestIds = new Set(manifest.chunks.map((c) => c.id));
-  for (const [chunkId, checkpoint] of Object.entries(prior.chunks)) {
-    if (manifestIds.has(chunkId)) continue;
-    const sweep = [];
-    for (const id of checkpoint.noteIds ?? []) {
-      if (notesById.get(id)?.seedOrigin === "seed") {
-        sweep.push(...await noteCascadeOps(sql, db, id));
-        summary.deleted += 1;
-      }
-    }
-    for (const id of checkpoint.blockIds ?? []) {
-      sweep.push({ op: "delete", store: "block_index", key: id });
-      summary.deleted += 1;
-    }
-    await applyOps(db, sweep);
+  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 });
   }
-  await applyOps(db, [{ op: "put", store: "meta", value: nextMeta }]);
   return summary;
 }
-async function noteCascadeOps(sql, db, noteId) {
-  const ops = [{ op: "delete", store: "notes", key: noteId }];
-  for (const store of ["segments", "block_index", "block_efforts", "note_tags"]) {
-    const rows = await sql.listRows(db.db, sql.storeDefinition(store), { only: noteId }, void 0, "by-note");
-    for (const row of rows) {
-      ops.push({ op: "delete", store, key: store === "segments" ? [row.id, row.version ?? 1] : row.id });
-    }
-  }
-  return ops;
-}
 function defaultSeedDirs(cwd) {
   const base = nodePath().resolve(cwd, "apps", "playground", "public", "seed");
   return ["core", "community"].map((id) => nodePath().resolve(base, id)).filter((dir) => nodeFs().existsSync(nodePath().resolve(dir, "manifest.json")));
 }
-
-// src/cli/runner.ts
 function getFs2() {
   if (typeof globalThis.process?.versions?.node === "undefined" && typeof globalThis.Bun === "undefined") {
     throw new Error("File system operations are only supported in Node / Bun environments");
@@ -2052,6 +2091,16 @@ function getFs2() {
   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",
@@ -2061,6 +2110,7 @@ function parseCliArgs(args) {
   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++;
@@ -2119,12 +2169,6 @@ function parseCliArgs(args) {
     } else if (arg.startsWith("--debug=")) {
       result.debug = arg.slice("--debug=".length);
       i++;
-    } else if (arg === "--at") {
-      result.at = args[++i];
-      i++;
-    } else if (arg.startsWith("--at=")) {
-      result.at = arg.slice("--at=".length);
-      i++;
     } else if (arg === "--source") {
       const source = args[++i];
       if (source) result.sources.push(source);
@@ -2218,7 +2262,7 @@ USAGE:
 
 SUBCOMMANDS:
   parse <file | ->    Parse Whiteboard Script, create a note in the database
-                     (segments + block index), optionally emit parse-tree IR.
+                     (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 +
@@ -2226,10 +2270,8 @@ SUBCOMMANDS:
                      execution-log IR
   query '<wql>'       Evaluate WQL against the database (or an explicit
                      dataset) and emit QueryResult / RowsQueryResult IR
-  download note <id>  Compose the note's markdown from its segment rows and
-                     write it to <id>.md. Use --at <version> to compose
-                     as-of a segment version (default: latest). The stamp
-                     in the frontmatter makes 'wod parse' re-import it.
+  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>
@@ -2246,8 +2288,8 @@ SUBCOMMANDS:
   import note <file>  Re-import exported note markdown (same as parse with
                      the stamped identity).
   import session <file>
-                     Recreate a session + its events from a downloaded CSV
-                     into the same or a clean database (id-keyed upsert).
+                     Import 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>
@@ -2255,7 +2297,7 @@ SUBCOMMANDS:
   build [dir]         Compile a seed corpus: validate every .md under
                      <dir>/markdown (parity gate + dashboard format gate) and
                      write manifest.json + content-hashed chunks/ +
-                     block-parent-map.json + report.html to <dir>/dist
+                     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).
 
@@ -2283,8 +2325,6 @@ OPTIONS:
   --format <fmt>      Output format: json (default), table, csv
   -o, --output <path> Write the IR payload (or download) to a path instead of
                       the default; '-' writes to stdout
-  --at <version>      With 'download note': compose the markdown as-of the
-                      given segment version (default: latest)
   --debug[=name]      Also write the IR payload to <name> (default
                       wod-<subcommand>-debug.json); without it, parse/run
                       print a one-line summary of what was persisted
@@ -2313,7 +2353,13 @@ 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);
+  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;
@@ -2339,7 +2385,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
     }
   }
   const deliverOutput = (formattedText) => {
-    if (parsed.output) {
+    if (parsed.output && parsed.output !== "-") {
       getFs2().writeFileSync(parsed.output, formattedText, "utf-8");
     } else {
       writeOut(formattedText);
@@ -2369,20 +2415,21 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         }
         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,
+          source: noteSource,
           sourceLabel: parsed.target,
           noteId: identity?.noteId,
           title: identity?.title,
           tags
         });
         writeOut(
-          `[wod parse] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.segments} segments, ${persisted.blocks} blocks, ${persisted.efforts} efforts${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db.path}`
+          `[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();
@@ -2410,14 +2457,30 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         }
         source = fs.readFileSync(parsed.target, "utf-8");
       }
-      const ir = await runExecution(source, { sport: parsed.sport, sourceLabel: `cli:wod run ${parsed.target}` });
+      const identity = extractNoteIdentity(source);
       const db = await openCliDb(parsed.db);
+      let ir;
       try {
-        const persisted = await persistRun(db, {
-          source,
+        const started = await startRun(db, {
+          source: cliNoteSource(source, parsed.target, parsed.sport),
           sourceLabel: parsed.target,
-          executionLog: ir.data
+          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}`
         );
@@ -2495,7 +2558,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       const id = parsed.target2;
       const DOWNLOAD_KINDS = ["note", "session", "effort", "equipment"];
       if (!id && kind !== "equipment" || !DOWNLOAD_KINDS.includes(kind ?? "")) {
-        writeErr("[wod download] Usage: wod download <note|session|effort|equipment> <id> [--at <version>] [-o <path>]");
+        writeErr("[wod download] Usage: wod download <note|session|effort|equipment> <id> [-o <path>]");
         return 1;
       }
       const targetId = id;
@@ -2507,21 +2570,14 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
             writeErr(`[wod download] Note not found in ${db.path}: ${id}`);
             return 1;
           }
-          const at = parsed.at === void 0 ? void 0 : Number(parsed.at);
-          if (parsed.at !== void 0 && (!Number.isInteger(at) || at < 1)) {
-            writeErr(`[wod download] Invalid --at version: ${parsed.at}`);
-            return 1;
-          }
-          const markdown = composeNoteMarkdown(bundle.note, bundle.segments, at);
-          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}${at ? `.v${at}` : ""}.md`;
+          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");
           }
-          writeOut(
-            `[wod download] note ${id}${at ? ` v${at}` : ""} \u2192 ${target} (${bundle.segments.length} segment rows)`
-          );
+          if (parsed.output !== "-") writeOut(`[wod download] note ${id} \u2192 ${target}`);
         } else if (kind === "session") {
           const bundle = await getSessionBundle(db.db, targetId);
           if (!bundle) {
@@ -2535,7 +2591,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
           } else {
             nodeFs().writeFileSync(target, csv, "utf-8");
           }
-          writeOut(`[wod download] session ${id} \u2192 ${target} (${bundle.events.length} events)`);
+          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) {
@@ -2593,7 +2649,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
             tags
           });
           writeOut(
-            `[wod import] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.segments} segments${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db2.path}`
+            `[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();
@@ -2635,7 +2691,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       try {
         const result = await persistSessionBundle(db, session, events);
         writeOut(
-          `[wod import] session ${session.id} \u2014 ${result.events} events${result.noteCreated ? " (stub note created)" : ""} \u2192 ${db.path}`
+          `[wod import] session ${session.id} \u2014 ${result.events} events \u2192 ${db.path}`
         );
       } finally {
         await db.close();
@@ -2649,7 +2705,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         writeErr(`[wod build] No markdown/ corpus under ${root} \u2014 run from the content repo root (or pass its directory).`);
         return 1;
       }
-      const { generateSeed } = await import('./compiler-KTBR6OEL.mjs');
+      const { generateSeed } = await import('./compiler-MQRZVZQW.mjs');
       try {
         const result = generateSeed({
           corpusRoot: root,
@@ -2661,7 +2717,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         const totalBytes = result.manifest.chunks.reduce((s, c) => s + c.bytes, 0);
         writeOut(`[wod build] schema v${result.manifest.schema} version ${result.manifest.version} (${result.manifest.versionLabel}) \u2192 ${result.outDir}`);
         for (const c of result.manifest.chunks) {
-          writeOut(`  ${c.id.padEnd(48)} ${String(c.count).padStart(4)} ${c.kind === "block-index" ? "rows " : "files"}  ${kb(c.bytes).padStart(8)}`);
+          writeOut(`  ${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;
@@ -2717,6 +2773,6 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
   }
 }
 
-export { NOTE_ID_FRONTMATTER_KEY, PackLoadError, ParseSyntaxError, SESSION_CSV_HEADER, WqlSyntaxError, buildStatementTree, buildWorkoutResults, cliMain, composeNoteMarkdown, createIRFile, csvToEquipmentLabels, csvToSessionRows, defineLanguagePack, effortToMarkdown, equipmentToCsv, extractNoteIdentity, extractTypedTags, formatExecutionOutput, formatParseOutput, formatQueryOutput, getRegisteredLanguagePacks, inMemoryEventStore, injectIdentityFrontmatter, isIRFile, listLanguagePacks, loadLanguagePack, loadQueryData, markdownToEffort, parseCliArgs, parseCsvLine, readFrontmatterMeta, readStdin, registerLanguagePack, runExecution, runParse, runQueryCli, sessionToCsv, splitCsvRecords, statementToNode, unregisterLanguagePack };
-//# sourceMappingURL=chunk-B2OYLNEZ.mjs.map
-//# sourceMappingURL=chunk-B2OYLNEZ.mjs.map
+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-AKNXDA75.mjs.map
+//# sourceMappingURL=chunk-AKNXDA75.mjs.map