throttleMs?: number;

/** Minimum chars before sending first message (debounce for push notifications) */

minInitialChars?: number;

/** Maximum time to hold a short first preview before materializing it anyway. */

minInitialDelayMs?: number;

/** Optional preview renderer (e.g. markdown -> HTML + parse mode). */

renderText?: (text: string) => TelegramDraftPreview;

/** Called when a late send resolves after forceNewMessage() switched generations. */

const maxChars = Math.min(params.maxChars ?? transportLimit, transportLimit);

const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);

const minInitialChars = params.minInitialChars;

const minInitialDelayMs = params.minInitialDelayMs;

const chatId = params.chatId;

const threadParams = buildTelegramThreadParams(params.thread);

const replyToMessageId = normalizeTelegramReplyToMessageId(params.replyToMessageId);

let lastDeliveredText = "";

let lastRequestedText = "";

let lastRequestedPreview: TelegramDraftPreview | undefined;

let firstShortPreviewSeenMs: number | undefined;

let initialPreviewTimer: ReturnType<typeof setTimeout> | undefined;

let previewRevision = 0;

let generation = 0;

let deliveredTextOffset = 0;

streamVisibleSinceMs = visibleSinceMs;

return true;

};

const clearInitialPreviewTimer = () => {

if (initialPreviewTimer) {

clearTimeout(initialPreviewTimer);

initialPreviewTimer = undefined;

}

};

const scheduleInitialPreviewFlush = (delayMs: number) => {

if (initialPreviewTimer) {

return;

}

initialPreviewTimer = setTimeout(

() => {

initialPreviewTimer = undefined;

void flushInitialPreview().catch((err: unknown) => {

params.warn?.(`telegram stream preview delayed send failed: ${formatErrorMessage(err)}`);

});

},

Math.max(0, delayMs),

);

};

const stopOversizedPreview = (payloadLength: number): false => {

streamState.stopped = true;

params.warn?.(`telegram stream preview stopped (text length ${payloadLength} > ${maxChars})`);

if (typeof streamMessageId !== "number" && minInitialChars != null && !streamState.final) {

if (renderedText.length < minInitialChars) {

return false;

if (minInitialDelayMs == null) {

return false;

}

const now = Date.now();

firstShortPreviewSeenMs ??= now;

const remainingDelayMs = minInitialDelayMs - (now - firstShortPreviewSeenMs);

if (remainingDelayMs > 0) {

scheduleInitialPreviewFlush(remainingDelayMs);

return false;

}

clearInitialPreviewTimer();

} else {

firstShortPreviewSeenMs = undefined;

clearInitialPreviewTimer();

}

} else {

firstShortPreviewSeenMs = undefined;

clearInitialPreviewTimer();

}

const previousSentPreviewKey = lastSentPreviewKey;

state: streamState,

sendOrEditStreamMessage,

});

const flushInitialPreview = loop.flush;

const requestDraftUpdate = (text: string, preview?: TelegramDraftPreview) => {

if (streamState.stopped || streamState.final) {

messageSendAttempted = false;

streamMessageId = undefined;

streamVisibleSinceMs = undefined;

firstShortPreviewSeenMs = undefined;

clearInitialPreviewTimer();

lastSentPreviewKey = "";

if (options?.resetOffset !== false) {

deliveredTextOffset = 0;

};

const clear = async () => {

clearInitialPreviewTimer();

const messageId = await takeMessageIdAfterStop({

stopForClear,

readMessageId: () => streamMessageId,

};

const discard = async () => {

clearInitialPreviewTimer();

await stopForClear();

};