reducer-array-allocation-fixes (squashed)

Author: frenchie4111

src/shared/state/json-claude.test.ts

@@ -280,6 +280,48 @@ describe('jsonClaudeReducer', () => {
     expect(next).toBe(state)
   })
 
+  it('assistantBlockAppended preserves reference identity for untouched entries', () => {
+    let state = seedSession(initialJsonClaude)
+    const e1: JsonClaudeChatEntry = {
+      entryId: 'u1',
+      kind: 'user',
+      text: 'hi',
+      timestamp: 1
+    }
+    const e2: JsonClaudeChatEntry = {
+      entryId: 'a1',
+      kind: 'assistant',
+      blocks: [{ type: 'text', text: 'hello' }],
+      timestamp: 2,
+      isPartial: true
+    }
+    const e3: JsonClaudeChatEntry = {
+      entryId: 'u2',
+      kind: 'user',
+      text: 'follow',
+      timestamp: 3
+    }
+    state = jsonClaudeReducer(state, {
+      type: 'jsonClaude/entriesSeeded',
+      payload: { sessionId: SID, entries: [e1, e2, e3] }
+    })
+    const before = state.sessions[SID].entries
+    const next = jsonClaudeReducer(state, {
+      type: 'jsonClaude/assistantBlockAppended',
+      payload: {
+        sessionId: SID,
+        entryId: 'a1',
+        block: { type: 'tool_use', id: 't1', name: 'Read' }
+      }
+    })
+    const after = next.sessions[SID].entries
+    expect(after).not.toBe(before)
+    expect(after[0]).toBe(before[0])
+    expect(after[2]).toBe(before[2])
+    expect(after[1]).not.toBe(before[1])
+    expect(after[1].blocks).toHaveLength(2)
+  })
+
   it('assistantTextDelta is a no-op for an unknown entry', () => {
     const state = seedSession(initialJsonClaude)
     const next = jsonClaudeReducer(state, {
@@ -335,6 +377,48 @@ describe('jsonClaudeReducer', () => {
     expect(next).toBe(state)
   })
 
+  it('assistantEntryFinalized preserves reference identity for untouched entries', () => {
+    let state = seedSession(initialJsonClaude)
+    const e1: JsonClaudeChatEntry = {
+      entryId: 'u1',
+      kind: 'user',
+      text: 'hi',
+      timestamp: 1
+    }
+    const e2: JsonClaudeChatEntry = {
+      entryId: 'a1',
+      kind: 'assistant',
+      blocks: [{ type: 'text', text: 'hello' }],
+      timestamp: 2,
+      isPartial: true
+    }
+    const e3: JsonClaudeChatEntry = {
+      entryId: 'u2',
+      kind: 'user',
+      text: 'follow',
+      timestamp: 3
+    }
+    state = jsonClaudeReducer(state, {
+      type: 'jsonClaude/entriesSeeded',
+      payload: { sessionId: SID, entries: [e1, e2, e3] }
+    })
+    const before = state.sessions[SID].entries
+    const next = jsonClaudeReducer(state, {
+      type: 'jsonClaude/assistantEntryFinalized',
+      payload: {
+        sessionId: SID,
+        entryId: 'a1',
+        blocks: [{ type: 'text', text: 'hello world' }]
+      }
+    })
+    const after = next.sessions[SID].entries
+    expect(after).not.toBe(before)
+    expect(after[0]).toBe(before[0])
+    expect(after[2]).toBe(before[2])
+    expect(after[1]).not.toBe(before[1])
+    expect(after[1].isPartial).toBeUndefined()
+  })
+
   it('toolResultAttached appends a tool_result entry', () => {
     let state = seedSession(initialJsonClaude)
     state = jsonClaudeReducer(state, {
@@ -559,6 +643,55 @@ describe('jsonClaudeReducer', () => {
     expect(next).toBe(state)
   })
 
+  it('userEntriesUnqueued is a no-op when entries exist but none are queued', () => {
+    let state = seedSession(initialJsonClaude)
+    state = jsonClaudeReducer(state, {
+      type: 'jsonClaude/entriesSeeded',
+      payload: {
+        sessionId: SID,
+        entries: [
+          { entryId: 'u1', kind: 'user', text: 'a', timestamp: 1 },
+          { entryId: 'u2', kind: 'user', text: 'b', timestamp: 2 }
+        ]
+      }
+    })
+    const next = jsonClaudeReducer(state, {
+      type: 'jsonClaude/userEntriesUnqueued',
+      payload: { sessionId: SID }
+    })
+    expect(next).toBe(state)
+  })
+
+  it('userEntriesUnqueued preserves reference identity for non-queued entries', () => {
+    let state = seedSession(initialJsonClaude)
+    const plain: JsonClaudeChatEntry = {
+      entryId: 'u1',
+      kind: 'user',
+      text: 'plain',
+      timestamp: 1
+    }
+    const queued: JsonClaudeChatEntry = {
+      entryId: 'u2',
+      kind: 'user',
+      text: 'queued',
+      timestamp: 2,
+      isQueued: true
+    }
+    state = jsonClaudeReducer(state, {
+      type: 'jsonClaude/entriesSeeded',
+      payload: { sessionId: SID, entries: [plain, queued] }
+    })
+    const before = state.sessions[SID].entries
+    const next = jsonClaudeReducer(state, {
+      type: 'jsonClaude/userEntriesUnqueued',
+      payload: { sessionId: SID }
+    })
+    const after = next.sessions[SID].entries
+    expect(after[0]).toBe(before[0])
+    expect(after[1]).not.toBe(before[1])
+    expect(after[1].isQueued).toBeUndefined()
+  })
+
   it('entryRemoved drops the matching entry by id', () => {
     let state = seedSession(initialJsonClaude)
     state = jsonClaudeReducer(state, {

src/shared/state/json-claude.ts

@@ -464,13 +464,15 @@ export function jsonClaudeReducer(
       const session = state.sessions[event.payload.sessionId]
       if (!session) return state
       const { entryId, block } = event.payload
-      let changed = false
-      const nextEntries = session.entries.map((entry) => {
-        if (entry.entryId !== entryId) return entry
-        changed = true
-        return { ...entry, blocks: [...(entry.blocks ?? []), block] }
-      })
-      if (!changed) return state
+      const i = session.entries.findIndex((e) => e.entryId === entryId)
+      if (i === -1) return state
+      const entry = session.entries[i]
+      const patched = { ...entry, blocks: [...(entry.blocks ?? []), block] }
+      const nextEntries = [
+        ...session.entries.slice(0, i),
+        patched,
+        ...session.entries.slice(i + 1)
+      ]
       return {
         ...state,
         sessions: {
@@ -483,15 +485,16 @@ export function jsonClaudeReducer(
       const session = state.sessions[event.payload.sessionId]
       if (!session) return state
       const { entryId, blocks } = event.payload
-      let found = false
-      const nextEntries = session.entries.map((entry) => {
-        if (entry.entryId !== entryId) return entry
-        found = true
-        const { isPartial: _drop, ...rest } = entry
-        void _drop
-        return { ...rest, blocks }
-      })
-      if (!found) return state
+      const i = session.entries.findIndex((e) => e.entryId === entryId)
+      if (i === -1) return state
+      const { isPartial: _drop, ...rest } = session.entries[i]
+      void _drop
+      const patched = { ...rest, blocks }
+      const nextEntries = [
+        ...session.entries.slice(0, i),
+        patched,
+        ...session.entries.slice(i + 1)
+      ]
       return {
         ...state,
         sessions: {
@@ -634,15 +637,13 @@ export function jsonClaudeReducer(
     case 'jsonClaude/userEntriesUnqueued': {
       const session = state.sessions[event.payload.sessionId]
       if (!session) return state
-      let changed = false
+      if (!session.entries.some((e) => e.isQueued)) return state
       const nextEntries = session.entries.map((entry) => {
         if (!entry.isQueued) return entry
-        changed = true
         const { isQueued: _drop, ...rest } = entry
         void _drop
         return rest
       })
-      if (!changed) return state
       return {
         ...state,
         sessions: {

src/shared/state/worktrees.test.ts

@@ -94,8 +94,26 @@ describe('worktreesReducer', () => {
       type: 'worktrees/pendingUpdated',
       payload: { id: 'pending:missing', patch: { status: 'error', error: 'nope' } }
     })
-    expect(next.pending).toHaveLength(1)
-    expect(next.pending[0].status).toBe('creating')
+    expect(next).toBe(start)
+  })
+
+  it('pendingUpdated preserves reference identity for untouched siblings', () => {
+    const a = stubPending({ id: 'pending:a' })
+    const b = stubPending({ id: 'pending:b' })
+    const c = stubPending({ id: 'pending:c' })
+    const start: WorktreesState = {
+      ...initialWorktrees,
+      pending: [a, b, c]
+    }
+    const next = apply(start, {
+      type: 'worktrees/pendingUpdated',
+      payload: { id: 'pending:b', patch: { status: 'setup' } }
+    })
+    expect(next.pending).not.toBe(start.pending)
+    expect(next.pending[0]).toBe(a)
+    expect(next.pending[2]).toBe(c)
+    expect(next.pending[1]).not.toBe(b)
+    expect(next.pending[1].status).toBe('setup')
   })
 
   it('pendingRemoved drops the matching entry', () => {
@@ -149,6 +167,44 @@ describe('worktreesReducer', () => {
     expect(next.pendingDeletions[0].teardownLog).toBe('hi')
   })
 
+  it('pendingDeletionUpdated on an unknown path is a no-op', () => {
+    const start: WorktreesState = {
+      ...initialWorktrees,
+      pendingDeletions: [
+        { path: '/tmp/wt/a', repoRoot: '/tmp/repo', branch: 'a', phase: 'running-teardown' }
+      ]
+    }
+    const next = apply(start, {
+      type: 'worktrees/pendingDeletionUpdated',
+      payload: { path: '/tmp/wt/missing', patch: { phase: 'failed' } }
+    })
+    expect(next).toBe(start)
+  })
+
+  it('pendingDeletionUpdated preserves reference identity for untouched siblings', () => {
+    const a: PendingDeletion = {
+      path: '/tmp/wt/a',
+      repoRoot: '/tmp/repo',
+      branch: 'a',
+      phase: 'running-teardown'
+    }
+    const b: PendingDeletion = { ...a, path: '/tmp/wt/b' }
+    const c: PendingDeletion = { ...a, path: '/tmp/wt/c' }
+    const start: WorktreesState = {
+      ...initialWorktrees,
+      pendingDeletions: [a, b, c]
+    }
+    const next = apply(start, {
+      type: 'worktrees/pendingDeletionUpdated',
+      payload: { path: '/tmp/wt/b', patch: { phase: 'removing-worktree' } }
+    })
+    expect(next.pendingDeletions).not.toBe(start.pendingDeletions)
+    expect(next.pendingDeletions[0]).toBe(a)
+    expect(next.pendingDeletions[2]).toBe(c)
+    expect(next.pendingDeletions[1]).not.toBe(b)
+    expect(next.pendingDeletions[1].phase).toBe('removing-worktree')
+  })
+
   it('pendingDeletionRemoved drops the matching entry', () => {
     const start: WorktreesState = {
       ...initialWorktrees,

src/shared/state/worktrees.ts

@@ -99,13 +99,19 @@ export function worktreesReducer(
       return { ...state, repoRoots: event.payload }
     case 'worktrees/pendingAdded':
       return { ...state, pending: [...state.pending, event.payload] }
-    case 'worktrees/pendingUpdated':
+    case 'worktrees/pendingUpdated': {
+      const i = state.pending.findIndex((p) => p.id === event.payload.id)
+      if (i === -1) return state
+      const patched = { ...state.pending[i], ...event.payload.patch }
       return {
         ...state,
-        pending: state.pending.map((p) =>
-          p.id === event.payload.id ? { ...p, ...event.payload.patch } : p
-        )
+        pending: [
+          ...state.pending.slice(0, i),
+          patched,
+          ...state.pending.slice(i + 1)
+        ]
       }
+    }
     case 'worktrees/pendingRemoved':
       return { ...state, pending: state.pending.filter((p) => p.id !== event.payload) }
     case 'worktrees/pendingDeletionStarted':
@@ -116,13 +122,21 @@ export function worktreesReducer(
           event.payload
         ]
       }
-    case 'worktrees/pendingDeletionUpdated':
+    case 'worktrees/pendingDeletionUpdated': {
+      const i = state.pendingDeletions.findIndex(
+        (d) => d.path === event.payload.path
+      )
+      if (i === -1) return state
+      const patched = { ...state.pendingDeletions[i], ...event.payload.patch }
       return {
         ...state,
-        pendingDeletions: state.pendingDeletions.map((d) =>
-          d.path === event.payload.path ? { ...d, ...event.payload.patch } : d
-        )
+        pendingDeletions: [
+          ...state.pendingDeletions.slice(0, i),
+          patched,
+          ...state.pendingDeletions.slice(i + 1)
+        ]
       }
+    }
     case 'worktrees/pendingDeletionRemoved':
       return {
         ...state,