ep_data_tables 0.0.97 → 0.0.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ep_data_tables",
-  "version": "0.0.97",
+  "version": "0.0.99",
   "description": "BETA - etherpad tables plugin, compatible with other character/line based styling and other features",
   "author": {
     "name": "DCastelone",

package/static/js/client_hooks.js

@@ -741,807 +741,21 @@ exports.acePostWriteDomLineHTML = function (hook_name, args, cb) {
   let skipMismatchReturn = false;
 
   if (htmlSegments.length !== rowMetadata.cols) {
-    console.warn('[ep_data_tables][diag] Segment/column mismatch', { nodeId, lineNum, segs: htmlSegments.length, cols: rowMetadata.cols, tblId: rowMetadata.tblId, row: rowMetadata.row });
-
-    // Skip mismatch repair during column operations
-    if (__epDT_columnOperationInProgress) {
-      console.debug('[ep_data_tables][diag] mismatch-skip-scheduling', { nodeId, reason: 'column-operation-in-progress' });
-      skipMismatchReturn = true;
-    }
-    // Schedule deferred canonicalization
-    else if (nodeId && !__epDT_postWriteScheduled.has(nodeId)) {
-      __epDT_postWriteScheduled.add(nodeId);
-      const fallbackLineNum = lineNum; // DOM-derived index as fallback
-      const capturedTblId = rowMetadata.tblId;
-      const capturedRow = rowMetadata.row;
-      const expectedCols = rowMetadata.cols;
-      setTimeout(() => {
-        try {
-          if (!EP_DT_EDITOR_INFO) return;
-          const ed = EP_DT_EDITOR_INFO;
-          const docManager = ed.ep_data_tables_docManager || null;
-          
-          if (__epDT_columnOperationInProgress) {
-            console.debug('[ep_data_tables:postWriteCanonicalize] skipped - column operation in progress');
-            return;
-          }
-          
-          // Pre-check editor state (prevents crash if keyToNodeMap corrupted)
-          try {
-            const preCheckRep = ed.ace_getRep && ed.ace_getRep();
-            if (!preCheckRep || !preCheckRep.lines) {
-              console.debug('[ep_data_tables:postWriteCanonicalize] skipped - rep unavailable');
-              return;
-            }
-          } catch (preCheckErr) {
-            console.debug('[ep_data_tables:postWriteCanonicalize] skipped - pre-check failed', preCheckErr?.message);
-            return;
-          }
-          
-          try {
-          ed.ace_callWithAce((ace) => {
-            try {
-              const rep = ace.ace_getRep();
-              if (!rep || !rep.lines) return;
-              
-              const origLineInfo = __epDT_compositionOriginalLine;
-              const hasOriginalLineInfo = origLineInfo && 
-                origLineInfo.tblId === capturedTblId && 
-                typeof origLineInfo.lineNum === 'number' &&
-                (Date.now() - origLineInfo.timestamp) < 5000; // Only use if recent (within 5 seconds)
-              
-              console.debug('[ep_data_tables:postWriteCanonicalize] start', {
-                nodeId, fallbackLineNum, capturedTblId, capturedRow, expectedCols,
-                hasDocManager: !!docManager,
-                originalLineInfo: hasOriginalLineInfo ? origLineInfo.lineNum : null,
-              });
-              if (!docManager || typeof docManager.getAttributeOnLine !== 'function') {
-                console.debug('[ep_data_tables:postWriteCanonicalize] abort: no documentAttributeManager available');
-                return;
-              }
-              // Robust line resolution: primary by attribute scan (tblId/row), then key lookup, then fallback.
-              let ln = -1;
-              let attrScanLine = -1; // Track where attr scan finds the table (may differ from original)
-              try {
-                const totalScan = rep.lines.length();
-                for (let i = 0; i < totalScan; i++) {
-                  let sAttr = null;
-                  try { sAttr = docManager.getAttributeOnLine(i, ATTR_TABLE_JSON); } catch (_) {}
-                  if (!sAttr) continue;
-                  try {
-                    const m = JSON.parse(sAttr);
-                    if (m && m.tblId === capturedTblId && m.row === capturedRow) {
-                      attrScanLine = i;
-                      ln = i;
-                      console.debug('[ep_data_tables:postWriteCanonicalize] found-by-attr-scan', { ln, tblId: m.tblId, row: m.row, cols: m.cols });
-                      break;
-                    }
-                  } catch (_) { /* ignore parse errors */ }
-                }
-              } catch (scanErr) {
-                console.error('[ep_data_tables:postWriteCanonicalize] line scan error', scanErr);
-              }
-              
-              if (hasOriginalLineInfo && attrScanLine >= 0 && attrScanLine !== origLineInfo.lineNum) {
-                console.debug('[ep_data_tables:postWriteCanonicalize] line shift detected', {
-                  attrScanLine,
-                  originalLine: origLineInfo.lineNum,
-                  shift: attrScanLine - origLineInfo.lineNum,
-                });
-                
-                // Check if the original line still has a table DOM
-                const origEntry = rep.lines.atIndex(origLineInfo.lineNum);
-                if (origEntry?.lineNode) {
-                  const origTableEl = origEntry.lineNode.querySelector(
-                    `table.dataTable[data-tblId="${capturedTblId}"], table.dataTable[data-tblid="${capturedTblId}"]`
-                  );
-                  if (origTableEl) {
-                    console.debug('[ep_data_tables:postWriteCanonicalize] original line still has table DOM, preferring it', {
-                      originalLine: origLineInfo.lineNum,
-                      attrLine: attrScanLine,
-                    });
-                    ln = origLineInfo.lineNum;
-                  }
-                }
-              }
-              
-              if (ln < 0) {
-                try {
-                  if (rep.lines && typeof rep.lines.indexOfKey === 'function') {
-                    ln = rep.lines.indexOfKey(nodeId);
-                    console.debug('[ep_data_tables:postWriteCanonicalize] found-by-indexOfKey', { ln, nodeId });
-                  }
-                } catch (eIdx) {
-                  console.error('[ep_data_tables:postWriteCanonicalize] indexOfKey error; using fallback line', eIdx);
-                  ln = (typeof fallbackLineNum === 'number') ? fallbackLineNum : -1;
-                }
-              }
-              if (typeof ln !== 'number' || ln < 0) {
-                console.debug('[ep_data_tables:postWriteCanonicalize] abort: invalid line', { nodeId, ln });
-                return;
-              }
-              let attrStr = null;
-              try { attrStr = docManager.getAttributeOnLine(ln, ATTR_TABLE_JSON); } catch (_) { attrStr = null; }
-              if (!attrStr) {
-                console.debug('[ep_data_tables:postWriteCanonicalize] abort: no tbljson on resolved line', { ln, nodeId, capturedTblId, capturedRow });
-                return;
-              }
-              let metaAttr = null;
-              try { metaAttr = JSON.parse(attrStr); } catch (_) { metaAttr = null; }
-              if (!metaAttr || metaAttr.tblId !== capturedTblId || metaAttr.row !== capturedRow) {
-                console.debug('[ep_data_tables:postWriteCanonicalize] abort: meta mismatch', { ln, metaAttr, capturedTblId, capturedRow });
-                return;
-              }
-              if (typeof metaAttr.cols !== 'number') {
-                console.debug('[ep_data_tables:postWriteCanonicalize] abort: invalid cols', { ln, metaAttr });
-                return;
-              }
-              const entry = rep.lines.atIndex(ln);
-              const currentText = entry?.text || '';
-              const segs = currentText.split(DELIMITER);
-              const needed = metaAttr.cols;
-              const sanitize = (s) => {
-                const x = normalizeSoftWhitespace((s || '').replace(new RegExp(DELIMITER, 'g'), ' ').replace(/[\u200B\u200C\u200D\uFEFF]/g, ' '));
-                return x || ' ';
-              };
-              const cells = new Array(needed);
-                for (let i = 0; i < needed; i++) cells[i] = sanitize(segs[i] || ' ');
-              const canonical = cells.join(DELIMITER);
-              
-              // Check if line has table DOM (text matching alone is insufficient)
-              let lineHasTableDOM = false;
-              try {
-                const lineNode = entry?.lineNode;
-                if (lineNode && typeof lineNode.querySelector === 'function') {
-                  const tableEl = lineNode.querySelector(
-                    `table.dataTable[data-tblId="${capturedTblId}"], table.dataTable[data-tblid="${capturedTblId}"]`
-                  );
-                  lineHasTableDOM = !!tableEl;
-                }
-              } catch (_) {}
-              
-              const textMatches = canonical === currentText;
-              const needsRepair = !textMatches || !lineHasTableDOM;
-              
-              // Extract character-level styling before replacement
-              const extractedStyling = [];
-              try {
-                const lineNode = entry?.lineNode;
-                if (lineNode && lineHasTableDOM) {
-                  const tableEl = lineNode.querySelector('table.dataTable');
-                  if (tableEl) {
-                    const tds = tableEl.querySelectorAll('td');
-                    tds.forEach((td, cellIdx) => {
-                      const spans = td.querySelectorAll('span:not(.ep-data_tables-delim):not(.ep-data_tables-caret-anchor)');
-                      let relPos = 0; // Position relative to cell start
-                      spans.forEach((span) => {
-                        const text = (span.textContent || '').replace(/\u00A0/g, ' '); // Normalize nbsp
-                        const textLen = text.length;
-                        if (textLen === 0) return;
-                        
-                        // Extract ALL classes except table-related ones
-                        // Convert class names to Etherpad attribute format
-                        const stylingAttrs = [];
-                        if (span.classList) {
-                          for (const cls of span.classList) {
-                            if (cls.startsWith('tbljson-') || cls.startsWith('tblCell-')) continue;
-                            if (cls === 'ace-line' || cls.startsWith('ep-data_tables-')) continue;
-                            
-                            // Parse class name to attribute key-value pair
-                            // Etherpad uses formats like: "author-xyz", "font-size:12", "bold"
-                            if (cls.includes(':')) {
-                              // Format: "key:value" (e.g., "font-size:12", "color:red")
-                              const colonIdx = cls.indexOf(':');
-                              const key = cls.substring(0, colonIdx);
-                              const value = cls.substring(colonIdx + 1);
-                              stylingAttrs.push([key, value]);
-                            } else if (cls.includes('-')) {
-                              // Format: "key-value" (e.g., "author-a1b2c3")
-                              const dashIdx = cls.indexOf('-');
-                              const key = cls.substring(0, dashIdx);
-                              const value = cls.substring(dashIdx + 1);
-                              stylingAttrs.push([key, value]);
-                            } else {
-                              // Format: "key" only (e.g., "bold", "italic")
-                              // These are boolean attributes set to "true"
-                              stylingAttrs.push([cls, 'true']);
-                            }
-                          }
-                        }
-                        
-                        if (stylingAttrs.length > 0) {
-                          extractedStyling.push({
-                            cellIdx,
-                            relStart: relPos,
-                            len: textLen,
-                            text: text, // Store text for matching
-                            attrs: stylingAttrs,
-                          });
-                        }
-                        relPos += textLen;
-                      });
-                    });
-                  }
-                }
-                if (extractedStyling.length > 0) {
-                  console.debug('[ep_data_tables:postWriteCanonicalize] extracted styling', {
-                    ln, count: extractedStyling.length, 
-                    sample: extractedStyling.slice(0, 2).map(s => ({ cell: s.cellIdx, attrs: s.attrs })),
-                  });
-                }
-              } catch (extractErr) {
-                console.debug('[ep_data_tables:postWriteCanonicalize] styling extraction error (non-fatal)', extractErr?.message);
-              }
-              
-              if (needsRepair) {
-                console.debug('[ep_data_tables:postWriteCanonicalize] line needs repair', {
-                  ln,
-                  textMatches,
-                  lineHasTableDOM,
-                  fromLen: currentText.length,
-                  toLen: canonical.length,
-                });
-                if (!textMatches) {
-                  // Validate line is safe to modify before replacement (prevents keyToNodeMap errors)
-                  const repBeforeRepair = ace.ace_getRep();
-                  if (!isLineSafeToModify(repBeforeRepair, ln, '[ep_data_tables:postWriteCanonicalize] repair')) {
-                    console.warn('[ep_data_tables:postWriteCanonicalize] line not safe to modify, skipping repair');
-                    return cb();
-                  }
-                ace.ace_performDocumentReplaceRange([ln, 0], [ln, currentText.length], canonical);
-                }
-                // Note: If lineHasTableDOM is false, orphan detection below will handle finding the real table
-              } else {
-                console.debug('[ep_data_tables:postWriteCanonicalize] line already canonical', { ln, lineHasTableDOM });
-              }
-              let offset = 0;
-              for (let i = 0; i < cells.length; i++) {
-                const len = cells[i].length;
-                if (len > 0) {
-                  ace.ace_performDocumentApplyAttributesToRange([ln, offset], [ln, offset + len], [[ATTR_CELL, String(i)]]);
-                }
-                offset += len;
-                if (i < cells.length - 1) offset += DELIMITER.length;
-              }
-              
-              if (extractedStyling.length > 0) {
-                let appliedCount = 0;
-                try {
-                  for (const style of extractedStyling) {
-                    const cellIdx = style.cellIdx;
-                    const cellContent = cells[cellIdx] || '';
-                    const styledText = style.text;
-                    
-                    if (!styledText || styledText.length === 0 || !cellContent) continue;
-                    
-                    // Find where the styled text appears in the NEW cell content
-                    let foundPos = cellContent.indexOf(styledText);
-                    
-                    if (foundPos === -1) {
-                      const lowerCell = cellContent.toLowerCase();
-                      const lowerStyled = styledText.toLowerCase();
-                      foundPos = lowerCell.indexOf(lowerStyled);
-                    }
-                    
-                    if (foundPos === -1) continue; // Text not found in cell
-                    
-                    // Calculate absolute position in the line
-                    let absStart = 0;
-                    for (let c = 0; c < cellIdx; c++) {
-                      absStart += (cells[c]?.length || 0) + DELIMITER.length;
-                    }
-                    absStart += foundPos;
-                    const absEnd = absStart + styledText.length;
-                    
-                    if (style.attrs.length > 0) {
-                      ace.ace_performDocumentApplyAttributesToRange(
-                        [ln, absStart],
-                        [ln, absEnd],
-                        style.attrs
-                      );
-                      appliedCount++;
-                    }
-                  }
-                  if (appliedCount > 0) {
-                    console.debug('[ep_data_tables:postWriteCanonicalize] re-applied styling', {
-                      ln, applied: appliedCount, total: extractedStyling.length,
-                    });
-                  }
-                } catch (applyErr) {
-                  console.debug('[ep_data_tables:postWriteCanonicalize] styling re-apply error (non-fatal)', applyErr?.message);
-                }
-              }
-              
-              try {
-                ed.ep_data_tables_applyMeta(ln, metaAttr.tblId, metaAttr.row, metaAttr.cols, ace.ace_getRep(), ed, JSON.stringify(metaAttr), docManager);
-              } catch (metaErr) {
-                console.error('[ep_data_tables:postWriteCanonicalize] meta apply error', metaErr);
-              }
-              
-              if (!lineHasTableDOM) {
-                console.debug('[ep_data_tables:postWriteCanonicalize] skipping orphan detection (no table on primary line)', { ln, capturedTblId, capturedRow });
-                return;
-              }
-              
-              // Detect orphan lines (same tblId/row or tbljson-* spans without table)
-              const orphanLines = [];
-              const seenOrphanLines = new Set();
-              try {
-                const total = rep.lines.length();
-                for (let li = 0; li < total; li++) {
-                  if (li === ln) continue;
-                  
-                  // Check line attribute
-                  let sOther = null;
-                  try { sOther = docManager.getAttributeOnLine(li, ATTR_TABLE_JSON); } catch (_) { sOther = null; }
-                  if (sOther) {
-                  let mOther = null;
-                  try { mOther = JSON.parse(sOther); } catch (_) { mOther = null; }
-                  if (mOther && mOther.tblId === capturedTblId && mOther.row === capturedRow) {
-                      const orphanEntry = rep.lines.atIndex(li);
-                      const orphanText = orphanEntry?.text || '';
-                      orphanLines.push({ lineNum: li, text: orphanText, meta: mOther, source: 'attr' });
-                      seenOrphanLines.add(li);
-                      continue;
-                    }
-                  }
-                  
-                  // DOM-based detection (tbljson-* or tblCell-* spans without table parent)
-                  if (seenOrphanLines.has(li)) continue;
-                  try {
-                    const lineEntry = rep.lines.atIndex(li);
-                    const lineNode = lineEntry?.lineNode;
-                    if (lineNode) {
-                      const hasTable = lineNode.querySelector('table.dataTable');
-                      if (!hasTable) {
-                        const tbljsonSpan = lineNode.querySelector('[class*="tbljson-"]');
-                        if (tbljsonSpan) {
-                          for (const cls of tbljsonSpan.classList) {
-                            if (cls.startsWith('tbljson-')) {
-                              try {
-                                const decoded = JSON.parse(atob(cls.substring(8)));
-                                if (decoded && decoded.tblId === capturedTblId && decoded.row === capturedRow) {
-                                  const orphanText = lineEntry?.text || '';
-                                  orphanLines.push({
-                                    lineNum: li,
-                                    text: orphanText,
-                                    meta: decoded,
-                                    source: 'dom-class-tbljson',
-                                  });
-                                  seenOrphanLines.add(li);
-                                  console.debug('[ep_data_tables:postWriteCanonicalize] detected tbljson DOM orphan', {
-                                    lineNum: li, tblId: decoded.tblId, row: decoded.row, textLen: orphanText.length,
-                                  });
-                                  break;
-                                }
-                              } catch (_) {}
-                            }
-                          }
-                        }
-                        
-                        // Also check for tblCell-* spans (no encoded metadata)
-                        if (!seenOrphanLines.has(li)) {
-                          const tblCellSpan = lineNode.querySelector('[class*="tblCell-"]');
-                          if (tblCellSpan) {
-                            // SAFETY CHECK: Verify this line has OUR tbljson attribute, just row might differ
-                            let belongsToOurTable = false;
-                            try {
-                              const lineAttr = docManager.getAttributeOnLine(li, ATTR_TABLE_JSON);
-                              if (lineAttr) {
-                                const lineMeta = JSON.parse(lineAttr);
-                                if (lineMeta && lineMeta.tblId === capturedTblId) {
-                                  belongsToOurTable = true;
-                                }
-                              } else {
-                                // No tbljson attribute - check if there's a tbljson-* CLASS that we can decode
-                                const anyTbljsonSpan = lineNode.querySelector('[class*="tbljson-"]');
-                                if (anyTbljsonSpan) {
-                                  for (const cls of anyTbljsonSpan.classList) {
-                                    if (cls.startsWith('tbljson-')) {
-                                      try {
-                                        const decoded = JSON.parse(atob(cls.substring(8)));
-                                        if (decoded && decoded.tblId === capturedTblId) {
-                                          belongsToOurTable = true;
-                                        }
-                                      } catch (_) {}
-                                      break;
-                                    }
-                                  }
-                                }
-                              }
-                            } catch (_) {}
-                            
-                            if (belongsToOurTable) {
-                              const orphanText = lineEntry?.text || '';
-                              if (orphanText.includes(DELIMITER) || orphanText.trim().length > 0) {
-                                orphanLines.push({
-                                  lineNum: li,
-                                  text: orphanText,
-                                  meta: { tblId: capturedTblId, row: capturedRow, cols: expectedCols },
-                                  source: 'dom-class-tblCell',
-                                });
-                                seenOrphanLines.add(li);
-                                console.debug('[ep_data_tables:postWriteCanonicalize] detected tblCell DOM orphan', {
-                                  lineNum: li, capturedTblId, capturedRow, textLen: orphanText.length,
-                                });
-                              }
-                            } else {
-                              console.debug('[ep_data_tables:postWriteCanonicalize] skipping tblCell line (different table)', {
-                                lineNum: li, capturedTblId,
-                              });
-                            }
-                          }
-                        }
-                      }
-                    }
-                  } catch (domErr) {
-                    console.error('[ep_data_tables:postWriteCanonicalize] DOM orphan detection error', domErr);
-                  }
-                }
-              } catch (scanOrphanErr) {
-                console.error('[ep_data_tables:postWriteCanonicalize] orphan scan error', scanOrphanErr);
-                  }
-              
-              if (orphanLines.length > 0) {
-                let mainEntry = rep.lines.atIndex(ln);
-                
-                let lineWithTableIdx = -1;
-                  try {
-                  const innerDoc = node?.ownerDocument || document;
-                  const editorBody = innerDoc.getElementById('innerdocbody') || innerDoc.body;
-                  if (editorBody) {
-                    const allAceLines = editorBody.querySelectorAll('div.ace-line');
-                    for (let ai = 0; ai < allAceLines.length; ai++) {
-                      const aceLine = allAceLines[ai];
-                      const tableEl = aceLine.querySelector(
-                        `table.dataTable[data-tblId="${capturedTblId}"][data-row="${capturedRow}"], ` +
-                        `table.dataTable[data-tblid="${capturedTblId}"][data-row="${capturedRow}"]`
-                      );
-                      if (tableEl) {
-                        lineWithTableIdx = ai;
-                        console.debug('[ep_data_tables:postWriteCanonicalize] LIVE DOM found table', {
-                          domIndex: ai, aceLineId: aceLine.id, tblId: capturedTblId, row: capturedRow,
-                        });
-                              break;
-                            }
-                          }
-                  }
-                } catch (domQueryErr) {
-                  console.error('[ep_data_tables:postWriteCanonicalize] live DOM query error', domQueryErr);
-                }
-                
-                if (lineWithTableIdx >= 0 && lineWithTableIdx !== ln) {
-                  // Find if this line is in our orphan list
-                  const orphanIdx = orphanLines.findIndex(o => o.lineNum === lineWithTableIdx);
-                  if (orphanIdx >= 0) {
-                    console.warn('[ep_data_tables:postWriteCanonicalize] SWAPPING primary via LIVE DOM: table found on orphan line', {
-                      oldPrimary: ln,
-                      newPrimary: lineWithTableIdx,
-                      orphanIdx,
-                    });
-                    
-                    // Move current "primary" to orphan list
-                    const formerPrimary = {
-                      lineNum: ln,
-                      text: mainEntry?.text || '',
-                      meta: metaAttr,
-                      source: 'swapped-to-orphan',
-                    };
-
-                    // Swap: orphan becomes primary
-                    const newPrimary = orphanLines[orphanIdx];
-                    ln = newPrimary.lineNum;
-                    metaAttr = newPrimary.meta;
-                    mainEntry = rep.lines.atIndex(ln);
-                    
-                    orphanLines.splice(orphanIdx, 1);
-                    orphanLines.push(formerPrimary);
-                    
-                    const newText = mainEntry?.text || '';
-                    const newSegs = newText.split(DELIMITER);
-                    for (let i = 0; i < needed; i++) {
-                      cells[i] = sanitize(newSegs[i] || ' ');
-                    }
-                  }
-                } else if (lineWithTableIdx < 0) {
-                  // No line has the table - this is bad, but we should still try to preserve content
-                  console.warn('[ep_data_tables:postWriteCanonicalize] WARNING: no line has table DOM for tblId/row', {
-                    capturedTblId, capturedRow, primaryLn: ln, orphanCount: orphanLines.length,
-                  });
-                }
-                
-                console.warn('[ep_data_tables:postWriteCanonicalize] orphan lines detected - merging content', {
-                  keepLine: ln, orphans: orphanLines.map(o => ({ line: o.lineNum, textLen: o.text.length })),
-                  tableFoundOnLine: lineWithTableIdx,
-                });
-                
-                // CRITICAL FIX: Extract cell content from LIVE DOM table, not from line text!
-                const mainText = mainEntry?.text || '';
-                const mainSegs = mainText.split(DELIMITER);
-                const mergedCells = new Array(needed);
-                
-                // Try to get clean cell content from the DOM table
-                let usedDomContent = false;
-                if (lineWithTableIdx >= 0) {
-                  try {
-                    const innerDoc = node?.ownerDocument || document;
-                    const editorBody = innerDoc.getElementById('innerdocbody') || innerDoc.body;
-                    const allAceLines = editorBody?.querySelectorAll('div.ace-line');
-                    const tableAceLine = allAceLines?.[lineWithTableIdx];
-                    const tableEl = tableAceLine?.querySelector(
-                      `table.dataTable[data-tblId="${capturedTblId}"], table.dataTable[data-tblid="${capturedTblId}"]`
-                    );
-                    if (tableEl) {
-                      const tr = tableEl.querySelector('tbody > tr');
-                      if (tr && tr.children.length === needed) {
-                        for (let i = 0; i < needed; i++) {
-                          const td = tr.children[i];
-                          // Extract text content, excluding delimiters and special elements
-                          let cellText = '';
-                          for (const child of td.childNodes) {
-                            if (child.nodeType === 3) { // Text node
-                              cellText += child.textContent || '';
-                            } else if (child.nodeType === 1) { // Element
-                              const el = child;
-                              if (el.classList?.contains('ep-data_tables-delim')) continue;
-                              if (el.classList?.contains('ep-data_tables-caret-anchor')) continue;
-                              if (el.classList?.contains('ep-data_tables-resize-handle')) continue;
-                              cellText += el.textContent || '';
-                            }
-                          }
-                          mergedCells[i] = sanitize(cellText || ' ');
-                        }
-                        usedDomContent = true;
-                        console.debug('[ep_data_tables:postWriteCanonicalize] using DOM table content for merge base', {
-                          cells: mergedCells.map(c => c.slice(0, 20)),
-                        });
-                      }
-                    }
-                  } catch (domExtractErr) {
-                    console.error('[ep_data_tables:postWriteCanonicalize] DOM content extraction error', domExtractErr);
-                  }
-                }
-                
-                if (!usedDomContent) {
-                for (let i = 0; i < needed; i++) {
-                  mergedCells[i] = sanitize(mainSegs[i] || ' ');
-                  }
-                  console.debug('[ep_data_tables:postWriteCanonicalize] using line text for merge base (DOM extraction failed)');
-                }
-
-                for (const orphan of orphanLines) {
-                  const orphanSegs = orphan.text.split(DELIMITER);
-                  for (let i = 0; i < Math.min(orphanSegs.length, needed); i++) {
-                    const orphanContent = sanitize(orphanSegs[i] || '');
-                    if (!orphanContent || orphanContent.trim() === '') continue;
-                    const mainCellTrimmed = (mergedCells[i] || '').trim();
-                    const orphanTrimmed = orphanContent.trim();
-                    if (mainCellTrimmed.includes(orphanTrimmed)) continue;
-                    if (!mainCellTrimmed) {
-                      mergedCells[i] = orphanContent;
-                    } else {
-                      // Append orphan content to existing cell content (preserve user data)
-                      mergedCells[i] = mainCellTrimmed + orphanTrimmed;
-                                  }
-                    console.debug('[ep_data_tables:postWriteCanonicalize] merged orphan content', {
-                      cellIdx: i, orphanLine: orphan.lineNum, orphanContent, mergedResult: mergedCells[i],
-                    });
-                  }
-                }
-                
-                const repBeforeMerge = ace.ace_getRep();
-                if (!isLineSafeToModify(repBeforeMerge, ln, '[ep_data_tables:postWriteCanonicalize] merge-target')) {
-                  console.warn('[ep_data_tables:postWriteCanonicalize] main line not safe to modify, aborting merge');
-                } else {
-                const mergedCanonical = mergedCells.join(DELIMITER);
-                if (mergedCanonical !== mainText) {
-                  console.debug('[ep_data_tables:postWriteCanonicalize] applying merged canonical line', {
-                    ln, fromLen: mainText.length, toLen: mergedCanonical.length, mergedCells,
-                  });
-                  ace.ace_performDocumentReplaceRange([ln, 0], [ln, mainText.length], mergedCanonical);
-
-                  let mergeOffset = 0;
-                  for (let i = 0; i < mergedCells.length; i++) {
-                    const cellLen = mergedCells[i].length;
-                        if (cellLen > 0) {
-                      ace.ace_performDocumentApplyAttributesToRange([ln, mergeOffset], [ln, mergeOffset + cellLen], [[ATTR_CELL, String(i)]]);
-                        }
-                    mergeOffset += cellLen;
-                    if (i < mergedCells.length - 1) mergeOffset += DELIMITER.length;
-                  }
-                  
-                  try {
-                    const repAfterMerge = ace.ace_getRep();
-                    ed.ep_data_tables_applyMeta(ln, capturedTblId, capturedRow, expectedCols, repAfterMerge, ed, JSON.stringify(metaAttr), docManager);
-                    console.debug('[ep_data_tables:postWriteCanonicalize] re-applied tbljson after merge', {
-                      ln, tblId: capturedTblId, row: capturedRow, cols: expectedCols,
-                    });
-                  } catch (metaMergeErr) {
-                    console.error('[ep_data_tables:postWriteCanonicalize] failed to re-apply tbljson after merge', metaMergeErr);
-                  }
-                      }
-                } // end isLineSafeToModify check for merge target
-
-                // Delete orphan lines bottom-up
-                // Validate lines and check DOM desync before destructive ops
-                if (!isDestructiveOperationSafe('postWriteCanonicalize orphan removal')) {
-                  console.debug('[ep_data_tables:postWriteCanonicalize] skipping orphan removal (safe mode)');
-                } else {
-                orphanLines.sort((a, b) => b.lineNum - a.lineNum).forEach((orphan) => {
-                    try {
-                      // Re-fetch rep to get current state after any previous deletions
-                      const repCheck = ace.ace_getRep();
-                      
-                      if (!isLineSafeToModify(repCheck, orphan.lineNum, '[ep_data_tables:postWriteCanonicalize] orphan')) {
-                        return;
-                      }
-                      
-                      try {
-                        if (docManager && typeof docManager.removeAttributeOnLine === 'function') {
-                        docManager.removeAttributeOnLine(orphan.lineNum, ATTR_TABLE_JSON);
-                        }
-                    } catch (remErr) {
-                      console.debug('[ep_data_tables:postWriteCanonicalize] removeAttributeOnLine error (non-fatal)', remErr?.message);
-                    }
-                    console.debug('[ep_data_tables:postWriteCanonicalize] removing orphan line (content already merged)', {
-                      orphanLine: orphan.lineNum,
-                    });
-                    ace.ace_performDocumentReplaceRange([orphan.lineNum, 0], [orphan.lineNum + 1, 0], '');
-                  } catch (orphanRemErr) {
-                    console.error('[ep_data_tables:postWriteCanonicalize] orphan line removal error', {
-                      orphanLine: orphan.lineNum,
-                      error: orphanRemErr?.message || orphanRemErr,
-                    });
-                    // Check if this was a desync error
-                    handleDomDesyncError(orphanRemErr, 'postWriteCanonicalize orphan removal');
-                    }
-                  });
-                }
-                  
-                // Clean up spurious blank lines between this table row and the next
-                // These can be created when orphan content gets merged and lines shift
-                try {
-                  const repAfterOrphanRemoval = ace.ace_getRep();
-                  const currentLineNum = ln;
-                  const nextRowNum = capturedRow + 1;
-                  
-                  let nextRowLineNum = -1;
-                  const totalAfter = repAfterOrphanRemoval.lines.length();
-                  for (let li = currentLineNum + 1; li < totalAfter && li < currentLineNum + 10; li++) {
-                    try {
-                      const attrStr = docManager.getAttributeOnLine(li, ATTR_TABLE_JSON);
-                      if (attrStr) {
-                        const meta = JSON.parse(attrStr);
-                        if (meta && meta.tblId === capturedTblId && meta.row === nextRowNum) {
-                          nextRowLineNum = li;
-                          break;
-                        }
-                      }
-                    } catch (_) {}
-                  }
-                  
-                  // If there are blank lines between current row and next row, remove them
-                  if (nextRowLineNum > currentLineNum + 1) {
-                    const blankLinesToRemove = [];
-                    for (let li = currentLineNum + 1; li < nextRowLineNum; li++) {
-                      const lineEntry = repAfterOrphanRemoval.lines.atIndex(li);
-                      const lineText = lineEntry?.text || '';
-                      // Check if line is blank (empty or just whitespace)
-                      if (!lineText.trim() || lineText === '\n') {
-                        blankLinesToRemove.push(li);
-                      }
-                    }
-                    
-                    // Remove blank lines bottom-up to preserve line numbers
-                    if (!isDestructiveOperationSafe('postWriteCanonicalize blank line removal')) {
-                      console.debug('[ep_data_tables:postWriteCanonicalize] skipping blank line removal (safe mode)');
-                    } else {
-                    blankLinesToRemove.sort((a, b) => b - a).forEach((blankLineNum) => {
-                      try {
-                        // Re-fetch rep and validate line before removal (prevents keyToNodeMap errors)
-                        const repBlankCheck = ace.ace_getRep();
-                        if (!isLineSafeToModify(repBlankCheck, blankLineNum, '[ep_data_tables:postWriteCanonicalize] blank')) {
-                          return;
-                        }
-                        console.debug('[ep_data_tables:postWriteCanonicalize] removing spurious blank line between table rows', {
-                          blankLineNum, betweenRows: [capturedRow, nextRowNum],
-                        });
-                        ace.ace_performDocumentReplaceRange([blankLineNum, 0], [blankLineNum + 1, 0], '');
-                      } catch (blankRemErr) {
-                        console.error('[ep_data_tables:postWriteCanonicalize] blank line removal error', blankRemErr);
-                        handleDomDesyncError(blankRemErr, 'postWriteCanonicalize blank removal');
-                      }
-                    });
-                    }
-                  }
-                } catch (cleanupErr) {
-                  console.error('[ep_data_tables:postWriteCanonicalize] blank line cleanup error', cleanupErr);
-                }
-                  
-                  try { ace.ace_fastIncorp(5); } catch (_) {}
-                }
-              
-              // ALWAYS run blank line cleanup after repair, even if there were no orphans
-              // Grammarly and other extensions can create blank lines without triggering orphan detection
-              try {
-                const repFinal = ace.ace_getRep();
-                if (repFinal && repFinal.lines) {
-                  const finalLineNum = ln;
-                  const totalFinal = repFinal.lines.length();
-                  
-                  const blankLinesToClean = [];
-                  for (let li = finalLineNum + 1; li < totalFinal && li < finalLineNum + 5; li++) {
-                    const lineEntry = repFinal.lines.atIndex(li);
-                    const lineText = lineEntry?.text || '';
-                    
-                    // Check if this is a table row (should stop scanning)
-                    let isTableRow = false;
-                    try {
-                      const attrStr = docManager.getAttributeOnLine(li, ATTR_TABLE_JSON);
-                      if (attrStr) isTableRow = true;
-                    } catch (_) {}
-                    
-                    if (isTableRow) break; // Stop at next table row
-                    
-                    // Check if blank line (empty or just whitespace)
-                    if (!lineText.trim() || lineText === '\n') {
-                      blankLinesToClean.push(li);
-                    } else {
-                      break; // Stop at first non-blank, non-table line
-                    }
-                  }
-                  
-                  // Remove blank lines bottom-up
-                  // Check for DOM desync before destructive operations
-                  if (blankLinesToClean.length > 0 && isDestructiveOperationSafe('postWriteCanonicalize blank-after removal')) {
-                    blankLinesToClean.sort((a, b) => b - a).forEach((blankLineNum) => {
-                      try {
-                        const checkRep = ace.ace_getRep();
-                        if (!isLineSafeToModify(checkRep, blankLineNum, '[ep_data_tables:postWriteCanonicalize] blank-after')) {
-                          return;
-                        }
-                        console.debug('[ep_data_tables:postWriteCanonicalize] removing blank line after repair', {
-                          blankLineNum, afterRow: capturedRow,
-                        });
-                        ace.ace_performDocumentReplaceRange([blankLineNum, 0], [blankLineNum + 1, 0], '');
-                      } catch (blankErr) {
-                        handleDomDesyncError(blankErr, 'postWriteCanonicalize blank-after');
-                      }
-                    });
-                  }
-                }
-              } catch (finalCleanupErr) {
-                console.debug('[ep_data_tables:postWriteCanonicalize] final blank cleanup error (non-fatal)', finalCleanupErr?.message);
-              }
-              
-              try { ace.ace_fastIncorp(5); } catch (_) {}
-              } catch (innerErr) {
-                console.error('[ep_data_tables:postWriteCanonicalize] inner callback error', {
-                  error: innerErr?.message || innerErr,
-                });
-            }
-          }, 'ep_data_tables:postwrite-canonicalize', true);
-          } catch (aceCallErr) {
-            // This catches errors from ace_callWithAce itself (Etherpad internal state corruption)
-            console.warn('[ep_data_tables:postWriteCanonicalize] ace_callWithAce failed - editor state may need refresh', {
-              error: aceCallErr?.message || aceCallErr,
-            });
-          }
-        } finally {
-          __epDT_postWriteScheduled.delete(nodeId);
-          if (__epDT_compositionOriginalLine.tblId === capturedTblId) {
-            __epDT_compositionOriginalLine = { tblId: null, lineNum: null, timestamp: 0 };
-          }
-        }
-      }, 0);
-    }
-    // Stop here; let the next render reflect the canonicalized text.
-    // BUT: if column operation is in progress, continue to render the table with current segments
-    if (!skipMismatchReturn) {
-    return cb();
-    }
-    // Otherwise, fall through to table building below
-  } else {
+    // GRACEFUL DEGRADATION: Log the mismatch but render the table with actual segments
+    // This prevents the cascade of: repair → re-render → mismatch → repair → crash
+    // The table will display with its actual content (may differ from metadata column count)
+    // Content and styling are preserved - user can edit normally
+    // If user edits this row, handleDesktopCommitInput will normalize it at that time
+    console.warn('[ep_data_tables][diag] Segment/column mismatch (rendering as-is)', { 
+      nodeId, lineNum, 
+      actualSegs: htmlSegments.length, 
+      expectedCols: rowMetadata.cols, 
+      tblId: rowMetadata.tblId, 
+      row: rowMetadata.row 
+    });
+    
+    // Always continue to render - don't return early, don't schedule repair
+    skipMismatchReturn = true;
   }
 
   try {
@@ -3387,12 +2601,18 @@ exports.aceInitialized = (h, ctx) => {
             let originalTableLine = null; // Track where the table actually is
             
             // Recover cursor if browser moved it to wrong line between compositions
+            // CONSERVATIVE: More validation, shorter timeout, always clear after check
             let usedCursorRecovery = false;
             if (desktopComposition && desktopComposition._expectedCursor) {
               const stored = desktopComposition._expectedCursor;
               const timeSinceStored = Date.now() - stored.timestamp;
               
-              if (timeSinceStored < 1000) {
+              // Reduced timeout from 1000ms to 500ms for rapid typing safety
+              const isFresh = timeSinceStored < 500;
+              const sameTable = stored.tblId && tableMetadata && stored.tblId === tableMetadata.tblId;
+              const reasonableLineDelta = typeof stored.lineNum === 'number' && Math.abs(lineNum - stored.lineNum) <= 1;
+              
+              if (isFresh && sameTable && reasonableLineDelta) {
                 const currentLine = lineNum;
                 const expectedLine = stored.lineNum;
                 const expectedCell = stored.cellIndex;
@@ -3401,26 +2621,35 @@ exports.aceInitialized = (h, ctx) => {
                 const seemsWrong = lineChanged && (currentLine === expectedLine + 1);
                 
                 if (seemsWrong) {
-                  const storedMeta = getTableMetadataForLine(expectedLine);
-                  if (storedMeta && storedMeta.tblId === stored.tblId) {
-                    lineNum = expectedLine;
-                    cellIndex = expectedCell;
-                    tableMetadata = storedMeta;
-                    originalTableLine = expectedLine;
-                    usedCursorRecovery = true;
+                  // Additional validation: verify stored position is still valid
+                  try {
+                    const storedEntry = rep0.lines.atIndex(expectedLine);
+                    const storedText = storedEntry?.text || '';
+                    const storedCells = storedText.split(DELIMITER);
                     
-                    try {
-                      ed.ace_callWithAce((aceInstance) => {
-                        aceInstance.ace_performSelectionChange([expectedLine, stored.col], [expectedLine, stored.col], false);
-                      }, 'compositionstart-cursor-recovery', true);
-                    } catch (_) {}
-                  }
+                    // Only recover if cell structure matches expectations
+                    if (expectedCell >= 0 && expectedCell < storedCells.length) {
+                      const storedMeta = getTableMetadataForLine(expectedLine);
+                      if (storedMeta && storedMeta.tblId === stored.tblId) {
+                        lineNum = expectedLine;
+                        cellIndex = expectedCell;
+                        tableMetadata = storedMeta;
+                        originalTableLine = expectedLine;
+                        usedCursorRecovery = true;
+                        
+                        try {
+                          ed.ace_callWithAce((aceInstance) => {
+                            aceInstance.ace_performSelectionChange([expectedLine, stored.col], [expectedLine, stored.col], false);
+                          }, 'compositionstart-cursor-recovery', true);
+                        } catch (_) {}
+                      }
+                    }
+                  } catch (_) { /* validation failed, don't recover */ }
                 }
               }
               
-              if (timeSinceStored > 1000 || usedCursorRecovery) {
-                delete desktopComposition._expectedCursor;
-              }
+              // ALWAYS clear after checking to prevent stale reuse
+              delete desktopComposition._expectedCursor;
             }
             
             try {
@@ -4867,12 +4096,29 @@ exports.aceInitialized = (h, ctx) => {
       const dataPreview = typeof nativeEvt?.data === 'string' ? nativeEvt.data : '';
       logCompositionEvent('compositionend-desktop-fired', evt, { data: dataPreview });
 
-      // Capture desktopComposition state before async ops
-      // which would overwrite desktopComposition and cause us to use the wrong state.
-      const capturedComposition = desktopComposition ? { ...desktopComposition } : null;
-      
-        // Prevent the immediate post-composition input commit from running; we pipeline instead
-        suppressNextInputCommit = true;
+      // CRITICAL: Capture composition state with DEEP COPY before async deferral.
+      // This prevents race conditions where a new compositionstart overwrites state
+      // before this callback executes. Deep copy all arrays to prevent shared references.
+      const capturedComposition = desktopComposition
+        ? {
+            active: desktopComposition.active,
+            start: desktopComposition.start ? desktopComposition.start.slice() : null,
+            end: desktopComposition.end ? desktopComposition.end.slice() : null,
+            lineNum: desktopComposition.lineNum,
+            cellIndex: desktopComposition.cellIndex,
+            tblId: desktopComposition.tblId,
+            snapshot: desktopComposition.snapshot ? desktopComposition.snapshot.slice() : null,
+            snapshotMeta: desktopComposition.snapshotMeta ? { ...desktopComposition.snapshotMeta } : null,
+            originalTableLine: desktopComposition.originalTableLine,
+            usedCursorRecovery: desktopComposition.usedCursorRecovery,
+          }
+        : null;
+
+      // Capture the commit string synchronously too (before any async deferral)
+      const commitStrRawSync = typeof nativeEvt?.data === 'string' ? nativeEvt.data : '';
+
+      // Prevent the immediate post-composition input commit from running; we pipeline instead
+      suppressNextInputCommit = true;
       requestAnimationFrame(() => {
         try {
           ed.ace_callWithAce((aceInstance) => {
@@ -4892,12 +4138,12 @@ exports.aceInitialized = (h, ctx) => {
               return;
             }
             
-            // Pipeline: Apply committed IME string synchronously to the target cell
-            const commitStrRaw = typeof nativeEvt?.data === 'string' ? nativeEvt.data : '';
-            const commitStr = sanitizeCellContent(commitStrRaw || '');
+            // Pipeline: Apply committed IME string to the target cell
+            // Use the synchronously captured commit string (commitStrRawSync) to avoid race conditions
+            const commitStr = sanitizeCellContent(commitStrRawSync || '');
             // Only suppress the next beforeinput commit if the IME provided a non-empty commit string.
             // Normalize using the same soft-whitespace rules the editor uses.
-            const willCommit = typeof commitStrRaw === 'string' && normalizeSoftWhitespace(commitStrRaw).trim().length > 0;
+            const willCommit = typeof commitStrRawSync === 'string' && normalizeSoftWhitespace(commitStrRawSync).trim().length > 0;
             if (willCommit) suppressNextBeforeinputCommitOnce = true;
               const repNow = aceInstance.ace_getRep();
               const caret = repNow && repNow.selStart;
@@ -5025,15 +4271,44 @@ exports.aceInitialized = (h, ctx) => {
             }
               const cellsNow = (entry.text || '').split(DELIMITER);
               while (cellsNow.length < metadata.cols) cellsNow.push(' ');
-              // Prefer the cell index captured at compositionstart; otherwise compute using RAW mapping.
-              let idx = (capturedComposition && capturedComposition.cellIndex >= 0)
-                ? capturedComposition.cellIndex
-                : (() => {
-                    const selCol = (capturedComposition && capturedComposition.start) ? capturedComposition.start[1] : (caret ? caret[1] : 0);
-                    const rawMap = computeTargetCellIndexFromRaw(entry, selCol);
-                    return rawMap.index;
-                  })();
-            if (idx < 0) idx = Math.min(metadata.cols - 1, 0);
+              
+              // DEFENSIVE CELL INDEX RESOLUTION:
+              // 1. Prefer the cell index captured at compositionstart
+              // 2. Fall back to live DOM selection (authoritative for current cursor)
+              // 3. Fall back to raw line text mapping using current caret
+              // 4. Final fallback: first cell (ensures we never lose text)
+              let idx = -1;
+              
+              // Strategy 1: Use captured cell index from compositionstart
+              if (capturedComposition && capturedComposition.cellIndex >= 0) {
+                idx = capturedComposition.cellIndex;
+              }
+              
+              // Strategy 2: Use live DOM selection as authoritative source
+              if (idx < 0) {
+                try {
+                  const liveDomTarget = getDomCellTargetFromSelection();
+                  if (liveDomTarget && typeof liveDomTarget.idx === 'number' && liveDomTarget.idx >= 0) {
+                    idx = liveDomTarget.idx;
+                  }
+                } catch (_) { /* ignore DOM errors */ }
+              }
+              
+              // Strategy 3: Compute from raw line text using captured or current caret
+              if (idx < 0) {
+                try {
+                  const selCol = (capturedComposition && capturedComposition.start) 
+                    ? capturedComposition.start[1] 
+                    : (caret ? caret[1] : 0);
+                  const rawMap = computeTargetCellIndexFromRaw(entry, selCol);
+                  if (rawMap.index >= 0) idx = rawMap.index;
+                } catch (_) { /* ignore */ }
+              }
+              
+              // Strategy 4: Final fallback - first cell (ensures no data loss)
+              if (idx < 0) idx = 0;
+              // Clamp to valid range
+              if (idx >= metadata.cols) idx = metadata.cols - 1;
 
             // Compute relative selection in cell
               let baseOffset = 0;
@@ -5100,7 +4375,21 @@ exports.aceInitialized = (h, ctx) => {
               }
 
             // Post-composition orphan detection and repair using snapshot
+            // Capture timestamp for staleness check
+            const orphanRepairScheduledAt = Date.now();
             setTimeout(() => {
+              // GUARD: Skip if a new composition started since we scheduled this
+              // This prevents concurrent document modifications during rapid typing
+              if (__epDT_compositionActive) {
+                console.debug('[ep_data_tables:compositionend-orphan-repair] skipped - new composition active');
+                return;
+              }
+              // Also skip if another composition just ended (within 30ms)
+              if (Date.now() - __epDT_lastCompositionEndTime < 30 && __epDT_lastCompositionEndTime > orphanRepairScheduledAt) {
+                console.debug('[ep_data_tables:compositionend-orphan-repair] skipped - very recent composition end');
+                return;
+              }
+              
               // Pre-check editor state
               // (keyToNodeMap.get(...) is undefined error)
               try {
@@ -5472,7 +4761,10 @@ exports.aceInitialized = (h, ctx) => {
               }
             }, 50); // Small delay to let Etherpad process the cell edit first
 
+            // Reset composition state but PRESERVE _expectedCursor for next compositionstart
+            const preservedCursor = desktopComposition._expectedCursor;
             desktopComposition = { active: false, start: null, end: null, lineNum: null, cellIndex: -1, snapshot: null, snapshotMeta: null };
+            if (preservedCursor) desktopComposition._expectedCursor = preservedCursor;
           }, 'tableDesktopCompositionEnd');
         } catch (compositionErr) {
           console.error(`${compLogPrefix} ERROR during desktop composition repair:`, compositionErr);