{
  "text": "And God said, Let there be light, and there was light.",
  "start_time": 3.045,
  "duration": 3.535,
  "words": [
    {"word": "And",    "start": 3.057, "end": 3.395, "confidence": 0.73},
    {"word": "God",    "start": 3.395, "end": 3.758, "confidence": 0.96},
    {"word": "said,",  "start": 3.758, "end": 4.025, "confidence": 0.86},
    {"word": "Let",    "start": 4.025, "end": 4.169, "confidence": 0.68},
    {"word": "there",  "start": 4.169, "end": 4.315, "confidence": 0.99},
    {"word": "be",     "start": 4.315, "end": 4.871, "confidence": 1.00},
    {"word": "light,", "start": 4.871, "end": 5.258, "confidence": 0.88},
    {"word": "and",    "start": 5.258, "end": 5.402, "confidence": 0.96},
    {"word": "there",  "start": 5.402, "end": 5.548, "confidence": 1.00},
    {"word": "was",    "start": 5.548, "end": 6.030, "confidence": 1.00},
    {"word": "light.", "start": 6.030, "end": 6.575, "confidence": 0.97}
  ]
}

moonshine_option_t options[] = {
    { "word_timestamps", "true" },
};
int32_t handle = moonshine_load_transcriber_from_files(
    model_path, MOONSHINE_MODEL_ARCH_TINY, // or MOONSHINE_MODEL_ARCH_TINY_STREAMING
    options, 1, moonshine_get_version());

for (uint64_t i = 0; i < transcript->line_count; i++) {
    transcript_line_t *line = &transcript->lines[i];
    for (uint64_t j = 0; j < line->word_count; j++) {
        transcript_word_t *word = &line->words[j];
        printf("[%.3fs - %.3fs] %s (conf: %.2f)\n",
               word->start, word->end, word->text, word->confidence);
    }
}

moonshine::Transcriber transcriber(modelPath, moonshine::ModelArch::TINY,
    {{"word_timestamps", "true"}});

auto transcript = transcriber.transcribeWithoutStreaming(audioData, 16000);
for (auto &line : transcript.lines) {
    for (auto &word : line.words) {
        std::cout << "[" << word.start << "s - " << word.end << "s] "
                  << word.word << " (conf: " << word.confidence << ")\n";
    }
}

from moonshine_voice import Transcriber, ModelArch

transcriber = Transcriber(model_path, ModelArch.TINY,
    options={"word_timestamps": "true"})
transcript = transcriber.transcribe_without_streaming(audio_data)

for line in transcript.lines:
    if line.words:
        for word in line.words:
            print(f"[{word.start:.3f}s - {word.end:.3f}s] {word.word}")

let transcriber = try Transcriber(
    modelPath: modelPath,
    modelArch: .tiny,
    options: [TranscriberOption(name: "word_timestamps", value: "true")])

let transcript = try transcriber.transcribeWithoutStreaming(audioData: audio)
for line in transcript.lines {
    for word in line.words {
        print("[\(word.start)s - \(word.end)s] \(word.word)")
    }
}

# Non-streaming model
python scripts/export-decoder-with-attention.py path/to/tiny-en/

# Streaming model
python scripts/export-decoder-with-attention.py path/to/tiny-streaming-en/

attention_weights = softmax(Q @ K^T / sqrt(d))

Audio
  → encoder_model.ort → encoder_hidden_states
  → decoder_with_attention.ort (autoregressive decode loop)
      → logits, KV cache (same as before)
      → cross_attentions.* (NEW: attention weights per step)
  → DTW alignment → word timestamps

Audio chunks
  → frontend.ort → encoder.ort → adapter.ort → memory
  → cross_kv.ort → precomputed K/V
  → decoder_kv_with_attention.ort (per-step decode)
      → logits, KV cache (same as before)
      → cross_attentions.* (NEW: attention weights per step)
  → DTW alignment → word timestamps

stack per-step attention into [layers*heads, tokens, encoder_frames]
→ z-score normalize per head
→ median filter (width 7) to smooth
→ average across heads/layers → [tokens, encoder_frames]
→ DTW on negated matrix → monotonic alignment path
→ group tokens into words (SentencePiece ▁ boundaries)
→ fix overlapping word boundaries
→ TranscriberWord { text, start, end, confidence }

struct transcript_word_t {
    const char *text;    /* UTF-8 word text */
    float start;         /* Start time in seconds (absolute) */
    float end;           /* End time in seconds */
    float confidence;    /* 0.0 to 1.0 */
};

struct transcript_line_t {
    /* ... existing fields ... */
    const struct transcript_word_t *words;  /* NULL if not enabled */
    uint64_t word_count;                    /* 0 if not enabled */
};

struct WordTiming {
    std::string word;
    float start;
    float end;
    float confidence;
};

struct TranscriptLine {
    /* ... existing fields ... */
    std::vector<WordTiming> words;  // empty if not enabled
};

@dataclass
class WordTiming:
    word: str
    start: float
    end: float
    confidence: float

@dataclass
class TranscriptLine:
    # ... existing fields ...
    words: Optional[List[WordTiming]] = None

public struct WordTiming {
    public let word: String
    public let start: Float
    public let end: Float
    public let confidence: Float
}

public struct TranscriptLine {
    // ... existing fields ...
    public let words: [WordTiming]  // empty if not enabled
}

public class WordTiming {
    public String word;
    public float start;
    public float end;
    public float confidence;
}

public class TranscriptLine {
    // ... existing fields ...
    public List<WordTiming> words;
}

export interface WordTiming {
    word: string;
    start: number;
    end: number;
    confidence: number;
}