feat: unify edit history (#2946)

Author: harbournick

packages/document-api/src/contract/operation-definitions.ts

@@ -3317,7 +3317,7 @@ export const OPERATION_DEFINITIONS = {
 
   'history.get': {
     memberPath: 'history.get',
-    description: 'Query the current undo/redo history state of the active editor.',
+    description: 'Query the current undo/redo history state of the document.',
     expectedResult:
       'Returns a HistoryState object with undoDepth, redoDepth, canUndo, canRedo, and a list of history-unsafe operations.',
     requiresDocumentContext: true,
@@ -3330,7 +3330,7 @@ export const OPERATION_DEFINITIONS = {
 
   'history.undo': {
     memberPath: 'history.undo',
-    description: 'Undo the most recent history-safe mutation in the active editor.',
+    description: 'Undo the most recent history-safe mutation in the document.',
     expectedResult:
       'Returns a HistoryActionResult with noop flag, reason (EMPTY_UNDO_STACK | NO_EFFECT when noop), and revision before/after.',
     requiresDocumentContext: true,
@@ -3350,7 +3350,7 @@ export const OPERATION_DEFINITIONS = {
 
   'history.redo': {
     memberPath: 'history.redo',
-    description: 'Redo the most recently undone action in the active editor.',
+    description: 'Redo the most recently undone action in the document.',
     expectedResult:
       'Returns a HistoryActionResult with noop flag, reason (EMPTY_REDO_STACK | NO_EFFECT when noop), and revision before/after.',
     requiresDocumentContext: true,

packages/layout-engine/layout-bridge/src/text-measurement.ts

@@ -19,6 +19,14 @@ let measurementCanvas: HTMLCanvasElement | null = null;
 let measurementCtx: CanvasRenderingContext2D | null = null;
 
 const TAB_CHAR_LENGTH = 1;
+const FOOTNOTE_MARKER_DATA_ATTR = 'data-sd-footnote-number';
+
+const getRunDataAttrs = (run: Run | undefined): Record<string, string> | undefined => {
+  if (!run || !('dataAttrs' in run)) {
+    return undefined;
+  }
+  return run.dataAttrs;
+};
 
 const getRunCharacterLength = (run: Run | undefined): number => {
   if (!run) return 0;
@@ -35,6 +43,10 @@ const getRunCharacterLength = (run: Run | undefined): number => {
   return run.text?.length ?? 0;
 };
 
+const isVisualOnlyRun = (run: Run | undefined): boolean => {
+  return getRunDataAttrs(run)?.[FOOTNOTE_MARKER_DATA_ATTR] === 'true';
+};
+
 /**
  * Characters considered as spaces for justify alignment calculations.
  * Only includes regular space (U+0020) and non-breaking space (U+00A0).
@@ -703,28 +715,27 @@ export function charOffsetToPm(block: FlowBlock, line: Line, charOffset: number,
   let cursor = 0;
   let lastPm = fallbackPmStart;
 
-  for (const run of runs) {
-    const isTab = isTabRun(run);
-    const text =
-      'src' in run ||
-      run.kind === 'lineBreak' ||
-      run.kind === 'break' ||
-      run.kind === 'fieldAnnotation' ||
-      run.kind === 'math'
-        ? ''
-        : (run.text ?? '');
-    const runLength = isTab ? TAB_CHAR_LENGTH : text.length;
-
-    const runPmStart = typeof run.pmStart === 'number' ? run.pmStart : null;
-    const runPmEnd = typeof run.pmEnd === 'number' ? run.pmEnd : runPmStart != null ? runPmStart + runLength : null;
+  for (let runIndex = 0; runIndex < runs.length; runIndex += 1) {
+    const run = runs[runIndex];
+    const runLength = getRunCharacterLength(run);
+    const runPmStart = resolveRunPmStart(run, runLength);
+    const runPmEnd = resolveRunPmEnd(run, runLength, runPmStart);
 
     if (runPmStart != null) {
       lastPm = runPmStart;
     }
 
     if (safeCharOffset <= cursor + runLength) {
       const offsetInRun = Math.max(0, safeCharOffset - cursor);
-      return runPmStart != null ? runPmStart + Math.min(offsetInRun, runLength) : fallbackPmStart + safeCharOffset;
+      if (runPmStart != null) {
+        return runPmStart + Math.min(offsetInRun, runLength);
+      }
+
+      if (isVisualOnlyRun(run)) {
+        return resolveVisualOnlyRunBoundary(runs, runIndex, offsetInRun, runLength, lastPm);
+      }
+
+      return fallbackPmStart + safeCharOffset;
     }
 
     if (runPmEnd != null) {
@@ -737,6 +748,72 @@ export function charOffsetToPm(block: FlowBlock, line: Line, charOffset: number,
   return lastPm;
 }
 
+const resolveRunPmStart = (run: Run | undefined, runLength: number): number | null => {
+  if (!run) {
+    return null;
+  }
+
+  if (typeof run.pmStart === 'number') {
+    return run.pmStart;
+  }
+
+  if (typeof run.pmEnd === 'number') {
+    return run.pmEnd - runLength;
+  }
+
+  return null;
+};
+
+const resolveRunPmEnd = (run: Run | undefined, runLength: number, runPmStart: number | null): number | null => {
+  if (!run) {
+    return null;
+  }
+
+  if (typeof run.pmEnd === 'number') {
+    return run.pmEnd;
+  }
+
+  if (runPmStart != null) {
+    return runPmStart + runLength;
+  }
+
+  return null;
+};
+
+const findNextPmBoundary = (runs: readonly Run[], startIndex: number, fallbackPm: number): number => {
+  for (let runIndex = startIndex; runIndex < runs.length; runIndex += 1) {
+    const run = runs[runIndex];
+    const runLength = getRunCharacterLength(run);
+    const nextPmStart = resolveRunPmStart(run, runLength);
+    if (nextPmStart != null) {
+      return nextPmStart;
+    }
+
+    const nextPmEnd = resolveRunPmEnd(run, runLength, nextPmStart);
+    if (nextPmEnd != null) {
+      return nextPmEnd;
+    }
+  }
+
+  return fallbackPm;
+};
+
+const resolveVisualOnlyRunBoundary = (
+  runs: readonly Run[],
+  runIndex: number,
+  offsetInRun: number,
+  runLength: number,
+  previousPmBoundary: number,
+): number => {
+  const nextPmBoundary = findNextPmBoundary(runs, runIndex + 1, previousPmBoundary);
+  if (runLength <= 0 || previousPmBoundary === nextPmBoundary) {
+    return previousPmBoundary;
+  }
+
+  const midpoint = runLength / 2;
+  return offsetInRun < midpoint ? previousPmBoundary : nextPmBoundary;
+};
+
 /**
  * Find the character offset and PM position at a given X coordinate within a line.
  * This is the inverse of measureCharacterX.

packages/layout-engine/layout-bridge/test/text-measurement.test.ts

@@ -238,6 +238,25 @@ describe('text measurement utility', () => {
     expect(secondTab.pmPosition).toBeLessThanOrEqual(3);
   });
 
+  it('maps clicks through leading visual-only marker runs to editable PM positions', () => {
+    const block = createBlock([
+      { text: '1', fontFamily: 'Arial', fontSize: 16, dataAttrs: { 'data-sd-footnote-number': 'true' } } as Run,
+      { text: 'Hello', fontFamily: 'Arial', fontSize: 16, pmStart: 0, pmEnd: 5 },
+    ]);
+    const line = baseLine({
+      fromRun: 0,
+      toRun: 1,
+      toChar: 6,
+      width: 6 * CHAR_WIDTH,
+    });
+
+    const markerHit = findCharacterAtX(block, line, CHAR_WIDTH / 2, 0);
+    expect(markerHit.pmPosition).toBe(0);
+
+    const textHit = findCharacterAtX(block, line, CHAR_WIDTH * 3.5, 0);
+    expect(textHit.pmPosition).toBe(3);
+  });
+
   describe('charOffsetToPm edge cases', () => {
     it('clamps character offset beyond line bounds to end position', () => {
       const block = createBlock([{ text: 'Hello', fontFamily: 'Arial', fontSize: 16, pmStart: 0, pmEnd: 5 }]);
@@ -380,6 +399,22 @@ describe('text measurement utility', () => {
       const result = charOffsetToPm(block, line, 0, 5);
       expect(result).toBe(5);
     });
+
+    it('does not advance PM positions through visual-only marker runs', () => {
+      const block = createBlock([
+        { text: '1', fontFamily: 'Arial', fontSize: 16, dataAttrs: { 'data-sd-footnote-number': 'true' } } as Run,
+        { text: 'Hello', fontFamily: 'Arial', fontSize: 16, pmStart: 0, pmEnd: 5 },
+      ]);
+      const line = baseLine({
+        fromRun: 0,
+        toRun: 1,
+        toChar: 6,
+      });
+
+      expect(charOffsetToPm(block, line, 0, 0)).toBe(0);
+      expect(charOffsetToPm(block, line, 1, 0)).toBe(0);
+      expect(charOffsetToPm(block, line, 3, 0)).toBe(2);
+    });
   });
 
   describe('countSpaces helper', () => {

packages/super-editor/src/editors/v1/core/extensions/editable.js

@@ -2,24 +2,86 @@ import { Plugin, PluginKey } from 'prosemirror-state';
 import { __endComposition } from 'prosemirror-view';
 import { Extension } from '../Extension.js';
 
-const handleInsertTextBeforeInput = (view, event) => {
+const appendStoryInputDebugLog = (entry) => {
+  const debugGlobal = globalThis;
+  if (debugGlobal.__SD_DEBUG_STORY_INPUT__ !== true) {
+    return;
+  }
+
+  const existingLog = Array.isArray(debugGlobal.__SD_DEBUG_STORY_INPUT_LOG__)
+    ? debugGlobal.__SD_DEBUG_STORY_INPUT_LOG__
+    : [];
+
+  existingLog.push(entry);
+  if (existingLog.length > 200) {
+    existingLog.splice(0, existingLog.length - 200);
+  }
+
+  debugGlobal.__SD_DEBUG_STORY_INPUT_LOG__ = existingLog;
+};
+
+const isStorySurfaceEditor = (editor) => {
+  const documentId = editor?.options?.documentId ?? '';
+  return documentId.startsWith('hf:') || documentId.startsWith('fn:') || documentId.startsWith('en:');
+};
+
+const recordStoryInputDebug = (view, event, editor, phase, extra = {}) => {
+  if (!isStorySurfaceEditor(editor)) {
+    return;
+  }
+
+  let domAnchorPos = null;
+  const domSelection = view?.dom?.ownerDocument?.getSelection?.() ?? null;
+
+  try {
+    if (view?.dom && domSelection?.anchorNode && view.dom.contains(domSelection.anchorNode)) {
+      domAnchorPos = view.posAtDOM(domSelection.anchorNode, domSelection.anchorOffset, -1);
+    }
+  } catch {
+    domAnchorPos = null;
+  }
+
+  appendStoryInputDebugLog({
+    phase,
+    documentId: editor?.options?.documentId ?? null,
+    inputType: event?.inputType ?? null,
+    data: event?.data ?? null,
+    cancelable: event?.cancelable ?? null,
+    defaultPrevented: event?.defaultPrevented ?? null,
+    selectionFrom: view?.state?.selection?.from ?? null,
+    selectionTo: view?.state?.selection?.to ?? null,
+    domAnchorPos,
+    ...extra,
+  });
+};
+
+const handleInsertTextBeforeInput = (view, event, editor) => {
   const isInsertTextInput = event?.inputType === 'insertText';
   const hasTextData = typeof event?.data === 'string' && event.data.length > 0;
   const isComposing = event?.isComposing === true;
 
+  recordStoryInputDebug(view, event, editor, 'beforeinput:start', {
+    isInsertTextInput,
+    hasTextData,
+    isComposing,
+  });
+
   if (!isInsertTextInput || !hasTextData || isComposing) {
+    recordStoryInputDebug(view, event, editor, 'beforeinput:skip');
     return false;
   }
 
   const selection = view.state.selection;
-  if (selection.empty) {
+  if (selection.empty && !isStorySurfaceEditor(editor)) {
+    recordStoryInputDebug(view, event, editor, 'beforeinput:skip-empty-selection');
     return false;
   }
 
   const tr = view.state.tr.insertText(event.data, selection.from, selection.to);
   tr.setMeta('inputType', 'insertText');
   view.dispatch(tr);
   event.preventDefault();
+  recordStoryInputDebug(view, event, editor, 'beforeinput:handled');
 
   return true;
 };
@@ -91,6 +153,7 @@ export const Editable = Extension.create({
         editable: () => editor.options.editable,
         handleDOMEvents: {
           beforeinput: (view, event) => {
+            recordStoryInputDebug(view, event, editor, 'dom:beforeinput');
             if (!editor.options.editable) {
               event.preventDefault();
               return true;
@@ -104,11 +167,15 @@ export const Editable = Extension.create({
             // can widen the replace range around hidden inline content in story
             // editors. Apply the replacement against the PM selection directly
             // before the browser mutates the DOM.
-            if (handleInsertTextBeforeInput(view, event)) {
+            if (handleInsertTextBeforeInput(view, event, editor)) {
               return true;
             }
             return false;
           },
+          input: (view, event) => {
+            recordStoryInputDebug(view, event, editor, 'dom:input');
+            return false;
+          },
           compositionstart: (view, event) => blockWhenNotEditable(view, event),
           compositionupdate: (view, event) => blockWhenNotEditable(view, event),
           compositionend: (view, event) => blockWhenNotEditable(view, event),