collavre 0.24.0 → 0.25.0

data/app/javascript/controllers/comments/__tests__/form_controller_ime_send.test.js

@@ -0,0 +1,324 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from '@jest/globals'
+import { Application } from '@hotwired/stimulus'
+import FormController from '../form_controller'
+import chatDrafts from '../../../lib/chat_drafts'
+
+describe('FormController - IME composition send', () => {
+  let application
+  let container
+  let controller
+  let popupEl
+
+  const FIXTURE = `
+    <div id="comments-popup"
+         data-controller="comments--form"
+         data-update-comment-text="Update">
+      <form data-comments--form-target="form">
+        <input type="hidden" name="comment[quoted_comment_id]" data-comments--form-target="quotedCommentId" value="" />
+        <input type="hidden" name="comment[quoted_text]" data-comments--form-target="quotedText" value="" />
+        <div data-comments--form-target="quoteIndicator" style="display:none;">
+          <span data-comments--form-target="quoteIndicatorText"></span>
+        </div>
+        <div class="review-quotes-container" data-comments--form-target="reviewQuotesContainer" style="display:none;"></div>
+        <textarea data-comments--form-target="textarea" rows="2"></textarea>
+        <input type="checkbox" data-comments--form-target="privateCheckbox" />
+        <button type="submit" data-comments--form-target="submit">Send</button>
+        <button data-comments--form-target="cancel" style="display:none;">Cancel</button>
+        <button data-comments--form-target="searchButton" style="display:none;">Search</button>
+        <button data-comments--form-target="voiceButton" style="display:none;">Voice</button>
+        <input type="file" data-comments--form-target="imageInput" style="display:none;" />
+        <button data-comments--form-target="imageButton" style="display:none;">Image</button>
+        <div data-comments--form-target="attachmentList"></div>
+      </form>
+    </div>`
+
+  // Stimulus disconnects a removed controller asynchronously, so a previous
+  // test's pending draft flush can land inside a later test's timer wait.
+  // Giving each test its own chat id keeps those flushes off our key.
+  let chatId
+  let nextChatId = 77
+
+  const dispatchTopicChange = (effectiveCreativeId = chatId, topicId = '10073') => {
+    popupEl.dataset.effectiveCreativeId = String(effectiveCreativeId)
+    popupEl.dispatchEvent(
+      new CustomEvent('comments--topics:change', { detail: { topicId } }),
+    )
+  }
+
+  const typeInto = (textarea, value) => {
+    textarea.value = value
+    textarea.dispatchEvent(new Event('input', { bubbles: true }))
+  }
+
+  // A real IME commit ends the composition and then fires `input` for the
+  // committed text. jsdom has no IME, so replay that exact pair.
+  const commitComposition = (textarea, value = textarea.value) => {
+    textarea.dispatchEvent(new CompositionEvent('compositionend', { bubbles: true, data: value }))
+    textarea.value = value
+    textarea.dispatchEvent(new Event('input', { bubbles: true }))
+  }
+
+  beforeEach(async () => {
+    window.localStorage.clear()
+    window.sessionStorage.clear()
+    document.body.dataset.currentUserId = '9'
+
+    if (typeof global.requestAnimationFrame !== 'function') {
+      global.requestAnimationFrame = (cb) => setTimeout(cb, 0)
+    }
+    const meta = document.createElement('meta')
+    meta.name = 'csrf-token'
+    meta.content = 'test-token'
+    document.head.appendChild(meta)
+
+    container = document.createElement('div')
+    container.innerHTML = FIXTURE
+    document.body.appendChild(container)
+
+    application = Application.start()
+    application.register('comments--form', FormController)
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    popupEl = container.querySelector('#comments-popup')
+    controller = application.getControllerForElementAndIdentifier(popupEl, 'comments--form')
+    jest.spyOn(controller, 'setImageFiles').mockImplementation(() => {})
+    chatId = String(nextChatId)
+    nextChatId += 1
+    controller.creativeId = chatId
+  })
+
+  afterEach(() => {
+    application.stop()
+    document.body.removeChild(container)
+    document.head.querySelector('meta[name="csrf-token"]').remove()
+    delete document.body.dataset.currentUserId
+    jest.restoreAllMocks()
+  })
+
+  test('Enter pressed while an IME composition is active does not send', async () => {
+    dispatchTopicChange()
+    global.fetch = jest.fn(() => Promise.resolve({
+      ok: true,
+      status: 200,
+      text: () => Promise.resolve('<div></div>'),
+    }))
+    typeInto(controller.textareaTarget, '안녕하세')
+
+    controller.textareaTarget.dispatchEvent(new KeyboardEvent('keydown', {
+      key: 'Enter',
+      isComposing: true,
+      bubbles: true,
+      cancelable: true,
+    }))
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(global.fetch).not.toHaveBeenCalled()
+    expect(controller.textareaTarget.value).toBe('안녕하세')
+  })
+
+  test('an IME commit after send does not restore the sent text into the textarea', async () => {
+    dispatchTopicChange()
+    let finishFetch
+    global.fetch = jest.fn(() => new Promise((resolve) => { finishFetch = resolve }))
+
+    typeInto(controller.textareaTarget, '안녕하세요')
+    controller.handleSend(new Event('submit', { cancelable: true }))
+
+    // The IME commits the pending syllable right after keydown started the
+    // send. The textarea content is unchanged, but an input event still fires.
+    commitComposition(controller.textareaTarget)
+
+    finishFetch({ ok: true, status: 200, text: () => Promise.resolve('<div></div>') })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(controller.textareaTarget.value).toBe('')
+    expect(chatDrafts.get(chatId)).toBeNull()
+  })
+
+  test('a slow send does not let the IME commit debounce the sent text into storage', async () => {
+    dispatchTopicChange()
+    let finishFetch
+    global.fetch = jest.fn(() => new Promise((resolve) => { finishFetch = resolve }))
+
+    typeInto(controller.textareaTarget, '안녕하세요')
+    controller.handleSend(new Event('submit', { cancelable: true }))
+    commitComposition(controller.textareaTarget)
+
+    // The response outlives the 500ms draft debounce window.
+    await new Promise((resolve) => setTimeout(resolve, 600))
+    expect(chatDrafts.get(chatId)).toBeNull()
+
+    finishFetch({ ok: true, status: 200, text: () => Promise.resolve('<div></div>') })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(controller.textareaTarget.value).toBe('')
+    expect(chatDrafts.get(chatId)).toBeNull()
+  })
+
+  test('Enter after the composition ends still sends', async () => {
+    dispatchTopicChange()
+    global.fetch = jest.fn(() => Promise.resolve({
+      ok: true,
+      status: 200,
+      text: () => Promise.resolve('<div></div>'),
+    }))
+    typeInto(controller.textareaTarget, '안녕하세요')
+
+    controller.textareaTarget.dispatchEvent(new KeyboardEvent('keydown', {
+      key: 'Enter',
+      isComposing: false,
+      bubbles: true,
+      cancelable: true,
+    }))
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(global.fetch).toHaveBeenCalled()
+    expect(controller.textareaTarget.value).toBe('')
+  })
+
+  test('re-entering the same text during the send is preserved, not treated as an IME commit', async () => {
+    dispatchTopicChange()
+    let finishFetch
+    global.fetch = jest.fn(() => new Promise((resolve) => { finishFetch = resolve }))
+
+    typeInto(controller.textareaTarget, 'send me twice')
+    controller.handleSend(new Event('submit', { cancelable: true }))
+
+    // Select-all + paste of the identical string to send it again. No
+    // composition is involved, so this is a genuine edit even though the
+    // value matches the in-flight submission.
+    typeInto(controller.textareaTarget, 'send me twice')
+
+    finishFetch({ ok: true, status: 200, text: () => Promise.resolve('<div></div>') })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(controller.textareaTarget.value).toBe('send me twice')
+    expect(chatDrafts.get(chatId)).toBe('send me twice')
+  })
+
+  test('an input event still carrying isComposing is treated as an IME commit', async () => {
+    dispatchTopicChange()
+    let finishFetch
+    global.fetch = jest.fn(() => new Promise((resolve) => { finishFetch = resolve }))
+
+    typeInto(controller.textareaTarget, '안녕하세요')
+    controller.handleSend(new Event('submit', { cancelable: true }))
+
+    // Some browsers fire the commit `input` before `compositionend`, with
+    // isComposing still set on the input event itself.
+    controller.textareaTarget.dispatchEvent(
+      new InputEvent('input', { bubbles: true, isComposing: true }),
+    )
+
+    finishFetch({ ok: true, status: 200, text: () => Promise.resolve('<div></div>') })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(controller.textareaTarget.value).toBe('')
+    expect(chatDrafts.get(chatId)).toBeNull()
+  })
+
+  test.each(['paste', 'drop'])('a compositionend that trails the commit input does not swallow a later %s', async (gesture) => {
+    dispatchTopicChange()
+    let finishFetch
+    global.fetch = jest.fn(() => new Promise((resolve) => { finishFetch = resolve }))
+
+    typeInto(controller.textareaTarget, 'send me twice')
+    controller.handleSend(new Event('submit', { cancelable: true }))
+
+    // Input-before-compositionend ordering: the commit input already identified
+    // itself, so the trailing compositionend has no input left to pair with.
+    controller.textareaTarget.dispatchEvent(
+      new InputEvent('input', { bubbles: true, isComposing: true }),
+    )
+    controller.textareaTarget.dispatchEvent(
+      new CompositionEvent('compositionend', { bubbles: true, data: 'send me twice' }),
+    )
+
+    // Select-all + paste (or drag-drop) of the identical string to send it again.
+    controller.textareaTarget.dispatchEvent(new Event(gesture, { bubbles: true }))
+    typeInto(controller.textareaTarget, 'send me twice')
+
+    finishFetch({ ok: true, status: 200, text: () => Promise.resolve('<div></div>') })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(controller.textareaTarget.value).toBe('send me twice')
+    expect(chatDrafts.get(chatId)).toBe('send me twice')
+  })
+
+  test('a compositionend that trails the commit input does not swallow later typing', async () => {
+    dispatchTopicChange()
+    let finishFetch
+    global.fetch = jest.fn(() => new Promise((resolve) => { finishFetch = resolve }))
+
+    typeInto(controller.textareaTarget, 'send me twice')
+    controller.handleSend(new Event('submit', { cancelable: true }))
+
+    controller.textareaTarget.dispatchEvent(
+      new InputEvent('input', { bubbles: true, isComposing: true }),
+    )
+    controller.textareaTarget.dispatchEvent(
+      new CompositionEvent('compositionend', { bubbles: true, data: 'send me twice' }),
+    )
+
+    // Retyping the same string by hand — an ordinary keystroke, not a commit.
+    controller.textareaTarget.dispatchEvent(new KeyboardEvent('keydown', {
+      key: 'e',
+      isComposing: false,
+      bubbles: true,
+      cancelable: true,
+    }))
+    typeInto(controller.textareaTarget, 'send me twice')
+
+    finishFetch({ ok: true, status: 200, text: () => Promise.resolve('<div></div>') })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(controller.textareaTarget.value).toBe('send me twice')
+    expect(chatDrafts.get(chatId)).toBe('send me twice')
+  })
+
+  test('a composing keydown between compositionend and the commit input keeps the latch', async () => {
+    dispatchTopicChange()
+    let finishFetch
+    global.fetch = jest.fn(() => new Promise((resolve) => { finishFetch = resolve }))
+
+    typeInto(controller.textareaTarget, '안녕하세요')
+    controller.handleSend(new Event('submit', { cancelable: true }))
+
+    controller.textareaTarget.dispatchEvent(
+      new CompositionEvent('compositionend', { bubbles: true, data: '안녕하세요' }),
+    )
+    // Soft keyboards can interleave the next composing keystroke before the
+    // commit input lands; that is not a fresh gesture, so it must not expire.
+    controller.textareaTarget.dispatchEvent(new KeyboardEvent('keydown', {
+      keyCode: 229,
+      bubbles: true,
+      cancelable: true,
+    }))
+    controller.textareaTarget.dispatchEvent(new Event('input', { bubbles: true }))
+
+    finishFetch({ ok: true, status: 200, text: () => Promise.resolve('<div></div>') })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(controller.textareaTarget.value).toBe('')
+    expect(chatDrafts.get(chatId)).toBeNull()
+  })
+
+  test('text genuinely typed during the send is still preserved', async () => {
+    dispatchTopicChange()
+    let finishFetch
+    global.fetch = jest.fn(() => new Promise((resolve) => { finishFetch = resolve }))
+
+    typeInto(controller.textareaTarget, 'first message')
+    controller.handleSend(new Event('submit', { cancelable: true }))
+    typeInto(controller.textareaTarget, 'typed while sending')
+
+    finishFetch({ ok: true, status: 200, text: () => Promise.resolve('<div></div>') })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(controller.textareaTarget.value).toBe('typed while sending')
+    expect(chatDrafts.get(chatId)).toBe('typed while sending')
+  })
+})

data/app/javascript/controllers/comments/__tests__/form_controller_review.test.js

@@ -282,7 +282,7 @@ describe('FormController - Review Quote Chips', () => {
 
       expect(getQuotes(controller)).toHaveLength(0)
       expect(getActiveId(controller)).toBeNull()
-      expect(controller.textareaTarget.placeholder).toBe('')
+      expect(controller.textareaTarget.placeholder).toBe('Type a message, or use / for commands')
       expect(container.querySelector('.review-quotes-container').style.display).toBe('none')
     })
 
@@ -306,7 +306,7 @@ describe('FormController - Review Quote Chips', () => {
 
       expect(getQuotes(controller)).toHaveLength(0)
       expect(getActiveId(controller)).toBeNull()
-      expect(controller.textareaTarget.placeholder).toBe('')
+      expect(controller.textareaTarget.placeholder).toBe('Type a message, or use / for commands')
     })
   })
 
@@ -343,4 +343,30 @@ describe('FormController - Review Quote Chips', () => {
       expect(controller.textareaTarget.value).toBe('fb2')
     })
   })
+
+  describe('active chip re-click - programmatic scroll', () => {
+    // Re-clicking the active chip scrolls its quoted comment into view. That is a
+    // programmatic list scroll, so it must drop the prev-message anchor the same way
+    // scrollToBottom/highlightComment do — otherwise a stale anchor inside the corridor
+    // survives and the next previous-message click skips the comment now in view.
+    test('re-clicking the active chip notifies the list of a programmatic scroll', () => {
+      const commentEl = document.createElement('div')
+      commentEl.setAttribute('data-comment-id', '1')
+      commentEl.scrollIntoView = jest.fn() // jsdom has no scrollIntoView
+      document.body.appendChild(commentEl)
+
+      const notifyProgrammaticScroll = jest.fn()
+      jest
+        .spyOn(controller, 'listController', 'get')
+        .mockReturnValue({ notifyProgrammaticScroll })
+
+      controller.appendReviewQuote(1, 'first') // freshly appended quote is active
+      container.querySelector('.review-quote-chip-text').click()
+
+      expect(commentEl.scrollIntoView).toHaveBeenCalled()
+      expect(notifyProgrammaticScroll).toHaveBeenCalled()
+
+      commentEl.remove()
+    })
+  })
 })

data/app/javascript/controllers/comments/__tests__/form_controller_search_submit.test.js

@@ -0,0 +1,106 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from '@jest/globals'
+import CommentsFormController from '../form_controller'
+
+const COMMENT_HTML =
+  '<div id="comment_9" class="comment-item" data-comment-id="9">hello team</div>'
+
+// renderCommentHtml reaches for #comments-list in the document and for the
+// sibling list controller through the `listController` getter. Stub both.
+const buildController = ({ manualSearchQuery = null } = {}) => {
+  document.body.innerHTML = `
+    <div id="comments-list">
+      <div id="no-search-results" class="comments-placeholder">no results</div>
+    </div>
+  `
+
+  const listCtrl = {
+    manualSearchQuery,
+    resetToLatest: jest.fn(),
+    markCommentsRead: jest.fn(),
+    recordRenderedAllTopicWatermarks: jest.fn(),
+    reportRenderedAllTopics: jest.fn(),
+  }
+
+  const controller = Object.create(CommentsFormController.prototype)
+  Object.defineProperty(controller, 'listController', { get: () => listCtrl })
+
+  return { controller, listCtrl }
+}
+
+const listItems = () =>
+  document.getElementById('comments-list').querySelectorAll('.comment-item')
+
+describe('CommentsFormController local submit during search', () => {
+  test('leaves search and reloads rather than appending into the results', () => {
+    const { controller, listCtrl } = buildController({ manualSearchQuery: 'invoice' })
+
+    controller.renderCommentHtml(COMMENT_HTML)
+
+    // The posted comment carries no verdict on whether it matches the query,
+    // so it must not be spliced into the result set.
+    expect(listItems()).toHaveLength(0)
+    expect(listCtrl.resetToLatest).toHaveBeenCalledTimes(1)
+  })
+
+  test('keeps the no-results notice instead of clearing it on submit', () => {
+    const { controller } = buildController({ manualSearchQuery: 'invoice' })
+
+    controller.renderCommentHtml(COMMENT_HTML)
+
+    // removePlaceholder() clears any .comments-placeholder, so reaching it
+    // would strip the explanation and leave an unrelated message alone on
+    // screen. resetToLatest() re-renders the list from the server instead.
+    expect(document.getElementById('no-search-results')).not.toBeNull()
+  })
+
+  test('appends normally when no search is active', () => {
+    const { controller, listCtrl } = buildController({ manualSearchQuery: null })
+
+    controller.renderCommentHtml(COMMENT_HTML)
+
+    expect(listItems()).toHaveLength(1)
+    expect(listCtrl.resetToLatest).not.toHaveBeenCalled()
+    expect(listCtrl.recordRenderedAllTopicWatermarks).toHaveBeenCalledWith(
+      document.getElementById('comment_9'),
+      { includeNewTopics: true },
+    )
+    // The placeholder is stale once a real comment lands.
+    expect(document.getElementById('no-search-results')).toBeNull()
+  })
+
+  test('extends and reports the All Messages snapshot for a locally appended topic', () => {
+    const { controller, listCtrl } = buildController({ manualSearchQuery: null })
+    listCtrl.recordRenderedAllTopicWatermarks.mockReturnValue(true)
+
+    controller.renderCommentHtml(
+      '<div id="comment_10" class="comment-item" data-comment-id="10" data-topic-id="2">new topic</div>',
+    )
+
+    expect(listCtrl.recordRenderedAllTopicWatermarks).toHaveBeenCalledWith(
+      document.getElementById('comment_10'),
+      { includeNewTopics: true },
+    )
+    expect(listCtrl.reportRenderedAllTopics).toHaveBeenCalledTimes(1)
+  })
+
+  test('still replaces an edited comment in place during a search', () => {
+    // Mirrors the stream path, which blocks `append` but never `replace` /
+    // `remove`: the edited comment is already part of the result set, so
+    // dropping the update would leave stale text on screen.
+    const { controller, listCtrl } = buildController({ manualSearchQuery: 'invoice' })
+    document.getElementById('comments-list').insertAdjacentHTML(
+      'beforeend',
+      '<div id="comment_9" class="comment-item" data-comment-id="9">old text</div>',
+    )
+
+    controller.renderCommentHtml(COMMENT_HTML, { replaceExisting: true })
+
+    expect(listCtrl.resetToLatest).not.toHaveBeenCalled()
+    expect(document.getElementById('comment_9').textContent).toBe('hello team')
+    expect(listItems()).toHaveLength(1)
+  })
+})

data/app/javascript/controllers/comments/__tests__/form_controller_stashed_draft.test.js

@@ -0,0 +1,134 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from '@jest/globals'
+import CommentsFormController from '../form_controller'
+
+// A slash command with an input schema takes over the textarea and submits
+// itself (modules/command_menu.js `argsForm.onSubmit`), so a draft the user had
+// already typed cannot go out with it. The menu hands the draft over on a
+// `comments--form:stash-draft` event and the controller puts it back once the
+// send settles.
+const buildController = () => {
+  document.body.innerHTML = '<div id="comments-popup"><textarea></textarea></div>'
+  const textarea = document.querySelector('textarea')
+
+  const controller = Object.create(CommentsFormController.prototype)
+  Object.defineProperty(controller, 'textareaTarget', { get: () => textarea })
+  controller._autoResize = jest.fn()
+  controller._updateSubmitButton = jest.fn()
+  controller.creativeId = '7'
+
+  return { controller, textarea }
+}
+
+// The stash is tagged with the creative it was typed in, so tests build it the
+// way handleStashDraft does rather than assigning a bare string.
+const stash = (controller, draft) => {
+  controller._stashedDraft = { draft, creativeId: controller.creativeId }
+}
+
+describe('CommentsFormController stashed draft', () => {
+  test('stashes the draft carried by the event', () => {
+    const { controller } = buildController()
+
+    controller.handleStashDraft(
+      new CustomEvent('comments--form:stash-draft', { detail: { draft: 'roadmap notes' } }),
+    )
+
+    expect(controller._stashedDraft).toEqual({ draft: 'roadmap notes', creativeId: '7' })
+  })
+
+  test('receives the event dispatched on the textarea, which bubbles to the popup', () => {
+    // command_menu.js dispatches on `#new-comment-form textarea`, and the
+    // comments--form controller element is `#comments-popup`, which wraps the
+    // form (_comments_popup.html.erb). The stash only arrives if it bubbles.
+    const { controller, textarea } = buildController()
+    const element = document.getElementById('comments-popup')
+    element.addEventListener(
+      'comments--form:stash-draft',
+      controller.handleStashDraft.bind(controller),
+    )
+
+    textarea.dispatchEvent(
+      new CustomEvent('comments--form:stash-draft', {
+        bubbles: true,
+        detail: { draft: 'roadmap notes' },
+      }),
+    )
+
+    expect(controller._stashedDraft).toEqual({ draft: 'roadmap notes', creativeId: '7' })
+  })
+
+  test('restores the draft into the textarea the send cleared', () => {
+    const { controller, textarea } = buildController()
+    stash(controller, 'roadmap notes')
+
+    // The success path runs resetForm() before .finally(), so the box is empty.
+    textarea.value = ''
+    controller._restoreStashedDraft()
+
+    expect(textarea.value).toBe('roadmap notes')
+    expect(controller._autoResize).toHaveBeenCalledTimes(1)
+    expect(controller._updateSubmitButton).toHaveBeenCalledTimes(1)
+  })
+
+  test('does not clobber text the user typed while the command was in flight', () => {
+    const { controller, textarea } = buildController()
+    stash(controller, 'roadmap notes')
+
+    textarea.value = 'something else entirely'
+    controller._restoreStashedDraft('/calendar 2026-08-14')
+
+    expect(textarea.value).toBe('something else entirely')
+  })
+
+  test('restores over the command text a failed send left in the box', () => {
+    // The failure path never runs resetForm(), so the submitted command is
+    // still sitting there. Matching it proves the user has not typed since,
+    // which makes the box safe to hand the draft back into.
+    const { controller, textarea } = buildController()
+    stash(controller, 'roadmap notes')
+
+    textarea.value = '/calendar 2026-08-14'
+    controller._restoreStashedDraft('/calendar 2026-08-14')
+
+    expect(textarea.value).toBe('roadmap notes')
+    expect(controller._autoResize).toHaveBeenCalledTimes(1)
+    expect(controller._updateSubmitButton).toHaveBeenCalledTimes(1)
+  })
+
+  test('does not clobber a review quote the failure path restored', () => {
+    // handleSend's .catch reinstates the backed-up quote text before .finally,
+    // so the box holds something other than what was submitted.
+    const { controller, textarea } = buildController()
+    stash(controller, 'roadmap notes')
+
+    textarea.value = '> quoted review text\n\nmy reply'
+    controller._restoreStashedDraft('/calendar 2026-08-14')
+
+    expect(textarea.value).toBe('> quoted review text\n\nmy reply')
+  })
+
+  test('consumes the stash so a later send does not resurrect it', () => {
+    const { controller, textarea } = buildController()
+    stash(controller, 'roadmap notes')
+
+    controller._restoreStashedDraft()
+    expect(controller._stashedDraft).toBeNull()
+
+    textarea.value = ''
+    controller._restoreStashedDraft()
+    expect(textarea.value).toBe('')
+  })
+
+  test('is a no-op for an ordinary send with nothing stashed', () => {
+    const { controller, textarea } = buildController()
+
+    controller._restoreStashedDraft()
+
+    expect(textarea.value).toBe('')
+    expect(controller._autoResize).not.toHaveBeenCalled()
+  })
+})