Verify each finding against the current code and only fix it if needed.

Outside diff comments:
In `@docs/tasks/active/20260329-table-crdt-phase-a-todo.md`:
- Around line 730-741: The manual smoke-test checkbox in the "Step 3: Manual
smoke test" checklist is marked complete ([x]) while PR objectives still list
these checks as pending; either revert the checklist mark to unchecked ([ ]) or
attach concrete evidence of the test run (screenshots/logs) and update the PR
objectives to reflect completion; specifically update the "Step 3: Manual smoke
test" line and any related PR objective text mentioning these manual checks so
they are consistent.

In `@packages/docs/src/model/document.ts`:
- Around line 597-619: mergeCells() currently only copies cell.blocks[0].inlines
into topLeft, dropping any text in blocks[1+] and losing block types/styles;
change the logic in the nested loop that handles a non-empty cell (where
getCellText(cell) > 0) to either (A) clone and append all non-empty blocks from
cell.blocks into topLeft.blocks (preserving each block's type, style and
inlines) — i.e., push deep-cloned block objects instead of flattening everything
into topLeft.blocks[0].inlines, then normalize via this.normalizeInlinesArray on
each affected block or the whole blocks array — or (B) detect when
cell.blocks.length > 1 and reject/abort the merge with a clear error/return
(reject multi-block merges) so you don't silently drop content; make sure to use
generateBlockId only when creating the covered placeholder and do not mutate the
original source blocks (use cloning) and keep references to functions/vars from
the diff: mergeCells(), getCellText(cell), topLeft.blocks, cell.blocks,
normalizeInlinesArray.
- Around line 405-490: The cell-edit helpers (insertTextInCell,
deleteTextInCell, applyCellInlineStyle) assume the target is always
tableCell.blocks[0], which breaks or silently mutates when a cell has multiple
blocks; add a guard at the start of each method to detect
tableCell.blocks.length !== 1 and fail fast (throw an Error or return after
logging) with a clear message referencing the blockId and cell so callers know
multi-block cells are unsupported, or alternatively implement full multi-block
logic by mapping offsets across tableCell.blocks instead; for the quick fix
update insertTextInCell, deleteTextInCell and applyCellInlineStyle to check
tableCell.blocks.length !== 1 and abort before touching blocks[0].

---

Nitpick comments:
In `@docs/tasks/active/20260329-table-crdt-phase-a-todo.md`:
- Around line 720-731: Update the task so the final step archives it when all
verifications and docs updates are complete: ensure you run the checks (pnpm
verify:fast and node scripts/verify-entropy.mjs), update any changed
architecture in docs/design/, then perform the standard archive flow with pnpm
tasks:archive && pnpm tasks:index and move the task out of docs/tasks/active
(the file docs/tasks/active/20260329-table-crdt-phase-a-todo.md) to reflect the
completed state.

In `@packages/docs/src/model/document.ts`:
- Line 613: Replace the inline empty paragraph literal used to reset table cells
with the existing helper createEmptyBlock() so cleared cells use the canonical
block shape; specifically, in the assignment where cell.blocks is set to [{ id:
generateBlockId(), type: 'paragraph', inlines: [{ text: '', style: {} }], style:
{ ...DEFAULT_BLOCK_STYLE } }] (and the similar occurrence around the other
mentioned site) call createEmptyBlock() (or createEmptyBlock().wrapped/array
form as appropriate) instead of rebuilding the literal, preserving the same
semantics but centralizing the shape in createEmptyBlock().

In `@packages/docs/src/view/text-editor.ts`:
- Around line 2289-2310: The offset computation flattens all blocks
(cell.blocks.flatMap(...)) but insertTextInCell/deleteTextInCell operate only on
blocks[0], which will cause misalignment if cells become multi-block; change the
offset calculation used before cursor.moveTo to compute length only for the
first block (e.g., sum inlines of cell.blocks[0]) or alternatively update the
editing functions (insertTextInCell/deleteTextInCell) to accept and correctly
resolve multi-block offsets; reference cell.blocks, cursor.moveTo,
insertTextInCell, deleteTextInCell and createTableCell to locate the related
logic and keep cursor offsets and editor operations consistent.

In `@packages/docs/test/view/table-selection.test.ts`:
- Line 27: Extract the repeated flattening chain used to get a cell's text
(block.tableData!.rows[0].cells[0].blocks.flatMap(b => b.inlines).map(i =>
i.text).join('')) into a small local test helper (e.g., getCellText or
extractCellText) and replace each duplicate occurrence in the test with calls to
that helper; update usages referenced in this file (table-selection.test.ts) for
the other indices mentioned (lines around the duplicates) so the tests call
getCellText(block, rowIndex, colIndex) or similar instead of repeating the
flatMap/map/join chain.

In `@packages/frontend/src/app/docs/yorkie-doc-store.ts`:
- Around line 240-255: The table branch currently parses attrs.cols into cols
and may produce an empty columnWidths array; add validation in the blockType ===
'table' path (the code that builds tableData) to detect when parsed cols is
empty and provide a sensible fallback (e.g., derive column count from parsed
rows via treeNodeToRow or default to [1] or a single-column width) before
returning { tableData: { rows, columnWidths: cols } }; keep existing fields (id,
type, inlines, style via parseBlockStyle) and ensure columnWidths is never empty
to avoid downstream layout issues.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/docs/src/model/document.ts`:
- Around line 684-701: The merge logic uses getCellText(cell) to detect
non-empty content but only copies from cell.blocks[0], dropping text in
cell.blocks[1+] and flattening everything into topLeft.blocks[0]; update the
merge to iterate over all source blocks in each covered cell (cell.blocks) and
append each block as a distinct block to topLeft.blocks (preserving block order
and their inlines), then mark the original cell as covered (setting blocks to
the placeholder) as before and finally call this.normalizeInlinesArray on each
resulting topLeft block if needed; reference functions/values to change:
getCellText, cell.blocks, topLeft.blocks, generateBlockId,
normalizeInlinesArray.

In `@packages/docs/src/view/table-layout.ts`:
- Around line 144-173: layoutCellBlocks currently treats every Block as plain
inline text by calling layoutCellInlines; update it to perform block-aware
layout like the main document flow: inspect block.type (e.g., "heading",
"paragraph", "list"), headingLevel, listKind, listLevel and apply the
corresponding block layout logic (styles, font sizes, indentation, list markers,
and spacing) instead of only inlines, by reusing or delegating to the existing
block-aware layout functions used for the main flow (e.g., the layoutBlock /
layoutBlocks or flow layout helpers) and ensure blockBoundaries and line y
offsets are computed the same way; also update the related usage that currently
calls layoutCellInlines (the other occurrence referenced around
layoutCellInlines) so list items and headings inside cells render with proper
indentation and spacing.

---

Outside diff comments:
In `@packages/docs/src/view/peer-cursor.ts`:
- Around line 78-117: The caret placement loop in peer-cursor.ts always selects
the first visual line whose char count >= position.offset, ignoring
position.lineAffinity; update the loop inside the block that iterates li from
startLine to endLine so that when offsetRemaining exactly equals the cumulative
chars at a wrap boundary you choose the next visual line if
position.lineAffinity === "forward" (mirror the non-table path) and keep the
current visual line if affinity is backward; use the existing
position.lineAffinity (or similar field) when computing which line to treat as
the cursor line and ensure any helper that consumes the resolved line/offset
also receives the affinity so wrapped-cell cursor/navigation remains stable.

In `@packages/docs/src/view/text-editor.ts`:
- Around line 1299-1317: handleArrow's table-cell branch currently compares
pos.offset against the full cellLen and ignores cellBlockIndex, so
ArrowLeft/ArrowRight bypass block-aware movement; update the table-cell logic in
handleArrow to consult pos.cellBlockIndex and the current block length (not
whole cellLen), and use the block-aware helpers (moveLeft/moveRight or
moveWordLeft/moveWordRight) or fall back to moveToPrevCell/moveToNextCell when
at a block boundary — adjust the branches around moveWordLeft/moveWordRight,
moveToPrevCell/moveToNextCell, and the newPos assignments so arrows enter/leave
blocks correctly, and still call selection.setRange(null) and requestRender()
when crossing cells.
- Around line 259-280: The cell edit paths still treat cell offsets as flat—fix
the IME/live-edit and deleteSelection() code that calls
deleteTextInCell/insertTextInCell (and computes lengths from end.offset -
start.offset) to use the position's cellBlockIndex and per-block offsets: when
startPosition.cellAddress exists, compute the target block index
(startPosition.cellBlockIndex) and the intra-block offset (e.g., offset within
that cell block) and pass that plus the cellBlockIndex into the cell-specific
APIs instead of the flat offset; also guard length calculations so you only use
end.offset - start.offset when both positions refer to the same cell block
(end.cellBlockIndex === start.cellBlockIndex), otherwise iterate or target the
correct block(s) in the cell. Ensure updates around composition.currentLength
and compPos preserve cellBlockIndex and intra-block offsets when setting the new
composition position.
- Around line 2198-2250: The hit-test ignores vertical position so clicks in
later wrapped lines or paragraphs map to the first line; compute logicalY in
resolveOffsetInCell (using e.clientY, container.getBoundingClientRect().top,
container.scrollTop and getScaleFactor()) and pass it into
resolveOffsetInCellAtX (add a logicalY parameter), then inside
resolveOffsetInCellAtX compute cellOriginY (use
paginatedLayout.pageSetup.margins.top + tl.rowYOffsets[cellAddr.rowIndex] or the
table's row Y offsets) and localY = logicalY - cellOriginY; while iterating
cell.lines subtract each line's height (or use line.height/line.metrics) from
localY to find the target line index, and only run the per-run X measurement for
that specific line (leave other logic intact and return offset + i and
currentBlockIndex once the correct line and run position is found).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/docs/src/model/document.ts`:
- Around line 539-555: splitBlockInCell always creates newBlock with type
'paragraph', dropping list semantics (listKind/listLevel) when splitting a cell;
update splitBlockInCell to preserve list metadata and exit-behavior like
splitBlock: detect if targetBlock has listKind/listLevel and copy those fields
(and any list-specific behavior such as empty-list-item exit) onto the newBlock
and maintain the same type if it's a list-item, ensure
targetBlock.inlines/afterInlines handling remains the same, and reuse the same
logic splitBlock uses for empty-list-item exit so splitting inside list-items in
cells preserves list semantics and exit behavior.

In `@packages/docs/src/view/text-editor.ts`:
- Around line 947-975: The cell-aware delete logic only handles single-character
Backspace/Delete; update handleWordBackspace, handleWordDelete, and
handleLineBackspace to detect when cursor.position.cellAddress is set and, in
that case, operate on the cell-specific APIs (use
this.doc.getCellBlockTextLength, this.doc.deleteTextInCell,
this.doc.mergeBlocksInCell) instead of this.doc.getBlock / this.doc.deleteText,
and adjust cursor moves to set/maintain cellAddress and cellBlockIndex (mirror
the approach in the existing single-char backspace branch). Ensure each handler
preserves the original shortcut semantics (word/line deletion or merge) but
applies them inside the cell, calls markDirty(pos.blockId), requestRender(), and
invalidateLayout() where appropriate.
- Around line 200-220: The IME live update path in handleInput() is not passing
startPosition.cellBlockIndex into the cell-aware edits and cursor updates;
update handleInput() so that when it calls deleteTextInCell(...) and
insertTextInCell(...) it forwards startPosition.cellBlockIndex (or 0/undefined
consistently) just like the commit path does, and ensure the resulting
cursor/selection calculation uses that same cellBlockIndex when constructing the
new DocPosition (matching how endPos is built in the commit code) so previews
and final commits target the correct cell block.

---

Outside diff comments:
In `@packages/docs/src/view/text-editor.ts`:
- Around line 2255-2305: The resolver only uses X so clicks map to the top-most
line; change resolveOffsetInCell to also compute logicalY from e.clientY
(similar to logicalX) and pass it into resolveOffsetInCellAtX, then in
resolveOffsetInCellAtX compute localY for the cell (using the page Y offset /
margins and the table/row Y offset for cellAddr.rowIndex) and use localY to pick
the correct line index instead of scanning from the top—i.e., determine lineIdx
by comparing localY against each line's vertical position or accumulated line
heights, then only iterate runs in that single visual line to measure X and
return the correct offset and cellBlockIndex (keep using
cell.blockBoundaries/currentBlockIndex logic when mapping lineIdx to block
index).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/docs/src/view/editor.ts`:
- Around line 869-879: The current branch uses doc.applyCellInlineStyle once
with anchor.cellBlockIndex, which misapplies href when the normalized selection
spans multiple blocks; instead split the normalized selection across the cell's
blocks and call doc.applyCellInlineStyle per-block with the correct start/end
offsets and per-block index (use anchor.cellBlockIndex ?? 0 as the base), then
call markDirty(anchor.blockId) and render() once after applying to all affected
blocks; locate the code around anchor.cellAddress, selection.getNormalizedRange,
normalized.start/end, and replace the single applyCellInlineStyle call with a
loop that applies the href to each block segment within the normalized range.
- Around line 375-378: setSearchMatches currently builds auto-scroll rects from
block-only ranges, so table-cell matches (which now carry cellAddress and
cellBlockIndex) won't scroll correctly; update setSearchMatches (and any helper
that computes active-match scroll rects) to thread the full range shape
including anchor.cellAddress, anchor.cellBlockIndex, focus.cellAddress, and
focus.cellBlockIndex when constructing the auto-scroll/visible-rect for each
match so scrolling uses the cell-aware coordinates for table hits; ensure any
calls that create the match object (the place that previously set anchor/focus
with only blockId/offset) are changed to pass through the new
cellAddress/cellBlockIndex fields so active-match navigation scrolls table cells
into view.

In `@packages/docs/src/view/table-renderer.ts`:
- Around line 148-174: The list counter logic in table-renderer.ts increments
listCounters for every list-item regardless of kind, causing ordered lists to
continue numbering across unordered entries; modify the loop around listCounters
so that you only compute/increment/set the counter when cellBlock.listKind ===
'ordered' (using cellBlock.listLevel/listLevel as the key) and when
cellBlock.listKind === 'unordered' delete/reset the counter for that specific
level so subsequent ordered items restart; keep the existing deeper-level
cleanup logic (for ... of listCounters) and use UNORDERED_MARKERS when choosing
markers for unordered items.

---

Duplicate comments:
In `@packages/docs/src/model/document.ts`:
- Around line 753-770: The merge routine is only copying cell.blocks[0] into
topLeft.blocks[0], which discards blocks at cell.blocks[1+]; instead iterate
over all blocks in cell.blocks and for each append a corresponding block object
to topLeft.blocks (preserving or cloning id/type/style/inlines, using
generateBlockId() and DEFAULT_BLOCK_STYLE as needed for any missing fields) so
each source block becomes its own block in topLeft.blocks rather than flattening
all inlines into the first block; keep the subsequent "Mark as covered"
assignment to cell.blocks and the final
normalizeInlinesArray(topLeft.blocks[0].inlines) step (or adjust normalization
to run on each block if desired).
- Around line 539-555: When creating the new block after splitting a cell, don't
hard-code type:'paragraph' or drop list metadata; set the new block's type to
targetBlock.type and copy list-related fields (e.g., listKind, listLevel) from
targetBlock so list items inside table cells preserve list behavior, and
implement the empty-list-item exit logic used by splitBlock() (i.e., when
splitting an empty list item follow the same exit-to-paragraph behavior as
splitBlock) rather than unconditionally producing a paragraph without list
metadata; locate this change around the code that builds newBlock (uses
generateBlockId(), buildInlinesFromSplit(), getStyleAtOffset()) and update the
newBlock construction to mirror splitBlock()'s handling of listKind/listLevel
and empty-item exits.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/docs/src/view/selection.ts`:
- Around line 330-342: The loop uses tablePageY !== 0 to break the outer loop
which fails when a table legitimately sits at Y=0; change to an explicit found
flag (e.g., foundTable) or similar boolean: set foundTable = true when
pl.blockIndex === blockIndex && pl.lineIndex === 0, assign tablePageY and
tableRowBaseY using getPageYOffset(...) and tl.rowYOffsets[0], break the inner
loop, and then break the outer loop when foundTable is true; reference symbols:
tablePageY, tableRowBaseY, paginatedLayout.pages, pl.blockIndex, pl.lineIndex,
getPageYOffset, tl.rowYOffsets.

---

Outside diff comments:
In `@packages/docs/src/view/selection.ts`:
- Around line 385-390: The return type of getNormalizedRange should be changed
to NormalizedRange | null so callers can access the tableCellRange property
safely; update the method signature getNormalizedRange(layout: DocumentLayout):
NormalizedRange | null and leave the implementation returning
normalizeRange(this.range, layout) unchanged so callers (e.g., code that checks
normalized.tableCellRange in text-editor.ts) can type-safely branch on
cell-range selections.