@bitcobblers/wod-wiki-core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,830 @@
+// src/ownership/types.ts
+var METRIC_OWNERSHIP_LAYER_CHAIN = [
+  "parser",
+  "dialect",
+  "user-plan",
+  "runtime",
+  "user-entry"
+];
+var LEGACY_ORIGIN_TO_OWNERSHIP_LAYER = {
+  parser: "parser",
+  compiler: "dialect",
+  dialect: "dialect",
+  hinted: "dialect",
+  "user-plan": "user-plan",
+  runtime: "runtime",
+  tracked: "runtime",
+  analyzed: "runtime",
+  "analyzed-estimated": "runtime",
+  execution: "runtime",
+  user: "user-entry",
+  collected: "user-entry"
+};
+function getMetricOwnershipLayer(origin) {
+  return LEGACY_ORIGIN_TO_OWNERSHIP_LAYER[origin ?? "parser"] ?? "parser";
+}
+
+// src/ownership/ledger.ts
+var LAYER_RANK = {
+  parser: 0,
+  dialect: 1,
+  "user-plan": 2,
+  runtime: 3,
+  "user-entry": 4
+};
+function resolveLayer(metric) {
+  const maybeLayer = metric.ownershipLayer;
+  if (maybeLayer != null) {
+    return maybeLayer;
+  }
+  return getMetricOwnershipLayer(metric.origin);
+}
+function normalize(metrics) {
+  return metrics.map((metric, index) => {
+    const layer = resolveLayer(metric);
+    return {
+      metric,
+      type: metric.type,
+      layer,
+      layerRank: LAYER_RANK[layer] ?? 0,
+      index,
+      isSuppressor: metric.action === "suppress"
+    };
+  });
+}
+function applyQuery(contributions, query) {
+  if (!query) {
+    return [...contributions];
+  }
+  return contributions.filter((contribution) => {
+    if (query.types && !query.types.includes(contribution.type)) {
+      return false;
+    }
+    if (query.layers && !query.layers.includes(contribution.layer)) {
+      return false;
+    }
+    return true;
+  });
+}
+function groupByType(contributions) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const contribution of contributions) {
+    const bucket = grouped.get(contribution.type);
+    if (bucket) {
+      bucket.push(contribution);
+      continue;
+    }
+    grouped.set(contribution.type, [contribution]);
+  }
+  return grouped;
+}
+function getWinningLayerRank(contributions) {
+  let winningLayerRank;
+  for (const contribution of contributions) {
+    if (contribution.isSuppressor) {
+      continue;
+    }
+    if (winningLayerRank == null || contribution.layerRank > winningLayerRank) {
+      winningLayerRank = contribution.layerRank;
+    }
+  }
+  return winningLayerRank;
+}
+function toResolvedContribution(contribution, outcome) {
+  return {
+    metric: contribution.metric,
+    type: contribution.type,
+    layer: contribution.layer,
+    outcome
+  };
+}
+function compareByOriginalIndex(a, b) {
+  return a.index - b.index;
+}
+function createMetricOwnershipLedger(metrics) {
+  const contributions = normalize(metrics);
+  return {
+    raw(query) {
+      return applyQuery(contributions, query).map((contribution) => contribution.metric);
+    },
+    visible(query) {
+      const filtered = applyQuery(contributions, query);
+      const grouped = groupByType(filtered);
+      const visible = [];
+      for (const groupedContributions of grouped.values()) {
+        if (groupedContributions.some((contribution) => contribution.isSuppressor)) {
+          continue;
+        }
+        const winningLayerRank = getWinningLayerRank(groupedContributions);
+        if (winningLayerRank == null) {
+          continue;
+        }
+        for (const contribution of groupedContributions) {
+          if (!contribution.isSuppressor && contribution.layerRank === winningLayerRank) {
+            visible.push(contribution);
+          }
+        }
+      }
+      visible.sort(compareByOriginalIndex);
+      return visible.map((contribution) => contribution.metric);
+    },
+    byLayer(query) {
+      const filtered = applyQuery(contributions, query);
+      const grouped = {};
+      for (const layer of METRIC_OWNERSHIP_LAYER_CHAIN) {
+        grouped[layer] = [];
+      }
+      for (const contribution of filtered) {
+        grouped[contribution.layer].push(contribution.metric);
+      }
+      for (const layer of METRIC_OWNERSHIP_LAYER_CHAIN) {
+        if (grouped[layer]?.length === 0) {
+          delete grouped[layer];
+        }
+      }
+      return grouped;
+    },
+    promotionCandidates(query) {
+      const filtered = applyQuery(contributions, query);
+      const grouped = groupByType(filtered);
+      const candidates = [];
+      for (const groupedContributions of grouped.values()) {
+        const suppressors = groupedContributions.filter((contribution) => contribution.isSuppressor);
+        const nonSuppressors = groupedContributions.filter((contribution) => !contribution.isSuppressor);
+        if (nonSuppressors.length === 0) {
+          continue;
+        }
+        if (suppressors.length > 0) {
+          const highestCandidateRank = Math.max(...nonSuppressors.map((contribution) => contribution.layerRank));
+          const suppressingLayerRank = Math.max(...suppressors.map((contribution) => contribution.layerRank));
+          for (const contribution of nonSuppressors) {
+            if (contribution.layerRank === highestCandidateRank) {
+              candidates.push({
+                metric: contribution.metric,
+                type: contribution.type,
+                layer: contribution.layer,
+                reason: "suppressed",
+                blockedByLayer: METRIC_OWNERSHIP_LAYER_CHAIN[suppressingLayerRank]
+              });
+            }
+          }
+          continue;
+        }
+        const winningLayerRank = getWinningLayerRank(nonSuppressors);
+        if (winningLayerRank == null) {
+          continue;
+        }
+        const lowerLayerContributions = nonSuppressors.filter(
+          (contribution) => contribution.layerRank < winningLayerRank
+        );
+        if (lowerLayerContributions.length === 0) {
+          continue;
+        }
+        const promotionLayerRank = Math.max(...lowerLayerContributions.map((contribution) => contribution.layerRank));
+        for (const contribution of lowerLayerContributions) {
+          if (contribution.layerRank === promotionLayerRank) {
+            candidates.push({
+              metric: contribution.metric,
+              type: contribution.type,
+              layer: contribution.layer,
+              reason: "shadowed-by-higher-layer",
+              blockedByLayer: METRIC_OWNERSHIP_LAYER_CHAIN[winningLayerRank]
+            });
+          }
+        }
+      }
+      candidates.sort((a, b) => {
+        const rankDelta = (LAYER_RANK[b.layer] ?? 0) - (LAYER_RANK[a.layer] ?? 0);
+        if (rankDelta !== 0) {
+          return rankDelta;
+        }
+        return 0;
+      });
+      return candidates;
+    },
+    explain(query) {
+      const filtered = applyQuery(contributions, query);
+      const grouped = groupByType(filtered);
+      const explanations = [];
+      for (const [type, groupedContributions] of grouped.entries()) {
+        const suppressed = groupedContributions.some((contribution) => contribution.isSuppressor);
+        const winningLayerRank = suppressed ? void 0 : getWinningLayerRank(groupedContributions);
+        const entries = groupedContributions.map((contribution) => {
+          if (contribution.isSuppressor) {
+            return toResolvedContribution(contribution, "suppressor");
+          }
+          if (suppressed) {
+            return toResolvedContribution(contribution, "hidden-by-suppressor");
+          }
+          if (winningLayerRank != null && contribution.layerRank === winningLayerRank) {
+            return toResolvedContribution(contribution, "visible");
+          }
+          return toResolvedContribution(contribution, "hidden-by-layer");
+        });
+        explanations.push({
+          type,
+          winnerLayer: winningLayerRank == null ? void 0 : METRIC_OWNERSHIP_LAYER_CHAIN[winningLayerRank],
+          suppressed,
+          entries
+        });
+      }
+      return explanations;
+    }
+  };
+}
+
+// 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;
+  if (!wantsHints) {
+    filtered = filtered.filter((m) => m.type !== "hint" /* Hint */);
+  }
+  if (!filter) return filtered;
+  if (filter.origins) {
+    filtered = filtered.filter((m) => filter.origins.includes(m.origin ?? "parser"));
+  }
+  if (filter.types) {
+    filtered = filtered.filter((m) => filter.types.includes(m.type));
+  }
+  if (filter.excludeTypes) {
+    filtered = filtered.filter((m) => !filter.excludeTypes.includes(m.type));
+  }
+  return filtered;
+}
+var OwnershipResolver = class {
+  resolve(metrics, filter) {
+    const filtered = applyFilter(metrics, filter);
+    const ledger = createMetricOwnershipLedger(filtered);
+    return ledger.visible();
+  }
+  resolveOne(metrics, type) {
+    return this.resolve(metrics, { types: [type] })[0];
+  }
+  resolveAll(metrics, type) {
+    const ofType = metrics.filter((m) => m.type === type);
+    if (ofType.length <= 1) return ofType;
+    return [...ofType].sort((a, b) => ownershipRank(b) - ownershipRank(a));
+  }
+};
+
+// src/models/CodeMetadata.ts
+var CodeMetadata = class {
+  constructor(line, startOffset, endOffset, length, columnStart = 0, columnEnd = 0, raw = "") {
+    this.line = line;
+    this.startOffset = startOffset;
+    this.endOffset = endOffset;
+    this.length = length;
+    this.columnStart = columnStart;
+    this.columnEnd = columnEnd;
+    this.raw = raw;
+  }
+  line;
+  startOffset;
+  endOffset;
+  length;
+  columnStart;
+  columnEnd;
+  raw;
+};
+
+// src/models/MetricContainer.ts
+var MetricContainer = class _MetricContainer {
+  _metrics;
+  _indexedLength = 0;
+  _resolver = new OwnershipResolver();
+  id;
+  // ── Construction ───────────────────────────────────────────
+  constructor(metrics, id = "metrics") {
+    this.id = id;
+    if (metrics instanceof _MetricContainer) {
+      this._metrics = metrics.toArray();
+      this.syncIndexProperties();
+      return;
+    }
+    if (Array.isArray(metrics)) {
+      this._metrics = [...metrics];
+    } else if (metrics != null) {
+      this._metrics = [];
+    } else {
+      this._metrics = [];
+    }
+    this.syncIndexProperties();
+  }
+  /**
+   * Create a container from an existing metric array, MetricContainer, or
+   * a deserialized plain object.
+   */
+  static from(metrics, id = "metrics") {
+    if (metrics instanceof _MetricContainer) {
+      return metrics.clone(id);
+    }
+    if (Array.isArray(metrics)) {
+      return new _MetricContainer(metrics, id);
+    }
+    if (metrics != null && typeof metrics === "object" && "_metrics" in metrics) {
+      const raw = metrics._metrics;
+      if (Array.isArray(raw)) {
+        return new _MetricContainer(raw, id);
+      }
+    }
+    return _MetricContainer.empty(id);
+  }
+  /** Create an empty container. */
+  static empty(id = "metrics") {
+    return new _MetricContainer(void 0, id);
+  }
+  /** Create a defensive copy of this container. */
+  clone(id = this.id) {
+    return new _MetricContainer(this._metrics, id);
+  }
+  // ── Read ───────────────────────────────────────────────────
+  /** All metrics in insertion order. Returns a defensive copy. */
+  get all() {
+    return [...this._metrics];
+  }
+  /** Number of metrics in the container. */
+  get length() {
+    return this._metrics.length;
+  }
+  /** Alias for length */
+  get size() {
+    return this._metrics.length;
+  }
+  /** Whether the container has no metrics. */
+  get isEmpty() {
+    return this._metrics.length === 0;
+  }
+  /**
+   * Get all metrics of a given MetricType / name, sorted by ownership layer
+   * (highest precedence first).
+   */
+  getByType(type) {
+    const ofType = this._metrics.filter((m) => m.type === type || m.name === type);
+    if (ofType.length <= 1) return ofType;
+    return [...ofType].sort((a, b) => ownershipRank(b) - ownershipRank(a));
+  }
+  /**
+   * Get the highest-precedence metric of a given type/name, or undefined.
+   */
+  getFirst(type) {
+    const byType = this.getByType(type);
+    return byType.length > 0 ? byType[0] : void 0;
+  }
+  /**
+   * Lookup a metric by type or name.
+   */
+  get(type) {
+    return this.getFirst(type);
+  }
+  /** Whether any metric of the given type/name exists. */
+  has(type) {
+    return this._metrics.some((m) => m.type === type || m.name === type);
+  }
+  hasMetric(type) {
+    return this.has(type);
+  }
+  getDisplayMetrics(filter) {
+    return this.resolve(filter);
+  }
+  getMetric(type) {
+    return this._resolver.resolveOne(this._metrics, type);
+  }
+  getAllMetricsByType(type) {
+    return this.getByType(type);
+  }
+  get rawMetrics() {
+    return this.toArray();
+  }
+  getAll() {
+    return this.toArray();
+  }
+  /**
+   * Get all metrics matching the given origin.
+   */
+  getByOrigin(origin) {
+    return this._metrics.filter((m) => (m.origin ?? "parser") === origin);
+  }
+  /**
+   * Apply the standard precedence resolution algorithm.
+   */
+  resolve(filter) {
+    return this._resolver.resolve(this._metrics, filter);
+  }
+  // ── Write (mutating, returns `this` for chaining) ──────────
+  /** Append one or more metrics. */
+  add(...metrics) {
+    this._metrics.push(...metrics);
+    this.syncIndexProperties();
+    return this;
+  }
+  /**
+   * Remove metrics matching a predicate.
+   * Returns the removed metrics.
+   */
+  remove(predicate) {
+    const removed = [];
+    this._metrics = this._metrics.filter((m) => {
+      if (predicate(m)) {
+        removed.push(m);
+        return false;
+      }
+      return true;
+    });
+    this.syncIndexProperties();
+    return removed;
+  }
+  /**
+   * Remove all metrics of a given type.
+   * Returns the removed metrics.
+   */
+  removeByType(type) {
+    return this.remove((m) => m.type === type || m.name === type);
+  }
+  /** Remove all metrics. */
+  clear() {
+    this._metrics = [];
+    this.syncIndexProperties();
+    return this;
+  }
+  /**
+   * Replace all metrics of a given type with new ones.
+   */
+  replaceByType(type, ...replacements) {
+    const removed = this.removeByType(type);
+    this._metrics.push(...replacements);
+    this.syncIndexProperties();
+    return removed;
+  }
+  // ── Merge ──────────────────────────────────────────────────
+  /**
+   * Merge another container (or raw array) into this one.
+   */
+  merge(other) {
+    const incoming = other instanceof _MetricContainer ? other._metrics : Array.isArray(other) ? other : other.metrics.toArray();
+    const byType = /* @__PURE__ */ new Map();
+    for (const m of incoming) {
+      const group = byType.get(m.type) ?? [];
+      group.push(m);
+      byType.set(m.type, group);
+    }
+    for (const [type, incomingGroup] of byType) {
+      const existing = this._metrics.filter((m) => m.type === type);
+      if (existing.length === 0) {
+        this._metrics.push(...incomingGroup);
+        continue;
+      }
+      const existingRank = Math.max(...existing.map((m) => ownershipRank(m)));
+      const incomingRank = Math.max(...incomingGroup.map((m) => ownershipRank(m)));
+      if (incomingRank > existingRank) {
+        this._metrics = this._metrics.filter((m) => m.type !== type);
+        this._metrics.push(...incomingGroup);
+      } else if (incomingRank === existingRank) {
+        this._metrics.push(...incomingGroup);
+      }
+    }
+    this.syncIndexProperties();
+    return this;
+  }
+  // ── Iteration / Projection ─────────────────────────────────
+  /** Iterate over all metrics. */
+  [Symbol.iterator]() {
+    return this._metrics[Symbol.iterator]();
+  }
+  /** Filter metrics, returning a new array. */
+  filter(predicate) {
+    return this._metrics.filter(predicate);
+  }
+  /** Map metrics to a new array. */
+  map(fn) {
+    return this._metrics.map(fn);
+  }
+  /** Flat-map metrics to a new array. */
+  flatMap(fn) {
+    return this._metrics.flatMap(fn);
+  }
+  /** Find the first metric matching a predicate. */
+  find(predicate) {
+    return this._metrics.find(predicate);
+  }
+  /** Whether any metric matches the predicate. */
+  some(predicate) {
+    return this._metrics.some(predicate);
+  }
+  /** Whether all metrics match the predicate. */
+  every(predicate) {
+    return this._metrics.every(predicate);
+  }
+  // ── Conversion ─────────────────────────────────────────────
+  /** Return a mutable copy of the underlying array. */
+  toArray() {
+    return [...this._metrics];
+  }
+  /** Spread-friendly: returns the underlying array (no copy). */
+  get raw() {
+    return this._metrics;
+  }
+  syncIndexProperties() {
+    for (let i = 0; i < this._indexedLength; i++) {
+      delete this[i];
+    }
+    for (let i = 0; i < this._metrics.length; i++) {
+      this[i] = this._metrics[i];
+    }
+    this._indexedLength = this._metrics.length;
+  }
+  toString() {
+    return `MetricContainer(${this._metrics.length})[${this._metrics.map((m) => m.type).join(", ")}]`;
+  }
+};
+
+// src/models/CodeStatement.ts
+var CodeStatement = class {
+  exerciseId;
+  line;
+  text;
+  raw;
+  dialect;
+  // ── IMetricSource ─────────────────────────────────────────────
+  hasMetric(type) {
+    return this.metricContainer.hasMetric(type);
+  }
+  getDisplayMetrics(filter) {
+    return this.metricContainer.getDisplayMetrics(filter);
+  }
+  getMetric(type) {
+    return this.metricContainer.getMetric(type);
+  }
+  getAllMetricsByType(type) {
+    return this.metricContainer.getAllMetricsByType(type);
+  }
+  get rawMetrics() {
+    return this.metricContainer.rawMetrics;
+  }
+  get metricContainer() {
+    return this.metrics instanceof MetricContainer ? this.metrics : MetricContainer.from(this.metrics, this.id);
+  }
+};
+var ParsedCodeStatement = class extends CodeStatement {
+  id = 0;
+  parent;
+  children = [];
+  meta = new CodeMetadata(0, 0, 0, 0);
+  _metrics = MetricContainer.empty();
+  metricMeta = /* @__PURE__ */ new Map();
+  isLeaf;
+  get metrics() {
+    return this._metrics;
+  }
+  set metrics(metrics) {
+    this._metrics = MetricContainer.from(metrics, this.id);
+  }
+  constructor(init) {
+    super();
+    if (init) {
+      Object.assign(this, init);
+      if (init.metrics) {
+        this.metrics = MetricContainer.from(init.metrics, this.id);
+      }
+      if (!this.metricMeta) {
+        this.metricMeta = /* @__PURE__ */ new Map();
+      }
+    }
+  }
+};
+
+// src/models/OutputStatement.ts
+var OutputStatement = class _OutputStatement {
+  static nextId = 1e6;
+  id;
+  outputType;
+  timeSpan;
+  sourceStatementId;
+  sourceBlockKey;
+  stackLevel;
+  metrics;
+  metricMeta;
+  completionReason;
+  parent;
+  children;
+  isLeaf;
+  meta;
+  statement;
+  timestamp;
+  constructor(optionsOrStatement, metricsArg, timestamp) {
+    if (optionsOrStatement && "outputType" in optionsOrStatement && "timeSpan" in optionsOrStatement) {
+      const options = optionsOrStatement;
+      this.id = _OutputStatement.nextId++;
+      this.outputType = options.outputType;
+      this.timeSpan = options.timeSpan;
+      this.sourceBlockKey = options.sourceBlockKey ?? "";
+      this.sourceStatementId = options.sourceStatementId;
+      this.stackLevel = options.stackLevel ?? 0;
+      this.metrics = MetricContainer.from(options.metrics, this.id);
+      this.metricMeta = options.metricMeta ?? /* @__PURE__ */ new Map();
+      this.completionReason = options.completionReason;
+      this.parent = options.parent;
+      this.children = options.children ?? [];
+      this.isLeaf = this.children.length === 0;
+      this.meta = new CodeMetadata(0, 0, 0, 0);
+    } else {
+      const stmt = optionsOrStatement;
+      this.id = _OutputStatement.nextId++;
+      this.statement = stmt;
+      this.outputType = "segment";
+      this.timeSpan = { started: timestamp ?? Date.now() };
+      this.sourceBlockKey = "";
+      this.sourceStatementId = typeof stmt?.id === "number" ? stmt.id : void 0;
+      this.stackLevel = 0;
+      this.metrics = MetricContainer.from(metricsArg, this.id);
+      this.metricMeta = /* @__PURE__ */ new Map();
+      this.children = [];
+      this.isLeaf = true;
+      this.meta = stmt?.meta ?? new CodeMetadata(0, 0, 0, 0);
+      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;
+  }
+  /**
+   * Reset the ID counter (useful for testing)
+   */
+  static resetIdCounter(startAt = 1e6) {
+    _OutputStatement.nextId = startAt;
+  }
+};
+
+// 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;
+  constructor(value) {
+    this.value = value ?? (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : Math.random().toString(36).slice(2));
+  }
+  toString() {
+    return this.value;
+  }
+  valueOf() {
+    return this.value;
+  }
+  equals(other) {
+    return this.value === other?.value;
+  }
+};
+
+// src/types/section.ts
+var VALID_FENCE_DIALECTS = ["time", "log"];
+function runAffordance(baseTag) {
+  if (baseTag === "time") return "run";
+  if (baseTag === "log") return "log";
+  return null;
+}
+function isWorkoutSectionType(type) {
+  return type === "time" || type === "log";
+}
+
+// src/types/notebook.ts
+var NOTEBOOK_TAG_PREFIX = "notebook:";
+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);
+
+export { BlockKey, CodeMetadata, CodeStatement, Duration, LEGACY_ORIGIN_TO_OWNERSHIP_LAYER, METRIC_OWNERSHIP_LAYER_CHAIN, Metric, MetricContainer, MetricType, NOTEBOOK_TAG_PREFIX, OutputStatement, OwnershipResolver, ParsedCodeStatement, SpanDuration, VALID_FENCE_DIALECTS, createMetricOwnershipLedger, fromNotebookTag, getMetricOwnershipLayer, isNotebookTag, isWorkoutSectionType, ownershipRank, runAffordance, toNotebookTag };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map