@bendyline/squisq 1.5.2 → 2.0.0

package/dist/chunk-T3TI7GSZ.js

@@ -0,0 +1,884 @@
+import {
+  expectedSyllablesAt,
+  wordPosAtExpectedSyllables
+} from "./chunk-GF3BVNLU.js";
+
+// src/narration/types.ts
+var DEFAULT_FEATURE_CONFIG = Object.freeze({
+  frameSize: 1024,
+  hopSec: 0.02,
+  bandLowHz: 250,
+  bandHighHz: 3e3
+});
+var DEFAULT_VAD_CONFIG = Object.freeze({
+  warmupMs: 200,
+  alphaDown: 0.3,
+  alphaUp: 5e-3,
+  enterRatio: 3,
+  exitRatio: 2.5,
+  enterFrames: 2,
+  hangoverMs: 300,
+  noiseRebaselineSec: 1.5,
+  floorMin: 1e-9
+});
+var DEFAULT_NUCLEI_CONFIG = Object.freeze({
+  // Continuous reading blurs adjacent syllables together: a 10 Hz envelope
+  // over-smooths 5–7 Hz syllable structure and a 1.6× prominence gate
+  // rejects the shallow dips between connected syllables — both cause the
+  // detector to UNDER-count, which makes the prompter lag. A higher
+  // envelope cutoff preserves per-syllable peaks and a gentler prominence
+  // gate accepts them; the min-spacing gate still rejects true doublets.
+  envelopeHz: 16,
+  minInterOnsetMs: 110,
+  prominenceRatio: 1.3,
+  minRelPeak: 0.1,
+  peakRefTauSec: 3
+});
+var DEFAULT_PACING_CONFIG = Object.freeze({
+  baseWpm: 150,
+  voiceBlend: 0.6,
+  minRateMult: 0.5,
+  maxRateMult: 3,
+  rateEmaTauSec: 0.7,
+  velSlewTauSec: 0.15,
+  haltTauSec: 0.085,
+  kP: 0.14,
+  kI: 0.02,
+  intClamp: 4,
+  maxCorrection: 0.6,
+  sylWindowWords: 8,
+  resyncSyllables: 8
+});
+var DEFAULT_ALIGN_CONFIG = Object.freeze({
+  hopSec: 0.01,
+  gapMinSec: 0.35,
+  bandRadiusSec: 1.5,
+  bandRadiusNoTraceSec: 3,
+  matchTimeWeight: 1,
+  pauseToSylCost: 2,
+  sylToGapCost: 1.5,
+  deleteCost: 0.8,
+  insertCost: 0.8,
+  blockSnapWindowSec: 0.8,
+  tailPadSec: 0.4
+});
+
+// src/narration/features.ts
+function highpassCoeffs(sampleRate, freqHz) {
+  const w0 = 2 * Math.PI * freqHz / sampleRate;
+  const cosW0 = Math.cos(w0);
+  const alpha = Math.sin(w0) / (2 * Math.SQRT1_2);
+  const a0 = 1 + alpha;
+  return {
+    b0: (1 + cosW0) / 2 / a0,
+    b1: -(1 + cosW0) / a0,
+    b2: (1 + cosW0) / 2 / a0,
+    a1: -2 * cosW0 / a0,
+    a2: (1 - alpha) / a0
+  };
+}
+function lowpassCoeffs(sampleRate, freqHz) {
+  const w0 = 2 * Math.PI * freqHz / sampleRate;
+  const cosW0 = Math.cos(w0);
+  const alpha = Math.sin(w0) / (2 * Math.SQRT1_2);
+  const a0 = 1 + alpha;
+  return {
+    b0: (1 - cosW0) / 2 / a0,
+    b1: (1 - cosW0) / a0,
+    b2: (1 - cosW0) / 2 / a0,
+    a1: -2 * cosW0 / a0,
+    a2: (1 - alpha) / a0
+  };
+}
+function createBandpass(sampleRate, lowHz = DEFAULT_FEATURE_CONFIG.bandLowHz, highHz = DEFAULT_FEATURE_CONFIG.bandHighHz) {
+  return {
+    coeffs: { hp: highpassCoeffs(sampleRate, lowHz), lp: lowpassCoeffs(sampleRate, highHz) },
+    hp: { x1: 0, x2: 0, y1: 0, y2: 0 },
+    lp: { x1: 0, x2: 0, y1: 0, y2: 0 }
+  };
+}
+function biquadRun(coeffs, state, input, output) {
+  let { x1, x2, y1, y2 } = state;
+  const { b0, b1, b2, a1, a2 } = coeffs;
+  for (let i = 0; i < input.length; i++) {
+    const x0 = input[i];
+    const y0 = b0 * x0 + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;
+    output[i] = y0;
+    x2 = x1;
+    x1 = x0;
+    y2 = y1;
+    y1 = y0;
+  }
+  return { x1, x2, y1, y2 };
+}
+function bandpassRun(state, input, output) {
+  const hp = biquadRun(state.coeffs.hp, state.hp, input, output);
+  const lp = biquadRun(state.coeffs.lp, state.lp, output, output);
+  return { coeffs: state.coeffs, hp, lp };
+}
+function createFeatureState(sampleRate, config) {
+  const merged = { ...DEFAULT_FEATURE_CONFIG, ...config };
+  return {
+    sampleRate,
+    config: merged,
+    hopSamples: Math.max(1, Math.round(merged.hopSec * sampleRate)),
+    bandpass: createBandpass(sampleRate, merged.bandLowHz, merged.bandHighHz),
+    rawCarry: new Float32Array(0),
+    bandCarry: new Float32Array(0),
+    carryStartSample: 0
+  };
+}
+function concatF32(a, b) {
+  if (a.length === 0) return b;
+  const out = new Float32Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
+}
+function frameOf(raw, band, start, size, startSample, sampleRate) {
+  let sumSq = 0;
+  let bandSumSq = 0;
+  let crossings = 0;
+  let prev = raw[start];
+  for (let i = 0; i < size; i++) {
+    const r = raw[start + i];
+    const b = band[start + i];
+    sumSq += r * r;
+    bandSumSq += b * b;
+    if (i > 0 && (r >= 0 && prev < 0 || r < 0 && prev >= 0)) crossings++;
+    prev = r;
+  }
+  return {
+    tSec: (startSample + size / 2) / sampleRate,
+    rms: Math.sqrt(sumSq / size),
+    bandEnergy: bandSumSq / size,
+    zcr: size > 1 ? crossings / (size - 1) : 0
+  };
+}
+function featureStep(state, hop) {
+  const banded = new Float32Array(hop.length);
+  const bandpass = bandpassRun(state.bandpass, hop, banded);
+  const raw = concatF32(state.rawCarry, hop);
+  const band = concatF32(state.bandCarry, banded);
+  const { frameSize } = state.config;
+  const frames = [];
+  let cursor = 0;
+  while (raw.length - cursor >= frameSize) {
+    frames.push(
+      frameOf(raw, band, cursor, frameSize, state.carryStartSample + cursor, state.sampleRate)
+    );
+    cursor += state.hopSamples;
+  }
+  return {
+    state: {
+      ...state,
+      bandpass,
+      // slice(), not subarray(): the carry must OWN its memory. `raw` can
+      // alias the caller's hop buffer, and callers may recycle those
+      // (e.g. Chrome invalidates buffers transferred out of an
+      // AudioWorklet after the message handler returns) — a retained
+      // view would silently read zeros on the next step.
+      rawCarry: raw.slice(cursor),
+      bandCarry: band.slice(cursor),
+      carryStartSample: state.carryStartSample + cursor
+    },
+    frames
+  };
+}
+function extractFrameFeatures(pcm, sampleRate, config) {
+  const state = createFeatureState(sampleRate, config);
+  return featureStep(state, pcm).frames;
+}
+
+// src/narration/vad.ts
+function createVadState(config) {
+  const merged = { ...DEFAULT_VAD_CONFIG, ...config };
+  return {
+    noiseFloor: merged.floorMin,
+    speaking: false,
+    enterStreak: 0,
+    subExitSince: null,
+    noDipSince: null,
+    warmupUntilSec: merged.warmupMs / 1e3,
+    seeded: false,
+    lastTSec: 0
+  };
+}
+function vadStep(state, frame, config) {
+  const c = { ...DEFAULT_VAD_CONFIG, ...config };
+  const energy = Math.max(0, frame.bandEnergy);
+  let floor = state.seeded ? state.noiseFloor : Math.max(energy, c.floorMin);
+  if (state.seeded) {
+    if (!state.speaking) {
+      const alpha = energy < floor ? c.alphaDown : c.alphaUp;
+      floor += (energy - floor) * alpha;
+    } else if (energy < floor) {
+      floor += (energy - floor) * c.alphaDown;
+    }
+  }
+  if (floor < c.floorMin) floor = c.floorMin;
+  let speaking = state.speaking;
+  let enterStreak = state.enterStreak;
+  let subExitSince = state.subExitSince;
+  let noDipSince = state.noDipSince;
+  if (frame.tSec < state.warmupUntilSec) {
+    speaking = false;
+    enterStreak = 0;
+    subExitSince = null;
+    noDipSince = null;
+  } else if (!speaking) {
+    noDipSince = null;
+    if (energy > floor * c.enterRatio) {
+      enterStreak += 1;
+      if (enterStreak >= c.enterFrames) {
+        speaking = true;
+        subExitSince = null;
+        noDipSince = frame.tSec;
+      }
+    } else {
+      enterStreak = 0;
+    }
+  } else {
+    if (energy >= floor * c.exitRatio) {
+      subExitSince = null;
+    } else {
+      if (subExitSince === null) subExitSince = frame.tSec;
+      if (frame.tSec - subExitSince >= c.hangoverMs / 1e3) {
+        speaking = false;
+        subExitSince = null;
+        noDipSince = null;
+        enterStreak = 0;
+      }
+    }
+    if (speaking) {
+      if (energy <= floor * c.enterRatio) {
+        noDipSince = frame.tSec;
+      } else if (noDipSince !== null && frame.tSec - noDipSince >= c.noiseRebaselineSec) {
+        floor = Math.max(energy, c.floorMin);
+        speaking = false;
+        subExitSince = null;
+        noDipSince = null;
+        enterStreak = 0;
+      }
+    }
+  }
+  return {
+    noiseFloor: floor,
+    speaking,
+    enterStreak,
+    subExitSince,
+    noDipSince,
+    warmupUntilSec: state.warmupUntilSec,
+    seeded: true,
+    lastTSec: frame.tSec
+  };
+}
+
+// src/narration/nuclei.ts
+function createNucleiState(_config) {
+  return {
+    env: 0,
+    prevEnv: 0,
+    prevPrevEnv: 0,
+    prevTSec: 0,
+    valley: Number.POSITIVE_INFINITY,
+    lastOnsetTSec: Number.NEGATIVE_INFINITY,
+    peakRef: 0,
+    lastTSec: 0,
+    framesSeen: 0
+  };
+}
+function nucleiStep(state, frame, speaking, config) {
+  const c = { ...DEFAULT_NUCLEI_CONFIG, ...config };
+  const amp = Math.sqrt(Math.max(0, frame.bandEnergy));
+  const dt = state.framesSeen > 0 ? Math.max(0, frame.tSec - state.lastTSec) : 0;
+  const env = state.framesSeen > 0 ? state.env + (amp - state.env) * (1 - Math.exp(-2 * Math.PI * c.envelopeHz * dt)) : amp;
+  const peakRef = Math.max(env, state.peakRef * Math.exp(-(dt || 0) / c.peakRefTauSec));
+  let onset = null;
+  let valley = state.framesSeen > 0 ? state.valley : env;
+  let lastOnsetTSec = state.lastOnsetTSec;
+  if (state.framesSeen >= 2 && state.prevEnv >= state.prevPrevEnv && state.prevEnv > env && speaking && state.prevTSec - lastOnsetTSec >= c.minInterOnsetMs / 1e3 && state.prevEnv >= valley * c.prominenceRatio && state.prevEnv >= peakRef * c.minRelPeak) {
+    onset = state.prevTSec;
+    lastOnsetTSec = state.prevTSec;
+    valley = state.prevEnv;
+  }
+  valley = Math.min(valley, env);
+  return {
+    state: {
+      env,
+      prevEnv: env,
+      prevPrevEnv: state.framesSeen > 0 ? state.prevEnv : env,
+      prevTSec: frame.tSec,
+      valley,
+      lastOnsetTSec,
+      peakRef,
+      lastTSec: frame.tSec,
+      framesSeen: state.framesSeen + 1
+    },
+    onset
+  };
+}
+function detectSyllableOnsets(frames, vadFlags, config) {
+  let state = createNucleiState(config);
+  const onsets = [];
+  for (let i = 0; i < frames.length; i++) {
+    const step = nucleiStep(state, frames[i], vadFlags[i] ?? false, config);
+    state = step.state;
+    if (step.onset !== null) onsets.push(step.onset);
+  }
+  return onsets;
+}
+
+// src/narration/pacing.ts
+function createPacingState(startWordPos = 0) {
+  return {
+    wordPos: startWordPos,
+    velocityWps: 0,
+    emaSylPerSec: 0,
+    lastOnsetTSec: null,
+    cumDetectedSyl: 0,
+    anchorExpectedSyl: 0,
+    errIntegral: 0,
+    silenceSec: 0,
+    lastTSec: null,
+    halted: true
+  };
+}
+function clamp(value, min, max) {
+  return value < min ? min : value > max ? max : value;
+}
+function localSyllablesPerWord(script, wordPos, windowWords) {
+  const n = script.tokens.length;
+  if (n === 0) return 1.4;
+  const start = clamp(Math.floor(wordPos), 0, n - 1);
+  let sum = 0;
+  let count = 0;
+  for (let i = start; i < n && count < windowWords; i++) {
+    if (!script.tokens[i].spoken) continue;
+    sum += script.tokens[i].syllables;
+    count += 1;
+  }
+  return count > 0 ? Math.max(1, sum / count) : 1.4;
+}
+function pacingStep(state, tick, script, config) {
+  const c = { ...DEFAULT_PACING_CONFIG, ...config };
+  const baseWps = c.baseWpm / 60;
+  const dt = clamp(tick.tSec - (state.lastTSec ?? tick.tSec), 0, 0.25);
+  let emaSylPerSec = state.emaSylPerSec;
+  let lastOnsetTSec = state.lastOnsetTSec;
+  let cumDetectedSyl = state.cumDetectedSyl;
+  for (let k = 0; k < tick.onsets; k++) {
+    if (lastOnsetTSec !== null) {
+      const ioi = tick.tSec - lastOnsetTSec;
+      if (ioi > 0) {
+        const instRate = clamp(1 / ioi, 0.5, 12);
+        const alpha = 1 - Math.exp(-ioi / c.rateEmaTauSec);
+        emaSylPerSec = emaSylPerSec === 0 ? instRate : emaSylPerSec + (instRate - emaSylPerSec) * alpha;
+      }
+    }
+    lastOnsetTSec = tick.tSec;
+    cumDetectedSyl += 1;
+  }
+  const sylPerWordLocal = localSyllablesPerWord(script, state.wordPos, c.sylWindowWords);
+  const voiceWps = emaSylPerSec > 0 ? emaSylPerSec / sylPerWordLocal : baseWps;
+  const cruise = clamp(
+    c.voiceBlend * voiceWps + (1 - c.voiceBlend) * baseWps,
+    baseWps * c.minRateMult,
+    baseWps * c.maxRateMult
+  );
+  const err = expectedSyllablesAt(script, state.wordPos) - (state.anchorExpectedSyl + cumDetectedSyl);
+  let errIntegral = clamp(Math.min(0, state.errIntegral + err * dt), -c.intClamp, 0);
+  const boost = err < 0 ? clamp(c.kP * -err + c.kI * -errIntegral, 0, c.maxCorrection) : 0;
+  let velocityWps = state.velocityWps;
+  let silenceSec = state.silenceSec;
+  if (tick.speaking) {
+    silenceSec = 0;
+    const target = Math.max(0, cruise * (1 + boost));
+    velocityWps += (target - velocityWps) * (1 - Math.exp(-dt / c.velSlewTauSec));
+  } else {
+    silenceSec += dt;
+    velocityWps *= Math.exp(-dt / c.haltTauSec);
+    if (velocityWps < 0.02) velocityWps = 0;
+  }
+  let wordPos = state.wordPos;
+  if (err < -c.resyncSyllables) {
+    wordPos = Math.max(
+      wordPos,
+      wordPosAtExpectedSyllables(script, state.anchorExpectedSyl + cumDetectedSyl)
+    );
+    errIntegral = 0;
+  }
+  wordPos = clamp(wordPos + velocityWps * dt, 0, script.tokens.length);
+  return {
+    wordPos,
+    velocityWps,
+    emaSylPerSec,
+    lastOnsetTSec,
+    cumDetectedSyl,
+    anchorExpectedSyl: state.anchorExpectedSyl,
+    errIntegral,
+    silenceSec,
+    lastTSec: tick.tSec,
+    halted: !tick.speaking && velocityWps === 0
+  };
+}
+function reanchorPacing(state, wordPos, script) {
+  const pos = clamp(wordPos, 0, script.tokens.length);
+  return {
+    ...state,
+    wordPos: pos,
+    anchorExpectedSyl: expectedSyllablesAt(script, pos),
+    cumDetectedSyl: 0,
+    errIntegral: 0
+  };
+}
+
+// src/narration/session.ts
+function createNarrationSession(sampleRate, script, config) {
+  const merged = config ?? {};
+  return {
+    script,
+    config: merged,
+    features: createFeatureState(sampleRate, merged.feature),
+    vad: createVadState(merged.vad),
+    nuclei: createNucleiState(merged.nuclei),
+    pacing: createPacingState(0),
+    lastFrame: null,
+    tSec: 0
+  };
+}
+function narrationSessionStep(state, hop) {
+  const { state: features, frames } = featureStep(state.features, hop);
+  let vad = state.vad;
+  let nuclei = state.nuclei;
+  let pacing = state.pacing;
+  let lastFrame = state.lastFrame;
+  for (const frame of frames) {
+    vad = vadStep(vad, frame, state.config.vad);
+    const nucleiResult = nucleiStep(nuclei, frame, vad.speaking, state.config.nuclei);
+    nuclei = nucleiResult.state;
+    pacing = pacingStep(
+      pacing,
+      { tSec: frame.tSec, speaking: vad.speaking, onsets: nucleiResult.onset !== null ? 1 : 0 },
+      state.script,
+      state.config.pacing
+    );
+    lastFrame = frame;
+  }
+  return {
+    ...state,
+    features,
+    vad,
+    nuclei,
+    pacing,
+    lastFrame,
+    tSec: state.tSec + hop.length / state.features.sampleRate
+  };
+}
+function reanchorSession(state, wordPos) {
+  return { ...state, pacing: reanchorPacing(state.pacing, wordPos, state.script) };
+}
+
+// src/narration/trace.ts
+function traceWordPosAt(trace, tSec) {
+  const samples = trace.samples;
+  if (samples.length === 0) return 0;
+  const tMs = tSec * 1e3;
+  if (tMs <= samples[0].tMs) return samples[0].wordPos;
+  const last = samples[samples.length - 1];
+  if (tMs >= last.tMs) return last.wordPos;
+  let lo = 0;
+  let hi = samples.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (samples[mid].tMs <= tMs) lo = mid;
+    else hi = mid - 1;
+  }
+  const a = samples[lo];
+  const b = samples[lo + 1];
+  const span = b.tMs - a.tMs;
+  if (span <= 0) return a.wordPos;
+  return a.wordPos + (tMs - a.tMs) / span * (b.wordPos - a.wordPos);
+}
+function downsampleTrace(trace, maxSamples) {
+  const samples = trace.samples;
+  if (maxSamples < 2 || samples.length <= maxSamples) return { samples: samples.slice() };
+  const out = [];
+  const stride = (samples.length - 1) / (maxSamples - 1);
+  for (let i = 0; i < maxSamples; i++) {
+    out.push(samples[Math.round(i * stride)]);
+  }
+  return { samples: out };
+}
+
+// src/narration/align.ts
+var MAX_BAND_RADIUS_SEC = 60;
+function alignNarration(input, config) {
+  const c = { ...DEFAULT_ALIGN_CONFIG, ...config };
+  const { pcm, sampleRate, script } = input;
+  const takeDuration = pcm.length / Math.max(1, sampleRate);
+  if (script.tokens.length === 0 || takeDuration <= 0) {
+    return { words: [], blocks: [], detectedSyllables: 0, cost: 0 };
+  }
+  const frames = extractFrameFeatures(pcm, sampleRate, { hopSec: c.hopSec });
+  const vadFlags = runVad(frames);
+  const onsets = detectSyllableOnsets(frames, vadFlags);
+  const gaps = findSilenceGaps(frames, vadFlags, c.gapMinSec);
+  const lastSpeechEnd = findLastSpeechEnd(frames, vadFlags);
+  if (onsets.length === 0) {
+    return proportionalAlignment(
+      script,
+      lastSpeechEnd > 0 ? lastSpeechEnd : takeDuration,
+      takeDuration,
+      c,
+      0
+    );
+  }
+  const events = [
+    ...onsets.map((t) => ({ kind: "syl", tSec: t, startSec: t, endSec: t })),
+    ...gaps
+  ].sort((a, b) => a.tSec - b.tSec);
+  const bandRadius = Math.min(
+    MAX_BAND_RADIUS_SEC,
+    input.trace && input.trace.samples.length >= 2 ? c.bandRadiusSec : Math.max(c.bandRadiusNoTraceSec, 0.1 * takeDuration)
+  );
+  const slots = buildExpectedSlots(script, takeDuration, input.trace);
+  const { matchedEventBySlot, cost } = bandedDtw(slots, events, bandRadius, c);
+  const words = deriveWordTimings(script, slots, events, matchedEventBySlot);
+  const blocks = deriveBlockRanges(script, words, gaps, takeDuration, lastSpeechEnd, c);
+  return { words, blocks, detectedSyllables: onsets.length, cost };
+}
+function runVad(frames) {
+  let vad = createVadState();
+  const flags = new Array(frames.length);
+  for (let i = 0; i < frames.length; i++) {
+    vad = vadStep(vad, frames[i]);
+    flags[i] = vad.speaking;
+  }
+  return flags;
+}
+function findSilenceGaps(frames, vadFlags, gapMinSec) {
+  const gaps = [];
+  let runStart = -1;
+  for (let i = 0; i <= frames.length; i++) {
+    const silent = i < frames.length ? !vadFlags[i] : false;
+    if (silent && runStart === -1) {
+      runStart = i;
+    } else if (!silent && runStart !== -1) {
+      const startSec = frames[runStart].tSec;
+      const endSec = frames[i - 1].tSec;
+      if (endSec - startSec >= gapMinSec) {
+        gaps.push({ kind: "gap", tSec: (startSec + endSec) / 2, startSec, endSec });
+      }
+      runStart = -1;
+    }
+  }
+  return gaps;
+}
+function findLastSpeechEnd(frames, vadFlags) {
+  for (let i = frames.length - 1; i >= 0; i--) {
+    if (vadFlags[i]) return frames[i].tSec;
+  }
+  return 0;
+}
+function buildExpectedSlots(script, takeDuration, trace) {
+  const slots = [];
+  for (let k = 0; k < script.tokens.length; k++) {
+    const token = script.tokens[k];
+    for (let s = 0; s < token.syllables; s++) {
+      slots.push({ kind: "syl", tokenIndex: k, slotIndex: s, priorSec: 0 });
+    }
+    if (token.pauseAfter >= 2) {
+      slots.push({ kind: "pause", tokenIndex: k, slotIndex: -1, priorSec: 0 });
+    }
+  }
+  const useTrace = trace !== void 0 && trace.samples.length >= 2;
+  if (useTrace) {
+    assignTracePriors(slots, script, trace, takeDuration);
+  } else {
+    const total = Math.max(1, script.totalSyllables);
+    for (const slot of slots) {
+      const cumBefore = slot.kind === "pause" ? script.cumulativeSyllables[slot.tokenIndex + 1] : script.cumulativeSyllables[slot.tokenIndex] + slot.slotIndex;
+      slot.priorSec = cumBefore / total * takeDuration;
+    }
+  }
+  let prev = 0;
+  for (const slot of slots) {
+    if (slot.priorSec < prev) slot.priorSec = prev;
+    if (slot.priorSec > takeDuration) slot.priorSec = takeDuration;
+    prev = slot.priorSec;
+  }
+  return slots;
+}
+function assignTracePriors(slots, script, trace, takeDuration) {
+  const times = [];
+  const positions = [];
+  let runningMax = 0;
+  for (const sample of trace.samples) {
+    runningMax = Math.max(runningMax, sample.wordPos);
+    times.push(sample.tMs / 1e3);
+    positions.push(runningMax);
+  }
+  let ptr = 0;
+  for (const slot of slots) {
+    const token = script.tokens[slot.tokenIndex];
+    const target = slot.kind === "pause" ? slot.tokenIndex + 1 : slot.tokenIndex + slot.slotIndex / Math.max(1, token.syllables);
+    while (ptr < positions.length - 1 && positions[ptr + 1] < target) ptr++;
+    let t;
+    if (positions[ptr] >= target) {
+      t = times[ptr];
+    } else if (ptr >= positions.length - 1) {
+      t = times[times.length - 1];
+    } else {
+      const span = positions[ptr + 1] - positions[ptr];
+      const frac = span > 0 ? (target - positions[ptr]) / span : 0;
+      t = times[ptr] + frac * (times[ptr + 1] - times[ptr]);
+    }
+    slot.priorSec = Math.min(Math.max(0, t), takeDuration);
+  }
+}
+function matchCost(slot, event, bandRadius, c) {
+  if (slot.kind === "syl") {
+    if (event.kind === "syl") {
+      return c.matchTimeWeight * Math.abs(event.tSec - slot.priorSec) / Math.max(1e-6, bandRadius);
+    }
+    return c.sylToGapCost;
+  }
+  return event.kind === "gap" ? 0 : c.pauseToSylCost;
+}
+function bandedDtw(slots, events, bandRadius, c) {
+  const N = slots.length;
+  const M = events.length;
+  const INF = Number.POSITIVE_INFINITY;
+  const eventTimes = events.map((e) => e.tSec);
+  const lo = new Int32Array(N + 1);
+  const hi = new Int32Array(N + 1);
+  for (let i2 = 1; i2 <= N; i2++) {
+    const prior = slots[i2 - 1].priorSec;
+    lo[i2] = lowerBound(eventTimes, prior - bandRadius);
+    hi[i2] = upperBound(eventTimes, prior + bandRadius);
+  }
+  lo[0] = 0;
+  hi[0] = N >= 1 ? hi[1] : M;
+  for (let i2 = 1; i2 <= N; i2++) {
+    if (lo[i2] < lo[i2 - 1]) lo[i2] = lo[i2 - 1];
+    if (lo[i2] > hi[i2 - 1] + 1) lo[i2] = hi[i2 - 1] + 1;
+    if (lo[i2] > M) lo[i2] = M;
+    if (hi[i2] < hi[i2 - 1]) hi[i2] = hi[i2 - 1];
+    if (hi[i2] < lo[i2]) hi[i2] = lo[i2];
+    if (hi[i2] > M) hi[i2] = M;
+  }
+  hi[N] = M;
+  if (lo[N] > M) lo[N] = M;
+  const ptrRows = new Array(N + 1);
+  let prevCost = new Float64Array(hi[0] - lo[0] + 1);
+  {
+    const row = new Uint8Array(hi[0] - lo[0] + 1);
+    for (let j2 = lo[0]; j2 <= hi[0]; j2++) {
+      prevCost[j2 - lo[0]] = j2 * c.insertCost;
+      row[j2 - lo[0]] = 2;
+    }
+    ptrRows[0] = row;
+  }
+  for (let i2 = 1; i2 <= N; i2++) {
+    const width = hi[i2] - lo[i2] + 1;
+    const cost = new Float64Array(width).fill(INF);
+    const ptr = new Uint8Array(width);
+    const slot = slots[i2 - 1];
+    for (let j2 = lo[i2]; j2 <= hi[i2]; j2++) {
+      const idx = j2 - lo[i2];
+      let best = INF;
+      let bestPtr = 1;
+      if (j2 >= 1 && j2 - 1 >= lo[i2 - 1] && j2 - 1 <= hi[i2 - 1]) {
+        const v = prevCost[j2 - 1 - lo[i2 - 1]] + matchCost(slot, events[j2 - 1], bandRadius, c);
+        if (v < best) {
+          best = v;
+          bestPtr = 0;
+        }
+      }
+      if (j2 >= lo[i2 - 1] && j2 <= hi[i2 - 1]) {
+        const v = prevCost[j2 - lo[i2 - 1]] + c.deleteCost;
+        if (v < best) {
+          best = v;
+          bestPtr = 1;
+        }
+      }
+      if (j2 - 1 >= lo[i2]) {
+        const v = cost[idx - 1] + c.insertCost;
+        if (v < best) {
+          best = v;
+          bestPtr = 2;
+        }
+      }
+      cost[idx] = best;
+      ptr[idx] = bestPtr;
+    }
+    ptrRows[i2] = ptr;
+    prevCost = cost;
+  }
+  const matchedEventBySlot = new Int32Array(N).fill(-1);
+  let i = N;
+  let j = M;
+  const finalCost = prevCost[M - lo[N]] ?? 0;
+  while (i > 0 || j > 0) {
+    const row = ptrRows[i];
+    const idx = j - lo[i];
+    const move = idx >= 0 && idx < row.length ? row[idx] : i > 0 ? 1 : 2;
+    if (move === 0 && i > 0 && j > 0) {
+      matchedEventBySlot[i - 1] = j - 1;
+      i--;
+      j--;
+    } else if (move === 1 && i > 0) {
+      i--;
+    } else if (j > 0) {
+      j--;
+    } else if (i > 0) {
+      i--;
+    } else {
+      break;
+    }
+  }
+  return { matchedEventBySlot, cost: Number.isFinite(finalCost) ? finalCost : 0 };
+}
+function lowerBound(values, target) {
+  let lo = 0;
+  let hi = values.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (values[mid] < target) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function upperBound(values, target) {
+  let lo = 0;
+  let hi = values.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (values[mid] <= target) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function deriveWordTimings(script, slots, events, matchedEventBySlot) {
+  const n = script.tokens.length;
+  const raw = new Array(n);
+  for (let s = 0; s < slots.length; s++) {
+    const eventIdx = matchedEventBySlot[s];
+    if (eventIdx < 0) continue;
+    const slot = slots[s];
+    if (slot.kind !== "syl") continue;
+    if (raw[slot.tokenIndex] !== void 0) continue;
+    const event = events[eventIdx];
+    raw[slot.tokenIndex] = event.kind === "gap" ? event.endSec : event.tSec;
+  }
+  const words = new Array(n);
+  let prevKnownIdx = -1;
+  let prevKnownT = 0;
+  for (let k = 0; k < n; k++) {
+    if (raw[k] === void 0) continue;
+    const t = raw[k];
+    for (let u = prevKnownIdx + 1; u < k; u++) {
+      const frac = (u - prevKnownIdx) / (k - prevKnownIdx);
+      const base = prevKnownIdx >= 0 ? prevKnownT : t;
+      words[u] = {
+        tokenIndex: u,
+        tSec: base + (t - base) * (prevKnownIdx >= 0 ? frac : 0),
+        interpolated: true
+      };
+    }
+    words[k] = { tokenIndex: k, tSec: t, interpolated: false };
+    prevKnownIdx = k;
+    prevKnownT = t;
+  }
+  for (let u = prevKnownIdx + 1; u < n; u++) {
+    words[u] = { tokenIndex: u, tSec: prevKnownT, interpolated: true };
+  }
+  if (prevKnownIdx === -1) {
+    for (let u = 0; u < n; u++) words[u] = { tokenIndex: u, tSec: 0, interpolated: true };
+  }
+  let running = 0;
+  for (const w of words) {
+    running = Math.max(running, w.tSec);
+    w.tSec = running;
+  }
+  return words;
+}
+function deriveBlockRanges(script, words, gaps, takeDuration, lastSpeechEnd, c) {
+  const blocks = [];
+  const gapEnds = gaps.map((g) => g.endSec);
+  let prevStart = 0;
+  for (let b = 0; b < script.blocks.length; b++) {
+    const range = script.blocks[b];
+    const firstWord = words[range.tokenStart];
+    let startSec = b === 0 ? 0 : firstWord?.tSec ?? prevStart;
+    if (b > 0) {
+      const idx = upperBound(gapEnds, startSec) - 1;
+      if (idx >= 0 && startSec - gapEnds[idx] <= c.blockSnapWindowSec && gapEnds[idx] > prevStart) {
+        startSec = gapEnds[idx];
+      }
+      if (startSec < prevStart) startSec = prevStart;
+    }
+    blocks.push({
+      blockId: range.blockId,
+      ...range.heading !== void 0 ? { heading: range.heading } : {},
+      blockIndex: b,
+      charStart: range.charStart,
+      charEnd: range.charEnd,
+      startSec,
+      endSec: startSec
+    });
+    prevStart = startSec;
+  }
+  for (let b = 0; b < blocks.length - 1; b++) {
+    blocks[b].endSec = blocks[b + 1].startSec;
+  }
+  if (blocks.length > 0) {
+    const last = blocks[blocks.length - 1];
+    let end = Math.min(
+      takeDuration,
+      (lastSpeechEnd > 0 ? lastSpeechEnd : takeDuration) + c.tailPadSec
+    );
+    if (takeDuration - end <= 1) end = takeDuration;
+    last.endSec = Math.max(last.startSec, end);
+  }
+  return blocks;
+}
+function proportionalAlignment(script, effectiveDuration, takeDuration, c, detectedSyllables) {
+  const total = Math.max(1, script.totalSyllables);
+  const words = script.tokens.map((_, k) => ({
+    tokenIndex: k,
+    tSec: script.cumulativeSyllables[k] / total * effectiveDuration,
+    interpolated: true
+  }));
+  const blocks = deriveBlockRanges(script, words, [], takeDuration, effectiveDuration, c);
+  return { words, blocks, detectedSyllables, cost: 0 };
+}
+
+export {
+  DEFAULT_FEATURE_CONFIG,
+  DEFAULT_VAD_CONFIG,
+  DEFAULT_NUCLEI_CONFIG,
+  DEFAULT_PACING_CONFIG,
+  DEFAULT_ALIGN_CONFIG,
+  createBandpass,
+  bandpassRun,
+  createFeatureState,
+  featureStep,
+  extractFrameFeatures,
+  createVadState,
+  vadStep,
+  createNucleiState,
+  nucleiStep,
+  detectSyllableOnsets,
+  createPacingState,
+  pacingStep,
+  reanchorPacing,
+  createNarrationSession,
+  narrationSessionStep,
+  reanchorSession,
+  traceWordPosAt,
+  downsampleTrace,
+  alignNarration
+};
+//# sourceMappingURL=chunk-T3TI7GSZ.js.map