@storyteller-platform/ghost-story 0.0.1

package/dist/utilities/Timing.cjs

@@ -0,0 +1,287 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Timing_exports = {};
+__export(Timing_exports, {
+  Timing: () => Timing,
+  TimingAggregator: () => TimingAggregator,
+  createAggregator: () => createAggregator,
+  createTiming: () => createTiming,
+  formatDuration: () => formatDuration,
+  formatPercentage: () => formatPercentage,
+  formatSingleReport: () => formatSingleReport,
+  printSingleReport: () => printSingleReport
+});
+module.exports = __toCommonJS(Timing_exports);
+class Timing {
+  spans = [];
+  activeSpans = /* @__PURE__ */ new Map();
+  startTime = 0;
+  metadata = {};
+  constructor() {
+    this.startTime = performance.now();
+  }
+  time(name, fn) {
+    const start = performance.now();
+    try {
+      return fn();
+    } finally {
+      const end = performance.now();
+      this.spans.push({
+        name,
+        startTime: start - this.startTime,
+        endTime: end - this.startTime,
+        duration: end - start
+      });
+    }
+  }
+  async timeAsync(name, fn) {
+    const start = performance.now();
+    try {
+      return await fn();
+    } finally {
+      const end = performance.now();
+      this.spans.push({
+        name,
+        startTime: start - this.startTime,
+        endTime: end - this.startTime,
+        duration: end - start
+      });
+    }
+  }
+  start(name) {
+    const start = performance.now();
+    this.activeSpans.set(name, start);
+    return () => {
+      this.end(name);
+    };
+  }
+  end(name) {
+    const start = this.activeSpans.get(name);
+    if (start === void 0) return;
+    const end = performance.now();
+    this.activeSpans.delete(name);
+    this.spans.push({
+      name,
+      startTime: start - this.startTime,
+      endTime: end - this.startTime,
+      duration: end - start
+    });
+  }
+  setMetadata(key, value) {
+    this.metadata[key] = value;
+    return this;
+  }
+  addMetadata(data) {
+    Object.assign(this.metadata, data);
+    return this;
+  }
+  getElapsedMs() {
+    return performance.now() - this.startTime;
+  }
+  summary() {
+    const wallClockMs = performance.now() - this.startTime;
+    const totalMs = this.spans.reduce((sum, s) => sum + s.duration, 0);
+    const phaseMap = /* @__PURE__ */ new Map();
+    for (const span of this.spans) {
+      phaseMap.set(span.name, (phaseMap.get(span.name) ?? 0) + span.duration);
+    }
+    const phases = [...phaseMap.entries()].map(
+      ([name, duration]) => ({
+        name,
+        duration,
+        percentage: totalMs > 0 ? duration / totalMs * 100 : 0
+      })
+    );
+    return {
+      totalMs,
+      wallClockMs,
+      phases,
+      spans: [...this.spans],
+      metadata: { ...this.metadata }
+    };
+  }
+}
+function createTiming() {
+  return new Timing();
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms.toFixed(0)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(2)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = (ms % 6e4 / 1e3).toFixed(1);
+  return `${minutes}m ${seconds}s`;
+}
+function formatPercentage(pct) {
+  return `${pct.toFixed(1)}%`;
+}
+class TimingAggregator {
+  summaries = [];
+  metadata = {};
+  aggregatorStartTime = performance.now();
+  add(summary) {
+    this.summaries.push(summary);
+    return this;
+  }
+  setMetadata(key, value) {
+    this.metadata[key] = value;
+    return this;
+  }
+  getStats() {
+    if (this.summaries.length === 0) {
+      return {
+        count: 0,
+        totalMs: 0,
+        wallClockMs: 0,
+        avgMs: 0,
+        minMs: 0,
+        maxMs: 0,
+        phaseStats: /* @__PURE__ */ new Map()
+      };
+    }
+    const wallClockTotals = this.summaries.map((s) => s.wallClockMs);
+    const totalMs = wallClockTotals.reduce((a, b) => a + b, 0);
+    const wallClockMs = performance.now() - this.aggregatorStartTime;
+    const avgMs = totalMs / this.summaries.length;
+    const minMs = Math.min(...wallClockTotals);
+    const maxMs = Math.max(...wallClockTotals);
+    const phaseStats = /* @__PURE__ */ new Map();
+    for (const summary of this.summaries) {
+      for (const phase of summary.phases) {
+        const existing = phaseStats.get(phase.name);
+        if (existing) {
+          existing.totalMs += phase.duration;
+        } else {
+          phaseStats.set(phase.name, {
+            totalMs: phase.duration,
+            avgMs: 0,
+            percentage: 0
+          });
+        }
+      }
+    }
+    const phaseTotalMs = [...phaseStats.values()].reduce(
+      (sum, p) => sum + p.totalMs,
+      0
+    );
+    for (const [, stats] of phaseStats) {
+      stats.avgMs = stats.totalMs / this.summaries.length;
+      stats.percentage = phaseTotalMs > 0 ? stats.totalMs / phaseTotalMs * 100 : 0;
+    }
+    return {
+      count: this.summaries.length,
+      totalMs,
+      wallClockMs,
+      avgMs,
+      minMs,
+      maxMs,
+      phaseStats
+    };
+  }
+  formatReport(title) {
+    const stats = this.getStats();
+    const lines = [];
+    const divider = "-".repeat(60);
+    lines.push(divider);
+    lines.push(title ?? "Timing Report");
+    lines.push(divider);
+    for (const [key, value] of Object.entries(this.metadata)) {
+      lines.push(`  ${key}: ${value}`);
+    }
+    if (Object.keys(this.metadata).length > 0) {
+      lines.push("");
+    }
+    lines.push(`  Files processed: ${stats.count}`);
+    lines.push(`  Wall clock time: ${formatDuration(stats.wallClockMs)}`);
+    lines.push(`  Combined time: ${formatDuration(stats.totalMs)}`);
+    lines.push(`  Average per file: ${formatDuration(stats.avgMs)}`);
+    lines.push(`  Fastest: ${formatDuration(stats.minMs)}`);
+    lines.push(`  Slowest: ${formatDuration(stats.maxMs)}`);
+    if (stats.phaseStats.size > 0) {
+      lines.push("");
+      lines.push("  Time by phase:");
+      const sortedPhases = [...stats.phaseStats.entries()].sort(
+        (a, b) => b[1].totalMs - a[1].totalMs
+      );
+      for (const [name, phaseData] of sortedPhases) {
+        const pct = formatPercentage(phaseData.percentage);
+        const avg = formatDuration(phaseData.avgMs);
+        const total = formatDuration(phaseData.totalMs);
+        lines.push(
+          `    ${name.padEnd(20)} ${pct.padStart(6)}  avg: ${avg.padStart(8)}  total: ${total}`
+        );
+      }
+    }
+    lines.push(divider);
+    return lines.join("\n");
+  }
+  print(title) {
+    console.log(this.formatReport(title));
+  }
+}
+function createAggregator() {
+  return new TimingAggregator();
+}
+function formatSingleReport(summary, title) {
+  const lines = [];
+  const divider = "-".repeat(50);
+  lines.push(divider);
+  lines.push(title ?? "Timing");
+  lines.push(divider);
+  for (const [key, value] of Object.entries(summary.metadata)) {
+    lines.push(`  ${key}: ${value}`);
+  }
+  if (Object.keys(summary.metadata).length > 0) {
+    lines.push("");
+  }
+  lines.push(`  Wall clock: ${formatDuration(summary.wallClockMs)}`);
+  lines.push(`  Active time: ${formatDuration(summary.totalMs)}`);
+  if (summary.phases.length > 0) {
+    lines.push("");
+    const sortedPhases = [...summary.phases].sort(
+      (a, b) => b.duration - a.duration
+    );
+    for (const phase of sortedPhases) {
+      const pct = formatPercentage(phase.percentage);
+      const dur = formatDuration(phase.duration);
+      lines.push(
+        `    ${phase.name.padEnd(20)} ${pct.padStart(6)}  ${dur.padStart(10)}`
+      );
+    }
+  }
+  lines.push(divider);
+  return lines.join("\n");
+}
+function printSingleReport(summary, title) {
+  console.log(formatSingleReport(summary, title));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Timing,
+  TimingAggregator,
+  createAggregator,
+  createTiming,
+  formatDuration,
+  formatPercentage,
+  formatSingleReport,
+  printSingleReport
+});

package/dist/utilities/Timing.d.cts

@@ -0,0 +1,64 @@
+interface TimingSpan {
+    name: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+}
+interface PhaseTiming {
+    name: string;
+    duration: number;
+    percentage: number;
+}
+interface TimingSummary {
+    totalMs: number;
+    wallClockMs: number;
+    phases: PhaseTiming[];
+    spans: TimingSpan[];
+    metadata: Record<string, string | number | boolean>;
+}
+declare class Timing {
+    private spans;
+    private activeSpans;
+    private startTime;
+    private metadata;
+    constructor();
+    time<T>(name: string, fn: () => T): T;
+    timeAsync<T>(name: string, fn: () => Promise<T>): Promise<T>;
+    start(name: string): () => void;
+    end(name: string): void;
+    setMetadata(key: string, value: string | number | boolean): this;
+    addMetadata(data: Record<string, string | number | boolean>): this;
+    getElapsedMs(): number;
+    summary(): TimingSummary;
+}
+declare function createTiming(): Timing;
+declare function formatDuration(ms: number): string;
+declare function formatPercentage(pct: number): string;
+interface AggregatedStats {
+    count: number;
+    totalMs: number;
+    wallClockMs: number;
+    avgMs: number;
+    minMs: number;
+    maxMs: number;
+    phaseStats: Map<string, {
+        totalMs: number;
+        avgMs: number;
+        percentage: number;
+    }>;
+}
+declare class TimingAggregator {
+    private summaries;
+    private metadata;
+    private aggregatorStartTime;
+    add(summary: TimingSummary): this;
+    setMetadata(key: string, value: string | number | boolean): this;
+    getStats(): AggregatedStats;
+    formatReport(title?: string): string;
+    print(title?: string): void;
+}
+declare function createAggregator(): TimingAggregator;
+declare function formatSingleReport(summary: TimingSummary, title?: string): string;
+declare function printSingleReport(summary: TimingSummary, title?: string): void;
+
+export { type AggregatedStats, type PhaseTiming, Timing, TimingAggregator, type TimingSpan, type TimingSummary, createAggregator, createTiming, formatDuration, formatPercentage, formatSingleReport, printSingleReport };

package/dist/utilities/Timing.d.ts

@@ -0,0 +1,64 @@
+interface TimingSpan {
+    name: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+}
+interface PhaseTiming {
+    name: string;
+    duration: number;
+    percentage: number;
+}
+interface TimingSummary {
+    totalMs: number;
+    wallClockMs: number;
+    phases: PhaseTiming[];
+    spans: TimingSpan[];
+    metadata: Record<string, string | number | boolean>;
+}
+declare class Timing {
+    private spans;
+    private activeSpans;
+    private startTime;
+    private metadata;
+    constructor();
+    time<T>(name: string, fn: () => T): T;
+    timeAsync<T>(name: string, fn: () => Promise<T>): Promise<T>;
+    start(name: string): () => void;
+    end(name: string): void;
+    setMetadata(key: string, value: string | number | boolean): this;
+    addMetadata(data: Record<string, string | number | boolean>): this;
+    getElapsedMs(): number;
+    summary(): TimingSummary;
+}
+declare function createTiming(): Timing;
+declare function formatDuration(ms: number): string;
+declare function formatPercentage(pct: number): string;
+interface AggregatedStats {
+    count: number;
+    totalMs: number;
+    wallClockMs: number;
+    avgMs: number;
+    minMs: number;
+    maxMs: number;
+    phaseStats: Map<string, {
+        totalMs: number;
+        avgMs: number;
+        percentage: number;
+    }>;
+}
+declare class TimingAggregator {
+    private summaries;
+    private metadata;
+    private aggregatorStartTime;
+    add(summary: TimingSummary): this;
+    setMetadata(key: string, value: string | number | boolean): this;
+    getStats(): AggregatedStats;
+    formatReport(title?: string): string;
+    print(title?: string): void;
+}
+declare function createAggregator(): TimingAggregator;
+declare function formatSingleReport(summary: TimingSummary, title?: string): string;
+declare function printSingleReport(summary: TimingSummary, title?: string): void;
+
+export { type AggregatedStats, type PhaseTiming, Timing, TimingAggregator, type TimingSpan, type TimingSummary, createAggregator, createTiming, formatDuration, formatPercentage, formatSingleReport, printSingleReport };

package/dist/utilities/Timing.js

@@ -0,0 +1,256 @@
+class Timing {
+  spans = [];
+  activeSpans = /* @__PURE__ */ new Map();
+  startTime = 0;
+  metadata = {};
+  constructor() {
+    this.startTime = performance.now();
+  }
+  time(name, fn) {
+    const start = performance.now();
+    try {
+      return fn();
+    } finally {
+      const end = performance.now();
+      this.spans.push({
+        name,
+        startTime: start - this.startTime,
+        endTime: end - this.startTime,
+        duration: end - start
+      });
+    }
+  }
+  async timeAsync(name, fn) {
+    const start = performance.now();
+    try {
+      return await fn();
+    } finally {
+      const end = performance.now();
+      this.spans.push({
+        name,
+        startTime: start - this.startTime,
+        endTime: end - this.startTime,
+        duration: end - start
+      });
+    }
+  }
+  start(name) {
+    const start = performance.now();
+    this.activeSpans.set(name, start);
+    return () => {
+      this.end(name);
+    };
+  }
+  end(name) {
+    const start = this.activeSpans.get(name);
+    if (start === void 0) return;
+    const end = performance.now();
+    this.activeSpans.delete(name);
+    this.spans.push({
+      name,
+      startTime: start - this.startTime,
+      endTime: end - this.startTime,
+      duration: end - start
+    });
+  }
+  setMetadata(key, value) {
+    this.metadata[key] = value;
+    return this;
+  }
+  addMetadata(data) {
+    Object.assign(this.metadata, data);
+    return this;
+  }
+  getElapsedMs() {
+    return performance.now() - this.startTime;
+  }
+  summary() {
+    const wallClockMs = performance.now() - this.startTime;
+    const totalMs = this.spans.reduce((sum, s) => sum + s.duration, 0);
+    const phaseMap = /* @__PURE__ */ new Map();
+    for (const span of this.spans) {
+      phaseMap.set(span.name, (phaseMap.get(span.name) ?? 0) + span.duration);
+    }
+    const phases = [...phaseMap.entries()].map(
+      ([name, duration]) => ({
+        name,
+        duration,
+        percentage: totalMs > 0 ? duration / totalMs * 100 : 0
+      })
+    );
+    return {
+      totalMs,
+      wallClockMs,
+      phases,
+      spans: [...this.spans],
+      metadata: { ...this.metadata }
+    };
+  }
+}
+function createTiming() {
+  return new Timing();
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms.toFixed(0)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(2)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = (ms % 6e4 / 1e3).toFixed(1);
+  return `${minutes}m ${seconds}s`;
+}
+function formatPercentage(pct) {
+  return `${pct.toFixed(1)}%`;
+}
+class TimingAggregator {
+  summaries = [];
+  metadata = {};
+  aggregatorStartTime = performance.now();
+  add(summary) {
+    this.summaries.push(summary);
+    return this;
+  }
+  setMetadata(key, value) {
+    this.metadata[key] = value;
+    return this;
+  }
+  getStats() {
+    if (this.summaries.length === 0) {
+      return {
+        count: 0,
+        totalMs: 0,
+        wallClockMs: 0,
+        avgMs: 0,
+        minMs: 0,
+        maxMs: 0,
+        phaseStats: /* @__PURE__ */ new Map()
+      };
+    }
+    const wallClockTotals = this.summaries.map((s) => s.wallClockMs);
+    const totalMs = wallClockTotals.reduce((a, b) => a + b, 0);
+    const wallClockMs = performance.now() - this.aggregatorStartTime;
+    const avgMs = totalMs / this.summaries.length;
+    const minMs = Math.min(...wallClockTotals);
+    const maxMs = Math.max(...wallClockTotals);
+    const phaseStats = /* @__PURE__ */ new Map();
+    for (const summary of this.summaries) {
+      for (const phase of summary.phases) {
+        const existing = phaseStats.get(phase.name);
+        if (existing) {
+          existing.totalMs += phase.duration;
+        } else {
+          phaseStats.set(phase.name, {
+            totalMs: phase.duration,
+            avgMs: 0,
+            percentage: 0
+          });
+        }
+      }
+    }
+    const phaseTotalMs = [...phaseStats.values()].reduce(
+      (sum, p) => sum + p.totalMs,
+      0
+    );
+    for (const [, stats] of phaseStats) {
+      stats.avgMs = stats.totalMs / this.summaries.length;
+      stats.percentage = phaseTotalMs > 0 ? stats.totalMs / phaseTotalMs * 100 : 0;
+    }
+    return {
+      count: this.summaries.length,
+      totalMs,
+      wallClockMs,
+      avgMs,
+      minMs,
+      maxMs,
+      phaseStats
+    };
+  }
+  formatReport(title) {
+    const stats = this.getStats();
+    const lines = [];
+    const divider = "-".repeat(60);
+    lines.push(divider);
+    lines.push(title ?? "Timing Report");
+    lines.push(divider);
+    for (const [key, value] of Object.entries(this.metadata)) {
+      lines.push(`  ${key}: ${value}`);
+    }
+    if (Object.keys(this.metadata).length > 0) {
+      lines.push("");
+    }
+    lines.push(`  Files processed: ${stats.count}`);
+    lines.push(`  Wall clock time: ${formatDuration(stats.wallClockMs)}`);
+    lines.push(`  Combined time: ${formatDuration(stats.totalMs)}`);
+    lines.push(`  Average per file: ${formatDuration(stats.avgMs)}`);
+    lines.push(`  Fastest: ${formatDuration(stats.minMs)}`);
+    lines.push(`  Slowest: ${formatDuration(stats.maxMs)}`);
+    if (stats.phaseStats.size > 0) {
+      lines.push("");
+      lines.push("  Time by phase:");
+      const sortedPhases = [...stats.phaseStats.entries()].sort(
+        (a, b) => b[1].totalMs - a[1].totalMs
+      );
+      for (const [name, phaseData] of sortedPhases) {
+        const pct = formatPercentage(phaseData.percentage);
+        const avg = formatDuration(phaseData.avgMs);
+        const total = formatDuration(phaseData.totalMs);
+        lines.push(
+          `    ${name.padEnd(20)} ${pct.padStart(6)}  avg: ${avg.padStart(8)}  total: ${total}`
+        );
+      }
+    }
+    lines.push(divider);
+    return lines.join("\n");
+  }
+  print(title) {
+    console.log(this.formatReport(title));
+  }
+}
+function createAggregator() {
+  return new TimingAggregator();
+}
+function formatSingleReport(summary, title) {
+  const lines = [];
+  const divider = "-".repeat(50);
+  lines.push(divider);
+  lines.push(title ?? "Timing");
+  lines.push(divider);
+  for (const [key, value] of Object.entries(summary.metadata)) {
+    lines.push(`  ${key}: ${value}`);
+  }
+  if (Object.keys(summary.metadata).length > 0) {
+    lines.push("");
+  }
+  lines.push(`  Wall clock: ${formatDuration(summary.wallClockMs)}`);
+  lines.push(`  Active time: ${formatDuration(summary.totalMs)}`);
+  if (summary.phases.length > 0) {
+    lines.push("");
+    const sortedPhases = [...summary.phases].sort(
+      (a, b) => b.duration - a.duration
+    );
+    for (const phase of sortedPhases) {
+      const pct = formatPercentage(phase.percentage);
+      const dur = formatDuration(phase.duration);
+      lines.push(
+        `    ${phase.name.padEnd(20)} ${pct.padStart(6)}  ${dur.padStart(10)}`
+      );
+    }
+  }
+  lines.push(divider);
+  return lines.join("\n");
+}
+function printSingleReport(summary, title) {
+  console.log(formatSingleReport(summary, title));
+}
+export {
+  Timing,
+  TimingAggregator,
+  createAggregator,
+  createTiming,
+  formatDuration,
+  formatPercentage,
+  formatSingleReport,
+  printSingleReport
+};