@kimdayoun/hwpx-mcp 0.3.0 → 0.3.3

package/dist/HwpxDocument.js

@@ -9,9 +9,25 @@ const pako_1 = __importDefault(require("pako"));
 const HwpxParser_1 = require("./HwpxParser");
 const HangingIndentCalculator_1 = require("./HangingIndentCalculator");
 const MAX_UNDO_STACK_SIZE = 50;
+/**
+ * HWPX 텍스트 노드 `<hp:t>` / `<hs:t>` 전용 매처.
+ *
+ * `<(hp|hs):t([^>]*)>` 처럼 태그명 뒤 경계를 두지 않으면 `<hp:tc>`·`<hp:tr>`·
+ * `<hp:tbl>` 같은 형제 태그의 접두사까지 삼킨다. 그 상태로 본문을 지우면
+ * 셀 구조가 통째로 사라지고 닫는 태그만 남아 한/글이 파일을 열지 못한다.
+ * 뒤에 오는 문자가 공백·`/`·`>` 중 하나임을 강제해 태그명을 정확히 끊는다.
+ */
+const T_TAG_WITH_CONTENT = /<(hp|hs):t((?:\s[^>]*)?)>[\s\S]*?<\/\1:t>/g;
+const T_TAG_EMPTY = /<(hp|hs):t((?:\s[^>]*)?)><\/\1:t>/g;
 class HwpxDocument {
     constructor(id, path, zip, content, format) {
         this._isDirty = false;
+        /**
+         * True once the section element list has changed shape since the XML was
+         * parsed (insert/delete/copy/move of paragraphs, tables or images).
+         * Parsed XML offsets are unusable from that point until the next save.
+         */
+        this._structureChanged = false;
         this._undoStack = [];
         this._redoStack = [];
         this._pendingTextReplacements = [];
@@ -21,7 +37,13 @@ class HwpxDocument {
         this._pendingImageInserts = [];
         this._pendingCellImageInserts = [];
         this._pendingTableInserts = [];
-        this._tableInsertCounter = 0; // Counter for insertion order
+        /**
+         * Monotonic counter shared by paragraph and table inserts. Both kinds are
+         * replayed into XML in this order so each insert sees exactly the elements
+         * that existed when it was made. Replaying all tables before all paragraphs
+         * wrote "A, table, A-2, table" to disk as "A, A-2, table, table".
+         */
+        this._tableInsertCounter = 0;
         this._pendingImageDeletes = [];
         this._pendingTableDeletes = [];
         this._pendingParagraphDeletes = [];
@@ -127,7 +149,10 @@ class HwpxDocument {
                     elements: [{
                             type: 'paragraph',
                             data: {
-                                id: Math.random().toString(36).substring(2, 11),
+                                // Must match the id written into Contents/section0.xml below. Later
+                                // inserts anchor on this id; a random value here pointed at a node
+                                // that does not exist in the XML.
+                                id: '0',
                                 runs: [{ text: '' }],
                             },
                         }],
@@ -227,10 +252,20 @@ class HwpxDocument {
         zip.file('Contents/section0.xml', `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?><hs:sec xmlns:ha="http://www.hancom.co.kr/hwpml/2011/app" xmlns:hp="http://www.hancom.co.kr/hwpml/2011/paragraph" xmlns:hp10="http://www.hancom.co.kr/hwpml/2016/paragraph" xmlns:hs="http://www.hancom.co.kr/hwpml/2011/section" xmlns:hc="http://www.hancom.co.kr/hwpml/2011/core" xmlns:hh="http://www.hancom.co.kr/hwpml/2011/head" xmlns:hhs="http://www.hancom.co.kr/hwpml/2011/history" xmlns:hm="http://www.hancom.co.kr/hwpml/2011/master-page" xmlns:hpf="http://www.hancom.co.kr/schema/2011/hpf" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:opf="http://www.idpf.org/2007/opf/" xmlns:ooxmlchart="http://www.hancom.co.kr/hwpml/2016/ooxmlchart" xmlns:hwpunitchar="http://www.hancom.co.kr/hwpml/2016/HwpUnitChar" xmlns:epub="http://www.idpf.org/2007/ops" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0"><hp:p id="0" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="0"><hp:secPr id="" textDirection="HORIZONTAL" spaceColumns="1134" tabStop="8000" tabStopVal="4000" tabStopUnit="HWPUNIT" outlineShapeIDRef="1" memoShapeIDRef="0" textVerticalWidthHead="0" masterPageCnt="0"><hp:grid lineGrid="0" charGrid="0" wongoji="0"/><hp:startNum pageStartsOn="BOTH" page="0" pic="0" tbl="0" equation="0"/><hp:visibility hideFirstHeader="0" hideFirstFooter="0" hideFirstMasterPage="0" border="SHOW_ALL" fill="SHOW_ALL" hideFirstPageNum="0" hideFirstEmptyLine="0" showLineNumber="0"/><hp:pagePr landscape="0" width="59528" height="84188" gutterType="LEFT_ONLY"><hp:pageMar header="4252" footer="4252" left="8504" right="8504" top="5668" bottom="4252" gutter="0"/></hp:pagePr><hp:footNotePr><hp:autoNumFormat type="DIGIT"/><hp:noteLine length="-1" type="SOLID" width="0.12mm" color="#000000"/><hp:noteSpacing aboveLine="850" belowLine="567" betweenNotes="283"/><hp:numbering type="CONTINUOUS" newNum="1"/><hp:placement place="EACH_COLUMN" beneathText="0"/></hp:footNotePr><hp:endNotePr><hp:autoNumFormat type="DIGIT"/><hp:noteLine length="14692" type="SOLID" width="0.12mm" color="#000000"/><hp:noteSpacing aboveLine="850" belowLine="567" betweenNotes="0"/><hp:numbering type="CONTINUOUS" newNum="1"/><hp:placement place="END_OF_DOCUMENT" beneathText="0"/></hp:endNotePr></hp:secPr><hp:t></hp:t></hp:run></hp:p></hs:sec>`);
         // Create empty BinData folder
         zip.folder('BinData');
-        return new HwpxDocument(id, 'new-document.hwpx', zip, content, 'hwpx');
+        // A new document has no location on disk yet. Seeding a bare filename here
+        // made save_document resolve it against the server process cwd, so callers
+        // could not find the file they had just written.
+        return new HwpxDocument(id, '', zip, content, 'hwpx');
     }
     get id() { return this._id; }
     get path() { return this._path; }
+    /** True once the document has a real location on disk. */
+    get hasPath() { return this._path.length > 0; }
+    /**
+     * Record where the document now lives after a successful write, so the next
+     * save without an explicit path targets the same file.
+     */
+    setPath(newPath) { this._path = newPath; }
     get format() { return this._format; }
     get isDirty() { return this._isDirty; }
     get zip() { return this._zip; }
@@ -256,6 +291,8 @@ class HwpxDocument {
         const parsed = JSON.parse(state);
         this._content.sections = parsed.sections;
         this._content.metadata = parsed.metadata;
+        // Undo/redo swaps in a whole element list; parse-time offsets no longer apply.
+        this.markStructureChanged();
     }
     canUndo() { return this._undoStack.length > 0; }
     canRedo() { return this._redoStack.length > 0; }
@@ -322,6 +359,60 @@ class HwpxDocument {
         this._isDirty = true;
         this.invalidateReadingCache();
     }
+    /**
+     * Record that the section element list changed shape. Call from every method
+     * that inserts, removes, copies or moves a section-level element. Once set,
+     * paragraph edits stop trusting offsets cached at parse time and locate their
+     * target in the current XML instead.
+     */
+    markStructureChanged() {
+        this._structureChanged = true;
+    }
+    /**
+     * Resolve "after element N" into an id-based anchor using the memory model
+     * as it is right now (before the new element is spliced in).
+     *
+     * Returns null for "before everything" (N < 0). Elements without an XML
+     * paragraph/table of their own (images, shapes) are skipped backwards to the
+     * nearest paragraph or table, which is what the XML placement needs.
+     *
+     * The parser turns a paragraph that is only a line of ─/━/═ into an 'hr'
+     * element with a fresh id. That paragraph is still in the XML, so it still
+     * takes an occurrence slot there: skipping it here put later anchors one
+     * paragraph early (measured on Hancom files with divider lines).
+     */
+    resolveElementAnchor(sectionIndex, afterElementIndex) {
+        const elements = this._content.sections[sectionIndex]?.elements ?? [];
+        for (let i = Math.min(afterElementIndex, elements.length - 1); i >= 0; i--) {
+            const key = this.anchorKeyOf(elements[i]);
+            if (!key)
+                continue;
+            let occurrence = 0;
+            for (let j = 0; j < i; j++) {
+                const other = this.anchorKeyOf(elements[j]);
+                if (other && other.kind === key.kind && other.id === key.id)
+                    occurrence++;
+            }
+            return { ...key, occurrence };
+        }
+        return null;
+    }
+    /**
+     * The XML node a memory element stands for, or null if it has none of its
+     * own. An 'hr' parsed from a divider paragraph stands for that paragraph.
+     */
+    anchorKeyOf(el) {
+        if (!el)
+            return null;
+        if (el.type === 'hr') {
+            const src = el.data.sourceParagraphId;
+            return src ? { kind: 'paragraph', id: String(src) } : null;
+        }
+        if (el.type !== 'paragraph' && el.type !== 'table')
+            return null;
+        const id = String(el.data.id ?? '');
+        return id ? { kind: el.type, id } : null;
+    }
     // ============================================================
     // Content Access
     // ============================================================
@@ -389,6 +480,8 @@ class HwpxDocument {
                         index: ei,
                         text: el.data.runs.map(r => r.text).join(''),
                         style: el.data.paraStyle,
+                        paraPrIDRef: el.data.paraPrId,
+                        charPrIDRef: el.data.runs.find(r => r.charPrIDRef !== undefined)?.charPrIDRef,
                     });
                 }
             });
@@ -403,6 +496,9 @@ class HwpxDocument {
             text: para.runs.map(r => r.text).join(''),
             runs: para.runs,
             style: para.paraStyle,
+            // Raw header.xml references, so callers can build XML without scraping it.
+            paraPrIDRef: para.paraPrId,
+            charPrIDRef: para.runs.find(r => r.charPrIDRef !== undefined)?.charPrIDRef,
         };
     }
     updateParagraphText(sectionIndex, elementIndex, runIndex, text) {
@@ -436,6 +532,7 @@ class HwpxDocument {
                 elementIndex,
                 paragraphId: paragraph.id || '', // Use stable paragraph ID for reliable identification
                 paragraphOccurrence,
+                paragraph,
                 runIndex,
                 oldText,
                 newText: text
@@ -450,6 +547,7 @@ class HwpxDocument {
                             elementIndex,
                             paragraphId: paragraph.id || '',
                             paragraphOccurrence,
+                            paragraph,
                             runIndex: i,
                             oldText: otherOldText,
                             newText: '' // Clear other runs
@@ -530,6 +628,7 @@ class HwpxDocument {
                     elementIndex,
                     paragraphId: paragraph.id || '',
                     paragraphOccurrence,
+                    paragraph,
                     runIndex: i,
                     oldText: oldText || '',
                     newText: run.text
@@ -549,12 +648,17 @@ class HwpxDocument {
             id: paragraphId,
             runs: [{ text }],
         };
+        // Resolve the XML position before the new paragraph joins the element list.
+        const anchor = this.resolveElementAnchor(sectionIndex, afterElementIndex);
         const newElement = { type: 'paragraph', data: newParagraph };
         section.elements.splice(afterElementIndex + 1, 0, newElement);
+        this.markStructureChanged();
         // Add to pending list for XML sync
         this._pendingParagraphInserts.push({
             sectionIndex,
             afterElementIndex,
+            anchor,
+            insertOrder: this._tableInsertCounter++,
             paragraphId,
             text,
         });
@@ -578,6 +682,7 @@ class HwpxDocument {
         });
         // Remove from memory
         section.elements.splice(elementIndex, 1);
+        this.markStructureChanged();
         this.markModified();
         this.invalidateReadingCache();
         return true;
@@ -600,6 +705,7 @@ class HwpxDocument {
                     elementIndex,
                     paragraphId: paragraph.id || '', // Use stable paragraph ID
                     paragraphOccurrence,
+                    paragraph,
                     runIndex: lastRunIndex,
                     oldText,
                     newText
@@ -618,6 +724,7 @@ class HwpxDocument {
                     elementIndex,
                     paragraphId: paragraph.id || '', // Use stable paragraph ID
                     paragraphOccurrence,
+                    paragraph,
                     runIndex: 0,
                     oldText: '',
                     newText: text
@@ -1391,8 +1498,15 @@ class HwpxDocument {
             // Get previous value
             const cellData = this.getTableCell(tableInfo.section_index, tableInfo.local_index, position.row, position.col);
             const previousValue = cellData?.text || '';
-            // Update the cell
-            const updated = this.updateTableCell(tableInfo.section_index, tableInfo.local_index, position.row, position.col, value);
+            // Update the cell. A cell covered by a merge throws; treat it as a failed
+            // path rather than aborting the remaining entries.
+            let updated = false;
+            try {
+                updated = this.updateTableCell(tableInfo.section_index, tableInfo.local_index, position.row, position.col, value);
+            }
+            catch {
+                updated = false;
+            }
             if (updated) {
                 result.success++;
                 result.details.push({
@@ -1531,6 +1645,7 @@ class HwpxDocument {
         const result = {
             success: 0,
             outOfBounds: [],
+            failed: [],
             updated: [],
         };
         const tableInfo = this.convertGlobalToLocalTableIndex(tableIndex);
@@ -1555,8 +1670,16 @@ class HwpxDocument {
                 // Get previous value
                 const cellData = this.getTableCell(tableInfo.section_index, tableInfo.local_index, targetRow, targetCol);
                 const previousValue = cellData?.text || '';
-                // Update cell
-                const updated = this.updateTableCell(tableInfo.section_index, tableInfo.local_index, targetRow, targetCol, value);
+                // Update cell. A cell covered by a merge throws; record it and keep
+                // going so one merged position does not discard the whole batch.
+                let updated = false;
+                let failure = '';
+                try {
+                    updated = this.updateTableCell(tableInfo.section_index, tableInfo.local_index, targetRow, targetCol, value);
+                }
+                catch (err) {
+                    failure = err instanceof Error ? err.message : String(err);
+                }
                 if (updated) {
                     result.success++;
                     result.updated.push({
@@ -1566,6 +1689,14 @@ class HwpxDocument {
                         newValue: value,
                     });
                 }
+                else {
+                    result.failed.push({
+                        row: targetRow,
+                        col: targetCol,
+                        value,
+                        error: failure || 'Cell update failed',
+                    });
+                }
             }
         }
         return result;
@@ -1990,6 +2121,43 @@ class HwpxDocument {
             cell,
         };
     }
+    /**
+     * Find the merged cell that covers (row, col), if that position is not itself
+     * a master cell. A covered cell has no <hp:tc> of its own in the saved XML,
+     * so writing to it succeeds in memory and then silently vanishes on save.
+     */
+    findCoveringMergedCell(table, row, col) {
+        const rows = table.rows;
+        if (!rows)
+            return null;
+        const target = rows[row]?.cells?.[col];
+        if (target && ((target.colSpan ?? 1) > 1 || (target.rowSpan ?? 1) > 1)) {
+            return null; // the position is a master cell
+        }
+        // Merged cells can only originate at or before (row, col), and a table with
+        // no spans at all — the common case — exits on the first row scan.
+        for (let r = 0; r <= row && r < rows.length; r++) {
+            const cells = rows[r]?.cells;
+            if (!cells)
+                continue;
+            const lastCol = Math.min(col, cells.length - 1);
+            for (let c = 0; c <= lastCol; c++) {
+                const cell = cells[c];
+                if (!cell)
+                    continue;
+                const rowSpan = cell.rowSpan ?? 1;
+                const colSpan = cell.colSpan ?? 1;
+                if (rowSpan <= 1 && colSpan <= 1)
+                    continue;
+                if (r === row && c === col)
+                    continue;
+                if (row < r + rowSpan && col < c + colSpan) {
+                    return { row: r, col: c };
+                }
+            }
+        }
+        return null;
+    }
     updateTableCell(sectionIndex, tableIndex, row, col, text, charShapeId) {
         const table = this.findTable(sectionIndex, tableIndex);
         if (!table)
@@ -1997,6 +2165,12 @@ class HwpxDocument {
         const cell = table.rows[row]?.cells[col];
         if (!cell)
             return false;
+        // Refuse instead of reporting success and losing the text at save time.
+        const covering = this.findCoveringMergedCell(table, row, col);
+        if (covering) {
+            throw new Error(`Cell (${row}, ${col}) is covered by the merged cell at ` +
+                `(${covering.row}, ${covering.col}); write to the master cell instead`);
+        }
         // Track cell update for XML sync (works for both empty and non-empty cells)
         // Store table ID for reliable XML matching
         // charShapeId is optional - if provided, it will override the existing charPrIDRef
@@ -2099,6 +2273,7 @@ class HwpxDocument {
         });
         // Remove from memory model
         section.elements.splice(elementIndex, 1);
+        this.markStructureChanged();
         this.markModified();
         return true;
     }
@@ -2389,15 +2564,24 @@ class HwpxDocument {
         const srcElement = srcSection.elements[sourceParagraph];
         if (!srcElement || srcElement.type !== 'paragraph')
             return false;
+        const source = this.resolveElementAnchor(sourceSection, sourceParagraph);
+        if (!source)
+            return false;
+        const anchor = this.resolveElementAnchor(targetSection, targetAfter);
         this.saveState();
         const copy = JSON.parse(JSON.stringify(srcElement));
-        copy.data.id = Math.random().toString(36).substring(2, 11);
+        const paragraphId = Math.random().toString(36).substring(2, 11);
+        copy.data.id = paragraphId;
+        delete copy.data._xmlPosition;
         tgtSection.elements.splice(targetAfter + 1, 0, copy);
+        this.markStructureChanged();
         this._pendingParagraphCopies.push({
             sourceSection,
-            sourceParagraph,
             targetSection,
-            targetAfter,
+            source,
+            anchor,
+            paragraphId,
+            insertOrder: this._tableInsertCounter++,
         });
         this.markModified();
         return true;
@@ -2410,6 +2594,9 @@ class HwpxDocument {
         const srcElement = srcSection.elements[sourceParagraph];
         if (!srcElement || srcElement.type !== 'paragraph')
             return false;
+        const source = this.resolveElementAnchor(sourceSection, sourceParagraph);
+        if (!source)
+            return false;
         this.saveState();
         srcSection.elements.splice(sourceParagraph, 1);
         // Fix same-section index shift: if source was before target, adjust target down
@@ -2417,12 +2604,17 @@ class HwpxDocument {
         if (sourceSection === targetSection && sourceParagraph < targetAfter) {
             adjustedTargetAfter -= 1;
         }
+        // Resolve the destination now that the paragraph has left its old slot,
+        // matching the XML at replay time (source node removed, then re-inserted).
+        const anchor = this.resolveElementAnchor(targetSection, adjustedTargetAfter);
         tgtSection.elements.splice(adjustedTargetAfter + 1, 0, srcElement);
+        this.markStructureChanged();
         this._pendingParagraphMoves.push({
             sourceSection,
-            sourceParagraph,
             targetSection,
-            targetAfter,
+            source,
+            anchor,
+            insertOrder: this._tableInsertCounter++,
         });
         this.markModified();
         return true;
@@ -2587,8 +2779,11 @@ class HwpxDocument {
             rows: tableRows,
             width: defaultWidth,
         };
+        // Resolve the XML position before the new table joins the element list.
+        const anchor = this.resolveElementAnchor(sectionIndex, afterElementIndex);
         const newElement = { type: 'table', data: newTable };
         section.elements.splice(afterElementIndex + 1, 0, newElement);
+        this.markStructureChanged();
         // Calculate table index
         let tableIndex = 0;
         for (let i = 0; i <= afterElementIndex + 1; i++) {
@@ -2599,10 +2794,10 @@ class HwpxDocument {
             }
         }
         // Add to pending table inserts for XML generation
-        // Store the original afterElementIndex and insertOrder for proper sequencing
         this._pendingTableInserts.push({
             sectionIndex,
             afterElementIndex,
+            anchor,
             rows,
             cols,
             width: defaultWidth,
@@ -3115,6 +3310,7 @@ class HwpxDocument {
         // Add image element to section
         const newElement = { type: 'image', data: newImage };
         section.elements.splice(afterElementIndex + 1, 0, newElement);
+        this.markStructureChanged();
         // Add to pending inserts for XML sync
         this._pendingImageInserts.push({
             sectionIndex,
@@ -3295,6 +3491,7 @@ class HwpxDocument {
             const index = section.elements.findIndex(el => el.type === 'image' && el.data.id === imageId);
             if (index !== -1) {
                 section.elements.splice(index, 1);
+                this.markStructureChanged();
                 break;
             }
         }
@@ -3321,6 +3518,7 @@ class HwpxDocument {
         };
         const newElement = { type: 'line', data: newLine };
         section.elements.push(newElement);
+        this.markStructureChanged();
         this.markModified();
         return { id: lineId };
     }
@@ -3341,6 +3539,7 @@ class HwpxDocument {
         };
         const newElement = { type: 'rect', data: newRect };
         section.elements.push(newElement);
+        this.markStructureChanged();
         this.markModified();
         return { id: rectId };
     }
@@ -3361,6 +3560,7 @@ class HwpxDocument {
         };
         const newElement = { type: 'ellipse', data: newEllipse };
         section.elements.push(newElement);
+        this.markStructureChanged();
         this.markModified();
         return { id: ellipseId };
     }
@@ -3381,6 +3581,7 @@ class HwpxDocument {
         };
         const newElement = { type: 'equation', data: newEquation };
         section.elements.splice(afterElementIndex + 1, 0, newElement);
+        this.markStructureChanged();
         this.markModified();
         return { id: equationId };
     }
@@ -3643,10 +3844,20 @@ class HwpxDocument {
     async syncContentToZip() {
         if (!this._zip)
             return;
-        // Apply table inserts FIRST (other operations depend on tables existing in XML)
-        if (this._pendingTableInserts && this._pendingTableInserts.length > 0) {
-            await this.applyTableInsertsToXml();
+        // Replay paragraph/table inserts and paragraph copies/moves together, in
+        // call order, before any text update. Text updates resolve their target in
+        // the current XML, and other operations locate tables by index, so the
+        // structure must already match the memory model.
+        const hasStructuralEdits = this._pendingTableInserts.length > 0 ||
+            this._pendingParagraphInserts.length > 0 ||
+            this._pendingParagraphCopies.length > 0 ||
+            this._pendingParagraphMoves.length > 0;
+        if (hasStructuralEdits) {
+            await this.applyStructuralInsertsToXml();
             this._pendingTableInserts = [];
+            this._pendingParagraphInserts = [];
+            this._pendingParagraphCopies = [];
+            this._pendingParagraphMoves = [];
         }
         // Apply table deletes
         if (this._pendingTableDeletes && this._pendingTableDeletes.length > 0) {
@@ -3663,11 +3874,6 @@ class HwpxDocument {
             await this.applyTableMovesToXml();
             this._pendingTableMoves = [];
         }
-        // Apply paragraph inserts
-        if (this._pendingParagraphInserts && this._pendingParagraphInserts.length > 0) {
-            await this.applyParagraphInsertsToXml();
-            this._pendingParagraphInserts = [];
-        }
         // Apply table cell updates (preserves original XML structure)
         if (this._pendingTableCellUpdates && this._pendingTableCellUpdates.length > 0) {
             await this.applyTableCellUpdatesToXml();
@@ -3753,16 +3959,6 @@ class HwpxDocument {
             await this.applyTableColumnDeletesToXml();
             this._pendingTableColumnDeletes = [];
         }
-        // Apply paragraph copies
-        if (this._pendingParagraphCopies && this._pendingParagraphCopies.length > 0) {
-            await this.applyParagraphCopiesToXml();
-            this._pendingParagraphCopies = [];
-        }
-        // Apply paragraph moves
-        if (this._pendingParagraphMoves && this._pendingParagraphMoves.length > 0) {
-            await this.applyParagraphMovesToXml();
-            this._pendingParagraphMoves = [];
-        }
         // Apply header/footer updates
         if (this._pendingHeaderUpdates && this._pendingHeaderUpdates.length > 0 ||
             this._pendingFooterUpdates && this._pendingFooterUpdates.length > 0) {
@@ -3817,6 +4013,13 @@ class HwpxDocument {
      * The cached positions are populated during parsing in HwpxParser.parseSection().
      */
     getCachedXmlPosition(sectionIndex, elementIndex) {
+        // Cached offsets point into the section XML as it was when parsed. Once any
+        // element has been inserted, removed, copied or moved, the element index no
+        // longer names the same XML node and every earlier offset may have shifted.
+        // Using the cache then rewrites the wrong paragraph — measured: after
+        // copyParagraph on a reopened document, the edit landed on the original.
+        if (this._structureChanged)
+            return undefined;
         const section = this._content?.sections?.[sectionIndex];
         if (!section)
             return undefined;
@@ -4054,143 +4257,345 @@ class HwpxDocument {
         }
     }
     /**
-     * Apply table inserts to XML.
-     * Inserts new tables into the section XML.
+     * Find the end offset of the section-level element an insert anchors to.
+     *
+     * Paragraphs are matched by their own <hp:p id>. Tables are matched by
+     * <hp:tbl id>, either wrapped in a paragraph (the insert goes after that
+     * paragraph) or placed directly in the section (move_table writes them that
+     * way).
+     *
+     * The returned offset is always the end of a TOP-LEVEL element, because that
+     * is the only place a new section-level element may go. But paragraph
+     * occurrences are counted over exactly the paragraphs the parser puts in the
+     * memory model (see parsedParagraphStarts), so they agree with the occurrence
+     * resolveElementAnchor recorded. The parser also lifts paragraphs out of
+     * headers, text boxes and shapes; Hancom reuses id="0" / id="2147483648"
+     * there too. Counting only top-level paragraphs put 47 of 131 sampled Hancom
+     * files' copies and moves on the wrong paragraph.
+     *
+     * Returns -1 if the anchor is not present in the current XML.
+     */
+    findAnchorEnd(xml, anchor) {
+        const topLevel = this.findTopLevelFullElements(xml);
+        const idOf = (fragment) => fragment.slice(0, fragment.indexOf('>') + 1).match(/\bid="([^"]*)"/)?.[1];
+        if (anchor.kind === 'paragraph') {
+            const hit = this.findParsedParagraph(xml, anchor);
+            if (!hit)
+                return -1;
+            // The anchor may sit inside a header/shape; new content goes after the
+            // top-level element that contains it.
+            const owner = topLevel.find(el => el.startIndex <= hit.start && hit.start < el.endIndex);
+            return owner ? owner.endIndex : -1;
+        }
+        let seen = 0;
+        for (const el of topLevel) {
+            if (el.type === 'tbl') {
+                if (idOf(el.xml) !== anchor.id)
+                    continue;
+            }
+            else if (!this.wrapsTopLevelTable(el.xml, anchor.id)) {
+                continue;
+            }
+            if (seen === anchor.occurrence)
+                return el.endIndex;
+            seen++;
+        }
+        return -1;
+    }
+    /**
+     * The exact XML range of the memory paragraph a paragraph anchor names,
+     * found by id + occurrence among parsedParagraphStarts. For a paragraph in a
+     * header or text box this is that paragraph alone, not its container.
      */
-    async applyTableInsertsToXml() {
-        if (!this._zip)
-            return;
-        // Group inserts by section
-        const insertsBySection = new Map();
-        for (const insert of this._pendingTableInserts) {
-            const sectionInserts = insertsBySection.get(insert.sectionIndex) || [];
-            sectionInserts.push({
-                afterElementIndex: insert.afterElementIndex,
-                rows: insert.rows,
-                cols: insert.cols,
-                width: insert.width,
-                cellWidth: insert.cellWidth,
-                insertOrder: insert.insertOrder,
-                tableId: insert.tableId,
-            });
-            insertsBySection.set(insert.sectionIndex, sectionInserts);
+    findParsedParagraph(xml, anchor) {
+        let seen = 0;
+        for (const start of this.parsedParagraphStarts(xml)) {
+            const openEnd = xml.indexOf('>', start) + 1;
+            const id = xml.slice(start, openEnd).match(/\bid="([^"]*)"/)?.[1];
+            if (id !== anchor.id)
+                continue;
+            if (seen === anchor.occurrence) {
+                const end = this.findBalancedParagraphEnd(xml, start);
+                return end === -1 ? null : { start, end };
+            }
+            seen++;
         }
-        // Process each section
-        for (const [sectionIndex, inserts] of insertsBySection) {
-            const sectionPath = `Contents/section${sectionIndex}.xml`;
-            const file = this._zip.file(sectionPath);
-            if (!file)
+        return null;
+    }
+    /**
+     * Start offsets (in `xml`) of the paragraphs HwpxParser turns into memory
+     * paragraphs, in document order. Mirrors HwpxParser.parseSection:
+     *
+     *  - MEMO fields, footnotes and endnotes are ignored;
+     *  - paragraphs inside any table are skipped;
+     *  - a paragraph that holds a table is kept only if it still has <hp:t>
+     *    once its tables are removed.
+     *
+     * Offsets are mapped back to the original XML, so callers can slice it.
+     */
+    parsedParagraphStarts(xml) {
+        // Ranges the parser strips before it looks for paragraphs.
+        const hidden = [];
+        const hide = (re) => {
+            for (const m of xml.matchAll(re))
+                hidden.push([m.index, m.index + m[0].length]);
+        };
+        hide(/<hp:fieldBegin[^>]*type="MEMO"[^>]*>[\s\S]*?<\/hp:fieldBegin>/gi);
+        hide(/<hp:footNote\b[^>]*>[\s\S]*?<\/hp:footNote>/gi);
+        hide(/<hp:endNote\b[^>]*>[\s\S]*?<\/hp:endNote>/gi);
+        const isHidden = (pos) => hidden.some(([a, b]) => pos >= a && pos < b);
+        const tables = this.findAllTablesDeep(xml).filter(t => !isHidden(t.startIndex));
+        const inTable = (pos) => tables.some(t => pos > t.startIndex && pos < t.endIndex);
+        const starts = [];
+        for (const m of xml.matchAll(/<hp:p\b(?=[\s>])[^>]*>/g)) {
+            const start = m.index;
+            if (isHidden(start) || inTable(start))
                 continue;
-            let xml = await file.async('string');
-            // Get maximum id and instid for generating new ones
-            const idMatches = xml.matchAll(/id="(\d+)"/g);
-            let maxId = 0;
-            for (const m of idMatches) {
-                maxId = Math.max(maxId, parseInt(m[1], 10));
-            }
-            // Sort inserts by insertOrder (ascending) - process in the order they were added
-            // This ensures tables are inserted sequentially, building on each other
-            const sortedInserts = [...inserts].sort((a, b) => a.insertOrder - b.insertOrder);
-            for (const insert of sortedInserts) {
-                // Use the in-memory table ID for consistency with updateTableCell operations
-                const tableId = insert.tableId;
-                // Calculate row height based on standard settings
-                const rowHeight = 1000; // Default row height in hwpunit
-                const tableHeight = rowHeight * insert.rows;
-                // Build table XML
-                let tableXml = `<hp:tbl id="${tableId}" zOrder="0" numberingType="TABLE" textWrap="TOP_AND_BOTTOM" textFlow="BOTH_SIDES" lock="0" dropcapstyle="None" pageBreak="CELL" repeatHeader="0" rowCnt="${insert.rows}" colCnt="${insert.cols}" cellSpacing="0" borderFillIDRef="2" noAdjust="0">`;
-                tableXml += `<hp:sz width="${insert.width}" widthRelTo="ABSOLUTE" height="${tableHeight}" heightRelTo="ABSOLUTE" protect="0"/>`;
-                tableXml += `<hp:pos treatAsChar="1" affectLSpacing="0" flowWithText="1" allowOverlap="0" holdAnchorAndSO="0" vertRelTo="PARA" horzRelTo="PARA" vertAlign="TOP" horzAlign="LEFT" vertOffset="0" horzOffset="0"/>`;
-                tableXml += `<hp:outMargin left="141" right="141" top="141" bottom="141"/>`;
-                tableXml += `<hp:inMargin left="0" right="0" top="0" bottom="0"/>`;
-                // Generate rows
-                for (let r = 0; r < insert.rows; r++) {
-                    tableXml += `<hp:tr>`;
-                    for (let c = 0; c < insert.cols; c++) {
-                        maxId++;
-                        const cellParaId = maxId;
-                        tableXml += `<hp:tc name="" header="0" hasMargin="0" protect="0" editable="0" dirty="0" borderFillIDRef="2">`;
-                        tableXml += `<hp:subList id="" textDirection="HORIZONTAL" lineWrap="BREAK" vertAlign="CENTER" linkListIDRef="0" linkListNextIDRef="0" textWidth="0" textHeight="0" hasTextRef="0" hasNumRef="0">`;
-                        tableXml += `<hp:p id="${cellParaId}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`;
-                        tableXml += `<hp:run charPrIDRef="0"><hp:t></hp:t></hp:run>`;
-                        tableXml += `</hp:p>`;
-                        tableXml += `</hp:subList>`;
-                        tableXml += `<hp:cellAddr colAddr="${c}" rowAddr="${r}"/>`;
-                        tableXml += `<hp:cellSpan colSpan="1" rowSpan="1"/>`;
-                        tableXml += `<hp:cellSz width="${insert.cellWidth}" height="${rowHeight}"/>`;
-                        tableXml += `<hp:cellMargin left="141" right="141" top="141" bottom="141"/>`;
-                        tableXml += `</hp:tc>`;
-                    }
-                    tableXml += `</hp:tr>`;
-                }
-                tableXml += `</hp:tbl>`;
-                // Find the position to insert the table
-                // We need to insert after a paragraph element
-                // Find all <hp:p> elements at the root level (not inside tables)
-                const paragraphMatches = [...xml.matchAll(/<hp:p\s[^>]*>.*?<\/hp:p>/gs)];
-                // Filter to find only top-level paragraphs (not inside <hp:tbl> or <hp:subList>)
-                // For simplicity, insert after the first paragraph if afterElementIndex is 0
-                // or find the appropriate position
-                let insertPosition = -1;
-                let elementCount = -1;
-                let searchPos = 0;
-                // Find paragraphs and tables at root level using balanced bracket matching
-                while (searchPos < xml.length) {
-                    // Look for next <hp:p or <hp:tbl
-                    const nextP = xml.indexOf('<hp:p ', searchPos);
-                    const nextTbl = xml.indexOf('<hp:tbl ', searchPos);
-                    let nextPos = -1;
-                    let isTable = false;
-                    if (nextP !== -1 && (nextTbl === -1 || nextP < nextTbl)) {
-                        nextPos = nextP;
-                        isTable = false;
-                    }
-                    else if (nextTbl !== -1) {
-                        nextPos = nextTbl;
-                        isTable = true;
-                    }
-                    if (nextPos === -1)
-                        break;
-                    // Check if this is inside a subList (nested)
-                    const beforeText = xml.substring(Math.max(0, nextPos - HwpxDocument.NESTED_CHECK_LOOKBACK), nextPos);
-                    const subListOpen = beforeText.lastIndexOf('<hp:subList');
-                    const subListClose = beforeText.lastIndexOf('</hp:subList>');
-                    const isNested = subListOpen > subListClose;
-                    if (!isNested) {
-                        elementCount++;
-                        // Find the end of this element using balanced bracket matching
-                        const endPos = isTable
-                            ? HwpxDocument.findClosingTagPosition(xml, nextPos + 1, '<hp:tbl', '</hp:tbl>')
-                            : HwpxDocument.findClosingTagPosition(xml, nextPos + 1, '<hp:p ', '</hp:p>');
-                        if (endPos === -1) {
-                            searchPos = nextPos + HwpxDocument.SEARCH_SKIP_OFFSET;
-                            continue;
-                        }
-                        if (elementCount === insert.afterElementIndex) {
-                            insertPosition = endPos;
-                            break;
-                        }
-                        searchPos = endPos;
-                    }
-                    else {
-                        searchPos = nextPos + HwpxDocument.SEARCH_SKIP_OFFSET;
-                    }
+            const end = this.findBalancedParagraphEnd(xml, start);
+            if (end === -1)
+                continue;
+            // Remove only the outermost tables in this paragraph. A nested table
+            // is already inside one of them; cutting it again with its original
+            // offsets would slice the wrong text out of the shortened string.
+            const own = tables.filter(t => t.startIndex >= start && t.endIndex <= end &&
+                !tables.some(o => o !== t && o.startIndex >= start && o.startIndex < t.startIndex && o.endIndex > t.endIndex));
+            if (own.length > 0) {
+                let rest = xml.slice(start, end);
+                for (const t of [...own].sort((a, b) => b.startIndex - a.startIndex)) {
+                    rest = rest.slice(0, t.startIndex - start) + rest.slice(t.endIndex - start);
+                }
+                if (!/<hp:t\b[^>]*>/.test(rest))
+                    continue;
+            }
+            starts.push(start);
+        }
+        return starts;
+    }
+    /** Every <hp:tbl> range at any depth (outer tables before their nested ones). */
+    findAllTablesDeep(xml) {
+        const out = [];
+        for (const m of xml.matchAll(/<hp:tbl\b/g)) {
+            let depth = 1;
+            let pos = m.index + 7;
+            while (depth > 0 && pos < xml.length) {
+                const nextOpen = xml.indexOf('<hp:tbl', pos);
+                const nextClose = xml.indexOf('</hp:tbl>', pos);
+                if (nextClose === -1)
+                    break;
+                if (nextOpen !== -1 && nextOpen < nextClose) {
+                    depth++;
+                    pos = nextOpen + 7;
                 }
-                // If position not found, insert at end of section (before </hs:sec>)
-                if (insertPosition === -1) {
-                    const secEnd = xml.lastIndexOf('</hs:sec>');
-                    if (secEnd !== -1) {
-                        insertPosition = secEnd;
-                    }
+                else {
+                    depth--;
+                    pos = nextClose + 9;
+                }
+            }
+            if (depth === 0)
+                out.push({ startIndex: m.index, endIndex: pos });
+        }
+        return out;
+    }
+    /** End offset of the paragraph opening at `start`, counting nested <hp:p>. */
+    findBalancedParagraphEnd(xml, start) {
+        const openRe = /<hp:p\b(?=[\s>/])[^>]*>/g;
+        let depth = 0;
+        let pos = start;
+        while (pos < xml.length) {
+            openRe.lastIndex = pos;
+            const open = openRe.exec(xml);
+            const close = xml.indexOf('</hp:p>', pos);
+            if (close === -1)
+                return -1;
+            if (open && open.index < close) {
+                if (!open[0].endsWith('/>'))
+                    depth++;
+                pos = open.index + open[0].length;
+            }
+            else {
+                depth--;
+                pos = close + 7;
+                if (depth === 0)
+                    return pos;
+            }
+        }
+        return -1;
+    }
+    /** True if this paragraph directly (not via a nested table) holds <hp:tbl id>. */
+    wrapsTopLevelTable(paragraphXml, tableId) {
+        const escaped = tableId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const match = paragraphXml.match(new RegExp(`<(?:hp|hs|hc):tbl\\b[^>]*\\bid="${escaped}"`));
+        if (!match || match.index === undefined)
+            return false;
+        const before = paragraphXml.slice(0, match.index);
+        const opens = (before.match(/<(?:hp|hs|hc):tbl\b/g) || []).length;
+        const closes = (before.match(/<\/(?:hp|hs|hc):tbl>/g) || []).length;
+        return opens === closes;
+    }
+    /**
+     * Offset for an insert with no anchor ("before everything"). The first
+     * paragraph carries <hp:secPr> (page and section settings) and must stay
+     * first, so new content goes right after it.
+     */
+    findSectionHeadEnd(xml) {
+        const topLevel = this.findTopLevelFullElements(xml);
+        const first = topLevel.find(el => el.type === 'p');
+        if (first)
+            return first.endIndex;
+        const secOpen = xml.match(/<(?:hs|hp):sec[^>]*>/);
+        return secOpen && secOpen.index !== undefined ? secOpen.index + secOpen[0].length : -1;
+    }
+    /** Build the XML for a table inserted by insertTable, wrapped in its own paragraph. */
+    buildInsertedTableXml(insert, nextId) {
+        const rowHeight = 1000; // hwpunit
+        const tableHeight = rowHeight * insert.rows;
+        let tableXml = `<hp:tbl id="${insert.tableId}" zOrder="0" numberingType="TABLE" textWrap="TOP_AND_BOTTOM" textFlow="BOTH_SIDES" lock="0" dropcapstyle="None" pageBreak="CELL" repeatHeader="0" rowCnt="${insert.rows}" colCnt="${insert.cols}" cellSpacing="0" borderFillIDRef="2" noAdjust="0">`;
+        tableXml += `<hp:sz width="${insert.width}" widthRelTo="ABSOLUTE" height="${tableHeight}" heightRelTo="ABSOLUTE" protect="0"/>`;
+        tableXml += `<hp:pos treatAsChar="1" affectLSpacing="0" flowWithText="1" allowOverlap="0" holdAnchorAndSO="0" vertRelTo="PARA" horzRelTo="PARA" vertAlign="TOP" horzAlign="LEFT" vertOffset="0" horzOffset="0"/>`;
+        tableXml += `<hp:outMargin left="141" right="141" top="141" bottom="141"/>`;
+        // Cells below use hasMargin="0", which tells Hancom to pad them with this
+        // table-level inMargin and ignore their own cellMargin. A zero inMargin put
+        // text flush against the cell border (measured 0pt). 510/510/141/141 is the
+        // most common value in Hancom-saved tables (1,868 surveyed).
+        tableXml += `<hp:inMargin left="510" right="510" top="141" bottom="141"/>`;
+        for (let r = 0; r < insert.rows; r++) {
+            tableXml += `<hp:tr>`;
+            for (let c = 0; c < insert.cols; c++) {
+                tableXml += `<hp:tc name="" header="0" hasMargin="0" protect="0" editable="0" dirty="0" borderFillIDRef="2">`;
+                tableXml += `<hp:subList id="" textDirection="HORIZONTAL" lineWrap="BREAK" vertAlign="CENTER" linkListIDRef="0" linkListNextIDRef="0" textWidth="0" textHeight="0" hasTextRef="0" hasNumRef="0">`;
+                tableXml += `<hp:p id="${nextId()}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`;
+                tableXml += `<hp:run charPrIDRef="0"><hp:t></hp:t></hp:run>`;
+                tableXml += `</hp:p>`;
+                tableXml += `</hp:subList>`;
+                tableXml += `<hp:cellAddr colAddr="${c}" rowAddr="${r}"/>`;
+                tableXml += `<hp:cellSpan colSpan="1" rowSpan="1"/>`;
+                tableXml += `<hp:cellSz width="${insert.cellWidth}" height="${rowHeight}"/>`;
+                tableXml += `<hp:cellMargin left="510" right="510" top="141" bottom="141"/>`;
+                tableXml += `</hp:tc>`;
+            }
+            tableXml += `</hp:tr>`;
+        }
+        tableXml += `</hp:tbl>`;
+        return `<hp:p id="${nextId()}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="0">${tableXml}<hp:t></hp:t></hp:run></hp:p>`;
+    }
+    /**
+     * Replay structural edits — paragraph/table inserts and paragraph
+     * copies/moves — into the section XML in the order the calls were made.
+     *
+     * Every edit carries id-based anchors resolved at call time, so it lands
+     * after the same element in the XML that it followed in memory. Replaying in
+     * call order means each anchor already exists (or has already moved) by the
+     * time a later edit needs it. Copies/moves may cross sections, so all
+     * touched sections are held in memory and written once at the end.
+     */
+    async applyStructuralInsertsToXml() {
+        if (!this._zip)
+            return;
+        const edits = [
+            ...this._pendingParagraphInserts.map(i => ({
+                kind: 'paragraph', order: i.insertOrder, sectionIndex: i.sectionIndex,
+                anchor: i.anchor, paragraphId: i.paragraphId, text: i.text,
+            })),
+            ...this._pendingTableInserts.map(i => ({
+                kind: 'table', order: i.insertOrder, sectionIndex: i.sectionIndex,
+                anchor: i.anchor, rows: i.rows, cols: i.cols, width: i.width,
+                cellWidth: i.cellWidth, tableId: i.tableId,
+            })),
+            ...this._pendingParagraphCopies.map(c => ({
+                kind: 'copy', order: c.insertOrder, sectionIndex: c.targetSection,
+                sourceSection: c.sourceSection, source: c.source, anchor: c.anchor, paragraphId: c.paragraphId,
+            })),
+            ...this._pendingParagraphMoves.map(m => ({
+                kind: 'move', order: m.insertOrder, sectionIndex: m.targetSection,
+                sourceSection: m.sourceSection, source: m.source, anchor: m.anchor,
+            })),
+        ].sort((a, b) => a.order - b.order);
+        if (edits.length === 0)
+            return;
+        const sections = new Map();
+        const load = async (index) => {
+            if (sections.has(index))
+                return sections.get(index);
+            const file = this._zip.file(`Contents/section${index}.xml`);
+            if (!file)
+                return undefined;
+            const xml = await file.async('string');
+            sections.set(index, xml);
+            return xml;
+        };
+        // Numeric ids for generated cell/wrapper paragraphs must not collide.
+        const maxIdBySection = new Map();
+        const nextIdFor = (index, xml) => {
+            if (!maxIdBySection.has(index)) {
+                let maxId = 0;
+                for (const m of xml.matchAll(/\bid="(\d+)"/g)) {
+                    const n = parseInt(m[1], 10);
+                    if (n < 2147483648 && n > maxId)
+                        maxId = n;
+                }
+                maxIdBySection.set(index, maxId);
+            }
+            return () => {
+                const next = maxIdBySection.get(index) + 1;
+                maxIdBySection.set(index, next);
+                return next;
+            };
+        };
+        const placeAfter = (xml, anchor) => {
+            const position = anchor ? this.findAnchorEnd(xml, anchor) : this.findSectionHeadEnd(xml);
+            if (position !== -1)
+                return position;
+            // The anchor vanished (e.g. deleted later in the same session) —
+            // append rather than drop the user's content.
+            return Math.max(xml.lastIndexOf('</hs:sec>'), xml.lastIndexOf('</hp:sec>'));
+        };
+        for (const edit of edits) {
+            if (edit.kind === 'copy' || edit.kind === 'move') {
+                const srcXml = await load(edit.sourceSection);
+                if (srcXml === undefined)
+                    continue;
+                // Only a section-level paragraph can be copied or moved as a unit; a
+                // paragraph inside a header or text box would drag its container along.
+                const found = this.findParsedParagraph(srcXml, edit.source);
+                if (!found)
+                    continue;
+                const srcEl = this.findTopLevelFullElements(srcXml)
+                    .find(el => el.type === 'p' && el.startIndex === found.start && el.endIndex === found.end);
+                if (!srcEl)
+                    continue;
+                let fragment = srcEl.xml;
+                if (edit.kind === 'copy') {
+                    // Same id as the memory copy, so later edits anchored on it find it.
+                    fragment = fragment.replace(/^<(hp|hs):p\b([^>]*?)\bid="[^"]*"/, `<$1:p$2id="${edit.paragraphId}"`);
+                    // The clone inherits the source's fixed <hp:lineseg> geometry; reset
+                    // it so replacement text of a different length does not overlap.
+                    fragment = this.resetLinesegInXml(fragment);
                 }
-                if (insertPosition !== -1) {
-                    // Wrap table in a paragraph for proper positioning
-                    const wrapperXml = `<hp:p id="${maxId + 1}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="0">${tableXml}<hp:t></hp:t></hp:run></hp:p>`;
-                    maxId++;
-                    xml = xml.substring(0, insertPosition) + wrapperXml + xml.substring(insertPosition);
+                else {
+                    sections.set(edit.sourceSection, srcXml.slice(0, srcEl.startIndex) + srcXml.slice(srcEl.endIndex));
                 }
+                const tgtXml = await load(edit.sectionIndex);
+                if (tgtXml === undefined)
+                    continue;
+                const position = placeAfter(tgtXml, edit.anchor);
+                if (position === -1)
+                    continue;
+                sections.set(edit.sectionIndex, tgtXml.slice(0, position) + fragment + tgtXml.slice(position));
+                continue;
             }
-            this._zip.file(sectionPath, xml);
+            const xml = await load(edit.sectionIndex);
+            if (xml === undefined)
+                continue;
+            const position = placeAfter(xml, edit.anchor);
+            if (position === -1)
+                continue;
+            const newXml = edit.kind === 'paragraph'
+                ? `<hp:p id="${edit.paragraphId}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="0"><hp:t>${this.escapeXml(edit.text)}</hp:t></hp:run></hp:p>`
+                : this.buildInsertedTableXml(edit, nextIdFor(edit.sectionIndex, xml));
+            sections.set(edit.sectionIndex, xml.slice(0, position) + newXml + xml.slice(position));
+        }
+        for (const [index, xml] of sections) {
+            this._zip.file(`Contents/section${index}.xml`, xml);
         }
     }
     /**
@@ -4330,111 +4735,6 @@ class HwpxDocument {
         // Return position after the element at afterIndex
         return elements[afterIndex].end;
     }
-    /**
-     * Apply paragraph inserts to XML.
-     * Inserts new paragraphs at the specified positions.
-     */
-    async applyParagraphInsertsToXml() {
-        if (!this._zip)
-            return;
-        // Group inserts by section
-        const insertsBySection = new Map();
-        for (const insert of this._pendingParagraphInserts) {
-            const sectionInserts = insertsBySection.get(insert.sectionIndex) || [];
-            sectionInserts.push({
-                afterElementIndex: insert.afterElementIndex,
-                paragraphId: insert.paragraphId,
-                text: insert.text,
-            });
-            insertsBySection.set(insert.sectionIndex, sectionInserts);
-        }
-        // Process each section
-        for (const [sectionIndex, inserts] of insertsBySection) {
-            const sectionPath = `Contents/section${sectionIndex}.xml`;
-            const file = this._zip.file(sectionPath);
-            if (!file)
-                continue;
-            let xml = await file.async('string');
-            // Sort inserts by afterElementIndex in ascending order
-            // This ensures each insert happens at the correct position as XML grows
-            const sortedInserts = [...inserts].sort((a, b) => a.afterElementIndex - b.afterElementIndex);
-            for (const insert of sortedInserts) {
-                // Escape text for XML
-                const escapedText = this.escapeXml(insert.text);
-                // Build paragraph XML
-                const paragraphXml = `<hp:p id="${insert.paragraphId}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="0"><hp:t>${escapedText}</hp:t></hp:run></hp:p>`;
-                // Find the position to insert
-                let insertPosition = -1;
-                let elementCount = -1;
-                let searchPos = 0;
-                // Find paragraphs and tables at root level using balanced bracket matching
-                while (searchPos < xml.length) {
-                    // Look for next <hp:p or <hp:tbl
-                    const nextP = xml.indexOf('<hp:p ', searchPos);
-                    const nextTbl = xml.indexOf('<hp:tbl ', searchPos);
-                    let nextPos = -1;
-                    let isTable = false;
-                    if (nextP !== -1 && (nextTbl === -1 || nextP < nextTbl)) {
-                        nextPos = nextP;
-                        isTable = false;
-                    }
-                    else if (nextTbl !== -1) {
-                        nextPos = nextTbl;
-                        isTable = true;
-                    }
-                    if (nextPos === -1)
-                        break;
-                    // Check if this is inside a subList (nested)
-                    const beforeText = xml.substring(Math.max(0, nextPos - HwpxDocument.NESTED_CHECK_LOOKBACK), nextPos);
-                    const subListOpen = beforeText.lastIndexOf('<hp:subList');
-                    const subListClose = beforeText.lastIndexOf('</hp:subList>');
-                    const isNested = subListOpen > subListClose;
-                    if (!isNested) {
-                        elementCount++;
-                        // Find the end of this element using balanced bracket matching
-                        const endPos = isTable
-                            ? HwpxDocument.findClosingTagPosition(xml, nextPos + 1, '<hp:tbl', '</hp:tbl>')
-                            : HwpxDocument.findClosingTagPosition(xml, nextPos + 1, '<hp:p ', '</hp:p>');
-                        if (endPos === -1) {
-                            searchPos = nextPos + HwpxDocument.SEARCH_SKIP_OFFSET;
-                            continue;
-                        }
-                        if (elementCount === insert.afterElementIndex) {
-                            insertPosition = endPos;
-                            break;
-                        }
-                        searchPos = endPos;
-                    }
-                    else {
-                        searchPos = nextPos + HwpxDocument.SEARCH_SKIP_OFFSET;
-                    }
-                }
-                // If afterElementIndex is -1, insert after the first paragraph (which contains secPr)
-                // IMPORTANT: <hp:secPr> must remain in the first paragraph for the document to be valid
-                if (insert.afterElementIndex === -1) {
-                    // Find the end of the first <hp:p> element (which contains <hp:secPr>)
-                    const firstPStart = xml.indexOf('<hp:p');
-                    if (firstPStart !== -1) {
-                        const firstPEnd = xml.indexOf('</hp:p>', firstPStart);
-                        if (firstPEnd !== -1) {
-                            insertPosition = firstPEnd + '</hp:p>'.length;
-                        }
-                    }
-                }
-                // If position not found, insert at end of section (before </hs:sec>)
-                if (insertPosition === -1) {
-                    const secEnd = xml.lastIndexOf('</hs:sec>');
-                    if (secEnd !== -1) {
-                        insertPosition = secEnd;
-                    }
-                }
-                if (insertPosition !== -1) {
-                    xml = xml.substring(0, insertPosition) + paragraphXml + xml.substring(insertPosition);
-                }
-            }
-            this._zip.file(sectionPath, xml);
-        }
-    }
     /**
      * Apply nested table inserts to XML.
      * Inserts a new table inside a cell of an existing table.
@@ -4506,8 +4806,11 @@ class HwpxDocument {
                     if (insert.col >= cells.length)
                         continue;
                     const cellXml = cells[insert.col].xml;
-                    // Generate nested table XML
-                    const nestedTableXml = this.generateNestedTableXml(insert.nestedRows, insert.nestedCols, insert.data);
+                    // Size the nested table to the parent cell. A fixed per-cell width
+                    // ignored the parent and pushed columns past its border (measured:
+                    // 3 × 8000 = 24000 inside a 21260-wide cell).
+                    const innerWidth = this.getCellInnerWidth(cellXml, tableXml);
+                    const nestedTableXml = this.generateNestedTableXml(insert.nestedRows, insert.nestedCols, insert.data, innerWidth);
                     // Insert nested table into cell
                     const updatedCellXml = this.insertNestedTableIntoCell(cellXml, nestedTableXml);
                     // Update the row with the new cell
@@ -4538,14 +4841,54 @@ class HwpxDocument {
     /**
      * Generate XML for a nested table.
      */
-    generateNestedTableXml(rows, cols, data) {
+    /**
+     * Usable width inside a table cell, in hwpunit.
+     *
+     * A cell with hasMargin="0" takes its padding from the table's inMargin, so
+     * the cell's own cellMargin is only authoritative when hasMargin="1".
+     *
+     * Every lookup is scoped to the cell's (or table's) own markup. A nested
+     * table inside the cell carries its own cellSz/cellMargin/inMargin, and a
+     * first-match regex over the whole cell would read those instead — which
+     * sized a second nested table to the first one's column (7086 vs 21260).
+     */
+    getCellInnerWidth(cellXml, tableXml) {
+        // hp:tc children are subList → cellAddr → cellSpan → cellSz → cellMargin,
+        // so the cell's own properties are everything after its last </hp:subList>.
+        const subListEnd = cellXml.lastIndexOf('</hp:subList>');
+        const cellProps = subListEnd === -1 ? cellXml : cellXml.slice(subListEnd);
+        const size = cellProps.match(/<hp:cellSz width="(\d+)"/);
+        if (!size)
+            return null;
+        const width = parseInt(size[1], 10);
+        const openTag = cellXml.slice(0, cellXml.indexOf('>') + 1);
+        const usesOwnMargin = /\bhasMargin="1"/.test(openTag);
+        // Table-level inMargin precedes the first row.
+        const firstRow = tableXml.indexOf('<hp:tr');
+        const tableHead = firstRow === -1 ? tableXml : tableXml.slice(0, firstRow);
+        const margin = usesOwnMargin
+            ? cellProps.match(/<hp:cellMargin left="(\d+)" right="(\d+)"/)
+            : tableHead.match(/<hp:inMargin left="(\d+)" right="(\d+)"/);
+        const padding = margin ? parseInt(margin[1], 10) + parseInt(margin[2], 10) : 0;
+        return Math.max(width - padding, 0);
+    }
+    /**
+     * Generate XML for a nested table.
+     *
+     * @param innerWidth Usable width of the parent cell in hwpunit. The nested
+     *   table is sized to fit it exactly; columns share the width evenly.
+     */
+    generateNestedTableXml(rows, cols, data, innerWidth = null) {
         // Generate unique ID
         const id = Math.floor(Math.random() * 2000000000) + 100000000;
         const zOrder = Math.floor(Math.random() * 100);
-        // Calculate sizes (in hwpunit, 1 hwpunit = 0.1mm)
-        const cellWidth = 8000; // ~80mm per cell
+        // Calculate sizes (hwpunit, 100 = 1pt). Without a parent width fall back to
+        // the previous fixed column width so standalone callers keep working.
+        const tableWidth = innerWidth !== null && innerWidth > 0 ? innerWidth : 8000 * cols;
+        const baseCellWidth = Math.floor(tableWidth / cols);
+        // Give the rounding remainder to the last column so the columns sum to tableWidth.
+        const cellWidthAt = (c) => (c === cols - 1 ? tableWidth - baseCellWidth * (cols - 1) : baseCellWidth);
         const cellHeight = 1400; // ~14mm per cell
-        const tableWidth = cellWidth * cols;
         const tableHeight = cellHeight * rows;
         let xml = `<hp:tbl id="${id}" zOrder="${zOrder}" numberingType="TABLE" textWrap="TOP_AND_BOTTOM" textFlow="BOTH_SIDES" lock="0" dropcapstyle="None" pageBreak="NONE" repeatHeader="0" rowCnt="${rows}" colCnt="${cols}" cellSpacing="0" borderFillIDRef="2" noAdjust="0">`;
         // Size element
@@ -4578,7 +4921,7 @@ class HwpxDocument {
                 xml += `</hp:subList>`;
                 xml += `<hp:cellAddr colAddr="${c}" rowAddr="${r}"/>`;
                 xml += `<hp:cellSpan colSpan="1" rowSpan="1"/>`;
-                xml += `<hp:cellSz width="${cellWidth}" height="${cellHeight}"/>`;
+                xml += `<hp:cellSz width="${cellWidthAt(c)}" height="${cellHeight}"/>`;
                 xml += `<hp:cellMargin left="141" right="141" top="141" bottom="141"/>`;
                 xml += `</hp:tc>`;
             }
@@ -4599,7 +4942,7 @@ class HwpxDocument {
             const pMatch = cellXml.match(/<hp:p[^>]*>/);
             if (pMatch) {
                 const insertPos = cellXml.indexOf(pMatch[0]) + pMatch[0].length;
-                const runXml = `<hp:run charPrIDRef="0"><hp:t> </hp:t>${nestedTableXml}<hp:t/></hp:run>`;
+                const runXml = `<hp:run charPrIDRef="0">${nestedTableXml}<hp:t/></hp:run>`;
                 return cellXml.substring(0, insertPos) + runXml + cellXml.substring(insertPos);
             }
             return cellXml;
@@ -4618,8 +4961,10 @@ class HwpxDocument {
             return cellXml;
         // Find the end of the opening <hp:p ...> tag
         const pTagEnd = cellXml.indexOf('>', pStart) + 1;
-        // Create new run with nested table
-        const runXml = `<hp:run charPrIDRef="0"><hp:t> </hp:t>${nestedTableXml}<hp:t/></hp:run>`;
+        // Create new run with nested table. No leading text: a space before an
+        // inline (treatAsChar) table that fills the cell width forces the table onto
+        // a second line and leaves an empty first line above it (measured in Hancom).
+        const runXml = `<hp:run charPrIDRef="0">${nestedTableXml}<hp:t/></hp:run>`;
         // Insert after the opening <hp:p> tag
         return cellXml.substring(0, pTagEnd) + runXml + cellXml.substring(pTagEnd);
     }
@@ -6106,9 +6451,31 @@ class HwpxDocument {
     async applyDirectTextUpdatesToXml() {
         if (!this._zip)
             return;
+        // Re-anchor every update on the memory paragraph it edits. The element
+        // index and id-occurrence recorded at call time are stale once a later
+        // insert/delete/copy/move reshapes the section: the frozen occurrence then
+        // names another same-id paragraph (measured: [A,B,C] all id="0", edit B,
+        // move C to the front → A was rewritten). At this point the memory model
+        // matches the XML, whose structural edits were already replayed.
+        for (const update of this._pendingDirectTextUpdates) {
+            if (!update.paragraph)
+                continue;
+            const elements = this._content.sections[update.sectionIndex]?.elements ?? [];
+            const now = elements.findIndex(e => e.type === 'paragraph' && e.data === update.paragraph);
+            if (now === -1) {
+                // The paragraph was deleted after the edit; there is nothing to write.
+                update.elementIndex = -1;
+                continue;
+            }
+            update.elementIndex = now;
+            update.paragraphId = update.paragraph.id || '';
+            update.paragraphOccurrence = this.getParagraphOccurrence(update.sectionIndex, now, update.paragraphId);
+        }
         // Group updates by sectionIndex, then by elementIndex
         const updatesBySectionAndElement = new Map();
         for (const update of this._pendingDirectTextUpdates) {
+            if (update.elementIndex < 0)
+                continue;
             let sectionMap = updatesBySectionAndElement.get(update.sectionIndex);
             if (!sectionMap) {
                 sectionMap = new Map();
@@ -6170,11 +6537,11 @@ class HwpxDocument {
                 // Sort by runIndex to process in order
                 updates.sort((a, b) => a.runIndex - b.runIndex);
                 // Apply the update directly using pre-computed target location
-                if (updates.length > 1) {
+                if (updates.length > 1 || /<hp:t\b/.test(target.xml)) {
                     xml = this.replaceRunsInParagraphDirect(xml, target, updates);
                 }
                 else {
-                    // For single update, use the existing method with pre-computed target
+                    // Empty runs without text tags need a new hp:t element.
                     xml = this.replaceTextInElementDirect(xml, target, updates[0].oldText, updates[0].newText);
                 }
             }
@@ -6483,27 +6850,14 @@ class HwpxDocument {
         return xml.slice(0, targetInOriginal.start) + newParagraphXml + xml.slice(targetInOriginal.end);
     }
     /**
-     * Calculate the occurrence index for a paragraph with given ID.
-     * Returns how many paragraphs with the same ID appear before this one.
+     * Occurrence index of the paragraph at `elementIndex` among paragraphs with
+     * the same id — counted with the same rule as insert anchors
+     * (resolveElementAnchor), so a text update finds the paragraph that
+     * findParsedParagraph resolves. Divider paragraphs parsed as 'hr' count.
      */
     getParagraphOccurrence(sectionIndex, elementIndex, paragraphId) {
-        // Use _content.sections (same as findParagraphByPath) instead of _sections
-        if (!this._content || !this._content.sections || !this._content.sections[sectionIndex])
-            return 0;
-        const section = this._content.sections[sectionIndex];
-        if (!section || !section.elements)
-            return 0;
-        let occurrenceCount = 0;
-        for (let i = 0; i < elementIndex; i++) {
-            const element = section.elements[i];
-            if (element && element.type === 'paragraph') { // Use 'paragraph' not 'p'
-                const para = element.data;
-                if (para.id === paragraphId) {
-                    occurrenceCount++;
-                }
-            }
-        }
-        return occurrenceCount;
+        const anchor = this.resolveElementAnchor(sectionIndex, elementIndex);
+        return anchor && anchor.kind === 'paragraph' && anchor.id === paragraphId ? anchor.occurrence : 0;
     }
     /**
      * Find paragraph by its ID attribute and occurrence index.
@@ -6799,18 +7153,22 @@ class HwpxDocument {
         // TIER 1: ID-based lookup (most reliable)
         // TIER 2: Index-based lookup with text validation
         // TIER 3: Fuzzy text matching fallback
-        // TIER 1: ID-based lookup - DISABLED
-        // Problem: XML counting includes nested paragraphs (inside tables),
-        // but _content.sections.elements only has top-level elements.
-        // This mismatch causes wrong paragraph selection.
-        // Solution: Skip ID-based lookup and use index-based (TIER 2) instead.
+        // TIER 1: id + occurrence, counted with the parser's paragraph rule.
         //
-        // if (paragraphId) {
-        //   const idBasedTarget = this.findParagraphById(xml, paragraphId, paragraphOccurrence ?? 0);
-        //   if (idBasedTarget) {
-        //     return idBasedTarget;
-        //   }
-        // }
+        // This was disabled because counting every <hp:p> in the XML included cell
+        // paragraphs the memory model does not have. findAnchorEnd counts only
+        // top-level paragraphs the parser keeps, so the occurrence recorded from
+        // the memory model names the same node. Index lookup (TIER 2) is wrong
+        // after a copy: its ±2 text search finds the original first because the
+        // copy carries the same text, and the edit lands on the original.
+        if (paragraphId) {
+            // The paragraph's OWN range. For a paragraph inside a header or text
+            // box, the enclosing top-level paragraph would rewrite the whole body.
+            const hit = this.findParsedParagraph(xml, { kind: 'paragraph', id: paragraphId, occurrence: paragraphOccurrence ?? 0 });
+            if (hit) {
+                return { start: hit.start, end: hit.end, xml: xml.slice(hit.start, hit.end) };
+            }
+        }
         // Calculate paragraph index using _content.sections.elements (same source as elementIndex)
         // This ensures consistency between elementIndex and paragraph counting
         let topLevelParagraphIndex = 0;
@@ -6911,27 +7269,43 @@ class HwpxDocument {
         // Filter to only runs that have <hp:t> content (matching memory model behavior)
         // Memory model only counts runs with text, not runs with only <hp:ctrl> etc.
         const textRuns = runs.filter(run => /<hp:t\b/.test(run.xml) || /<hp:t\s*\/>/.test(run.xml));
+        // The parser creates a model run per non-empty hp:t, not per hp:run.
+        // Merge those updates back into their shared XML run without losing a suffix.
+        const xmlRunUpdates = new Map();
+        let modelRunIndex = 0;
+        for (let i = 0; i < textRuns.length; i++) {
+            const textNodes = [...textRuns[i].xml.matchAll(/<hp:t\b[^>]*>([^<]+)<\/hp:t>/g)];
+            const count = Math.max(1, textNodes.length);
+            let changed = false;
+            let escapedText = '';
+            for (let offset = 0; offset < count; offset++) {
+                const index = modelRunIndex + offset;
+                if (updateMap.has(index)) {
+                    escapedText += this.escapeXml(updateMap.get(index));
+                    changed = true;
+                }
+                else {
+                    escapedText += textNodes[offset]?.[1] || '';
+                }
+            }
+            if (changed)
+                xmlRunUpdates.set(i, escapedText);
+            modelRunIndex += count;
+        }
         // Process text runs in reverse order to maintain positions
         for (let i = textRuns.length - 1; i >= 0; i--) {
-            if (!updateMap.has(i))
+            if (!xmlRunUpdates.has(i))
                 continue;
             const run = textRuns[i];
-            const newText = updateMap.get(i);
-            const escapedNew = this.escapeXml(newText);
+            const escapedNew = xmlRunUpdates.get(i);
             let newRunXml = run.xml;
-            // Find and replace hp:t content within this run
-            if (/<hp:t\s*\/>/.test(newRunXml)) {
-                // Self-closing tag: <hp:t/> -> <hp:t>newText</hp:t>
-                newRunXml = newRunXml.replace(/<hp:t\s*\/>/, `<hp:t>${escapedNew}</hp:t>`);
-            }
-            else if (/<hp:t\b[^>]*>/.test(newRunXml)) {
-                // Has content: replace first hp:t content only
-                newRunXml = newRunXml.replace(/(<hp:t\b[^>]*>)[^<]*(<\/hp:t>)/, `$1${escapedNew}$2`);
-            }
-            else {
-                // No hp:t tag - add one after the opening hp:run tag
-                newRunXml = newRunXml.replace(/(<hp:run\b[^>]*>)/, `$1<hp:t>${escapedNew}</hp:t>`);
-            }
+            // Write each XML run's combined text once, preserving text-tag attributes.
+            let textWritten = false;
+            newRunXml = newRunXml.replace(/<hp:t\b([^>]*?)\/>|<hp:t\b([^>]*)>[^<]*<\/hp:t>/g, (_match, selfClosingAttrs, attrs) => {
+                const text = textWritten ? '' : escapedNew;
+                textWritten = true;
+                return `<hp:t${selfClosingAttrs ?? attrs ?? ''}>${text}</hp:t>`;
+            });
             // Replace in paragraph XML
             paragraphXml = paragraphXml.slice(0, run.start) + newRunXml + paragraphXml.slice(run.end);
         }
@@ -10284,6 +10658,35 @@ class HwpxDocument {
     // ============================================================
     // Table Row Insert/Delete XML Persistence
     // ============================================================
+    /**
+     * Clone a table cell for a newly inserted row: same cell attributes, same
+     * first-paragraph formatting, but a single paragraph holding `text`.
+     *
+     * Nested tables and extra paragraphs are dropped. The first run's
+     * charPrIDRef is kept so the new text matches the template cell's font.
+     */
+    cloneCellWithText(cellXml, text) {
+        const subListOpen = cellXml.match(/<(hp|hs):subList\b[^>]*>/);
+        const subListCloseIdx = cellXml.lastIndexOf('</hp:subList>') !== -1
+            ? cellXml.lastIndexOf('</hp:subList>')
+            : cellXml.lastIndexOf('</hs:subList>');
+        if (!subListOpen || subListOpen.index === undefined || subListCloseIdx === -1) {
+            // No sub-list to rebuild — fall back to blanking the text in place.
+            return this.resetLinesegInXml(cellXml.replace(T_TAG_WITH_CONTENT, '<$1:t$2></$1:t>'));
+        }
+        const prefix = subListOpen[1];
+        const inner = cellXml.slice(subListOpen.index + subListOpen[0].length, subListCloseIdx);
+        const firstPara = inner.match(new RegExp(`<${prefix}:p\\b[^>]*>`));
+        const paraOpen = firstPara
+            ? firstPara[0]
+            : `<${prefix}:p id="0" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`;
+        const firstRun = inner.match(new RegExp(`<${prefix}:run\\b[^>]*charPrIDRef="(\\d+)"`));
+        const charPr = firstRun ? firstRun[1] : '0';
+        const paragraph = `${paraOpen}<${prefix}:run charPrIDRef="${charPr}"><${prefix}:t>${this.escapeXml(text)}</${prefix}:t></${prefix}:run>` +
+            `<${prefix}:linesegarray><${prefix}:lineseg textpos="0" vertpos="0" vertsize="1000" textheight="1000" baseline="850" spacing="600" horzpos="0" horzsize="0" flags="0"/></${prefix}:linesegarray>` +
+            `</${prefix}:p>`;
+        return cellXml.slice(0, subListOpen.index + subListOpen[0].length) + paragraph + cellXml.slice(subListCloseIdx);
+    }
     async applyTableRowInsertsToXml() {
         if (!this._zip)
             return;
@@ -10310,26 +10713,22 @@ class HwpxDocument {
                 if (insert.afterRowIndex >= rows.length)
                     continue;
                 const templateRow = rows[insert.afterRowIndex];
-                // Clone the template row - clear text content but preserve XML structure
+                // Clone the template row cell by cell. Each new cell keeps the
+                // template cell's formatting but only its FIRST paragraph, emptied:
+                // cloning every paragraph copied multi-line cells (e.g. "○ a\n○ b\n- c")
+                // as three empty lines, so Hancom sized the row for three lines and the
+                // one line of new text sat at the top.
+                const newRowAddr = insert.afterRowIndex + 1;
+                const templateCells = this.findAllElementsWithDepth(templateRow.xml, 'tc');
                 let newRowXml = templateRow.xml;
-                // Clear text inside <hp:t> and <hs:t> tags but preserve the tags themselves
-                newRowXml = newRowXml.replace(/<(hp|hs):t([^>]*)>[\s\S]*?<\/\1:t>/g, '<$1:t$2></$1:t>');
+                for (let c = templateCells.length - 1; c >= 0; c--) {
+                    const cell = templateCells[c];
+                    const text = insert.cellTexts?.[c] ?? '';
+                    const newCellXml = this.cloneCellWithText(cell.xml, text);
+                    newRowXml = newRowXml.slice(0, cell.startIndex) + newCellXml + newRowXml.slice(cell.endIndex);
+                }
                 // Update rowAddr in each cell
-                const newRowAddr = insert.afterRowIndex + 1;
                 newRowXml = newRowXml.replace(/rowAddr="(\d+)"/g, `rowAddr="${newRowAddr}"`);
-                // Set cell texts if provided
-                if (insert.cellTexts) {
-                    let cellIdx = 0;
-                    newRowXml = newRowXml.replace(/<(hp|hs):t([^>]*)><\/\1:t>/g, (match, prefix, attrs) => {
-                        if (cellIdx < insert.cellTexts.length) {
-                            const text = this.escapeXml(insert.cellTexts[cellIdx]);
-                            cellIdx++;
-                            return `<${prefix}:t${attrs}>${text}</${prefix}:t>`;
-                        }
-                        cellIdx++;
-                        return match;
-                    });
-                }
                 // Insert after the template row
                 const insertPos = templateRow.startIndex + templateRow.xml.length;
                 const newTableXml = tableXml.substring(0, insertPos) + '\n' + newRowXml + tableXml.substring(insertPos);
@@ -10480,9 +10879,11 @@ class HwpxDocument {
                     }
                     if (!templateCell)
                         continue;
-                    // Clone template and clear text
+                    // Clone template and clear text.
+                    // The tag-name boundary in T_TAG_WITH_CONTENT keeps <hp:tc> structure intact.
                     let newCellXml = templateCell.xml;
-                    newCellXml = newCellXml.replace(/<(hp|hs):t([^>]*)>[\s\S]*?<\/\1:t>/g, '<$1:t$2></$1:t>');
+                    newCellXml = newCellXml.replace(T_TAG_WITH_CONTENT, '<$1:t$2></$1:t>');
+                    newCellXml = this.resetLinesegInXml(newCellXml);
                     // Update colAddr to afterColIndex + 1
                     newCellXml = newCellXml.replace(/colAddr="(\d+)"/, `colAddr="${insert.afterColIndex + 1}"`);
                     // Also update <hp:cellAddr colAddr="..."> inside the cell
@@ -10582,12 +10983,43 @@ class HwpxDocument {
             const prefix = prefixMatch[1];
             const tag = prefixMatch[2];
             const closeTag = `</${prefix}:${tag}>`;
-            // For paragraphs, find the close tag accounting for nesting
+            // Paragraphs DO nest: a paragraph that holds a table contains the
+            // paragraphs of every cell. Taking the first </hp:p> cut a table-wrapper
+            // paragraph off inside its first cell, so anything placed "after" it
+            // landed inside that cell (measured: text inserted after a table
+            // appeared in the table's first cell).
             if (tag === 'p') {
-                // Paragraphs don't nest, so find the next close tag
-                const closeIdx = sectionXml.indexOf(closeTag, elem.start);
-                if (closeIdx !== -1) {
-                    const endIndex = closeIdx + closeTag.length;
+                const openTag = `<${prefix}:p`;
+                let depth = 1;
+                let pos = elem.start + elem.tagLength;
+                let endIndex = -1;
+                while (depth > 0 && pos < sectionXml.length) {
+                    const nextClose = sectionXml.indexOf(closeTag, pos);
+                    if (nextClose === -1)
+                        break;
+                    // Count only real <hp:p ...> / <hp:p> opens, not <hp:pic>, <hp:pos>, ...
+                    let nextOpen = sectionXml.indexOf(openTag, pos);
+                    while (nextOpen !== -1 && nextOpen < nextClose) {
+                        const after = sectionXml[nextOpen + openTag.length];
+                        if (after === ' ' || after === '>' || after === '/')
+                            break;
+                        nextOpen = sectionXml.indexOf(openTag, nextOpen + 1);
+                    }
+                    if (nextOpen !== -1 && nextOpen < nextClose) {
+                        const tagEnd = sectionXml.indexOf('>', nextOpen);
+                        // A self-closing <hp:p/> does not change depth.
+                        if (sectionXml[tagEnd - 1] !== '/')
+                            depth++;
+                        pos = tagEnd + 1;
+                    }
+                    else {
+                        depth--;
+                        pos = nextClose + closeTag.length;
+                        if (depth === 0)
+                            endIndex = pos;
+                    }
+                }
+                if (endIndex !== -1) {
                     results.push({
                         xml: sectionXml.substring(elem.start, endIndex),
                         startIndex: elem.start,
@@ -10628,102 +11060,6 @@ class HwpxDocument {
         }
         return results;
     }
-    async applyParagraphCopiesToXml() {
-        if (!this._zip)
-            return;
-        for (const copy of this._pendingParagraphCopies) {
-            const srcPath = `Contents/section${copy.sourceSection}.xml`;
-            const srcXml = await this._zip.file(srcPath)?.async('string');
-            if (!srcXml)
-                continue;
-            const srcElements = this.findTopLevelFullElements(srcXml);
-            if (copy.sourceParagraph >= srcElements.length)
-                continue;
-            const srcElem = srcElements[copy.sourceParagraph];
-            if (srcElem.type !== 'p')
-                continue;
-            // Clone and regenerate ID
-            let clonedXml = srcElem.xml;
-            const newId = Math.random().toString(36).substring(2, 11);
-            clonedXml = clonedXml.replace(/<(hp|hs):p\s+([^>]*?)id="[^"]*"/, `<$1:p $2id="${newId}"`);
-            // Read target section
-            const tgtPath = `Contents/section${copy.targetSection}.xml`;
-            let tgtXml = await this._zip.file(tgtPath)?.async('string');
-            if (!tgtXml)
-                continue;
-            const tgtElements = this.findTopLevelFullElements(tgtXml);
-            // Insert after targetAfter element
-            let insertPos;
-            if (copy.targetAfter >= 0 && copy.targetAfter < tgtElements.length) {
-                insertPos = tgtElements[copy.targetAfter].endIndex;
-            }
-            else if (copy.targetAfter < 0) {
-                // Insert at beginning - find first element
-                if (tgtElements.length > 0) {
-                    insertPos = tgtElements[0].startIndex;
-                }
-                else {
-                    const secMatch = tgtXml.match(/<(?:hs|hp):sec[^>]*>/);
-                    insertPos = secMatch ? secMatch.index + secMatch[0].length : 0;
-                }
-            }
-            else {
-                // After last element
-                insertPos = tgtElements.length > 0 ? tgtElements[tgtElements.length - 1].endIndex : tgtXml.lastIndexOf('</');
-            }
-            tgtXml = tgtXml.substring(0, insertPos) + '\n' + clonedXml + tgtXml.substring(insertPos);
-            this._zip.file(tgtPath, tgtXml);
-        }
-    }
-    async applyParagraphMovesToXml() {
-        if (!this._zip)
-            return;
-        for (const move of this._pendingParagraphMoves) {
-            const srcPath = `Contents/section${move.sourceSection}.xml`;
-            let srcXml = await this._zip.file(srcPath)?.async('string');
-            if (!srcXml)
-                continue;
-            const srcElements = this.findTopLevelFullElements(srcXml);
-            if (move.sourceParagraph >= srcElements.length)
-                continue;
-            const srcElem = srcElements[move.sourceParagraph];
-            if (srcElem.type !== 'p')
-                continue;
-            const extractedXml = srcElem.xml;
-            // Remove from source
-            srcXml = srcXml.substring(0, srcElem.startIndex) + srcXml.substring(srcElem.endIndex);
-            this._zip.file(srcPath, srcXml);
-            // Read target section (re-read if same section since we modified it)
-            const tgtPath = `Contents/section${move.targetSection}.xml`;
-            let tgtXml = await this._zip.file(tgtPath)?.async('string');
-            if (!tgtXml)
-                continue;
-            const tgtElements = this.findTopLevelFullElements(tgtXml);
-            // Adjust target index for same-section moves
-            let adjustedTarget = move.targetAfter;
-            if (move.sourceSection === move.targetSection && move.sourceParagraph < move.targetAfter) {
-                adjustedTarget -= 1;
-            }
-            let insertPos;
-            if (adjustedTarget >= 0 && adjustedTarget < tgtElements.length) {
-                insertPos = tgtElements[adjustedTarget].endIndex;
-            }
-            else if (adjustedTarget < 0) {
-                if (tgtElements.length > 0) {
-                    insertPos = tgtElements[0].startIndex;
-                }
-                else {
-                    const secMatch = tgtXml.match(/<(?:hs|hp):sec[^>]*>/);
-                    insertPos = secMatch ? secMatch.index + secMatch[0].length : 0;
-                }
-            }
-            else {
-                insertPos = tgtElements.length > 0 ? tgtElements[tgtElements.length - 1].endIndex : tgtXml.lastIndexOf('</');
-            }
-            tgtXml = tgtXml.substring(0, insertPos) + '\n' + extractedXml + tgtXml.substring(insertPos);
-            this._zip.file(tgtPath, tgtXml);
-        }
-    }
     // ============================================================
     // Header/Footer XML Persistence
     // ============================================================