@storyteller-platform/ghost-story 0.0.1

package/dist/utilities/WhisperTimeline.cjs

@@ -0,0 +1,344 @@
+"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 WhisperTimeline_exports = {};
+__export(WhisperTimeline_exports, {
+  calculateEffectiveProcessors: () => calculateEffectiveProcessors,
+  calculateWhisperSplits: () => calculateWhisperSplits,
+  compareTimelines: () => compareTimelines,
+  countProcessorBoundaries: () => countProcessorBoundaries,
+  extractCorrectedTimeline: () => extractCorrectedTimeline,
+  parseWhisperCppOutput: () => parseWhisperCppOutput,
+  parseWhisperServerOutput: () => parseWhisperServerOutput,
+  scoreTimeline: () => scoreTimeline
+});
+module.exports = __toCommonJS(WhisperTimeline_exports);
+const WHISPER_SAMPLE_RATE = 16e3;
+function calculateWhisperSplits(durationSeconds, numProcessors, sampleRate = WHISPER_SAMPLE_RATE) {
+  if (numProcessors <= 1) return [];
+  const totalSamples = Math.floor(durationSeconds * sampleRate);
+  const samplesPerProcessor = Math.floor(totalSamples / numProcessors);
+  const splits = [];
+  for (let i = 1; i < numProcessors; i++) {
+    const splitSamples = i * samplesPerProcessor;
+    const splitSeconds = splitSamples / sampleRate;
+    splits.push(splitSeconds);
+  }
+  return splits;
+}
+const specialTokenPattern = /\[_.+\]|<\|[a-z_]+\|>/g;
+function parseWhisperCppOutput(transcription) {
+  return transcription.map((segment) => {
+    var _a, _b;
+    const words = [];
+    let lastTokenEndMs = 0;
+    for (const token of segment.tokens) {
+      const cleanedText = token.text.replace(specialTokenPattern, "");
+      if (cleanedText.trim().length === 0) continue;
+      const offsetFrom = ((_a = token.offsets) == null ? void 0 : _a.from) ?? lastTokenEndMs;
+      const offsetTo = ((_b = token.offsets) == null ? void 0 : _b.to) ?? lastTokenEndMs;
+      if (token.offsets) {
+        lastTokenEndMs = token.offsets.to;
+      }
+      words.push({
+        text: cleanedText,
+        start: offsetFrom / 1e3,
+        end: offsetTo / 1e3,
+        confidence: token.p
+      });
+    }
+    return {
+      text: segment.text,
+      segmentStart: segment.offsets.from / 1e3,
+      segmentEnd: segment.offsets.to / 1e3,
+      words
+    };
+  });
+}
+function parseWhisperServerOutput(segments) {
+  return segments.map((segment) => {
+    const words = (segment.words ?? []).map((word) => ({
+      text: word.word,
+      start: word.start,
+      end: word.end,
+      confidence: word.probability ?? 0
+    }));
+    return {
+      text: segment.text,
+      segmentStart: segment.start,
+      segmentEnd: segment.end,
+      words
+    };
+  });
+}
+const MS_PER_CHAR = 0.15;
+const MAX_REASONABLE_WORD_DURATION = 5;
+const LOW_CONFIDENCE_THRESHOLD = 0.3;
+function estimateReasonableDuration(text) {
+  const charCount = text.trim().length;
+  return Math.max(0.1, charCount * MS_PER_CHAR);
+}
+function detectProcessorBoundary(segment, state) {
+  if (segment.words.length === 0) return false;
+  const firstWord = segment.words[0];
+  if (!firstWord) return false;
+  const wordStartsNearZero = firstWord.start < 1;
+  if (!wordStartsNearZero) return false;
+  const segmentJumpsForward = segment.segmentStart > state.lastSegmentEnd + 1;
+  if (segmentJumpsForward) return true;
+  const segmentGoesBackwards = segment.segmentEnd < segment.segmentStart;
+  if (segmentGoesBackwards) return true;
+  const significantTimeAccumulated = state.lastWordEnd > 30;
+  if (significantTimeAccumulated && firstWord.start < 0.5) return true;
+  return false;
+}
+function countProcessorBoundaries(segments) {
+  if (segments.length === 0) return 0;
+  let boundaryCount = 0;
+  const state = {
+    cumulativeOffset: 0,
+    lastSegmentEnd: 0,
+    lastWordEnd: 0
+  };
+  for (const segment of segments) {
+    if (detectProcessorBoundary(segment, state)) {
+      boundaryCount++;
+    }
+    const segmentEnd = segment.segmentEnd < segment.segmentStart ? segment.segmentStart : segment.segmentEnd;
+    state.lastSegmentEnd = segmentEnd;
+    const lastWord = segment.words[segment.words.length - 1];
+    if (lastWord) {
+      state.lastWordEnd = Math.max(state.lastWordEnd, lastWord.end);
+    }
+  }
+  return boundaryCount;
+}
+const MIN_SECONDS_PER_PROCESSOR = 30;
+function calculateEffectiveProcessors(durationSeconds, requestedProcessors) {
+  const maxProcessors = Math.max(
+    1,
+    Math.floor(durationSeconds / MIN_SECONDS_PER_PROCESSOR)
+  );
+  return Math.min(requestedProcessors, maxProcessors);
+}
+function correctWordTimestamps(word, state, segmentBounds) {
+  let startTime = word.start + state.cumulativeOffset;
+  let endTime = word.end + state.cumulativeOffset;
+  const duration = endTime - startTime;
+  if (duration > MAX_REASONABLE_WORD_DURATION && word.confidence < LOW_CONFIDENCE_THRESHOLD) {
+    const reasonableDuration = estimateReasonableDuration(word.text);
+    endTime = startTime + reasonableDuration;
+  }
+  if (startTime < state.lastWordEnd) {
+    const shift = state.lastWordEnd - startTime;
+    startTime = state.lastWordEnd;
+    endTime = endTime + shift;
+  }
+  if (endTime < startTime) {
+    endTime = startTime;
+  }
+  const segmentDuration = segmentBounds.end - segmentBounds.start;
+  if (segmentDuration > 0 && endTime > segmentBounds.end + state.cumulativeOffset) {
+    endTime = Math.max(startTime, segmentBounds.end + state.cumulativeOffset);
+  }
+  return { startTime, endTime };
+}
+function extractCorrectedTimeline(segments, options = {}) {
+  var _a;
+  if (segments.length === 0) return [];
+  const { splitBoundaries = [] } = options;
+  const usedSplits = /* @__PURE__ */ new Set();
+  const timeline = [];
+  const state = {
+    cumulativeOffset: 0,
+    lastSegmentEnd: 0,
+    lastWordEnd: 0
+  };
+  for (const segment of segments) {
+    const segmentStart = segment.segmentStart;
+    const segmentEnd = segment.segmentEnd < segment.segmentStart ? segment.segmentStart : segment.segmentEnd;
+    if (detectProcessorBoundary(segment, state)) {
+      const firstWord = segment.words[0];
+      const firstWordStart = (firstWord == null ? void 0 : firstWord.start) ?? 0;
+      if (splitBoundaries.length > 0) {
+        const expectedTime = state.lastWordEnd > 0 ? state.lastWordEnd : segmentStart;
+        let bestSplit = null;
+        for (const split of splitBoundaries) {
+          if (usedSplits.has(split)) continue;
+          if (Math.abs(split - expectedTime) < 30 || Math.abs(split - segmentStart) < 30) {
+            bestSplit = split;
+            break;
+          }
+        }
+        if (bestSplit !== null) {
+          state.cumulativeOffset = bestSplit - firstWordStart;
+          usedSplits.add(bestSplit);
+        } else if (state.lastWordEnd > 0) {
+          state.cumulativeOffset = state.lastWordEnd - firstWordStart;
+        } else {
+          state.cumulativeOffset = segmentStart - firstWordStart;
+        }
+      } else {
+        if (state.lastWordEnd > 0) {
+          state.cumulativeOffset = state.lastWordEnd - firstWordStart;
+        } else {
+          state.cumulativeOffset = segmentStart - firstWordStart;
+        }
+      }
+    }
+    for (const word of segment.words) {
+      const trimmedText = word.text.trim();
+      if (trimmedText.length === 0) continue;
+      if (trimmedText.includes("BLANK_AUDIO")) continue;
+      const { startTime, endTime } = correctWordTimestamps(word, state, {
+        start: segmentStart,
+        end: segmentEnd
+      });
+      const lastEntry = timeline[timeline.length - 1];
+      if (lastEntry && !word.text.startsWith(" ")) {
+        lastEntry.text += trimmedText;
+        if (lastEntry.confidence !== void 0) {
+          lastEntry.confidence = Math.min(lastEntry.confidence, word.confidence);
+        }
+        const mergedDuration = endTime - lastEntry.startTime;
+        const mergedConfidence = lastEntry.confidence ?? 1;
+        if (mergedDuration > MAX_REASONABLE_WORD_DURATION && mergedConfidence < LOW_CONFIDENCE_THRESHOLD) {
+          lastEntry.endTime = lastEntry.startTime + estimateReasonableDuration(lastEntry.text);
+        } else {
+          lastEntry.endTime = endTime;
+        }
+      } else {
+        timeline.push({
+          type: "word",
+          text: trimmedText,
+          startTime,
+          endTime,
+          confidence: word.confidence
+        });
+      }
+      state.lastWordEnd = ((_a = timeline[timeline.length - 1]) == null ? void 0 : _a.endTime) ?? endTime;
+    }
+    state.lastSegmentEnd = segmentEnd;
+  }
+  return ensureMonotonicTimeline(timeline);
+}
+function ensureMonotonicTimeline(timeline) {
+  if (timeline.length === 0) return [];
+  const sorted = [...timeline].sort((a, b) => a.startTime - b.startTime);
+  const result = [];
+  let lastEndTime = 0;
+  for (const entry of sorted) {
+    let startTime = entry.startTime;
+    let endTime = entry.endTime;
+    if (startTime < lastEndTime) {
+      const shift = lastEndTime - startTime;
+      startTime = lastEndTime;
+      endTime = endTime + shift;
+    }
+    if (endTime < startTime) {
+      endTime = startTime;
+    }
+    result.push({
+      ...entry,
+      startTime,
+      endTime
+    });
+    lastEndTime = endTime;
+  }
+  return result;
+}
+function scoreTimeline(timeline) {
+  if (timeline.length === 0) {
+    return {
+      totalWords: 0,
+      maxWordDuration: 0,
+      averageWordDuration: 0,
+      medianWordDuration: 0,
+      suspiciousTokenCount: 0,
+      suspiciousTokens: [],
+      totalDuration: 0
+    };
+  }
+  const durations = timeline.map((entry) => entry.endTime - entry.startTime);
+  const sortedDurations = [...durations].sort((a, b) => a - b);
+  const suspiciousTokens = [];
+  for (const entry of timeline) {
+    const duration = entry.endTime - entry.startTime;
+    const confidence = entry.confidence ?? 1;
+    if (duration > 3 && confidence < LOW_CONFIDENCE_THRESHOLD) {
+      suspiciousTokens.push({
+        text: entry.text,
+        duration,
+        confidence,
+        startTime: entry.startTime
+      });
+    }
+  }
+  const lastEntry = timeline[timeline.length - 1];
+  const totalDuration = lastEntry ? lastEntry.endTime : 0;
+  const sum = durations.reduce((acc, d) => acc + d, 0);
+  const medianIndex = Math.floor(sortedDurations.length / 2);
+  return {
+    totalWords: timeline.length,
+    maxWordDuration: Math.max(...durations),
+    averageWordDuration: sum / durations.length,
+    medianWordDuration: sortedDurations[medianIndex] ?? 0,
+    suspiciousTokenCount: suspiciousTokens.length,
+    suspiciousTokens,
+    totalDuration
+  };
+}
+function compareTimelines(baseline, test) {
+  const baselineText = baseline.map((e) => e.text).join(" ").toLowerCase();
+  const testText = test.map((e) => e.text).join(" ").toLowerCase();
+  const baselineWords = new Set(baselineText.split(/\s+/));
+  const testWords = new Set(testText.split(/\s+/));
+  const intersection = [...baselineWords].filter((w) => testWords.has(w));
+  const union = /* @__PURE__ */ new Set([...baselineWords, ...testWords]);
+  const textSimilarity = intersection.length / union.size;
+  const baselineMetrics = scoreTimeline(baseline);
+  const testMetrics = scoreTimeline(test);
+  const durationDifference = Math.abs(
+    baselineMetrics.totalDuration - testMetrics.totalDuration
+  );
+  const wordCountDifference = Math.abs(
+    baselineMetrics.totalWords - testMetrics.totalWords
+  );
+  const maxDurationDifference = Math.abs(
+    baselineMetrics.maxWordDuration - testMetrics.maxWordDuration
+  );
+  const isAcceptable = textSimilarity > 0.8 && testMetrics.suspiciousTokenCount === 0 && maxDurationDifference < 2;
+  return {
+    textSimilarity,
+    durationDifference,
+    wordCountDifference,
+    maxDurationDifference,
+    isAcceptable
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateEffectiveProcessors,
+  calculateWhisperSplits,
+  compareTimelines,
+  countProcessorBoundaries,
+  extractCorrectedTimeline,
+  parseWhisperCppOutput,
+  parseWhisperServerOutput,
+  scoreTimeline
+});

package/dist/utilities/WhisperTimeline.d.cts

@@ -0,0 +1,86 @@
+import { Timeline } from './Timeline.cjs';
+
+declare function calculateWhisperSplits(durationSeconds: number, numProcessors: number, sampleRate?: number): number[];
+interface RawWhisperSegment {
+    text: string;
+    segmentStart: number;
+    segmentEnd: number;
+    words: RawWhisperWord[];
+}
+interface RawWhisperWord {
+    text: string;
+    start: number;
+    end: number;
+    confidence: number;
+}
+interface WhisperCppTranscriptionSegment {
+    text: string;
+    timestamps: {
+        from: string;
+        to: string;
+    };
+    offsets: {
+        from: number;
+        to: number;
+    };
+    tokens: WhisperCppToken[];
+}
+interface WhisperCppToken {
+    text: string;
+    timestamps: {
+        from: string;
+        to: string;
+    };
+    offsets?: {
+        from: number;
+        to: number;
+    };
+    t_dtw: number;
+    p: number;
+    id: number;
+}
+interface WhisperServerSegment {
+    text: string;
+    start: number;
+    end: number;
+    words?: WhisperServerWord[];
+}
+interface WhisperServerWord {
+    word: string;
+    start: number;
+    end: number;
+    probability?: number;
+}
+declare function parseWhisperCppOutput(transcription: WhisperCppTranscriptionSegment[]): RawWhisperSegment[];
+declare function parseWhisperServerOutput(segments: WhisperServerSegment[]): RawWhisperSegment[];
+declare function countProcessorBoundaries(segments: RawWhisperSegment[]): number;
+declare function calculateEffectiveProcessors(durationSeconds: number, requestedProcessors: number): number;
+interface TimelineCorrectionOptions {
+    splitBoundaries?: number[] | undefined;
+}
+declare function extractCorrectedTimeline(segments: RawWhisperSegment[], options?: TimelineCorrectionOptions): Timeline;
+interface TimelineQualityMetrics {
+    totalWords: number;
+    maxWordDuration: number;
+    averageWordDuration: number;
+    medianWordDuration: number;
+    suspiciousTokenCount: number;
+    suspiciousTokens: Array<{
+        text: string;
+        duration: number;
+        confidence: number;
+        startTime: number;
+    }>;
+    totalDuration: number;
+}
+declare function scoreTimeline(timeline: Timeline): TimelineQualityMetrics;
+interface TimelineComparisonResult {
+    textSimilarity: number;
+    durationDifference: number;
+    wordCountDifference: number;
+    maxDurationDifference: number;
+    isAcceptable: boolean;
+}
+declare function compareTimelines(baseline: Timeline, test: Timeline): TimelineComparisonResult;
+
+export { type RawWhisperSegment, type RawWhisperWord, type TimelineComparisonResult, type TimelineCorrectionOptions, type TimelineQualityMetrics, type WhisperCppToken, type WhisperCppTranscriptionSegment, type WhisperServerSegment, type WhisperServerWord, calculateEffectiveProcessors, calculateWhisperSplits, compareTimelines, countProcessorBoundaries, extractCorrectedTimeline, parseWhisperCppOutput, parseWhisperServerOutput, scoreTimeline };

package/dist/utilities/WhisperTimeline.d.ts

@@ -0,0 +1,86 @@
+import { Timeline } from './Timeline.js';
+
+declare function calculateWhisperSplits(durationSeconds: number, numProcessors: number, sampleRate?: number): number[];
+interface RawWhisperSegment {
+    text: string;
+    segmentStart: number;
+    segmentEnd: number;
+    words: RawWhisperWord[];
+}
+interface RawWhisperWord {
+    text: string;
+    start: number;
+    end: number;
+    confidence: number;
+}
+interface WhisperCppTranscriptionSegment {
+    text: string;
+    timestamps: {
+        from: string;
+        to: string;
+    };
+    offsets: {
+        from: number;
+        to: number;
+    };
+    tokens: WhisperCppToken[];
+}
+interface WhisperCppToken {
+    text: string;
+    timestamps: {
+        from: string;
+        to: string;
+    };
+    offsets?: {
+        from: number;
+        to: number;
+    };
+    t_dtw: number;
+    p: number;
+    id: number;
+}
+interface WhisperServerSegment {
+    text: string;
+    start: number;
+    end: number;
+    words?: WhisperServerWord[];
+}
+interface WhisperServerWord {
+    word: string;
+    start: number;
+    end: number;
+    probability?: number;
+}
+declare function parseWhisperCppOutput(transcription: WhisperCppTranscriptionSegment[]): RawWhisperSegment[];
+declare function parseWhisperServerOutput(segments: WhisperServerSegment[]): RawWhisperSegment[];
+declare function countProcessorBoundaries(segments: RawWhisperSegment[]): number;
+declare function calculateEffectiveProcessors(durationSeconds: number, requestedProcessors: number): number;
+interface TimelineCorrectionOptions {
+    splitBoundaries?: number[] | undefined;
+}
+declare function extractCorrectedTimeline(segments: RawWhisperSegment[], options?: TimelineCorrectionOptions): Timeline;
+interface TimelineQualityMetrics {
+    totalWords: number;
+    maxWordDuration: number;
+    averageWordDuration: number;
+    medianWordDuration: number;
+    suspiciousTokenCount: number;
+    suspiciousTokens: Array<{
+        text: string;
+        duration: number;
+        confidence: number;
+        startTime: number;
+    }>;
+    totalDuration: number;
+}
+declare function scoreTimeline(timeline: Timeline): TimelineQualityMetrics;
+interface TimelineComparisonResult {
+    textSimilarity: number;
+    durationDifference: number;
+    wordCountDifference: number;
+    maxDurationDifference: number;
+    isAcceptable: boolean;
+}
+declare function compareTimelines(baseline: Timeline, test: Timeline): TimelineComparisonResult;
+
+export { type RawWhisperSegment, type RawWhisperWord, type TimelineComparisonResult, type TimelineCorrectionOptions, type TimelineQualityMetrics, type WhisperCppToken, type WhisperCppTranscriptionSegment, type WhisperServerSegment, type WhisperServerWord, calculateEffectiveProcessors, calculateWhisperSplits, compareTimelines, countProcessorBoundaries, extractCorrectedTimeline, parseWhisperCppOutput, parseWhisperServerOutput, scoreTimeline };