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

Inline comments:
In `@packages/frontend/src/app/docs/yorkie-doc-store.ts`:
- Around line 850-858: The tree.editByPath call can delete a wide range when
nextIdx is not directly adjacent to blockIdx; before calling tree.editByPath
(and before the corresponding cache removal logic handling nextIdx), validate
that nextIdx === blockIdx + 1 and reject or bail out otherwise to avoid deleting
intermediate blocks; update the guard inside this.doc.update (around the tree
variable and the existing editByPath invocation) to check adjacency and only
perform tree.editByPath([blockIdx + off, firstBlockInlineCount], [nextIdx + off,
0]) when that adjacency holds, and apply the same adjacency check to the
analogous code block handling lines ~861-868 so local cache updates remain
consistent with Yorkie edits.

In `@packages/frontend/tests/app/docs/yorkie-doc-store-concurrent.integration.ts`:
- Around line 41-50: Replace the current equality checks that only compare
textA/textB/fullText with a structural comparison of normalized block snapshots
from docA and docB: implement a small normalizer (e.g.,
normalizeBlocks(doc.blocks)) that maps each block to a canonical shape
containing stable identifiers relevant to behavior (block type, list/heading
attrs, children count, and the joined inline text) and then assert deep equality
between normalizeBlocks(docA.blocks) and normalizeBlocks(docB.blocks) as well as
the expected presence/length of inserted text ("XXX") in the joined inline text;
update the assertions around variables docA, docB, textA/textB/fullText to use
normalizeBlocks and assert.deepEqual on those snapshots so metadata mismatches
(IDs/types/attrs) fail the test.

In `@packages/frontend/tests/app/docs/yorkie-doc-store.test.ts`:
- Around line 350-465: Add tests covering block-level attributes when splitting:
within the existing splitBlock suite add one test that splits a heading block
into a paragraph (e.g., create a Block with type 'heading' and headingLevel set,
call store.splitBlock(block.id, offset, 'new-id', 'paragraph') and assert the
first block keeps headingLevel and the new block has type 'paragraph' and
correct attrs), and another test that splits a list-item into another list-item
(create a Block with type 'list-item' and listKind/listLevel set, call
store.splitBlock(..., 'list-item'), then assert both resulting blocks preserve
listKind/listLevel); reference store.splitBlock, makeBlock or direct Block
literal, generateBlockId and DEFAULT_BLOCK_STYLE to locate where to add these
cases.

In `@packages/frontend/tests/helpers/two-user-docs-yorkie.ts`:
- Around line 81-100: Wrap the setup sequence that calls clientA.activate(),
clientB.activate(), clientA.attach(...), storeA.setDocument(...),
clientA.sync(...), clientB.attach(...), and syncClients(...) in a try/catch; in
the catch block perform the same cleanup you do on success (call
detach/deactivate on clientA and clientB and any doc detach as appropriate) and
then rethrow the error so activated clients/sessions are always torn down on
failure.

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

Inline comments:
In `@packages/frontend/src/app/docs/yorkie-doc-store.ts`:
- Around line 788-806: Before calling the native split (the tree.editByPath
invocation inside this.doc.update in splitBlock), validate that the target block
is a splittable text block: use the same block obtained from
currentDoc.blocks[blockIdx] and check its shape/type or presence of inline
children (i.e., that resolveOffset returned a valid inlineIndex and that
block.inline/children[inlineIndex] exists and contains text content) and bail
out early (throw or return) for non-text blocks like table, horizontal-rule, or
page-break so you never call tree.editByPath with an invalid Yorkie path.

---

Duplicate comments:
In `@packages/frontend/src/app/docs/yorkie-doc-store.ts`:
- Around line 835-848: The header/footer merge branch (using
findHeaderFooterBlock, hf1/hf2, applyMergeBlocks and commitHeaderFooterChange)
lacks the adjacency/order check present for body blocks, so it can merge
non-adjacent or reversed header/footer blocks and corrupt the region; add the
same validation you use for body merges: when hf1 && hf2 && hf1.region ===
hf2.region ensure hf2.index and hf1.index exist and that hf2.index === hf1.index
+ 1 (or otherwise enforce adjacency and correct order), throw an Error like
'Blocks to merge must be adjacent and in order' if the check fails, and only
then perform the applyMergeBlocks, replace hf1.blocks[hf1.index] with merged,
splice hf2.index, and call commitHeaderFooterChange.

In `@packages/frontend/tests/helpers/two-user-docs-yorkie.ts`:
- Around line 81-95: Move the client activations into the guarded setup so
partial activation can't leak: call clientA.activate() and clientB.activate()
inside the try (or before entering try but only after both clients are
constructed and within a try/finally block) so that the cleanup function (which
calls clientA.detach, clientB.detach, clientA.deactivate, clientB.deactivate)
always runs in the finally/catch path; adjust the surrounding block around
clientA.activate, clientB.activate, the existing cleanup constant, and the
try/finally so any exception from clientB.activate triggers the cleanup for
clientA via the finally block.