fix(mobile): keep the soft keyboard up when tapping between editing blocks

Tapping from one editing block straight into another dropped the soft
keyboard and exited edit mode, so it took a second tap to resume editing.

`isEditing` is one flag shared across the UI-state surface, owned by
whichever block holds `focusedBlockLocation`. On a block->block tap the
tapped block's `focusBlock(edit:true)` sets the flag true, while the
outgoing editor's blur handler clears it -- an identity-less write that,
because it commits asynchronously, can land AFTER the handoff and clobber
the flag the new block just set, exiting edit mode entirely. It only
misfires under that timing (slow builds, touch emulation, and the iOS
path where the soft-keyboard proxy input holds focus), which is why it
didn't repro on fast native paths.

Fix: `exitEditModeForBlock` reads the focused location INSIDE the tx
(commit-consistent -- the same `tx.get` pattern `focusBlock` uses to
preserve edit mode) and clears `isEditing` only if this block still owns
it, a compare-and-swap. Whichever of the two txs commits second sees the
other's effect, so both interleavings settle on the tapped block editing.
Unlike a DOM-focus heuristic it's oblivious to where focus physically
sits (proxy input, incoming block's shell), so it holds on iOS too.

Verified in a Chrome block->block repro driven via the live repo: cold and
warm, both directions, and with a body-level proxy-input focus simulating
the iOS keyboard-grab path -- edit mode + focus move cleanly to the tapped
block every time.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Stvad

src/components/BlockEditor.tsx

@@ -3,6 +3,7 @@ import { Block } from '../data/block'
 import {
   editorSelection,
   editorFocusRequestProp,
+  exitEditModeForBlock,
   isFocusedBlock,
   type EditorSelectionState,
 } from '@/data/properties.js'
@@ -34,7 +35,7 @@ export const BlockEditor = ({
   const cm = useRef<ReactCodeMirrorRef>(null)
   const [editorView, setEditorView] = useState<EditorView | null>(null)
 
-  const [isEditing, setIsEditing] = useIsEditing()
+  const [isEditing] = useIsEditing()
   const inEditMode = useInEditMode(block.id)
   const blockContext = useBlockContext()
   const renderScopeId = typeof blockContext.renderScopeId === 'string'
@@ -289,7 +290,11 @@ export const BlockEditor = ({
             return
           }
           if (keepalive === 'yield') return
-          setIsEditing(false)
+          // Clear edit mode only if THIS block still owns it. A block→block
+          // tap may have already handed edit mode to the tapped block; an
+          // unconditional clear would race that handoff and drop it (the
+          // "keyboard hides / needs a second tap" bug). See exitEditModeForBlock.
+          void exitEditModeForBlock(uiStateBlock, block.id, renderScopeId)
         })
       }}
       extensions={mergedExtensions}

src/data/properties.ts

@@ -379,6 +379,39 @@ export const focusBlock = async (
   }, {scope: ChangeScope.UiState, description: 'focus block'})
 }
 
+/** Exit edit mode on behalf of `blockId` — but only if that block still
+ *  owns edit mode when the tx commits.
+ *
+ *  `isEditing` is a single flag shared across the UI-state surface, so an
+ *  unconditional clear is identity-less: it can't tell *whose* edit mode it
+ *  ends. During a block→block tap the tapped block's `focusBlock(edit:true)`
+ *  and the outgoing editor's blur-driven exit race. An anonymous clear that
+ *  commits *after* the handoff clobbers the flag the new block just set,
+ *  dropping edit mode entirely (on a soft keyboard it hides, needing a
+ *  second tap) — and it only misfires under that timing, which is why it
+ *  doesn't repro on fast/native paths.
+ *
+ *  Reading the focused location INSIDE the tx (commit-consistent — the same
+ *  `tx.get` pattern `focusBlock` uses to preserve edit mode) makes this a
+ *  compare-and-swap: whichever of the two txs commits second sees the
+ *  other's effect, so both interleavings settle on the tapped block editing.
+ *  Unlike a DOM-focus heuristic it's oblivious to *where* focus physically
+ *  sits (the iOS soft-keyboard proxy input, the incoming block's shell, …). */
+export const exitEditModeForBlock = async (
+  uiStateBlock: Block,
+  blockId: string,
+  renderScopeId?: string,
+): Promise<void> => {
+  await uiStateBlock.repo.tx(async tx => {
+    const location = focusedBlockLocationFromProperties((await tx.get(uiStateBlock.id))?.properties)
+    // Another block owns the focused location now (or a different render-scope
+    // copy of this block does) → the handoff already moved on; not ours to clear.
+    if (location && location.blockId !== blockId) return
+    if (location && renderScopeId !== undefined && location.renderScopeId !== renderScopeId) return
+    await tx.setProperty(uiStateBlock.id, isEditingProp, false)
+  }, {scope: ChangeScope.UiState, description: 'exit edit mode'})
+}
+
 export const requestEditorFocus = (uiStateBlock: Block): void => {
   const current = uiStateBlock.peekProperty(editorFocusRequestProp) ?? 0
   void uiStateBlock.set(editorFocusRequestProp, current + 1)

src/data/test/focusBlock.test.ts

@@ -2,7 +2,13 @@
 
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
 import { ChangeScope } from '@/data/api'
-import { focusBlock, focusedBlockLocationProp, isEditingProp, topLevelBlockIdProp } from '@/data/properties'
+import {
+  exitEditModeForBlock,
+  focusBlock,
+  focusedBlockLocationProp,
+  isEditingProp,
+  topLevelBlockIdProp,
+} from '@/data/properties'
 import { Repo } from '@/data/repo'
 import { createTestDb, resetTestDb, type TestDb } from '@/data/test/createTestDb'
 import { createTestRepo } from '@/data/test/createTestRepo'
@@ -79,3 +85,53 @@ describe('focusBlock', () => {
     expect(uiStateBlock.peekProperty(isEditingProp)).toBe(false)
   })
 })
+
+describe('exitEditModeForBlock', () => {
+  it('clears the edit flag when this block still owns edit mode (a genuine tap-away)', async () => {
+    const uiStateBlock = env.repo.block('ui')
+    await focusBlock(uiStateBlock, 'note-1', {edit: true, renderScopeId: NOTE_SCOPE})
+
+    await exitEditModeForBlock(uiStateBlock, 'note-1', NOTE_SCOPE)
+
+    expect(uiStateBlock.peekProperty(isEditingProp)).toBe(false)
+    // The focus location is left intact — only the edit flag is cleared.
+    expect(uiStateBlock.peekProperty(focusedBlockLocationProp)).toEqual({
+      blockId: 'note-1',
+      renderScopeId: NOTE_SCOPE,
+    })
+  })
+
+  it('is a no-op once another block has taken over edit mode (block→block handoff)', async () => {
+    const uiStateBlock = env.repo.block('ui')
+    // note-1 is editing; a tap on note-2 hands edit mode over (focusBlock
+    // commits first) — then note-1's outgoing editor blurs and tries to exit.
+    // The stale clear must NOT clobber note-2's edit mode (else the keyboard
+    // drops and it takes a second tap to resume). This is the exact ordering
+    // an unconditional `setIsEditing(false)` got wrong.
+    await focusBlock(uiStateBlock, 'note-1', {edit: true, renderScopeId: NOTE_SCOPE})
+    await focusBlock(uiStateBlock, 'note-2', {edit: true, renderScopeId: NOTE_SCOPE})
+
+    await exitEditModeForBlock(uiStateBlock, 'note-1', NOTE_SCOPE)
+
+    expect(uiStateBlock.peekProperty(isEditingProp)).toBe(true)
+    expect(uiStateBlock.peekProperty(focusedBlockLocationProp)).toEqual({
+      blockId: 'note-2',
+      renderScopeId: NOTE_SCOPE,
+    })
+  })
+
+  it('is a no-op when another render-scope copy of the same block owns edit mode', async () => {
+    const uiStateBlock = env.repo.block('ui')
+    const EMBED_SCOPE = 'embed:xyz'
+    await focusBlock(uiStateBlock, 'note-1', {edit: true, renderScopeId: NOTE_SCOPE})
+    await focusBlock(uiStateBlock, 'note-1', {edit: true, renderScopeId: EMBED_SCOPE})
+
+    await exitEditModeForBlock(uiStateBlock, 'note-1', NOTE_SCOPE)
+
+    expect(uiStateBlock.peekProperty(isEditingProp)).toBe(true)
+    expect(uiStateBlock.peekProperty(focusedBlockLocationProp)).toEqual({
+      blockId: 'note-1',
+      renderScopeId: EMBED_SCOPE,
+    })
+  })
+})