@bitcobblers/wod-wiki-core 0.10.42 → 0.35.2115

package/dist/index.cjs

@@ -26,6 +26,88 @@ function getMetricOwnershipLayer(origin) {
   return LEGACY_ORIGIN_TO_OWNERSHIP_LAYER[origin ?? "parser"] ?? "parser";
 }
 
+// src/models/Metric.ts
+var MetricType = /* @__PURE__ */ ((MetricType2) => {
+  MetricType2["Duration"] = "duration";
+  MetricType2["Spans"] = "spans";
+  MetricType2["SystemTime"] = "system-time";
+  MetricType2["Time"] = "time";
+  MetricType2["Elapsed"] = "elapsed";
+  MetricType2["Total"] = "total";
+  MetricType2["Rep"] = "rep";
+  MetricType2["Effort"] = "effort";
+  MetricType2["Distance"] = "distance";
+  MetricType2["Rounds"] = "rounds";
+  MetricType2["CurrentRound"] = "current-round";
+  MetricType2["Action"] = "action";
+  MetricType2["Increment"] = "increment";
+  MetricType2["Group"] = "group";
+  MetricType2["Text"] = "text";
+  MetricType2["Resistance"] = "resistance";
+  MetricType2["Sound"] = "sound";
+  MetricType2["System"] = "system";
+  MetricType2["Label"] = "label";
+  MetricType2["Lap"] = "lap";
+  MetricType2["Metric"] = "metric";
+  MetricType2["Hint"] = "hint";
+  MetricType2["Custom"] = "custom";
+  MetricType2["Volume"] = "volume";
+  MetricType2["Intensity"] = "intensity";
+  MetricType2["Grade"] = "grade";
+  MetricType2["Load"] = "load";
+  MetricType2["Work"] = "work";
+  MetricType2["RIR"] = "rir";
+  MetricType2["SessionRPE"] = "session-rpe";
+  MetricType2["SessionLoad"] = "session-load";
+  MetricType2["METScore"] = "met-score";
+  MetricType2["TIS"] = "tis";
+  MetricType2["Calculated"] = "calculated";
+  MetricType2["Choice"] = "choice";
+  return MetricType2;
+})(MetricType || {});
+var Metric = class {
+  type;
+  metricType;
+  value;
+  origin;
+  unit;
+  action;
+  image;
+  sourceBlockKey;
+  timestamp;
+  metadata;
+  name;
+  ownershipLayer;
+  constructor(typeOrName, valueOrType, originOrValue, unit, origin, action, image) {
+    if (typeof valueOrType === "string" && (typeof originOrValue === "number" || typeof originOrValue === "string" || typeof originOrValue === "boolean" || originOrValue === null || originOrValue === void 0)) {
+      this.name = String(typeOrName);
+      this.type = valueOrType;
+      this.metricType = valueOrType;
+      this.value = originOrValue;
+      this.unit = unit;
+      this.origin = origin || "parser";
+      this.action = action === "suppress" ? "suppress" : void 0;
+      this.image = image ?? String(originOrValue ?? valueOrType);
+    } else {
+      this.type = typeOrName;
+      this.metricType = typeOrName;
+      this.value = valueOrType;
+      this.origin = originOrValue || "parser";
+      this.unit = unit;
+      this.action = typeof origin === "string" && origin === "suppress" ? "suppress" : action === "suppress" ? "suppress" : void 0;
+      this.image = image ?? String(valueOrType ?? typeOrName);
+    }
+  }
+  toNumber() {
+    if (typeof this.value === "number") return this.value;
+    if (typeof this.value === "string") {
+      const parsed = parseFloat(this.value);
+      return isNaN(parsed) ? 0 : parsed;
+    }
+    return 0;
+  }
+};
+
 // src/ownership/ledger.ts
 var LAYER_RANK = {
   parser: 0,
@@ -41,6 +123,10 @@ function resolveLayer(metric) {
   }
   return getMetricOwnershipLayer(metric.origin);
 }
+function ownershipRank(metric) {
+  const layer = resolveLayer(metric);
+  return LAYER_RANK[layer] ?? 0;
+}
 function normalize(metrics) {
   return metrics.map((metric, index) => {
     const layer = resolveLayer(metric);
@@ -234,98 +320,6 @@ function createMetricOwnershipLedger(metrics) {
     }
   };
 }
-
-// src/models/Metric.ts
-var MetricType = /* @__PURE__ */ ((MetricType2) => {
-  MetricType2["Duration"] = "duration";
-  MetricType2["Spans"] = "spans";
-  MetricType2["SystemTime"] = "system-time";
-  MetricType2["Time"] = "time";
-  MetricType2["Elapsed"] = "elapsed";
-  MetricType2["Total"] = "total";
-  MetricType2["Rep"] = "rep";
-  MetricType2["Effort"] = "effort";
-  MetricType2["Distance"] = "distance";
-  MetricType2["Rounds"] = "rounds";
-  MetricType2["CurrentRound"] = "current-round";
-  MetricType2["Action"] = "action";
-  MetricType2["Increment"] = "increment";
-  MetricType2["Group"] = "group";
-  MetricType2["Text"] = "text";
-  MetricType2["Resistance"] = "resistance";
-  MetricType2["Sound"] = "sound";
-  MetricType2["System"] = "system";
-  MetricType2["Label"] = "label";
-  MetricType2["Lap"] = "lap";
-  MetricType2["Metric"] = "metric";
-  MetricType2["Hint"] = "hint";
-  MetricType2["Custom"] = "custom";
-  MetricType2["Volume"] = "volume";
-  MetricType2["Intensity"] = "intensity";
-  MetricType2["Load"] = "load";
-  MetricType2["Work"] = "work";
-  MetricType2["RIR"] = "rir";
-  MetricType2["SessionRPE"] = "session-rpe";
-  MetricType2["SessionLoad"] = "session-load";
-  MetricType2["METScore"] = "met-score";
-  MetricType2["TIS"] = "tis";
-  MetricType2["Calculated"] = "calculated";
-  MetricType2["Choice"] = "choice";
-  return MetricType2;
-})(MetricType || {});
-var Metric = class {
-  type;
-  metricType;
-  value;
-  origin;
-  unit;
-  action;
-  image;
-  sourceBlockKey;
-  timestamp;
-  metadata;
-  name;
-  ownershipLayer;
-  constructor(typeOrName, valueOrType, originOrValue, unit, origin, action, image) {
-    if (typeof valueOrType === "string" && (typeof originOrValue === "number" || typeof originOrValue === "string" || typeof originOrValue === "boolean" || originOrValue === null || originOrValue === void 0)) {
-      this.name = String(typeOrName);
-      this.type = valueOrType;
-      this.metricType = valueOrType;
-      this.value = originOrValue;
-      this.unit = unit;
-      this.origin = origin || "parser";
-      this.action = action === "suppress" ? "suppress" : void 0;
-      this.image = image ?? String(originOrValue ?? valueOrType);
-    } else {
-      this.type = typeOrName;
-      this.metricType = typeOrName;
-      this.value = valueOrType;
-      this.origin = originOrValue || "parser";
-      this.unit = unit;
-      this.action = typeof origin === "string" && origin === "suppress" ? "suppress" : action === "suppress" ? "suppress" : void 0;
-      this.image = image ?? String(valueOrType ?? typeOrName);
-    }
-  }
-  toNumber() {
-    if (typeof this.value === "number") return this.value;
-    if (typeof this.value === "string") {
-      const parsed = parseFloat(this.value);
-      return isNaN(parsed) ? 0 : parsed;
-    }
-    return 0;
-  }
-};
-
-// src/ownership/OwnershipResolver.ts
-function resolveLayer2(metric) {
-  const maybeLayer = metric.ownershipLayer;
-  if (maybeLayer != null) return maybeLayer;
-  return getMetricOwnershipLayer(metric.origin ?? "parser");
-}
-function ownershipRank(metric) {
-  const layer = resolveLayer2(metric);
-  return METRIC_OWNERSHIP_LAYER_CHAIN.indexOf(layer);
-}
 function applyFilter(metrics, filter) {
   let filtered = [...metrics];
   const wantsHints = filter?.types?.includes("hint" /* Hint */) ?? false;
@@ -360,6 +354,181 @@ var OwnershipResolver = class {
   }
 };
 
+// src/fields/fieldIdentity.ts
+function splitWords(component) {
+  const onSeparators = component.split(/[\s_\-\u2010-\u2015]+/).filter(Boolean);
+  const words = [];
+  for (const chunk of onSeparators) {
+    const cased = chunk.replace(/([\p{Ll}\p{Nd}])(\p{Lu})/gu, "$1\0$2").replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, "$1\0$2");
+    for (const word of cased.split("\0")) {
+      if (word) words.push(word);
+    }
+  }
+  return words;
+}
+function normalizeFieldComponent(component) {
+  const words = splitWords(component);
+  if (words.length === 0) return "";
+  return words.map((word, index) => {
+    const lower = word.toLowerCase();
+    return index === 0 ? lower : lower.charAt(0).toUpperCase() + lower.slice(1);
+  }).join("");
+}
+function normalizeFieldPath(path) {
+  return path.split(".").map(normalizeFieldComponent).filter((component) => component.length > 0).join(".");
+}
+function valueKindOf(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  switch (typeof value) {
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "object":
+      return "object";
+    default:
+      return "undefined";
+  }
+}
+function flattenFieldLeaves(input, prefix = "") {
+  const leaves = [];
+  for (const [rawKey, value] of Object.entries(input)) {
+    const path = prefix ? `${prefix}.${normalizeFieldPath(rawKey)}` : normalizeFieldPath(rawKey);
+    if (!path) continue;
+    const kind = valueKindOf(value);
+    if (kind === "object") {
+      leaves.push(...flattenFieldLeaves(value, path));
+    } else if (kind !== "undefined") {
+      leaves.push({ path, kind, value, originalPath: prefix ? `${prefix}.${rawKey}` : rawKey });
+    }
+  }
+  return leaves;
+}
+function fieldRefKey(ref) {
+  return JSON.stringify([ref.path, ref.kind, ref.dimension ?? null]);
+}
+function fieldRefFromKey(key) {
+  const [path, kind, dimension] = JSON.parse(key);
+  return { path, kind, ...dimension ? { dimension } : {} };
+}
+
+// src/units/catalog.ts
+var UnitConversionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "UnitConversionError";
+    this.code = code;
+  }
+};
+var UNIT_CATALOG = [
+  // Distance — base m
+  { canonical: "m", dimension: "distance", factor: 1, aliases: ["meter", "meters", "metre", "metres"] },
+  { canonical: "km", dimension: "distance", factor: 1e3, aliases: ["kilometer", "kilometers", "kilometre", "kilometres"] },
+  { canonical: "cm", dimension: "distance", factor: 0.01, aliases: ["centimeter", "centimeters"] },
+  { canonical: "mm", dimension: "distance", factor: 1e-3, aliases: ["millimeter", "millimeters"] },
+  { canonical: "ft", dimension: "distance", factor: 0.3048, aliases: ["foot", "feet"] },
+  { canonical: "in", dimension: "distance", factor: 0.0254, aliases: ["inch", "inches"] },
+  { canonical: "yd", dimension: "distance", factor: 0.9144, aliases: ["yard", "yards"] },
+  { canonical: "mi", dimension: "distance", factor: 1609.344, aliases: ["mile", "miles"] },
+  // Mass — base kg
+  { canonical: "kg", dimension: "mass", factor: 1, aliases: ["kilogram", "kilograms", "kilo", "kilos"] },
+  { canonical: "g", dimension: "mass", factor: 1e-3, aliases: ["gram", "grams"] },
+  { canonical: "lb", dimension: "mass", factor: 0.45359237, aliases: ["lbs", "pound", "pounds"] },
+  // Duration — base s
+  { canonical: "ms", dimension: "duration", factor: 1e-3, aliases: ["millisecond", "milliseconds"] },
+  { canonical: "s", dimension: "duration", factor: 1, aliases: ["sec", "secs", "second", "seconds"] },
+  { canonical: "min", dimension: "duration", factor: 60, aliases: ["mins", "minute", "minutes"] },
+  { canonical: "h", dimension: "duration", factor: 3600, aliases: ["hr", "hrs", "hour", "hours"] },
+  // Count — base count. Test-result scales ("pull-up", "thruster",
+  // "problem") are count-dimension scales: one of their units is one rep.
+  { canonical: "count", dimension: "count", factor: 1 },
+  { canonical: "rep", dimension: "count", factor: 1, aliases: ["reps"] },
+  { canonical: "pull-up", dimension: "count", factor: 1 },
+  { canonical: "thruster", dimension: "count", factor: 1 },
+  { canonical: "problem", dimension: "count", factor: 1 },
+  // Count-rate — base count/s; bpm (beats per minute) is its registered scale
+  { canonical: "count/s", dimension: "count-rate", factor: 1 },
+  { canonical: "bpm", dimension: "count-rate", factor: 1 / 60 },
+  // Energy — base cal
+  { canonical: "cal", dimension: "energy", factor: 1, aliases: ["calorie", "calories"] },
+  { canonical: "kcal", dimension: "energy", factor: 1e3, aliases: ["kilocalorie", "kilocalories"] },
+  // Speed — base m/s
+  { canonical: "m/s", dimension: "speed", factor: 1 },
+  { canonical: "km/h", dimension: "speed", factor: 1e3 / 3600, aliases: ["kmh", "kph"] },
+  { canonical: "mph", dimension: "speed", factor: 1609.344 / 3600 },
+  // Pace — base min/km
+  { canonical: "min/km", dimension: "pace", factor: 1 },
+  { canonical: "min/mi", dimension: "pace", factor: 1e3 / 1609.344 },
+  { canonical: "s/m", dimension: "pace", factor: 1 / 60 },
+  // Ratio — unitless base (factor 1); percent via 100% = 1.
+  // Dimensionless named scales (arbitrary units, points) share the ratio
+  // dimension but are convertible only to the base — never to each other.
+  { canonical: "ratio", dimension: "ratio", factor: 1, aliases: ["x"] },
+  { canonical: "%", dimension: "ratio", factor: 0.01, aliases: ["pct", "percent"] },
+  { canonical: "au", dimension: "ratio", factor: 1, aliases: ["AU"] },
+  { canonical: "pts", dimension: "ratio", factor: 1, aliases: ["point", "points"] },
+  { canonical: "rating", dimension: "ratio", factor: 1, aliases: ["ratings"] }
+];
+var bySpelling = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const def of UNIT_CATALOG) {
+    map.set(def.canonical.toLowerCase(), def);
+    for (const alias of def.aliases ?? []) {
+      if (!map.has(alias.toLowerCase())) map.set(alias.toLowerCase(), def);
+    }
+  }
+  return map;
+})();
+function lookupUnit(spelling) {
+  return bySpelling.get(spelling.trim().toLowerCase());
+}
+function dimensionKeyOf(spelling) {
+  return lookupUnit(spelling)?.dimension;
+}
+var SYSTEM_DEFAULT_OUTPUT_UNIT = Object.freeze({
+  mass: "kg",
+  distance: "m",
+  duration: "s",
+  count: "count",
+  "count-rate": "count/s",
+  energy: "cal",
+  speed: "m/s",
+  pace: "min/km",
+  ratio: void 0
+});
+function systemDefaultUnit(dimension) {
+  return SYSTEM_DEFAULT_OUTPUT_UNIT[dimension];
+}
+function convertViaCatalog(value, from, to) {
+  const fromDef = lookupUnit(from);
+  if (!fromDef) throw new UnitConversionError("unknown-unit", `Unknown unit "${from}"`);
+  const toDef = lookupUnit(to);
+  if (!toDef) throw new UnitConversionError("unknown-unit", `Unknown unit "${to}"`);
+  if (fromDef.dimension !== toDef.dimension) {
+    throw new UnitConversionError(
+      "dimension-mismatch",
+      `Cannot convert ${from} (${fromDef.dimension}) to ${to} (${toDef.dimension})`
+    );
+  }
+  if (fromDef.dimension === "ratio" && fromDef.canonical !== toDef.canonical) {
+    if (fromDef.canonical !== "ratio" && toDef.canonical !== "ratio") {
+      throw new UnitConversionError(
+        "scale-mismatch",
+        `Named scales ${from} and ${to} are not interchangeable`
+      );
+    }
+  }
+  if (!Number.isFinite(value)) {
+    throw new UnitConversionError("non-finite", `Non-finite value cannot be converted`);
+  }
+  return value * fromDef.factor / toDef.factor;
+}
+
 // src/models/CodeMetadata.ts
 var CodeMetadata = class {
   constructor(line, startOffset, endOffset, length, columnStart = 0, columnEnd = 0, raw = "") {
@@ -686,7 +855,7 @@ var ParsedCodeStatement = class extends CodeStatement {
 };
 
 // src/models/OutputStatement.ts
-var OutputStatement = class _OutputStatement {
+var OutputStatement = class _OutputStatement extends CodeStatement {
   static nextId = 1e6;
   id;
   outputType;
@@ -704,6 +873,7 @@ var OutputStatement = class _OutputStatement {
   statement;
   timestamp;
   constructor(optionsOrStatement, metricsArg, timestamp) {
+    super();
     if (optionsOrStatement && "outputType" in optionsOrStatement && "timeSpan" in optionsOrStatement) {
       const options = optionsOrStatement;
       this.id = _OutputStatement.nextId++;
@@ -711,6 +881,9 @@ var OutputStatement = class _OutputStatement {
       this.timeSpan = options.timeSpan;
       this.sourceBlockKey = options.sourceBlockKey ?? "";
       this.sourceStatementId = options.sourceStatementId;
+      this.line = options.line;
+      this.text = options.text;
+      this.dialect = options.dialect;
       this.stackLevel = options.stackLevel ?? 0;
       this.metrics = MetricContainer.from(options.metrics, this.id);
       this.metricMeta = options.metricMeta ?? /* @__PURE__ */ new Map();
@@ -733,27 +906,13 @@ var OutputStatement = class _OutputStatement {
       this.children = [];
       this.isLeaf = true;
       this.meta = stmt?.meta ?? new CodeMetadata(0, 0, 0, 0);
+      this.line = stmt?.line;
+      this.text = stmt?.text;
+      this.dialect = stmt?.dialect;
       this.timestamp = timestamp ?? Date.now();
     }
   }
-  // ═══════════════════════════════════════════════════════════════
-  // IMetricSource implementation
-  // ═══════════════════════════════════════════════════════════════
-  getDisplayMetrics(filter) {
-    return this.metrics.getDisplayMetrics(filter);
-  }
-  getMetric(type) {
-    return this.metrics.getMetric(type);
-  }
-  getAllMetricsByType(type) {
-    return this.metrics.getAllMetricsByType(type);
-  }
-  hasMetric(type) {
-    return this.metrics.hasMetric(type);
-  }
-  get rawMetrics() {
-    return this.metrics.rawMetrics;
-  }
+  // IMetricSource implementation is inherited from CodeStatement
   /**
    * Reset the ID counter (useful for testing)
    */
@@ -762,37 +921,6 @@ var OutputStatement = class _OutputStatement {
   }
 };
 
-// src/models/Duration.ts
-var Duration = class {
-  constructor(original) {
-    this.original = original;
-    let remaining = original ?? 0;
-    this.days = Math.floor(remaining / 864e5);
-    remaining %= 864e5;
-    this.hours = Math.floor(remaining / 36e5);
-    remaining %= 36e5;
-    this.minutes = Math.floor(remaining / 6e4);
-    remaining %= 6e4;
-    this.seconds = Math.floor(remaining / 1e3);
-    this.milliseconds = Math.round(remaining - this.seconds * 1e3);
-  }
-  original;
-  days;
-  hours;
-  minutes;
-  seconds;
-  milliseconds;
-};
-var SpanDuration = class extends Duration {
-  constructor(spans) {
-    const total = spans.reduce((sum, span) => {
-      const end = span.ended ?? Date.now();
-      return sum + Math.max(0, end - span.started);
-    }, 0);
-    super(total);
-  }
-};
-
 // src/models/BlockKey.ts
 var BlockKey = class {
   value;
@@ -810,6 +938,17 @@ var BlockKey = class {
   }
 };
 
+// src/models/blockContentId.ts
+function blockContentId(content) {
+  const normalized = content.trim();
+  let hash = 2166136261;
+  for (let i = 0; i < normalized.length; i++) {
+    hash ^= normalized.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `bc-${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+
 // src/types/storage.ts
 var KNOWN_OUTPUT_TYPES = [
   "segment",
@@ -839,21 +978,399 @@ var toNotebookTag = (notebookId) => `${NOTEBOOK_TAG_PREFIX}${notebookId}`;
 var fromNotebookTag = (tag) => tag.startsWith(NOTEBOOK_TAG_PREFIX) ? tag.slice(NOTEBOOK_TAG_PREFIX.length) : null;
 var isNotebookTag = (tag) => tag.startsWith(NOTEBOOK_TAG_PREFIX);
 
+// src/sections/blockDetection.ts
+function matchDialectFence(trimmedLine) {
+  if (!trimmedLine.startsWith("```")) return null;
+  const tag = trimmedLine.slice(3).split(/[\s\t]/)[0].toLowerCase();
+  const [base, sport] = tag.split(":", 2);
+  if (VALID_FENCE_DIALECTS.includes(base)) {
+    return { dialect: base, sport: sport || void 0 };
+  }
+  return null;
+}
+function detectScriptBlocks(content) {
+  const lines = content.split("\n");
+  const blocks = [];
+  let inBlock = false;
+  let currentBlock = {};
+  let blockContent = [];
+  lines.forEach((line, index) => {
+    const trimmedLine = line.trim();
+    if (!inBlock) {
+      const fence = matchDialectFence(trimmedLine);
+      if (fence) {
+        inBlock = true;
+        const now = Date.now();
+        currentBlock = {
+          id: `${fence.dialect}-block-${now}-${Math.random().toString(36).slice(2, 9)}`,
+          dialect: fence.dialect,
+          sport: fence.sport,
+          startLine: index,
+          state: "idle",
+          version: 1,
+          createdAt: now
+        };
+        blockContent = [];
+        return;
+      }
+    }
+    if (inBlock && trimmedLine.startsWith("```")) {
+      inBlock = false;
+      currentBlock.endLine = index;
+      currentBlock.content = blockContent.join("\n");
+      blocks.push(currentBlock);
+      currentBlock = {};
+      blockContent = [];
+    } else if (inBlock) {
+      blockContent.push(line);
+    }
+  });
+  if (inBlock && currentBlock.startLine !== void 0) {
+    currentBlock.endLine = lines.length - 1;
+    currentBlock.content = blockContent.join("\n");
+    blocks.push(currentBlock);
+  }
+  return blocks;
+}
+function findBlockAtLine(blocks, lineNumber) {
+  return blocks.find(
+    (block) => lineNumber >= block.startLine && lineNumber <= block.endLine
+  ) ?? null;
+}
+function extractBlockContent(content, startLine, endLine) {
+  const lines = content.split("\n");
+  return lines.slice(startLine + 1, endLine).join("\n");
+}
+
+// src/sections/sectionParser.ts
+var METADATA_REGEX = /<!--\s*section-metadata\s+id:(\S+)\s+version:(\d+)\s+created:(\d+)\s*-->/i;
+function extractMetadata(text) {
+  const match = text.match(METADATA_REGEX);
+  if (!match) return { metadata: null, cleanText: text };
+  return {
+    metadata: {
+      id: match[1],
+      version: parseInt(match[2], 10),
+      createdAt: parseInt(match[3], 10)
+    },
+    cleanText: text.replace(METADATA_REGEX, "").trim()
+  };
+}
+function generateSectionId(type, startLine, content) {
+  let hash = 0;
+  for (let i = 0; i < content.length && i < 64; i++) {
+    hash = (hash << 5) - hash + content.charCodeAt(i) | 0;
+  }
+  const hashHex = (hash >>> 0).toString(16).padStart(8, "0");
+  return `${type}-${startLine}-${hashHex}`;
+}
+function detectUrlSubtype(url) {
+  if (!url) return null;
+  const withoutScheme = url.trim().replace(/^[a-z][a-z0-9+.-]*:\/\//i, "");
+  const host = withoutScheme.split(/[/?#:]/, 1)[0].toLowerCase();
+  if (host === "youtube.com" || host.endsWith(".youtube.com") || host === "youtu.be") return "youtube";
+  if (host === "strava.com" || host.endsWith(".strava.com")) return "strava";
+  if (host === "amazon.com" || host.endsWith(".amazon.com") || host === "amzn.to") return "amazon";
+  return null;
+}
+function resolveFrontMatterSubtype(props) {
+  const typeValue = (props["type"] || "").toLowerCase();
+  if (typeValue === "youtube") return "youtube";
+  if (typeValue === "strava") return "strava";
+  if (typeValue === "amazon") return "amazon";
+  if (typeValue === "file") return "file";
+  if (typeValue === "effort") return "effort";
+  const url = props["url"] || props["link"] || "";
+  if (url) {
+    const detected = detectUrlSubtype(url);
+    if (detected) return detected;
+  }
+  if (props["baseAttributes"] !== void 0 || props["discipline"] !== void 0 || props["effortType"] !== void 0 || props["targetRPE"] !== void 0 || props["equipment"] !== void 0 || props["aliases"] !== void 0 || props["derivation"] !== void 0) {
+    return "effort";
+  }
+  return "default";
+}
+function parseFrontMatterProperties(innerLines) {
+  const props = {};
+  for (const line of innerLines) {
+    const match = line.match(/^([^:]+):\s*(.*)$/);
+    if (match) {
+      props[match[1].trim()] = match[2].trim();
+    }
+  }
+  return props;
+}
+function matchMarkdownEmbed(trimmed) {
+  const match = trimmed.match(/^(!)?\[([^\]]*)\]\(([^)]+)\)$/);
+  if (!match) return null;
+  const isImage = !!match[1];
+  const label = match[2];
+  const url = match[3];
+  let type = isImage ? "image" : "link";
+  if (/youtube\.com|youtu\.be/i.test(url)) {
+    type = "youtube";
+  }
+  return { type, label, url, isImage };
+}
+function detectFrontMatterBlocks(lines, scriptBlocks) {
+  const ranges = [];
+  let i = 0;
+  while (i < lines.length) {
+    const inScript = scriptBlocks.some((b) => i >= b.startLine && i <= b.endLine);
+    if (inScript) {
+      i++;
+      continue;
+    }
+    if (lines[i].trim() === "---") {
+      const openLine = i;
+      let j = i + 1;
+      while (j < lines.length) {
+        const inScriptInner = scriptBlocks.some((b) => j >= b.startLine && j <= b.endLine);
+        if (inScriptInner) {
+          j++;
+          continue;
+        }
+        if (lines[j].trim() === "---") {
+          ranges.push({ startLine: openLine, endLine: j });
+          i = j + 1;
+          break;
+        }
+        j++;
+      }
+      if (j >= lines.length) {
+        i++;
+      }
+    } else {
+      i++;
+    }
+  }
+  return ranges;
+}
+function parseDocumentSections(content, scriptBlocks) {
+  if (!content) return [];
+  const blocks = scriptBlocks ?? detectScriptBlocks(content);
+  const lines = content.split("\n");
+  const sections = [];
+  const fmRanges = detectFrontMatterBlocks(lines, blocks);
+  const now = Date.now();
+  let currentLine = 0;
+  let isFirstTextBlock = true;
+  function flushMarkdownLines(mdLines, startLine) {
+    if (mdLines.length === 0) return;
+    let currentGroup = [];
+    let groupStartLine = startLine;
+    const flushGroup = () => {
+      if (currentGroup.length > 0) {
+        const raw = currentGroup.join("\n");
+        const { metadata, cleanText } = extractMetadata(raw);
+        const trimmed = cleanText.trim();
+        const embed = currentGroup.length === 1 ? matchMarkdownEmbed(trimmed) : null;
+        if (embed) {
+          sections.push({
+            id: metadata?.id || generateSectionId("embed", groupStartLine, trimmed),
+            type: "embed",
+            rawContent: cleanText,
+            displayContent: cleanText,
+            startLine: groupStartLine,
+            endLine: groupStartLine,
+            lineCount: 1,
+            embed,
+            version: metadata?.version || 1,
+            createdAt: metadata?.createdAt || now
+          });
+        } else if (isFirstTextBlock) {
+          isFirstTextBlock = false;
+          sections.push({
+            id: metadata?.id || generateSectionId("title", groupStartLine, cleanText),
+            type: "title",
+            rawContent: cleanText,
+            displayContent: cleanText,
+            startLine: groupStartLine,
+            endLine: groupStartLine + currentGroup.length - 1,
+            lineCount: currentGroup.length,
+            version: metadata?.version || 1,
+            createdAt: metadata?.createdAt || now
+          });
+        } else {
+          sections.push({
+            id: metadata?.id || generateSectionId("markdown", groupStartLine, cleanText),
+            type: "markdown",
+            rawContent: cleanText,
+            displayContent: cleanText,
+            startLine: groupStartLine,
+            endLine: groupStartLine + currentGroup.length - 1,
+            lineCount: currentGroup.length,
+            version: metadata?.version || 1,
+            createdAt: metadata?.createdAt || now
+          });
+        }
+      }
+      currentGroup = [];
+    };
+    for (let i = 0; i < mdLines.length; i++) {
+      const line = mdLines[i];
+      if (line.trim().length === 0) {
+        flushGroup();
+        sections.push({
+          id: generateSectionId("markdown", startLine + i, ""),
+          type: "markdown",
+          rawContent: "",
+          displayContent: "",
+          startLine: startLine + i,
+          endLine: startLine + i,
+          lineCount: 1,
+          version: 1,
+          createdAt: now
+        });
+        groupStartLine = startLine + i + 1;
+      } else {
+        currentGroup.push(line);
+      }
+    }
+    flushGroup();
+  }
+  let mdBuffer = [];
+  let mdBufferStart = 0;
+  while (currentLine < lines.length) {
+    const scriptBlock = blocks.find((b) => b.startLine === currentLine);
+    if (scriptBlock) {
+      flushMarkdownLines(mdBuffer, mdBufferStart);
+      mdBuffer = [];
+      const dialect = scriptBlock.dialect ?? "time";
+      const { metadata, cleanText } = extractMetadata(scriptBlock.content);
+      const fenceTag = scriptBlock.sport ? `${dialect}:${scriptBlock.sport}` : dialect;
+      const cleanRawContent = `\`\`\`${fenceTag}
+${cleanText}
+\`\`\``;
+      const cleanLineCount = cleanRawContent.split("\n").length;
+      const sectionId = metadata?.id || generateSectionId(dialect, scriptBlock.startLine, cleanText);
+      const contentId = blockContentId(cleanText);
+      sections.push({
+        id: sectionId,
+        contentId,
+        type: dialect,
+        sport: scriptBlock.sport,
+        rawContent: cleanRawContent,
+        displayContent: cleanText,
+        startLine: scriptBlock.startLine,
+        endLine: scriptBlock.startLine + cleanLineCount - 1,
+        lineCount: cleanLineCount,
+        scriptBlock: {
+          ...scriptBlock,
+          id: sectionId,
+          contentId,
+          content: cleanText,
+          dialect,
+          version: metadata?.version || 1,
+          createdAt: metadata?.createdAt || now
+        },
+        version: metadata?.version || 1,
+        createdAt: metadata?.createdAt || now
+      });
+      currentLine = scriptBlock.endLine + 1;
+      mdBufferStart = currentLine;
+      continue;
+    }
+    const fmRange = fmRanges.find((r) => r.startLine === currentLine);
+    if (fmRange) {
+      flushMarkdownLines(mdBuffer, mdBufferStart);
+      mdBuffer = [];
+      const rawLines = lines.slice(fmRange.startLine, fmRange.endLine + 1);
+      const raw = rawLines.join("\n");
+      const innerLines = lines.slice(fmRange.startLine + 1, fmRange.endLine);
+      const { metadata, cleanText } = extractMetadata(innerLines.join("\n"));
+      const properties = parseFrontMatterProperties(cleanText.split("\n"));
+      const subtype = resolveFrontMatterSubtype(properties);
+      const lineCount = fmRange.endLine - fmRange.startLine + 1;
+      sections.push({
+        id: metadata?.id || generateSectionId("frontmatter", fmRange.startLine, raw),
+        type: "frontmatter",
+        rawContent: raw,
+        displayContent: cleanText,
+        startLine: fmRange.startLine,
+        endLine: fmRange.endLine,
+        lineCount,
+        properties,
+        frontmatterType: subtype,
+        version: metadata?.version || 1,
+        createdAt: metadata?.createdAt || now
+      });
+      currentLine = fmRange.endLine + 1;
+      mdBufferStart = currentLine;
+      continue;
+    }
+    if (mdBuffer.length === 0) {
+      mdBufferStart = currentLine;
+    }
+    mdBuffer.push(lines[currentLine]);
+    currentLine++;
+  }
+  flushMarkdownLines(mdBuffer, mdBufferStart);
+  return sections;
+}
+function buildRawContent(sections) {
+  return sections.filter((s) => !s.deleted).map((s) => s.rawContent).join("\n");
+}
+function calculateTotalLines(sections) {
+  const visible = sections.filter((s) => !s.deleted);
+  if (visible.length === 0) return 0;
+  const last = visible[visible.length - 1];
+  return last.endLine + 1;
+}
+function matchSectionIds(oldSections, newSections) {
+  return newSections.map((newSec) => {
+    const { metadata } = extractMetadata(newSec.rawContent);
+    if (metadata) {
+      const updated = { ...newSec, id: metadata.id, version: metadata.version, createdAt: metadata.createdAt };
+      if (updated.scriptBlock) {
+        updated.scriptBlock = { ...updated.scriptBlock, id: metadata.id };
+      }
+      return updated;
+    }
+    const exactMatch = oldSections.find(
+      (old) => old.type === newSec.type && old.startLine === newSec.startLine && old.displayContent === newSec.displayContent
+    );
+    if (exactMatch) {
+      const updated = { ...newSec, id: exactMatch.id, version: exactMatch.version, createdAt: exactMatch.createdAt };
+      if (updated.scriptBlock) {
+        updated.scriptBlock = { ...updated.scriptBlock, id: exactMatch.id };
+      }
+      return updated;
+    }
+    const positionMatch = oldSections.find(
+      (old) => old.type === newSec.type && old.startLine === newSec.startLine
+    );
+    if (positionMatch) {
+      const newVersion = (positionMatch.version || 1) + 1;
+      const updated = {
+        ...newSec,
+        id: positionMatch.id,
+        version: newVersion,
+        createdAt: positionMatch.createdAt
+      };
+      if (updated.scriptBlock) {
+        updated.scriptBlock = { ...updated.scriptBlock, id: positionMatch.id, version: newVersion };
+      }
+      return updated;
+    }
+    return newSec;
+  });
+}
+
 // src/version.ts
-var VERSION = "0.10.42";
-var GIT_SHA = "79c6d18";
-var BUILD_TIME = "2026-08-26T04:44:54.356Z";
+var VERSION = "0.35.2115";
+var GIT_SHA = "37944a8";
+var BUILD_TIME = "2026-10-11T23:54:36.367Z";
 var SEMVER = {
-  version: "0.10.42",
-  gitSha: "79c6d18",
-  buildTime: "2026-08-26T04:44:54.356Z"
+  version: "0.35.2115",
+  gitSha: "37944a8",
+  buildTime: "2026-10-11T23:54:36.367Z"
 };
 
 exports.BUILD_TIME = BUILD_TIME;
 exports.BlockKey = BlockKey;
 exports.CodeMetadata = CodeMetadata;
 exports.CodeStatement = CodeStatement;
-exports.Duration = Duration;
 exports.GIT_SHA = GIT_SHA;
 exports.KNOWN_OUTPUT_TYPES = KNOWN_OUTPUT_TYPES;
 exports.LEGACY_ORIGIN_TO_OWNERSHIP_LAYER = LEGACY_ORIGIN_TO_OWNERSHIP_LAYER;
@@ -866,16 +1383,39 @@ exports.OutputStatement = OutputStatement;
 exports.OwnershipResolver = OwnershipResolver;
 exports.ParsedCodeStatement = ParsedCodeStatement;
 exports.SEMVER = SEMVER;
-exports.SpanDuration = SpanDuration;
+exports.SYSTEM_DEFAULT_OUTPUT_UNIT = SYSTEM_DEFAULT_OUTPUT_UNIT;
+exports.UNIT_CATALOG = UNIT_CATALOG;
+exports.UnitConversionError = UnitConversionError;
 exports.VALID_FENCE_DIALECTS = VALID_FENCE_DIALECTS;
 exports.VERSION = VERSION;
+exports.blockContentId = blockContentId;
+exports.buildRawContent = buildRawContent;
+exports.calculateTotalLines = calculateTotalLines;
+exports.convertViaCatalog = convertViaCatalog;
 exports.createMetricOwnershipLedger = createMetricOwnershipLedger;
+exports.detectScriptBlocks = detectScriptBlocks;
+exports.dimensionKeyOf = dimensionKeyOf;
+exports.extractBlockContent = extractBlockContent;
+exports.fieldRefFromKey = fieldRefFromKey;
+exports.fieldRefKey = fieldRefKey;
+exports.findBlockAtLine = findBlockAtLine;
+exports.flattenFieldLeaves = flattenFieldLeaves;
 exports.fromNotebookTag = fromNotebookTag;
+exports.generateSectionId = generateSectionId;
 exports.getMetricOwnershipLayer = getMetricOwnershipLayer;
 exports.isNotebookTag = isNotebookTag;
 exports.isWorkoutSectionType = isWorkoutSectionType;
+exports.lookupUnit = lookupUnit;
+exports.matchDialectFence = matchDialectFence;
+exports.matchSectionIds = matchSectionIds;
+exports.normalizeFieldComponent = normalizeFieldComponent;
+exports.normalizeFieldPath = normalizeFieldPath;
 exports.ownershipRank = ownershipRank;
+exports.parseDocumentSections = parseDocumentSections;
+exports.resolveLayer = resolveLayer;
 exports.runAffordance = runAffordance;
+exports.systemDefaultUnit = systemDefaultUnit;
 exports.toNotebookTag = toNotebookTag;
+exports.valueKindOf = valueKindOf;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map