@bendyline/squisq 2.0.1 → 2.2.0

package/dist/chunk-CY2R2VPR.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/narration/types.ts","../src/narration/features.ts","../src/narration/vad.ts","../src/narration/nuclei.ts","../src/narration/pacing.ts","../src/narration/session.ts","../src/narration/trace.ts","../src/narration/align.ts"],"sourcesContent":["/**\n * Shared types + tuning configs for the narration engine.\n *\n * The engine is pure TypeScript with zero dependencies and no DOM/Node\n * APIs: audio arrives as mono `Float32Array` PCM (the editor decodes\n * WebM/MP4 on its side), and every stage is a deterministic step\n * function `(state, input, config) → state` so the whole pipeline is\n * unit-testable in Node with synthetic signals. No `Date.now`, no\n * `Math.random`, no timers anywhere in this module.\n */\n\n/** One word of the teleprompter script, positioned inside {@link NarrationScript.sourceText}. */\nexport interface ScriptToken {\n  /** The word as displayed (no surrounding whitespace). */\n  text: string;\n  /** Start offset into {@link NarrationScript.sourceText}. */\n  charOffset: number;\n  /** Exclusive end offset into {@link NarrationScript.sourceText}. */\n  charEnd: number;\n  /** Id of the doc block this word belongs to. */\n  blockId: string;\n  /** Index into {@link NarrationScript.blocks}. */\n  blockIndex: number;\n  /** Estimated syllable count (≥ 1 for spoken tokens; 0 when `spoken` is false). */\n  syllables: number;\n  /** Spoken-word equivalents (numbers count as several words; 0 when not spoken). */\n  spokenWordEquiv: number;\n  /**\n   * Pause class after this token:\n   * 0 none · 1 clause/sentence punctuation · 2 paragraph break · 3 block boundary.\n   */\n  pauseAfter: 0 | 1 | 2 | 3;\n  /**\n   * Whether this token is actually spoken. Standalone punctuation runs —\n   * an em-dash, a lone bullet, `···` — tokenize on whitespace like words\n   * but carry no letters or digits: they DISPLAY in the prompter yet must\n   * never be the highlighted active word, are never paused on, and add no\n   * syllables to the pacing/alignment model.\n   */\n  spoken: boolean;\n}\n\n/** The token/char span of one doc block inside the script. */\nexport interface ScriptBlockRange {\n  blockId: string;\n  /** The block's heading text, when present. */\n  heading?: string;\n  /** Inclusive index into {@link NarrationScript.tokens}. */\n  tokenStart: number;\n  /** Exclusive index into {@link NarrationScript.tokens}. */\n  tokenEnd: number;\n  /** Start offset into {@link NarrationScript.sourceText} (includes the spoken title). */\n  charStart: number;\n  /** Exclusive end offset into {@link NarrationScript.sourceText}. */\n  charEnd: number;\n}\n\n/**\n * The teleprompter script derived from a Doc. `sourceText` is canonical:\n * it is stored verbatim in the timing sidecar, and every `charOffset`\n * indexes into it. Building is deterministic — the same Doc always\n * yields a byte-identical script.\n */\nexport interface NarrationScript {\n  sourceText: string;\n  tokens: ScriptToken[];\n  blocks: ScriptBlockRange[];\n  totalSyllables: number;\n  /**\n   * Prefix sums: `cumulativeSyllables[i]` = syllables of `tokens[0..i-1]`.\n   * Length is `tokens.length + 1`.\n   */\n  cumulativeSyllables: number[];\n}\n\n/** Per-frame acoustic features extracted from PCM. */\nexport interface FrameFeatures {\n  /** Frame CENTER time in seconds from the start of the signal. */\n  tSec: number;\n  /** Full-band root-mean-square of the frame. */\n  rms: number;\n  /** Mean square of the 250–3000 Hz bandpassed frame (speech band energy). */\n  bandEnergy: number;\n  /** Zero crossings / (frameLength − 1), in [0, 1]. */\n  zcr: number;\n}\n\n// ── Configs ──────────────────────────────────────────────────────────\n\nexport interface FeatureConfig {\n  /** Analysis frame length in samples (~21 ms @ 48 kHz). */\n  frameSize: number;\n  /** Hop between frame starts in seconds (live 0.02; the aligner uses 0.01). */\n  hopSec: number;\n  /** Bandpass high-pass corner (Hz). */\n  bandLowHz: number;\n  /** Bandpass low-pass corner (Hz). */\n  bandHighHz: number;\n}\n\nexport const DEFAULT_FEATURE_CONFIG: FeatureConfig = Object.freeze({\n  frameSize: 1024,\n  hopSec: 0.02,\n  bandLowHz: 250,\n  bandHighHz: 3000,\n});\n\nexport interface VadConfig {\n  /** Floor-seeding period before any speech decision (ms). */\n  warmupMs: number;\n  /** Floor attack toward minima (per-frame EMA alpha when energy < floor). */\n  alphaDown: number;\n  /** Floor release (per-frame EMA alpha when energy ≥ floor; frozen while speaking). */\n  alphaUp: number;\n  /** Enter speech when energy > floor × enterRatio for enterFrames frames. */\n  enterRatio: number;\n  /**\n   * Exit hysteresis: sub-exit frames only count once energy < floor ×\n   * exitRatio. The floor is a LOW-percentile tracker, so steady room\n   * noise runs ~1.8–2.3× above it — exitRatio must sit above that band\n   * (and below enterRatio) or silence never registers.\n   */\n  exitRatio: number;\n  /** Consecutive supra-enter frames required to enter speech. */\n  enterFrames: number;\n  /** Sub-exit dwell required to leave speech (ms). */\n  hangoverMs: number;\n  /**\n   * Dip-starved rebaseline: real speech dips below enterRatio × floor\n   * between syllables; a \"speech\" that stays strongly above the floor\n   * for this long with zero dips is a shifted noise floor — adopt it\n   * and exit. Guards against a step change in room noise wedging the\n   * VAD open forever (the floor is otherwise frozen while speaking).\n   */\n  noiseRebaselineSec: number;\n  /** Absolute floor clamp guarding digital silence. */\n  floorMin: number;\n}\n\nexport const DEFAULT_VAD_CONFIG: VadConfig = Object.freeze({\n  warmupMs: 200,\n  alphaDown: 0.3,\n  alphaUp: 0.005,\n  enterRatio: 3.0,\n  exitRatio: 2.5,\n  enterFrames: 2,\n  hangoverMs: 300,\n  noiseRebaselineSec: 1.5,\n  floorMin: 1e-9,\n});\n\nexport interface NucleiConfig {\n  /** One-pole low-pass cutoff for the amplitude envelope (Hz). */\n  envelopeHz: number;\n  /** Minimum spacing between accepted syllable onsets (ms) — caps ~8.3 syl/s. */\n  minInterOnsetMs: number;\n  /** Peak must exceed valley-since-last-peak × this ratio. */\n  prominenceRatio: number;\n  /** Peak must exceed the decaying loudness reference × this fraction. */\n  minRelPeak: number;\n  /** Decay time constant of the loudness reference (s). */\n  peakRefTauSec: number;\n}\n\nexport const DEFAULT_NUCLEI_CONFIG: NucleiConfig = Object.freeze({\n  // Continuous reading blurs adjacent syllables together: a 10 Hz envelope\n  // over-smooths 5–7 Hz syllable structure and a 1.6× prominence gate\n  // rejects the shallow dips between connected syllables — both cause the\n  // detector to UNDER-count, which makes the prompter lag. A higher\n  // envelope cutoff preserves per-syllable peaks and a gentler prominence\n  // gate accepts them; the min-spacing gate still rejects true doublets.\n  envelopeHz: 16,\n  minInterOnsetMs: 110,\n  prominenceRatio: 1.3,\n  minRelPeak: 0.1,\n  peakRefTauSec: 3.0,\n});\n\nexport interface PacingConfig {\n  /** The user's base speaking rate (words per minute). */\n  baseWpm: number;\n  /**\n   * How strongly the detected voice rate steers the cruise velocity vs.\n   * the user's set pace, in [0, 1]. The speaking-cruise velocity is\n   * `voiceBlend·voiceRate + (1 − voiceBlend)·baseRate`, so the WPM slider\n   * is ALWAYS felt (it never fully cancels) and an under-counting detector\n   * can't drag the prompter to a crawl. 1 = pure voice-follow (the old\n   * behavior, where WPM only mattered at the clamps); 0 = ignore the voice.\n   */\n  voiceBlend: number;\n  /** Clamp on the cruise velocity as a fraction of the set pace. */\n  minRateMult: number;\n  maxRateMult: number;\n  /** EMA time constant for the detected syllable rate (s). */\n  rateEmaTauSec: number;\n  /** Velocity slew time constant while speaking (s). */\n  velSlewTauSec: number;\n  /** Velocity decay time constant in silence (s) — halted within ~250 ms. */\n  haltTauSec: number;\n  /** Proportional gain of the forward-only catch-up boost (per syllable behind). */\n  kP: number;\n  /** Integral gain of the forward-only boost (per syllable·second behind). */\n  kI: number;\n  /** Anti-windup clamp on the (≤ 0) behind-error integral (syllable·seconds). */\n  intClamp: number;\n  /** Max fraction the catch-up boost may ADD to the cruise velocity. */\n  maxCorrection: number;\n  /** Window (words ahead) used for the local expected syllables-per-word. */\n  sylWindowWords: number;\n  /** Reader-ahead error beyond this hard-resyncs the prompter FORWARD. */\n  resyncSyllables: number;\n}\n\nexport const DEFAULT_PACING_CONFIG: PacingConfig = Object.freeze({\n  baseWpm: 150,\n  voiceBlend: 0.6,\n  minRateMult: 0.5,\n  maxRateMult: 3.0,\n  rateEmaTauSec: 0.7,\n  velSlewTauSec: 0.15,\n  haltTauSec: 0.085,\n  kP: 0.14,\n  kI: 0.02,\n  intClamp: 4,\n  maxCorrection: 0.6,\n  sylWindowWords: 8,\n  resyncSyllables: 8,\n});\n\nexport interface AlignConfig {\n  /** Fine analysis hop for the offline pass (s). */\n  hopSec: number;\n  /** Non-speech runs at least this long become GAP events (s). */\n  gapMinSec: number;\n  /** Sakoe-Chiba band half-width around the live-trace prior (s). */\n  bandRadiusSec: number;\n  /** Band half-width when no trace exists (s); also floored at 10% of take length. */\n  bandRadiusNoTraceSec: number;\n  /** Cost weight for |Δt| on syllable↔syllable matches (normalized by band radius). */\n  matchTimeWeight: number;\n  /** Cost of matching an expected pause slot to a detected syllable (reader didn't pause). */\n  pauseToSylCost: number;\n  /** Cost of matching an expected syllable slot to a detected gap (mid-sentence hesitation). */\n  sylToGapCost: number;\n  /** Cost of skipping an expected slot (merged/unspoken syllable). */\n  deleteCost: number;\n  /** Cost of skipping a detected event (filler word, breath, click). */\n  insertCost: number;\n  /** Snap a block start to a silence-gap end within this window before it (s). */\n  blockSnapWindowSec: number;\n  /** Padding after the last speech for the final block's end (s). */\n  tailPadSec: number;\n}\n\nexport const DEFAULT_ALIGN_CONFIG: AlignConfig = Object.freeze({\n  hopSec: 0.01,\n  gapMinSec: 0.35,\n  bandRadiusSec: 1.5,\n  bandRadiusNoTraceSec: 3,\n  matchTimeWeight: 1.0,\n  pauseToSylCost: 2.0,\n  sylToGapCost: 1.5,\n  deleteCost: 0.8,\n  insertCost: 0.8,\n  blockSnapWindowSec: 0.8,\n  tailPadSec: 0.4,\n});\n\n// ── Alignment outputs ────────────────────────────────────────────────\n\n/** Refined timestamp of one script token. */\nexport interface WordTiming {\n  tokenIndex: number;\n  /** Seconds into the take when the word begins. Monotonically non-decreasing. */\n  tSec: number;\n  /** True when this word had no matched syllable and was interpolated. */\n  interpolated: boolean;\n}\n\n/** Narration time range of one doc block. Ranges are CONTIGUOUS: endSec === next.startSec. */\nexport interface NarrationBlockRange {\n  blockId: string;\n  heading?: string;\n  blockIndex: number;\n  charStart: number;\n  charEnd: number;\n  startSec: number;\n  endSec: number;\n}\n\nexport interface NarrationAlignment {\n  /** One entry per script token, monotonic in time. */\n  words: WordTiming[];\n  blocks: NarrationBlockRange[];\n  /** Total syllable onsets detected in the take (diagnostics). */\n  detectedSyllables: number;\n  /** Total DTW path cost (diagnostics/QA). */\n  cost: number;\n}\n","/**\n * Frame feature extraction: full-band RMS, speech-band energy, and\n * zero-crossing rate over hopped (possibly overlapping) frames.\n *\n * Band energy uses two cascaded RBJ biquads — a high-pass at\n * `bandLowHz` and a low-pass at `bandHighHz` (both Q = 1/√2,\n * Audio-EQ-Cookbook closed forms) — rather than an FFT or Goertzel\n * bins: a Butterworth-ish cascade gives a true maximally-flat band in\n * one O(N) pass, and the filter state persists across hops, which is\n * exactly right for streaming (no window-boundary energy jitter).\n * Goertzel measures single frequencies (DTMF-style) — wrong tool for\n * broadband speech energy.\n */\n\nimport type { FeatureConfig, FrameFeatures } from './types.js';\nimport { DEFAULT_FEATURE_CONFIG } from './types.js';\n\ninterface BiquadCoeffs {\n  b0: number;\n  b1: number;\n  b2: number;\n  a1: number;\n  a2: number;\n}\n\ninterface BiquadState {\n  x1: number;\n  x2: number;\n  y1: number;\n  y2: number;\n}\n\nexport interface BandpassState {\n  coeffs: { hp: BiquadCoeffs; lp: BiquadCoeffs };\n  hp: BiquadState;\n  lp: BiquadState;\n}\n\nfunction highpassCoeffs(sampleRate: number, freqHz: number): BiquadCoeffs {\n  const w0 = (2 * Math.PI * freqHz) / sampleRate;\n  const cosW0 = Math.cos(w0);\n  // alpha = sin(w0) / (2Q) with Butterworth Q = 1/√2.\n  const alpha = Math.sin(w0) / (2 * Math.SQRT1_2);\n  const a0 = 1 + alpha;\n  return {\n    b0: (1 + cosW0) / 2 / a0,\n    b1: -(1 + cosW0) / a0,\n    b2: (1 + cosW0) / 2 / a0,\n    a1: (-2 * cosW0) / a0,\n    a2: (1 - alpha) / a0,\n  };\n}\n\nfunction lowpassCoeffs(sampleRate: number, freqHz: number): BiquadCoeffs {\n  const w0 = (2 * Math.PI * freqHz) / sampleRate;\n  const cosW0 = Math.cos(w0);\n  const alpha = Math.sin(w0) / (2 * Math.SQRT1_2);\n  const a0 = 1 + alpha;\n  return {\n    b0: (1 - cosW0) / 2 / a0,\n    b1: (1 - cosW0) / a0,\n    b2: (1 - cosW0) / 2 / a0,\n    a1: (-2 * cosW0) / a0,\n    a2: (1 - alpha) / a0,\n  };\n}\n\n/** Create bandpass state for a sample rate (corners derived at init). */\nexport function createBandpass(\n  sampleRate: number,\n  lowHz = DEFAULT_FEATURE_CONFIG.bandLowHz,\n  highHz = DEFAULT_FEATURE_CONFIG.bandHighHz,\n): BandpassState {\n  return {\n    coeffs: { hp: highpassCoeffs(sampleRate, lowHz), lp: lowpassCoeffs(sampleRate, highHz) },\n    hp: { x1: 0, x2: 0, y1: 0, y2: 0 },\n    lp: { x1: 0, x2: 0, y1: 0, y2: 0 },\n  };\n}\n\nfunction biquadRun(\n  coeffs: BiquadCoeffs,\n  state: BiquadState,\n  input: Float32Array,\n  output: Float32Array,\n): BiquadState {\n  let { x1, x2, y1, y2 } = state;\n  const { b0, b1, b2, a1, a2 } = coeffs;\n  for (let i = 0; i < input.length; i++) {\n    const x0 = input[i];\n    const y0 = b0 * x0 + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;\n    output[i] = y0;\n    x2 = x1;\n    x1 = x0;\n    y2 = y1;\n    y1 = y0;\n  }\n  return { x1, x2, y1, y2 };\n}\n\n/**\n * Run the bandpass over a chunk. Pure in the state: returns a NEW state,\n * writes filtered samples into `output` (may alias `input`).\n */\nexport function bandpassRun(\n  state: BandpassState,\n  input: Float32Array,\n  output: Float32Array,\n): BandpassState {\n  const hp = biquadRun(state.coeffs.hp, state.hp, input, output);\n  const lp = biquadRun(state.coeffs.lp, state.lp, output, output);\n  return { coeffs: state.coeffs, hp, lp };\n}\n\nexport interface FeatureState {\n  sampleRate: number;\n  config: FeatureConfig;\n  /** Hop between frame starts, in samples. */\n  hopSamples: number;\n  bandpass: BandpassState;\n  /** Unconsumed raw samples (the next frame's prefix). */\n  rawCarry: Float32Array;\n  /** Bandpassed twin of `rawCarry`. */\n  bandCarry: Float32Array;\n  /** Absolute sample index of `rawCarry[0]` from the start of the signal. */\n  carryStartSample: number;\n}\n\nexport function createFeatureState(\n  sampleRate: number,\n  config?: Partial<FeatureConfig>,\n): FeatureState {\n  const merged: FeatureConfig = { ...DEFAULT_FEATURE_CONFIG, ...config };\n  return {\n    sampleRate,\n    config: merged,\n    hopSamples: Math.max(1, Math.round(merged.hopSec * sampleRate)),\n    bandpass: createBandpass(sampleRate, merged.bandLowHz, merged.bandHighHz),\n    rawCarry: new Float32Array(0),\n    bandCarry: new Float32Array(0),\n    carryStartSample: 0,\n  };\n}\n\nfunction concatF32(a: Float32Array, b: Float32Array): Float32Array {\n  if (a.length === 0) return b;\n  const out = new Float32Array(a.length + b.length);\n  out.set(a, 0);\n  out.set(b, a.length);\n  return out;\n}\n\nfunction frameOf(\n  raw: Float32Array,\n  band: Float32Array,\n  start: number,\n  size: number,\n  startSample: number,\n  sampleRate: number,\n): FrameFeatures {\n  let sumSq = 0;\n  let bandSumSq = 0;\n  let crossings = 0;\n  let prev = raw[start];\n  for (let i = 0; i < size; i++) {\n    const r = raw[start + i];\n    const b = band[start + i];\n    sumSq += r * r;\n    bandSumSq += b * b;\n    if (i > 0 && ((r >= 0 && prev < 0) || (r < 0 && prev >= 0))) crossings++;\n    prev = r;\n  }\n  return {\n    tSec: (startSample + size / 2) / sampleRate,\n    rms: Math.sqrt(sumSq / size),\n    bandEnergy: bandSumSq / size,\n    zcr: size > 1 ? crossings / (size - 1) : 0,\n  };\n}\n\n/**\n * Feed a hop of PCM. Returns a new state plus every complete frame the\n * buffered signal now covers (usually 0–1 for worklet-sized hops, more\n * for large chunks).\n */\nexport function featureStep(\n  state: FeatureState,\n  hop: Float32Array,\n): { state: FeatureState; frames: FrameFeatures[] } {\n  const banded = new Float32Array(hop.length);\n  const bandpass = bandpassRun(state.bandpass, hop, banded);\n\n  const raw = concatF32(state.rawCarry, hop);\n  const band = concatF32(state.bandCarry, banded);\n  const { frameSize } = state.config;\n  const frames: FrameFeatures[] = [];\n\n  let cursor = 0;\n  while (raw.length - cursor >= frameSize) {\n    frames.push(\n      frameOf(raw, band, cursor, frameSize, state.carryStartSample + cursor, state.sampleRate),\n    );\n    cursor += state.hopSamples;\n  }\n\n  return {\n    state: {\n      ...state,\n      bandpass,\n      // slice(), not subarray(): the carry must OWN its memory. `raw` can\n      // alias the caller's hop buffer, and callers may recycle those\n      // (e.g. Chrome invalidates buffers transferred out of an\n      // AudioWorklet after the message handler returns) — a retained\n      // view would silently read zeros on the next step.\n      rawCarry: raw.slice(cursor),\n      bandCarry: band.slice(cursor),\n      carryStartSample: state.carryStartSample + cursor,\n    },\n    frames,\n  };\n}\n\n/** Batch feature extraction over a whole take (the aligner's entry point). */\nexport function extractFrameFeatures(\n  pcm: Float32Array,\n  sampleRate: number,\n  config?: Partial<FeatureConfig>,\n): FrameFeatures[] {\n  const state = createFeatureState(sampleRate, config);\n  return featureStep(state, pcm).frames;\n}\n","/**\n * Adaptive voice-activity detection over frame features.\n *\n * The noise floor is an asymmetric EMA of band energy that hugs minima\n * (≈ a 5th-percentile tracker): fast attack toward quieter frames, slow\n * release upward, and FROZEN upward while speaking so long speech can't\n * inflate it. Speech enters via a ratio threshold with a\n * consecutive-frame debounce and exits after a continuous sub-exit\n * dwell (hangover) — the hangover also bridges trailing fricatives and\n * inter-word dips. A dip-starved rebaseline escape keeps a step change\n * in room noise from wedging the detector open: real speech dips below\n * the enter threshold between syllables, steady noise never does.\n */\n\nimport type { FrameFeatures, VadConfig } from './types.js';\nimport { DEFAULT_VAD_CONFIG } from './types.js';\n\nexport interface VadState {\n  /** Adaptive noise-floor estimate (band-energy units). */\n  noiseFloor: number;\n  /** The VAD decision — the stage's output. */\n  speaking: boolean;\n  /** Consecutive supra-enter frames observed while silent. */\n  enterStreak: number;\n  /** tSec when the current sub-exit dwell began (while speaking), else null. */\n  subExitSince: number | null;\n  /** tSec when the current zero-dip run began (while speaking), else null. */\n  noDipSince: number | null;\n  /** No speech decisions before this time (floor seeding). */\n  warmupUntilSec: number;\n  /** False until the first frame seeds the floor. */\n  seeded: boolean;\n  lastTSec: number;\n}\n\nexport function createVadState(config?: Partial<VadConfig>): VadState {\n  const merged = { ...DEFAULT_VAD_CONFIG, ...config };\n  return {\n    noiseFloor: merged.floorMin,\n    speaking: false,\n    enterStreak: 0,\n    subExitSince: null,\n    noDipSince: null,\n    warmupUntilSec: merged.warmupMs / 1000,\n    seeded: false,\n    lastTSec: 0,\n  };\n}\n\n/** Pure per-frame step. `state.speaking` on the returned state is the decision for this frame. */\nexport function vadStep(\n  state: VadState,\n  frame: FrameFeatures,\n  config?: Partial<VadConfig>,\n): VadState {\n  const c = { ...DEFAULT_VAD_CONFIG, ...config };\n  const energy = Math.max(0, frame.bandEnergy);\n\n  let floor = state.seeded ? state.noiseFloor : Math.max(energy, c.floorMin);\n  if (state.seeded) {\n    if (!state.speaking) {\n      const alpha = energy < floor ? c.alphaDown : c.alphaUp;\n      floor += (energy - floor) * alpha;\n    } else if (energy < floor) {\n      // Downward adaptation stays safe while speaking; only upward is frozen.\n      floor += (energy - floor) * c.alphaDown;\n    }\n  }\n  if (floor < c.floorMin) floor = c.floorMin;\n\n  let speaking = state.speaking;\n  let enterStreak = state.enterStreak;\n  let subExitSince = state.subExitSince;\n  let noDipSince = state.noDipSince;\n\n  if (frame.tSec < state.warmupUntilSec) {\n    speaking = false;\n    enterStreak = 0;\n    subExitSince = null;\n    noDipSince = null;\n  } else if (!speaking) {\n    noDipSince = null;\n    if (energy > floor * c.enterRatio) {\n      enterStreak += 1;\n      if (enterStreak >= c.enterFrames) {\n        speaking = true;\n        subExitSince = null;\n        noDipSince = frame.tSec;\n      }\n    } else {\n      enterStreak = 0;\n    }\n  } else {\n    // Hangover: leave speech only after a continuous sub-exit dwell.\n    if (energy >= floor * c.exitRatio) {\n      subExitSince = null;\n    } else {\n      if (subExitSince === null) subExitSince = frame.tSec;\n      if (frame.tSec - subExitSince >= c.hangoverMs / 1000) {\n        speaking = false;\n        subExitSince = null;\n        noDipSince = null;\n        enterStreak = 0;\n      }\n    }\n    // Dip-starved rebaseline: a signal that never dips near the floor\n    // is a new noise floor, not speech.\n    if (speaking) {\n      if (energy <= floor * c.enterRatio) {\n        noDipSince = frame.tSec;\n      } else if (noDipSince !== null && frame.tSec - noDipSince >= c.noiseRebaselineSec) {\n        floor = Math.max(energy, c.floorMin);\n        speaking = false;\n        subExitSince = null;\n        noDipSince = null;\n        enterStreak = 0;\n      }\n    }\n  }\n\n  return {\n    noiseFloor: floor,\n    speaking,\n    enterStreak,\n    subExitSince,\n    noDipSince,\n    warmupUntilSec: state.warmupUntilSec,\n    seeded: true,\n    lastTSec: frame.tSec,\n  };\n}\n","/**\n * Syllable-nuclei detection: vowel nuclei show up as peaks in a\n * low-passed amplitude envelope of the speech-band signal.\n *\n * Envelope = one-pole low-pass (≈10 Hz) over √bandEnergy (amplitude\n * domain, so peaks are nuclei rather than energy spikes). A peak is\n * emitted one frame late (local-max needs one frame of lookahead —\n * ~20 ms live latency) and accepted only when: VAD says speaking, it\n * clears the minimum inter-onset spacing, it is prominent relative to\n * the valley since the last accepted peak, and it clears a decaying\n * loudness reference (guards against ripples inside quiet speech).\n */\n\nimport type { FrameFeatures, NucleiConfig } from './types.js';\nimport { DEFAULT_NUCLEI_CONFIG } from './types.js';\n\nexport interface NucleiState {\n  /** One-pole envelope of √bandEnergy. */\n  env: number;\n  prevEnv: number;\n  prevPrevEnv: number;\n  /** tSec of the previous frame (the peak-candidate time). */\n  prevTSec: number;\n  /** Envelope minimum since the last accepted peak. */\n  valley: number;\n  lastOnsetTSec: number;\n  /** Decaying loudness reference. */\n  peakRef: number;\n  lastTSec: number;\n  framesSeen: number;\n}\n\nexport function createNucleiState(_config?: Partial<NucleiConfig>): NucleiState {\n  return {\n    env: 0,\n    prevEnv: 0,\n    prevPrevEnv: 0,\n    prevTSec: 0,\n    valley: Number.POSITIVE_INFINITY,\n    lastOnsetTSec: Number.NEGATIVE_INFINITY,\n    peakRef: 0,\n    lastTSec: 0,\n    framesSeen: 0,\n  };\n}\n\n/**\n * Pure per-frame step. `onset` is the tSec of a newly accepted syllable\n * nucleus (emitted once, at its peak frame), or null.\n */\nexport function nucleiStep(\n  state: NucleiState,\n  frame: FrameFeatures,\n  speaking: boolean,\n  config?: Partial<NucleiConfig>,\n): { state: NucleiState; onset: number | null } {\n  const c = { ...DEFAULT_NUCLEI_CONFIG, ...config };\n  const amp = Math.sqrt(Math.max(0, frame.bandEnergy));\n  const dt = state.framesSeen > 0 ? Math.max(0, frame.tSec - state.lastTSec) : 0;\n\n  const env =\n    state.framesSeen > 0\n      ? state.env + (amp - state.env) * (1 - Math.exp(-2 * Math.PI * c.envelopeHz * dt))\n      : amp;\n  const peakRef = Math.max(env, state.peakRef * Math.exp(-(dt || 0) / c.peakRefTauSec));\n\n  let onset: number | null = null;\n  let valley = state.framesSeen > 0 ? state.valley : env;\n  let lastOnsetTSec = state.lastOnsetTSec;\n\n  // Candidate peak at the PREVIOUS frame: env[t-1] ≥ env[t-2] && env[t-1] > env[t].\n  if (\n    state.framesSeen >= 2 &&\n    state.prevEnv >= state.prevPrevEnv &&\n    state.prevEnv > env &&\n    speaking &&\n    state.prevTSec - lastOnsetTSec >= c.minInterOnsetMs / 1000 &&\n    state.prevEnv >= valley * c.prominenceRatio &&\n    state.prevEnv >= peakRef * c.minRelPeak\n  ) {\n    onset = state.prevTSec;\n    lastOnsetTSec = state.prevTSec;\n    // Re-seed the valley at the accepted peak; it decays via min() below.\n    valley = state.prevEnv;\n  }\n  valley = Math.min(valley, env);\n\n  return {\n    state: {\n      env,\n      prevEnv: env,\n      prevPrevEnv: state.framesSeen > 0 ? state.prevEnv : env,\n      prevTSec: frame.tSec,\n      valley,\n      lastOnsetTSec,\n      peakRef,\n      lastTSec: frame.tSec,\n      framesSeen: state.framesSeen + 1,\n    },\n    onset,\n  };\n}\n\n/** Batch wrapper for the offline aligner. `vadFlags[i]` pairs with `frames[i]`. */\nexport function detectSyllableOnsets(\n  frames: FrameFeatures[],\n  vadFlags: boolean[],\n  config?: Partial<NucleiConfig>,\n): number[] {\n  let state = createNucleiState(config);\n  const onsets: number[] = [];\n  for (let i = 0; i < frames.length; i++) {\n    const step = nucleiStep(state, frames[i], vadFlags[i] ?? false, config);\n    state = step.state;\n    if (step.onset !== null) onsets.push(step.onset);\n  }\n  return onsets;\n}\n","/**\n * The teleprompter pacing controller.\n *\n * A pure, deterministic step function: given the current state, one\n * analysis tick (VAD flag + syllable onsets), and the script, produce\n * the next state. The prompter position (`wordPos`) advances at a\n * velocity that (a) halts within ~250 ms of silence, (b) tracks the\n * reader's detected syllable rate while speaking, and (c) is corrected\n * by a PI loop on cumulative detected-vs-expected syllables so the\n * highlight can't drift arbitrarily far from the voice. Silence near an\n * expected paragraph/block break is legitimate and accrues no error.\n */\n\nimport { expectedSyllablesAt, wordPosAtExpectedSyllables } from './script.js';\nimport type { NarrationScript, PacingConfig } from './types.js';\nimport { DEFAULT_PACING_CONFIG } from './types.js';\n\nexport interface PacingTick {\n  tSec: number;\n  speaking: boolean;\n  /** Syllable onsets detected in this tick (0 or 1 for frame-sized ticks). */\n  onsets: number;\n}\n\nexport interface PacingState {\n  /** Fractional word position — the active token is `floor(wordPos)`. */\n  wordPos: number;\n  /** Current scroll velocity in words per second. */\n  velocityWps: number;\n  /** EMA of the detected syllable rate (syl/s); 0 until two onsets arrive. */\n  emaSylPerSec: number;\n  lastOnsetTSec: number | null;\n  /** Syllables detected since the last anchor. */\n  cumDetectedSyl: number;\n  /** Expected cumulative syllables at the last anchor position. */\n  anchorExpectedSyl: number;\n  /** PI integral of the cumulative-syllable error (syl·s). */\n  errIntegral: number;\n  /** Continuous silence observed so far (s). */\n  silenceSec: number;\n  lastTSec: number | null;\n  /** True when silent and fully stopped. */\n  halted: boolean;\n}\n\nexport function createPacingState(startWordPos = 0): PacingState {\n  return {\n    wordPos: startWordPos,\n    velocityWps: 0,\n    emaSylPerSec: 0,\n    lastOnsetTSec: null,\n    cumDetectedSyl: 0,\n    anchorExpectedSyl: 0,\n    errIntegral: 0,\n    silenceSec: 0,\n    lastTSec: null,\n    halted: true,\n  };\n}\n\nfunction clamp(value: number, min: number, max: number): number {\n  return value < min ? min : value > max ? max : value;\n}\n\n/**\n * Mean syllables-per-SPOKEN-word over a short window ahead of the prompter\n * position. Standalone punctuation (0 syllables, `spoken: false`) is\n * excluded so it doesn't deflate the average.\n */\nfunction localSyllablesPerWord(\n  script: NarrationScript,\n  wordPos: number,\n  windowWords: number,\n): number {\n  const n = script.tokens.length;\n  if (n === 0) return 1.4;\n  const start = clamp(Math.floor(wordPos), 0, n - 1);\n  let sum = 0;\n  let count = 0;\n  for (let i = start; i < n && count < windowWords; i++) {\n    if (!script.tokens[i].spoken) continue;\n    sum += script.tokens[i].syllables;\n    count += 1;\n  }\n  // Default to the English average (~1.4) when the window has no words yet.\n  return count > 0 ? Math.max(1, sum / count) : 1.4;\n}\n\n/** Pure controller step — same inputs always yield the same output state. */\nexport function pacingStep(\n  state: PacingState,\n  tick: PacingTick,\n  script: NarrationScript,\n  config?: Partial<PacingConfig>,\n): PacingState {\n  const c = { ...DEFAULT_PACING_CONFIG, ...config };\n  const baseWps = c.baseWpm / 60;\n  const dt = clamp(tick.tSec - (state.lastTSec ?? tick.tSec), 0, 0.25);\n\n  // 1. Onset bookkeeping: cumulative count + inter-onset-interval rate EMA.\n  let emaSylPerSec = state.emaSylPerSec;\n  let lastOnsetTSec = state.lastOnsetTSec;\n  let cumDetectedSyl = state.cumDetectedSyl;\n  for (let k = 0; k < tick.onsets; k++) {\n    if (lastOnsetTSec !== null) {\n      const ioi = tick.tSec - lastOnsetTSec;\n      if (ioi > 0) {\n        const instRate = clamp(1 / ioi, 0.5, 12);\n        const alpha = 1 - Math.exp(-ioi / c.rateEmaTauSec);\n        emaSylPerSec =\n          emaSylPerSec === 0 ? instRate : emaSylPerSec + (instRate - emaSylPerSec) * alpha;\n      }\n    }\n    lastOnsetTSec = tick.tSec;\n    cumDetectedSyl += 1;\n  }\n\n  // 2–3. Cruise velocity: BLEND the user's set pace with the voice-derived\n  // rate. The old design used `baseWps · clamp(voiceWps / baseWps)`, in\n  // which baseWps algebraically cancels in the unclamped range — so the WPM\n  // slider did nothing and a chronically under-counting detector dragged\n  // the prompter slow with no way to compensate. Blending keeps the set\n  // pace as a real feedforward term (WPM always felt), while the voice\n  // steers within a band. Then clamp to a band around the set pace so\n  // neither term alone can stall or run away.\n  const sylPerWordLocal = localSyllablesPerWord(script, state.wordPos, c.sylWindowWords);\n  const voiceWps = emaSylPerSec > 0 ? emaSylPerSec / sylPerWordLocal : baseWps;\n  const cruise = clamp(\n    c.voiceBlend * voiceWps + (1 - c.voiceBlend) * baseWps,\n    baseWps * c.minRateMult,\n    baseWps * c.maxRateMult,\n  );\n\n  // 4–5. FORWARD-ONLY position correction. `err` compares where the\n  // prompter is (expected syllables at wordPos) against how many syllables\n  // the voice has actually delivered. err < 0 → the reader is AHEAD of the\n  // prompter → speed up to catch them. err > 0 → the prompter looks ahead\n  // of the reader, but this is exactly the signal a chronically\n  // under-counting syllable detector produces even when the prompter is\n  // really BEHIND — so we deliberately do NOT slow or snap backward on it.\n  // (The old symmetric PI pinned the prompter to the DETECTED count, so a\n  // detector catching half the syllables parked the prompter at half the\n  // reader's true position — the lag the user saw.) Slowing down is instead\n  // handled honestly by the cruise blend (a slow voice lowers voiceWps) and\n  // by halt-on-silence.\n  const err =\n    expectedSyllablesAt(script, state.wordPos) - (state.anchorExpectedSyl + cumDetectedSyl);\n  let errIntegral = clamp(Math.min(0, state.errIntegral + err * dt), -c.intClamp, 0);\n  const boost = err < 0 ? clamp(c.kP * -err + c.kI * -errIntegral, 0, c.maxCorrection) : 0;\n\n  // 6. Velocity: track while speaking, decay to a halt in silence.\n  let velocityWps = state.velocityWps;\n  let silenceSec = state.silenceSec;\n  if (tick.speaking) {\n    silenceSec = 0;\n    const target = Math.max(0, cruise * (1 + boost));\n    velocityWps += (target - velocityWps) * (1 - Math.exp(-dt / c.velSlewTauSec));\n  } else {\n    silenceSec += dt;\n    velocityWps *= Math.exp(-dt / c.haltTauSec);\n    if (velocityWps < 0.02) velocityWps = 0;\n  }\n\n  // 7. Hard resync forward only: when the reader has clearly outrun the\n  // prompter by more than a paragraph, jump ahead to catch up. Never jump\n  // backward (a false \"prompter ahead\" from under-counting must not yank\n  // the highlight back).\n  let wordPos = state.wordPos;\n  if (err < -c.resyncSyllables) {\n    wordPos = Math.max(\n      wordPos,\n      wordPosAtExpectedSyllables(script, state.anchorExpectedSyl + cumDetectedSyl),\n    );\n    errIntegral = 0;\n  }\n\n  // 8. Integrate.\n  wordPos = clamp(wordPos + velocityWps * dt, 0, script.tokens.length);\n\n  return {\n    wordPos,\n    velocityWps,\n    emaSylPerSec,\n    lastOnsetTSec,\n    cumDetectedSyl,\n    anchorExpectedSyl: state.anchorExpectedSyl,\n    errIntegral,\n    silenceSec,\n    lastTSec: tick.tSec,\n    halted: !tick.speaking && velocityWps === 0,\n  };\n}\n\n/**\n * Re-anchor after a manual nudge/scroll: the new position becomes the\n * zero-error reference. The learned rate EMA survives.\n */\nexport function reanchorPacing(\n  state: PacingState,\n  wordPos: number,\n  script: NarrationScript,\n): PacingState {\n  const pos = clamp(wordPos, 0, script.tokens.length);\n  return {\n    ...state,\n    wordPos: pos,\n    anchorExpectedSyl: expectedSyllablesAt(script, pos),\n    cumDetectedSyl: 0,\n    errIntegral: 0,\n  };\n}\n","/**\n * Live-session composition: one pure call per PCM hop runs feature\n * extraction → VAD → nuclei → pacing. This is the only surface the\n * editor's mic loop needs — feed it worklet batches, read\n * `state.pacing.wordPos` / `state.vad.speaking` / `state.lastFrame`.\n */\n\nimport { createFeatureState, featureStep, type FeatureState } from './features.js';\nimport { createNucleiState, nucleiStep, type NucleiState } from './nuclei.js';\nimport { createPacingState, pacingStep, reanchorPacing, type PacingState } from './pacing.js';\nimport { createVadState, vadStep, type VadState } from './vad.js';\nimport type {\n  FeatureConfig,\n  FrameFeatures,\n  NarrationScript,\n  NucleiConfig,\n  PacingConfig,\n  VadConfig,\n} from './types.js';\n\nexport interface NarrationSessionConfig {\n  feature?: Partial<FeatureConfig>;\n  vad?: Partial<VadConfig>;\n  nuclei?: Partial<NucleiConfig>;\n  pacing?: Partial<PacingConfig>;\n}\n\nexport interface NarrationSessionState {\n  script: NarrationScript;\n  config: NarrationSessionConfig;\n  features: FeatureState;\n  vad: VadState;\n  nuclei: NucleiState;\n  pacing: PacingState;\n  /** Most recent analysis frame — drives the UI level meter. */\n  lastFrame: FrameFeatures | null;\n  /** Seconds of PCM consumed so far. */\n  tSec: number;\n}\n\nexport function createNarrationSession(\n  sampleRate: number,\n  script: NarrationScript,\n  config?: NarrationSessionConfig,\n): NarrationSessionState {\n  const merged = config ?? {};\n  return {\n    script,\n    config: merged,\n    features: createFeatureState(sampleRate, merged.feature),\n    vad: createVadState(merged.vad),\n    nuclei: createNucleiState(merged.nuclei),\n    pacing: createPacingState(0),\n    lastFrame: null,\n    tSec: 0,\n  };\n}\n\n/** Feed one hop of mono PCM; every completed frame advances VAD/nuclei/pacing. */\nexport function narrationSessionStep(\n  state: NarrationSessionState,\n  hop: Float32Array,\n): NarrationSessionState {\n  const { state: features, frames } = featureStep(state.features, hop);\n  let vad = state.vad;\n  let nuclei = state.nuclei;\n  let pacing = state.pacing;\n  let lastFrame = state.lastFrame;\n\n  for (const frame of frames) {\n    vad = vadStep(vad, frame, state.config.vad);\n    const nucleiResult = nucleiStep(nuclei, frame, vad.speaking, state.config.nuclei);\n    nuclei = nucleiResult.state;\n    pacing = pacingStep(\n      pacing,\n      { tSec: frame.tSec, speaking: vad.speaking, onsets: nucleiResult.onset !== null ? 1 : 0 },\n      state.script,\n      state.config.pacing,\n    );\n    lastFrame = frame;\n  }\n\n  return {\n    ...state,\n    features,\n    vad,\n    nuclei,\n    pacing,\n    lastFrame,\n    tSec: state.tSec + hop.length / state.features.sampleRate,\n  };\n}\n\n/** Manual nudge/scroll: re-anchor the pacing controller at a word position. */\nexport function reanchorSession(\n  state: NarrationSessionState,\n  wordPos: number,\n): NarrationSessionState {\n  return { ...state, pacing: reanchorPacing(state.pacing, wordPos, state.script) };\n}\n","/**\n * Live prompter trace: sparse `{ tMs, wordPos }` samples the UI records\n * while the reader records a take (~4 Hz plus one on every re-anchor).\n * The offline aligner uses it as a prior — a Sakoe-Chiba band around\n * the trace keeps the DTW honest and cheap.\n */\n\nexport interface TraceSample {\n  tMs: number;\n  wordPos: number;\n}\n\nexport interface NarrationTrace {\n  samples: TraceSample[];\n}\n\n/** Clamped linear interpolation of the trace at a time. */\nexport function traceWordPosAt(trace: NarrationTrace, tSec: number): number {\n  const samples = trace.samples;\n  if (samples.length === 0) return 0;\n  const tMs = tSec * 1000;\n  if (tMs <= samples[0].tMs) return samples[0].wordPos;\n  const last = samples[samples.length - 1];\n  if (tMs >= last.tMs) return last.wordPos;\n  // Binary search: last sample with tMs <= target.\n  let lo = 0;\n  let hi = samples.length - 1;\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1;\n    if (samples[mid].tMs <= tMs) lo = mid;\n    else hi = mid - 1;\n  }\n  const a = samples[lo];\n  const b = samples[lo + 1];\n  const span = b.tMs - a.tMs;\n  if (span <= 0) return a.wordPos;\n  return a.wordPos + ((tMs - a.tMs) / span) * (b.wordPos - a.wordPos);\n}\n\n/** Downsample to at most `maxSamples`, always keeping both endpoints. */\nexport function downsampleTrace(trace: NarrationTrace, maxSamples: number): NarrationTrace {\n  const samples = trace.samples;\n  if (maxSamples < 2 || samples.length <= maxSamples) return { samples: samples.slice() };\n  const out: TraceSample[] = [];\n  const stride = (samples.length - 1) / (maxSamples - 1);\n  for (let i = 0; i < maxSamples; i++) {\n    out.push(samples[Math.round(i * stride)]);\n  }\n  return { samples: out };\n}\n","/**\n * Offline narration alignment: refine word/block timestamps from a\n * recorded take.\n *\n * Pipeline: fine-hop features → VAD flags → syllable onsets + silence\n * gaps (the DETECTED event sequence) vs. the script's expected\n * syllable/pause slots (the EXPECTED sequence), aligned with a banded\n * DTW. The band (Sakoe-Chiba style) follows the live prompter trace\n * when one exists — the trace is what the reader actually saw — and a\n * proportional prior otherwise. Matched slots yield word timestamps;\n * block starts snap to the end of the breath gap readers take before a\n * heading; block ranges are made CONTIGUOUS because downstream preview\n * building re-derives start times from durations.\n */\n\nimport { extractFrameFeatures } from './features.js';\nimport { detectSyllableOnsets } from './nuclei.js';\nimport { createVadState, vadStep } from './vad.js';\nimport type { NarrationTrace } from './trace.js';\nimport type {\n  AlignConfig,\n  FrameFeatures,\n  NarrationAlignment,\n  NarrationBlockRange,\n  NarrationScript,\n  WordTiming,\n} from './types.js';\nimport { DEFAULT_ALIGN_CONFIG } from './types.js';\n\nexport interface AlignInput {\n  /** Mono PCM of the whole take. */\n  pcm: Float32Array;\n  sampleRate: number;\n  script: NarrationScript;\n  /** Live prompter trace recorded during the take, if any. */\n  trace?: NarrationTrace;\n}\n\ninterface DetectedEvent {\n  kind: 'syl' | 'gap';\n  /** Representative time (onset peak, or gap midpoint). */\n  tSec: number;\n  startSec: number;\n  endSec: number;\n}\n\ninterface ExpectedSlot {\n  kind: 'syl' | 'pause';\n  tokenIndex: number;\n  /** Syllable index within the token; -1 for pause slots. */\n  slotIndex: number;\n  /** Prior estimate of when this slot is spoken. */\n  priorSec: number;\n}\n\n/** Hard cap keeping the banded DP tractable on very long no-trace takes. */\nconst MAX_BAND_RADIUS_SEC = 60;\n\nexport function alignNarration(\n  input: AlignInput,\n  config?: Partial<AlignConfig>,\n): NarrationAlignment {\n  const c = { ...DEFAULT_ALIGN_CONFIG, ...config };\n  const { pcm, sampleRate, script } = input;\n  const takeDuration = pcm.length / Math.max(1, sampleRate);\n\n  if (script.tokens.length === 0 || takeDuration <= 0) {\n    return { words: [], blocks: [], detectedSyllables: 0, cost: 0 };\n  }\n\n  // ── 1. Detected events over the whole take ─────────────────────────\n  const frames = extractFrameFeatures(pcm, sampleRate, { hopSec: c.hopSec });\n  const vadFlags = runVad(frames);\n  const onsets = detectSyllableOnsets(frames, vadFlags);\n  const gaps = findSilenceGaps(frames, vadFlags, c.gapMinSec);\n  const lastSpeechEnd = findLastSpeechEnd(frames, vadFlags);\n\n  if (onsets.length === 0) {\n    return proportionalAlignment(\n      script,\n      lastSpeechEnd > 0 ? lastSpeechEnd : takeDuration,\n      takeDuration,\n      c,\n      0,\n    );\n  }\n\n  const events: DetectedEvent[] = [\n    ...onsets.map((t): DetectedEvent => ({ kind: 'syl', tSec: t, startSec: t, endSec: t })),\n    ...gaps,\n  ].sort((a, b) => a.tSec - b.tSec);\n\n  // ── 2. Expected slots with prior times ─────────────────────────────\n  const bandRadius = Math.min(\n    MAX_BAND_RADIUS_SEC,\n    input.trace && input.trace.samples.length >= 2\n      ? c.bandRadiusSec\n      : Math.max(c.bandRadiusNoTraceSec, 0.1 * takeDuration),\n  );\n  const slots = buildExpectedSlots(script, takeDuration, input.trace);\n\n  // ── 3. Banded DP ────────────────────────────────────────────────────\n  const { matchedEventBySlot, cost } = bandedDtw(slots, events, bandRadius, c);\n\n  // ── 4. Word timestamps ──────────────────────────────────────────────\n  const words = deriveWordTimings(script, slots, events, matchedEventBySlot);\n\n  // ── 5. Block ranges ─────────────────────────────────────────────────\n  const blocks = deriveBlockRanges(script, words, gaps, takeDuration, lastSpeechEnd, c);\n\n  return { words, blocks, detectedSyllables: onsets.length, cost };\n}\n\n// ── Detection helpers ─────────────────────────────────────────────────\n\nfunction runVad(frames: FrameFeatures[]): boolean[] {\n  let vad = createVadState();\n  const flags = new Array<boolean>(frames.length);\n  for (let i = 0; i < frames.length; i++) {\n    vad = vadStep(vad, frames[i]);\n    flags[i] = vad.speaking;\n  }\n  return flags;\n}\n\nfunction findSilenceGaps(\n  frames: FrameFeatures[],\n  vadFlags: boolean[],\n  gapMinSec: number,\n): DetectedEvent[] {\n  const gaps: DetectedEvent[] = [];\n  let runStart = -1;\n  for (let i = 0; i <= frames.length; i++) {\n    const silent = i < frames.length ? !vadFlags[i] : false;\n    if (silent && runStart === -1) {\n      runStart = i;\n    } else if (!silent && runStart !== -1) {\n      const startSec = frames[runStart].tSec;\n      const endSec = frames[i - 1].tSec;\n      if (endSec - startSec >= gapMinSec) {\n        gaps.push({ kind: 'gap', tSec: (startSec + endSec) / 2, startSec, endSec });\n      }\n      runStart = -1;\n    }\n  }\n  return gaps;\n}\n\nfunction findLastSpeechEnd(frames: FrameFeatures[], vadFlags: boolean[]): number {\n  for (let i = frames.length - 1; i >= 0; i--) {\n    if (vadFlags[i]) return frames[i].tSec;\n  }\n  return 0;\n}\n\n// ── Expected slots + priors ───────────────────────────────────────────\n\nfunction buildExpectedSlots(\n  script: NarrationScript,\n  takeDuration: number,\n  trace: NarrationTrace | undefined,\n): ExpectedSlot[] {\n  const slots: ExpectedSlot[] = [];\n  for (let k = 0; k < script.tokens.length; k++) {\n    const token = script.tokens[k];\n    for (let s = 0; s < token.syllables; s++) {\n      slots.push({ kind: 'syl', tokenIndex: k, slotIndex: s, priorSec: 0 });\n    }\n    if (token.pauseAfter >= 2) {\n      slots.push({ kind: 'pause', tokenIndex: k, slotIndex: -1, priorSec: 0 });\n    }\n  }\n\n  const useTrace = trace !== undefined && trace.samples.length >= 2;\n  if (useTrace) {\n    assignTracePriors(slots, script, trace, takeDuration);\n  } else {\n    const total = Math.max(1, script.totalSyllables);\n    for (const slot of slots) {\n      const cumBefore =\n        slot.kind === 'pause'\n          ? script.cumulativeSyllables[slot.tokenIndex + 1]\n          : script.cumulativeSyllables[slot.tokenIndex] + slot.slotIndex;\n      slot.priorSec = (cumBefore / total) * takeDuration;\n    }\n  }\n\n  // Priors must be monotone for the band windows to be monotone.\n  let prev = 0;\n  for (const slot of slots) {\n    if (slot.priorSec < prev) slot.priorSec = prev;\n    if (slot.priorSec > takeDuration) slot.priorSec = takeDuration;\n    prev = slot.priorSec;\n  }\n  return slots;\n}\n\n/** Invert the (monotonicized) live trace: earliest time the prompter reached each slot's word position. */\nfunction assignTracePriors(\n  slots: ExpectedSlot[],\n  script: NarrationScript,\n  trace: NarrationTrace,\n  takeDuration: number,\n): void {\n  // Monotonicize wordPos (manual back-nudges would break the sweep).\n  const times: number[] = [];\n  const positions: number[] = [];\n  let runningMax = 0;\n  for (const sample of trace.samples) {\n    runningMax = Math.max(runningMax, sample.wordPos);\n    times.push(sample.tMs / 1000);\n    positions.push(runningMax);\n  }\n\n  let ptr = 0;\n  for (const slot of slots) {\n    const token = script.tokens[slot.tokenIndex];\n    const target =\n      slot.kind === 'pause'\n        ? slot.tokenIndex + 1\n        : slot.tokenIndex + slot.slotIndex / Math.max(1, token.syllables);\n    while (ptr < positions.length - 1 && positions[ptr + 1] < target) ptr++;\n    let t: number;\n    if (positions[ptr] >= target) {\n      t = times[ptr];\n    } else if (ptr >= positions.length - 1) {\n      t = times[times.length - 1];\n    } else {\n      const span = positions[ptr + 1] - positions[ptr];\n      const frac = span > 0 ? (target - positions[ptr]) / span : 0;\n      t = times[ptr] + frac * (times[ptr + 1] - times[ptr]);\n    }\n    slot.priorSec = Math.min(Math.max(0, t), takeDuration);\n  }\n}\n\n// ── The banded DP ─────────────────────────────────────────────────────\n\nfunction matchCost(\n  slot: ExpectedSlot,\n  event: DetectedEvent,\n  bandRadius: number,\n  c: AlignConfig,\n): number {\n  if (slot.kind === 'syl') {\n    if (event.kind === 'syl') {\n      return (\n        (c.matchTimeWeight * Math.abs(event.tSec - slot.priorSec)) / Math.max(1e-6, bandRadius)\n      );\n    }\n    return c.sylToGapCost;\n  }\n  return event.kind === 'gap' ? 0 : c.pauseToSylCost;\n}\n\nfunction bandedDtw(\n  slots: ExpectedSlot[],\n  events: DetectedEvent[],\n  bandRadius: number,\n  c: AlignConfig,\n): { matchedEventBySlot: Int32Array; cost: number } {\n  const N = slots.length;\n  const M = events.length;\n  const INF = Number.POSITIVE_INFINITY;\n  const eventTimes = events.map((e) => e.tSec);\n\n  // Column windows per DP row (row i consumed i slots; columns are consumed events).\n  const lo = new Int32Array(N + 1);\n  const hi = new Int32Array(N + 1);\n  for (let i = 1; i <= N; i++) {\n    const prior = slots[i - 1].priorSec;\n    lo[i] = lowerBound(eventTimes, prior - bandRadius);\n    hi[i] = upperBound(eventTimes, prior + bandRadius);\n  }\n  lo[0] = 0;\n  hi[0] = N >= 1 ? hi[1] : M;\n  // Forward pass: monotone, connected, in-range.\n  for (let i = 1; i <= N; i++) {\n    if (lo[i] < lo[i - 1]) lo[i] = lo[i - 1];\n    if (lo[i] > hi[i - 1] + 1) lo[i] = hi[i - 1] + 1;\n    if (lo[i] > M) lo[i] = M;\n    if (hi[i] < hi[i - 1]) hi[i] = hi[i - 1];\n    if (hi[i] < lo[i]) hi[i] = lo[i];\n    if (hi[i] > M) hi[i] = M;\n  }\n  hi[N] = M;\n  if (lo[N] > M) lo[N] = M;\n\n  // DP with per-row backpointers (0 = diag/match, 1 = up/delete-slot, 2 = left/insert-event).\n  const ptrRows: Uint8Array[] = new Array(N + 1);\n  let prevCost = new Float64Array(hi[0] - lo[0] + 1);\n  {\n    const row = new Uint8Array(hi[0] - lo[0] + 1);\n    for (let j = lo[0]; j <= hi[0]; j++) {\n      prevCost[j - lo[0]] = j * c.insertCost;\n      row[j - lo[0]] = 2;\n    }\n    ptrRows[0] = row;\n  }\n\n  for (let i = 1; i <= N; i++) {\n    const width = hi[i] - lo[i] + 1;\n    const cost = new Float64Array(width).fill(INF);\n    const ptr = new Uint8Array(width);\n    const slot = slots[i - 1];\n    for (let j = lo[i]; j <= hi[i]; j++) {\n      const idx = j - lo[i];\n      let best = INF;\n      let bestPtr = 1;\n      // Diagonal: match slot i-1 with event j-1.\n      if (j >= 1 && j - 1 >= lo[i - 1] && j - 1 <= hi[i - 1]) {\n        const v = prevCost[j - 1 - lo[i - 1]] + matchCost(slot, events[j - 1], bandRadius, c);\n        if (v < best) {\n          best = v;\n          bestPtr = 0;\n        }\n      }\n      // Up: delete the slot (unspoken/merged syllable).\n      if (j >= lo[i - 1] && j <= hi[i - 1]) {\n        const v = prevCost[j - lo[i - 1]] + c.deleteCost;\n        if (v < best) {\n          best = v;\n          bestPtr = 1;\n        }\n      }\n      // Left: insert the event (filler, breath, click).\n      if (j - 1 >= lo[i]) {\n        const v = cost[idx - 1] + c.insertCost;\n        if (v < best) {\n          best = v;\n          bestPtr = 2;\n        }\n      }\n      cost[idx] = best;\n      ptr[idx] = bestPtr;\n    }\n    ptrRows[i] = ptr;\n    prevCost = cost;\n  }\n\n  // Backtrack from (N, M).\n  const matchedEventBySlot = new Int32Array(N).fill(-1);\n  let i = N;\n  let j = M;\n  const finalCost = prevCost[M - lo[N]] ?? 0;\n  while (i > 0 || j > 0) {\n    const row = ptrRows[i];\n    const idx = j - lo[i];\n    const move = idx >= 0 && idx < row.length ? row[idx] : i > 0 ? 1 : 2;\n    if (move === 0 && i > 0 && j > 0) {\n      matchedEventBySlot[i - 1] = j - 1;\n      i--;\n      j--;\n    } else if (move === 1 && i > 0) {\n      i--;\n    } else if (j > 0) {\n      j--;\n    } else if (i > 0) {\n      i--;\n    } else {\n      break;\n    }\n  }\n\n  return { matchedEventBySlot, cost: Number.isFinite(finalCost) ? finalCost : 0 };\n}\n\n/** First index with values[idx] >= target. */\nfunction lowerBound(values: number[], target: number): number {\n  let lo = 0;\n  let hi = values.length;\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1;\n    if (values[mid] < target) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n}\n\n/** Count of values <= target (i.e. exclusive upper index). */\nfunction upperBound(values: number[], target: number): number {\n  let lo = 0;\n  let hi = values.length;\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1;\n    if (values[mid] <= target) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n}\n\n// ── Outputs ───────────────────────────────────────────────────────────\n\nfunction deriveWordTimings(\n  script: NarrationScript,\n  slots: ExpectedSlot[],\n  events: DetectedEvent[],\n  matchedEventBySlot: Int32Array,\n): WordTiming[] {\n  const n = script.tokens.length;\n  const raw = new Array<number | undefined>(n);\n  for (let s = 0; s < slots.length; s++) {\n    const eventIdx = matchedEventBySlot[s];\n    if (eventIdx < 0) continue;\n    const slot = slots[s];\n    if (slot.kind !== 'syl') continue;\n    if (raw[slot.tokenIndex] !== undefined) continue; // first matched slot wins\n    const event = events[eventIdx];\n    // A word matched to a gap starts when speech resumes.\n    raw[slot.tokenIndex] = event.kind === 'gap' ? event.endSec : event.tSec;\n  }\n\n  const words: WordTiming[] = new Array(n);\n  let prevKnownIdx = -1;\n  let prevKnownT = 0;\n  for (let k = 0; k < n; k++) {\n    if (raw[k] === undefined) continue;\n    // Interpolate the run of unknowns between prevKnown and k.\n    const t = raw[k]!;\n    for (let u = prevKnownIdx + 1; u < k; u++) {\n      const frac = (u - prevKnownIdx) / (k - prevKnownIdx);\n      const base = prevKnownIdx >= 0 ? prevKnownT : t;\n      words[u] = {\n        tokenIndex: u,\n        tSec: base + (t - base) * (prevKnownIdx >= 0 ? frac : 0),\n        interpolated: true,\n      };\n    }\n    words[k] = { tokenIndex: k, tSec: t, interpolated: false };\n    prevKnownIdx = k;\n    prevKnownT = t;\n  }\n  for (let u = prevKnownIdx + 1; u < n; u++) {\n    words[u] = { tokenIndex: u, tSec: prevKnownT, interpolated: true };\n  }\n  if (prevKnownIdx === -1) {\n    for (let u = 0; u < n; u++) words[u] = { tokenIndex: u, tSec: 0, interpolated: true };\n  }\n  // Monotonic.\n  let running = 0;\n  for (const w of words) {\n    running = Math.max(running, w.tSec);\n    w.tSec = running;\n  }\n  return words;\n}\n\nfunction deriveBlockRanges(\n  script: NarrationScript,\n  words: WordTiming[],\n  gaps: DetectedEvent[],\n  takeDuration: number,\n  lastSpeechEnd: number,\n  c: AlignConfig,\n): NarrationBlockRange[] {\n  const blocks: NarrationBlockRange[] = [];\n  const gapEnds = gaps.map((g) => g.endSec);\n  let prevStart = 0;\n  for (let b = 0; b < script.blocks.length; b++) {\n    const range = script.blocks[b];\n    const firstWord = words[range.tokenStart];\n    let startSec = b === 0 ? 0 : (firstWord?.tSec ?? prevStart);\n    if (b > 0) {\n      // Snap to the end of the breath gap just before the block, if close.\n      const idx = upperBound(gapEnds, startSec) - 1;\n      if (idx >= 0 && startSec - gapEnds[idx] <= c.blockSnapWindowSec && gapEnds[idx] > prevStart) {\n        startSec = gapEnds[idx];\n      }\n      if (startSec < prevStart) startSec = prevStart;\n    }\n    blocks.push({\n      blockId: range.blockId,\n      ...(range.heading !== undefined ? { heading: range.heading } : {}),\n      blockIndex: b,\n      charStart: range.charStart,\n      charEnd: range.charEnd,\n      startSec,\n      endSec: startSec,\n    });\n    prevStart = startSec;\n  }\n  // Contiguous ranges: endSec === next.startSec; final block covers the tail.\n  for (let b = 0; b < blocks.length - 1; b++) {\n    blocks[b].endSec = blocks[b + 1].startSec;\n  }\n  if (blocks.length > 0) {\n    const last = blocks[blocks.length - 1];\n    let end = Math.min(\n      takeDuration,\n      (lastSpeechEnd > 0 ? lastSpeechEnd : takeDuration) + c.tailPadSec,\n    );\n    if (takeDuration - end <= 1) end = takeDuration;\n    last.endSec = Math.max(last.startSec, end);\n  }\n  return blocks;\n}\n\n/** Fallback when nothing was detected: proportional by expected syllables. */\nfunction proportionalAlignment(\n  script: NarrationScript,\n  effectiveDuration: number,\n  takeDuration: number,\n  c: AlignConfig,\n  detectedSyllables: number,\n): NarrationAlignment {\n  const total = Math.max(1, script.totalSyllables);\n  const words: WordTiming[] = script.tokens.map((_, k) => ({\n    tokenIndex: k,\n    tSec: (script.cumulativeSyllables[k] / total) * effectiveDuration,\n    interpolated: true,\n  }));\n  const blocks = deriveBlockRanges(script, words, [], takeDuration, effectiveDuration, c);\n  return { words, blocks, detectedSyllables, cost: 0 };\n}\n"],"mappings":"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","names":["i","j"]}