@addozhang/dsh-discord 0.1.0

package/lib/stream/live.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Live render wiring (Phase 1): the DSH events.mux stream drives per-thread
+ * render state into Discord delivery. Each bound session thread owns one
+ * runtime — render model, update scheduler, typing lifecycle, tool activity
+ * surface, and the turn's head message. Frames for sessions with no bound
+ * thread are dropped (reconciliation owns recovery, not the live path);
+ * `assistant/message` finalizes exactly once with ordered continuations;
+ * `turn/end` stops typing, releases the adapter-owned turn, and deletes the
+ * turn's tool activity message.
+ */
+import type { DiscordVerbosity } from '../settings.js';
+/** The mux frames the live path consumes (narrow, defensive shape). */
+export type LiveFrame = {
+    type: 'session/event';
+    sessionId: string;
+    event: {
+        type: string;
+        data: Record<string, unknown>;
+    };
+    view?: unknown;
+} | {
+    type: 'session/subscribed';
+    sessionId: string;
+} | {
+    type: 'session/queue';
+    sessionId: string;
+    items: Array<{
+        id: string;
+        summary: string;
+    }>;
+} | {
+    type: string;
+};
+/**
+ * The Discord delivery face the live renderer needs. `unknown` on a send
+ * means the request's application on Discord's side is unobservable (rest.ts
+ * contract); the caller must never blind-resent such a send — the live path
+ * pauses instead and lets the finalizer's single fresh send carry the text.
+ */
+export interface LiveDeliveryPort {
+    send(request: {
+        channelId: string;
+        content: string;
+    }): Promise<{
+        outcome: 'completed';
+        messageId: string;
+    } | {
+        outcome: 'unknown';
+    } | {
+        outcome: 'failed';
+    }>;
+    edit(request: {
+        channelId: string;
+        messageId: string;
+        content: string;
+    }): Promise<{
+        outcome: 'completed';
+    } | {
+        outcome: 'failed';
+    }>;
+    delete(request: {
+        channelId: string;
+        messageId: string;
+    }): Promise<{
+        outcome: 'completed';
+    } | {
+        outcome: 'failed';
+    }>;
+    typing(channelId: string): Promise<void>;
+    renameThread(request: {
+        channelId: string;
+        name: string;
+    }): Promise<{
+        outcome: 'completed';
+    } | {
+        outcome: 'failed';
+    }>;
+}
+export interface LiveRenderDeps {
+    frames: (signal: AbortSignal) => AsyncIterable<unknown>;
+    threadForSession: (sessionId: string) => string | undefined;
+    delivery: LiveDeliveryPort;
+    /** Wire name of a thread, when resolvable; lets a restart skip no-op renames. */
+    threadName?: (channelId: string) => Promise<string | undefined>;
+    updateIntervalMs: number;
+    typingIntervalMs: number;
+    /** Approval ask deadline (approvalTimeoutMs setting). */
+    approvalTimeoutMs: number;
+    /** Question ask deadline (questionTimeoutMs setting). */
+    questionTimeoutMs: number;
+    /** Coalescing budget for tool-activity edits (default 1s). */
+    activityCoalesceMs?: number;
+    verbosity?: DiscordVerbosity;
+    log?: (event: string, detail?: unknown) => void;
+    /** Queue snapshot cache (the /queue surface's data source). */
+    onQueueSnapshot?: (sessionId: string, items: Array<{
+        id: string;
+        summary: string;
+    }>) => void;
+    /** Localized interruption suffix, resolved live (language can change). */
+    interruptedMarker?: () => string;
+    /** Turn ownership release on turn/end. */
+    onTurnEnded?: (sessionId: string) => void;
+    /**
+     * Answerable server-request frames (interaction-routing spec): approvals
+     * and questions arrive as mux frames with an envelope rpcId the response
+     * must echo. The composition owns rendering, ownership, and expiry.
+     */
+    requests?: {
+        onApprovalRequested(input: {
+            sessionId: string;
+            threadId: string;
+            rpcId: string;
+            approvalId: string;
+            toolName: string;
+            reason?: string | undefined;
+            expiresAtMs: number;
+        }): void;
+        onApprovalResolved(input: {
+            sessionId: string;
+            approvalId: string;
+            outcome?: string | undefined;
+        }): void;
+        onQuestionRequested(input: {
+            sessionId: string;
+            threadId: string;
+            rpcId: string;
+            questions: Array<Record<string, unknown>>;
+            expiresAtMs: number;
+        }): void;
+        onQuestionResolved(input: {
+            sessionId: string;
+            questionRpcId: string;
+            outcome: 'answered' | 'cancelled';
+        }): void;
+    };
+}
+export declare function startLiveRender(deps: LiveRenderDeps): {
+    dispose(): void;
+};

package/lib/stream/live.js

@@ -0,0 +1,515 @@
+/**
+ * Live render wiring (Phase 1): the DSH events.mux stream drives per-thread
+ * render state into Discord delivery. Each bound session thread owns one
+ * runtime — render model, update scheduler, typing lifecycle, tool activity
+ * surface, and the turn's head message. Frames for sessions with no bound
+ * thread are dropped (reconciliation owns recovery, not the live path);
+ * `assistant/message` finalizes exactly once with ordered continuations;
+ * `turn/end` stops typing, releases the adapter-owned turn, and deletes the
+ * turn's tool activity message.
+ */
+import { createThreadRenderModel } from './render-model.js';
+import { createUpdateScheduler } from './update-scheduler.js';
+import { createTypingLifecycle } from './typing.js';
+import { createToolActivitySurface } from './tool-view.js';
+import { createAnswerFinalizer } from './finalizer.js';
+import { buildOutboundMessage } from './outbound.js';
+import { toolCategoryIcon } from './icons.js';
+import { discordChannelNameKey, safeTitle } from '../policy/disclosure.js';
+/** Coalescing budget for activity-message edits under parallel tools. */
+const DEFAULT_ACTIVITY_COALESCE_MS = 1_000;
+/** Row budget: a presentation title is truncated before it reaches Discord. */
+const ACTIVITY_TITLE_MAX = 80;
+const ANSWER_MARKER = (interrupted, marker) => interrupted ? `\n\n${marker}` : '';
+/** Pair-safe truncation: never split a surrogate pair at the boundary. */
+function truncateText(text, max) {
+    if (text.length <= max)
+        return text;
+    const cut = text.slice(0, max);
+    const last = cut.charCodeAt(cut.length - 1);
+    return last >= 0xd800 && last <= 0xdbff ? cut.slice(0, -1) : cut;
+}
+/** Extract the visible text of one assistant message (text blocks only). */
+function assistantText(message) {
+    if (typeof message !== 'object' || message === null)
+        return '';
+    const content = message.content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((block) => typeof block === 'object' && block !== null && block.type === 'text')
+        .map(block => block.text)
+        .join('');
+}
+/** The callId of a tool/result event (block-carried, defensive). */
+function resultCallId(data) {
+    if (typeof data['callId'] === 'string')
+        return data['callId'];
+    const message = data['message'];
+    const block = Array.isArray(message?.content) ? message.content[0] : undefined;
+    return typeof block?.toolCallId === 'string' ? block.toolCallId : undefined;
+}
+/**
+ * The Host presentation view's title for one tool event: a terminal call's
+ * title IS the command; generic/diff cards title the call. Host-curated
+ * disclosure — never raw arguments.
+ */
+function presentationTitle(frameView) {
+    if (typeof frameView !== 'object' || frameView === null)
+        return undefined;
+    const view = frameView.view;
+    if (typeof view !== 'object' || view === null)
+        return undefined;
+    const title = view.title;
+    return typeof title === 'string' && title !== '' ? title : undefined;
+}
+export function startLiveRender(deps) {
+    const verbosity = deps.verbosity ?? 'essential-tools';
+    const runtimes = new Map();
+    const state = { disposed: false };
+    const controller = new AbortController();
+    const runtimeFor = (threadId) => {
+        let runtime = runtimes.get(threadId);
+        if (runtime !== undefined)
+            return runtime;
+        runtime = {
+            render: createThreadRenderModel(),
+            tools: createToolActivitySurface({ verbosity }),
+            typing: createTypingLifecycle({
+                trigger: () => deps.delivery.typing(threadId),
+                intervalMs: deps.typingIntervalMs,
+                onFailure: (cause) => { deps.log?.('discord_live_typing_threw', { threadId, cause: String(cause) }); },
+            }),
+            scheduler: undefined,
+            activityScheduler: undefined,
+            finalizer: undefined,
+            headMessageId: undefined,
+            activityMessageId: undefined,
+            stepSeq: 0,
+            headAttempted: false,
+            activityAttempted: false,
+            turnId: undefined,
+            toolNames: new Map(),
+            toolTitles: new Map(),
+            lastTitle: undefined,
+        };
+        runtimes.set(threadId, runtime);
+        return runtime;
+    };
+    /** Flush the current answer text: create the head once, then edit it. */
+    function flushAnswer(threadId, runtime) {
+        const stepSeq = runtime.stepSeq;
+        return async (content) => {
+            if (runtime.stepSeq !== stepSeq)
+                return;
+            const payload = buildOutboundMessage({ kind: 'assistant', content });
+            if (runtime.headMessageId === undefined) {
+                // An earlier send whose application was unobservable must never be
+                // blind-resent (rest.ts contract): the stream pauses here and the
+                // finalizer's single fresh send carries the answer instead.
+                if (runtime.headAttempted)
+                    return;
+                const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
+                if (sent.outcome === 'completed')
+                    runtime.headMessageId = sent.messageId;
+                else if (sent.outcome === 'unknown') {
+                    runtime.headAttempted = true;
+                    deps.log?.('discord_live_head_send_unknown', { threadId });
+                }
+                return;
+            }
+            await deps.delivery.edit({ channelId: threadId, messageId: runtime.headMessageId, content: payload.content });
+        };
+    }
+    function beginTurn(threadId, runtime, turnId) {
+        runtime.render.beginTurn({ turnId });
+        runtime.turnId = turnId;
+        runtime.headMessageId = undefined;
+        runtime.activityMessageId = undefined;
+        runtime.headAttempted = false;
+        runtime.activityAttempted = false;
+        runtime.stepSeq += 1;
+        runtime.tools = createToolActivitySurface({ verbosity });
+        runtime.toolNames = new Map();
+        runtime.toolTitles = new Map();
+        runtime.scheduler?.dispose();
+        runtime.scheduler = createUpdateScheduler({
+            minIntervalMs: deps.updateIntervalMs,
+            onFlush: flushAnswer(threadId, runtime),
+            onFlushError: (cause) => { deps.log?.('discord_live_flush_failed', { threadId, cause: String(cause) }); },
+        });
+        // The activity message's own coalescer: row changes share one edit per
+        // interval, so parallel tools cannot exceed the channel's edit budget.
+        runtime.activityScheduler?.dispose();
+        runtime.activityScheduler = createUpdateScheduler({
+            minIntervalMs: deps.activityCoalesceMs ?? DEFAULT_ACTIVITY_COALESCE_MS,
+            onFlush: renderActivity(threadId, runtime),
+            onFlushError: (cause) => { deps.log?.('discord_live_activity_flush_failed', { threadId, cause: String(cause) }); },
+        });
+        runtime.finalizer = undefined;
+        // A fresh lifecycle per turn: start() no-ops on a stopped one, so a
+        // second turn in the same thread would otherwise never type again.
+        runtime.typing.dispose();
+        runtime.typing = createTypingLifecycle({
+            trigger: () => deps.delivery.typing(threadId),
+            intervalMs: deps.typingIntervalMs,
+            onFailure: (cause) => { deps.log?.('discord_live_typing_threw', { threadId, cause: String(cause) }); },
+        });
+        runtime.typing.start();
+    }
+    /** The activity message body: one icon + presentation title per call row. */
+    function renderActivityContent(runtime) {
+        const rows = runtime.tools.render();
+        return rows.map(row => {
+            const title = truncateText(row.title ?? row.label, ACTIVITY_TITLE_MAX);
+            return `> ${toolCategoryIcon(row.label)} ${title}`;
+        }).join('\n');
+    }
+    /** Render the tool rows into one bounded activity message (create once, edit after). */
+    function renderActivity(threadId, runtime) {
+        return async () => {
+            if (runtime.tools.render().length === 0)
+                return;
+            // Tool titles are Host-presented free text (terminal commands): they
+            // go through the same outbound builder as every other message path.
+            const payload = buildOutboundMessage({ kind: 'tool', content: renderActivityContent(runtime) });
+            if (runtime.activityMessageId === undefined) {
+                if (runtime.activityAttempted)
+                    return;
+                const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
+                if (sent.outcome === 'completed')
+                    runtime.activityMessageId = sent.messageId;
+                else if (sent.outcome === 'unknown') {
+                    runtime.activityAttempted = true;
+                    deps.log?.('discord_live_activity_send_unknown', { threadId });
+                }
+                return;
+            }
+            await deps.delivery.edit({ channelId: threadId, messageId: runtime.activityMessageId, content: payload.content });
+        };
+    }
+    function handleSessionEvent(sessionId, threadId, runtime, event, frameView) {
+        const data = event.data;
+        const turnId = typeof data['turn'] === 'number' ? String(data['turn']) : undefined;
+        const stepId = typeof data['step'] === 'number' ? String(data['step']) : undefined;
+        switch (event.type) {
+            case 'turn/start': {
+                if (typeof turnId !== 'string')
+                    return;
+                beginTurn(threadId, runtime, turnId);
+                return;
+            }
+            case 'step/start': {
+                if (turnId !== undefined && stepId !== undefined)
+                    runtime.render.beginStep({ turnId, stepId });
+                // A new step opens a NEW logical answer message: the previous
+                // step's completed head is never overwritten (stream-renderer spec).
+                runtime.headMessageId = undefined;
+                runtime.headAttempted = false;
+                runtime.stepSeq += 1;
+                // The previous step's finalize disposed the scheduler; a fresh one
+                // carries the new step's chunk coalescing.
+                runtime.scheduler?.dispose();
+                runtime.scheduler = createUpdateScheduler({
+                    minIntervalMs: deps.updateIntervalMs,
+                    onFlush: flushAnswer(threadId, runtime),
+                    onFlushError: (cause) => { deps.log?.('discord_live_flush_failed', { threadId, cause: String(cause) }); },
+                });
+                return;
+            }
+            case 'assistant/chunk': {
+                if (runtime.scheduler === undefined || turnId === undefined || stepId === undefined)
+                    return;
+                const chunk = data['chunk'];
+                if (chunk?.type !== 'text-delta' || typeof chunk.text !== 'string')
+                    return;
+                runtime.render.appendDelta({ turnId, stepId, text: chunk.text });
+                const snapshot = runtime.render.snapshot();
+                const current = snapshot.answers.find(answer => answer.stepId === stepId);
+                if (current !== undefined)
+                    runtime.scheduler.schedule(current.text);
+                return;
+            }
+            case 'assistant/message': {
+                if (turnId === undefined || stepId === undefined)
+                    return;
+                const interrupted = data['interrupted'] === true;
+                const text = assistantText(data['message']);
+                runtime.render.setAuthoritative({ turnId, stepId, text });
+                if (interrupted)
+                    runtime.render.interrupt({ turnId, stepId });
+                runtime.scheduler?.dispose();
+                runtime.scheduler = undefined;
+                if (text === '')
+                    return;
+                // The authoritative finalize sends exactly once per turn answer. It
+                // runs detached, so it captures the step generation here: a finalize
+                // whose REST is still in flight when the next step starts must not
+                // re-point the live head at its own (older) message.
+                const finalizedStepSeq = runtime.stepSeq;
+                runtime.finalizer = createAnswerFinalizer({
+                    delivery: {
+                        editHead: async ({ messageId, content }) => {
+                            const payload = buildOutboundMessage({ kind: 'assistant', content });
+                            // No head exists (text arrived without flushed chunks): the
+                            // first finalize send IS the head, recorded for continuations.
+                            if (messageId === '') {
+                                const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
+                                if (sent.outcome === 'completed') {
+                                    if (runtime.stepSeq === finalizedStepSeq && runtime.headMessageId === undefined) {
+                                        runtime.headMessageId = sent.messageId;
+                                    }
+                                    return { outcome: 'completed' };
+                                }
+                                return { outcome: 'failed' };
+                            }
+                            const edited = await deps.delivery.edit({ channelId: threadId, messageId, content: payload.content });
+                            return edited.outcome === 'completed' ? { outcome: 'completed' } : { outcome: 'failed' };
+                        },
+                        sendContinuation: async ({ content }) => {
+                            const payload = buildOutboundMessage({ kind: 'assistant', content });
+                            const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
+                            return sent.outcome === 'completed' ? { outcome: 'completed' } : { outcome: 'failed' };
+                        },
+                    },
+                    headMessageId: runtime.headMessageId ?? '',
+                });
+                const finalText = text + ANSWER_MARKER(interrupted, deps.interruptedMarker?.() ?? '*（已被中断）*');
+                void runtime.finalizer.finalize(finalText).catch((cause) => {
+                    deps.log?.('discord_live_finalize_threw', { threadId, cause: String(cause) });
+                });
+                return;
+            }
+            case 'tool/call': {
+                if (typeof data['callId'] !== 'string' || typeof data['name'] !== 'string')
+                    return;
+                const title = presentationTitle(frameView);
+                runtime.toolNames.set(data['callId'], data['name']);
+                if (title !== undefined)
+                    runtime.toolTitles.set(data['callId'], title);
+                runtime.tools.record({
+                    callId: data['callId'],
+                    toolName: data['name'],
+                    state: 'running',
+                    title,
+                    rawArguments: typeof data['arguments'] === 'string' ? data['arguments'] : undefined,
+                });
+                runtime.activityScheduler?.schedule(renderActivityContent(runtime));
+                return;
+            }
+            case 'tool/result': {
+                const callId = resultCallId(data);
+                if (callId === undefined)
+                    return;
+                const failed = data['error'] !== undefined;
+                runtime.tools.record({
+                    callId,
+                    toolName: runtime.toolNames.get(callId) ?? 'tool',
+                    state: failed ? 'failed' : 'succeeded',
+                    title: runtime.toolTitles.get(callId),
+                });
+                runtime.activityScheduler?.schedule(renderActivityContent(runtime));
+                return;
+            }
+            case 'turn/end': {
+                runtime.typing.stop('completed');
+                runtime.scheduler?.dispose();
+                runtime.scheduler = undefined;
+                runtime.activityScheduler?.dispose();
+                runtime.activityScheduler = undefined;
+                // The activity message is the live "what's happening" surface only:
+                // at turn end it is deleted — the durable record is the Session log
+                // and the assistant's answer.
+                const activityMessageId = runtime.activityMessageId;
+                runtime.activityMessageId = undefined;
+                if (activityMessageId !== undefined) {
+                    void deps.delivery.delete({ channelId: threadId, messageId: activityMessageId }).catch((cause) => {
+                        deps.log?.('discord_live_activity_delete_threw', { threadId, cause: String(cause) });
+                    });
+                }
+                deps.onTurnEnded?.(sessionId);
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    /** A bounded one-line summary of a queued message: text blocks only. */
+    function queueSummary(item) {
+        const record = (typeof item === 'object' && item !== null ? item : {});
+        const id = typeof record.id === 'string' ? record.id : '';
+        const content = Array.isArray(record.message?.content) ? record.message.content : [];
+        const text = truncateText(content
+            .filter((block) => typeof block === 'object' && block !== null && block.type === 'text')
+            .map(block => block.text)
+            .join(' '), 120);
+        return { id, summary: text === '' ? '（非文本消息）' : text };
+    }
+    function handleFrame(raw, envelopeRpcId) {
+        const frame = (typeof raw === 'object' && raw !== null ? raw : {});
+        const type = frame['type'];
+        const sessionId = typeof frame['sessionId'] === 'string' ? frame['sessionId'] : undefined;
+        if (typeof type !== 'string' || sessionId === undefined)
+            return;
+        if (type === 'session/queue') {
+            const items = Array.isArray(frame['items']) ? frame['items'] : [];
+            deps.onQueueSnapshot?.(sessionId, items.map(item => queueSummary(item)));
+            // Admission-time typing: typing starts when the prompt is
+            // ENQUEUED — covering the queue wait, agent startup, and first-token
+            // latency before the first turn event — and stops when the queue
+            // drains with no turn open (never wedges the indicator on).
+            const threadId = deps.threadForSession(sessionId);
+            if (threadId === undefined)
+                return;
+            const runtime = runtimeFor(threadId);
+            if (items.length > 0) {
+                runtime.typing.start();
+                return;
+            }
+            if (!runtime.render.snapshot().turnOpen)
+                runtime.typing.stop();
+            return;
+        }
+        if (type === 'session/projection') {
+            // DSH's model-generated session title (from the user's first input):
+            // rename the thread once per distinct title.
+            if (frame['key'] !== 'title')
+                return;
+            const title = frame['value'];
+            if (typeof title !== 'string' || title === '')
+                return;
+            const threadId = deps.threadForSession(sessionId);
+            if (threadId === undefined)
+                return;
+            const runtime = runtimeFor(threadId);
+            const name = safeTitle(title);
+            if (name === '' || name === runtime.lastTitle)
+                return;
+            runtime.lastTitle = name;
+            // Cold dedupe state after a restart: confirm the thread's wire name
+            // before PATCHing — Discord throttles renames hard (~2 per 10 min),
+            // and an unchanged session must not burn one on a no-op. Both sides
+            // are slugified: Discord stores names lowercased and dashed, so a
+            // raw comparison would report a false difference on every restart.
+            const renameNeeded = deps.threadName === undefined ? Promise.resolve(true)
+                : deps.threadName(threadId).then((current) => current === undefined || discordChannelNameKey(current) !== discordChannelNameKey(name)).catch(() => true);
+            void renameNeeded.then((needed) => {
+                if (!needed)
+                    return;
+                return deps.delivery.renameThread({ channelId: threadId, name }).then((result) => {
+                    if (result.outcome !== 'completed') {
+                        deps.log?.('discord_live_rename_failed', { threadId, name });
+                    }
+                });
+            }).catch((cause) => {
+                deps.log?.('discord_live_rename_threw', { threadId, cause: String(cause) });
+            });
+            return;
+        }
+        if (type === 'approval/requested') {
+            const threadId = deps.threadForSession(sessionId);
+            if (threadId === undefined || deps.requests === undefined)
+                return;
+            deps.requests.onApprovalRequested({
+                sessionId,
+                threadId,
+                rpcId: envelopeRpcId ?? '',
+                approvalId: typeof frame['approvalId'] === 'string' ? frame['approvalId'] : '',
+                toolName: typeof frame['toolName'] === 'string' ? frame['toolName'] : 'tool',
+                reason: typeof frame['reason'] === 'string' ? frame['reason'] : undefined,
+                expiresAtMs: Date.now() + deps.approvalTimeoutMs,
+            });
+            return;
+        }
+        if (type === 'approval/resolved') {
+            deps.requests?.onApprovalResolved({
+                sessionId,
+                approvalId: typeof frame['approvalId'] === 'string' ? frame['approvalId'] : '',
+                outcome: typeof frame['outcome'] === 'string' ? frame['outcome'] : undefined,
+            });
+            return;
+        }
+        if (type === 'question/requested') {
+            const threadId = deps.threadForSession(sessionId);
+            if (threadId === undefined || deps.requests === undefined)
+                return;
+            const questions = Array.isArray(frame['questions']) ? frame['questions'] : [];
+            deps.requests.onQuestionRequested({
+                sessionId,
+                threadId,
+                rpcId: envelopeRpcId ?? '',
+                questions,
+                expiresAtMs: Date.now() + deps.questionTimeoutMs,
+            });
+            return;
+        }
+        if (type === 'question/resolved') {
+            const outcome = frame['outcome'] === 'cancelled' ? 'cancelled' : 'answered';
+            deps.requests?.onQuestionResolved({
+                sessionId,
+                questionRpcId: typeof frame['questionRpcId'] === 'string' ? frame['questionRpcId'] : '',
+                outcome,
+            });
+            return;
+        }
+        if (type !== 'session/event')
+            return;
+        const threadId = deps.threadForSession(sessionId);
+        if (threadId === undefined)
+            return;
+        const eventWrapper = frame['event'];
+        if (eventWrapper === undefined || typeof eventWrapper.type !== 'string')
+            return;
+        handleSessionEvent(sessionId, threadId, runtimeFor(threadId), { type: eventWrapper.type, data: eventWrapper.data ?? {} }, frame['view']);
+    }
+    async function runLoop() {
+        // Bounded reopen loop: the mux stream is the live accelerator; a dropped
+        // stream reopens after backoff while reconciliation covers the gap.
+        // The flag is read through a call: dispose() mutates it asynchronously.
+        let backoffMs = 1_000;
+        const isDisposed = () => state.disposed;
+        while (!isDisposed()) {
+            try {
+                for await (const frame of deps.frames(controller.signal)) {
+                    if (isDisposed())
+                        return;
+                    try {
+                        const envelopeRpcId = (typeof frame === 'object' && frame !== null && 'rpcId' in frame)
+                            ? frame.rpcId
+                            : undefined;
+                        const payload = (typeof frame === 'object' && frame !== null && 'payload' in frame)
+                            ? frame.payload
+                            : frame;
+                        handleFrame(payload, typeof envelopeRpcId === 'string' ? envelopeRpcId : undefined);
+                    }
+                    catch (cause) {
+                        deps.log?.('discord_live_frame_threw', { cause: String(cause) });
+                    }
+                }
+                backoffMs = 1_000;
+            }
+            catch (cause) {
+                if (isDisposed())
+                    return;
+                deps.log?.('discord_live_stream_error', { cause: String(cause) });
+            }
+            if (isDisposed())
+                return;
+            await new Promise(resolve => { setTimeout(resolve, backoffMs); });
+            backoffMs = Math.min(backoffMs * 2, 30_000);
+        }
+    }
+    void runLoop();
+    return {
+        dispose() {
+            state.disposed = true;
+            controller.abort();
+            for (const runtime of runtimes.values()) {
+                runtime.scheduler?.dispose();
+                runtime.activityScheduler?.dispose();
+                runtime.typing.dispose();
+            }
+            runtimes.clear();
+        },
+    };
+}

package/lib/stream/markdown.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Markdown-aware splitting (design.md §8, task 11.6). Fenced code blocks stay
+ * balanced across chunk boundaries: a cut inside a fence closes it at the end
+ * of the earlier chunk and reopens it — same language — at the top of the
+ * next. Output ending inside a fence gets the fence closed. GFM tables are
+ * wrapped into fences (wrapGfmTables) before splitting, so they ride the
+ * same balance guarantee.
+ */
+/** Append a closing fence when `text` ends inside an open block. */
+export declare function closeOpenFences(text: string): string;
+/**
+ * Split like the base splitter, then rebalance fences across chunks: each
+ * chunk renders as well-formed Markdown on its own, and fence language
+ * markers survive the boundary.
+ */
+export declare function splitMarkdownAware(text: string, limit: number): string[];
+/**
+ * Discord does not render GFM tables: raw pipe rows collapse into ragged
+ * text. A table region outside any fence — a header row, a delimiter row,
+ * then body rows — is wrapped in a fence so Discord renders it as aligned
+ * monospace. Regions inside fences are left untouched, and the resulting
+ * fences are ordinary balanced fences to the splitter.
+ */
+export declare function wrapGfmTables(text: string): string;