@moda-editor/core 0.1.3 → 0.1.5

package/dist/state/transaction.js

@@ -1,45 +1,31 @@
-import { firstTextPath, lastTextPath, nodeAt } from "../model/traverse.js";
-import { applyStep, computeSplitOps, mapThroughSplitOp, marksEq, } from "./apply.js";
-import { normalizeRange, pointEq, textSelection } from "./selection.js";
+import { nodeAt } from "../model/traverse.js";
+import { applyStep } from "./apply.js";
+import { deleteRange } from "./delete-ops.js";
+import { insertNodeInto, insertTextInto, newTextBlock, splitAt, } from "./insert-ops.js";
+import { applyInputRulesTo } from "./input-rules.js";
+import { liftItemOut, sinkItemUnder, splitItemInto } from "./list-ops.js";
+import { resolveInsert } from "./resolve-insert.js";
+import { normalizeRange } from "./selection.js";
+import { insertSliceInto } from "./slice-ops.js";
 // ── 구현 ────────────────────────────────────────────────────
-function pathEq(a, b) {
-    return a.length === b.length && a.every((v, i) => v === b[i]);
-}
 /**
  * 트랜잭션 빌더 — EditorState.tr()이 만든다.
- * delete() 지원 범위 (Phase 2):
- *   같은 노드 안 / 같은 부모 안 형제 / 같은 grandparent 아래 텍스트블록
- *   사이(anchor 블록에 focus 잔여 inline을 join). 더 깊은 중첩은 양끝
- *   trim만 하고 join 없이 둔다 — 스키마 검증과 함께 보강 예정.
- */
-/**
- * 삽입 위치에 상속할 마크 — PM의 MarkSpec.inclusive 관례.
- * 마크 run의 가장자리(앞뒤 이웃이 같은 마크를 갖지 않는 경계)에선
- * `inclusive: false` 마크를 뗀다 — code 마크 끝에서 타이핑이 스팬
- * 밖으로 나오도록. run 안쪽(중간 오프셋, 또는 이웃이 같은 마크인
- * 분할 경계)이면 그대로 이어받는다.
+ *
+ * 복잡한 연산은 전용 모듈에 위임하고 이 클래스는 스텝 큐와
+ * 좌표계(docNow)만 유지한다:
+ *   insert-ops.ts    — insertText/insertNode/split + 빈 블록 삽입
+ *   delete-ops.ts    — 임의 범위의 remove/insert 분해
+ *   list-ops.ts      — splitItem/liftItem/sinkItem
+ *   slice-ops.ts     — 붙여넣기 조각 삽입
+ *   input-rules.ts   — 마크다운식 입력 변환
+ *   resolve-insert.ts — DOM 포인트 → 삽입 좌표 정규화 (순수)
+ *
+ * 각 모듈은 호스트 인터페이스(ListOpsHost 등)로 이 빌더의 최소
+ * 표면만 받는다 — 순환 import 없이 빌더를 재사용한다.
  */
-function marksForInsert(state, doc, p) {
-    const node = nodeAt(doc, p.path);
-    const marks = node?.marks;
-    if (!marks?.length)
-        return marks;
-    const parent = nodeAt(doc, p.path.slice(0, -1));
-    const kids = parent?.content ?? [];
-    const idx = p.path[p.path.length - 1];
-    const has = (n, type) => !!n?.marks?.some((m) => m.type === type);
-    const len = node.text?.length ?? 0;
-    return marks.filter((m) => {
-        if (state.schema.markSpec(m.type)?.inclusive !== false)
-            return true;
-        if (p.offset === 0)
-            return has(kids[idx - 1], m.type);
-        if (p.offset === len)
-            return has(kids[idx + 1], m.type);
-        return true;
-    });
-}
 export class TransactionBuilder {
+    // state는 각 *OpsHost 계약의 일부 — 전용 연산 모듈들이
+    // 스키마를 조회할 수 있어야 한다. readonly라 외부 변경은 없다.
     constructor(state) {
         Object.defineProperty(this, "state", {
             enumerable: true,
@@ -83,275 +69,43 @@ export class TransactionBuilder {
      * PM 관례상 "직전 스텝까지 적용된 문서" 좌표다. tr.delete(sel) 뒤
      * insertText가 삭제된 노드를 가리키는 일이 없게 한다.
      */
+    // *OpsHost 계약 — 전용 연산 모듈들이 현재 문서를 읽는다
     docNow() {
         return (this.steps.length ? this.simulate() : this.doc);
     }
-    pushRemove(at, node) {
-        this.steps.push({ op: "remove", at, node });
-    }
-    /** atom 리프가 아닌 컨테이너인가 — content가 있거나 spec이 자식을 허용 */
-    isContainer(n) {
-        return (n.content !== undefined ||
-            !!this.state.schema.nodeSpec(n.type)?.content);
-    }
-    /** 컨테이너가 인라인 자식을 허용하는가 — 스키마 content 표현 기준 */
-    acceptsInline(n) {
-        return /inline/.test(this.state.schema.nodeSpec(n.type)?.content ?? "");
-    }
-    /**
-     * DOM 셀렉션에서 오는 임의 포인트를 텍스트 삽입 가능한 형태로 정규화한다.
-     * 브라우저는 캐럿을 컨테이너 경계(block 엘리먼트, doc 루트)나
-     * contenteditable=false 노드(atom) 안쪽에도 놓는다 — 그대로 insert하면
-     * doc 루트에 bare text 같은 잘못된 구조가 나온다.
-     *   - text    : 텍스트 노드 안 포인트 — 문자 오프셋 의미
-     *   - inside  : 인라인 전용 빈 컨테이너 — 텍스트 노드를 자식으로 삽입
-     *   - block   : 블록 경계 — paragraph로 감싼 블록을 삽입
-     */
+    /** 임의 포인트를 삽입 가능한 좌표로 정규화 (SliceOpsHost 계약) */
     resolveInsert(doc, p) {
-        const node = nodeAt(doc, p.path);
-        if (!node)
-            return { kind: "block", path: [], offset: 0 };
-        if (node.type === "text")
-            return { kind: "text", point: p };
-        if (!this.isContainer(node)) {
-            // atom 리프 — 오프셋은 의미가 없으므로 부모 경계(노드 뒤)로 올린다
-            const idx = p.path[p.path.length - 1];
-            if (idx == null)
-                return { kind: "block", path: [], offset: 0 };
-            return this.resolveInsert(doc, {
-                path: p.path.slice(0, -1),
-                offset: idx + 1,
-            });
-        }
-        const children = node.content ?? [];
-        // 앞으로 탐색 — 경계 뒤 첫 텍스트 후손의 시작
-        for (let i = p.offset; i < children.length; i++) {
-            const ftp = firstTextPath(children[i]);
-            if (ftp) {
-                return {
-                    kind: "text",
-                    point: { path: [...p.path, i, ...ftp], offset: 0 },
-                };
-            }
-        }
-        // 뒤로 탐색 — 경계 앞 마지막 텍스트의 끝
-        for (let i = Math.min(p.offset, children.length) - 1; i >= 0; i--) {
-            const ltp = lastTextPath(children[i]);
-            if (ltp) {
-                const len = nodeAt(children[i], ltp)?.text?.length ?? 0;
-                return {
-                    kind: "text",
-                    point: { path: [...p.path, i, ...ltp], offset: len },
-                };
-            }
-        }
-        // 텍스트 후손이 전혀 없다 — 인라인 블록이면 안에, 아니면 새 블록으로
-        if (p.path.length > 0 && this.acceptsInline(node)) {
-            return { kind: "inside", path: p.path, offset: p.offset };
-        }
-        return { kind: "block", path: p.path, offset: p.offset };
-    }
-    /** 기본 텍스트블록 타입 — paragraph, 없으면 inline을 받는 첫 block */
-    defaultBlockType() {
-        const spec = this.state.schema.spec.nodes;
-        return spec["paragraph"]
-            ? "paragraph"
-            : (Object.keys(spec).find((t) => spec[t].group?.split(" ").includes("block") &&
-                /inline/.test(spec[t].content ?? "")) ?? "paragraph");
+        return resolveInsert(this.state, doc, p);
     }
-    /** 텍스트를 담는 새 블록 — 스키마에 paragraph가 없으면 inline 블록을 찾는다 */
+    /** 텍스트를 담는 새 블록 — 스키마에 paragraph가 없으면 inline 블록을 찾는다 (SliceOpsHost 계약) */
     newTextBlock(children) {
-        return { type: this.defaultBlockType(), content: [...children] };
-    }
-    /** 블록 시작 셀렉션 — 텍스트 자식이 있으면 첫 텍스트 앞, 없으면 블록 안 */
-    selStartOfBlock(blockPath, block) {
-        const t = firstTextPath(block);
-        return textSelection(t
-            ? { path: [...blockPath, ...t], offset: 0 }
-            : { path: [...blockPath], offset: 0 });
-    }
-    /** 블록 경계에 새 빈 블록을 넣고 캐럿을 그 안에 둔다 */
-    insertEmptyBlock(insertAt, type) {
-        this.steps.push({
-            op: "insert",
-            at: insertAt,
-            node: type
-                ? { type, content: [] }
-                : this.newTextBlock([]),
-        });
-        this.selection = textSelection({
-            path: [...insertAt.path, insertAt.offset],
-            offset: 0,
-        });
-        return this;
+        return newTextBlock(this.state, children);
     }
+    /**
+     * 텍스트 삽입 — 구현은 insert-ops.ts. at이 없으면 현재 셀렉션
+     * (비축소면 먼저 삭제). 마크 우선순위와 code 블록 무시는
+     * insert-ops.ts의 규칙을 따른다.
+     */
     insertText(text, at) {
-        if (!text)
-            return this;
-        let target = at;
-        if (!target) {
-            const sel = this.selection ?? this.state.selection;
-            if (sel.type !== "text")
-                return this;
-            const r = normalizeRange(sel);
-            if (!pointEq(r.anchor, r.focus))
-                this.delete(r);
-            target = r.anchor;
-        }
-        const doc = this.docNow();
-        const t = this.resolveInsert(doc, target);
-        // 마크 우선순위: 이 tr에서 명시한 storedMarks → 이전 tr이 남긴
-        // state.storedMarks(툴바 토글 등) → 커서 위치 텍스트 마크
-        const marks = this.storedMarks ??
-            this.state.storedMarks ??
-            (t.kind === "text"
-                ? marksForInsert(this.state, doc, t.point)
-                : undefined);
-        const node = {
-            type: "text",
-            text,
-            ...(marks?.length ? { marks } : {}),
-        };
-        if (t.kind === "text") {
-            this.steps.push({ op: "insert", at: t.point, node });
-            this.selection = this.selectionAfterInsert(t.point, node, nodeAt(doc, t.point.path));
-            return this;
-        }
-        if (t.kind === "inside") {
-            const at2 = { path: t.path, offset: t.offset };
-            this.steps.push({ op: "insert", at: at2, node });
-            this.selection = textSelection({
-                path: [...t.path, t.offset],
-                offset: text.length,
-            });
-            return this;
-        }
-        // 블록 경계 — paragraph로 감싸 삽입 (전체 선택 후 타이핑 등)
-        const block = this.newTextBlock([node]);
-        const at2 = { path: t.path, offset: t.offset };
-        this.steps.push({ op: "insert", at: at2, node: block });
-        this.selection = textSelection({
-            path: [...t.path, t.offset, 0],
-            offset: text.length,
-        });
+        insertTextInto(this, text, at);
         return this;
     }
-    selectionAfterInsert(at, node, target) {
-        const len = node.text?.length ?? 0;
-        if (target?.type === "text") {
-            if (node.type === "text" && marksEq(target.marks, node.marks)) {
-                return textSelection({ path: at.path, offset: at.offset + len });
-            }
-            // 마크가 달라 [head?, 삽입, tail?]로 분할된다 — 삽입 노드는
-            // head가 있으면 idx+1, 없으면(맨 앞) idx에 놓인다. 캐럿은
-            // 삽입 노드 끝 — 끝 삽입에서 idx+2 같은 빈 경로를 만들면
-            // 안 된다 (회귀 — 다음 tr이 무효 경로를 block 폴백으로 해석)
-            const parent = at.path.slice(0, -1);
-            const idx = at.path[at.path.length - 1] + (at.offset > 0 ? 1 : 0);
-            return textSelection({ path: [...parent, idx], offset: len });
-        }
-        if (node.type === "text") {
-            return textSelection({ path: [...at.path, at.offset], offset: len });
-        }
-        return textSelection({ path: at.path, offset: at.offset + 1 });
-    }
+    /**
+     * 노드 삽입 — at에 그대로 넣고 캐럿은 삽입물 뒤에 둔다.
+     * 구현은 insert-ops.ts.
+     */
     insertNode(at, node) {
-        this.steps.push({ op: "insert", at, node });
-        this.selection = this.selectionAfterInsert(at, node, nodeAt(this.docNow(), at.path));
+        insertNodeInto(this, at, node);
         return this;
     }
     /**
      * at 위치에서 노드를 분할한다 (Enter). 생략하면 현재 셀렉션 —
      * 비어있지 않은 셀렉션이면 먼저 지운 뒤 분할한다.
      * 셀렉션은 분할된 "오른쪽" 부분의 시작으로 옮긴다.
+     * 구현은 insert-ops.ts — 비텍스트 포인트 환원과 splitExit 규칙을 포함한다.
      */
     split(at, depth = 1) {
-        let p = at;
-        if (!p) {
-            const sel = this.selection ?? this.state.selection;
-            if (sel.type !== "text")
-                return this;
-            const r = normalizeRange(sel);
-            if (!pointEq(r.anchor, r.focus))
-                this.delete(r);
-            p = r.anchor;
-        }
-        const doc = this.docNow();
-        if (nodeAt(doc, p.path)?.type !== "text") {
-            // 비텍스트 포인트 Enter — 인라인 컨테이너 경계면 가장 가까운
-            // 텍스트 위치로 환원해 정상 분할하고, 그 외(블록 컨테이너 경계,
-            // atom 안, 빈 블록)에는 그 자리에 새 빈 블록을 만든다.
-            const node = nodeAt(doc, p.path);
-            let insertAt = null;
-            if (node && this.isContainer(node) && this.acceptsInline(node)) {
-                const res = this.resolveInsert(doc, p);
-                if (res.kind === "text") {
-                    p = res.point;
-                }
-                else {
-                    // 빈 인라인 블록 — 뒤에 새 블록
-                    insertAt = {
-                        path: p.path.slice(0, -1),
-                        offset: p.path[p.path.length - 1] + 1,
-                    };
-                }
-            }
-            else if (node && this.isContainer(node)) {
-                // 블록 전용 컨테이너(doc 등) 경계 — 그 위치 그대로
-                insertAt = p;
-            }
-            else {
-                // atom/리프 안 — 노드 뒤 부모 경계
-                const idx = p.path[p.path.length - 1];
-                insertAt =
-                    idx == null
-                        ? p
-                        : { path: p.path.slice(0, -1), offset: idx + 1 };
-            }
-            if (insertAt)
-                return this.insertEmptyBlock(insertAt);
-        }
-        // 블록 "끝"에서의 Enter는 splitExit 타입의 블록을 새로 만든다 — PM
-        // 관례 (heading 끝 Enter → 다음 heading이 아니라 paragraph. 중간
-        // 분할은 타입을 유지한다). splitExit 미지정 블록은 기본 블록 타입으로.
-        const target = nodeAt(doc, p.path);
-        if (target?.type === "text" && p.path.length >= 2) {
-            const blockPath = p.path.slice(0, -1);
-            const block = nodeAt(doc, blockPath);
-            const lastIdx = (block?.content?.length ?? 0) - 1;
-            const atEnd = p.offset === (target.text ?? "").length &&
-                p.path[p.path.length - 1] === lastIdx;
-            const exitType = block
-                ? (this.state.schema.nodeSpec(block.type)?.splitExit ??
-                    this.defaultBlockType())
-                : undefined;
-            if (atEnd && block && exitType && exitType !== block.type) {
-                return this.insertEmptyBlock({
-                    path: blockPath.slice(0, -1),
-                    offset: blockPath[blockPath.length - 1] + 1,
-                }, exitType);
-            }
-        }
-        const step = { op: "split", at: p, depth };
-        this.steps.push(step);
-        const ops = computeSplitOps(doc, step);
-        let caret = null;
-        if (target?.type === "text") {
-            // 텍스트 분할 뒤 경계(= 오른쪽 텍스트 시작)를 만들어 나머지
-            // nodeSplit op들로 매핑 — 오른쪽 편향
-            caret = {
-                path: p.path.slice(0, -1),
-                offset: p.path[p.path.length - 1] + 1,
-            };
-            for (const op of ops.slice(1))
-                caret = mapThroughSplitOp(caret, op);
-        }
-        else {
-            caret = p;
-            for (const op of ops)
-                caret = mapThroughSplitOp(caret, op);
-        }
-        this.selection = textSelection(caret);
+        splitAt(this, at, depth);
         return this;
     }
     /**
@@ -360,73 +114,8 @@ export class TransactionBuilder {
      * caret은 아이템 안의 텍스트 포인트여야 한다.
      */
     splitItem(itemPath, caret) {
-        const doc = this.docNow();
-        const listPath = itemPath.slice(0, -1);
-        const k = itemPath[itemPath.length - 1];
-        const list = k == null ? undefined : nodeAt(doc, listPath);
-        const item = nodeAt(doc, itemPath);
-        if (!list?.content || !item?.content || k == null)
-            return this;
-        // caret = [...itemPath, childIdx, textIdx]/offset
-        const childIdx = caret.path[itemPath.length] ?? 0;
-        const child = item.content[childIdx];
-        const textIdx = caret.path[itemPath.length + 1] ?? 0;
-        const textNode = child?.content?.[textIdx];
-        const headText = textNode?.type === "text" ? (textNode.text ?? "").slice(0, caret.offset) : "";
-        const tailText = textNode?.type === "text" ? (textNode.text ?? "").slice(caret.offset) : "";
-        if (child && !childIdx && !textIdx && !headText) {
-            // 아이템 맨 앞 Enter — 빈 아이템을 위에 삽입 (PM liftEmptyItem과 유사)
-            const empty = {
-                type: item.type,
-                content: [{ type: child.type, content: [] }],
-            };
-            this.replaceNode(listPath, {
-                ...list,
-                content: [
-                    ...list.content.slice(0, k),
-                    empty,
-                    item,
-                    ...list.content.slice(k + 1),
-                ],
-            });
-            this.selection = this.selStartOfBlock([...listPath, k], empty);
-            return this;
-        }
-        const headChild = child
-            ? {
-                ...child,
-                content: [
-                    ...(child.content ?? []).slice(0, textIdx),
-                    ...(textNode ? [{ ...textNode, text: headText }] : []),
-                ],
-            }
-            : { type: this.defaultBlockType(), content: [] };
-        const tailChildContent = [
-            ...(textNode || tailText ? [{ type: "text", text: tailText }] : []),
-            ...(child?.content?.slice(textIdx + 1) ?? []),
-        ];
-        const tailChild = {
-            type: child?.type ?? this.defaultBlockType(),
-            content: tailChildContent,
-        };
-        const headItem = {
-            ...item,
-            content: [...item.content.slice(0, childIdx), headChild],
-        };
-        const tailItem = {
-            type: item.type,
-            content: [tailChild, ...item.content.slice(childIdx + 1)],
-        };
-        this.replaceNode(listPath, {
-            ...list,
-            content: [
-                ...list.content.slice(0, k),
-                headItem,
-                tailItem,
-                ...list.content.slice(k + 1),
-            ],
-        });
-        this.selection = this.selStartOfBlock([...listPath, k + 1], tailItem);
+        // 구현은 list-ops.ts — 빌더는 ListOpsHost 계약으로 스텝만 받는다
+        splitItemInto(this, this.docNow(), itemPath, caret);
         return this;
     }
     /**
@@ -436,89 +125,7 @@ export class TransactionBuilder {
      * 끼운다 (PM liftListItem 관례).
      */
     liftItem(itemPath) {
-        const doc = this.docNow();
-        const listPath = itemPath.slice(0, -1);
-        const k = itemPath[itemPath.length - 1];
-        const list = k == null ? undefined : nodeAt(doc, listPath);
-        const item = nodeAt(doc, itemPath);
-        const blocks = item?.content ?? [];
-        if (!list?.content ||
-            !item ||
-            !blocks.length ||
-            k == null ||
-            !listPath.length) {
-            return this;
-        }
-        const gPath = listPath.slice(0, -1);
-        const container = gPath.length ? nodeAt(doc, gPath) : undefined;
-        if (container && this.state.schema.nodeSpec(container.type)?.listItem) {
-            // 중첩 아이템 — 부모 li 안에 풀지 않고 바깥 리스트의 형제 li로 들어올린다.
-            // 뒤따르는 형제들은 들어올린 아이템의 서브리스트로 딸려 나간다(PM 관례)
-            const outerListPath = gPath.slice(0, -1);
-            const outerIdx = gPath[gPath.length - 1];
-            const subIdx = listPath[listPath.length - 1];
-            const trailing = list.content.slice(k + 1);
-            const before = list.content.slice(0, k);
-            const lifted = {
-                ...item,
-                content: trailing.length
-                    ? [...blocks, { type: list.type, content: trailing }]
-                    : blocks,
-            };
-            this.delete({
-                anchor: { path: listPath, offset: k },
-                focus: { path: listPath, offset: list.content.length },
-            });
-            if (!before.length) {
-                this.delete({
-                    anchor: { path: gPath, offset: subIdx },
-                    focus: { path: gPath, offset: subIdx + 1 },
-                });
-            }
-            this.insertNode({ path: outerListPath, offset: outerIdx + 1 }, lifted);
-            this.selection = this.selStartOfBlock([...outerListPath, outerIdx + 1, 0], blocks[0]);
-            return this;
-        }
-        const li = listPath[listPath.length - 1];
-        const len = list.content.length;
-        if (len === 1) {
-            // 유일한 아이템 — 리스트 통째를 아이템 블록들로 교체
-            this.delete({
-                anchor: { path: gPath, offset: li },
-                focus: { path: gPath, offset: li + 1 },
-            });
-            for (let i = 0; i < blocks.length; i++) {
-                this.insertNode({ path: gPath, offset: li + i }, blocks[i]);
-            }
-            this.selection = this.selStartOfBlock([...gPath, li], blocks[0]);
-            return this;
-        }
-        if (k === 0 || k === len - 1) {
-            // 머리 → 리스트 앞 / 꼬리 → 리스트 뒤
-            const out = k === 0 ? li : li + 1;
-            this.delete({
-                anchor: { path: listPath, offset: k },
-                focus: { path: listPath, offset: k + 1 },
-            });
-            for (let i = 0; i < blocks.length; i++) {
-                this.insertNode({ path: gPath, offset: out + i }, blocks[i]);
-            }
-            this.selection = this.selStartOfBlock([...gPath, out], blocks[0]);
-            return this;
-        }
-        // 중간 — 리스트를 [앞], 아이템 블록들, [뒤]로 쪼갠다
-        const listA = { ...list, content: list.content.slice(0, k) };
-        const listB = { ...list, content: list.content.slice(k + 1) };
-        this.delete({
-            anchor: { path: gPath, offset: li },
-            focus: { path: gPath, offset: li + 1 },
-        });
-        let off = li;
-        this.insertNode({ path: gPath, offset: off++ }, listA);
-        for (const b of blocks)
-            this.insertNode({ path: gPath, offset: off++ }, b);
-        this.insertNode({ path: gPath, offset: off }, listB);
-        this.selection = this.selStartOfBlock([...gPath, li + 1], blocks[0]);
+        liftItemOut(this, this.docNow(), itemPath);
         return this;
     }
     /**
@@ -526,47 +133,7 @@ export class TransactionBuilder {
      * 자식이 같은 타입 리스트면 그 끝에, 아니면 새 리스트를 만들어 넣는다.
      */
     sinkItem(itemPath) {
-        const doc = this.docNow();
-        const listPath = itemPath.slice(0, -1);
-        const k = itemPath[itemPath.length - 1];
-        const list = k == null ? undefined : nodeAt(doc, listPath);
-        const item = nodeAt(doc, itemPath);
-        if (!list?.content || !item || k == null || k === 0)
-            return this;
-        const prev = list.content[k - 1];
-        const prevContent = prev.content ?? [];
-        const last = prevContent[prevContent.length - 1];
-        let childIdx;
-        let subIdx;
-        let newPrev;
-        if (last?.type === list.type && last.content !== undefined) {
-            childIdx = prevContent.length - 1;
-            subIdx = last.content.length;
-            newPrev = {
-                ...prev,
-                content: [
-                    ...prevContent.slice(0, -1),
-                    { ...last, content: [...last.content, item] },
-                ],
-            };
-        }
-        else {
-            childIdx = prevContent.length;
-            subIdx = 0;
-            newPrev = {
-                ...prev,
-                content: [...prevContent, { type: list.type, content: [item] }],
-            };
-        }
-        this.replaceNode(listPath, {
-            ...list,
-            content: [
-                ...list.content.slice(0, k - 1),
-                newPrev,
-                ...list.content.slice(k + 1),
-            ],
-        });
-        this.selection = this.selStartOfBlock([...listPath, k - 1, childIdx, subIdx], item);
+        sinkItemUnder(this, this.docNow(), itemPath);
         return this;
     }
     replaceNode(path, node) {
@@ -583,153 +150,21 @@ export class TransactionBuilder {
         this.steps.push(step);
         return this;
     }
+    /** SliceOpsHost 계약 — 스키마 기준 인라인 노드 판정 */
     isInlineNode(n) {
         return n.type === "text" || this.state.schema.isInline(n.type);
     }
+    /** SliceOpsHost 계약 — 인라인만 담는 텍스트블록 판정 */
     isTextBlock(n) {
         return (!this.isInlineNode(n) &&
             (n.content ?? []).length > 0 &&
             (n.content ?? []).every((c) => this.isInlineNode(c)));
     }
     insertSlice(at, nodes) {
-        if (!nodes.length)
-            return this;
-        const doc = this.docNow();
-        if (nodeAt(doc, at.path)?.type !== "text") {
-            // 컨테이너 경계/atom 안 포인트 — 텍스트 위치로 해석해 수준을 맞춘다
-            const r = this.resolveInsert(doc, at);
-            if (r.kind === "text") {
-                at = r.point;
-            }
-            else if (r.kind === "inside") {
-                at = nodes.every((n) => this.isInlineNode(n))
-                    ? { path: r.path, offset: r.offset }
-                    : // 블록은 인라인 컨테이너 안에 못 넣는다 — 블록 뒤 경계로 승격
-                        {
-                            path: r.path.slice(0, -1),
-                            offset: r.path[r.path.length - 1] + 1,
-                        };
-            }
-            else {
-                const at2 = { path: r.path, offset: r.offset };
-                // doc 루트 등 블록 경계 — 인라인 조각은 paragraph로 감싼다
-                return nodes.every((n) => this.isInlineNode(n))
-                    ? this.insertBlockSlice(doc, at2, [this.newTextBlock(nodes)])
-                    : this.insertBlockSlice(doc, at2, nodes);
-            }
-        }
-        const target = nodeAt(doc, at.path);
-        // 문단 하나짜리 붙여넣기 — 인라인으로 풀어 삽입 (PM slice 관례)
-        if (nodes.length === 1 &&
-            target?.type === "text" &&
-            this.isTextBlock(nodes[0])) {
-            return this.insertInlineSlice(at, nodes[0].content ?? []);
-        }
-        if (nodes.every((n) => this.isInlineNode(n))) {
-            return this.insertInlineSlice(at, nodes);
-        }
-        return this.insertBlockSlice(doc, at, nodes);
-    }
-    /** 인라인 조각 — 텍스트를 o에서 나누고 사이에 끼운다 */
-    insertInlineSlice(at, nodes) {
-        const target = nodeAt(this.docNow(), at.path);
-        if (target?.type === "text") {
-            const parent = at.path.slice(0, -1);
-            const i = at.path[at.path.length - 1];
-            const len = target.text?.length ?? 0;
-            let base;
-            let caretAfter;
-            if (at.offset === 0) {
-                base = i;
-                caretAfter = { path: [...parent, i + nodes.length], offset: 0 };
-            }
-            else if (at.offset >= len) {
-                base = i + 1;
-                caretAfter = { path: [...parent, i + 1 + nodes.length], offset: 0 };
-            }
-            else {
-                this.steps.push({ op: "split", at, depth: 0 });
-                base = i + 1;
-                caretAfter = { path: [...parent, i + 1 + nodes.length], offset: 0 };
-            }
-            nodes.forEach((node, j) => {
-                this.steps.push({
-                    op: "insert",
-                    at: { path: parent, offset: base + j },
-                    node,
-                });
-            });
-            this.selection = textSelection(caretAfter);
-            return this;
-        }
-        // 컨테이너 경계
-        nodes.forEach((node, j) => {
-            this.steps.push({
-                op: "insert",
-                at: { path: at.path, offset: at.offset + j },
-                node,
-            });
-        });
-        this.selection = textSelection({
-            path: at.path,
-            offset: at.offset + nodes.length,
-        });
-        return this;
-    }
-    /** 블록 조각 — 현재 블록을 나누고 사이에 삽입 (doc 최상위 기준) */
-    insertBlockSlice(doc, at, nodes) {
-        const target = nodeAt(doc, at.path);
-        if (target?.type === "text") {
-            const bi = at.path[0];
-            if (bi == null)
-                return this;
-            // 텍스트 + 상위 체인을 전부 나눠 최상위 블록을 둘로 만든다
-            this.steps.push({ op: "split", at, depth: at.path.length - 1 });
-            const insertAt = bi + 1;
-            nodes.forEach((node, j) => {
-                this.steps.push({
-                    op: "insert",
-                    at: { path: [], offset: insertAt + j },
-                    node,
-                });
-            });
-            // 캐럿 = 오른쪽 부분 블록(bi+1+n)의 첫 텍스트, 없으면 마지막 삽입 끝
-            const sim = this.simulate();
-            const right = nodeAt(sim, [insertAt + nodes.length]);
-            const ftp = right ? firstTextPath(right) : null;
-            if (ftp) {
-                this.selection = textSelection({
-                    path: [insertAt + nodes.length, ...ftp],
-                    offset: 0,
-                });
-            }
-            else {
-                const last = nodes[nodes.length - 1];
-                const ltp = last ? lastTextPath(last) : null;
-                this.selection = ltp
-                    ? textSelection({
-                        path: [insertAt + nodes.length - 1, ...ltp],
-                        offset: (nodeAt(last, ltp)?.text ?? "").length,
-                    })
-                    : textSelection({ path: [insertAt], offset: 0 });
-            }
-            return this;
-        }
-        // 컨테이너 경계 — 같은 부모 안에 순서대로 삽입
-        nodes.forEach((node, j) => {
-            this.steps.push({
-                op: "insert",
-                at: { path: at.path, offset: at.offset + j },
-                node,
-            });
-        });
-        this.selection = textSelection({
-            path: at.path,
-            offset: at.offset + nodes.length,
-        });
+        insertSliceInto(this, at, nodes);
         return this;
     }
-    /** 지금까지 쌓인 스텝을 doc에 적용한 결과 — 캐럿 계산용 */
+    /** 지금까지 쌓인 스텝을 doc에 적용한 결과 — 캐럿 계산용 (SliceOpsHost 계약) */
     simulate() {
         let d = this.doc;
         for (const s of this.steps)
@@ -737,200 +172,24 @@ export class TransactionBuilder {
         return d;
     }
     /**
-     * 문서 순서 비교 — pointCmp와 다른 점: 컨테이너 경계 포인트를
-     * "자식 offset 앞"으로 해석한다. pointCmp는 [i]/k < [i,j]/m이지만
-     * 실제 문서 순서에선 [i]/k 는 k>j 이면 [i,j] 안쪽 "뒤"다 —
-     * DOM 셀렉션이 만드는 (블록엘리먼트, 자식인덱스) 포인트를 정렬할 때
-     * pointCmp를 쓰면 범위가 뒤집힌다.
+     * 범위 삭제 — 구현은 delete-ops.ts. anchor/focus 순서와 atom 경계를
+     * 정규화하고, LCA 레벨 삭제 + 양 끝 재귀 trim으로 임의 범위를
+     * remove/insert 스텝 열로 분해한다.
      */
-    docOrderCmp(a, b) {
-        const d = Math.min(a.path.length, b.path.length);
-        for (let i = 0; i < d; i++) {
-            if (a.path[i] !== b.path[i])
-                return a.path[i] - b.path[i];
-        }
-        if (a.path.length === b.path.length)
-            return a.offset - b.offset;
-        if (a.path.length < b.path.length) {
-            return b.path[a.path.length] < a.offset ? 1 : -1;
-        }
-        return a.path[b.path.length] < b.offset ? -1 : 1;
-    }
-    /** atom 리프 안 포인트를 부모 경계로 올린다 — dir>0이면 노드 "뒤" 경계 */
-    resolveBoundary(doc, p, dir) {
-        const node = nodeAt(doc, p.path);
-        if (!node || node.type === "text" || this.isContainer(node))
-            return p;
-        const idx = p.path[p.path.length - 1];
-        if (idx == null)
-            return p;
-        return {
-            path: p.path.slice(0, -1),
-            offset: idx + (dir > 0 ? 1 : 0),
-        };
-    }
     delete(range) {
-        const doc = this.docNow();
-        const fwd = this.docOrderCmp(range.anchor, range.focus) <= 0;
-        const a = this.resolveBoundary(doc, fwd ? range.anchor : range.focus, -1);
-        const f = this.resolveBoundary(doc, fwd ? range.focus : range.anchor, 1);
-        return this.deleteOrdered(doc, a, f);
-    }
-    /** a<f로 정렬 + atom 경계 해석이 끝난 범위 삭제 — 재귀용 내부 구현 */
-    deleteOrdered(doc, a, f) {
-        if (pointEq(a, f))
-            return this;
-        const aNode = nodeAt(doc, a.path);
-        const fNode = nodeAt(doc, f.path);
-        // 같은 노드 안
-        if (pathEq(a.path, f.path)) {
-            if (aNode?.type === "text") {
-                this.pushRemove(a, {
-                    type: "text",
-                    text: (aNode.text ?? "").slice(a.offset, f.offset),
-                    ...(aNode.marks && { marks: aNode.marks }),
-                });
-            }
-            else if (aNode?.content) {
-                for (let j = f.offset - 1; j >= a.offset; j--) {
-                    const child = aNode.content[j];
-                    if (child)
-                        this.pushRemove({ path: a.path, offset: j }, child);
-                }
-            }
-            return this.setSelection(textSelection(a));
-        }
-        const aParent = a.path.slice(0, -1);
-        const fParent = f.path.slice(0, -1);
-        // 같은 부모 안 형제 사이
-        if (pathEq(aParent, fParent)) {
-            if (fNode?.type === "text" && f.offset > 0) {
-                this.pushRemove({ path: f.path, offset: 0 }, {
-                    type: "text",
-                    text: fNode.text.slice(0, f.offset),
-                    ...(fNode.marks && { marks: fNode.marks }),
-                });
-            }
-            const ai = a.path[a.path.length - 1];
-            const fi = f.path[f.path.length - 1];
-            for (let j = fi - 1; j > ai; j--) {
-                const child = nodeAt(doc, [...aParent, j]);
-                if (child)
-                    this.pushRemove({ path: aParent, offset: j }, child);
-            }
-            if (aNode?.type === "text") {
-                const tail = (aNode.text ?? "").slice(a.offset);
-                if (tail) {
-                    this.pushRemove(a, {
-                        type: "text",
-                        text: tail,
-                        ...(aNode.marks && { marks: aNode.marks }),
-                    });
-                }
-            }
-            return this.setSelection(textSelection(a));
-        }
-        // 다른 블록 — 같은 grandparent 아래 텍스트블록 사이면 join한다
-        const aGrand = aParent.slice(0, -1);
-        const fGrand = fParent.slice(0, -1);
-        const joinable = pathEq(aGrand, fGrand) &&
-            aParent.length === fParent.length &&
-            aNode?.type === "text" &&
-            fNode?.type === "text";
-        if (joinable) {
-            const ai = aParent[aParent.length - 1];
-            const fi = fParent[fParent.length - 1];
-            const ti = a.path[a.path.length - 1];
-            const tj = f.path[f.path.length - 1];
-            const aBlock = nodeAt(doc, aParent);
-            const fBlock = nodeAt(doc, fParent);
-            // anchor 텍스트 tail 제거
-            const aTail = aNode.text.slice(a.offset);
-            if (aTail) {
-                this.pushRemove(a, {
-                    type: "text",
-                    text: aTail,
-                    ...(aNode.marks && { marks: aNode.marks }),
-                });
-            }
-            // anchor 블록의 뒤쪽 형제 제거 (desc)
-            const aSibs = aBlock.content ?? [];
-            for (let j = aSibs.length - 1; j > ti; j--) {
-                this.pushRemove({ path: aParent, offset: j }, aSibs[j]);
-            }
-            // focus 잔여분을 anchor 블록에 join
-            const fTail = fNode.text.slice(f.offset);
-            let insAt = ti + 1;
-            if (fTail) {
-                this.steps.push({
-                    op: "insert",
-                    at: { path: aParent, offset: insAt++ },
-                    node: {
-                        type: "text",
-                        text: fTail,
-                        ...(fNode.marks && { marks: fNode.marks }),
-                    },
-                });
-            }
-            const fSibs = fBlock.content ?? [];
-            for (let j = tj + 1; j < fSibs.length; j++) {
-                this.steps.push({
-                    op: "insert",
-                    at: { path: aParent, offset: insAt++ },
-                    node: fSibs[j],
-                });
-            }
-            // focus 블록 + 중간 블록 제거 (desc index — anchor는 항상 앞)
-            for (let j = fi; j > ai; j--) {
-                const blk = nodeAt(doc, [...aGrand, j]);
-                if (blk)
-                    this.pushRemove({ path: aGrand, offset: j }, blk);
-            }
-            return this.setSelection(textSelection(a));
-        }
-        // 일반화 — LCA 레벨에서 완전히 선택된 자식을 제거하고, 양 끝은
-        // 각각 "자식 끝까지"/"자식 처음부터" 범위로 재귀 trim한다.
-        // DOM 셀렉션이 만드는 경계↔내부 혼합 범위(전체 선택, atom 걸침)를 커버.
-        let l = 0;
-        const minLen = Math.min(a.path.length, f.path.length);
-        while (l < minLen && a.path[l] === f.path[l])
-            l++;
-        const lca = a.path.slice(0, l);
-        const aIn = a.path.length > l;
-        const fIn = f.path.length > l;
-        const aChild = aIn ? a.path[l] : a.offset;
-        const fChild = fIn ? f.path[l] : f.offset;
-        const remStart = aIn ? aChild + 1 : a.offset;
-        const remEnd = fIn ? fChild : f.offset;
-        // 끝쪽 부분 삭제 — f가 담긴 자식의 처음부터 f까지
-        if (fIn) {
-            this.deleteOrdered(doc, { path: [...lca, fChild], offset: 0 }, f);
-        }
-        // 시작쪽 부분 삭제 — a부터 a가 담긴 자식의 끝까지
-        // (텍스트 자식의 끝은 문자 길이, 컨테이너는 자식 수)
-        if (aIn) {
-            const aChildPath = [...lca, aChild];
-            const aChildNode = nodeAt(doc, aChildPath);
-            const endOffset = aChildNode?.type === "text"
-                ? (aChildNode.text?.length ?? 0)
-                : (aChildNode?.content?.length ?? 0);
-            this.deleteOrdered(doc, a, { path: aChildPath, offset: endOffset });
-        }
-        // 완전 삭제 구간 — LCA의 자식 [remStart, remEnd)을 역순으로
-        const lcaNode = nodeAt(doc, lca);
-        for (let j = remEnd - 1; j >= remStart; j--) {
-            const child = lcaNode?.content?.[j];
-            if (child)
-                this.pushRemove({ path: lca, offset: j }, child);
-        }
-        return this.setSelection(textSelection(a));
+        deleteRange(this, range);
+        return this;
     }
     addMark(range, mark) {
         this.steps.push({ op: "addMark", range: normalizeRange(range), mark });
         return this;
     }
     removeMark(range, markType) {
-        this.steps.push({ op: "removeMark", range: normalizeRange(range), markType });
+        this.steps.push({
+            op: "removeMark",
+            range: normalizeRange(range),
+            markType,
+        });
         return this;
     }
     setNodeAttr(path, key, value) {
@@ -947,66 +206,11 @@ export class TransactionBuilder {
         return this;
     }
     /**
-     * 입력 규칙 — 마크다운식 변환(`# `→heading, `**x**`→bold).
-     * 캐럿이 속한 인라인 블록의 블록 시작~커서 텍스트를 만들어 각
-     * 규칙의 pattern에 매칭한다. 매치가 커서에서 끝나는 첫 규칙이
-     * 이 tr 위에 변환 스텝을 쌓는다 — 위치는 docNow 좌표라 규칙
-     * 핸들러가 쌓은 스텝도 직전 스텝 기준으로 해석된다.
+     * 입력 규칙 — 구현은 input-rules.ts. 캐럿이 멈춘 텍스트블록의
+     * 블록 시작~커서 텍스트에 규칙을 순서대로 적용한다.
      */
     applyInputRules(rules) {
-        if (!rules.length)
-            return this;
-        const sel = this.selection ?? this.state.selection;
-        if (sel.type !== "text" || !pointEq(sel.anchor, sel.focus))
-            return this;
-        const doc = this.docNow();
-        const caret = sel.anchor;
-        const node = nodeAt(doc, caret.path);
-        if (node?.type !== "text")
-            return this;
-        const blockPath = caret.path.slice(0, -1);
-        const block = nodeAt(doc, blockPath);
-        if (!block?.content || !this.acceptsInline(block))
-            return this;
-        // 코드 블록 안에서는 마크다운 변환을 하지 않는다
-        if (this.state.schema.nodeSpec(block.type)?.code)
-            return this;
-        const kids = block.content;
-        const ci = caret.path[caret.path.length - 1];
-        // 블록 시작~커서의 인라인 텍스트 + 각 세그먼트의 절대 오프셋
-        let textBefore = "";
-        const segs = [];
-        for (let i = 0; i <= ci && i < kids.length; i++) {
-            const t = kids[i]?.text ?? "";
-            const take = i === ci ? Math.min(caret.offset, t.length) : t.length;
-            segs.push({ path: [...blockPath, i], start: textBefore.length, len: take });
-            textBefore += t.slice(0, take);
-        }
-        if (!textBefore)
-            return this;
-        // textBefore 절대 오프셋 → Point (끝은 항상 캐럿)
-        const toPoint = (pos) => {
-            for (const s of segs) {
-                if (!s.len)
-                    continue;
-                if (pos < s.start + s.len || pos === s.start) {
-                    return { path: s.path, offset: pos - s.start };
-                }
-            }
-            return caret;
-        };
-        for (const rule of rules) {
-            const m = rule.pattern.exec(textBefore);
-            if (!m)
-                continue;
-            const start = m.index;
-            const end = start + m[0].length;
-            if (end !== textBefore.length)
-                continue; // 커서에서 끝나는 매치만
-            const handled = rule.handler({ state: this.state, tr: this, dispatch: () => { } }, m, { anchor: toPoint(start), focus: caret }, doc);
-            if (handled !== false)
-                break;
-        }
+        applyInputRulesTo(this, rules);
         return this;
     }
     setMeta(key, value) {