@bitcobblers/wod-wiki-lang 0.42.2148 → 0.43.2149

package/dist/index.cjs

@@ -4960,6 +4960,284 @@ var ExecutionContext = class {
     }
   }
 };
+
+// src/runtime/RuntimeLogFormat.ts
+var RUNTIME_LOG_SUBJECT_WIDTH = 24;
+var pad2 = (n) => String(n).padStart(2, "0");
+var pad3 = (n) => String(n).padStart(3, "0");
+function formatRuntimeTimestamp(d) {
+  return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}.${pad3(d.getMilliseconds())}`;
+}
+function padRuntimeLogEvent(event) {
+  return (event + "     ").slice(0, 5);
+}
+function padRuntimeLogSubject(subject) {
+  return (subject + " ".repeat(RUNTIME_LOG_SUBJECT_WIDTH)).slice(0, RUNTIME_LOG_SUBJECT_WIDTH);
+}
+function formatRuntimeLogLine(timestamp, event, subject, payload) {
+  return `${formatRuntimeTimestamp(timestamp)}  ${padRuntimeLogEvent(event)}  ${padRuntimeLogSubject(subject)}${payload ? "  " + payload : ""}`;
+}
+function formatRuntimeLogRule(label) {
+  const width = 52;
+  if (!label) return "\u2500".repeat(width);
+  const inner = ` ${label} `;
+  const left = Math.max(0, Math.floor((width - inner.length) / 2));
+  const right = Math.max(0, width - inner.length - left);
+  return `${"\u2500".repeat(left)}${inner}${"\u2500".repeat(right)}`;
+}
+
+// src/runtime/RuntimeLogger.ts
+var RuntimeLoggerImpl = class {
+  // Console is this logger's designated output sink; all writes funnel
+  // through this single reference so the no-console rule is waived once.
+  // eslint-disable-next-line no-console
+  _console = console;
+  _enabled = false;
+  _history = [];
+  _maxHistory = 500;
+  EVENT_STYLES = {
+    BOOT: "color: #3b82f6; font-weight: bold",
+    // primary
+    PUSH: "color: #a855f7; font-weight: bold",
+    // rounds violet
+    POP: "color: #64748b",
+    // muted
+    NEXT: "color: #b45309; font-weight: bold",
+    // action ochre
+    EVNT: "color: #a855f7; font-weight: bold",
+    // violet
+    OUT: "color: #16a34a; font-weight: bold",
+    // effort green
+    MEM: "color: #f59e0b",
+    // amber
+    TIME: "color: #3b82f6; font-weight: bold",
+    // time slate
+    HALT: "color: #ef4444; font-weight: bold",
+    // destructive
+    WARN: "color: #f59e0b; font-weight: bold",
+    ERR: "color: #ef4444; font-weight: bold"
+  };
+  constructor() {
+    if (typeof window !== "undefined") {
+      const debugWindow = window;
+      this._enabled = !!debugWindow.__WOD_DEBUG__;
+    }
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  enable() {
+    this._enabled = true;
+    this.writeLine("BOOT", "runtime:ready", "logging enabled");
+  }
+  disable() {
+    this.writeLine("HALT", "runtime:logger", "logging disabled");
+    this._enabled = false;
+  }
+  getHistory() {
+    return [...this._history];
+  }
+  clearHistory() {
+    this._history = [];
+  }
+  // ============================================================================
+  // Logging Methods
+  // ============================================================================
+  /**
+   * Log runtime construction. Called once by ScriptRuntime's constructor;
+   * dropped when logging is disabled, so cheap to leave wired.
+   */
+  logBoot(detail) {
+    if (!this._enabled) return;
+    this.writeLine("BOOT", "runtime:ready", detail);
+  }
+  /**
+   * Log when a block is pushed onto the stack. `depth` is the 1-based
+   * stack depth the block landed at (prototype's `dN` column).
+   */
+  logPush(block, parentKey, depth) {
+    if (!this._enabled) return;
+    const behaviors = this.getBehaviorNames(block);
+    const payload = [
+      `d${depth ?? "?"}  ${block.blockType ?? "block"}`,
+      behaviors.length > 0 ? `behaviors [${behaviors.join(", ")}]` : void 0,
+      parentKey ? `parent ${parentKey.slice(0, 8)}` : void 0
+    ].filter(Boolean).join(" \xB7 ");
+    this.writeLine("PUSH", block.label || block.blockType || "Block", payload);
+    this.addToHistory("info", "push", `PUSH ${block.label}`, {
+      key: block.key.toString(),
+      parentKey,
+      behaviors,
+      sourceIds: block.sourceIds
+    });
+  }
+  /**
+   * Log when a block is popped from the stack. `depth` is the 1-based
+   * depth the block occupied (prototype's `dN` column).
+   */
+  logPop(block, reason, depth) {
+    if (!this._enabled) return;
+    this.writeLine("POP", block.label || block.blockType || "Block", `d${depth ?? "?"}${reason ? "  " + reason : ""}`);
+    this.addToHistory("info", "pop", `POP ${block.label}`, {
+      key: block.key.toString(),
+      reason
+    });
+  }
+  /**
+   * Log when next() is called on a block
+   */
+  logNext(block, actions) {
+    if (!this._enabled) return;
+    if (actions.length === 0) return;
+    const actionNames = actions.map((a) => a.type || a.constructor?.name || "Action");
+    this.writeLine("NEXT", block.label || "Block", `${actionNames.length} action(s): [${actionNames.join(", ")}]`);
+    this.addToHistory("info", "next", `NEXT ${block.label}`, {
+      key: block.key.toString(),
+      actions: actionNames
+    });
+  }
+  /**
+   * Log when an event produces actions
+   */
+  logEvent(event, actions) {
+    if (!this._enabled) return;
+    if (actions.length === 0) return;
+    const actionNames = actions.map((a) => a.type || a.constructor?.name || "Action");
+    this.writeLine("EVNT", event.name, `${actionNames.length} action(s): [${actionNames.join(", ")}]`);
+    this.addToHistory("info", "event", `EVENT ${event.name}`, {
+      eventName: event.name,
+      eventData: event.data,
+      actions: actionNames
+    });
+  }
+  /**
+   * Log an output statement (segment / milestone). Called by OutputEmitter
+   * on every published output. 'system' outputs (sound cues etc.) and
+   * label-less structural outputs (the boot 'load' statement) are skipped —
+   * volume stays proportional to what the athlete did.
+   */
+  logOutput(output) {
+    if (!this._enabled) return;
+    if (output.outputType !== "segment" && output.outputType !== "milestone") return;
+    const subject = output.text || this.outputSubject(output.metrics);
+    if (!subject) return;
+    this.writeLine("OUT", subject, output.outputType);
+    this.addToHistory("info", "output", `OUT ${subject}`, {
+      outputType: output.outputType,
+      label: subject
+    });
+  }
+  /** No `label` field exists on outputs — fall back to the explicit Label
+   *  metric (image, then value), matching the UI's naming convention. */
+  outputSubject(metrics) {
+    if (!metrics) return void 0;
+    for (const m of metrics) {
+      if (m.type === "label") return m.image || (m.value != null ? String(m.value) : "") || void 0;
+    }
+    return void 0;
+  }
+  /**
+   * Log when memory is updated on a block
+   */
+  logMemoryUpdate(blockKey, memoryType, value) {
+    if (!this._enabled) return;
+    const displayValue = typeof value === "object" && value !== null ? this.summarizeObject(value) : value;
+    this.writeLine("MEM", memoryType, `[${blockKey.slice(0, 8)}] ${safeJson(displayValue)}`);
+    this.addToHistory("debug", "memory", `MEMORY ${memoryType}`, {
+      blockKey,
+      memoryType,
+      value: displayValue
+    });
+  }
+  /**
+   * Log action execution
+   */
+  logAction(action, depth) {
+    if (!this._enabled) return;
+    const actionName = action.type || action.constructor?.name || "Action";
+    this.writeLine("EVNT", actionName, `d${depth}`);
+  }
+  /**
+   * General-purpose message log for runtime consumers.
+   * Gates on _enabled; writes to the console sink and history.
+   */
+  logMessage(level, category, message, data) {
+    if (!this._enabled) return;
+    this.writeLine(level === "error" ? "ERR" : level === "warn" ? "WARN" : "EVNT", category, message);
+    this.addToHistory(level, category, message, data);
+  }
+  /**
+   * Always-on variant of `logMessage`. Use sparingly for errors/warnings that
+   * must be visible even when debug logging is disabled.
+   */
+  logAlways(level, category, message, data) {
+    this.writeLine(level === "error" ? "ERR" : level === "warn" ? "WARN" : "EVNT", category, message);
+    this.addToHistory(level, category, message, data);
+  }
+  /** A round-boundary rule in the paper format (prototype tier 04). */
+  logRule(label) {
+    if (!this._enabled) return;
+    this._console.log(`%c${formatRuntimeLogRule(label)}`, "color: #94a3b8");
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  /**
+   * The one console write path: a single paper line with the event code
+   * tinted. `addToHistory` stays separate — entries carry structured data,
+   * lines carry display text.
+   */
+  writeLine(code, subject, payload) {
+    const ts = formatRuntimeTimestamp(/* @__PURE__ */ new Date());
+    this._console.log(
+      `${ts}  %c${padRuntimeLogEvent(code)}%c  ${padRuntimeLogSubject(subject)}${payload ? "  " + payload : ""}`,
+      this.EVENT_STYLES[code],
+      "color: inherit"
+    );
+  }
+  getBehaviorNames(block) {
+    const blockWithBehaviors = block;
+    const behaviors = blockWithBehaviors.behaviors;
+    if (!behaviors || !Array.isArray(behaviors)) return [];
+    return behaviors.map((b) => b.constructor?.name || "Behavior");
+  }
+  summarizeObject(obj) {
+    const summary = {};
+    for (const [key, val] of Object.entries(obj)) {
+      if (Array.isArray(val)) {
+        summary[key] = `[${val.length} items]`;
+      } else if (typeof val === "object" && val !== null) {
+        summary[key] = "{...}";
+      } else {
+        summary[key] = val;
+      }
+    }
+    return summary;
+  }
+  addToHistory(level, category, message, data) {
+    this._history.push({
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      category,
+      message,
+      data
+    });
+    if (this._history.length > this._maxHistory) {
+      this._history = this._history.slice(-this._maxHistory);
+    }
+  }
+};
+function safeJson(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+var RuntimeLogger = new RuntimeLoggerImpl();
+if (typeof window !== "undefined") {
+  window.RuntimeLogger = RuntimeLogger;
+}
 var OutputEmitter = class {
   _outputStatements = [];
   _outputListeners = /* @__PURE__ */ new Set();
@@ -5013,6 +5291,7 @@ var OutputEmitter = class {
     }
     const processed = this._analyticsEngine ? this._analyticsEngine.run(output) : output;
     this._propagateSourceLine(processed);
+    RuntimeLogger.logOutput(processed);
     this._outputStatements.push(processed);
     for (const listener of this._outputListeners) {
       try {
@@ -5358,249 +5637,6 @@ var RuntimeObservers = class {
   }
 };
 
-// src/runtime/RuntimeLogger.ts
-var RuntimeLoggerImpl = class {
-  // Console is this logger's designated output sink; all writes funnel
-  // through this single reference so the no-console rule is waived once.
-  // eslint-disable-next-line no-console
-  _console = console;
-  _enabled = false;
-  _history = [];
-  _maxHistory = 500;
-  // Style constants for console output
-  STYLES = {
-    push: "color: #22c55e; font-weight: bold",
-    // green
-    pop: "color: #ef4444; font-weight: bold",
-    // red
-    next: "color: #3b82f6; font-weight: bold",
-    // blue
-    event: "color: #a855f7; font-weight: bold",
-    // purple
-    memory: "color: #f59e0b; font-weight: bold",
-    // amber
-    action: "color: #6366f1; font-weight: normal",
-    // indigo
-    origin: "color: #64748b; font-weight: normal"
-    // slate
-  };
-  constructor() {
-    if (typeof window !== "undefined") {
-      const debugWindow = window;
-      this._enabled = !!debugWindow.__WOD_DEBUG__;
-    }
-  }
-  get enabled() {
-    return this._enabled;
-  }
-  enable() {
-    this._enabled = true;
-    this._console.log("%c[RT] \u{1F527} Runtime logging ENABLED", "color: #22c55e; font-weight: bold");
-  }
-  disable() {
-    this._enabled = false;
-    this._console.log("%c[RT] Runtime logging disabled", "color: #64748b");
-  }
-  getHistory() {
-    return [...this._history];
-  }
-  clearHistory() {
-    this._history = [];
-  }
-  // ============================================================================
-  // Logging Methods
-  // ============================================================================
-  /**
-   * Log when a block is pushed onto the stack
-   */
-  logPush(block, parentKey) {
-    if (!this._enabled) return;
-    const behaviors = this.getBehaviorNames(block);
-    const memoryTypes = block.getAllMemory?.().map((loc) => loc.tag) ?? [];
-    this._console.groupCollapsed(
-      `%c[RT] \u25B6 PUSH %c${block.label || block.blockType || "Block"}%c [${block.key.toString().slice(0, 8)}]`,
-      this.STYLES.push,
-      "color: inherit; font-weight: bold",
-      "color: #64748b; font-weight: normal"
-    );
-    this._console.log("Key:", block.key.toString());
-    if (parentKey) this._console.log("Parent:", parentKey);
-    this._console.log("Source IDs:", block.sourceIds);
-    this._console.log("Behaviors:", behaviors);
-    if (memoryTypes.length > 0) this._console.log("Memory Types:", memoryTypes);
-    this._console.groupEnd();
-    this.addToHistory("info", "push", `PUSH ${block.label}`, {
-      key: block.key.toString(),
-      parentKey,
-      behaviors,
-      sourceIds: block.sourceIds
-    });
-  }
-  /**
-   * Log when a block is popped from the stack
-   */
-  logPop(block, reason) {
-    if (!this._enabled) return;
-    this._console.log(
-      `%c[RT] \u25C0 POP  %c${block.label || block.blockType || "Block"}%c [${block.key.toString().slice(0, 8)}]${reason ? ` (${reason})` : ""}`,
-      this.STYLES.pop,
-      "color: inherit; font-weight: bold",
-      "color: #64748b; font-weight: normal"
-    );
-    this.addToHistory("info", "pop", `POP ${block.label}`, {
-      key: block.key.toString(),
-      reason
-    });
-  }
-  /**
-   * Log when next() is called on a block
-   */
-  logNext(block, actions) {
-    if (!this._enabled) return;
-    const actionNames = actions.map((a) => a.type || a.constructor?.name || "Action");
-    if (actions.length === 0) {
-      return;
-    }
-    this._console.groupCollapsed(
-      `%c[RT] \u2192 NEXT %c${block.label || "Block"}%c \u2192 ${actions.length} action(s)`,
-      this.STYLES.next,
-      "color: inherit; font-weight: bold",
-      "color: #64748b; font-weight: normal"
-    );
-    this._console.log("Block:", block.key.toString());
-    this._console.log("Actions:", actionNames);
-    this._console.groupEnd();
-    this.addToHistory("info", "next", `NEXT ${block.label}`, {
-      key: block.key.toString(),
-      actions: actionNames
-    });
-  }
-  /**
-   * Log when an event produces actions
-   */
-  logEvent(event, actions) {
-    if (!this._enabled) return;
-    if (actions.length === 0) return;
-    const actionNames = actions.map((a) => a.type || a.constructor?.name || "Action");
-    this._console.groupCollapsed(
-      `%c[RT] \u26A1 EVENT %c${event.name}%c \u2192 ${actions.length} action(s)`,
-      this.STYLES.event,
-      "color: inherit; font-weight: bold",
-      "color: #64748b; font-weight: normal"
-    );
-    this._console.log("Event Data:", event.data);
-    this._console.log("Actions:", actionNames);
-    this._console.groupEnd();
-    this.addToHistory("info", "event", `EVENT ${event.name}`, {
-      eventName: event.name,
-      eventData: event.data,
-      actions: actionNames
-    });
-  }
-  /**
-   * Log when memory is updated on a block
-   */
-  logMemoryUpdate(blockKey, memoryType, value) {
-    if (!this._enabled) return;
-    let displayValue = value;
-    if (typeof value === "object" && value !== null) {
-      displayValue = this.summarizeObject(value);
-    }
-    this._console.log(
-      `%c[RT] \u{1F4DD} MEMORY %c${memoryType}%c on [${blockKey.slice(0, 8)}]:`,
-      this.STYLES.memory,
-      "color: inherit; font-weight: bold",
-      "color: #64748b; font-weight: normal",
-      displayValue
-    );
-    this.addToHistory("debug", "memory", `MEMORY ${memoryType}`, {
-      blockKey,
-      memoryType,
-      value: displayValue
-    });
-  }
-  /**
-   * Log action execution (verbose, under a group)
-   */
-  logAction(action, depth) {
-    if (!this._enabled) return;
-    const indent = "  ".repeat(depth);
-    const actionName = action.type || action.constructor?.name || "Action";
-    this._console.log(
-      `%c[RT] ${indent}\u2699 %c${actionName}`,
-      this.STYLES.action,
-      "color: inherit"
-    );
-  }
-  /**
-   * General-purpose message log for runtime consumers.
-   * Gates on _enabled; writes to the console sink and history.
-   */
-  logMessage(level, category, message, data) {
-    if (!this._enabled) return;
-    this._console.log(`%c[RT] ${category} %c${message}`, this.styleFor(level), "color: inherit");
-    this.addToHistory(level, category, message, data);
-  }
-  /**
-   * Always-on variant of `logMessage`. Use sparingly for errors/warnings that
-   * must be visible even when debug logging is disabled.
-   */
-  logAlways(level, category, message, data) {
-    this._console.log(`%c[RT] ${category} %c${message}`, this.styleFor(level), "color: inherit");
-    this.addToHistory(level, category, message, data);
-  }
-  // ============================================================================
-  // Helpers
-  // ============================================================================
-  getBehaviorNames(block) {
-    const blockWithBehaviors = block;
-    const behaviors = blockWithBehaviors.behaviors;
-    if (!behaviors || !Array.isArray(behaviors)) return [];
-    return behaviors.map((b) => b.constructor?.name || "Behavior");
-  }
-  summarizeObject(obj) {
-    const summary = {};
-    for (const [key, val] of Object.entries(obj)) {
-      if (Array.isArray(val)) {
-        summary[key] = `[${val.length} items]`;
-      } else if (typeof val === "object" && val !== null) {
-        summary[key] = "{...}";
-      } else {
-        summary[key] = val;
-      }
-    }
-    return summary;
-  }
-  styleFor(level) {
-    switch (level) {
-      case "error":
-        return "color: #ef4444; font-weight: bold";
-      case "warn":
-        return "color: #f59e0b; font-weight: bold";
-      case "info":
-        return "color: #3b82f6; font-weight: bold";
-      default:
-        return "color: #64748b";
-    }
-  }
-  addToHistory(level, category, message, data) {
-    this._history.push({
-      timestamp: /* @__PURE__ */ new Date(),
-      level,
-      category,
-      message,
-      data
-    });
-    if (this._history.length > this._maxHistory) {
-      this._history = this._history.slice(-this._maxHistory);
-    }
-  }
-};
-var RuntimeLogger = new RuntimeLoggerImpl();
-if (typeof window !== "undefined") {
-  window.RuntimeLogger = RuntimeLogger;
-}
-
 // src/runtime/actions/stack/PushBlockAction.ts
 var PushBlockAction = class {
   constructor(block, options = {}) {
@@ -5634,7 +5670,7 @@ var PushBlockAction = class {
       runtime.stack.push(this.block);
       const mountActions = this.block.mount(runtime, lifecycle);
       const parentKey = runtime.stack.blocks.length > 1 ? runtime.stack.blocks[1]?.key.toString() : void 0;
-      RuntimeLogger.logPush(this.block, parentKey);
+      RuntimeLogger.logPush(this.block, parentKey, runtime.stack.blocks.length);
       return mountActions;
     } catch (error) {
       const runtimeWithSetError = runtime;
@@ -5665,7 +5701,7 @@ var PopBlockAction = class {
     }
     if (!current.isComplete && typeof current.markComplete === "function") {
       current.markComplete("forced-pop");
-      RuntimeLogger.logPop(current, "forced-pop (incomplete block popped without next)");
+      RuntimeLogger.logPop(current, "forced-pop (incomplete block popped without next)", runtime.stack.blocks.length);
     }
     const unmountActions = current.unmount(runtime, lifecycleOptions) ?? [];
     const popped = runtime.stack.pop();
@@ -5675,7 +5711,7 @@ var PopBlockAction = class {
     popped.dispose(runtime);
     popped.context?.release?.();
     if (popped.completionReason !== "forced-pop") {
-      RuntimeLogger.logPop(popped, popped.completionReason);
+      RuntimeLogger.logPop(popped, popped.completionReason, runtime.stack.blocks.length + 1);
     }
     const parent = runtime.stack.current;
     return parent ? [...unmountActions, new NextAction(lifecycleOptions, runtime.nowProvider)] : unmountActions;
@@ -5714,6 +5750,7 @@ var ScriptRuntime = class {
     });
     this.clock.start();
     this._output.emitLoad();
+    RuntimeLogger.logBoot(`statements ${this.script.statements.length}`);
   }
   script;
   eventBus;
@@ -8451,6 +8488,10 @@ var ReportOutputBehavior = class {
   writeResultMemory(ctx, resultFragments) {
     const existing = ctx.block.getMemoryByTag("metric:result");
     if (existing.length > 0) {
+      const preserved = collectUserOriginMetrics(existing);
+      if (preserved.length > 0) {
+        resultFragments = resultFragments.clone().add(...preserved);
+      }
       ctx.updateMemory("metric:result", resultFragments.toArray());
       return;
     }
@@ -8458,11 +8499,22 @@ var ReportOutputBehavior = class {
   }
   writeResultGroups(ctx, resultGroups) {
     const existing = ctx.block.getMemoryByTag("metric:result");
-    if (existing.length > 0) {
+    if (existing.length === 0) {
+      for (const group of resultGroups) {
+        ctx.pushMemory("metric:result", group.toArray());
+      }
       return;
     }
-    for (const group of resultGroups) {
-      ctx.pushMemory("metric:result", group.toArray());
+    const count = Math.max(existing.length, resultGroups.length);
+    for (let i = 0; i < count; i++) {
+      const base = resultGroups[i] ? resultGroups[i].clone() : existing[i].metrics.clone();
+      const userMetrics = resultGroups[i] && i < existing.length ? collectUserOriginMetrics([existing[i]]) : [];
+      const merged = base.add(...userMetrics);
+      if (i < existing.length) {
+        existing[i].update(merged);
+      } else {
+        ctx.pushMemory("metric:result", merged.toArray());
+      }
     }
   }
   formatLabel(ctx) {
@@ -8472,6 +8524,15 @@ var ReportOutputBehavior = class {
     return round.total !== void 0 ? `Round ${round.current} of ${round.total}` : `Round ${round.current}`;
   }
 };
+function collectUserOriginMetrics(locations) {
+  const userMetrics = [];
+  for (const loc of locations) {
+    for (const m of loc.metrics) {
+      if (m.origin === "user") userMetrics.push(m);
+    }
+  }
+  return userMetrics;
+}
 var SoundMetric = class {
   constructor(sound, trigger, options = {}) {
     this.sound = sound;
@@ -10801,8 +10862,7 @@ var CalcEngine = class {
       for (const segment of segments) {
         if (segment.outputType !== "segment") continue;
         if (exclusion && matchesExclusion(effortOf(segment).slug, exclusion)) continue;
-        for (const metric of segment.metrics.rawMetrics) {
-          if (metric.type !== metricType) continue;
+        for (const metric of segment.getDisplayMetrics({ types: [metricType] })) {
           const value = numericMetricValue(metric);
           if (value === void 0) continue;
           values.push(value);
@@ -14869,6 +14929,7 @@ exports.PushBlockAction = PushBlockAction;
 exports.PushRestBlockAction = PushRestBlockAction;
 exports.REST_EXCLUSION = REST_EXCLUSION;
 exports.RPE_LABELS = RPE_LABELS;
+exports.RUNTIME_LOG_SUBJECT_WIDTH = RUNTIME_LOG_SUBJECT_WIDTH;
 exports.RegisterEventHandlerAction = RegisterEventHandlerAction;
 exports.Registry = Registry;
 exports.ReportOutputBehavior = ReportOutputBehavior;
@@ -14984,6 +15045,9 @@ exports.fixtureUserCustom = fixtureUserCustom;
 exports.fixtureUserOverride = fixtureUserOverride;
 exports.formatDim = formatDim;
 exports.formatDuration = formatDuration;
+exports.formatRuntimeLogLine = formatRuntimeLogLine;
+exports.formatRuntimeLogRule = formatRuntimeLogRule;
+exports.formatRuntimeTimestamp = formatRuntimeTimestamp;
 exports.fragmentsToLabel = metricsToLabel;
 exports.frozenNow = frozenNow;
 exports.fullFixtureSet = fullFixtureSet;
@@ -15014,6 +15078,8 @@ exports.num = num;
 exports.openSpan = openSpan;
 exports.outputNodeId = outputNodeId;
 exports.outputNodeIds = outputNodeIds;
+exports.padRuntimeLogEvent = padRuntimeLogEvent;
+exports.padRuntimeLogSubject = padRuntimeLogSubject;
 exports.parseCalcLine = parseCalcLine;
 exports.parseCalculateBlock = parseCalculateBlock;
 exports.parseEffortFile = parseEffortFile;