dsh-code 1.0.2 → 1.0.3

package/src/render/width.ts

@@ -0,0 +1,189 @@
+/**
+ * Precise terminal-cell width measurement — the single authority every
+ * budget, wrap, and truncation path shares. The previous heuristic
+ * (`codePoint > 0x2e7f ? 2 : 1)) mis-sized Hangul Jamo (narrow), high
+ * non-CJK code points (wide), and emoji: text-default glyphs like ✳ ⚠ ❤
+ * counted 2 while terminals draw 1, and VS16 sequences counted 1 while
+ * terminals draw 2 — the exact drift class the community dsh-TUI string
+ * engine documents (a spinner glyph drifting one column per frame). This
+ * module adapts that engine's rules without its Ink-fork renderer: an ASCII
+ * fast path, grapheme-cluster iteration via Intl.Segmenter (code-point
+ * fallback), a merged East-Asian-Wide/Fullwidth + Emoji_Presentation range
+ * table, text-default emoji = 1, VS16 = 2, marks/selectors/ZWJ = 0.
+ * @module @deepseek-ai/dsh-code/render/width
+ */
+
+/**
+ * Code-point ranges rendered two cells wide: East Asian Wide/Fullwidth
+ * blocks merged with the Emoji_Presentation set (default-wide emoji) and
+ * regional indicators (flags). Sorted, inclusive, binary-searched.
+ */
+const WIDE_RANGES: readonly (readonly [number, number])[] = [
+  [0x1100, 0x115f],
+  [0x231a, 0x231b],
+  [0x2329, 0x232a],
+  [0x23e9, 0x23ec],
+  [0x23f0, 0x23f0],
+  [0x23f3, 0x23f3],
+  [0x23f8, 0x23fa],
+  [0x25fd, 0x25fe],
+  [0x2614, 0x2615],
+  [0x2648, 0x2653],
+  [0x267f, 0x267f],
+  [0x2693, 0x2693],
+  [0x26a1, 0x26a1],
+  [0x26aa, 0x26ab],
+  [0x26bd, 0x26be],
+  [0x26c4, 0x26c5],
+  [0x26ce, 0x26ce],
+  [0x26d4, 0x26d4],
+  [0x26ea, 0x26ea],
+  [0x26f2, 0x26f3],
+  [0x26f5, 0x26f5],
+  [0x26fa, 0x26fa],
+  [0x26fd, 0x26fd],
+  [0x2705, 0x2705],
+  [0x270a, 0x270b],
+  [0x2728, 0x2728],
+  [0x274c, 0x274c],
+  [0x274e, 0x274e],
+  [0x2753, 0x2755],
+  [0x2757, 0x2757],
+  [0x2795, 0x2797],
+  [0x27b0, 0x27b0],
+  [0x27bf, 0x27bf],
+  [0x2b1b, 0x2b1c],
+  [0x2b50, 0x2b50],
+  [0x2b55, 0x2b55],
+  [0x2e80, 0x303e],
+  [0x3041, 0x33ff],
+  [0x3400, 0x4dbf],
+  [0x4e00, 0xa4cf],
+  [0xa960, 0xa97f],
+  [0xac00, 0xd7a3],
+  [0xf900, 0xfaff],
+  [0xfe10, 0xfe19],
+  [0xfe30, 0xfe4f],
+  [0xff00, 0xff60],
+  [0xffe0, 0xffe6],
+  [0x16fe0, 0x16fe4],
+  [0x17000, 0x18aff],
+  [0x1b000, 0x1b2ff],
+  [0x1f004, 0x1f004],
+  [0x1f0cf, 0x1f0cf],
+  [0x1f18e, 0x1f18e],
+  [0x1f191, 0x1f19a],
+  [0x1f1e6, 0x1f1ff],
+  [0x1f200, 0x1f320],
+  [0x1f32d, 0x1f335],
+  [0x1f337, 0x1f37c],
+  [0x1f37e, 0x1f393],
+  [0x1f3a0, 0x1f3ca],
+  [0x1f3cf, 0x1f3d3],
+  [0x1f3e0, 0x1f3f0],
+  [0x1f3f4, 0x1f3f4],
+  [0x1f3f8, 0x1f43e],
+  [0x1f440, 0x1f440],
+  [0x1f442, 0x1f4fc],
+  [0x1f4ff, 0x1f53d],
+  [0x1f54b, 0x1f54e],
+  [0x1f550, 0x1f567],
+  [0x1f57a, 0x1f57a],
+  [0x1f595, 0x1f596],
+  [0x1f5a4, 0x1f5a4],
+  [0x1f5fb, 0x1f64f],
+  [0x1f680, 0x1f6c5],
+  [0x1f6cc, 0x1f6cc],
+  [0x1f6d0, 0x1f6d2],
+  [0x1f6d5, 0x1f6d7],
+  [0x1f6eb, 0x1f6ec],
+  [0x1f6f4, 0x1f6fc],
+  [0x1f7e0, 0x1f7eb],
+  [0x1f90c, 0x1f93a],
+  [0x1f93c, 0x1f945],
+  [0x1f947, 0x1f9ff],
+  [0x1fa70, 0x1fa7c],
+  [0x1fa80, 0x1fa89],
+  [0x1fa8f, 0x1fac6],
+  [0x1face, 0x1fadc],
+  [0x1fadf, 0x1fae9],
+  [0x1faf0, 0x1faf8],
+  [0x20000, 0x2fffd],
+  [0x30000, 0x3fffd],
+]
+
+/** Whether one code point falls inside a wide range (binary search). */
+function isWideCodePoint(code: number): boolean {
+  let low = 0
+  let high = WIDE_RANGES.length - 1
+  while (low <= high) {
+    const mid = (low + high) >> 1
+    const [start, end] = WIDE_RANGES[mid]!
+    if (code < start) high = mid - 1
+    else if (code > end) low = mid + 1
+    else return true
+  }
+  return false
+}
+
+/** Zero-width code points: combining marks, enclosing marks, format controls. */
+const ZERO_WIDTH = /^[\p{Mn}\p{Me}\p{Cf}]$/u
+
+/** Module-cached grapheme segmenter; undefined when the runtime lacks it. */
+let segmenter: Intl.Segmenter | undefined
+try {
+  segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' })
+} catch {
+  segmenter = undefined
+}
+
+/** Split text into grapheme clusters (code points when Segmenter is absent). */
+export function splitGraphemes(text: string): string[] {
+  if (segmenter === undefined) return Array.from(text)
+  return Array.from(segmenter.segment(text), part => part.segment)
+}
+
+/** Terminal-cell width of one grapheme cluster. */
+export function graphemeWidth(cluster: string): number {
+  // VS16 requests emoji presentation: ❤️ / ✳️ render two cells even when the
+  // base glyph is text-default (width 1 without the selector).
+  if (cluster.includes('\u{fe0f}', 0) as boolean) return 2
+  const first = cluster.codePointAt(0) ?? 0
+  if (ZERO_WIDTH.test(String.fromCodePoint(first))) return 0
+  return isWideCodePoint(first) ? 2 : 1
+}
+
+/** Terminal-cell width of one code point (surrogate pairs must stay paired). */
+export function codePointWidth(char: string): number {
+  if (ZERO_WIDTH.test(char)) return 0
+  return isWideCodePoint(char.codePointAt(0) ?? 0) ? 2 : 1
+}
+
+/**
+ * Terminal-cell width of a string: an ASCII fast path avoids the segmenter
+ * for the overwhelmingly common case; everything else sums grapheme clusters.
+ * Control characters occupy no cells (display sanitization makes them
+ * visible escapes before they ever reach a budget).
+ * @param text - display-safe or raw text to measure.
+ * @returns the column count the terminal will draw.
+ */
+export function stringWidth(text: string): number {
+  let asciiOnly = true
+  for (let index = 0; index < text.length; index += 1) {
+    if (text.charCodeAt(index) > 0x7f) {
+      asciiOnly = false
+      break
+    }
+  }
+  if (asciiOnly) {
+    let columns = 0
+    for (let index = 0; index < text.length; index += 1) {
+      const code = text.charCodeAt(index)
+      if (code >= 0x20 && code !== 0x7f) columns += 1
+    }
+    return columns
+  }
+  let columns = 0
+  for (const cluster of splitGraphemes(text)) columns += graphemeWidth(cluster)
+  return columns
+}

package/src/session-directory.ts

@@ -240,6 +240,62 @@ export function collectDeletionSubtree(records: readonly SessionRecord[], id: st
   return [...doomed]
 }
 
+/** One validated node of a deletion plan. */
+export interface DeletionPlanNode {
+  /** Session id to remove. */
+  readonly id: string
+  /** Distance from the deletion root (0 for the root itself). */
+  readonly depth: number
+}
+
+/** A fully preflighted subtree deletion, or the refusal that produced none. */
+export type SessionDeletionPlan =
+  | { readonly ok: true; readonly nodes: readonly DeletionPlanNode[] }
+  | { readonly ok: false; readonly reason: string }
+
+/**
+ * Plan one session-subtree deletion with NO filesystem side effects: collect
+ * the doomed lineage, refuse when the root or ANY member is live (a live
+ * child would outlive its deleted parent) or missing from the listing, and
+ * order the result children-first so the executor can never leave a deleted
+ * parent behind surviving children. Artifact-location guards stay at the
+ * call site; this is the pure preflight they complete.
+ * @param records - the full directory listing.
+ * @param id - the root session id to delete.
+ * @returns the ordered plan, or a user-facing refusal reason.
+ */
+export function planSessionDeletion(records: readonly SessionRecord[], id: string): SessionDeletionPlan {
+  const target = records.find(record => record.header.id === id)
+  if (target === undefined) return { ok: false, reason: `no persisted session matches "${id}"` }
+  if (target.live) return { ok: false, reason: 'cannot delete a live session — it is open in this or another process' }
+  const doomed = collectDeletionSubtree(records, id)
+  const byId = new Map<string, SessionRecord>(records.map(record => [record.header.id, record]))
+  const parentOf = new Map<string, string | undefined>()
+  for (const record of records) parentOf.set(record.header.id, record.header.parentSession)
+  const nodes: DeletionPlanNode[] = []
+  for (const candidate of doomed) {
+    const record = byId.get(candidate)
+    if (record === undefined) return { ok: false, reason: `no persisted session matches "${candidate}"` }
+    if (record.live) {
+      return {
+        ok: false,
+        reason: `cannot delete: child session ${candidate.slice(-12)} is live — close it (and any process using it) first`,
+      }
+    }
+    let depth = 0
+    let ancestor = parentOf.get(candidate)
+    while (ancestor !== undefined && depth < 64) {
+      depth += 1
+      ancestor = parentOf.get(ancestor)
+    }
+    nodes.push({ id: candidate, depth })
+  }
+  // Deepest first: a mid-deletion failure then leaves the shallowest lineage
+  // intact, never a deleted parent with surviving children.
+  nodes.sort((left, right) => right.depth - left.depth)
+  return { ok: true, nodes }
+}
+
 /**
  * Codex-style relative time for session rows ("now", "5m ago", "3h ago",
  * "2d ago"; older than a week falls back to the local date).

package/src/settings-file.ts

@@ -0,0 +1,56 @@
+/**
+ * Serialized, crash-atomic persistence for the small user-level JSON files
+ * under the DSH home (statusline.json, theme.json). Two guarantees the bare
+ * floating `writeFile` path could not give:
+ *
+ * 1. Every save is appended to ONE chain, so rapid consecutive edits land
+ *    in submission order and the last snapshot is the one on disk (parallel
+ *    floating writes let an older snapshot finish last and win).
+ * 2. Each write goes to a sibling temp file first and is renamed into
+ *    place, so a crash mid-write can never leave a half-written JSON
+ *    document behind.
+ *
+ * The chain itself never rejects: a failed write is reported to that
+ * save's caller while later saves keep their turn.
+ *
+ * @module @deepseek-ai/dsh-code/settings-file
+ */
+
+import { mkdir, rename, writeFile } from 'node:fs/promises'
+import { dirname } from 'node:path'
+
+/** The serialized persistence surface; flush() is handed to the quit sequence. */
+export interface UserSettingsPersistence {
+  /**
+   * Queue one file snapshot. Resolves when the chain reaches (and renames)
+   * it; rejects only to THIS caller when its own write failed.
+   */
+  save(path: string, text: string): Promise<void>
+  /** Wait for every queued write; safe to call repeatedly. */
+  flush(): Promise<void>
+}
+
+/**
+ * Create the shared settings-write chain. One instance per process keeps
+ * every user-level JSON file mutually serialized.
+ * @returns the persistence handle.
+ */
+export function createUserSettingsPersistence(): UserSettingsPersistence {
+  let chain: Promise<void> = Promise.resolve()
+  return {
+    save(path: string, text: string): Promise<void> {
+      const write = chain.then(async () => {
+        await mkdir(dirname(path), { recursive: true })
+        const temp = `${path}.tmp`
+        await writeFile(temp, text, 'utf8')
+        await rename(temp, path)
+      })
+      // A failed write must not break the chain for later saves.
+      chain = write.catch(() => {})
+      return write
+    },
+    flush(): Promise<void> {
+      return chain
+    },
+  }
+}

package/src/store.ts

@@ -3,6 +3,16 @@
  * and notifies subscribers. The renderer subscribes through
  * `useSyncExternalStore`; the runner owns event feeding.
  *
+ * Folding runs on the same mutable replay accumulator the persisted-log
+ * path uses (`replayProjectEvent`: id-indexed row updates, in-place
+ * appends), so a live structural event costs O(1) entry work regardless of
+ * transcript length — the copy-on-write fold rebuilt the whole entries
+ * array per event, making a growing session quadratic. An immutable
+ * `TranscriptView` snapshot is materialized only when a changed view is
+ * READ (once per rendered frame under the notification throttle, never per
+ * event), and every snapshot copies its arrays, so a view already handed
+ * out never observes later folds.
+ *
  * Notification coalescing: the fold stays synchronous — `getView()` always
  * returns the latest state the moment `apply` returns — but listener
  * notification is frame-throttled (~16ms) and deduplicated. The zai/GLM
@@ -21,7 +31,7 @@
  */
 
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
-import { createTranscriptView, projectEvent, projectEvents, type TranscriptView } from './render/projection.ts'
+import { createReplayAccumulator, replayProjectEvent, snapshotReplayView, type TranscriptView } from './render/projection.ts'
 
 /** Render frame budget: the notification cadence's upper bound. */
 const NOTIFY_FRAME_MS = 16
@@ -49,7 +59,10 @@ export interface TranscriptStore {
  * @returns the store the runner feeds and the renderer subscribes to.
  */
 export function createTranscriptStore(replay?: readonly SessionEvent[]): TranscriptStore {
-  let view = replay === undefined ? createTranscriptView() : projectEvents(replay)
+  let acc = createReplayAccumulator()
+  for (const event of replay ?? []) replayProjectEvent(acc, event)
+  let view = snapshotReplayView(acc)
+  let dirty = false
   const listeners = new Set<() => void>()
   let scheduled = false
   let lastNotifyAt = 0
@@ -70,7 +83,13 @@ export function createTranscriptStore(replay?: readonly SessionEvent[]): Transcr
     else setTimeout(dispatch, wait)
   }
   return {
-    getView: () => view,
+    getView: (): TranscriptView => {
+      if (dirty) {
+        view = snapshotReplayView(acc)
+        dirty = false
+      }
+      return view
+    },
     subscribe(listener: () => void): () => void {
       listeners.add(listener)
       return () => {
@@ -78,13 +97,13 @@ export function createTranscriptStore(replay?: readonly SessionEvent[]): Transcr
       }
     },
     apply(event: SessionEvent): void {
-      const next = projectEvent(view, event)
-      if (next === view) return
-      view = next
+      if (!replayProjectEvent(acc, event)) return
+      dirty = true
       notify()
     },
     reset(): void {
-      view = createTranscriptView()
+      acc = createReplayAccumulator()
+      dirty = true
       notify()
     },
   }

package/src/subagents.ts

@@ -7,8 +7,13 @@
  *
  * This is NOT a second transcript: each child folds to ONE row (label,
  * running state, bounded last-activity text), capped at
- * {@link MAX_SUBAGENT_ROWS}. Rows are advisory display state, rebuilt from
- * live events; nothing here persists or replays. Notification is coalesced
+ * {@link MAX_SUBAGENT_ROWS}. The cap is a display budget, not a fan-out
+ * limit: a new running child evicts the OLDEST settled row when one
+ * exists, and while every row is busy the newcomer waits off-screen — but
+ * the observed-session total (getTotalSeen) keeps counting, so status
+ * totals never under-report the fan-out. Rows are advisory display
+ * state, rebuilt from live events; nothing here persists or replays.
+ * Notification is coalesced
  * by the same ~16ms frame throttle as the transcript store (per-burst
  * microtask notify chained SyncLane rerenders past React's nested update
  * limit; a bare macrotask merge repaints a whole turn's bursts at once).
@@ -18,7 +23,7 @@
 
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
 
-/** Hard row cap: a fan-out larger than this stays summarized by the head. */
+/** Hard row cap: overflow evicts the oldest settled row; a fully busy feed waits. */
 export const MAX_SUBAGENT_ROWS = 8
 
 /** Render frame budget: the notification cadence's upper bound. */
@@ -47,6 +52,11 @@ export interface SubagentFeedView {
   subscribe(listener: () => void): () => void
   /** Read the current rows (identity-stable between changes). */
   getSnapshot(): readonly SubagentRow[]
+  /**
+   * Distinct child sessions observed since the last reset. The row cap is
+   * a display budget, not a count of the fan-out; totals surface this.
+   */
+  getTotalSeen(): number
 }
 
 /** Single-line bounded preview of an assembled message's text content. */
@@ -130,6 +140,7 @@ export function createSubagentFeed(): SubagentFeedView & {
   reset(): void
 } {
   let rows: readonly SubagentRow[] = Object.freeze([])
+  const seen = new Set<string>()
   const listeners = new Set<() => void>()
   let scheduled = false
   let lastNotifyAt = 0
@@ -150,12 +161,31 @@ export function createSubagentFeed(): SubagentFeedView & {
       const index = rows.findIndex(row => row.id === sessionId)
       const previous = index === -1 ? undefined : rows[index]
       const next = foldSubagentRow(previous, sessionId, event)
-      if (next === previous) return
-      if (index === -1 && rows.length >= MAX_SUBAGENT_ROWS) return
-      rows = Object.freeze(index === -1 ? [...rows, next] : rows.map((row, at) => at === index ? next : row))
+      if (index !== -1) {
+        if (next === previous) return
+        rows = Object.freeze(rows.map((row, at) => at === index ? next : row))
+        notify()
+        return
+      }
+      // A child this feed has not shown yet: the honest total grows even
+      // when every row is busy; admission then prefers evicting the OLDEST
+      // settled row so a new running agent never waits on one that finished.
+      const counted = !seen.has(sessionId)
+      if (counted) seen.add(sessionId)
+      if (rows.length >= MAX_SUBAGENT_ROWS) {
+        const evict = rows.findIndex(row => row.state === 'done')
+        if (evict === -1) {
+          if (counted) notify()
+          return
+        }
+        rows = Object.freeze([...rows.slice(0, evict), next, ...rows.slice(evict + 1)])
+      } else {
+        rows = Object.freeze([...rows, next])
+      }
       notify()
     },
     reset(): void {
+      seen.clear()
       if (rows.length === 0) return
       rows = Object.freeze([])
       notify()
@@ -169,5 +199,8 @@ export function createSubagentFeed(): SubagentFeedView & {
     getSnapshot(): readonly SubagentRow[] {
       return rows
     },
+    getTotalSeen(): number {
+      return seen.size
+    },
   }
 }