@bendyline/squisq 1.5.2 → 2.0.1

package/dist/chunk-CY2R2VPR.js.map

@@ -0,0 +1 @@
+{"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"]}

package/dist/chunk-FVJUUTEM.js

@@ -0,0 +1,74 @@
+// src/schemas/Media.ts
+function flatten(blocks, out = []) {
+  for (const b of blocks) {
+    out.push(b);
+    if (b.children && b.children.length > 0) flatten(b.children, out);
+  }
+  return out;
+}
+function clipLength(clip) {
+  if (clip.clipEnd == null) return null;
+  return Math.max(0, clip.clipEnd - (clip.clipStart ?? 0));
+}
+function baseTimelineEnd(doc) {
+  const blockEnd = flatten(doc.blocks).reduce(
+    (max, b) => Math.max(max, b.startTime + b.duration),
+    0
+  );
+  return Math.max(doc.duration ?? 0, blockEnd);
+}
+function resolveMediaSchedule(doc) {
+  const out = [];
+  const docEnd = baseTimelineEnd(doc);
+  for (const block of flatten(doc.blocks)) {
+    const blockEnd = block.startTime + block.duration;
+    for (const clip of block.media ?? []) {
+      const start = block.startTime + clip.startAt;
+      const len = clipLength(clip);
+      let end;
+      if (clip.spillover) {
+        end = len != null ? start + len : blockEnd;
+      } else {
+        end = len != null ? Math.min(start + len, blockEnd) : blockEnd;
+      }
+      out.push({
+        id: clip.id,
+        src: clip.src,
+        kind: clip.kind,
+        absoluteStart: start,
+        absoluteEnd: Math.max(start, end),
+        sourceIn: clip.clipStart ?? 0,
+        anchor: "block",
+        blockId: block.id,
+        ...clip.sourceLine != null ? { sourceLine: clip.sourceLine } : {}
+      });
+    }
+  }
+  for (const clip of doc.documentMedia ?? []) {
+    const start = clip.startAt;
+    const len = clipLength(clip);
+    const end = len != null ? start + len : docEnd;
+    out.push({
+      id: clip.id,
+      src: clip.src,
+      kind: clip.kind,
+      absoluteStart: start,
+      absoluteEnd: Math.max(start, end),
+      sourceIn: clip.clipStart ?? 0,
+      anchor: "document",
+      ...clip.sourceLine != null ? { sourceLine: clip.sourceLine } : {}
+    });
+  }
+  return out;
+}
+function getDocPlaybackDuration(doc) {
+  const base = baseTimelineEnd(doc);
+  const mediaEnd = resolveMediaSchedule(doc).reduce((max, c) => Math.max(max, c.absoluteEnd), 0);
+  return Math.max(base, mediaEnd);
+}
+
+export {
+  resolveMediaSchedule,
+  getDocPlaybackDuration
+};
+//# sourceMappingURL=chunk-FVJUUTEM.js.map

package/dist/chunk-FVJUUTEM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schemas/Media.ts"],"sourcesContent":["/**\n * Media-clip timing model.\n *\n * An additive layer on top of the simple sequential `Doc.audio.segments[]`\n * narration track, which remains first-class. A {@link MediaClip} is a piece\n * of audio or video whose\n * timing is expressed *relative to its parent block* (or the whole document),\n * with an optional `startAt` offset and an optional `spillover` past the\n * block's end. {@link resolveMediaSchedule} flattens these into absolute,\n * doc-timeline `ScheduledClip`s that playback and export consume.\n *\n * Authoring: a body-level `{[audio …]}` / `{[video …]}` annotation inside a\n * block becomes a `block.media` clip; the same annotation in the preamble\n * (before the first heading) with `anchor=document` becomes a\n * `doc.documentMedia` clip that spans the whole timeline.\n */\n\nimport type { Block, Doc } from './Doc.js';\n\n/**\n * A timed piece of media attached to a block (or the document).\n */\nexport interface MediaClip {\n  /** Stable id (for React keys and timeline selection). */\n  id: string;\n  /** Source path (mp3/mp4/…), relative to the article media dir. */\n  src: string;\n  kind: 'audio' | 'video';\n  /**\n   * Seconds from the parent block's start when this clip begins. For an\n   * `anchor='document'` clip, seconds from the document start. Default 0.\n   */\n  startAt: number;\n  /** Source in-point within the file (seconds). Default 0. */\n  clipStart?: number;\n  /** Source out-point within the file (seconds). Default: file/block end. */\n  clipEnd?: number;\n  /**\n   * When false (default) the clip stops at its block's end. When true it\n   * keeps playing past the block boundary until the clip itself finishes.\n   * Ignored for `anchor='document'` clips (they already span the timeline).\n   */\n  spillover?: boolean;\n  /**\n   * `'block'` (default) — timed relative to the parent block. `'document'` —\n   * timed relative to the document start and able to span every block.\n   */\n  anchor: 'block' | 'document';\n  /**\n   * 1-based source line of the authoring annotation, when derived from\n   * markdown. Enables round-tripping edits (e.g. the timeline editor rewriting\n   * `startAt`) back to the exact line. Absent for programmatically built clips.\n   */\n  sourceLine?: number;\n  /**\n   * Round-trip home of the authoring annotation: the block whose contents\n   * held the paragraph, its position in that block's ORIGINAL contents\n   * array (before extraction), and the paragraph's exact source text.\n   * `docToMarkdown` re-inserts the annotation from this — `raw` verbatim\n   * when present, a re-serialized annotation otherwise. Absent for\n   * programmatically built clips (those emit at the document top).\n   */\n  origin?: { blockId: string; index: number; raw?: string };\n}\n\n/**\n * A {@link MediaClip} resolved to absolute document-timeline coordinates.\n * Produced by {@link resolveMediaSchedule}; consumed by the playback\n * scheduler and the MP4 export.\n */\nexport interface ScheduledClip {\n  id: string;\n  src: string;\n  kind: 'audio' | 'video';\n  /** Absolute doc-timeline second the clip starts. */\n  absoluteStart: number;\n  /** Absolute doc-timeline second the clip ends (exclusive). */\n  absoluteEnd: number;\n  /** Source in-point to seek to at `absoluteStart`. */\n  sourceIn: number;\n  anchor: 'block' | 'document';\n  /** Owning block id for block-anchored clips (for video re-homing/export). */\n  blockId?: string;\n  /** 1-based source line of the authoring annotation, when known. */\n  sourceLine?: number;\n}\n\n/** Depth-first flatten of the block tree (local copy to avoid a doc-layer dep). */\nfunction flatten(blocks: Block[], out: Block[] = []): Block[] {\n  for (const b of blocks) {\n    out.push(b);\n    if (b.children && b.children.length > 0) flatten(b.children, out);\n  }\n  return out;\n}\n\n/** Played length of a clip when known from its in/out points, else null. */\nfunction clipLength(clip: MediaClip): number | null {\n  if (clip.clipEnd == null) return null;\n  return Math.max(0, clip.clipEnd - (clip.clipStart ?? 0));\n}\n\n/**\n * Base playback span ignoring media — the larger of the audio-segment sum\n * and the last block's end. Document clips that don't pin a length run to\n * this point.\n */\nfunction baseTimelineEnd(doc: Doc): number {\n  const blockEnd = flatten(doc.blocks).reduce(\n    (max, b) => Math.max(max, b.startTime + b.duration),\n    0,\n  );\n  return Math.max(doc.duration ?? 0, blockEnd);\n}\n\n/**\n * Flatten every block clip and document clip into absolute-timed\n * `ScheduledClip`s. Pure — depends only on `doc`.\n */\nexport function resolveMediaSchedule(doc: Doc): ScheduledClip[] {\n  const out: ScheduledClip[] = [];\n  const docEnd = baseTimelineEnd(doc);\n\n  for (const block of flatten(doc.blocks)) {\n    const blockEnd = block.startTime + block.duration;\n    for (const clip of block.media ?? []) {\n      const start = block.startTime + clip.startAt;\n      const len = clipLength(clip);\n      let end: number;\n      if (clip.spillover) {\n        // Continue past the block; fall back to the block end when the\n        // played length is unknown (no clipEnd authored).\n        end = len != null ? start + len : blockEnd;\n      } else {\n        end = len != null ? Math.min(start + len, blockEnd) : blockEnd;\n      }\n      out.push({\n        id: clip.id,\n        src: clip.src,\n        kind: clip.kind,\n        absoluteStart: start,\n        absoluteEnd: Math.max(start, end),\n        sourceIn: clip.clipStart ?? 0,\n        anchor: 'block',\n        blockId: block.id,\n        ...(clip.sourceLine != null ? { sourceLine: clip.sourceLine } : {}),\n      });\n    }\n  }\n\n  for (const clip of doc.documentMedia ?? []) {\n    const start = clip.startAt;\n    const len = clipLength(clip);\n    const end = len != null ? start + len : docEnd;\n    out.push({\n      id: clip.id,\n      src: clip.src,\n      kind: clip.kind,\n      absoluteStart: start,\n      absoluteEnd: Math.max(start, end),\n      sourceIn: clip.clipStart ?? 0,\n      anchor: 'document',\n      ...(clip.sourceLine != null ? { sourceLine: clip.sourceLine } : {}),\n    });\n  }\n\n  return out;\n}\n\n/**\n * Total playback duration including any media that spills past the last\n * block (or audio segment). Export uses this for the frame count and the\n * player for its effective timeline length.\n */\nexport function getDocPlaybackDuration(doc: Doc): number {\n  const base = baseTimelineEnd(doc);\n  const mediaEnd = resolveMediaSchedule(doc).reduce((max, c) => Math.max(max, c.absoluteEnd), 0);\n  return Math.max(base, mediaEnd);\n}\n"],"mappings":";AAwFA,SAAS,QAAQ,QAAiB,MAAe,CAAC,GAAY;AAC5D,aAAW,KAAK,QAAQ;AACtB,QAAI,KAAK,CAAC;AACV,QAAI,EAAE,YAAY,EAAE,SAAS,SAAS,EAAG,SAAQ,EAAE,UAAU,GAAG;AAAA,EAClE;AACA,SAAO;AACT;AAGA,SAAS,WAAW,MAAgC;AAClD,MAAI,KAAK,WAAW,KAAM,QAAO;AACjC,SAAO,KAAK,IAAI,GAAG,KAAK,WAAW,KAAK,aAAa,EAAE;AACzD;AAOA,SAAS,gBAAgB,KAAkB;AACzC,QAAM,WAAW,QAAQ,IAAI,MAAM,EAAE;AAAA,IACnC,CAAC,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,YAAY,EAAE,QAAQ;AAAA,IAClD;AAAA,EACF;AACA,SAAO,KAAK,IAAI,IAAI,YAAY,GAAG,QAAQ;AAC7C;AAMO,SAAS,qBAAqB,KAA2B;AAC9D,QAAM,MAAuB,CAAC;AAC9B,QAAM,SAAS,gBAAgB,GAAG;AAElC,aAAW,SAAS,QAAQ,IAAI,MAAM,GAAG;AACvC,UAAM,WAAW,MAAM,YAAY,MAAM;AACzC,eAAW,QAAQ,MAAM,SAAS,CAAC,GAAG;AACpC,YAAM,QAAQ,MAAM,YAAY,KAAK;AACrC,YAAM,MAAM,WAAW,IAAI;AAC3B,UAAI;AACJ,UAAI,KAAK,WAAW;AAGlB,cAAM,OAAO,OAAO,QAAQ,MAAM;AAAA,MACpC,OAAO;AACL,cAAM,OAAO,OAAO,KAAK,IAAI,QAAQ,KAAK,QAAQ,IAAI;AAAA,MACxD;AACA,UAAI,KAAK;AAAA,QACP,IAAI,KAAK;AAAA,QACT,KAAK,KAAK;AAAA,QACV,MAAM,KAAK;AAAA,QACX,eAAe;AAAA,QACf,aAAa,KAAK,IAAI,OAAO,GAAG;AAAA,QAChC,UAAU,KAAK,aAAa;AAAA,QAC5B,QAAQ;AAAA,QACR,SAAS,MAAM;AAAA,QACf,GAAI,KAAK,cAAc,OAAO,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC;AAAA,MACnE,CAAC;AAAA,IACH;AAAA,EACF;AAEA,aAAW,QAAQ,IAAI,iBAAiB,CAAC,GAAG;AAC1C,UAAM,QAAQ,KAAK;AACnB,UAAM,MAAM,WAAW,IAAI;AAC3B,UAAM,MAAM,OAAO,OAAO,QAAQ,MAAM;AACxC,QAAI,KAAK;AAAA,MACP,IAAI,KAAK;AAAA,MACT,KAAK,KAAK;AAAA,MACV,MAAM,KAAK;AAAA,MACX,eAAe;AAAA,MACf,aAAa,KAAK,IAAI,OAAO,GAAG;AAAA,MAChC,UAAU,KAAK,aAAa;AAAA,MAC5B,QAAQ;AAAA,MACR,GAAI,KAAK,cAAc,OAAO,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC;AAAA,IACnE,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAOO,SAAS,uBAAuB,KAAkB;AACvD,QAAM,OAAO,gBAAgB,GAAG;AAChC,QAAM,WAAW,qBAAqB,GAAG,EAAE,OAAO,CAAC,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,WAAW,GAAG,CAAC;AAC7F,SAAO,KAAK,IAAI,MAAM,QAAQ;AAChC;","names":[]}

package/dist/{chunk-Q3ROPT5H.js → chunk-GZY66SDN.js}

@@ -121,4 +121,4 @@ export {
   getGeohashPath,
   geohashOverlapsBounds
 };
-//# sourceMappingURL=chunk-Q3ROPT5H.js.map
+//# sourceMappingURL=chunk-GZY66SDN.js.map

package/dist/{chunk-Q3ROPT5H.js.map → chunk-GZY66SDN.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/spatial/Haversine.ts","../src/spatial/Geohash.ts"],"sourcesContent":["/**\n * Haversine Distance Calculation\n *\n * Provides accurate distance calculation between two geographic coordinates\n * using the Haversine formula, which accounts for Earth's curvature.\n */\n\nimport type { Coordinates } from '../schemas/Types.js';\n\n/**\n * Calculate distance between two coordinates using Haversine formula.\n *\n * @param from Start coordinates\n * @param to End coordinates\n * @returns Distance in kilometers\n */\nexport function haversineDistance(from: Coordinates, to: Coordinates): number {\n  const R = 6371; // Earth's radius in kilometers\n\n  const dLat = toRadians(to.lat - from.lat);\n  const dLng = toRadians(to.lng - from.lng);\n\n  const a =\n    Math.sin(dLat / 2) * Math.sin(dLat / 2) +\n    Math.cos(toRadians(from.lat)) *\n      Math.cos(toRadians(to.lat)) *\n      Math.sin(dLng / 2) *\n      Math.sin(dLng / 2);\n\n  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n\n  return R * c;\n}\n\n/**\n * Calculate bearing from one coordinate to another.\n *\n * @param from Start coordinates\n * @param to End coordinates\n * @returns Bearing in degrees (0-360, where 0 = north, 90 = east)\n */\nexport function calculateBearing(from: Coordinates, to: Coordinates): number {\n  const dLng = toRadians(to.lng - from.lng);\n  const lat1 = toRadians(from.lat);\n  const lat2 = toRadians(to.lat);\n\n  const x = Math.sin(dLng) * Math.cos(lat2);\n  const y = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLng);\n\n  const bearing = Math.atan2(x, y);\n  return ((bearing * 180) / Math.PI + 360) % 360;\n}\n\n/**\n * Convert degrees to radians.\n */\nfunction toRadians(degrees: number): number {\n  return (degrees * Math.PI) / 180;\n}\n","/**\n * Geohash Utilities\n *\n * Provides geohash encoding/decoding and spatial utilities using the standard\n * ngeohash library for core operations, plus custom utilities for overlap checking\n * and distance calculation.\n *\n * Geohashes are a hierarchical spatial indexing system that divides the world\n * into a grid of cells. Each additional character narrows the area by ~1/32.\n *\n * Precision guide:\n * - 4 chars: ~39km x 19km (used for tile indexing)\n * - 5 chars: ~5km x 5km\n * - 6 chars: ~1.2km x 0.6km\n */\n\nimport ngeohash from 'ngeohash';\nimport { haversineDistance } from './Haversine.js';\n\n/**\n * Encode latitude/longitude to a geohash string.\n * Uses the standard ngeohash library.\n */\nexport function encodeGeohash(lat: number, lng: number, precision = 9): string {\n  return ngeohash.encode(lat, lng, precision);\n}\n\n/**\n * Decode a geohash to latitude/longitude center with error bounds.\n * Uses the standard ngeohash library.\n */\nexport function decodeGeohash(hash: string): {\n  lat: number;\n  lng: number;\n  latErr: number;\n  lngErr: number;\n} {\n  const result = ngeohash.decode(hash);\n  return {\n    lat: result.latitude,\n    lng: result.longitude,\n    latErr: result.error.latitude,\n    lngErr: result.error.longitude,\n  };\n}\n\n/**\n * Get the 8 neighboring geohash cells.\n * Returns up to 8 neighbors (fewer at poles or antimeridian).\n * Uses the standard ngeohash library.\n */\nexport function getNeighbors(hash: string): string[] {\n  return ngeohash.neighbors(hash);\n}\n\n/**\n * Get a 3x3 grid of geohash4 cells (center + 8 neighbors).\n * Used for landing bonus expansions in Fly mode.\n *\n * @param geohash4 - Center geohash4 cell\n * @returns Array of 9 geohash4 cells (center first, then neighbors)\n *\n * @example\n * getGeohash4Neighbors('c23n')\n * // => ['c23n', 'c23p', 'c23q', 'c23j', 'c23m', 'c23k', 'c23h', 'c23e', 'c23s']\n */\nexport function getGeohash4Neighbors(geohash4: string): string[] {\n  if (geohash4.length !== 4) return [];\n  const neighbors = getNeighbors(geohash4);\n  return [geohash4, ...neighbors];\n}\n\n/**\n * Get the prefix of a geohash at a given precision.\n * Simple helper for extracting geohash prefixes for directory organization.\n */\nexport function getGeohashPrefix(geohash: string, precision: number): string {\n  return geohash.slice(0, precision);\n}\n\n/**\n * Convert a geohash prefix to a hierarchical path.\n *\n * Examples:\n *   \"9mud\" -> \"9/m/u/d\"\n *   \"9q8y\" -> \"9/q/8/y\"\n *   \"c24k\" -> \"c/2/4/k\"\n *\n * This is used for organizing files in hierarchical directories to avoid\n * thousands of folders in a single directory, which causes filesystem\n * performance issues.\n */\nexport function geohashToHierarchicalPath(geohash4: string): string {\n  if (geohash4.length !== 4) return '';\n  const [c1, c2, c3, c4] = geohash4.split('');\n  return `${c1}/${c2}/${c3}/${c4}`;\n}\n\n/**\n * Compute all geohash cells along the great-circle path between two geohash cells.\n * Samples points along the spherical arc from `from` to `to`, encoding each to a\n * geohash at the given precision, and returns the deduplicated list of intermediate\n * cells (excluding `from` and `to`).\n *\n * Uses spherical linear interpolation (SLERP) via 3D unit vectors, which correctly\n * handles antimeridian crossings and polar paths — both of which flat lat/lng\n * interpolation gets wrong.\n */\nexport function getGeohashPath(from: string, to: string, precision = 4): string[] {\n  if (from === to) return [];\n\n  const fromCenter = decodeGeohash(from);\n  const toCenter = decodeGeohash(to);\n\n  // Use haversine for accurate great-circle distance (step sizing)\n  const distKm = haversineDistance(\n    { lat: fromCenter.lat, lng: fromCenter.lng },\n    { lat: toCenter.lat, lng: toCenter.lng },\n  );\n\n  // Step every ~15km to avoid skipping any geohash4 cell (~39x19km)\n  const steps = Math.max(2, Math.ceil(distKm / 15));\n\n  // Convert endpoints to unit Cartesian vectors for SLERP\n  const φ1 = (fromCenter.lat * Math.PI) / 180;\n  const λ1 = (fromCenter.lng * Math.PI) / 180;\n  const φ2 = (toCenter.lat * Math.PI) / 180;\n  const λ2 = (toCenter.lng * Math.PI) / 180;\n\n  const x1 = Math.cos(φ1) * Math.cos(λ1);\n  const y1 = Math.cos(φ1) * Math.sin(λ1);\n  const z1 = Math.sin(φ1);\n  const x2 = Math.cos(φ2) * Math.cos(λ2);\n  const y2 = Math.cos(φ2) * Math.sin(λ2);\n  const z2 = Math.sin(φ2);\n\n  // Central angle between the two points\n  const dot = Math.max(-1, Math.min(1, x1 * x2 + y1 * y2 + z1 * z2));\n  const d = Math.acos(dot);\n  // Near-antipodal fallback: sin(d)≈0 means the great circle is undefined.\n  // Extremely unlikely for geohash path use; fall back to linear lat/lng.\n  const useLinear = Math.abs(Math.sin(d)) < 1e-10;\n\n  const seen = new Set<string>();\n  seen.add(from);\n  seen.add(to);\n\n  const path: string[] = [];\n  for (let i = 1; i < steps; i++) {\n    const t = i / steps;\n    let lat: number;\n    let lng: number;\n    if (useLinear) {\n      lat = fromCenter.lat + t * (toCenter.lat - fromCenter.lat);\n      lng = fromCenter.lng + t * (toCenter.lng - fromCenter.lng);\n    } else {\n      const A = Math.sin((1 - t) * d) / Math.sin(d);\n      const B = Math.sin(t * d) / Math.sin(d);\n      const x = A * x1 + B * x2;\n      const y = A * y1 + B * y2;\n      const z = A * z1 + B * z2;\n      lat = (Math.atan2(z, Math.sqrt(x * x + y * y)) * 180) / Math.PI;\n      lng = (Math.atan2(y, x) * 180) / Math.PI;\n    }\n    const hash = encodeGeohash(lat, lng, precision);\n    if (!seen.has(hash)) {\n      seen.add(hash);\n      path.push(hash);\n    }\n  }\n\n  return path;\n}\n\n/**\n * Check if a geohash cell overlaps with a bounding box.\n * Custom implementation (not available in ngeohash).\n */\nexport function geohashOverlapsBounds(\n  hash: string,\n  bounds: { north: number; south: number; east: number; west: number },\n): boolean {\n  const { lat, lng, latErr, lngErr } = decodeGeohash(hash);\n\n  const hashNorth = lat + latErr;\n  const hashSouth = lat - latErr;\n  const hashEast = lng + lngErr;\n  const hashWest = lng - lngErr;\n\n  return !(\n    hashNorth < bounds.south ||\n    hashSouth > bounds.north ||\n    hashEast < bounds.west ||\n    hashWest > bounds.east\n  );\n}\n\n// Re-export for backwards compatibility with existing imports.\nexport { haversineDistance };\n"],"mappings":";AAgBO,SAAS,kBAAkB,MAAmB,IAAyB;AAC5E,QAAM,IAAI;AAEV,QAAM,OAAO,UAAU,GAAG,MAAM,KAAK,GAAG;AACxC,QAAM,OAAO,UAAU,GAAG,MAAM,KAAK,GAAG;AAExC,QAAM,IACJ,KAAK,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,OAAO,CAAC,IACtC,KAAK,IAAI,UAAU,KAAK,GAAG,CAAC,IAC1B,KAAK,IAAI,UAAU,GAAG,GAAG,CAAC,IAC1B,KAAK,IAAI,OAAO,CAAC,IACjB,KAAK,IAAI,OAAO,CAAC;AAErB,QAAM,IAAI,IAAI,KAAK,MAAM,KAAK,KAAK,CAAC,GAAG,KAAK,KAAK,IAAI,CAAC,CAAC;AAEvD,SAAO,IAAI;AACb;AASO,SAAS,iBAAiB,MAAmB,IAAyB;AAC3E,QAAM,OAAO,UAAU,GAAG,MAAM,KAAK,GAAG;AACxC,QAAM,OAAO,UAAU,KAAK,GAAG;AAC/B,QAAM,OAAO,UAAU,GAAG,GAAG;AAE7B,QAAM,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI;AACxC,QAAM,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI;AAE3F,QAAM,UAAU,KAAK,MAAM,GAAG,CAAC;AAC/B,UAAS,UAAU,MAAO,KAAK,KAAK,OAAO;AAC7C;AAKA,SAAS,UAAU,SAAyB;AAC1C,SAAQ,UAAU,KAAK,KAAM;AAC/B;;;AC1CA,OAAO,cAAc;AAOd,SAAS,cAAc,KAAa,KAAa,YAAY,GAAW;AAC7E,SAAO,SAAS,OAAO,KAAK,KAAK,SAAS;AAC5C;AAMO,SAAS,cAAc,MAK5B;AACA,QAAM,SAAS,SAAS,OAAO,IAAI;AACnC,SAAO;AAAA,IACL,KAAK,OAAO;AAAA,IACZ,KAAK,OAAO;AAAA,IACZ,QAAQ,OAAO,MAAM;AAAA,IACrB,QAAQ,OAAO,MAAM;AAAA,EACvB;AACF;AAOO,SAAS,aAAa,MAAwB;AACnD,SAAO,SAAS,UAAU,IAAI;AAChC;AAaO,SAAS,qBAAqB,UAA4B;AAC/D,MAAI,SAAS,WAAW,EAAG,QAAO,CAAC;AACnC,QAAM,YAAY,aAAa,QAAQ;AACvC,SAAO,CAAC,UAAU,GAAG,SAAS;AAChC;AAMO,SAAS,iBAAiB,SAAiB,WAA2B;AAC3E,SAAO,QAAQ,MAAM,GAAG,SAAS;AACnC;AAcO,SAAS,0BAA0B,UAA0B;AAClE,MAAI,SAAS,WAAW,EAAG,QAAO;AAClC,QAAM,CAAC,IAAI,IAAI,IAAI,EAAE,IAAI,SAAS,MAAM,EAAE;AAC1C,SAAO,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;AAChC;AAYO,SAAS,eAAe,MAAc,IAAY,YAAY,GAAa;AAChF,MAAI,SAAS,GAAI,QAAO,CAAC;AAEzB,QAAM,aAAa,cAAc,IAAI;AACrC,QAAM,WAAW,cAAc,EAAE;AAGjC,QAAM,SAAS;AAAA,IACb,EAAE,KAAK,WAAW,KAAK,KAAK,WAAW,IAAI;AAAA,IAC3C,EAAE,KAAK,SAAS,KAAK,KAAK,SAAS,IAAI;AAAA,EACzC;AAGA,QAAM,QAAQ,KAAK,IAAI,GAAG,KAAK,KAAK,SAAS,EAAE,CAAC;AAGhD,QAAM,UAAM,WAAW,MAAM,KAAK,KAAM;AACxC,QAAM,UAAM,WAAW,MAAM,KAAK,KAAM;AACxC,QAAM,UAAM,SAAS,MAAM,KAAK,KAAM;AACtC,QAAM,UAAM,SAAS,MAAM,KAAK,KAAM;AAEtC,QAAM,KAAK,KAAK,IAAI,OAAE,IAAI,KAAK,IAAI,OAAE;AACrC,QAAM,KAAK,KAAK,IAAI,OAAE,IAAI,KAAK,IAAI,OAAE;AACrC,QAAM,KAAK,KAAK,IAAI,OAAE;AACtB,QAAM,KAAK,KAAK,IAAI,OAAE,IAAI,KAAK,IAAI,OAAE;AACrC,QAAM,KAAK,KAAK,IAAI,OAAE,IAAI,KAAK,IAAI,OAAE;AACrC,QAAM,KAAK,KAAK,IAAI,OAAE;AAGtB,QAAM,MAAM,KAAK,IAAI,IAAI,KAAK,IAAI,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,CAAC;AACjE,QAAM,IAAI,KAAK,KAAK,GAAG;AAGvB,QAAM,YAAY,KAAK,IAAI,KAAK,IAAI,CAAC,CAAC,IAAI;AAE1C,QAAM,OAAO,oBAAI,IAAY;AAC7B,OAAK,IAAI,IAAI;AACb,OAAK,IAAI,EAAE;AAEX,QAAM,OAAiB,CAAC;AACxB,WAAS,IAAI,GAAG,IAAI,OAAO,KAAK;AAC9B,UAAM,IAAI,IAAI;AACd,QAAI;AACJ,QAAI;AACJ,QAAI,WAAW;AACb,YAAM,WAAW,MAAM,KAAK,SAAS,MAAM,WAAW;AACtD,YAAM,WAAW,MAAM,KAAK,SAAS,MAAM,WAAW;AAAA,IACxD,OAAO;AACL,YAAM,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC;AAC5C,YAAM,IAAI,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC;AACtC,YAAM,IAAI,IAAI,KAAK,IAAI;AACvB,YAAM,IAAI,IAAI,KAAK,IAAI;AACvB,YAAM,IAAI,IAAI,KAAK,IAAI;AACvB,YAAO,KAAK,MAAM,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,CAAC,CAAC,IAAI,MAAO,KAAK;AAC7D,YAAO,KAAK,MAAM,GAAG,CAAC,IAAI,MAAO,KAAK;AAAA,IACxC;AACA,UAAM,OAAO,cAAc,KAAK,KAAK,SAAS;AAC9C,QAAI,CAAC,KAAK,IAAI,IAAI,GAAG;AACnB,WAAK,IAAI,IAAI;AACb,WAAK,KAAK,IAAI;AAAA,IAChB;AAAA,EACF;AAEA,SAAO;AACT;AAMO,SAAS,sBACd,MACA,QACS;AACT,QAAM,EAAE,KAAK,KAAK,QAAQ,OAAO,IAAI,cAAc,IAAI;AAEvD,QAAM,YAAY,MAAM;AACxB,QAAM,YAAY,MAAM;AACxB,QAAM,WAAW,MAAM;AACvB,QAAM,WAAW,MAAM;AAEvB,SAAO,EACL,YAAY,OAAO,SACnB,YAAY,OAAO,SACnB,WAAW,OAAO,QAClB,WAAW,OAAO;AAEtB;","names":[]}
+{"version":3,"sources":["../src/spatial/Haversine.ts","../src/spatial/Geohash.ts"],"sourcesContent":["/**\n * Haversine Distance Calculation\n *\n * Provides accurate distance calculation between two geographic coordinates\n * using the Haversine formula, which accounts for Earth's curvature.\n */\n\nimport type { Coordinates } from '../schemas/Types.js';\n\n/**\n * Calculate distance between two coordinates using Haversine formula.\n *\n * @param from Start coordinates\n * @param to End coordinates\n * @returns Distance in kilometers\n */\nexport function haversineDistance(from: Coordinates, to: Coordinates): number {\n  const R = 6371; // Earth's radius in kilometers\n\n  const dLat = toRadians(to.lat - from.lat);\n  const dLng = toRadians(to.lng - from.lng);\n\n  const a =\n    Math.sin(dLat / 2) * Math.sin(dLat / 2) +\n    Math.cos(toRadians(from.lat)) *\n      Math.cos(toRadians(to.lat)) *\n      Math.sin(dLng / 2) *\n      Math.sin(dLng / 2);\n\n  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n\n  return R * c;\n}\n\n/**\n * Calculate bearing from one coordinate to another.\n *\n * @param from Start coordinates\n * @param to End coordinates\n * @returns Bearing in degrees (0-360, where 0 = north, 90 = east)\n */\nexport function calculateBearing(from: Coordinates, to: Coordinates): number {\n  const dLng = toRadians(to.lng - from.lng);\n  const lat1 = toRadians(from.lat);\n  const lat2 = toRadians(to.lat);\n\n  const x = Math.sin(dLng) * Math.cos(lat2);\n  const y = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLng);\n\n  const bearing = Math.atan2(x, y);\n  return ((bearing * 180) / Math.PI + 360) % 360;\n}\n\n/**\n * Convert degrees to radians.\n */\nfunction toRadians(degrees: number): number {\n  return (degrees * Math.PI) / 180;\n}\n","/**\n * Geohash Utilities\n *\n * Provides geohash encoding/decoding and spatial utilities using the standard\n * ngeohash library for core operations, plus custom utilities for overlap checking\n * and distance calculation.\n *\n * Geohashes are a hierarchical spatial indexing system that divides the world\n * into a grid of cells. Each additional character narrows the area by ~1/32.\n *\n * Precision guide:\n * - 4 chars: ~39km x 19km (used for tile indexing)\n * - 5 chars: ~5km x 5km\n * - 6 chars: ~1.2km x 0.6km\n */\n\nimport ngeohash from 'ngeohash';\nimport { haversineDistance } from './Haversine.js';\n\n/**\n * Encode latitude/longitude to a geohash string.\n * Uses the standard ngeohash library.\n */\nexport function encodeGeohash(lat: number, lng: number, precision = 9): string {\n  return ngeohash.encode(lat, lng, precision);\n}\n\n/**\n * Decode a geohash to latitude/longitude center with error bounds.\n * Uses the standard ngeohash library.\n */\nexport function decodeGeohash(hash: string): {\n  lat: number;\n  lng: number;\n  latErr: number;\n  lngErr: number;\n} {\n  const result = ngeohash.decode(hash);\n  return {\n    lat: result.latitude,\n    lng: result.longitude,\n    latErr: result.error.latitude,\n    lngErr: result.error.longitude,\n  };\n}\n\n/**\n * Get the 8 neighboring geohash cells.\n * Returns up to 8 neighbors (fewer at poles or antimeridian).\n * Uses the standard ngeohash library.\n */\nexport function getNeighbors(hash: string): string[] {\n  return ngeohash.neighbors(hash);\n}\n\n/**\n * Get a 3x3 grid of geohash4 cells (center + 8 neighbors).\n * Used for landing bonus expansions in Fly mode.\n *\n * @param geohash4 - Center geohash4 cell\n * @returns Array of 9 geohash4 cells (center first, then neighbors)\n *\n * @example\n * getGeohash4Neighbors('c23n')\n * // => ['c23n', 'c23p', 'c23q', 'c23j', 'c23m', 'c23k', 'c23h', 'c23e', 'c23s']\n */\nexport function getGeohash4Neighbors(geohash4: string): string[] {\n  if (geohash4.length !== 4) return [];\n  const neighbors = getNeighbors(geohash4);\n  return [geohash4, ...neighbors];\n}\n\n/**\n * Get the prefix of a geohash at a given precision.\n * Simple helper for extracting geohash prefixes for directory organization.\n */\nexport function getGeohashPrefix(geohash: string, precision: number): string {\n  return geohash.slice(0, precision);\n}\n\n/**\n * Convert a geohash prefix to a hierarchical path.\n *\n * Examples:\n *   \"9mud\" -> \"9/m/u/d\"\n *   \"9q8y\" -> \"9/q/8/y\"\n *   \"c24k\" -> \"c/2/4/k\"\n *\n * This is used for organizing files in hierarchical directories to avoid\n * thousands of folders in a single directory, which causes filesystem\n * performance issues.\n */\nexport function geohashToHierarchicalPath(geohash4: string): string {\n  if (geohash4.length !== 4) return '';\n  const [c1, c2, c3, c4] = geohash4.split('');\n  return `${c1}/${c2}/${c3}/${c4}`;\n}\n\n/**\n * Compute all geohash cells along the great-circle path between two geohash cells.\n * Samples points along the spherical arc from `from` to `to`, encoding each to a\n * geohash at the given precision, and returns the deduplicated list of intermediate\n * cells (excluding `from` and `to`).\n *\n * Uses spherical linear interpolation (SLERP) via 3D unit vectors, which correctly\n * handles antimeridian crossings and polar paths — both of which flat lat/lng\n * interpolation gets wrong.\n */\nexport function getGeohashPath(from: string, to: string, precision = 4): string[] {\n  if (from === to) return [];\n\n  const fromCenter = decodeGeohash(from);\n  const toCenter = decodeGeohash(to);\n\n  // Use haversine for accurate great-circle distance (step sizing)\n  const distKm = haversineDistance(\n    { lat: fromCenter.lat, lng: fromCenter.lng },\n    { lat: toCenter.lat, lng: toCenter.lng },\n  );\n\n  // Step every ~15km to avoid skipping any geohash4 cell (~39x19km)\n  const steps = Math.max(2, Math.ceil(distKm / 15));\n\n  // Convert endpoints to unit Cartesian vectors for SLERP\n  const φ1 = (fromCenter.lat * Math.PI) / 180;\n  const λ1 = (fromCenter.lng * Math.PI) / 180;\n  const φ2 = (toCenter.lat * Math.PI) / 180;\n  const λ2 = (toCenter.lng * Math.PI) / 180;\n\n  const x1 = Math.cos(φ1) * Math.cos(λ1);\n  const y1 = Math.cos(φ1) * Math.sin(λ1);\n  const z1 = Math.sin(φ1);\n  const x2 = Math.cos(φ2) * Math.cos(λ2);\n  const y2 = Math.cos(φ2) * Math.sin(λ2);\n  const z2 = Math.sin(φ2);\n\n  // Central angle between the two points\n  const dot = Math.max(-1, Math.min(1, x1 * x2 + y1 * y2 + z1 * z2));\n  const d = Math.acos(dot);\n  // Near-antipodal fallback: sin(d)≈0 means the great circle is undefined.\n  // Extremely unlikely for geohash path use; fall back to linear lat/lng.\n  const useLinear = Math.abs(Math.sin(d)) < 1e-10;\n\n  const seen = new Set<string>();\n  seen.add(from);\n  seen.add(to);\n\n  const path: string[] = [];\n  for (let i = 1; i < steps; i++) {\n    const t = i / steps;\n    let lat: number;\n    let lng: number;\n    if (useLinear) {\n      lat = fromCenter.lat + t * (toCenter.lat - fromCenter.lat);\n      lng = fromCenter.lng + t * (toCenter.lng - fromCenter.lng);\n    } else {\n      const A = Math.sin((1 - t) * d) / Math.sin(d);\n      const B = Math.sin(t * d) / Math.sin(d);\n      const x = A * x1 + B * x2;\n      const y = A * y1 + B * y2;\n      const z = A * z1 + B * z2;\n      lat = (Math.atan2(z, Math.sqrt(x * x + y * y)) * 180) / Math.PI;\n      lng = (Math.atan2(y, x) * 180) / Math.PI;\n    }\n    const hash = encodeGeohash(lat, lng, precision);\n    if (!seen.has(hash)) {\n      seen.add(hash);\n      path.push(hash);\n    }\n  }\n\n  return path;\n}\n\n/**\n * Check if a geohash cell overlaps with a bounding box.\n * Custom implementation (not available in ngeohash).\n */\nexport function geohashOverlapsBounds(\n  hash: string,\n  bounds: { north: number; south: number; east: number; west: number },\n): boolean {\n  const { lat, lng, latErr, lngErr } = decodeGeohash(hash);\n\n  const hashNorth = lat + latErr;\n  const hashSouth = lat - latErr;\n  const hashEast = lng + lngErr;\n  const hashWest = lng - lngErr;\n\n  return !(\n    hashNorth < bounds.south ||\n    hashSouth > bounds.north ||\n    hashEast < bounds.west ||\n    hashWest > bounds.east\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-JOQYPRDZ.js

@@ -0,0 +1,127 @@
+import {
+  buildSnapshotPath,
+  coalesceSnapshots,
+  listSnapshots,
+  parseSnapshotPath,
+  pruneSnapshots,
+  readTextSnapshot,
+  saveTextSnapshot
+} from "./chunk-S7A5D7ZJ.js";
+
+// src/versions/paths.ts
+var VERSIONS_PREFIX = ".versions/";
+var DOCUMENT_VERSION_PATHS = Object.freeze({
+  prefix: VERSIONS_PREFIX,
+  extension: "md"
+});
+function getDocBasename(documentPath) {
+  const slash = documentPath.lastIndexOf("/");
+  const file = slash >= 0 ? documentPath.slice(slash + 1) : documentPath;
+  const dot = file.lastIndexOf(".");
+  return dot > 0 ? file.slice(0, dot) : file;
+}
+function buildVersionPath(basename, date, collision = 0) {
+  return buildSnapshotPath(DOCUMENT_VERSION_PATHS, basename, date, collision);
+}
+function parseVersionPath(path) {
+  return parseSnapshotPath(DOCUMENT_VERSION_PATHS, path);
+}
+
+// src/versions/operations.ts
+async function resolveBasename(container, override) {
+  if (override) return override;
+  const docPath = await container.getDocumentPath();
+  if (!docPath) return null;
+  return getDocBasename(docPath);
+}
+async function resolveDocPath(container) {
+  const docPath = await container.getDocumentPath();
+  return docPath ?? "index.md";
+}
+async function listVersions(container, basename) {
+  return listSnapshots(container, DOCUMENT_VERSION_PATHS, basename);
+}
+async function readVersion(container, version) {
+  return readTextSnapshot(container, version);
+}
+async function saveVersion(container, options = {}) {
+  const content = options.content ?? await container.readDocument();
+  if (content === null || content === void 0) {
+    return { saved: false, version: null, reason: "no-document" };
+  }
+  if (content.length === 0) {
+    return { saved: false, version: null, reason: "empty" };
+  }
+  const basename = await resolveBasename(container, options.basename);
+  if (!basename) {
+    return { saved: false, version: null, reason: "no-document" };
+  }
+  return saveTextSnapshot(container, DOCUMENT_VERSION_PATHS, {
+    content,
+    basename,
+    mimeType: "text/markdown",
+    now: options.now,
+    force: options.force
+  });
+}
+async function revertToVersion(container, version, options = {}) {
+  const content = await readVersion(container, version);
+  if (content === null) {
+    return { reverted: false, snapshotted: null };
+  }
+  let snapshotted = null;
+  if (options.snapshotCurrent !== false) {
+    const result = await saveVersion(container);
+    snapshotted = result.version;
+  }
+  const docPath = await resolveDocPath(container);
+  await container.writeDocument(content, docPath);
+  return { reverted: true, snapshotted };
+}
+async function pruneVersions(container, policy, basename) {
+  return pruneSnapshots(container, DOCUMENT_VERSION_PATHS, policy, basename);
+}
+async function coalesceVersions(container, options = {}, basename) {
+  return coalesceSnapshots(container, DOCUMENT_VERSION_PATHS, options, basename);
+}
+
+// src/versions/DocumentVersionManager.ts
+var DocumentVersionManager = class {
+  constructor(container, options = {}) {
+    this.container = container;
+    this.basename = options.basename;
+  }
+  saveVersion(options = {}) {
+    return saveVersion(this.container, { basename: this.basename, ...options });
+  }
+  listVersions() {
+    return listVersions(this.container, this.basename);
+  }
+  readVersion(version) {
+    return readVersion(this.container, version);
+  }
+  revertToVersion(version, options) {
+    return revertToVersion(this.container, version, options);
+  }
+  pruneVersions(policy) {
+    return pruneVersions(this.container, policy, this.basename);
+  }
+  coalesceVersions(options) {
+    return coalesceVersions(this.container, options, this.basename);
+  }
+};
+
+export {
+  VERSIONS_PREFIX,
+  getDocBasename,
+  buildVersionPath,
+  parseVersionPath,
+  listVersions,
+  readVersion,
+  saveVersion,
+  revertToVersion,
+  pruneVersions,
+  coalesceVersions,
+  DocumentVersionManager
+};
+//# sourceMappingURL=chunk-JOQYPRDZ.js.map

package/dist/chunk-JOQYPRDZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/versions/paths.ts","../src/versions/operations.ts","../src/versions/DocumentVersionManager.ts"],"sourcesContent":["/**\n * Path conventions for version snapshots.\n *\n * Snapshots live at `<VERSIONS_PREFIX><basename>.<timestamp>[<-suffix>].md`.\n * The optional numeric suffix (`-2`, `-3`, ...) is appended only when two\n * snapshots collide on the same UTC second.\n */\n\nimport {\n  buildSnapshotPath,\n  parseSnapshotPath,\n  type SnapshotPathStrategy,\n} from './snapshotStore.js';\n\n/** Subfolder (inside the ContentContainer) that holds version snapshots. */\nexport const VERSIONS_PREFIX = '.versions/';\n\n/** Internal strategy shared with the generic snapshot store. */\nexport const DOCUMENT_VERSION_PATHS: SnapshotPathStrategy = Object.freeze({\n  prefix: VERSIONS_PREFIX,\n  extension: 'md',\n});\n\n/**\n * Strip the directory and extension from a document path to produce the\n * basename used in version filenames. `subdir/index.md` -> `index`.\n */\nexport function getDocBasename(documentPath: string): string {\n  const slash = documentPath.lastIndexOf('/');\n  const file = slash >= 0 ? documentPath.slice(slash + 1) : documentPath;\n  const dot = file.lastIndexOf('.');\n  return dot > 0 ? file.slice(0, dot) : file;\n}\n\n/**\n * Build a version snapshot path. Optionally append a collision suffix\n * (e.g. `2`, `3`) when two saves land on the same UTC second.\n */\nexport function buildVersionPath(basename: string, date: Date, collision = 0): string {\n  return buildSnapshotPath(DOCUMENT_VERSION_PATHS, basename, date, collision);\n}\n\n/**\n * Parse a version snapshot path. Returns null if it doesn't match the\n * convention (so unrelated files stored under `.versions/` are ignored).\n */\nexport function parseVersionPath(\n  path: string,\n): { basename: string; timestamp: Date; collision: number } | null {\n  return parseSnapshotPath(DOCUMENT_VERSION_PATHS, path);\n}\n","/**\n * Pure-ish version operations against a {@link ContentContainer}.\n *\n * These functions are the canonical implementation. {@link DocumentVersionManager}\n * is a thin wrapper that captures a container reference for ergonomics.\n */\n\nimport type { ContentContainer } from '../storage/ContentContainer.js';\nimport { DOCUMENT_VERSION_PATHS, getDocBasename } from './paths.js';\nimport {\n  coalesceSnapshots,\n  listSnapshots,\n  pruneSnapshots,\n  readTextSnapshot,\n  saveTextSnapshot,\n} from './snapshotStore.js';\nimport type {\n  CoalesceOptions,\n  PrunePolicy,\n  RevertOptions,\n  SaveVersionOptions,\n  SaveVersionResult,\n  Version,\n} from './types.js';\n\nasync function resolveBasename(\n  container: ContentContainer,\n  override: string | undefined,\n): Promise<string | null> {\n  if (override) return override;\n  const docPath = await container.getDocumentPath();\n  if (!docPath) return null;\n  return getDocBasename(docPath);\n}\n\nasync function resolveDocPath(container: ContentContainer): Promise<string> {\n  // Default to `index.md` when the container has no document yet — matches\n  // `MemoryContentContainer.writeDocument`'s default.\n  const docPath = await container.getDocumentPath();\n  return docPath ?? 'index.md';\n}\n\n/**\n * List all snapshots in the container, newest-first.\n *\n * @param basename Optional filter: when set, only versions whose basename\n *   matches are returned.\n */\nexport async function listVersions(\n  container: ContentContainer,\n  basename?: string,\n): Promise<Version[]> {\n  return listSnapshots(container, DOCUMENT_VERSION_PATHS, basename);\n}\n\n/**\n * Read the markdown content of a snapshot. Returns null if the snapshot\n * doesn't exist.\n */\nexport async function readVersion(\n  container: ContentContainer,\n  version: Version | string,\n): Promise<string | null> {\n  return readTextSnapshot(container, version);\n}\n\n/**\n * Save a new snapshot of the document if its content differs from the\n * latest existing snapshot.\n */\nexport async function saveVersion(\n  container: ContentContainer,\n  options: SaveVersionOptions = {},\n): Promise<SaveVersionResult> {\n  const content = options.content ?? (await container.readDocument());\n  if (content === null || content === undefined) {\n    return { saved: false, version: null, reason: 'no-document' };\n  }\n  if (content.length === 0) {\n    return { saved: false, version: null, reason: 'empty' };\n  }\n\n  const basename = await resolveBasename(container, options.basename);\n  if (!basename) {\n    return { saved: false, version: null, reason: 'no-document' };\n  }\n\n  return saveTextSnapshot(container, DOCUMENT_VERSION_PATHS, {\n    content,\n    basename,\n    mimeType: 'text/markdown',\n    now: options.now,\n    force: options.force,\n  });\n}\n\n/**\n * Revert the document to a prior snapshot. By default, the *current*\n * document is snapshotted first so the revert is itself recoverable.\n */\nexport async function revertToVersion(\n  container: ContentContainer,\n  version: Version | string,\n  options: RevertOptions = {},\n): Promise<{ reverted: boolean; snapshotted: Version | null }> {\n  const content = await readVersion(container, version);\n  if (content === null) {\n    return { reverted: false, snapshotted: null };\n  }\n\n  let snapshotted: Version | null = null;\n  if (options.snapshotCurrent !== false) {\n    const result = await saveVersion(container);\n    snapshotted = result.version;\n  }\n\n  const docPath = await resolveDocPath(container);\n  await container.writeDocument(content, docPath);\n  return { reverted: true, snapshotted };\n}\n\n/**\n * Delete snapshots that don't satisfy the policy. Returns the deleted\n * versions in their original (newest-first) order.\n */\nexport async function pruneVersions(\n  container: ContentContainer,\n  policy: PrunePolicy,\n  basename?: string,\n): Promise<Version[]> {\n  return pruneSnapshots(container, DOCUMENT_VERSION_PATHS, policy, basename);\n}\n\n/**\n * Collapse adjacent snapshots that occurred close together — keeping the\n * newer one — to keep history readable across rapid edits.\n */\nexport async function coalesceVersions(\n  container: ContentContainer,\n  options: CoalesceOptions = {},\n  basename?: string,\n): Promise<Version[]> {\n  return coalesceSnapshots(container, DOCUMENT_VERSION_PATHS, options, basename);\n}\n","/**\n * Convenience wrapper around the version operations that captures a\n * {@link ContentContainer} reference and an optional basename override.\n *\n * Hosts that prefer a stable handle (e.g. to pass into a UI component)\n * use this; everything it does is also reachable as a free function.\n */\n\nimport type { ContentContainer } from '../storage/ContentContainer.js';\nimport {\n  coalesceVersions,\n  listVersions,\n  pruneVersions,\n  readVersion,\n  revertToVersion,\n  saveVersion,\n} from './operations.js';\nimport type {\n  CoalesceOptions,\n  PrunePolicy,\n  RevertOptions,\n  SaveVersionOptions,\n  SaveVersionResult,\n  Version,\n} from './types.js';\n\nexport interface DocumentVersionManagerOptions {\n  /**\n   * Override the document basename used in version filenames. Defaults to\n   * the basename of `container.getDocumentPath()` resolved at call time.\n   */\n  basename?: string;\n}\n\nexport class DocumentVersionManager {\n  private readonly container: ContentContainer;\n  private readonly basename: string | undefined;\n\n  constructor(container: ContentContainer, options: DocumentVersionManagerOptions = {}) {\n    this.container = container;\n    this.basename = options.basename;\n  }\n\n  saveVersion(options: SaveVersionOptions = {}): Promise<SaveVersionResult> {\n    return saveVersion(this.container, { basename: this.basename, ...options });\n  }\n\n  listVersions(): Promise<Version[]> {\n    return listVersions(this.container, this.basename);\n  }\n\n  readVersion(version: Version | string): Promise<string | null> {\n    return readVersion(this.container, version);\n  }\n\n  revertToVersion(\n    version: Version | string,\n    options?: RevertOptions,\n  ): Promise<{ reverted: boolean; snapshotted: Version | null }> {\n    return revertToVersion(this.container, version, options);\n  }\n\n  pruneVersions(policy: PrunePolicy): Promise<Version[]> {\n    return pruneVersions(this.container, policy, this.basename);\n  }\n\n  coalesceVersions(options?: CoalesceOptions): Promise<Version[]> {\n    return coalesceVersions(this.container, options, this.basename);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-A4O7GIWE.js → chunk-MMPBOUK7.js}

@@ -2,12 +2,14 @@ import {
   THEME_SCHEMA_VERSION,
   assertTheme,
   createTheme,
+  deriveScale,
+  isHex,
   oklchDarken,
   oklchLighten,
   oklchSetChroma,
   pickContrastingText,
   relativeLuminance
-} from "./chunk-KKNUBQ6Y.js";
+} from "./chunk-W4O2TX5I.js";
 
 // src/schemas/Doc.ts
 function calculateDuration(audio) {
@@ -40,75 +42,6 @@ function getCaptionAtTime(captions, time) {
   return null;
 }
 
-// src/schemas/Media.ts
-function flatten(blocks, out = []) {
-  for (const b of blocks) {
-    out.push(b);
-    if (b.children && b.children.length > 0) flatten(b.children, out);
-  }
-  return out;
-}
-function clipLength(clip) {
-  if (clip.clipEnd == null) return null;
-  return Math.max(0, clip.clipEnd - (clip.clipStart ?? 0));
-}
-function baseTimelineEnd(doc) {
-  const blockEnd = flatten(doc.blocks).reduce(
-    (max, b) => Math.max(max, b.startTime + b.duration),
-    0
-  );
-  return Math.max(doc.duration ?? 0, blockEnd);
-}
-function resolveMediaSchedule(doc) {
-  const out = [];
-  const docEnd = baseTimelineEnd(doc);
-  for (const block of flatten(doc.blocks)) {
-    const blockEnd = block.startTime + block.duration;
-    for (const clip of block.media ?? []) {
-      const start = block.startTime + clip.startAt;
-      const len = clipLength(clip);
-      let end;
-      if (clip.spillover) {
-        end = len != null ? start + len : blockEnd;
-      } else {
-        end = len != null ? Math.min(start + len, blockEnd) : blockEnd;
-      }
-      out.push({
-        id: clip.id,
-        src: clip.src,
-        kind: clip.kind,
-        absoluteStart: start,
-        absoluteEnd: Math.max(start, end),
-        sourceIn: clip.clipStart ?? 0,
-        anchor: "block",
-        blockId: block.id,
-        ...clip.sourceLine != null ? { sourceLine: clip.sourceLine } : {}
-      });
-    }
-  }
-  for (const clip of doc.documentMedia ?? []) {
-    const start = clip.startAt;
-    const len = clipLength(clip);
-    const end = len != null ? start + len : docEnd;
-    out.push({
-      id: clip.id,
-      src: clip.src,
-      kind: clip.kind,
-      absoluteStart: start,
-      absoluteEnd: Math.max(start, end),
-      sourceIn: clip.clipStart ?? 0,
-      anchor: "document",
-      ...clip.sourceLine != null ? { sourceLine: clip.sourceLine } : {}
-    });
-  }
-  return out;
-}
-function getDocPlaybackDuration(doc) {
-  const base = baseTimelineEnd(doc);
-  const mediaEnd = resolveMediaSchedule(doc).reduce((max, c) => Math.max(max, c.absoluteEnd), 0);
-  return Math.max(base, mediaEnd);
-}
-
 // src/schemas/themeCompile.ts
 var STARTER_BODY_FONT = { stackId: "system-sans" };
 var STARTER_TITLE_FONT = { stackId: "system-serif" };
@@ -186,6 +119,11 @@ function deriveColorPalette(seeds, partialColors = {}, opts = {}) {
     warning
   };
 }
+function accentToColorScheme(accent) {
+  if (!isHex(accent)) return { bg: "#1a202c", text: "#e2e8f0", accent: "#63b3ed" };
+  const scale = deriveScale(accent, 0.3);
+  return { bg: scale.darker2, text: scale.lighter2, accent: scale.base };
+}
 function compileTheme(partial, opts = {}) {
   const base = opts.base ?? STARTER_THEME;
   const merged = createTheme(base, partial);
@@ -233,12 +171,11 @@ export {
   getSegmentAtTime,
   getBlockAtTime,
   getCaptionAtTime,
-  resolveMediaSchedule,
-  getDocPlaybackDuration,
   STARTER_THEME,
   deriveColorPalette,
+  accentToColorScheme,
   compileTheme,
   parseTheme,
   serializeTheme
 };
-//# sourceMappingURL=chunk-A4O7GIWE.js.map
+//# sourceMappingURL=chunk-MMPBOUK7.js.map