switchroom 0.15.45 → 0.16.4

package/telegram-plugin/tests/draft-stream.test.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { createDraftStream } from '../draft-stream.js'
-import { __resetDraftIdForTests } from '../draft-transport.js'
 
 interface MockTelegram {
   send: (text: string) => Promise<number>
@@ -456,829 +455,3 @@ describe('createDraftStream', () => {
     expect(m.editCalls.length).toBe(1)
   })
 })
-
-// ─── Draft transport (sendMessageDraft) ───────────────────────────────────
-
-describe('createDraftStream — draft transport', () => {
-  beforeEach(() => {
-    vi.useFakeTimers()
-    __resetDraftIdForTests()
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  it('DM happy path: sendMessageDraft called per update, sendMessage NOT called during stream', async () => {
-    const m = makeMock()
-    const draftCalls: Array<{ chatId: string; draftId: number; text: string }> = []
-    const sendMessageDraft = vi.fn(async (chatId: string, draftId: number, text: string) => {
-      draftCalls.push({ chatId, draftId, text })
-    })
-
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 1000,
-      previewTransport: 'auto',
-      isPrivateChat: true,
-      sendMessageDraft,
-      chatId: 'chat1',
-    })
-
-    void stream.update('First update')
-    await microtaskFlush()
-
-    // Draft called, not sendMessage
-    expect(sendMessageDraft).toHaveBeenCalledTimes(1)
-    expect(draftCalls[0].text).toBe('First update')
-    expect(m.sendCalls.length).toBe(0)
-    expect(m.editCalls.length).toBe(0)
-
-    // Second update after throttle
-    vi.advanceTimersByTime(1000)
-    void stream.update('Second update')
-    await microtaskFlush()
-
-    expect(sendMessageDraft).toHaveBeenCalledTimes(2)
-    expect(draftCalls[1].text).toBe('Second update')
-    expect(m.sendCalls.length).toBe(0)
-  })
-
-  it('materialize on finalize: sends real sendMessage for push notification + clears draft', async () => {
-    const m = makeMock()
-    const draftClearCalls: string[] = []
-    const sendMessageDraft = vi.fn(async (_chatId: string, _draftId: number, text: string) => {
-      if (text === '') draftClearCalls.push(text)
-    })
-
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 1000,
-      previewTransport: 'draft',
-      isPrivateChat: true,
-      sendMessageDraft,
-      chatId: 'chat1',
-    })
-
-    void stream.update('Final answer')
-    await microtaskFlush()
-    expect(sendMessageDraft).toHaveBeenCalledTimes(1)
-
-    await stream.finalize()
-
-    // sendMessage should have been called to materialize
-    expect(m.sendCalls.length).toBe(1)
-    expect(m.sendCalls[0].text).toBe('Final answer')
-    expect(stream.getMessageId()).toBe(100)
-
-    // Draft should have been cleared (empty string call)
-    expect(draftClearCalls.length).toBe(1)
-    expect(stream.isFinal()).toBe(true)
-  })
-
-  it('init-time fallback when sendMessageDraft is undefined → uses sendMessage/editMessageText', async () => {
-    const m = makeMock()
-
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 1000,
-      previewTransport: 'draft',
-      isPrivateChat: true,
-      // No sendMessageDraft provided
-      chatId: 'chat1',
-    })
-
-    void stream.update('Hello')
-    await microtaskFlush()
-
-    expect(m.sendCalls.length).toBe(1)
-    expect(m.sendCalls[0].text).toBe('Hello')
-  })
-
-  it('runtime fallback on rejection matching DRAFT_METHOD_UNAVAILABLE_RE', async () => {
-    const m = makeMock()
-    let draftCallCount = 0
-    const sendMessageDraft = vi.fn(async () => {
-      draftCallCount++
-      throw new Error('sendMessageDraft: unknown method')
-    })
-
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 1000,
-      previewTransport: 'draft',
-      sendMessageDraft,
-      chatId: 'chat1',
-    })
-
-    void stream.update('Hello')
-    await microtaskFlush()
-
-    // Draft tried once, then fell back to sendMessage
-    expect(draftCallCount).toBe(1)
-    expect(m.sendCalls.length).toBe(1)
-    expect(m.sendCalls[0].text).toBe('Hello')
-
-    // Subsequent updates should use editMessageText, not draft
-    vi.advanceTimersByTime(1000)
-    void stream.update('Follow-up')
-    await microtaskFlush()
-
-    expect(draftCallCount).toBe(1) // no more draft calls
-    expect(m.editCalls.length).toBe(1)
-  })
-
-  it('runtime fallback on rejection matching DRAFT_CHAT_UNSUPPORTED_RE', async () => {
-    const m = makeMock()
-    const sendMessageDraft = vi.fn(async () => {
-      throw new Error("sendMessageDraft can't be used in this type of chat")
-    })
-
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 1000,
-      previewTransport: 'draft',
-      sendMessageDraft,
-      chatId: 'chat1',
-    })
-
-    void stream.update('Hello')
-    await microtaskFlush()
-
-    expect(sendMessageDraft).toHaveBeenCalledTimes(1)
-    expect(m.sendCalls.length).toBe(1)
-  })
-
-  it('non-matching rejection bubbles up — does not silently swap to message transport', async () => {
-    const m = makeMock()
-    const sendMessageDraft = vi.fn(async () => {
-      throw new Error('sendMessageDraft: internal server error 500')
-    })
-
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 1000,
-      previewTransport: 'draft',
-      sendMessageDraft,
-      chatId: 'chat1',
-    })
-
-    // The error should NOT trigger fallback — it should propagate (draft-stream
-    // logs it but doesn't swap; subsequent update can retry).
-    void stream.update('Hello')
-    await microtaskFlush()
-
-    // Did not fall through to sendMessage
-    expect(m.sendCalls.length).toBe(0)
-    // Draft was called
-    expect(sendMessageDraft).toHaveBeenCalledTimes(1)
-  })
-
-  it('group chat (isPrivateChat=false with auto transport) → never tries draft', async () => {
-    const m = makeMock()
-    const sendMessageDraft = vi.fn(async () => {})
-
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 1000,
-      previewTransport: 'auto',
-      isPrivateChat: false,
-      sendMessageDraft,
-      chatId: 'chat1',
-    })
-
-    void stream.update('Hello group')
-    await microtaskFlush()
-
-    expect(sendMessageDraft).not.toHaveBeenCalled()
-    expect(m.sendCalls.length).toBe(1)
-  })
-
-  it('forum topic (message transport) → never tries draft', async () => {
-    const m = makeMock()
-    const sendMessageDraft = vi.fn(async () => {})
-
-    // Caller forces message transport for forum topics
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 1000,
-      previewTransport: 'message',
-      isPrivateChat: true, // even if DM, message transport wins
-      sendMessageDraft,
-      chatId: 'chat1',
-    })
-
-    void stream.update('Hello forum')
-    await microtaskFlush()
-
-    expect(sendMessageDraft).not.toHaveBeenCalled()
-    expect(m.sendCalls.length).toBe(1)
-  })
-
-  it('initialMessageId — first update edits in place instead of sendMessage (#626)', async () => {
-    // Closes the duplicate-status-message regression: when a previous
-    // done=true finalized + deleted activeDraftStreams[sKey], the next
-    // emit creates a fresh stream. With initialMessageId, that fresh
-    // stream is initialized as if a previous send had landed with the
-    // given id, so the very first update fires editMessageText
-    // instead of sendMessage. No new "anchor message" lands.
-    const m = makeMock()
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 200,
-      initialMessageId: 999,
-    })
-    void stream.update('Edit-only payload')
-    await stream.finalize()
-    expect(m.sendCalls.length).toBe(0)
-    expect(m.editCalls.length).toBe(1)
-    expect(m.editCalls[0].id).toBe(999)
-    expect(m.editCalls[0].text).toBe('Edit-only payload')
-  })
-
-  it('initialMessageId — stale id falls back to sendMessage on not-found error', async () => {
-    // Defense in depth: if the externally-supplied id no longer exists
-    // (message deleted, chat moved, race), the edit returns
-    // "message to edit not found" and the draft stream re-sends. The
-    // user sees one fresh anchor — degraded but never silent failure.
-    const m = makeMock()
-    let editAttempts = 0
-    m.edit = async (_id: number, _text: string) => {
-      editAttempts++
-      throw new Error('Bad Request: message to edit not found')
-    }
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 200,
-      initialMessageId: 99999,
-    })
-    void stream.update('Recovery text')
-    await stream.finalize()
-    expect(editAttempts).toBeGreaterThanOrEqual(1)
-    expect(m.sendCalls.length).toBe(1)
-    expect(m.sendCalls[0].text).toBe('Recovery text')
-  })
-
-  it('initialMessageId — null/undefined behaves identically to omitted (back-compat)', async () => {
-    // The hook is opt-in. A caller that doesn't supply it (or supplies
-    // null) must observe identical behavior to the legacy path:
-    // first update sends, subsequent updates edit.
-    const m = makeMock()
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 200,
-      initialMessageId: null,
-    })
-    void stream.update('First call')
-    await stream.finalize()
-    expect(m.sendCalls.length).toBe(1)
-    expect(m.editCalls.length).toBe(0)
-  })
-
-  it('draft-clear failure is swallowed (best-effort)', async () => {
-    const m = makeMock()
-    let callCount = 0
-    const sendMessageDraft = vi.fn(async (_chatId: string, _draftId: number, text: string) => {
-      callCount++
-      if (text === '') throw new Error('Draft clear failed')
-      // Normal update — succeeds
-    })
-
-    const stream = createDraftStream(m.send, m.edit, {
-      throttleMs: 1000,
-      previewTransport: 'draft',
-      sendMessageDraft,
-      chatId: 'chat1',
-    })
-
-    void stream.update('Content')
-    await microtaskFlush()
-
-    // finalize should not throw even if draft-clear fails
-    await expect(stream.finalize()).resolves.toBeUndefined()
-    expect(m.sendCalls.length).toBe(1) // materialized
-    expect(callCount).toBeGreaterThan(1) // draft update + failed clear attempt
-  })
-
-  // ─── PR A observability: gw-trace stream-start / stream-end ───────────
-  describe('gw-trace stream-start / stream-end', () => {
-    let captured: string[] = []
-    let originalWrite: typeof process.stderr.write
-
-    beforeEach(() => {
-      captured = []
-      originalWrite = process.stderr.write
-      process.stderr.write = ((chunk: string | Uint8Array) => {
-        const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8')
-        captured.push(text)
-        return true
-      }) as typeof process.stderr.write
-    })
-    afterEach(() => {
-      process.stderr.write = originalWrite
-    })
-
-    it('emits stream-start with resolved transport=draft on dm + draftApi', async () => {
-      const m = makeMock()
-      const draftApi = vi.fn(async () => ({ ok: true }))
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 1000,
-        previewTransport: 'draft',
-        sendMessageDraft: draftApi,
-        chatId: 'chat-X',
-      })
-      const trace = captured.find((c) => c.includes('gw-trace stream-start'))
-      expect(trace).toBeDefined()
-      expect(trace).toContain('transport=draft')
-      expect(trace).toContain('reason=draft')
-      expect(trace).toContain('api=available')
-      expect(trace).toContain('chatId=chat-X')
-      await stream.finalize()
-    })
-
-    it('emits stream-start with reason=auto-non-dm when isPrivateChat is false', async () => {
-      const m = makeMock()
-      const draftApi = vi.fn(async () => ({ ok: true }))
-      createDraftStream(m.send, m.edit, {
-        throttleMs: 1000,
-        previewTransport: 'auto',
-        isPrivateChat: false,
-        sendMessageDraft: draftApi,
-        chatId: 'chat-Y',
-      })
-      const trace = captured.find((c) => c.includes('gw-trace stream-start'))
-      expect(trace).toBeDefined()
-      expect(trace).toContain('transport=message')
-      expect(trace).toContain('reason=auto-non-dm')
-    })
-
-    it('emits stream-end with fire counts on finalize', async () => {
-      const m = makeMock()
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'message',
-      })
-      void stream.update('first')
-      await microtaskFlush()
-      await stream.finalize()
-      const trace = captured.find((c) => c.includes('gw-trace stream-end'))
-      expect(trace).toBeDefined()
-      expect(trace).toContain('transport=message')
-      expect(trace).toMatch(/sends=[1-9]/)
-      expect(trace).toContain('firstFireMs=')
-      expect(trace).toContain('durationMs=')
-    })
-
-    it('SWITCHROOM_STREAM_TRACES=0 suppresses both traces', async () => {
-      const prev = process.env.SWITCHROOM_STREAM_TRACES
-      process.env.SWITCHROOM_STREAM_TRACES = '0'
-      try {
-        const m = makeMock()
-        const stream = createDraftStream(m.send, m.edit, {
-          throttleMs: 50,
-          previewTransport: 'message',
-        })
-        await stream.finalize()
-        expect(captured.find((c) => c.includes('gw-trace stream-'))).toBeUndefined()
-      } finally {
-        if (prev === undefined) delete process.env.SWITCHROOM_STREAM_TRACES
-        else process.env.SWITCHROOM_STREAM_TRACES = prev
-      }
-    })
-  })
-
-  // ─── PR B: transport-aware throttle defaults ──────────────────────────
-  describe('transport-aware throttle defaults (PR B)', () => {
-    let captured: string[] = []
-    let originalWrite: typeof process.stderr.write
-
-    beforeEach(() => {
-      captured = []
-      originalWrite = process.stderr.write
-      process.stderr.write = ((chunk: string | Uint8Array) => {
-        const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8')
-        captured.push(text)
-        return true
-      }) as typeof process.stderr.write
-    })
-    afterEach(() => {
-      process.stderr.write = originalWrite
-    })
-
-    it('draft transport defaults to 300ms throttle (sub-second)', () => {
-      const m = makeMock()
-      const draftApi = vi.fn(async () => ({ ok: true }))
-      createDraftStream(m.send, m.edit, {
-        previewTransport: 'draft',
-        sendMessageDraft: draftApi,
-        chatId: 'c1',
-      })
-      const trace = captured.find((c) => c.includes('gw-trace stream-start'))
-      expect(trace).toBeDefined()
-      expect(trace).toContain('throttleMs=300')
-    })
-
-    it('message transport defaults to 1000ms throttle', () => {
-      const m = makeMock()
-      createDraftStream(m.send, m.edit, {
-        previewTransport: 'message',
-      })
-      const trace = captured.find((c) => c.includes('gw-trace stream-start'))
-      expect(trace).toBeDefined()
-      expect(trace).toContain('throttleMs=1000')
-    })
-
-    it('auto + DM + draftApi resolves to draft default (300ms)', () => {
-      const m = makeMock()
-      const draftApi = vi.fn(async () => ({ ok: true }))
-      createDraftStream(m.send, m.edit, {
-        previewTransport: 'auto',
-        isPrivateChat: true,
-        sendMessageDraft: draftApi,
-        chatId: 'c1',
-      })
-      const trace = captured.find((c) => c.includes('gw-trace stream-start'))
-      expect(trace).toContain('throttleMs=300')
-    })
-
-    it('auto + non-DM resolves to message default (1000ms)', () => {
-      const m = makeMock()
-      const draftApi = vi.fn(async () => ({ ok: true }))
-      createDraftStream(m.send, m.edit, {
-        previewTransport: 'auto',
-        isPrivateChat: false,
-        sendMessageDraft: draftApi,
-        chatId: 'c1',
-      })
-      const trace = captured.find((c) => c.includes('gw-trace stream-start'))
-      expect(trace).toContain('throttleMs=1000')
-    })
-
-    it('explicit config.throttleMs wins over transport default', () => {
-      const m = makeMock()
-      const draftApi = vi.fn(async () => ({ ok: true }))
-      createDraftStream(m.send, m.edit, {
-        previewTransport: 'draft',
-        sendMessageDraft: draftApi,
-        chatId: 'c1',
-        throttleMs: 500,
-      })
-      const trace = captured.find((c) => c.includes('gw-trace stream-start'))
-      expect(trace).toContain('throttleMs=500')
-    })
-
-    it('explicit override below MIN_THROTTLE_MS is floored at 250', () => {
-      const m = makeMock()
-      createDraftStream(m.send, m.edit, {
-        previewTransport: 'message',
-        throttleMs: 100,
-      })
-      const trace = captured.find((c) => c.includes('gw-trace stream-start'))
-      expect(trace).toContain('throttleMs=250')
-    })
-  })
-
-  // ─── PR C: persist-then-continue chain at 25s / 4000-char boundary ───
-  describe('persist-chain (PR C)', () => {
-    let captured: string[] = []
-    let originalWrite: typeof process.stderr.write
-
-    beforeEach(() => {
-      // Outer describe sets useFakeTimers; keep that and drive time with
-      // advanceTimersByTimeAsync. The size-trigger doesn't need time at
-      // all (it fires on tail length); the time-trigger tests advance.
-      captured = []
-      originalWrite = process.stderr.write
-      process.stderr.write = ((chunk: string | Uint8Array) => {
-        const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8')
-        captured.push(text)
-        return true
-      }) as typeof process.stderr.write
-    })
-    afterEach(() => {
-      process.stderr.write = originalWrite
-    })
-
-    it('size-trigger: persist fires when tail crosses persistSizeLimit', async () => {
-      const m = makeMock()
-      const sendMessageDraft = vi.fn(async () => {})
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'draft',
-        sendMessageDraft,
-        chatId: 'chat-size',
-        persistSizeLimit: 200, // small for tests
-      })
-
-      // First update: 100 chars, below threshold. Drafts.
-      void stream.update('a'.repeat(100))
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(300); await microtaskFlush(20)
-      // Second update: 250 chars total, tail exceeds 200 → size persist.
-      void stream.update('a'.repeat(250))
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(300); await microtaskFlush(20)
-      await microtaskFlush(20)
-      await stream.finalize()
-
-      const persistLine = captured.find((c) => c.includes('gw-trace stream-persist'))
-      expect(persistLine).toBeDefined()
-      expect(persistLine).toContain('reason=size')
-      expect(m.sendCalls.length).toBeGreaterThan(0)
-    })
-
-    it('time-trigger: persist fires after persistIntervalMs elapsed', async () => {
-      const m = makeMock()
-      const sendMessageDraft = vi.fn(async () => {})
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'draft',
-        sendMessageDraft,
-        chatId: 'chat-time',
-        persistIntervalMs: 200, // small for tests
-      })
-
-      void stream.update('first chunk text')
-      await microtaskFlush(20)
-      // Advance past the time trigger.
-      vi.advanceTimersByTime(250); await microtaskFlush(20)
-      void stream.update('first chunk text continues')
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(300); await microtaskFlush(20)
-      await microtaskFlush(20)
-      await stream.finalize()
-
-      const persistLine = captured.find((c) => c.includes('gw-trace stream-persist'))
-      expect(persistLine).toBeDefined()
-      expect(persistLine).toContain('reason=time')
-    })
-
-    it('persist bumps persists counter in stream-end trace', async () => {
-      const m = makeMock()
-      const sendMessageDraft = vi.fn(async () => {})
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'draft',
-        sendMessageDraft,
-        chatId: 'chat-2',
-        persistSizeLimit: 100,
-      })
-
-      void stream.update('x'.repeat(50))
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(300); await microtaskFlush(20)
-      void stream.update('x'.repeat(150))
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(300); await microtaskFlush(20)
-      await microtaskFlush(20)
-      await stream.finalize()
-
-      const endLine = captured.find((c) => c.includes('gw-trace stream-end'))
-      expect(endLine).toBeDefined()
-      expect(endLine).toMatch(/persists=[1-9]/)
-    })
-
-    it('finalize only materializes the unpersisted tail (no duplicate)', async () => {
-      const m = makeMock()
-      const sendMessageDraft = vi.fn(async () => {})
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'draft',
-        sendMessageDraft,
-        chatId: 'chat-3',
-        persistSizeLimit: 200,
-      })
-
-      void stream.update('a'.repeat(100))
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(300); await microtaskFlush(20)
-      void stream.update('a'.repeat(250)) // size trigger fires
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(300); await microtaskFlush(20)
-      await microtaskFlush(20)
-      const persistsBefore = m.sendCalls.length
-      expect(persistsBefore).toBeGreaterThan(0)
-
-      // Now add a small tail and finalize. The tail-only send should
-      // be much smaller than 250 — only post-persist content.
-      void stream.update('a'.repeat(250) + 'tail')
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(300); await microtaskFlush(20)
-      await stream.finalize()
-
-      const lastSend = m.sendCalls[m.sendCalls.length - 1]
-      expect(lastSend).toBeDefined()
-      // Without PR C, finalize would re-send the entire 250+ chars.
-      expect(lastSend!.text.length).toBeLessThan(50)
-    })
-
-    it('message-transport stream has persists=0 (no chunking)', async () => {
-      const m = makeMock()
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'message',
-      })
-      void stream.update('z'.repeat(3000))
-      await microtaskFlush(20)
-      await stream.finalize()
-      const endLine = captured.find((c) => c.includes('gw-trace stream-end'))
-      expect(endLine).toContain('persists=0')
-    })
-  })
-
-  // ─── PR D: 429 + non-true return fallback robustness ──────────────────
-  describe('429 + non-true fallback (PR D)', () => {
-    it('429 on draft falls back to message transport (no further draft fires)', async () => {
-      const m = makeMock()
-      let draftCalls = 0
-      const sendMessageDraft = vi.fn(async () => {
-        draftCalls++
-        const err = new Error('sendMessageDraft: Too Many Requests: retry after 3') as Error & {
-          error_code?: number
-          method?: string
-          parameters?: { retry_after?: number }
-        }
-        err.error_code = 429
-        err.method = 'sendMessageDraft'
-        err.parameters = { retry_after: 3 }
-        throw err
-      })
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'draft',
-        sendMessageDraft,
-        chatId: 'chat-429',
-      })
-
-      void stream.update('hello')
-      await microtaskFlush(20)
-      expect(draftCalls).toBe(1)
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(3500)
-      await microtaskFlush(20)
-      await stream.finalize()
-      expect(m.sendCalls.length).toBeGreaterThanOrEqual(1)
-      // sendMessageDraft was NOT called again after the 429.
-      expect(draftCalls).toBe(1)
-    })
-
-    it('non-true (false) return from sendMessageDraft triggers fallback', async () => {
-      const m = makeMock()
-      let draftCalls = 0
-      const sendMessageDraft = vi.fn(async () => {
-        draftCalls++
-        return false
-      })
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'draft',
-        sendMessageDraft,
-        chatId: 'chat-nonbool',
-      })
-      void stream.update('content')
-      await microtaskFlush(20)
-      expect(draftCalls).toBe(1)
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(100)
-      await microtaskFlush(20)
-      await stream.finalize()
-      // Subsequent updates / finalize do NOT re-invoke sendMessageDraft.
-      expect(draftCalls).toBe(1)
-      expect(m.sendCalls.length).toBeGreaterThanOrEqual(1)
-    })
-
-    it('undefined return is treated as success (does not trigger fallback)', async () => {
-      // grammY's typed wrapper sometimes returns void/undefined on
-      // success. We must not false-positive fallback on those.
-      const m = makeMock()
-      let draftCalls = 0
-      const sendMessageDraft = vi.fn(async () => {
-        draftCalls++
-        return undefined
-      })
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'draft',
-        sendMessageDraft,
-        chatId: 'chat-undef',
-      })
-      void stream.update('first')
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(100)
-      void stream.update('second')
-      await microtaskFlush(20)
-      vi.advanceTimersByTime(100)
-      await microtaskFlush(20)
-      await stream.finalize()
-      expect(draftCalls).toBeGreaterThan(1)
-    })
-
-    it('429 path increments fallbacks counter (visible in stream-end trace)', async () => {
-      const captured: string[] = []
-      const originalWrite = process.stderr.write
-      process.stderr.write = ((chunk: string | Uint8Array) => {
-        const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8')
-        captured.push(text)
-        return true
-      }) as typeof process.stderr.write
-      try {
-        const m = makeMock()
-        const sendMessageDraft = vi.fn(async () => {
-          const err = new Error('429') as Error & {
-            error_code?: number
-            method?: string
-            parameters?: { retry_after?: number }
-          }
-          err.error_code = 429
-          err.method = 'sendMessageDraft'
-          err.parameters = { retry_after: 2 }
-          throw err
-        })
-        const stream = createDraftStream(m.send, m.edit, {
-          throttleMs: 50,
-          previewTransport: 'draft',
-          sendMessageDraft,
-          chatId: 'chat-429-trace',
-        })
-        void stream.update('text')
-        await microtaskFlush(20)
-        vi.advanceTimersByTime(3000)
-        await stream.finalize()
-        const endLine = captured.find((c) => c.includes('gw-trace stream-end'))
-        expect(endLine).toBeDefined()
-        expect(endLine).toMatch(/fallbacks=[1-9]/)
-      } finally {
-        process.stderr.write = originalWrite
-      }
-    })
-  })
-
-  // ─── Follow-up: stream-end `sends` counter includes finalize-materialize ───
-  describe('finalize-materialize bumps sends counter', () => {
-    let captured: string[] = []
-    let originalWrite: typeof process.stderr.write
-
-    beforeEach(() => {
-      captured = []
-      originalWrite = process.stderr.write
-      process.stderr.write = ((chunk: string | Uint8Array) => {
-        const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8')
-        captured.push(text)
-        return true
-      }) as typeof process.stderr.write
-    })
-    afterEach(() => {
-      process.stderr.write = originalWrite
-    })
-
-    it('draft-transport stream that materializes on finalize shows sends>=1', async () => {
-      // Pre-fix this showed sends=0 even though sendMessage fired
-      // inside finalize. Bug was visible in production v0.13.0 traces.
-      const m = makeMock()
-      const sendMessageDraft = vi.fn(async () => {})
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'draft',
-        sendMessageDraft,
-        chatId: 'chat-x',
-      })
-      void stream.update('Hello world')
-      await microtaskFlush()
-      vi.advanceTimersByTime(100)
-      await microtaskFlush()
-      await stream.finalize()
-      // Real send() called inside finalize.
-      expect(m.sendCalls.length).toBe(1)
-      const endLine = captured.find((c) => c.includes('gw-trace stream-end'))
-      expect(endLine).toBeDefined()
-      // Counter now reflects reality.
-      expect(endLine).toMatch(/sends=[1-9]/)
-    })
-
-    it('persist-chain bump counts toward sends (size-trigger fires + finalize)', async () => {
-      // The sibling bug at the persist-chain callsite — its bare
-      // send(chunk) also bypasses sendViaMessage. Without the fix
-      // a stream that crosses the size boundary would show sends=1
-      // (only the finalize materialize), missing the chain fire.
-      // With the fix sends counts BOTH the persist send AND the
-      // finalize materialize → sends>=2.
-      const m = makeMock()
-      const sendMessageDraft = vi.fn(async () => {})
-      const stream = createDraftStream(m.send, m.edit, {
-        throttleMs: 50,
-        previewTransport: 'draft',
-        sendMessageDraft,
-        chatId: 'chat-chain',
-        persistSizeLimit: 200,
-      })
-      void stream.update('a'.repeat(100))
-      await microtaskFlush()
-      vi.advanceTimersByTime(300)
-      void stream.update('a'.repeat(250)) // size trigger fires (tail=250 ≥ 200)
-      await microtaskFlush()
-      vi.advanceTimersByTime(300)
-      await microtaskFlush()
-      // Extra text after persist so finalize-materialize tail is non-empty.
-      void stream.update('a'.repeat(250) + 'b'.repeat(50))
-      await microtaskFlush()
-      vi.advanceTimersByTime(300)
-      await microtaskFlush()
-      await stream.finalize()
-      const endLine = captured.find((c) => c.includes('gw-trace stream-end'))
-      expect(endLine).toBeDefined()
-      // Persist send + finalize materialize = at least 2.
-      expect(endLine).toMatch(/sends=[2-9]/)
-      expect(endLine).toMatch(/persists=[1-9]/)
-    })
-  })
-
-})