@pipedog/core 0.0.0 → 0.2.0

package/dist/utils/text/phonemes.js

@@ -0,0 +1,172 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/text/phonemes.py
+/**
+ * Shared pronunciation parsing and normalization utilities for TTS services.
+ *
+ * A pronunciation reaches a TTS service as an IPA string. Services each want their
+ * own markup for it, but they all start from the same steps: tidy the notation,
+ * split it into phones, and find which vowel each stress mark belongs to. Those
+ * steps live here, so a service's formatter only has to render the result.
+ *
+ * Normalization is notation-only. It unifies ways of writing the same symbol
+ * (`ʧ` and `tʃ`, `g` and `ɡ`, `'` and `ˈ`) and never changes which sound
+ * is written, so it is safe for any language.
+ */
+export const PRIMARY_STRESS = "ˈ";
+export const SECONDARY_STRESS = "ˌ";
+export const STRESS_MARKS = [PRIMARY_STRESS, SECONDARY_STRESS];
+export const TIE_BAR = "͡";
+// Ligatures and ASCII look-alikes of IPA symbols. "tʃ" and "dʒ" are always read
+// as one phone, so they are written untied; other affricates keep the tie bar
+// that tells them apart from a cluster.
+const _IPA_NOTATION = [
+    ["͜", TIE_BAR], // tie bar below
+    ["ʧ", "tʃ"],
+    ["ʤ", "dʒ"],
+    [`t${TIE_BAR}ʃ`, "tʃ"],
+    [`d${TIE_BAR}ʒ`, "dʒ"],
+    ["ʦ", `t${TIE_BAR}s`],
+    ["ʣ", `d${TIE_BAR}z`],
+    ["g", "ɡ"],
+    ["'", PRIMARY_STRESS],
+    [":", "ː"],
+    [".", ""], // syllable break
+];
+// Sequences read as a single phone even without a tie bar: affricates written
+// this way in nearly every dictionary, and the English diphthongs. Anything else
+// ("ts" in "cats" against Italian "pizza") is one phone only when tied.
+const _IPA_MULTI = ["tʃ", "dʒ", "aɪ", "aʊ", "ɔɪ", "oʊ", "eɪ"].map((m) => Array.from(m));
+const _IPA_VOWELS = new Set(Array.from("aeiouyæɑɒɔəɚɛɜɝɪʊʌɐᵻɨʉɯɤøœɶɵɘɞ"));
+// Characters that belong to the phone before them rather than starting a new one.
+const _IPA_MODIFIERS = new Set(Array.from("ːˑ"));
+const _NONSPACING_MARK_RE = /^\p{Mn}$/u;
+function isStressMark(char) {
+    return char === PRIMARY_STRESS || char === SECONDARY_STRESS;
+}
+function isModifierChar(char) {
+    return _IPA_MODIFIERS.has(char) || _NONSPACING_MARK_RE.test(char);
+}
+/** Whether the code points `chars` start with `prefix` (code points) at `index`. */
+function startsWithAt(chars, prefix, index) {
+    if (index + prefix.length > chars.length)
+        return false;
+    return prefix.every((c, k) => chars[index + k] === c);
+}
+/**
+ * Unify the notation of an IPA string without changing what it says.
+ *
+ * Strips surrounding `/…/` or `[…]`, composes Unicode, replaces ligatures and
+ * ASCII look-alikes with their IPA symbols, writes `tʃ` and `dʒ` untied and
+ * other affricates tied (`ʦ` becomes `t͡s`), drops syllable breaks, and
+ * collapses whitespace.
+ *
+ * @param ipa An IPA transcription.
+ * @returns The same transcription in canonical notation.
+ *
+ * @example
+ * normalizeIpa("/ˈʧɪ.kən/"); // "ˈtʃɪkən"
+ */
+export function normalizeIpa(ipa) {
+    ipa = ipa.trim().normalize("NFC");
+    const chars = Array.from(ipa);
+    if (chars.length >= 2) {
+        const pair = `${chars[0]}${chars[chars.length - 1]}`;
+        if (pair === "//" || pair === "[]") {
+            ipa = chars.slice(1, -1).join("");
+        }
+    }
+    for (const [old, replacement] of _IPA_NOTATION) {
+        ipa = ipa.replaceAll(old, replacement);
+    }
+    return ipa
+        .split(/\s+/u)
+        .filter((part) => part.length > 0)
+        .join(" ");
+}
+/**
+ * Split one IPA word into phones, in written order.
+ *
+ * Stress marks are returned as tokens of their own, where they were written.
+ * Tied sequences (`t͡s`), `tʃ`, `dʒ` and the English diphthongs are one
+ * phone each, returned without the tie bar; length marks and combining
+ * diacritics stay with the phone they modify.
+ *
+ * @param ipa An IPA transcription of a single word.
+ * @returns The phones and stress marks of the word.
+ *
+ * @example
+ * ipaPhones("mɛtˈfɔɹmɪn"); // ["m", "ɛ", "t", "ˈ", "f", "ɔ", "ɹ", "m", "ɪ", "n"]
+ */
+export function ipaPhones(ipa) {
+    const chars = Array.from(normalizeIpa(ipa).replaceAll(" ", ""));
+    const phones = [];
+    let i = 0;
+    while (i < chars.length) {
+        const char = chars[i];
+        if (isStressMark(char)) {
+            phones.push(char);
+            i += 1;
+            continue;
+        }
+        let phone;
+        if (chars[i + 1] === TIE_BAR && i + 2 < chars.length) {
+            phone = char + chars[i + 2];
+            i += 3;
+        }
+        else {
+            const multi = _IPA_MULTI.find((m) => startsWithAt(chars, m, i));
+            phone = multi ? multi.join("") : char;
+            i += multi ? multi.length : 1;
+        }
+        while (i < chars.length && isModifierChar(chars[i])) {
+            phone += chars[i];
+            i += 1;
+        }
+        const last = phones[phones.length - 1];
+        if (last !== undefined && !isStressMark(last) && _isModifierOnly(phone)) {
+            phones[phones.length - 1] = last + phone;
+        }
+        else {
+            phones.push(phone);
+        }
+    }
+    return phones;
+}
+/** Whether an IPA phone (as returned by `ipaPhones`) is a vowel. */
+export function isIpaVowel(phone) {
+    const first = Array.from(phone)[0];
+    return first !== undefined && _IPA_VOWELS.has(first);
+}
+/**
+ * Move each stress mark from where it was written to just before its vowel.
+ *
+ * Transcriptions usually put stress at the start of the syllable
+ * (`mɛtˈfɔɹmɪn`); some services want it on the vowel itself
+ * (`mɛtfˈɔɹmɪn`). A stress mark with no vowel after it is dropped.
+ *
+ * @param phones Phones and stress marks, as returned by `ipaPhones`.
+ * @returns The same phones with every stress mark directly before a vowel.
+ */
+export function stressBeforeVowels(phones) {
+    const result = [];
+    let pending = null;
+    for (const phone of phones) {
+        if (isStressMark(phone)) {
+            pending = phone;
+            continue;
+        }
+        if (pending && isIpaVowel(phone)) {
+            result.push(pending);
+            pending = null;
+        }
+        result.push(phone);
+    }
+    return result;
+}
+function _isModifierOnly(phone) {
+    return Array.from(phone).every(isModifierChar);
+}
+//# sourceMappingURL=phonemes.js.map

package/dist/utils/text/simple_text_aggregator.d.ts

@@ -0,0 +1,135 @@
+import { Aggregation, BaseTextAggregator, type BaseTextAggregatorOptions } from "./base_text_aggregator.ts";
+/**
+ * Track lookahead across chunks for early emission and a word-end retry.
+ *
+ * Clear boundaries can emit at the first character; unresolved ones wait for
+ * a complete word. For example, "Hello. N" can emit without waiting for "Next ".
+ * Waiting for word completion added up to 297 ms in our Anthropic sample.
+ *
+ * Unresolved boundaries retry only when the following word ends. In "Albert I.
+ * Douglas", checking the partial word "Do" could mistake it for a sentence
+ * starter and split after the initial.
+ */
+declare const _LookaheadState: {
+    readonly IDLE: 1;
+    readonly AWAITING_CHARACTER: 2;
+    readonly AWAITING_WORD: 3;
+    readonly IN_WORD: 4;
+};
+type _LookaheadState = (typeof _LookaheadState)[keyof typeof _LookaheadState];
+/** Python `str.strip(" ")`: strip only ASCII spaces. */
+export declare function _stripSpaces(text: string): string;
+export interface SimpleTextAggregatorOptions extends BaseTextAggregatorOptions {
+}
+/**
+ * Simple text aggregator that accumulates text until sentence boundaries.
+ *
+ * This aggregator provides basic functionality for accumulating text tokens
+ * and releasing them when an end-of-sentence marker is detected. It's the
+ * most straightforward implementation of text aggregation for TTS processing.
+ */
+export declare class SimpleTextAggregator extends BaseTextAggregator {
+    protected _text: string;
+    protected _lookaheadState: _LookaheadState;
+    /**
+     * Initialize the simple text aggregator.
+     *
+     * Creates an empty text buffer ready to begin accumulating text tokens.
+     *
+     * @param options Additional arguments passed to BaseTextAggregator (e.g. aggregationType).
+     */
+    constructor(options?: SimpleTextAggregatorOptions);
+    /**
+     * Get the currently aggregated text.
+     *
+     * @returns The text that has been accumulated in the buffer.
+     */
+    get text(): Aggregation;
+    /**
+     * Aggregate text and yield completed aggregations.
+     *
+     * In SENTENCE mode, processes the input text character-by-character. When
+     * sentence-ending punctuation is detected, it waits for non-whitespace
+     * lookahead before calling the sentence tokenizer.
+     *
+     * In TOKEN mode, yields the text immediately without buffering.
+     *
+     * @param text Text to aggregate.
+     * @returns Aggregation objects (sentences in SENTENCE mode, tokens in TOKEN mode).
+     */
+    aggregate(text: string): AsyncGenerator<Aggregation>;
+    /**
+     * Check a possible sentence ending using text that arrives after it.
+     *
+     * `char` is already appended to `this._text`. Punctuation starts a
+     * candidate, but the tokenizer decides whether it actually ends a sentence:
+     *
+     * - `Hello.` or `Hello. `: keep buffering until meaningful text follows.
+     * - `Hello. N`: check immediately and emit `Hello.`. In contrast,
+     *   `Dr. N` and `$29.9` stay buffered as an abbreviation and a decimal.
+     * - `...you and I. D`: if unresolved, retry when the word `Did` ends.
+     *   Don't check intermediate prefixes: `Do` in `Albert I. Douglas`
+     *   could be mistaken for a sentence starter.
+     * - `...you and I. Did?`: the question mark ends the lookahead word and
+     *   starts a new candidate. First check the earlier period without `?`;
+     *   then wait for lookahead after `?`.
+     *
+     * A confirmed boundary emits only the prefix; the following text stays in
+     * the buffer. After a word-end retry, stop checking that candidate even if
+     * unresolved. At response end, `flush` returns any remaining text.
+     *
+     * Subclasses can call this via super for tag or pattern handling.
+     *
+     * @param char The character just appended to the aggregation buffer.
+     * @returns Aggregation if a sentence boundary is confirmed, otherwise null.
+     */
+    protected _checkSentenceWithLookahead(char: string): Promise<Aggregation | null>;
+    /**
+     * Advance the pending candidate and decide whether to check its boundary.
+     *
+     * Check once at the first non-whitespace character, then once more when
+     * the following word ends. Opening quotes or symbols do not start a word.
+     *
+     * If the first tokenizer check finds no boundary:
+     *
+     *     'I. '      -> AWAITING_CHARACTER
+     *     'I. "'     -> AWAITING_WORD (check at the quote)
+     *     'I. "D'    -> IN_WORD (no check)
+     *     'I. "Did ' -> IDLE (retry at the word-ending space)
+     *
+     * The caller performs the tokenizer check when this method returns true.
+     *
+     * @param char The most recently appended character.
+     * @param options.isPunctuation Whether the character is sentence-ending punctuation.
+     * @returns Whether the buffered text is ready for a tokenizer check.
+     */
+    protected _advanceLookahead(char: string, options: {
+        isPunctuation: boolean;
+    }): boolean;
+    /**
+     * Flush any remaining text in the buffer.
+     *
+     * Returns any text remaining in the buffer. This is called at the end
+     * of a stream to ensure all text is processed. In TOKEN mode, returns
+     * null since tokens are yielded immediately.
+     *
+     * @returns Any remaining text as a sentence, or null if buffer is empty or in TOKEN mode.
+     */
+    flush(): Promise<Aggregation | null>;
+    /**
+     * Handle interruptions by clearing the text buffer.
+     *
+     * Called when an interruption occurs in the processing pipeline,
+     * discarding any partially accumulated text.
+     */
+    handleInterruption(): Promise<void>;
+    /**
+     * Clear the internally aggregated text.
+     *
+     * Resets the aggregator to its initial empty state, discarding
+     * any accumulated text content.
+     */
+    reset(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=simple_text_aggregator.d.ts.map

package/dist/utils/text/simple_text_aggregator.js

@@ -0,0 +1,254 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/text/simple_text_aggregator.py
+/**
+ * Simple text aggregator for basic sentence-boundary text processing.
+ *
+ * This module provides a straightforward text aggregator that accumulates text
+ * until it finds an end-of-sentence marker, making it suitable for basic TTS
+ * text processing scenarios.
+ */
+import { matchEndofsentence, SENTENCE_ENDING_PUNCTUATION } from "../string.js";
+import { Aggregation, BaseTextAggregator, TextType, } from "./base_text_aggregator.js";
+/**
+ * Track lookahead across chunks for early emission and a word-end retry.
+ *
+ * Clear boundaries can emit at the first character; unresolved ones wait for
+ * a complete word. For example, "Hello. N" can emit without waiting for "Next ".
+ * Waiting for word completion added up to 297 ms in our Anthropic sample.
+ *
+ * Unresolved boundaries retry only when the following word ends. In "Albert I.
+ * Douglas", checking the partial word "Do" could mistake it for a sentence
+ * starter and split after the initial.
+ */
+const _LookaheadState = {
+    IDLE: 1,
+    AWAITING_CHARACTER: 2,
+    AWAITING_WORD: 3,
+    IN_WORD: 4,
+};
+const SPACE_RE = /^\s+$/u;
+const ALNUM_RE = /^[\p{L}\p{N}]+$/u;
+/** Python `str.isspace()` for a single character. */
+function isSpace(char) {
+    return SPACE_RE.test(char);
+}
+/** Python `str.isalnum()` for a single character. */
+function isAlnum(char) {
+    return ALNUM_RE.test(char);
+}
+/** Python `str.strip(" ")`: strip only ASCII spaces. */
+export function _stripSpaces(text) {
+    let start = 0;
+    let end = text.length;
+    while (start < end && text[start] === " ")
+        start++;
+    while (end > start && text[end - 1] === " ")
+        end--;
+    return text.slice(start, end);
+}
+/**
+ * Simple text aggregator that accumulates text until sentence boundaries.
+ *
+ * This aggregator provides basic functionality for accumulating text tokens
+ * and releasing them when an end-of-sentence marker is detected. It's the
+ * most straightforward implementation of text aggregation for TTS processing.
+ */
+export class SimpleTextAggregator extends BaseTextAggregator {
+    _text;
+    _lookaheadState;
+    /**
+     * Initialize the simple text aggregator.
+     *
+     * Creates an empty text buffer ready to begin accumulating text tokens.
+     *
+     * @param options Additional arguments passed to BaseTextAggregator (e.g. aggregationType).
+     */
+    constructor(options = {}) {
+        super(options);
+        this._text = "";
+        this._lookaheadState = _LookaheadState.IDLE;
+    }
+    /**
+     * Get the currently aggregated text.
+     *
+     * @returns The text that has been accumulated in the buffer.
+     */
+    get text() {
+        return new Aggregation({ text: _stripSpaces(this._text), type: TextType.SENTENCE });
+    }
+    /**
+     * Aggregate text and yield completed aggregations.
+     *
+     * In SENTENCE mode, processes the input text character-by-character. When
+     * sentence-ending punctuation is detected, it waits for non-whitespace
+     * lookahead before calling the sentence tokenizer.
+     *
+     * In TOKEN mode, yields the text immediately without buffering.
+     *
+     * @param text Text to aggregate.
+     * @returns Aggregation objects (sentences in SENTENCE mode, tokens in TOKEN mode).
+     */
+    async *aggregate(text) {
+        if (this._aggregationType === TextType.TOKEN) {
+            if (text) {
+                yield new Aggregation({ text, type: TextType.TOKEN });
+            }
+            return;
+        }
+        // Process text character by character
+        for (const char of text) {
+            this._text += char;
+            // Check for sentence with lookahead
+            const result = await this._checkSentenceWithLookahead(char);
+            if (result) {
+                yield result;
+            }
+        }
+    }
+    /**
+     * Check a possible sentence ending using text that arrives after it.
+     *
+     * `char` is already appended to `this._text`. Punctuation starts a
+     * candidate, but the tokenizer decides whether it actually ends a sentence:
+     *
+     * - `Hello.` or `Hello. `: keep buffering until meaningful text follows.
+     * - `Hello. N`: check immediately and emit `Hello.`. In contrast,
+     *   `Dr. N` and `$29.9` stay buffered as an abbreviation and a decimal.
+     * - `...you and I. D`: if unresolved, retry when the word `Did` ends.
+     *   Don't check intermediate prefixes: `Do` in `Albert I. Douglas`
+     *   could be mistaken for a sentence starter.
+     * - `...you and I. Did?`: the question mark ends the lookahead word and
+     *   starts a new candidate. First check the earlier period without `?`;
+     *   then wait for lookahead after `?`.
+     *
+     * A confirmed boundary emits only the prefix; the following text stays in
+     * the buffer. After a word-end retry, stop checking that candidate even if
+     * unresolved. At response end, `flush` returns any remaining text.
+     *
+     * Subclasses can call this via super for tag or pattern handling.
+     *
+     * @param char The character just appended to the aggregation buffer.
+     * @returns Aggregation if a sentence boundary is confirmed, otherwise null.
+     */
+    async _checkSentenceWithLookahead(char) {
+        const isPunctuation = SENTENCE_ENDING_PUNCTUATION.has(char);
+        let result = null;
+        // The state machine requests a check at the first lookahead character
+        // or the following word's end, not at every character in between.
+        if (this._advanceLookahead(char, { isPunctuation })) {
+            // For "...I. Did?", check "...I. Did" for the earlier boundary.
+            // Including "?" could make the terminal-punctuation fallback accept
+            // the whole buffer. This temporary slice does not discard the "?".
+            const candidate = isPunctuation ? this._text.slice(0, -char.length) : this._text;
+            const eosMarker = matchEndofsentence(candidate, { language: this.language });
+            if (eosMarker) {
+                result = new Aggregation({
+                    text: _stripSpaces(this._text.slice(0, eosMarker)),
+                    type: TextType.SENTENCE,
+                });
+                // Keep the lookahead text for the next sentence ("N" in "Hello. N").
+                this._text = this._text.slice(eosMarker);
+                this._lookaheadState = _LookaheadState.IDLE;
+            }
+        }
+        // A trailing "?" in "...I. Did?" needs its own lookahead, whether or not
+        // the retry above found a boundary at the earlier period.
+        if (isPunctuation) {
+            this._lookaheadState = _LookaheadState.AWAITING_CHARACTER;
+        }
+        return result;
+    }
+    /**
+     * Advance the pending candidate and decide whether to check its boundary.
+     *
+     * Check once at the first non-whitespace character, then once more when
+     * the following word ends. Opening quotes or symbols do not start a word.
+     *
+     * If the first tokenizer check finds no boundary:
+     *
+     *     'I. '      -> AWAITING_CHARACTER
+     *     'I. "'     -> AWAITING_WORD (check at the quote)
+     *     'I. "D'    -> IN_WORD (no check)
+     *     'I. "Did ' -> IDLE (retry at the word-ending space)
+     *
+     * The caller performs the tokenizer check when this method returns true.
+     *
+     * @param char The most recently appended character.
+     * @param options.isPunctuation Whether the character is sentence-ending punctuation.
+     * @returns Whether the buffered text is ready for a tokenizer check.
+     */
+    _advanceLookahead(char, options) {
+        const { isPunctuation } = options;
+        switch (this._lookaheadState) {
+            case _LookaheadState.IDLE:
+                return false;
+            case _LookaheadState.AWAITING_CHARACTER:
+                if (isSpace(char) || isPunctuation) {
+                    return false;
+                }
+                this._lookaheadState = isAlnum(char)
+                    ? _LookaheadState.IN_WORD
+                    : _LookaheadState.AWAITING_WORD;
+                // Ordinary boundaries such as "Hello. N" can emit immediately.
+                return true;
+            case _LookaheadState.AWAITING_WORD:
+                if (isAlnum(char)) {
+                    this._lookaheadState = _LookaheadState.IN_WORD;
+                }
+                return false;
+            case _LookaheadState.IN_WORD:
+                // Never retry at a partial prefix such as "Do" inside "Douglas".
+                if (isSpace(char) || isPunctuation) {
+                    this._lookaheadState = _LookaheadState.IDLE;
+                    return true;
+                }
+                return false;
+        }
+        return false;
+    }
+    /**
+     * Flush any remaining text in the buffer.
+     *
+     * Returns any text remaining in the buffer. This is called at the end
+     * of a stream to ensure all text is processed. In TOKEN mode, returns
+     * null since tokens are yielded immediately.
+     *
+     * @returns Any remaining text as a sentence, or null if buffer is empty or in TOKEN mode.
+     */
+    async flush() {
+        if (this._aggregationType === TextType.TOKEN) {
+            return null;
+        }
+        if (this._text) {
+            // Return whatever we have in the buffer
+            const result = this._text;
+            await this.reset();
+            return new Aggregation({ text: _stripSpaces(result), type: TextType.SENTENCE });
+        }
+        return null;
+    }
+    /**
+     * Handle interruptions by clearing the text buffer.
+     *
+     * Called when an interruption occurs in the processing pipeline,
+     * discarding any partially accumulated text.
+     */
+    async handleInterruption() {
+        this._text = "";
+        this._lookaheadState = _LookaheadState.IDLE;
+    }
+    /**
+     * Clear the internally aggregated text.
+     *
+     * Resets the aggregator to its initial empty state, discarding
+     * any accumulated text content.
+     */
+    async reset() {
+        this._text = "";
+        this._lookaheadState = _LookaheadState.IDLE;
+    }
+}
+//# sourceMappingURL=simple_text_aggregator.js.map

package/dist/utils/text/skip_tags_aggregator.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Skip tags aggregator for preventing sentence boundaries within tagged content.
+ *
+ * This module provides a text aggregator that prevents end-of-sentence matching
+ * between specified start/end tag pairs, ensuring that tagged content is processed
+ * as a unit regardless of internal punctuation.
+ */
+import { type StartEndTags } from "../string.ts";
+import { Aggregation } from "./base_text_aggregator.ts";
+import { SimpleTextAggregator, type SimpleTextAggregatorOptions } from "./simple_text_aggregator.ts";
+export interface SkipTagsAggregatorOptions extends SimpleTextAggregatorOptions {
+    /**
+     * Sequence of StartEndTags defining the tag pairs that should prevent
+     * sentence boundary detection.
+     */
+    tags: readonly StartEndTags[];
+}
+/**
+ * Aggregator that prevents end of sentence matching between start/end tags.
+ *
+ * This aggregator buffers text until it finds an end of sentence or a start
+ * tag. If a start tag is found the aggregator will keep aggregating text
+ * unconditionally until the corresponding end tag is found. It's particularly
+ * useful for processing content with custom delimiters that should prevent
+ * text from being considered for end of sentence matching.
+ *
+ * The aggregator ensures that tags spanning multiple text chunks are correctly
+ * identified and that content within tags is never split at sentence boundaries.
+ */
+export declare class SkipTagsAggregator extends SimpleTextAggregator {
+    protected _tags: readonly StartEndTags[];
+    protected _currentTag: StartEndTags | null;
+    protected _currentTagIndex: number;
+    /**
+     * Initialize the skip tags aggregator.
+     *
+     * @param options.tags Tag pairs that should prevent sentence boundary detection.
+     *   Other options are passed to SimpleTextAggregator (e.g. aggregationType).
+     */
+    constructor(options: SkipTagsAggregatorOptions);
+    /**
+     * Aggregate text while respecting tag boundaries.
+     *
+     * Processes the input text character-by-character, updates tag state, and
+     * uses the parent's lookahead logic for sentence detection when not
+     * inside tags.
+     *
+     * In TOKEN mode, text is passed through immediately unless we're inside
+     * a tag, in which case we buffer until the closing tag is found. Text
+     * ending in a partial start tag (e.g. `<spe` of `<spell>`) is held
+     * back until a later chunk determines whether it begins a tag, so a tag
+     * split across chunks is still recognized.
+     *
+     * @param text Text to aggregate.
+     * @returns Aggregation objects containing text up to a sentence boundary,
+     *   marked as SENTENCE type (or TOKEN type in TOKEN mode).
+     */
+    aggregate(text: string): AsyncGenerator<Aggregation>;
+    /**
+     * Flush any remaining text in the buffer.
+     *
+     * In SENTENCE mode, returns the buffered text as-is: tags are
+     * pass-through markers, so content is spoken whether or not a start
+     * tag's closing tag ever arrived. In TOKEN mode, returns any text
+     * still buffered behind an unclosed tag instead of discarding it.
+     *
+     * @returns Any remaining text, or null if the buffer is empty.
+     */
+    flush(): Promise<Aggregation | null>;
+    /**
+     * Handle interruptions by clearing the buffer and tag state.
+     *
+     * Called when an interruption occurs in the processing pipeline,
+     * to reset the state and discard any partially aggregated text.
+     */
+    handleInterruption(): Promise<void>;
+    /**
+     * Clear the internally aggregated text and tag state.
+     *
+     * Resets the aggregator to its initial state, discarding any
+     * buffered text.
+     */
+    reset(): Promise<void>;
+}
+//# sourceMappingURL=skip_tags_aggregator.d.ts.map