@bitcobblers/wod-wiki-engine 0.35.2129 → 0.36.2133

package/dist/index.mjs

@@ -1,25 +1,1100 @@
-import { createRequire } from 'module';
-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 } from './chunk-N4KFWY6Z.mjs';
-export { CANVAS_CHUNK_ID, DASHBOARDS_CHUNK_ID, EFFORTS_CHUNK_ID, SEED_BROADCAST_CHANNEL, SEED_REGISTERED_WIDGETS, SEED_SCHEMA, TEMPLATE_CHUNK_ID, canvasRouteSlug, catalogForChunkId, emptySeedMeta, seedMetaKey, seedNoteSourceId } from './chunk-Y6WO6MXS.mjs';
+import { KNOWN_SECTION_WIDGETS, MetricType, validateNoteBlocks, parseDocumentSections, blockContentId, reconcileNoteBlocks, mapNoteBlockChanges } from '@bitcobblers/wod-wiki-core';
 export * from '@bitcobblers/wod-wiki-core';
+import { dialectRegistry, realtimeProcessorRegistry, summaryProcessorRegistry, getHints, isEffortDiscipline } from '@bitcobblers/wod-wiki-lang';
 export { ABSENT, AGGREGATE_BUILTINS, AUTHORITATIVE_CASTS, AmrapLogicStrategy, AnalyticsEngine, AnalyticsTransformer, BUILTIN_CALCS, BUNDLED_EFFORT_COUNT, BlockBuilder, ButtonBehavior, CONSUMED_HINTS, CONSUMED_HINT_KEYS, CONTEXT_ATOMS, CalcEngine, CalculationRegistry, CardioDialect, ChildSelectionBehavior, ChildrenStrategy, ChoiceGroupMetric, ClimbDialect, ClimbMetricType, CountdownTimerBehavior, CountupTimerBehavior, CrossFitDialect, DEFAULT_RESOLVER_OPTIONS, DEFAULT_RUNTIME_OPTIONS, DEFAULT_UNRESOLVED_EFFORT_MET, DIM_LENGTH, DIM_MASS, DIM_TIME, DIM_ZERO, DialectStack, EFFORT_DATA_METRIC_TYPE, EFFORT_REGISTRY_ORIGINS, EffortFallbackStrategy, EffortResolver, ErrorAction, EventBus, ExecutionContext, ExitBehavior, FixtureSyntaxError, GenericGroupStrategy, GenericLoopStrategy, GenericTimerStrategy, HabitsDialect, INTENSITY_TIERS, InMemoryEffortRegistry, IntervalLogicStrategy, JitCompiler, LabelingBehavior, LocalRuntimeSubscription, LookupRegistry, MdTimerRuntime, MemoryLocation, MemoryTypeEnum, NextEvent, OutputEmitter, PRODUCTION_STRATEGIES, PopBlockAction, PushBlockAction, RegisterEventHandlerAction, Registry, ReportOutputBehavior, ReportOutputStrategy, RoundsMetric, RuntimeAdapter, RuntimeClock, RuntimeFactory, RuntimeLogger, RuntimeMemory, RuntimeObservers, RuntimeStack, STORE_CALCS, STREAM_ATOMS, ScriptRuntime, SessionRootStrategy, SnapshotClock, SoundCueBehavior, SoundStrategy, StandardAnalyticsProfile, StartSessionAction, StartWorkoutAction, SubscriptionManager, TimeSpan, TypedMemoryReference, UNITS, UnitsDialect, UnregisterEventHandlerAction, VISIBILITY_ICONS, VISIBILITY_LABELS, WhiteboardScript, WodDialect, YogaDialect, buildTooltip, bundledEfforts, calculateElapsed, canonicalizeType, collapseUnresolvedChoices, compareStatement, compileLineForm, compoundName, computeColumnLabel, computeLabel, createAnalyticsEngineForBlock, createCalcEngine, createCompiler, createDialectStack, createMetricPresentationPolicy, createMockClock, createParser, dialectRegistry, dialectStack, diffStatement, evaluate, evaluateCalculateDefinitions, extractMetrics, extractStatements, findBestFuzzyMatch, findUnresolvedChoices, frozenNow, getAnalyticsFromLogs, getHints, getMetricVisibility, getRuntimeNowMs, hasHint, hintMetric, hintsToContainer, isCastSubscription, isChoiceResolved, isTimeLikeMetric, isWithinThreshold, levenshteinDistance, metricPresentation, normalizeForFuzzy, outputNodeId, outputNodeIds, parseCalcLine, parseCalculateBlock, parseExpression, parseMetricLine, parseScript, realtimeProcessorRegistry, renderMetric, strategyRegistry, summaryProcessorRegistry, toStoredOutputStatement, truthy, wallClockNow, whiteboardParser, whiteboardScript, whiteboardScriptLanguage, writeChoiceSelection } from '@bitcobblers/wod-wiki-lang';
 export { BlockTimerDisplay, ScriptRuntimeProvider, useActiveControls, useBlockMemory, useLiveAnalytics, useMemorySubscription, useNextPreview, useOutputStatements, usePrimaryTimer, useRoundDisplay, useRuntimeExecution, useScriptRuntime, useSecondaryTimers, useSnapshotBlocks, useStackDisplayRows, useStackFragmentSources, useStackSnapshot, useStackTimers, useTimerDisplay, useTimerElapsed } from '@bitcobblers/wod-wiki-lang/react';
+import { WQL_TYPED_TAG_KEYS } from '@bitcobblers/wod-wiki-wql';
 export { DASHBOARD_GRID_MAX_COLS, DASHBOARD_WIDGET_TYPES, DEFAULT_DASHBOARD_TITLE, PLANNED_WIDGET_TYPES, QueryService, WQL_AGGREGATORS, WQL_CALC_TARGETS, WQL_CHART_HEADS, WQL_COMPARISON_OPS, WQL_CONTENT_FILTER_KEYS, WQL_DISPLAY_UNITS, WQL_FIND_TARGETS, WQL_FUNCTION_HEADS, WQL_GRAINS, WQL_INTENSITY_TIERS, WQL_KEYWORDS, WQL_METRIC_AGGREGATES, WQL_METRIC_FAMILIES, WQL_RESULT_PLANES, WQL_ROLLUP_PERIODS, WQL_SOURCES, WQL_SOURCE_HEADS, WQL_SOURCE_VALUES, WQL_STANDARD_DATASETS, WQL_TAG_KEYS, WQL_VIRTUAL_DIMS, buildDashboardDocument, buildDashboardScaffold, dashboardSlug, defaultTokenValues, extractDashboardTokens, isAggregateQuery, isDashboardMeta, isDashboardWidgetType, isFindQuery, isPipelineQuery, normalizeWql, parseQuery, parseQueryWidgetSuffix, parseWqlSuffixes, resolveWidgetType, serialize, splitAtWhere, substituteTokens, unknownTokensMessage, unknownWidgetTypeMessage, wql, wqlLanguage, wqlParser, wqlTerms } from '@bitcobblers/wod-wiki-wql';
 
-if (typeof globalThis.require === 'undefined') {
-  try { globalThis.require = createRequire(import.meta.url); } catch {}
+// src/index.ts
+var activePacks = /* @__PURE__ */ new Map();
+function defineLanguagePack(pack) {
+  return pack;
+}
+function registerLanguagePack(pack) {
+  const packId = pack.identity?.id ?? pack.identity?.name ?? "anonymous-pack";
+  activePacks.set(packId, pack);
+  if (pack.lang?.analyzer) {
+    const AnalyzerCtor = pack.lang.analyzer;
+    const instance = new AnalyzerCtor();
+    dialectRegistry.register(instance);
+  }
+  if (pack.lang?.analytics) {
+    for (const ProcessorCtor of pack.lang.analytics) {
+      const instance = new ProcessorCtor();
+      if ("processOutput" in instance) {
+        realtimeProcessorRegistry.register(instance);
+      }
+      if ("processSummary" in instance) {
+        summaryProcessorRegistry.register(instance);
+      }
+    }
+  }
+}
+function unregisterLanguagePack(packOrId) {
+  const packId = typeof packOrId === "string" ? packOrId : packOrId.identity?.id ?? packOrId.identity?.name ?? "anonymous-pack";
+  const pack = activePacks.get(packId);
+  activePacks.delete(packId);
+  if (pack?.lang?.analyzer) {
+    const instance = new pack.lang.analyzer();
+    dialectRegistry.unregister(instance.id);
+  } else if (typeof packOrId === "string") {
+    dialectRegistry.unregister(packOrId);
+  }
+  if (pack?.lang?.analytics) {
+    for (const ProcessorCtor of pack.lang.analytics) {
+      const instance = new ProcessorCtor();
+      if ("processOutput" in instance) {
+        realtimeProcessorRegistry.unregister(instance.id);
+      }
+      if ("processSummary" in instance) {
+        summaryProcessorRegistry.unregister(instance.id);
+      }
+    }
+  }
+}
+function listLanguagePacks() {
+  return Array.from(activePacks.values());
+}
+function getRegisteredLanguagePacks() {
+  return Array.from(activePacks.values());
+}
+
+// src/store.ts
+function inMemoryEventStore(events) {
+  const rows = [...events];
+  return {
+    getEventsByTimeRange: async (start, end) => rows.filter((r) => r.timestamp >= start && r.timestamp <= end),
+    getEventsByResult: async (resultId) => rows.filter((r) => r.resultId === resultId),
+    getEventsForNote: async (noteId) => rows.filter((r) => r.noteId === noteId),
+    getEventsByContent: async (blockContentId2) => rows.filter((r) => r.blockContentId === blockContentId2),
+    scanAll: async () => rows,
+    appendEvents: async (appended) => {
+      rows.push(...appended);
+    },
+    finalizeSummaries: async (resultId, finals) => {
+      for (let i = rows.length - 1; i >= 0; i--) {
+        const row = rows[i];
+        if (row.resultId === resultId && row.grain === "summary" && row.origin !== "user") rows.splice(i, 1);
+      }
+      rows.push(...finals);
+    },
+    deleteEvents: async (ids) => {
+      const doomed = new Set(ids);
+      for (let i = rows.length - 1; i >= 0; i--) {
+        if (doomed.has(rows[i].id)) rows.splice(i, 1);
+      }
+    }
+  };
+}
+function createIRFile(kind, data, optionsOrSource, generatedAt) {
+  let source = "wod:headless";
+  let genAt = Date.now();
+  if (typeof optionsOrSource === "string") {
+    source = optionsOrSource;
+    if (generatedAt !== void 0) genAt = generatedAt;
+  } else if (optionsOrSource && typeof optionsOrSource === "object") {
+    if (optionsOrSource.source) source = optionsOrSource.source;
+    if (optionsOrSource.generatedAt !== void 0) genAt = optionsOrSource.generatedAt;
+  }
+  return {
+    $schema: "https://wod-wiki.dev/ir/v1.json",
+    kind,
+    generatedAt: genAt,
+    source,
+    data
+  };
+}
+function isIRFile(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const cand = obj;
+  return cand.$schema === "https://wod-wiki.dev/ir/v1.json" && typeof cand.kind === "string" && typeof cand.generatedAt === "number" && typeof cand.source === "string" && "data" in cand;
+}
+function statementToNode(stmt, idMap) {
+  const meta = stmt.meta;
+  const metrics = stmt.metrics.toArray().map((m) => ({
+    type: m.type,
+    ...m.image !== void 0 ? { image: m.image } : {},
+    ...m.value !== void 0 ? { value: m.value } : {},
+    ...m.origin !== void 0 ? { origin: m.origin } : {}
+  }));
+  const raw = meta?.raw ?? "";
+  const from = meta?.startOffset ?? 0;
+  const to = meta?.endOffset ?? from + raw.length;
+  const durationFrag = stmt.metrics.find((m) => m.type === MetricType.Duration || m.type === "duration");
+  const roundsFrag = stmt.metrics.find((m) => m.type === MetricType.Rounds || m.type === "rounds");
+  const type = durationFrag ? "duration" : roundsFrag ? "rounds" : "statement";
+  const hints = getHints(stmt);
+  const childIds = (stmt.children ?? []).flat();
+  const children = childIds.map((cid) => idMap.get(cid)).filter((c) => c !== void 0).map((c) => statementToNode(c, idMap));
+  return {
+    id: stmt.id,
+    type,
+    raw,
+    from,
+    to,
+    metrics,
+    ...hints.length > 0 ? { hints } : {},
+    ...children.length > 0 ? { children } : {}
+  };
+}
+function buildStatementTree(script) {
+  const idMap = new Map(script.statements.map((s) => [s.id, s]));
+  const topLevel = script.statements.filter((s) => s.parent === void 0 || !idMap.has(s.parent));
+  if (topLevel.length === 1 && topLevel[0].children.length > 0) {
+    return statementToNode(topLevel[0], idMap);
+  }
+  return {
+    id: 0,
+    type: "root",
+    raw: script.source,
+    from: 0,
+    to: script.source.length,
+    metrics: [],
+    children: topLevel.map((s) => statementToNode(s, idMap))
+  };
+}
+var NOTE_ID_FRONTMATTER_KEY = "wod-note-id";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function extractNoteIdentity(markdown) {
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
+  if (!block) return void 0;
+  let noteId;
+  let title;
+  for (const line of block[1].split(/\r?\n/)) {
+    const kv = line.match(/^([^:]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1].trim();
+    const value = kv[2].trim();
+    if (key === NOTE_ID_FRONTMATTER_KEY && UUID_RE.test(value)) noteId = value;
+    if (key === "title" && value) title = value;
+  }
+  return noteId ? { noteId, title } : void 0;
+}
+var FRONTMATTER_SAFE = /^[^:#\[\]{}'"*&,!?|>%@`\s][^:#\[\]{}"']*$/;
+function injectIdentityFrontmatter(markdown, identity) {
+  const stamp = (lines2) => {
+    const replaceOrInsert = (key, value) => {
+      if (value === void 0 || !FRONTMATTER_SAFE.test(value)) return;
+      const idx = lines2.findIndex((l) => l.startsWith(`${key}:`));
+      if (idx >= 0) lines2[idx] = `${key}: ${value}`;
+      else lines2.push(`${key}: ${value}`);
+    };
+    replaceOrInsert("title", identity.title);
+    replaceOrInsert(NOTE_ID_FRONTMATTER_KEY, identity.noteId);
+    return lines2;
+  };
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
+  if (block) {
+    const newline = markdown.startsWith("---\r\n") ? "\r\n" : "\n";
+    const lines2 = stamp(block[1].split(/\r?\n/));
+    return `---${newline}${lines2.join(newline)}${newline}---${markdown.slice(block[0].length)}`;
+  }
+  const lines = stamp([]);
+  return `---
+${lines.join("\n")}
+---
+
+${markdown}`;
+}
+function composeNoteMarkdown(note) {
+  return injectIdentityFrontmatter(note.rawContent, { noteId: note.id, title: note.title });
+}
+var FRONTMATTER_BLOCK_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+function readFrontmatterMeta(markdown) {
+  const match = FRONTMATTER_BLOCK_RE.exec(markdown);
+  if (!match) return {};
+  const meta = {};
+  const lines = match[1].split(/\r?\n/);
+  let currentListKey;
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    const item = line.match(/^\s+-\s+(.*)$/);
+    if (item && currentListKey) {
+      meta[currentListKey].push(item[1].trim());
+      continue;
+    }
+    const kv = line.match(/^([^:]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1].trim().toLowerCase();
+    const value = kv[2].trim();
+    if (value === "") {
+      meta[key] = [];
+      currentListKey = key;
+    } else if (value.startsWith("[") && value.endsWith("]")) {
+      meta[key] = value.slice(1, -1).split(",").map((v) => v.trim().replace(/^['"]|['"]$/g, "")).filter((v) => v.length > 0);
+      currentListKey = void 0;
+    } else {
+      meta[key] = value;
+      currentListKey = void 0;
+    }
+  }
+  return meta;
+}
+var asList = (value) => Array.isArray(value) ? value : typeof value === "string" ? value.split(",").map((v) => v.trim()).filter((v) => v.length > 0) : [];
+function extractTypedTags(markdown, typedKeys = WQL_TYPED_TAG_KEYS) {
+  const meta = readFrontmatterMeta(markdown);
+  const results = asList(meta["tags"]).map((label) => ({ label }));
+  const metaKeys = Object.keys(meta);
+  for (const typeName of typedKeys) {
+    if (typeName === "tags") continue;
+    const matchedKey = metaKeys.find((k) => k === typeName.toLowerCase());
+    if (!matchedKey) continue;
+    for (const label of asList(meta[matchedKey])) {
+      results.push({ label, type: typeName });
+    }
+  }
+  return results.filter((t) => t.label.length > 0);
+}
+function markdownToEffort(raw) {
+  const match = FRONTMATTER_BLOCK_RE.exec(raw);
+  if (!match) return null;
+  const meta = readFrontmatterMeta(raw);
+  const body = raw.slice(match[0].length).trim();
+  const id = scalarOf(meta["id"]);
+  const slug = scalarOf(meta["slug"]);
+  const label = scalarOf(meta["label"]);
+  if (!id || !slug || !label) return null;
+  const baseAttributes = {};
+  const blockRe = /^\s{2,}([^:]+):\s*(.+)$/;
+  let inAttrs = false;
+  for (const line of match[1].split(/\r?\n/)) {
+    if (/^baseAttributes:/.test(line)) {
+      inAttrs = true;
+      continue;
+    }
+    if (inAttrs) {
+      const attr = blockRe.exec(line);
+      if (attr && /^ {2,}/.test(line)) {
+        const v = attr[2].trim();
+        baseAttributes[attr[1].trim()] = /^\d+(\.\d+)?$/.test(v) ? Number(v) : v;
+      } else if (/^\S/.test(line)) {
+        inAttrs = false;
+      }
+    }
+  }
+  if (typeof baseAttributes["met"] !== "number") return null;
+  return {
+    id,
+    slug,
+    label,
+    aliases: asList(meta["aliases"]),
+    baseAttributes,
+    ...body ? { body } : {}
+  };
+}
+function effortToMarkdown(effort) {
+  const lines = ["---", `id: ${effort.id}`, `slug: ${effort.slug}`, `label: ${effort.label}`];
+  if (effort.aliases && effort.aliases.length > 0) {
+    lines.push("aliases:");
+    for (const alias of effort.aliases) lines.push(`  - ${alias}`);
+  }
+  const attrs = Object.entries(effort.baseAttributes).filter(([, v]) => typeof v === "number" || typeof v === "string");
+  if (attrs.length > 0) {
+    lines.push("baseAttributes:");
+    for (const [k, v] of attrs) lines.push(`  ${k}: ${String(v)}`);
+  }
+  lines.push("---", "");
+  return `${lines.join("\n")}
+${(effort.body ?? "").trim()}`.trimEnd() + "\n";
+}
+function scalarOf(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function equipmentToCsv(labels) {
+  return ["label", ...labels].map((l) => escapeCsvField(l)).join("\n") + "\n";
+}
+function csvToEquipmentLabels(csv) {
+  const lines = splitCsvRecords(csv);
+  if (lines.length === 0) return [];
+  const header = parseCsvLine(lines[0]);
+  const labelIdx = header[0] === "label" ? 0 : -1;
+  const start = labelIdx >= 0 ? 1 : 0;
+  const labels = [];
+  for (const line of lines.slice(start)) {
+    const cells = parseCsvLine(line);
+    const label = (labelIdx >= 0 ? cells[0] : cells.join(",")).trim();
+    if (label) labels.push(label);
+  }
+  return [...new Set(labels)];
+}
+var SESSION_HEADER = [
+  "sessionId",
+  "noteId",
+  "blockId",
+  "blockVersion",
+  "blockContentId",
+  "origin",
+  "status",
+  "startTime",
+  "endTime",
+  "duration",
+  "completed",
+  "sessionCreatedAt",
+  "sessionExtraJson"
+];
+var EVENT_HEADER = [
+  "eventId",
+  "grain",
+  "outputType",
+  "timestamp",
+  "pageId",
+  "effortSlug",
+  "eventBlockId",
+  "eventBlockVersion",
+  "eventBlockContentId",
+  "eventOrigin",
+  "timeSpan",
+  "sourceBlockKey",
+  "sourceStatementId",
+  "line",
+  "text",
+  "dialect",
+  "stackLevel",
+  "completionReason",
+  "representationKind",
+  "metricType",
+  "metricValue",
+  "metricUnit",
+  "metricImage",
+  "metricOrigin",
+  "metricMetadata",
+  "metricTemporal",
+  // Verbatim JSON backstops: make the machine round-trip lossless across
+  // schema fields that have no dedicated spreadsheet column. Explicit cells
+  // above still win on import, so hand-edited values are honored.
+  "metricJson",
+  "eventExtraJson"
+];
+var SESSION_CSV_HEADER = [...SESSION_HEADER, ...EVENT_HEADER];
+function escapeCsvField(field) {
+  if (field === void 0 || field === null) return "";
+  const str = typeof field === "object" ? JSON.stringify(field) : String(field);
+  if (str.includes(",") || str.includes('"') || str.includes("\n") || str.includes("\r")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+var metricValueToCell = (value) => {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+};
+var metricValueFromCell = (cell) => {
+  if (cell === "") return void 0;
+  if (/^-?\d+(\.\d+)?$/.test(cell)) return Number(cell);
+  if (cell === "true" || cell === "false") return cell === "true";
+  if (cell.startsWith("{") || cell.startsWith("[")) {
+    try {
+      return JSON.parse(cell);
+    } catch {
+      return cell;
+    }
+  }
+  return cell;
+};
+function sessionCells(session) {
+  return [
+    session.id,
+    session.noteId,
+    session.blockId,
+    session.blockVersion,
+    session.blockContentId,
+    session.origin,
+    session.status,
+    session.startTime,
+    session.endTime,
+    session.duration,
+    session.completed,
+    session.createdAt,
+    JSON.stringify(session)
+  ].map(escapeCsvField);
+}
+function metricCells(event, metric, index) {
+  return [
+    event.id,
+    event.grain,
+    event.outputType,
+    event.timestamp,
+    event.pageId,
+    event.effortSlug,
+    event.blockId,
+    event.blockVersion,
+    event.blockContentId,
+    event.origin,
+    event.timeSpan,
+    event.sourceBlockKey,
+    event.sourceStatementId,
+    event.line,
+    event.text,
+    event.dialect,
+    event.stackLevel,
+    event.completionReason,
+    event.representationKind,
+    metric.type,
+    metricValueToCell(metric.value),
+    metric.unit,
+    metric.image,
+    metric.origin,
+    metric.metadata === void 0 ? "" : JSON.stringify(metric.metadata),
+    event.metricTemporal?.[index] === void 0 ? "" : JSON.stringify(event.metricTemporal[index]),
+    JSON.stringify(metric)
+  ].map(escapeCsvField);
+}
+function eventExtraCells(event) {
+  const { metrics: _metrics, ...rest } = event;
+  return escapeCsvField(JSON.stringify(rest));
+}
+function sessionToCsv(session, events) {
+  const lines = [SESSION_CSV_HEADER.join(",")];
+  lines.push([...sessionCells(session), ...EVENT_HEADER.map(() => "")].join(","));
+  const ordered = [...events].sort((a, b) => a.id.localeCompare(b.id));
+  for (const event of ordered) {
+    const extra = eventExtraCells(event);
+    const metrics = event.metrics ?? [];
+    if (metrics.length === 0) {
+      lines.push([...sessionCells(session), ...metricCells(event, { type: "" }, 0), extra].join(","));
+      continue;
+    }
+    for (let i = 0; i < metrics.length; i++) {
+      lines.push([...sessionCells(session), ...metricCells(event, metrics[i], i), extra].join(","));
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function parseCsvLine(line) {
+  const cells = [];
+  let current = "";
+  let quoted = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (quoted) {
+      if (ch === '"') {
+        if (line[i + 1] === '"') {
+          current += '"';
+          i += 1;
+        } else {
+          quoted = false;
+        }
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"' && current === "") {
+      quoted = true;
+    } else if (ch === ",") {
+      cells.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  cells.push(current);
+  return cells;
+}
+function splitCsvRecords(csv) {
+  const records = [];
+  let current = "";
+  let quoted = false;
+  for (let i = 0; i < csv.length; i++) {
+    const ch = csv[i];
+    if (ch === '"') {
+      if (quoted && csv[i + 1] === '"') {
+        current += '""';
+        i += 1;
+        continue;
+      }
+      quoted = !quoted;
+      current += ch;
+    } else if (!quoted && (ch === "\n" || ch === "\r")) {
+      if (ch === "\r" && csv[i + 1] === "\n") i += 1;
+      if (current.length > 0) records.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.length > 0) records.push(current);
+  return records;
+}
+var num = (cell) => cell === "" ? void 0 : Number(cell);
+var nonempty = (cell) => cell === "" ? void 0 : cell;
+function jsonCell(cell) {
+  if (!cell) return void 0;
+  try {
+    return JSON.parse(cell);
+  } catch {
+    return void 0;
+  }
+}
+function csvToSessionRows(csv) {
+  const lines = splitCsvRecords(csv);
+  if (lines.length < 2) throw new Error("[wod import] Session CSV has no data rows");
+  const header = parseCsvLine(lines[0]);
+  if (header.some((name) => /segment/i.test(name))) {
+    throw new Error("[wod import] Incompatible Session CSV segment pins; blockId/blockVersion are required");
+  }
+  const col = (name) => {
+    const idx = header.indexOf(name);
+    if (idx < 0) throw new Error(`[wod import] Session CSV missing column "${name}"`);
+    return idx;
+  };
+  const at = (cells, name) => cells[col(name)] ?? "";
+  const eventRows = /* @__PURE__ */ new Map();
+  let session;
+  const ensureSession = (cells) => {
+    const id = at(cells, "sessionId");
+    const noteId = at(cells, "noteId");
+    const blockId = at(cells, "blockId");
+    const blockVersion = Number(at(cells, "blockVersion"));
+    if (!id || !noteId || !blockId || !Number.isSafeInteger(blockVersion) || blockVersion < 1) {
+      throw new Error("[wod import] Session CSV requires sessionId, noteId, blockId and positive blockVersion");
+    }
+    if (session) {
+      if (session.id !== id || session.noteId !== noteId || session.blockId !== blockId || session.blockVersion !== blockVersion) {
+        throw new Error("[wod import] Session CSV contains inconsistent source pins");
+      }
+      return session;
+    }
+    const extra = jsonCell(at(cells, "sessionExtraJson")) ?? {};
+    if ("segmentId" in extra || "segmentVersion" in extra || "version" in extra || "rawContent" in extra || "data" in extra) {
+      throw new Error("[wod import] Incompatible Session CSV source snapshot or segment pin");
+    }
+    session = {
+      ...extra,
+      id,
+      noteId,
+      blockId,
+      blockVersion,
+      blockContentId: at(cells, "blockContentId") || void 0,
+      origin: at(cells, "origin") || void 0,
+      status: at(cells, "status") || void 0,
+      startTime: Number(at(cells, "startTime") || 0),
+      endTime: Number(at(cells, "endTime") || 0),
+      duration: Number(at(cells, "duration") || 0),
+      completed: at(cells, "completed") === "true",
+      createdAt: Number(at(cells, "sessionCreatedAt") || 0)
+    };
+    if (![session.startTime, session.endTime, session.duration, session.createdAt].every(Number.isFinite)) {
+      throw new Error("[wod import] Session CSV lifecycle values must be finite numbers");
+    }
+    return session;
+  };
+  for (const line of lines.slice(1)) {
+    const cells = parseCsvLine(line);
+    if (cells.length === 1 && cells[0] === "") continue;
+    const currentSession = ensureSession(cells);
+    const eventId = at(cells, "eventId");
+    if (!eventId) continue;
+    let event = eventRows.get(eventId);
+    if (!event) {
+      const extra = jsonCell(at(cells, "eventExtraJson")) ?? {};
+      if ("segmentId" in extra || "segmentVersion" in extra) {
+        throw new Error("[wod import] Incompatible Session CSV event segment pins");
+      }
+      const blockId = nonempty(at(cells, "eventBlockId"));
+      const blockVersion = num(at(cells, "eventBlockVersion"));
+      if (blockId !== currentSession.blockId || blockVersion !== currentSession.blockVersion) {
+        throw new Error("[wod import] Event source pin differs from Session source pin");
+      }
+      event = {
+        ...extra,
+        id: eventId,
+        resultId: currentSession.id,
+        noteId: nonempty(at(cells, "noteId")) ?? extra.noteId ?? currentSession.noteId,
+        blockContentId: nonempty(at(cells, "eventBlockContentId")) ?? extra.blockContentId,
+        pageId: nonempty(at(cells, "pageId")) ?? extra.pageId,
+        origin: nonempty(at(cells, "eventOrigin")) ?? extra.origin,
+        timestamp: Number(at(cells, "timestamp") || extra.timestamp || 0),
+        grain: nonempty(at(cells, "grain")) ?? extra.grain ?? "event",
+        effortSlug: nonempty(at(cells, "effortSlug")) ?? extra.effortSlug,
+        outputType: nonempty(at(cells, "outputType")) ?? extra.outputType ?? "event",
+        blockId,
+        blockVersion,
+        timeSpan: jsonCell(at(cells, "timeSpan")) ?? extra.timeSpan,
+        sourceBlockKey: nonempty(at(cells, "sourceBlockKey")) ?? extra.sourceBlockKey,
+        sourceStatementId: num(at(cells, "sourceStatementId")) ?? extra.sourceStatementId,
+        line: num(at(cells, "line")) ?? extra.line,
+        text: nonempty(at(cells, "text")) ?? extra.text,
+        dialect: nonempty(at(cells, "dialect")) ?? extra.dialect,
+        stackLevel: num(at(cells, "stackLevel")) ?? extra.stackLevel,
+        completionReason: nonempty(at(cells, "completionReason")) ?? extra.completionReason,
+        representationKind: nonempty(at(cells, "representationKind")) ?? extra.representationKind,
+        metrics: [],
+        // Rebuild anchors from metric rows while preserving an authored empty array.
+        metricTemporal: Array.isArray(extra.metricTemporal) ? [] : void 0
+      };
+      eventRows.set(eventId, event);
+    }
+    const metricType = at(cells, "metricType");
+    if (!metricType) continue;
+    const baseMetric = jsonCell(at(cells, "metricJson")) ?? {};
+    const metric = {
+      ...baseMetric,
+      type: metricType,
+      ...at(cells, "metricValue") !== "" ? { value: metricValueFromCell(at(cells, "metricValue")) } : {},
+      ...nonempty(at(cells, "metricUnit")) ? { unit: at(cells, "metricUnit") } : {},
+      ...nonempty(at(cells, "metricImage")) ? { image: at(cells, "metricImage") } : {},
+      ...nonempty(at(cells, "metricOrigin")) ? { origin: at(cells, "metricOrigin") } : {},
+      ...at(cells, "metricMetadata") !== "" ? { metadata: jsonCell(at(cells, "metricMetadata")) } : {}
+    };
+    event.metrics.push(metric);
+    const temporal = jsonCell(at(cells, "metricTemporal"));
+    if (temporal !== void 0) {
+      (event.metricTemporal ??= []).push(temporal);
+    }
+  }
+  if (!session) throw new Error("[wod import] Session CSV did not contain session columns");
+  return { session, events: [...eventRows.values()] };
 }
 
 // src/version.ts
-var VERSION = "0.35.2129";
-var GIT_SHA = "a49fd2c";
-var BUILD_TIME = "2026-10-14T20:59:51.571Z";
+var VERSION = "0.36.2133";
+var GIT_SHA = "bb2644d";
+var BUILD_TIME = "2026-10-15T01:00:35.539Z";
 var SEMVER = {
-  version: "0.35.2129",
-  gitSha: "a49fd2c",
-  buildTime: "2026-10-14T20:59:51.571Z"
+  version: "0.36.2133",
+  gitSha: "bb2644d",
+  buildTime: "2026-10-15T01:00:35.539Z"
 };
+var SEED_SCHEMA = 8;
+var SEED_REGISTERED_WIDGETS = KNOWN_SECTION_WIDGETS;
+var SEED_BROADCAST_CHANNEL = "wodwiki.seed";
+var EFFORTS_CHUNK_ID = "efforts";
+var CANVAS_CHUNK_ID = "canvas";
+var DASHBOARDS_CHUNK_ID = "dashboards";
+var TEMPLATE_CHUNK_ID = "template";
+function seedMetaKey(sourceId) {
+  return `seed:${sourceId}`;
+}
+function emptySeedMeta(key) {
+  return { key, schema: SEED_SCHEMA, seedVersion: 0, builtAt: "", importedAt: 0, chunks: {}, claim: null };
+}
+function catalogForChunkId(chunkId) {
+  const value = /^(?:collection|feed)\.(.+)$/.exec(chunkId)?.[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;
+  return fm?.[1]?.match(/^route:\s*(\S+)\s*$/m)?.[1]?.replace(/^\//, "") || null;
+}
+function seedNoteSourceId(path, content, chunkId) {
+  const parts = path.split("/");
+  const stem = (parts.at(-1) ?? "").replace(/\.md$/i, "");
+  const under = parts.slice(2).map((p) => p.replace(/\.md$/i, "")).join("/");
+  if (chunkId === CANVAS_CHUNK_ID) return `guides:${canvasRouteSlug(content) ?? 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);
+    return !catalog ? "collection:_root" : stem.toLowerCase() === "readme" ? `collection:${catalog}` : `collection:${catalog}/${stem}`;
+  }
+  if (chunkId.startsWith("feed.")) return `feed:feeds/${under}`;
+  return void 0;
+}
+
+// src/seed/frontmatter.ts
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function unquote(value) {
+  return value.replace(
+    /^(['"])(.*)\1$/,
+    (_match, quote, inner) => quote === '"' ? inner.replace(/\\(["\\])/g, "$1") : inner
+  );
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(FRONTMATTER_RE);
+  if (!match) return { meta: {}, body: raw };
+  return { meta: parseMetaLines(match[1].split(/\r?\n/)), body: raw.slice(match[0].length) };
+}
+function parseMetaLines(lines) {
+  const meta = {};
+  for (let i = 0; i < lines.length; i++) {
+    const keyMatch = lines[i].match(/^([A-Za-z][\w.-]*)\s*:(.*)$/);
+    if (!keyMatch) continue;
+    const key = keyMatch[1];
+    const rawVal = keyMatch[2].trim();
+    if (rawVal === "") {
+      const items = [];
+      while (i + 1 < lines.length) {
+        const itemMatch = lines[i + 1].match(/^\s+-\s+(.+)$/);
+        if (!itemMatch) break;
+        items.push(itemMatch[1].trim());
+        i++;
+      }
+      meta[key] = items.length > 0 ? items : "";
+    } else {
+      const wasQuoted = /^(['"])(.*)\1$/.test(rawVal);
+      const value = unquote(rawVal);
+      const num2 = Number(value);
+      meta[key] = !wasQuoted && value !== "" && !isNaN(num2) ? num2 : value;
+    }
+  }
+  return meta;
+}
+function getScalar(meta, key) {
+  const value = meta[key];
+  return typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function getList(meta, key) {
+  const value = meta[key];
+  return Array.isArray(value) ? value : [];
+}
+
+// src/seed/effort-file.ts
+function parseDiscipline(val) {
+  if (!val) return void 0;
+  const normalized = unquoteYaml(val.trim()).toLowerCase();
+  if (isEffortDiscipline(normalized)) return normalized;
+  console.warn(`[effort-file] unknown discipline '${val}' \u2014 treating as unset`);
+  return void 0;
+}
+function unquoteYaml(val) {
+  if (val.startsWith('"') && val.endsWith('"')) {
+    return val.slice(1, -1).replace(/\\(["\\])/g, "$1");
+  }
+  if (val.startsWith("'") && val.endsWith("'")) {
+    return val.slice(1, -1).replace(/\\'/g, "'");
+  }
+  return val;
+}
+function coerceNestedScalar(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw !== "" && !Number.isNaN(Number(raw))) return Number(raw);
+  return raw;
+}
+function readNestedSection(lines, key) {
+  const start = lines.findIndex((l) => new RegExp(`^${key}:\\s*$`).test(l));
+  if (start === -1) return void 0;
+  const result = {};
+  let subKey = null;
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\S/.test(line)) break;
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const m = trimmed.match(/^([\w.-]+):\s*(.*)$/);
+    if (!m) continue;
+    const [, k, rawVal] = m;
+    if (indent === 2) {
+      if (rawVal === "") {
+        subKey = k;
+        result[k] = {};
+      } else {
+        subKey = null;
+        result[k] = coerceNestedScalar(rawVal);
+      }
+    } else if (indent >= 4 && subKey !== null) {
+      result[subKey][k] = coerceNestedScalar(rawVal);
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseEffortFile(raw) {
+  const blockMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!blockMatch) return null;
+  const { meta, body } = parseFrontmatter(raw);
+  const innerLines = blockMatch[1].split(/\r?\n/);
+  const id = getScalar(meta, "id");
+  const slug = getScalar(meta, "slug");
+  const label = getScalar(meta, "label");
+  const aliases = getList(meta, "aliases");
+  const baseAttrs = readNestedSection(innerLines, "baseAttributes");
+  const hints = readNestedSection(innerLines, "hints");
+  const derivation = readNestedSection(innerLines, "derivation");
+  const metRaw = baseAttrs?.met;
+  const met = typeof metRaw === "number" ? metRaw : Number(metRaw);
+  if (!id || !slug || !label || metRaw === void 0 || Number.isNaN(met)) return null;
+  const discipline = parseDiscipline(
+    typeof baseAttrs?.discipline === "string" ? baseAttrs.discipline : void 0
+  );
+  const intensityTier = baseAttrs?.intensityTier;
+  const trimmedBody = body.trim();
+  return {
+    id: String(id),
+    slug: String(slug),
+    label: String(label),
+    aliases,
+    baseAttributes: {
+      met,
+      ...discipline ? { discipline } : {},
+      ...intensityTier ? { intensityTier } : {}
+    },
+    registrySource: "bundled",
+    ...trimmedBody ? { body: trimmedBody } : {},
+    ...hints ? { hints } : {},
+    ...derivation ? { derivation } : {}
+  };
+}
+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;
+}
+
+// src/seed/runtime.ts
+var SEED_NAMESPACE = "1b671a64-40d5-491e-99b0-da01ff1f3341";
+async function seedNoteId(path) {
+  const digest = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(`${SEED_NAMESPACE}:${path}`));
+  const bytes = new Uint8Array(digest.slice(0, 16));
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function equal(a, b) {
+  if (Object.is(a, b)) return true;
+  if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+  const ak = Object.keys(a).filter((key) => Reflect.get(a, key) !== void 0), bk = Object.keys(b).filter((key) => Reflect.get(b, key) !== void 0);
+  return ak.length === bk.length && ak.every((key) => key in b && equal(Reflect.get(a, key), Reflect.get(b, key)));
+}
+function titleFromPath(path) {
+  return (path.split("/").at(-1) ?? path).replace(/\.md$/, "").replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function refreshedBlocks(existing, rawContent, sourceRevision) {
+  const old = existing.rawContent;
+  let from = 0, endOld = old.length, endNew = rawContent.length;
+  while (from < endOld && from < endNew && old[from] === rawContent[from]) from++;
+  while (endOld > from && endNew > from && old[endOld - 1] === rawContent[endNew - 1]) {
+    endOld--;
+    endNew--;
+  }
+  const intersect = Object.values(existing.blocks).filter((b) => from < b.to && endOld > b.from);
+  const trusted = intersect.length <= 1 ? existing.blocks : Object.fromEntries(Object.entries(existing.blocks).filter(([, b]) => !intersect.includes(b)));
+  const mapped = mapNoteBlockChanges(trusted, [{ from, to: endOld, insert: rawContent.slice(from, endNew) }]);
+  let ordinal = 0;
+  return reconcileNoteBlocks(rawContent, { sourceRevision, blocks: mapped, registeredWidgets: SEED_REGISTERED_WIDGETS, createId: () => `seed:${existing.id}:r${sourceRevision}:${ordinal++}` });
+}
+async function putChanged(store, values, keys) {
+  if (!values.length) return;
+  const prior = await store.getMany(keys);
+  const changed = values.filter((value, i) => !equal(value, prior[i]));
+  if (changed.length) await store.putMany(changed);
+}
+async function applySeedChunk(storage, write) {
+  assertSeedManifest(write.manifest);
+  assertSeedRows(write.rows);
+  const result = { totalNotes: 0, totalEfforts: 0, totalBlocks: 0, skippedUserOwned: 0, deleted: 0, addedNotes: 0, updatedNotes: 0 };
+  const ids = await Promise.all(write.rows.map((row) => seedNoteId(row.path)));
+  const pagesBySlug = /* @__PURE__ */ new Map();
+  const linkIds = /* @__PURE__ */ new Map();
+  const tagIds = /* @__PURE__ */ new Map();
+  for (const [i, row] of write.rows.entries()) {
+    const slug = readFrontmatterMeta(row.content)["slug"];
+    if (typeof slug === "string" && slug.trim()) {
+      pagesBySlug.set(slug, await seedNoteId(`page:${slug}`));
+      linkIds.set(ids[i], await seedNoteId(`pagenote:${slug}:${row.path}`));
+    }
+    for (const { label } of extractTypedTags(row.content)) {
+      if (!tagIds.has(label)) tagIds.set(label, await seedNoteId(`tag:${label}`));
+    }
+  }
+  return storage.transaction(["notes", "block_revisions", "block_index", "block_efforts", "page", "page_notes", "tags", "note_tags", "efforts", "meta"], "readwrite", async (tx) => {
+    const metaStore = tx.readwrite("meta");
+    const actualMeta = await metaStore.get(write.meta.key);
+    if (!equal(actualMeta, write.expectedMeta)) throw new Error("Seed checkpoint changed during import");
+    if (write.meta.schema !== SEED_SCHEMA || write.manifest.schema !== SEED_SCHEMA) throw new Error("Incompatible seed schema; recreate artifacts");
+    const noteStore = tx.readwrite("notes");
+    const priorIds = write.chunkId ? write.expectedMeta?.chunks[write.chunkId]?.noteIds ?? [] : [];
+    const declared = new Set(ids);
+    const goneIds = priorIds.filter((id) => !declared.has(id));
+    const allIds = [.../* @__PURE__ */ new Set([...ids, ...goneIds])];
+    const stored = await noteStore.getMany(allIds);
+    const existingById = new Map(allIds.map((id, i) => [id, stored[i]]));
+    const ownedIds = allIds.filter((id) => {
+      const note = existingById.get(id);
+      return !note || note.seedOrigin === "seed" && (declared.has(id) || note.seedChunkId === write.chunkId);
+    });
+    const owned = new Set(ownedIds);
+    const revisionStore = tx.readwrite("block_revisions");
+    const historyIds = ids.filter((id, i) => owned.has(id) && existingById.get(id)?.rawContent !== write.rows[i].content);
+    const histories = await revisionStore.getAllFromIndexMany("by-note", historyIds);
+    const history = new Map(historyIds.map((id, i) => [id, histories[i]]));
+    const indexStore = tx.readwrite("block_index"), effortLinks = tx.readwrite("block_efforts");
+    const tagLinks = tx.readwrite("note_tags"), pageLinks = tx.readwrite("page_notes");
+    const currentIndexes = await indexStore.getAllFromIndexMany("by-note", ownedIds);
+    const currentEfforts = await effortLinks.getAllFromIndexMany("by-note", ownedIds);
+    const currentTags = await tagLinks.getAllFromIndexMany("by-note", ownedIds);
+    const currentPages = await pageLinks.getAllFromIndexMany("by-note", ownedIds);
+    const slot = new Map(ownedIds.map((id, i) => [id, i]));
+    const tagsStore = tx.readwrite("tags");
+    const labels = [...tagIds.keys()];
+    const matches = await tagsStore.getAllFromIndexMany("by-label", labels);
+    const tagsByLabel = new Map(labels.map((label, i) => [label, matches[i][0]]));
+    const changedTags = [], changedNotes = [], revisions = [], pages = [], pageNotes = [], noteTags = [];
+    const blocks = [], blockEfforts = [];
+    for (const [i, row] of write.rows.entries()) {
+      const id = ids[i], existing = existingById.get(id);
+      if (!owned.has(id)) {
+        result.skippedUserOwned++;
+        continue;
+      }
+      if (!existing) result.addedNotes++;
+      else if (existing.rawContent !== row.content) result.updatedNotes++;
+      validateNoteBlocks(row.content, row.blocks, 1, { registeredWidgets: SEED_REGISTERED_WIDGETS });
+      const sourceRevision = existing ? existing.sourceRevision + (existing.rawContent === row.content ? 0 : 1) : 1;
+      let ordinal = 0;
+      const retainedHistory = history.get(id) ?? [];
+      const map = !existing ? retainedHistory.length ? reconcileNoteBlocks(row.content, { sourceRevision, registeredWidgets: SEED_REGISTERED_WIDGETS, createId: () => `seed:${id}:new${retainedHistory.length}:${ordinal++}` }) : structuredClone(row.blocks) : existing.rawContent === row.content ? structuredClone(existing.blocks) : refreshedBlocks(existing, row.content, sourceRevision);
+      for (const block of Object.values(map)) {
+        const saved = (history.get(id) ?? []).filter((r) => r.blockId === block.id).sort((a, b) => b.version - a.version)[0];
+        const source = row.content.slice(block.from, block.to);
+        if (existing?.rawContent === row.content) continue;
+        const same = saved && saved.kind === block.kind && saved.rawContent === source && saved.dialect === block.dialect && saved.sport === block.sport;
+        block.version = !existing ? 1 : same ? saved.version : (saved?.version ?? 0) + 1;
+        if (!existing || !same) revisions.push({ noteId: id, blockId: block.id, version: block.version, kind: block.kind, rawContent: source, savedAt: write.meta.importedAt, ...block.dialect ? { dialect: block.dialect } : {}, ...block.sport ? { sport: block.sport } : {} });
+      }
+      validateNoteBlocks(row.content, map, sourceRevision, { registeredWidgets: SEED_REGISTERED_WIDGETS });
+      const fm = readFrontmatterMeta(row.content);
+      const title = typeof fm["title"] === "string" && fm["title"].trim() ? fm["title"].trim() : titleFromPath(row.path);
+      const sourceId = write.chunkId ? seedNoteSourceId(row.path, row.content, write.chunkId) : void 0;
+      if (!sourceId) throw new Error(`Unknown seed source family ${write.chunkId}`);
+      const date = typeof fm["date"] === "string" && /^\d{4}-\d{2}-\d{2}$/.test(fm["date"]) ? Date.parse(`${fm["date"]}T12:00:00Z`) : void 0;
+      const note = { ...existing, id, title, rawContent: row.content, sourceRevision, blocks: map, createdAt: write.manifest.version, ...date === void 0 ? {} : { date }, type: write.chunkId === DASHBOARDS_CHUNK_ID ? "dashboard" : "note", sourceId, catalog: catalogForChunkId(write.chunkId ?? ""), seedOrigin: "seed", seedVersion: write.manifest.version, seedChunkId: write.chunkId ?? void 0, sourcePath: row.path };
+      if (date === void 0) delete note.date;
+      if (!equal(note, existing)) changedNotes.push(note);
+      const byRange = new Map(Object.values(map).map((b) => [`${b.from}:${b.to}`, b]));
+      const compiledById = new Map(row.blockIndex.map((b) => [b.blockId, b]));
+      const remap = /* @__PURE__ */ new Map();
+      for (const compiled of row.blockIndex) {
+        const block = byRange.get(`${compiled.from}:${compiled.to}`);
+        if (!block || block.kind !== compiled.dataType) throw new Error("Orphan seed projection");
+        remap.set(compiled.blockId, block.id);
+        const projection = { ...compiled, id: `${id}:${block.id}`, noteId: id, blockId: block.id, blockVersion: block.version, sourceRevision, noteTitle: title, sourceId, sourcePath: row.path, rawContent: row.content.slice(block.from, block.to) };
+        const prior = currentIndexes[slot.get(id)].find((b) => b.id === projection.id);
+        if (!prior || prior.isStatic === true) blocks.push(projection);
+      }
+      for (const compiled of row.blockEfforts) {
+        const blockId = remap.get(compiled.blockId);
+        if (!blockId || compiledById.get(compiled.blockId)?.dataType !== "wod") throw new Error("Orphan seed effort link");
+        const link = { ...compiled, id: `${id}:${blockId}:${compiled.effortSlug}`, noteId: id, blockId, sourcePath: row.path };
+        const prior = currentEfforts[slot.get(id)].find((b) => b.id === link.id);
+        if (!prior || prior.isStatic === true) blockEfforts.push(prior ? { ...link, createdAt: prior.createdAt } : link);
+      }
+      const n = slot.get(id);
+      const wantedTags = /* @__PURE__ */ new Set();
+      for (const item of extractTypedTags(row.content)) {
+        let tag = tagsByLabel.get(item.label);
+        if (!tag) {
+          tag = { id: tagIds.get(item.label), label: item.label, type: item.type, createdAt: write.meta.importedAt };
+          changedTags.push(tag);
+          tagsByLabel.set(item.label, tag);
+        } else if (item.type && !tag.type) {
+          tag = { ...tag, type: item.type };
+          changedTags.push(tag);
+          tagsByLabel.set(item.label, tag);
+        }
+        if (wantedTags.has(tag.id)) continue;
+        wantedTags.add(tag.id);
+        const link = currentTags[n].find((l) => l.tagId === tag.id);
+        if (!link) noteTags.push({ id: `${id}:${tag.id}`, noteId: id, tagId: tag.id });
+      }
+      for (const link of currentTags[n]) if (!wantedTags.has(link.tagId)) await tagLinks.delete(link.id);
+      const slug = fm["slug"];
+      if (typeof slug === "string" && pagesBySlug.has(slug)) {
+        const pageId = pagesBySlug.get(slug);
+        pages.push({ id: pageId, slug, title: titleFromPath(row.path), createdAt: write.manifest.version });
+        pageNotes.push({ id: linkIds.get(id), pageId, noteId: id, createdAt: write.manifest.version });
+      }
+      result.totalNotes++;
+      result.totalBlocks += Object.keys(map).length;
+    }
+    const wantedBlocks = new Set(blocks.map((b) => b.id)), wantedEfforts = new Set(blockEfforts.map((b) => b.id));
+    for (const rows of currentIndexes) for (const row of rows) if (row.isStatic === true && !wantedBlocks.has(row.id)) await indexStore.delete(row.id);
+    for (const rows of currentEfforts) for (const row of rows) if (row.isStatic === true && !wantedEfforts.has(row.id)) await effortLinks.delete(row.id);
+    for (const id of goneIds) {
+      if (!owned.has(id) || !existingById.get(id)) continue;
+      const n = slot.get(id);
+      await noteStore.delete(id);
+      for (const link of currentTags[n]) await tagLinks.delete(link.id);
+      for (const link of currentPages[n]) await pageLinks.delete(link.id);
+      result.deleted++;
+    }
+    const effortStore = tx.readwrite("efforts");
+    if (write.chunkId === EFFORTS_CHUNK_ID) {
+      const efforts = write.rows.filter((_row, i) => owned.has(ids[i])).map((r) => parseEffortFile(r.content)).filter((e) => e !== null).map((e) => ({ ...e, registrySource: "bundled" }));
+      const prior = await effortStore.getMany(efforts.map((e) => e.slug));
+      const changed = efforts.filter((e, i) => (!prior[i] || prior[i]?.registrySource === "bundled") && !equal(e, prior[i]));
+      if (changed.length) await effortStore.putMany(changed);
+      result.totalEfforts = changed.length;
+      const wantedSlugs = new Set(efforts.map((effort) => effort.slug));
+      const removed = allIds.map((id) => {
+        const note = existingById.get(id);
+        return owned.has(id) && note ? parseEffortFile(note.rawContent)?.slug : void 0;
+      }).filter((slug) => !!slug && !wantedSlugs.has(slug));
+      const old = await effortStore.getMany(removed);
+      for (const [i, effort] of old.entries()) if (effort?.registrySource === "bundled") await effortStore.delete(removed[i]);
+    }
+    if (changedNotes.length) await noteStore.putMany(changedNotes);
+    if (revisions.length) await revisionStore.putMany(revisions);
+    await putChanged(indexStore, blocks, blocks.map((b) => b.id));
+    await putChanged(effortLinks, blockEfforts, blockEfforts.map((b) => b.id));
+    if (changedTags.length) await tagsStore.putMany([...new Map(changedTags.map((t) => [t.id, t])).values()]);
+    if (noteTags.length) await tagLinks.putMany(noteTags);
+    await putChanged(tx.readwrite("page"), pages, pages.map((p) => p.id));
+    await putChanged(pageLinks, pageNotes, pageNotes.map((p) => p.id));
+    await metaStore.put(write.meta);
+    return result;
+  });
+}
 
-export { BUILD_TIME, GIT_SHA, SEMVER, VERSION };
+export { BUILD_TIME, CANVAS_CHUNK_ID, DASHBOARDS_CHUNK_ID, EFFORTS_CHUNK_ID, GIT_SHA, NOTE_ID_FRONTMATTER_KEY, SEED_BROADCAST_CHANNEL, SEED_REGISTERED_WIDGETS, SEED_SCHEMA, SEMVER, SESSION_CSV_HEADER, TEMPLATE_CHUNK_ID, VERSION, applySeedChunk, assertSeedManifest, assertSeedRows, buildStatementTree, canvasRouteSlug, catalogForChunkId, composeNoteMarkdown, createIRFile, csvToEquipmentLabels, csvToSessionRows, defineLanguagePack, effortToMarkdown, emptySeedMeta, equipmentToCsv, extractNoteIdentity, extractTypedTags, getRegisteredLanguagePacks, inMemoryEventStore, injectIdentityFrontmatter, isIRFile, listLanguagePacks, markdownToEffort, parseCsvLine, readFrontmatterMeta, registerLanguagePack, seedMetaKey, seedNoteId, seedNoteSourceId, sessionToCsv, splitCsvRecords, statementToNode, unregisterLanguagePack };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map