collavre 0.22.0 → 0.24.0

data/app/javascript/lib/lexical/table_transformer.js

@@ -0,0 +1,182 @@
+import {
+  $createTableCellNode,
+  $createTableNode,
+  $createTableRowNode,
+  $isTableCellNode,
+  $isTableNode,
+  $isTableRowNode,
+  TableCellHeaderStates
+} from "@lexical/table"
+import { $convertFromMarkdownString, $convertToMarkdownString } from "@lexical/markdown"
+import { $isParagraphNode, $isTextNode } from "lexical"
+
+// GFM pipe-table support for the markdown-canonical editor. Ported from the
+// Lexical playground's MarkdownTransformers TABLE ElementTransformer, adapted to
+// .js and to a lazily-injected cell transformer list. Unlike the color/decorator
+// transformers (export-only), this one is bidirectional: it exports Lexical
+// tables to GFM and reconstructs them when markdown is parsed back.
+
+const TABLE_ROW_REG_EXP = /^(?:\|)(.+)(?:\|)\s?$/
+// -+ (not -*) is required per cell: a GFM divider must have at least one dash,
+// and the mandatory dash run anchors the surrounding :? colons so they can't both
+// compete for the same character — which would cause exponential backtracking.
+const TABLE_ROW_DIVIDER_REG_EXP = /^(\| ?:?-+:? ?)+\|\s?$/
+
+// Each table cell is (de)serialized with the full transformer list (which
+// includes this TABLE transformer). markdown_serialize.js injects the list once
+// at load via setCellTransformers to avoid a circular import. Cells never nest
+// tables, so the self-reference stays bounded.
+let cellTransformers = []
+export function setCellTransformers(list) {
+  cellTransformers = list
+}
+
+function getTableColumnsSize(table) {
+  const row = table.getFirstChild()
+  return $isTableRowNode(row) ? row.getChildrenSize() : 0
+}
+
+function $createTableCell(textContent) {
+  // Backslashes are governed by CommonMark and round-trip through the per-cell
+  // $convertFromMarkdownString below; we must NOT pre-decode them here. An earlier
+  // ".replace(/\\n/g, \"\\n\")" mis-fired on literal "a\nb" (backslash + n typed by
+  // the user, e.g. a regex or Windows path), corrupting it into a real newline
+  // that breaks the single-line row (CodeQL alert #42). Cells are single-line, so
+  // no newline decoding is needed at all.
+  const cell = $createTableCellNode(TableCellHeaderStates.NO_STATUS)
+  $convertFromMarkdownString(textContent, cellTransformers, cell)
+  return cell
+}
+
+// Split a row's inner text on cell boundaries and reverse the export escaping in
+// one left-to-right pass. Export escapes (in order) backslash -> "\\" then pipe
+// -> "\|", so here every backslash starts a 2-char escape: it consumes the next
+// char ("\\" -> "\", "\|" -> a literal in-cell pipe). Only a *bare* pipe is a
+// column boundary. The result still carries CommonMark's own backslash escapes,
+// which $convertFromMarkdownString decodes per cell. Undoing the backslash escape
+// here (not just "\|") is what keeps the escaping complete and unambiguous
+// (CodeQL js/incomplete-sanitization #43). Each cell is trimmed because GFM treats
+// the spaces around "| cell |" as insignificant padding (export re-adds them).
+function splitRowCells(inner) {
+  const cells = []
+  let current = ""
+  for (let i = 0; i < inner.length; i++) {
+    if (inner[i] === "\\" && i + 1 < inner.length) {
+      current += inner[i + 1] // "\\" -> "\", "\|" -> "|" (any other "\x" -> "x")
+      i++
+    } else if (inner[i] === "|") {
+      cells.push(current.trim())
+      current = ""
+    } else {
+      current += inner[i]
+    }
+  }
+  cells.push(current.trim())
+  return cells
+}
+
+function mapToTableCells(textContent) {
+  const match = textContent.match(TABLE_ROW_REG_EXP)
+  if (!match || !match[1]) return null
+  return splitRowCells(match[1]).map((text) => $createTableCell(text))
+}
+
+export const TABLE = {
+  dependencies: [],
+  export: (node) => {
+    if (!$isTableNode(node)) return null
+    const output = []
+    for (const row of node.getChildren()) {
+      if (!$isTableRowNode(row)) continue
+      const rowOutput = []
+      let isHeaderRow = false
+      for (const cell of row.getChildren()) {
+        if ($isTableCellNode(cell)) {
+          rowOutput.push(
+            $convertToMarkdownString(cellTransformers, cell)
+              // A GFM row is one line, so collapse any real newline to a space
+              // (multi-line cells aren't representable in GFM anyway). NOT "\\n":
+              // that re-imported as a literal backslash-n and then mis-decoded
+              // back to a newline, corrupting genuine "a\nb" text (CodeQL #42).
+              .replace(/\n+/g, " ")
+              // Escape the escape char FIRST, then pipes, so the escaping is
+              // complete and unambiguous (CodeQL js/incomplete-sanitization #43).
+              // splitRowCells reverses both ("\\"->"\", "\|"->"|") on import,
+              // restoring exactly what CommonMark emitted before re-decoding it.
+              .replace(/\\/g, "\\\\")
+              .replace(/\|/g, "\\|")
+              .trim()
+          )
+          if (cell.__headerState === TableCellHeaderStates.ROW) {
+            isHeaderRow = true
+          }
+        }
+      }
+      output.push(`| ${rowOutput.join(" | ")} |`)
+      if (isHeaderRow) {
+        output.push(`| ${rowOutput.map(() => "---").join(" | ")} |`)
+      }
+    }
+    return output.join("\n")
+  },
+  regExp: TABLE_ROW_REG_EXP,
+  replace: (parentNode, _children, match) => {
+    // A divider row ("| --- | --- |") promotes the previous table's last row to
+    // a header row, then removes itself.
+    if (TABLE_ROW_DIVIDER_REG_EXP.test(match[0])) {
+      const table = parentNode.getPreviousSibling()
+      if (!table || !$isTableNode(table)) return
+      const rows = table.getChildren()
+      const lastRow = rows[rows.length - 1]
+      if (!lastRow || !$isTableRowNode(lastRow)) return
+      lastRow.getChildren().forEach((cell) => {
+        if (!$isTableCellNode(cell)) return
+        cell.setHeaderStyles(TableCellHeaderStates.ROW, TableCellHeaderStates.ROW)
+      })
+      parentNode.remove()
+      return
+    }
+
+    const matchCells = mapToTableCells(match[0])
+    if (matchCells == null) return
+
+    // Walk backwards over preceding single-text paragraphs that are also table
+    // rows, accumulating them so a multi-line table is parsed as one node.
+    const rows = [matchCells]
+    let sibling = parentNode.getPreviousSibling()
+    let maxCells = matchCells.length
+    while (sibling) {
+      if (!$isParagraphNode(sibling) || sibling.getChildrenSize() !== 1) break
+      const firstChild = sibling.getFirstChild()
+      if (!$isTextNode(firstChild)) break
+      const cells = mapToTableCells(firstChild.getTextContent())
+      if (cells == null) break
+      maxCells = Math.max(maxCells, cells.length)
+      rows.unshift(cells)
+      const previousSibling = sibling.getPreviousSibling()
+      sibling.remove()
+      sibling = previousSibling
+    }
+
+    const table = $createTableNode()
+    for (const cells of rows) {
+      const tableRow = $createTableRowNode()
+      table.append(tableRow)
+      for (let i = 0; i < maxCells; i++) {
+        tableRow.append(i < cells.length ? cells[i] : $createTableCell(""))
+      }
+    }
+
+    // Merge with an adjacent table of the same width (the divider row already
+    // removed itself, leaving the header table directly before this body row).
+    const previousSibling = parentNode.getPreviousSibling()
+    if ($isTableNode(previousSibling) && getTableColumnsSize(previousSibling) === maxCells) {
+      previousSibling.append(...table.getChildren())
+      parentNode.remove()
+    } else {
+      parentNode.replace(table)
+    }
+    table.selectEnd()
+  },
+  type: "element"
+}

data/app/javascript/lib/lexical/trailing_paragraph.js

@@ -0,0 +1,29 @@
+import { $createParagraphNode, $isDecoratorNode, RootNode } from "lexical"
+
+// A top-level DecoratorNode (image / video / attachment) renders as
+// non-editable content. When one is the last child of the root there is no
+// text position after it, so the caret can't land below it and the whole
+// document becomes uneditable — the reported "an image steals focus / can't
+// edit" bug, worst when the image is the only block. Guarantee the root always
+// ends in a paragraph so there is always an editable landing spot after a
+// trailing decorator.
+//
+// Must run inside an editor.update()/transform.
+export function ensureTrailingParagraph(root) {
+  const last = root.getLastChild()
+  if (last !== null && $isDecoratorNode(last)) {
+    last.insertAfter($createParagraphNode())
+    return true
+  }
+  return false
+}
+
+// Keep the guarantee while editing too: deleting the text below an image, or
+// pasting an image as the last block, would otherwise re-trap the caret.
+// Appending leaves the root dirty, so the transform re-runs once more and then
+// no-ops (last child is now the paragraph) — it terminates.
+export function registerTrailingParagraph(editor) {
+  return editor.registerNodeTransform(RootNode, (root) => {
+    ensureTrailingParagraph(root)
+  })
+}

data/app/javascript/lib/turbo_confirm.js

@@ -0,0 +1,46 @@
+// turbo_confirm — route Turbo's declarative `data-turbo-confirm` prompts through
+// the in-app confirm dialog instead of the native window.confirm().
+//
+// Why: Rails/Turbo forms gate destructive submits with `data-turbo-confirm`.
+// Turbo's default confirm method calls window.confirm(), which in the packaged
+// desktop app (Tauri WKWebView) returns false with no UI — so the submit
+// silently no-ops (e.g. token revoke, user delete, share removal) and looks
+// like the button is broken. Converting hand-written confirm() calls does not
+// cover these, because Turbo intercepts them before any of our code runs. The
+// fix is a single global override of Turbo's confirm method.
+//
+// Returns a Promise<boolean>; Turbo awaits it before submitting (Turbo 8
+// `config.forms.confirm`, with a fallback to the deprecated setConfirmMethod).
+
+import { Turbo } from "@hotwired/turbo-rails"
+import { confirmDialog } from "./utils/dialog"
+
+// Turbo invokes this with (message, formElement, submitter). Style the confirm
+// button as destructive when the submit deletes (the common case for
+// data-turbo-confirm), so it matches the danger styling used elsewhere.
+function turboConfirm(message, formElement, submitter) {
+    const method = (
+        submitter?.getAttribute?.("data-turbo-method") ||
+        formElement?.getAttribute?.("data-turbo-method") ||
+        formElement?.querySelector?.("input[name='_method']")?.value ||
+        formElement?.getAttribute?.("method") ||
+        ""
+    ).toLowerCase()
+    const danger = method === "delete" || method === "destroy"
+    return confirmDialog(message, { danger })
+}
+
+// Install on both the bundled Turbo and any pre-existing global window.Turbo,
+// mirroring turbo_stream_actions.js — the two can be distinct instances.
+function installTurboConfirm(turbo) {
+    if (!turbo) return
+    if (turbo.config && turbo.config.forms) {
+        turbo.config.forms.confirm = turboConfirm
+    } else if (typeof turbo.setConfirmMethod === "function") {
+        // Turbo < 8 fallback.
+        turbo.setConfirmMethod(turboConfirm)
+    }
+}
+
+installTurboConfirm(Turbo)
+if (window.Turbo && window.Turbo !== Turbo) installTurboConfirm(window.Turbo)

data/app/javascript/lib/typo_correction.js

@@ -0,0 +1,146 @@
+// Pure logic for client-side typo correction (Phase 1: chat input).
+//
+// This module holds the framework-free core so it can be unit-tested without a
+// DOM: device classification, the 2D gating decision (mirrors the server's
+// `Collavre::User#typo_correction_active_for?`), candidate-list construction for
+// the selection popup, and edit anchoring/application with re-anchoring of the
+// remaining edits after one is applied.
+//
+// The overlay highlight is a *volatile* presentation layer — the textarea value
+// is the only canonical text. Nothing here ever serializes a highlight.
+
+export const DEVICE_VOICE = 'voice'
+export const DEVICE_SOFT_KEYBOARD = 'soft_keyboard'
+export const DEVICE_PHYSICAL_KEYBOARD = 'physical_keyboard'
+
+// Classify the active typing device from the signals we can observe.
+//
+// - Voice dictation is explicit (the composer exposes its recognition state).
+// - A physical keyboard fires a `keydown` for a printable key immediately
+//   before the resulting `input` event. Soft keyboards and IME composition
+//   insert text without that printable keydown (key is 'Unidentified'/'Process'
+//   or no keydown at all), which is the standard heuristic we rely on.
+export function detectDevice({ voiceActive = false, lastPrintableKeydownAt = null, inputAt = null } = {}) {
+  if (voiceActive) return DEVICE_VOICE
+  if (lastPrintableKeydownAt == null || inputAt == null) return DEVICE_SOFT_KEYBOARD
+  // A printable keydown that landed within the same input tick means a physical
+  // key produced this character.
+  const delta = inputAt - lastPrintableKeydownAt
+  if (delta >= 0 && delta <= 50) return DEVICE_PHYSICAL_KEYBOARD
+  return DEVICE_SOFT_KEYBOARD
+}
+
+// Mirror of the server-side 2D gate so the client avoids a pointless round-trip
+// when the feature is off for this device/location. The server re-checks; this
+// is an optimization, not the source of truth.
+export function shouldRun(settings, { device, location }) {
+  if (!settings || settings.enabled !== true) return false
+
+  const deviceOn =
+    device === DEVICE_VOICE ? settings.onVoice
+      : device === DEVICE_SOFT_KEYBOARD ? settings.onSoftKeyboard
+        : device === DEVICE_PHYSICAL_KEYBOARD ? settings.onPhysicalKeyboard
+          : false
+  if (deviceOn !== true) return false
+
+  const locationOn =
+    location === 'chat' ? settings.inChat
+      : location === 'editor' ? settings.inEditor
+        : false
+  return locationOn === true
+}
+
+// Build the popup's option list for one edit: the word currently sitting in the
+// document first (so Enter = keep), then the suggestions in confidence order,
+// de-duplicated. `currentValue` is whatever text is actually in the textarea at
+// the edit's span right now (original word, or the corrected word if it was
+// auto-applied). `originalWord` is the pre-correction text, surfaced as the undo
+// option when the current value is already the suggestion.
+export function buildCandidateList({ currentValue, originalWord, suggestions = [] }) {
+  const seen = new Set()
+  const list = []
+  const push = (value, role) => {
+    if (value == null || value === '') return
+    if (seen.has(value)) return
+    seen.add(value)
+    list.push({ value, label: value, isCurrent: value === currentValue, role })
+  }
+
+  // Current document value is always the pre-selected, pre-filled option.
+  push(currentValue, currentValue === originalWord ? 'original' : 'applied')
+  // If we're showing a corrected word, the original is the undo option.
+  push(originalWord, 'original')
+  // Suggestions, highest confidence first (assumed already sorted; sort defensively).
+  ;[...suggestions]
+    .sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0))
+    .forEach((s) => push(s.suggestion, 'suggestion'))
+
+  return list
+}
+
+// Attach character offsets to each edit. Prefer the server-supplied `offset`
+// (the first occurrence the server verified is *outside* a protected span) so a
+// duplicate word sitting inside code/URL/markup is never anchored — anchoring by
+// our own search would bind the first textual occurrence, which can be the
+// protected one the server already excluded. We only trust `offset` if the
+// substring still matches there (text is identical to what the server saw).
+// Without an offset we fall back to a left-to-right search, advancing the cursor
+// so repeated words bind to distinct occurrences. Edits whose original can no
+// longer be found are dropped — the caller re-runs the detector.
+export function anchorEdits(text, edits = []) {
+  const anchored = []
+  let cursor = 0
+  for (const edit of edits) {
+    if (!edit || !edit.original) continue
+    let idx
+    if (
+      Number.isInteger(edit.offset)
+      && text.slice(edit.offset, edit.offset + edit.original.length) === edit.original
+    ) {
+      idx = edit.offset
+    } else {
+      idx = text.indexOf(edit.original, cursor)
+    }
+    if (idx === -1) continue
+    anchored.push({ ...edit, start: idx, end: idx + edit.original.length })
+    cursor = Math.max(cursor, idx + edit.original.length)
+  }
+  return anchored
+}
+
+// Replace the span [start, end) of `text` with `replacement` and return the new
+// text plus the delta, so remaining edits can be shifted. We re-anchor by delta
+// rather than re-searching to avoid mis-binding when the same word repeats.
+export function applyEditAt(text, { start, end, replacement }) {
+  const before = text.slice(0, start)
+  const after = text.slice(end)
+  const newText = before + replacement + after
+  const delta = replacement.length - (end - start)
+  return { text: newText, delta }
+}
+
+// Shift every edit positioned at/after `fromOffset` by `delta`. Edits before the
+// applied span are untouched; the applied edit itself should be removed by the
+// caller before calling this.
+export function shiftEditsAfter(edits, fromOffset, delta) {
+  return edits.map((edit) => {
+    if (edit.start >= fromOffset) {
+      return { ...edit, start: edit.start + delta, end: edit.end + delta }
+    }
+    return edit
+  })
+}
+
+// Partition edits the server returned into auto-applied (confidence at/above the
+// user's threshold) and candidates (below it). Threshold is 0–100 to match the
+// profile setting; confidence is 0–1 from the model.
+export function partitionByThreshold(edits = [], threshold = 80) {
+  const cut = threshold / 100
+  const autoApplied = []
+  const candidates = []
+  for (const edit of edits) {
+    if ((edit.confidence ?? 0) >= cut) autoApplied.push(edit)
+    else candidates.push(edit)
+  }
+  return { autoApplied, candidates }
+}

data/app/javascript/lib/utils/__tests__/confirm_dialog.test.js

@@ -0,0 +1,88 @@
+/**
+ * @jest-environment jsdom
+ */
+import { confirmDialog } from '../confirm_dialog'
+
+const modal = () => document.querySelector('.modal-dialog')
+const overlay = () => document.querySelector('.modal-dialog-overlay')
+const message = () => document.querySelector('.confirm-dialog-message')
+
+describe('confirmDialog', () => {
+  afterEach(() => {
+    document.body.innerHTML = ''
+    document.documentElement.lang = ''
+  })
+
+  test('renders a modal with the message and OK/Cancel buttons', () => {
+    confirmDialog('Delete this?')
+    expect(modal()).not.toBeNull()
+    expect(overlay()).not.toBeNull()
+    expect(message().textContent).toBe('Delete this?')
+    expect(document.querySelector('.modal-dialog-btn-secondary')).not.toBeNull()
+    expect(document.querySelector('.modal-dialog-btn-primary')).not.toBeNull()
+  })
+
+  test('resolves true when confirm is clicked, then removes the modal', async () => {
+    const p = confirmDialog('ok?')
+    document.querySelector('.modal-dialog-btn-primary').click()
+    await expect(p).resolves.toBe(true)
+    expect(modal()).toBeNull()
+    expect(overlay()).toBeNull()
+  })
+
+  test('resolves false when cancel is clicked', async () => {
+    const p = confirmDialog('x')
+    document.querySelector('.modal-dialog-btn-secondary').click()
+    await expect(p).resolves.toBe(false)
+  })
+
+  test('resolves false when the backdrop is clicked', async () => {
+    const p = confirmDialog('x')
+    overlay().click()
+    await expect(p).resolves.toBe(false)
+  })
+
+  test('Enter resolves true, Escape resolves false', async () => {
+    const p1 = confirmDialog('x')
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter' }))
+    await expect(p1).resolves.toBe(true)
+
+    const p2 = confirmDialog('x')
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' }))
+    await expect(p2).resolves.toBe(false)
+  })
+
+  test('danger option styles the confirm button as destructive', () => {
+    confirmDialog('Delete?', { danger: true })
+    expect(document.querySelector('.modal-dialog-btn-danger')).not.toBeNull()
+    expect(document.querySelector('.modal-dialog-btn-primary')).toBeNull()
+  })
+
+  test('renders the message as text, never HTML (no injection)', () => {
+    confirmDialog('<img src=x onerror=alert(1)>')
+    expect(message().textContent).toBe('<img src=x onerror=alert(1)>')
+    expect(message().querySelector('img')).toBeNull()
+  })
+
+  test('localizes the buttons from <html lang>', () => {
+    document.documentElement.lang = 'ko'
+    confirmDialog('삭제?')
+    expect(document.querySelector('.modal-dialog-btn-primary').textContent).toBe('확인')
+    expect(document.querySelector('.modal-dialog-btn-secondary').textContent).toBe('취소')
+  })
+
+  test('only the topmost stacked dialog reacts to keys', async () => {
+    const p1 = confirmDialog('first')
+    const p2 = confirmDialog('second')
+    expect(document.querySelectorAll('.modal-dialog').length).toBe(2)
+
+    // Enter resolves only the topmost (second) dialog.
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter' }))
+    await expect(p2).resolves.toBe(true)
+    expect(document.querySelectorAll('.modal-dialog').length).toBe(1)
+
+    // The first dialog is now topmost and reacts.
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' }))
+    await expect(p1).resolves.toBe(false)
+  })
+})

data/app/javascript/lib/utils/__tests__/dialog.test.js

@@ -0,0 +1,92 @@
+/**
+ * @jest-environment jsdom
+ */
+import { alertDialog, confirmDialog, promptDialog } from '../dialog'
+
+const modal = () => document.querySelector('.modal-dialog')
+const overlay = () => document.querySelector('.modal-dialog-overlay')
+const message = () => document.querySelector('.confirm-dialog-message')
+const input = () => document.querySelector('.modal-dialog-input')
+
+afterEach(() => {
+  document.body.innerHTML = ''
+  document.documentElement.lang = ''
+})
+
+describe('alertDialog', () => {
+  test('renders a single OK button (no Cancel) with the message', () => {
+    alertDialog('Failed to save')
+    expect(modal()).not.toBeNull()
+    expect(message().textContent).toBe('Failed to save')
+    expect(document.querySelector('.modal-dialog-btn-primary')).not.toBeNull()
+    expect(document.querySelector('.modal-dialog-btn-secondary')).toBeNull()
+  })
+
+  test('resolves (undefined) and removes the modal when OK is clicked', async () => {
+    const p = alertDialog('done')
+    document.querySelector('.modal-dialog-btn-primary').click()
+    await expect(p).resolves.toBeUndefined()
+    expect(modal()).toBeNull()
+    expect(overlay()).toBeNull()
+  })
+
+  test('Enter and Escape both dismiss', async () => {
+    const p1 = alertDialog('x')
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter' }))
+    await expect(p1).resolves.toBeUndefined()
+
+    const p2 = alertDialog('x')
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' }))
+    await expect(p2).resolves.toBeUndefined()
+  })
+
+  test('renders the message as text, never HTML (no injection)', () => {
+    alertDialog('<img src=x onerror=alert(1)>')
+    expect(message().textContent).toBe('<img src=x onerror=alert(1)>')
+    expect(message().querySelector('img')).toBeNull()
+  })
+})
+
+describe('promptDialog', () => {
+  test('renders a text input seeded with defaultValue plus OK/Cancel', () => {
+    promptDialog('New name?', { defaultValue: 'old' })
+    expect(message().textContent).toBe('New name?')
+    expect(input()).not.toBeNull()
+    expect(input().value).toBe('old')
+    expect(document.querySelector('.modal-dialog-btn-secondary')).not.toBeNull()
+  })
+
+  test('resolves the entered value when confirmed', async () => {
+    const p = promptDialog('Name?')
+    input().value = 'typed'
+    document.querySelector('.modal-dialog-btn-primary').click()
+    await expect(p).resolves.toBe('typed')
+  })
+
+  test('resolves null when cancelled (parity with native prompt)', async () => {
+    const p = promptDialog('Name?', { defaultValue: 'x' })
+    document.querySelector('.modal-dialog-btn-secondary').click()
+    await expect(p).resolves.toBeNull()
+  })
+
+  test('resolves null when dismissed via Escape', async () => {
+    const p = promptDialog('Name?', { defaultValue: 'x' })
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' }))
+    await expect(p).resolves.toBeNull()
+  })
+
+  test('Enter submits the current input value', async () => {
+    const p = promptDialog('Name?')
+    input().value = 'viaEnter'
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter' }))
+    await expect(p).resolves.toBe('viaEnter')
+  })
+})
+
+describe('confirmDialog (re-exported from dialog)', () => {
+  test('still resolves true/false', async () => {
+    const p = confirmDialog('ok?')
+    document.querySelector('.modal-dialog-btn-primary').click()
+    await expect(p).resolves.toBe(true)
+  })
+})