dsh-code 1.0.2 → 1.0.3

package/src/render/markdown.ts

@@ -9,6 +9,8 @@
  * @module @deepseek-ai/dsh-code/render/markdown
  */
 
+import { stringWidth } from './width.ts'
+
 /** Style classes the renderer emits; the app maps them to colors/props. */
 export type MdStyle = 'plain' | 'bold' | 'italic' | 'boldItalic' | 'code' | 'accent' | 'accentBold' | 'dim' | 'strike'
 
@@ -30,14 +32,9 @@ function seg(text: string, style: MdStyle = 'plain'): MdSegment {
   return { text, style }
 }
 
-/** Visible width of a run in columns (CJK counts double). */
+/** Visible width of a run in columns (grapheme-cluster and emoji aware). */
 export function visibleColumns(text: string): number {
-  let columns = 0
-  for (const char of text) {
-    const code = char.codePointAt(0) ?? 0
-    columns += code > 0x2e7f ? 2 : 1
-  }
-  return columns
+  return stringWidth(text)
 }
 
 interface WrapUnit {

package/src/render/projection.ts

@@ -9,6 +9,7 @@
 
 import { boundContextSummary, type ContentBlock, type ImageBlock, type MessageId } from '@deepseek-ai/dsh-llm'
 import type { SessionEvent, TodoItem } from '@deepseek-ai/dsh-session'
+import { graphemeWidth, splitGraphemes } from './width.ts'
 // Type-only imports merge the plugin-owned SessionEventMap variants
 // (agent/inbox/spliced, command/*, compaction/*, goal/change, llm/retry*,
 // plan/mode, permission/preset, sandbox/mode, session/title) into the union
@@ -336,13 +337,13 @@ function imagesOf(content: readonly ContentBlock[]): readonly ImageBlock['attach
 export function imageLabels(images: readonly ImageBlock['attachment'][] | undefined): string {
   if (images === undefined || images.length === 0) return ''
   return images.map((image, index) => {
-    const rawName = image.name?.trim() || `image ${index + 1}`
-    const name = rawName.length <= 80 ? rawName : `${rawName.slice(0, 79)}…`
-    const original = image.originalDimensions
-    const dimensions = original === undefined
-      ? `${image.width}×${image.height}`
-      : `${image.width}×${image.height} · original ${original.width}×${original.height}`
-    return `[image: ${name} · ${dimensions} · ${image.bytes} B]`
+    const rawName = image.name?.trim() || `image ${index + 1}`
+    const name = rawName.length <= 80 ? rawName : `${rawName.slice(0, 79)}…`
+    const original = image.originalDimensions
+    const dimensions = original === undefined
+      ? `${image.width}×${image.height}`
+      : `${image.width}×${image.height} · original ${original.width}×${original.height}`
+    return `[image: ${name} · ${dimensions} · ${image.bytes} B]`
   }).join('\n')
 }
 
@@ -368,8 +369,8 @@ function reasoningOf(content: readonly ContentBlock[]): string {
 function estimateTokens(text: string): number {
   let wide = 0
   let narrow = 0
-  for (const char of text) {
-    if ((char.codePointAt(0) ?? 0) > 0x2e7f) wide += 1
+  for (const cluster of splitGraphemes(text)) {
+    if (graphemeWidth(cluster) > 1) wide += 1
     else narrow += 1
   }
   return wide + Math.ceil(narrow / 4)
@@ -1035,8 +1036,11 @@ function retireReplayEntry(acc: ReplayAccumulator, index: number): void {
  * to a sequential fold; only the `entries` container operations are mutable.
  *
  * @internal Test-instrumentation path; `projectEvents` is the public entry.
+ * @returns whether the event changed the accumulated state — the live store
+ * stays silent and keeps its snapshot identity for ignored events, exactly
+ * like the copy-on-write reducer returning its input view unchanged.
  */
-export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent): void {
+export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent): boolean {
   switch (event.type) {
     case 'user/message': {
       const message = event.data
@@ -1066,7 +1070,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
             prompt: acc.stats.contextSegments.prompt + estimateTokens(text),
           },
         }
-        return
+        return true
       }
       const notice = message.source.kind === 'plugin' && message.source.form === 'notice'
         ? message.source.summary
@@ -1080,7 +1084,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           system: acc.stats.contextSegments.system + estimateTokens(summary),
         },
       }
-      return
+      return true
     }
     case 'agent/inbox/spliced': {
       const { target, start, removedCount = 0, inserted } = event.data
@@ -1106,7 +1110,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         ids.push(message.id)
         acc.ops += 1
       }
-      return
+      return true
     }
     case 'assistant/chunk': {
       const chunk = event.data.chunk
@@ -1125,13 +1129,13 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       }
       if (chunk.type === 'text-delta') {
         acc.streaming = appendStreamingTail(acc.streaming, chunk.text)
-        return
+        return true
       }
       if (chunk.type === 'reasoning-delta') {
         acc.streamingReasoning = appendStreamingTail(acc.streamingReasoning, chunk.text)
-        return
+        return true
       }
-      return
+      return false
     }
     case 'assistant/message': {
       const key = `${event.data.turn}:${event.data.step}`
@@ -1165,7 +1169,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           assistant: acc.stats.contextSegments.assistant + estimateTokens(text),
         },
       }
-      return
+      return true
     }
     case 'tool/call': {
       const data = event.data
@@ -1195,7 +1199,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
             + (typeof data.arguments === 'string' ? estimateTokens(data.arguments) : 0),
         },
       }
-      return
+      return true
     }
     case 'tool/result': {
       const block = event.data.message.content[0]
@@ -1231,18 +1235,18 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           tools: acc.stats.contextSegments.tools + estimateTokens(rawText),
         },
       }
-      return
+      return true
     }
     case 'todo/write':
       acc.todos = event.data.todos
-      return
+      return true
     case 'turn/start': {
       const wasBusy = acc.busy
       acc.busy = true
       acc.busySince = wasBusy ? acc.busySince : event.time
       acc.todos = []
       acc.stats = { ...acc.stats, turns: acc.stats.turns + 1 }
-      return
+      return true
     }
     case 'step/start': {
       const key = `${event.data.turn}:${event.data.step}`
@@ -1256,7 +1260,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       acc.streaming = ''
       acc.streamingReasoning = ''
       acc.stats = { ...acc.stats, steps: acc.stats.steps + 1 }
-      return
+      return true
     }
     case 'turn/end': {
       const reason = event.data.reason
@@ -1297,7 +1301,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       acc.busy = false
       acc.busySince = 0
       for (const entry of appended) appendReplayEntry(acc, entry)
-      return
+      return true
     }
     case 'llm/retry': {
       const data = event.data
@@ -1313,23 +1317,23 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         state: 'running',
       })
       indexList(acc.retryIndex, data.retryId).push(acc.entries.length - 1)
-      return
+      return true
     }
     case 'llm/retry-started': {
       const data = event.data
       updateReplayById<RetryEntry>(acc, acc.retryIndex, data.retryId, entry => entry.retryId === data.retryId, entry => ({ ...entry, state: 'done' as const }))
-      return
+      return true
     }
     case 'sandbox/mode':
       acc.sandbox = event.data.mode
-      return
+      return true
     case 'goal/change': {
       const data = event.data
       const clip = (text: string): string => (text.length > 60 ? `${text.slice(0, 59)}…` : text)
       if (data.operation === 'clear') {
         acc.goal = undefined
         appendReplayEntry(acc, { kind: 'turn-marker', text: '◎ goal cleared' })
-        return
+        return true
       }
       const goal: GoalFold = {
         objective: data.goal.objective,
@@ -1351,31 +1355,31 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
                 : undefined
       acc.goal = goal
       if (line !== undefined) appendReplayEntry(acc, { kind: 'turn-marker', text: line })
-      return
+      return true
     }
     case 'session/title':
       acc.title = event.data.title
-      return
+      return true
     case 'compaction/summary':
       if (acc.compactionTokens.size >= MAX_COMPACTION_SUMMARY_RESIDUE) {
         const oldest = acc.compactionTokens.keys().next().value
         if (oldest !== undefined) acc.compactionTokens.delete(oldest)
       }
       acc.compactionTokens.set(event.data.compactionId, event.data.shadowedTokenCount)
-      return
+      return true
     case 'compaction/prune':
       acc.lastPruneTokens = event.data.shadowedTokenCount
-      return
+      return true
     case 'compaction/end': {
       const ok = event.data.error === undefined
       const tokens = acc.compactionTokens.get(event.data.compactionId) ?? acc.lastPruneTokens
       acc.compactionTokens.delete(event.data.compactionId)
       appendReplayEntry(acc, { kind: 'compaction', ok, tokens, error: event.data.error ?? '' })
-      return
+      return true
     }
     case 'request/context':
       acc.stats = { ...acc.stats, contextWindow: event.data.contextWindow ?? acc.stats.contextWindow }
-      return
+      return true
     case 'request/header': {
       const config = event.data.header.config
       acc.model = `${config.provider}/${config.model}`
@@ -1387,14 +1391,14 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           system: estimateTokens(event.data.header.system ?? ''),
         },
       }
-      return
+      return true
     }
     case 'plan/mode':
       acc.plan = event.data.active
-      return
+      return true
     case 'permission/preset':
       acc.permission = event.data.preset
-      return
+      return true
     case 'command/run': {
       const data = event.data
       appendReplayEntry(acc, {
@@ -1406,7 +1410,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         summary: '',
       })
       indexList(acc.commandIndex, data.commandId).push(acc.entries.length - 1)
-      return
+      return true
     }
     case 'command/done': {
       const data = event.data
@@ -1416,10 +1420,10 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         summary: boundContextSummary(data.text ?? ''),
       })
       updateReplayById<CommandEntry>(acc, acc.commandIndex, data.commandId, entry => entry.commandId === data.commandId, update)
-      return
+      return true
     }
     default:
-      return
+      return false
   }
 }
 
@@ -1431,8 +1435,27 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
  * @internal Test-instrumentation path; `projectEvents` is the public entry.
  */
 export function finishReplay(acc: ReplayAccumulator): TranscriptView {
+  return materializeReplayView(acc, false)
+}
+
+/**
+ * Materialize the accumulated fold as a fresh immutable snapshot for the
+ * live store. Unlike {@link finishReplay} — the one-shot replay entry, which
+ * hands the accumulator's own arrays through because the accumulator is
+ * discarded — every array a renderer can hold is copied here, so later
+ * folds never mutate a snapshot already handed out. Same fields, same
+ * tombstone compaction.
+ *
+ * @internal Live-store path; `projectEvents` is the public entry.
+ */
+export function snapshotReplayView(acc: ReplayAccumulator): TranscriptView {
+  return materializeReplayView(acc, true)
+}
+
+/** Field-for-field materialization; `copy` selects snapshot array isolation. */
+function materializeReplayView(acc: ReplayAccumulator, copy: boolean): TranscriptView {
   const entries: readonly TranscriptEntry[] = acc.removedCount === 0
-    ? acc.entries as TranscriptEntry[]
+    ? (copy ? [...acc.entries] : acc.entries) as TranscriptEntry[]
     : acc.entries.filter((entry): entry is TranscriptEntry => entry !== undefined)
   if (acc.removedCount > 0) acc.ops += acc.entries.length
   return {

package/src/render/text.ts

@@ -1,150 +1,152 @@
-/**
- * Display-boundary sanitization for externally sourced text (model output,
- * tool payloads, skill descriptions). Control characters — including ANSI
- * CSI/OSC escape sequences — would otherwise pass through Ink into the
- * terminal, letting output rewrite the screen or inject prompts. Newlines
- * survive; everything else in C0/C1 plus DEL becomes a visible `\xNN`
- * escape, and bidi overrides / invisible format controls / Unicode line and
- * paragraph separators become a visible `\uXXXX` escape (terminal emulators
- * that render bidirectional text would otherwise reorder the displayed
- * glyphs and let a command read as something it is not).
- *
- * @module @deepseek-ai/dsh-code/render/text
- */
-
-/** C0 controls except tab (0x09) and newline (0x0a), plus DEL and C1. */
-const CONTROL_ESCAPE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu
-
-/**
- * Bidi overrides and isolates (U+202A-202E, U+2066-2069), the Arabic Letter
- * Mark (U+061C), directional and zero-width format characters (U+200B,
- * U+200E/200F, U+2060-2064, U+FEFF), and Unicode line/paragraph separators
- * (U+2028/2029). Terminal emulators with bidi support (Windows Terminal,
- * iTerm2, kitty, WezTerm) reorder or hide these, so they must never reach
- * the terminal raw.
- */
-const INVISIBLE_ESCAPE = /[\u061c\u200b\u200e\u200f\u2028\u2029\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff]/gu
-
-/**
- * Escape control and deceptive characters so externally sourced text cannot
- * drive the terminal. C0/C1/DEL render as a literal `\xNN` escape; bidi,
- * invisible-format, and separator controls render as a literal `\uXXXX`
- * escape. Newlines and tabs survive (budgeted callers normalize tabs).
- * @param text - raw text from a session event, tool payload, or catalog.
- * @returns display-safe text with every injectable character made visible.
- */
-export function displayText(text: string): string {
-  return text
-    .replace(CONTROL_ESCAPE, char => `\\x${char.charCodeAt(0).toString(16).padStart(2, '0')}`)
-    .replace(INVISIBLE_ESCAPE, char => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`)
-}
-
-/** Collapse external text to one terminal-safe logical row. */
-export function singleLineText(text: string): string {
-  return displayText(text).replace(/\r?\n/gu, ' ↵ ').replace(/\t/gu, '  ')
-}
-
-/** Terminal-cell width matching the TUI's existing CJK-aware wrapping rule. */
-function cellWidth(text: string): number {
-  let columns = 0
-  for (const char of text) {
-    columns += (char.codePointAt(0) ?? 0) > 0x2e7f ? 2 : 1
-  }
-  return columns
-}
-
-/**
- * Truncate one display-safe row without ever exceeding its physical-column
- * budget. The ellipsis is included inside the budget, matching Codex's popup
- * truncation contract; the previous app-local helper appended it after the
- * row was already full and could force an extra terminal wrap.
- */
-export function truncateColumns(text: string, columns: number): string {
-  const limit = Math.max(0, Math.floor(columns))
-  if (limit === 0) return ''
-  if (cellWidth(text) <= limit) return text
-
-  const contentLimit = limit - 1
-  let used = 0
-  let result = ''
-  for (const char of text) {
-    const width = cellWidth(char)
-    if (used + width > contentLimit) break
-    result += char
-    used += width
-  }
-  return `${result}…`
-}
-
-/** A display-safe suffix bounded by terminal rows and columns. */
-export interface DisplayTail {
-  /** Sanitized suffix suitable for direct terminal rendering. */
-  text: string
-  /** Whether content before the returned suffix was omitted. */
-  truncated: boolean
-}
-
-/** Read one Unicode character immediately before `end`. */
-function previousCharacter(text: string, end: number): { char: string; start: number } {
-  const last = text.charCodeAt(end - 1)
-  if (last >= 0xdc00 && last <= 0xdfff && end >= 2) {
-    const first = text.charCodeAt(end - 2)
-    if (first >= 0xd800 && first <= 0xdbff) {
-      return { char: text.slice(end - 2, end), start: end - 2 }
-    }
-  }
-  return { char: text.slice(end - 1, end), start: end - 1 }
-}
-
-/**
- * Keep only the newest display-safe text that fits a terminal rectangle.
- * The scan walks backward and stops as soon as the suffix is full, so a long
- * reasoning stream does not rescan its entire accumulated prefix per chunk.
- * Explicit newlines and terminal wrapping both consume rows; tabs expand to
- * two spaces so terminal tab stops (which render at contextual column 8
- * boundaries, not at the budgeted cell count) cannot inflate the physical
- * row count of the live region.
- * @param text - raw externally sourced text.
- * @param columns - available terminal columns.
- * @param rows - available terminal rows.
- * @returns a sanitized bounded suffix and whether an earlier prefix was cut.
- */
-export function displayTail(text: string, columns: number, rows: number): DisplayTail {
-  const columnLimit = Math.max(1, Math.floor(columns))
-  const rowLimit = Math.max(1, Math.floor(rows))
-  const reversed: string[] = []
-  let row = 1
-  let used = 0
-  let end = text.length
-
-  while (end > 0) {
-    const previous = previousCharacter(text, end)
-    if (previous.char === '\n') {
-      if (row >= rowLimit) break
-      reversed.push('\n')
-      row += 1
-      used = 0
-      end = previous.start
-      continue
-    }
-
-    const safe = previous.char === '\t' ? '  ' : displayText(previous.char)
-    const width = cellWidth(safe)
-    if (used > 0 && used + width > columnLimit) {
-      if (row >= rowLimit) break
-      // Materialize the soft wrap. Ink otherwise reflows at word boundaries
-      // and can turn a cell-counted two-row suffix into three rendered rows.
-      reversed.push('\n')
-      row += 1
-      used = 0
-    }
-    const extraRows = Math.floor(Math.max(0, width - 1) / columnLimit)
-    if (row + extraRows > rowLimit) break
-    row += extraRows
-    reversed.push(safe)
-    used = extraRows === 0 ? used + width : width - extraRows * columnLimit
-    end = previous.start
-  }
-
-  return { text: reversed.reverse().join(''), truncated: end > 0 }
-}
+/**
+ * Display-boundary sanitization for externally sourced text (model output,
+ * tool payloads, skill descriptions). Control characters — including ANSI
+ * CSI/OSC escape sequences — would otherwise pass through Ink into the
+ * terminal, letting output rewrite the screen or inject prompts. Newlines
+ * survive; everything else in C0/C1 plus DEL becomes a visible `\xNN`
+ * escape, and bidi overrides / invisible format controls / Unicode line and
+ * paragraph separators become a visible `\uXXXX` escape (terminal emulators
+ * that render bidirectional text would otherwise reorder the displayed
+ * glyphs and let a command read as something it is not).
+ *
+ * @module @deepseek-ai/dsh-code/render/text
+ */
+
+import { graphemeWidth, splitGraphemes, stringWidth } from './width.ts'
+
+/** C0 controls except tab (0x09) and newline (0x0a), plus DEL and C1. */
+const CONTROL_ESCAPE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu
+
+/**
+ * Bidi overrides and isolates (U+202A-202E, U+2066-2069), the Arabic Letter
+ * Mark (U+061C), directional and zero-width format characters (U+200B,
+ * U+200E/200F, U+2060-2064, U+FEFF), and Unicode line/paragraph separators
+ * (U+2028/2029). Terminal emulators with bidi support (Windows Terminal,
+ * iTerm2, kitty, WezTerm) reorder or hide these, so they must never reach
+ * the terminal raw.
+ */
+const INVISIBLE_ESCAPE = /[\u061c\u200b\u200e\u200f\u2028\u2029\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff]/gu
+
+/**
+ * Escape control and deceptive characters so externally sourced text cannot
+ * drive the terminal. C0/C1/DEL render as a literal `\xNN` escape; bidi,
+ * invisible-format, and separator controls render as a literal `\uXXXX`
+ * escape. Newlines and tabs survive (budgeted callers normalize tabs).
+ * @param text - raw text from a session event, tool payload, or catalog.
+ * @returns display-safe text with every injectable character made visible.
+ */
+export function displayText(text: string): string {
+  return text
+    .replace(CONTROL_ESCAPE, char => `\\x${char.charCodeAt(0).toString(16).padStart(2, '0')}`)
+    .replace(INVISIBLE_ESCAPE, char => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`)
+}
+
+/** Collapse external text to one terminal-safe logical row. */
+export function singleLineText(text: string): string {
+  return displayText(text).replace(/\r?\n/gu, ' ↵ ').replace(/\t/gu, '  ')
+}
+
+/**
+ * Truncate one display-safe row without ever exceeding its physical-column
+ * budget. The ellipsis is included inside the budget, matching Codex's popup
+ * truncation contract; the cut walks grapheme clusters so emoji and
+ * combining sequences never split mid-cluster.
+ */
+export function truncateColumns(text: string, columns: number): string {
+  const limit = Math.max(0, Math.floor(columns))
+  if (limit === 0) return ''
+  if (stringWidth(text) <= limit) return text
+
+  const contentLimit = limit - 1
+  let used = 0
+  let result = ''
+  for (const cluster of splitGraphemes(text)) {
+    const width = graphemeWidth(cluster)
+    if (used + width > contentLimit) break
+    result += cluster
+    used += width
+  }
+  return `${result}…`
+}
+
+/** A display-safe suffix bounded by terminal rows and columns. */
+export interface DisplayTail {
+  /** Sanitized suffix suitable for direct terminal rendering. */
+  text: string
+  /** Whether content before the returned suffix was omitted. */
+  truncated: boolean
+}
+
+/** Punctuation that must never START a physical row (CJK kinsoku tail set). */
+const ROW_START_FORBIDDEN = '，。、；：！？）】」』〉》…‥'
+
+/** Punctuation that must never END a physical row (CJK kinsoku head set). */
+const ROW_END_FORBIDDEN = '（【「『〈《'
+
+/**
+ * Keep the newest display-safe text that fits a terminal rectangle, wrapping
+ * FORWARD from the start of the text and slicing the tail rows.
+ *
+ * Forward wrapping is what keeps a streaming tail calm: rows already produced
+ * never re-wrap as tokens append (a backward scan recomputes every wrap point
+ * per chunk and the whole visible block jumps), and the wrap rules match the
+ * settled text's renderer so the flush at turn end does not reflow the block
+ * a second time. CJK kinsoku applies at both edges: closing punctuation
+ * overhangs up to two cells onto the filled row instead of starting the next
+ * one (within the caret column the caller reserves), and opening punctuation
+ * moves down instead of dangling at a row end. Tabs expand to two spaces so
+ * terminal tab stops cannot inflate the physical row count; clusters carry
+ * emoji presentation and combining marks whole.
+ * @param text - raw externally sourced text.
+ * @param columns - available terminal columns.
+ * @param rows - available terminal rows.
+ * @returns a sanitized bounded suffix and whether an earlier prefix was cut.
+ */
+export function displayTail(text: string, columns: number, rows: number): DisplayTail {
+  const columnLimit = Math.max(1, Math.floor(columns))
+  const rowLimit = Math.max(1, Math.floor(rows))
+  const wrapped: string[] = []
+  let current = ''
+  let used = 0
+  let lastCluster = ''
+  const flush = (): void => {
+    wrapped.push(current)
+    current = ''
+    used = 0
+    lastCluster = ''
+  }
+
+  for (const cluster of splitGraphemes(text)) {
+    if (cluster === '\n') {
+      flush()
+      continue
+    }
+    const safe = cluster === '\t' ? '  ' : displayText(cluster)
+    // safe can be a multi-character escape literal (\xNN / \uXXXX); only
+    // stringWidth budgets the whole visible escape, never its first byte.
+    const width = stringWidth(safe)
+    if (used > 0 && used + width > columnLimit) {
+      const overhang = width <= 2 && ROW_START_FORBIDDEN.includes(cluster)
+      if (!overhang) {
+        // Kinsoku head: an opening mark at the row edge moves down with the
+        // incoming cluster instead of dangling at the end of the filled row.
+        if (lastCluster !== '' && ROW_END_FORBIDDEN.includes(lastCluster)) {
+          const carried = lastCluster
+          current = current.slice(0, current.length - carried.length)
+          flush()
+          current = carried
+          used = stringWidth(carried)
+        } else {
+          flush()
+        }
+      }
+    }
+    current += safe
+    used += width
+    lastCluster = cluster
+  }
+  if (current !== '' || (wrapped.length > 0 && text.endsWith('\n'))) flush()
+
+  const truncated = wrapped.length > rowLimit
+  return { text: (truncated ? wrapped.slice(-rowLimit) : wrapped).join('\n'), truncated }
+}