fix: newline style inheritance after clearing inline formatting (SD-2228) (#2559)

* fix(editor): treat empty storedMarks array as explicit no-formatting override

When storedMarks is set to an empty array ([]), it represents an
intentional user action to clear all formatting. Previously, the
`|| null` coercion and falsy checks on storedMarks caused empty arrays
to be treated the same as absent storedMarks, falling through to
paragraph/style inheritance and re-applying formatting the user had
explicitly removed.

Switch from `||` to `??` and introduce a `hasStoredMarks` flag using
strict null checks so that an empty array is respected as "no marks".

* fix(editor): preserve explicit stored marks across paragraph splits

When a user applies formatting (e.g., bold) and then presses Enter to
create a new paragraph, the storedMarks set by the formatting action
were being overwritten by applyStyleMarks, which resolved style marks
from the document's style hierarchy. This caused the user's explicit
formatting choice to be lost on the new line.

Capture storedMarks before style resolution and, when present, restore
or retain them instead of replacing with style-resolved marks.

* fix(editor): preserve storedMarks through run-management plugins

The run-management append-only plugins (calculateInlineRunProperties,
cleanupEmptyRuns, wrapTextInRuns) emit follow-up transactions that
rebuild run nodes and normalize selections. These transactions
inadvertently clear storedMarks, discarding formatting the user had
explicitly toggled before typing.

Propagate the original storedMarks through each plugin's transaction
so that explicit formatting state survives run restructuring.

* fix(editor): clear inherited paragraph runProperties on split when run has no formatting

When pressing Enter at the end of a run that has no inline formatting,
the new paragraph was inheriting the parent paragraph's runProperties
(e.g., bold). This caused the new line to appear formatted even though
the cursor was in an unformatted run.

Extract a shared syncSplitParagraphRunProperties helper that either
copies the current run's properties or explicitly removes them from
the new paragraph attrs, ensuring the split paragraph only inherits
formatting that the run actually carries.

* test(behavior): add e2e test for new-line style inheritance (SD-2228)

Verify that pressing Enter at the end of a line where bold+italic was
explicitly removed does not carry those marks into the new paragraph.
Covers the full user flow: type formatted text, remove formatting from
the end of the line, press Enter, and assert the new line is unformatted.

* fix(super-editor): preserve empty paragraph run properties on split

* fix(super-editor): honor cleared stored marks in formatting state

* fix(super-editor): preserve cleared formatting when splitting paragraphs

* fix(super-editor): preserve enclosing run properties on split-run fallback

* refactor(super-editor): share normalizeRunProperties helper

Author: luccas-harbour

packages/super-editor/src/core/commands/splitBlock.js

@@ -1,6 +1,7 @@
 import { NodeSelection, TextSelection } from 'prosemirror-state';
 import { canSplit } from 'prosemirror-transform';
 import { defaultBlockAt } from '../helpers/defaultBlockAt.js';
+import { getSplitRunProperties, syncSplitParagraphRunProperties } from '../helpers/splitParagraphRunProperties.js';
 import { Attribute } from '../Attribute.js';
 import { clearInheritedLinkedStyleId } from './linkedStyleSplitHelpers.js';
 
@@ -29,21 +30,6 @@ const ensureMarks = (state, splittableMarks) => {
   }
 };
 
-/**
- * Extracts runProperties from the run node at the cursor position.
- * When the cursor is directly inside a paragraph (not inside a run), it
- * looks at the node just before the cursor (which is typically a run node).
- * @param {import('prosemirror-model').ResolvedPos} $from
- * @returns {Record<string, unknown> | null}
- */
-const getRunPropertiesAtCursor = ($from) => {
-  const runNode = $from.nodeBefore;
-  if (runNode?.type.name === 'run' && runNode.attrs.runProperties) {
-    return { ...runNode.attrs.runProperties };
-  }
-  return null;
-};
-
 /**
  * Will split the current node into two nodes. If the selection is not
  * splittable, the command will be ignored.
@@ -87,16 +73,8 @@ export const splitBlock =
       // current run's runProperties on the new paragraph so the toolbar and
       // wrapTextInRunsPlugin know which inline formatting to inherit.
       if (atEnd) {
-        const runProperties = getRunPropertiesAtCursor($from);
-        if (runProperties) {
-          newAttrs = {
-            ...newAttrs,
-            paragraphProperties: {
-              ...(newAttrs.paragraphProperties || {}),
-              runProperties,
-            },
-          };
-        }
+        const runProperties = getSplitRunProperties(state, $from);
+        newAttrs = syncSplitParagraphRunProperties(newAttrs, runProperties);
       }
       if (selection instanceof TextSelection) tr.deleteSelection();
       const deflt = $from.depth === 0 ? null : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));

packages/super-editor/src/core/commands/splitBlock.test.js

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TextSelection } from 'prosemirror-state';
 import { splitBlock } from './splitBlock.js';
 
 vi.mock('../Attribute.js', () => ({
@@ -11,6 +12,21 @@ vi.mock('prosemirror-transform', () => ({
   canSplit: vi.fn(() => true),
 }));
 
+vi.mock('@converter/styles.js', () => ({
+  decodeRPrFromMarks: vi.fn((marks) => {
+    const runProperties = {};
+    for (const mark of marks || []) {
+      if (mark?.type?.name === 'bold' && mark.attrs?.value !== '0' && mark.attrs?.value !== false) {
+        runProperties.bold = true;
+      }
+      if (mark?.type?.name === 'textStyle') {
+        Object.assign(runProperties, mark.attrs || {});
+      }
+    }
+    return runProperties;
+  }),
+}));
+
 /**
  * Create a mock resolved position ($from/$to) compatible with ProseMirror
  */
@@ -209,6 +225,104 @@ describe('splitBlock', () => {
   });
 
   describe('edge cases', () => {
+    it('prefers explicit storedMarks over the previous run when splitting at paragraph end', () => {
+      const paragraphType = { name: 'paragraph', isTextblock: true, hasRequiredAttrs: vi.fn(() => false) };
+      const parentNode = {
+        contentMatchAt: vi.fn(() => ({
+          edgeCount: 1,
+          edge: vi.fn(() => ({ type: paragraphType })),
+        })),
+        canReplaceWith: vi.fn(() => true),
+      };
+      const textStyleMark = {
+        type: { name: 'textStyle' },
+        attrs: { fontFamily: 'Arial, sans-serif', fontSize: '12pt' },
+      };
+      const paragraphAttrs = { paragraphProperties: { runProperties: { bold: true } } };
+      const $from = createMockResolvedPos({
+        depth: 1,
+        parent: {
+          isBlock: true,
+          content: { size: 5 },
+          type: { name: 'paragraph' },
+          inlineContent: true,
+          attrs: paragraphAttrs,
+        },
+        parentOffset: 5,
+        node: vi.fn((depth) => {
+          if (depth === -1) return parentNode;
+          return { type: { name: 'paragraph' }, attrs: paragraphAttrs };
+        }),
+        nodeBefore: {
+          type: { name: 'run' },
+          attrs: { runProperties: { bold: true } },
+        },
+        indexAfter: vi.fn(() => 0),
+      });
+      const $to = createMockResolvedPos({
+        parentOffset: 5,
+        parent: { content: { size: 5 } },
+      });
+
+      mockState.storedMarks = [textStyleMark];
+      mockTr.selection = { $from, $to };
+      mockState.selection = mockTr.selection;
+      mockTr.doc = {
+        resolve: vi.fn((pos) => (pos === 1 ? $from : $to)),
+      };
+
+      const command = splitBlock();
+      command({ tr: mockTr, state: mockState, dispatch: () => {}, editor: mockEditor });
+
+      const [, , types] = mockTr.split.mock.calls[0];
+      expect(types[0].attrs.paragraphProperties.runProperties).toEqual(textStyleMark.attrs);
+    });
+
+    it('preserves paragraph runProperties at paragraph end for an empty paragraph', () => {
+      const paragraphType = { name: 'paragraph', isTextblock: true, hasRequiredAttrs: vi.fn(() => false) };
+      const parentNode = {
+        contentMatchAt: vi.fn(() => ({
+          edgeCount: 1,
+          edge: vi.fn(() => ({ type: paragraphType })),
+        })),
+        canReplaceWith: vi.fn(() => true),
+      };
+      const paragraphAttrs = { paragraphProperties: { runProperties: { bold: true } } };
+      const $from = createMockResolvedPos({
+        depth: 1,
+        parent: {
+          isBlock: true,
+          content: { size: 0 },
+          type: { name: 'paragraph' },
+          inlineContent: true,
+          attrs: paragraphAttrs,
+        },
+        parentOffset: 0,
+        node: vi.fn((depth) => {
+          if (depth === -1) return parentNode;
+          return { type: { name: 'paragraph' }, attrs: paragraphAttrs };
+        }),
+        nodeBefore: null,
+        indexAfter: vi.fn(() => 0),
+      });
+      const $to = createMockResolvedPos({
+        parentOffset: 0,
+        parent: { content: { size: 0 } },
+      });
+
+      mockTr.selection = { $from, $to };
+      mockState.selection = mockTr.selection;
+      mockTr.doc = {
+        resolve: vi.fn((pos) => (pos === 1 ? $from : $to)),
+      };
+
+      const command = splitBlock();
+      command({ tr: mockTr, state: mockState, dispatch: () => {}, editor: mockEditor });
+
+      const [, , types] = mockTr.split.mock.calls[0];
+      expect(types[0].attrs.paragraphProperties.runProperties).toEqual({ bold: true });
+    });
+
     it('does not call ensureMarks when keepMarks is false', () => {
       const $from = createMockResolvedPos({
         marks: [{ type: { name: 'bold' }, attrs: { value: true } }],

packages/super-editor/src/core/helpers/getMarksFromSelection.js

@@ -3,6 +3,7 @@ import { calculateResolvedParagraphProperties } from '@extensions/paragraph/reso
 import { decodeRPrFromMarks, encodeMarksFromRPr } from '@converter/styles.js';
 
 import { resolveRunProperties } from '@superdoc/style-engine/ooxml';
+import { normalizeRunProperties } from './normalizeRunProperties.js';
 
 export function getMarksFromSelection(state, editor) {
   return getSelectionFormattingState(state, editor).resolvedMarks;
@@ -13,7 +14,7 @@ export function getSelectionFormattingState(state, editor) {
 
   if (empty) {
     return getFormattingStateAtPos(state, state.selection.$head.pos, editor, {
-      storedMarks: state.storedMarks || null,
+      storedMarks: state.storedMarks ?? null,
       includeCursorMarksWithStoredMarks: true,
     });
   }
@@ -31,14 +32,16 @@ export function getFormattingStateAtPos(state, pos, editor, options = {}) {
   const context = getParagraphRunContext($pos, editor);
   const currentRunProperties = context?.runProperties || null;
   const cursorMarks = $pos.marks();
+  const hasStoredMarks = storedMarks !== null;
+  const hasExplicitEmptyStoredMarks = hasStoredMarks && storedMarks.length === 0;
   const resolvedMarks = [];
   const inlineMarks = [];
 
   let inlineRunProperties = null;
   if (preferParagraphRunProperties) {
     inlineRunProperties = context?.paragraphAttrs?.paragraphProperties?.runProperties || null;
     inlineMarks.push(...createMarksFromRunProperties(state, inlineRunProperties, editor));
-  } else if (storedMarks) {
+  } else if (hasStoredMarks) {
     inlineMarks.push(...storedMarks);
     inlineRunProperties = decodeRPrFromMarks(storedMarks);
   } else if (context?.isEmpty) {
@@ -52,18 +55,28 @@ export function getFormattingStateAtPos(state, pos, editor, options = {}) {
     inlineRunProperties = decodeRPrFromMarks(inlineMarks);
   }
 
+  if (hasExplicitEmptyStoredMarks) {
+    return {
+      resolvedMarks: [],
+      inlineMarks: [],
+      resolvedRunProperties: {},
+      inlineRunProperties: {},
+      styleRunProperties: {},
+    };
+  }
+
   const resolvedFromSelection = getInheritedRunProperties(
     $pos,
     editor,
-    preferParagraphRunProperties || (!storedMarks && context?.isEmpty)
+    preferParagraphRunProperties || (!hasStoredMarks && context?.isEmpty)
       ? context?.paragraphAttrs?.paragraphProperties?.runProperties || null
       : inlineRunProperties,
   );
   const resolvedRunProperties = resolvedFromSelection?.resolvedRunProperties ?? inlineRunProperties;
   const styleRunProperties = resolvedFromSelection?.styleRunProperties ?? null;
   const resolvedMarksFromProperties = createMarksFromRunProperties(state, resolvedRunProperties, editor);
   resolvedMarks.push(...mergeResolvedMarksWithInlineFallback(resolvedMarksFromProperties, inlineMarks));
-  if (storedMarks && includeCursorMarksWithStoredMarks) {
+  if (hasStoredMarks && includeCursorMarksWithStoredMarks) {
     resolvedMarks.push(...cursorMarks);
   }
 
@@ -240,11 +253,6 @@ function getParagraphRunContext($pos, editor) {
   };
 }
 
-function normalizeRunProperties(runProperties) {
-  if (!runProperties || typeof runProperties !== 'object') return null;
-  return Object.keys(runProperties).length > 0 ? runProperties : null;
-}
-
 function getSafeResolutionContext(editor, node, $pos, paragraphAttrs) {
   const fallback = {
     params: {

packages/super-editor/src/core/helpers/getMarksFromSelection.test.js

@@ -104,6 +104,24 @@ describe('getMarksFromSelection', () => {
       expect(result.some((mark) => mark.type.name === 'bold')).toBe(false);
     });
 
+    it('treats empty storedMarks as an explicit no-formatting override', () => {
+      const testDoc = customSchema.node('doc', null, [
+        customSchema.node('paragraph', { paragraphProperties: { runProperties: { bold: true } } }),
+      ]);
+      const baseState = EditorState.create({ schema: customSchema, doc: testDoc });
+      const tr = baseState.tr.setSelection(TextSelection.create(testDoc, 1));
+      tr.setStoredMarks([]);
+      const state = baseState.apply(tr);
+
+      const result = getSelectionFormattingState(state, mockEditor);
+
+      expect(result.inlineMarks).toEqual([]);
+      expect(result.inlineRunProperties).toEqual({});
+      expect(result.resolvedMarks).toEqual([]);
+      expect(result.resolvedRunProperties).toEqual({});
+      expect(result.styleRunProperties).toEqual({});
+    });
+
     it('does not return inherited marks when paragraph has text content', () => {
       const testDoc = customSchema.node('doc', null, [
         customSchema.node('paragraph', { paragraphProperties: { runProperties: { bold: true } } }, [

packages/super-editor/src/core/helpers/normalizeRunProperties.js

@@ -0,0 +1,10 @@
+/**
+ * Normalizes runProperties objects so empty or invalid values are treated as null.
+ *
+ * @param {Record<string, unknown> | null | undefined} runProperties
+ * @returns {Record<string, unknown> | null}
+ */
+export function normalizeRunProperties(runProperties) {
+  if (!runProperties || typeof runProperties !== 'object') return null;
+  return Object.keys(runProperties).length > 0 ? runProperties : null;
+}

packages/super-editor/src/core/helpers/splitParagraphRunProperties.js

@@ -0,0 +1,68 @@
+import { decodeRPrFromMarks } from '@converter/styles.js';
+import { normalizeRunProperties } from './normalizeRunProperties.js';
+
+/**
+ * Extracts runProperties from the cursor context.
+ * When the cursor is directly inside a paragraph (not inside a run), it
+ * looks at the node just before the cursor. For empty paragraphs, it falls
+ * back to `paragraphProperties.runProperties`.
+ *
+ * @param {import('prosemirror-model').ResolvedPos} $from
+ * @returns {Record<string, unknown> | null}
+ */
+export function getRunPropertiesAtCursor($from) {
+  if ($from.parent?.type.name === 'run' && $from.parent.attrs?.runProperties) {
+    return { ...$from.parent.attrs.runProperties };
+  }
+
+  const runNode = $from.nodeBefore;
+  if (runNode?.type.name === 'run' && runNode.attrs.runProperties) {
+    return { ...runNode.attrs.runProperties };
+  }
+
+  if ($from.parent?.type.name === 'paragraph' && $from.parent.content.size === 0) {
+    const paragraphRunProperties = $from.parent.attrs?.paragraphProperties?.runProperties;
+    if (paragraphRunProperties && typeof paragraphRunProperties === 'object') {
+      return { ...paragraphRunProperties };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Resolves the inline formatting source to carry onto a newly split paragraph.
+ * Explicit stored marks take precedence over inherited run-node formatting.
+ *
+ * @param {import('prosemirror-state').EditorState} state
+ * @param {import('prosemirror-model').ResolvedPos} $from
+ * @returns {Record<string, unknown> | null}
+ */
+export function getSplitRunProperties(state, $from) {
+  if (state.storedMarks !== null) {
+    return normalizeRunProperties(decodeRPrFromMarks(state.storedMarks));
+  }
+
+  return getRunPropertiesAtCursor($from);
+}
+
+/**
+ * Sync paragraph-level runProperties for a newly split paragraph.
+ *
+ * @param {Record<string, any>} attrs
+ * @param {Record<string, unknown> | null} runProperties
+ * @returns {Record<string, any>}
+ */
+export function syncSplitParagraphRunProperties(attrs, runProperties) {
+  const nextParagraphProperties = { ...(attrs.paragraphProperties || {}) };
+  if (runProperties) {
+    nextParagraphProperties.runProperties = { ...runProperties };
+  } else {
+    delete nextParagraphProperties.runProperties;
+  }
+
+  return {
+    ...attrs,
+    paragraphProperties: nextParagraphProperties,
+  };
+}

packages/super-editor/src/extensions/run/calculateInlineRunPropertiesPlugin.js

@@ -78,7 +78,7 @@ export const calculateInlineRunPropertiesPlugin = (editor) =>
 
       if (!runPositions.size) return null;
 
-      const selectionPreserver = createSelectionPreserver(tr, newState.selection);
+      const selectionPreserver = createSelectionPreserver(tr, newState.selection, newState.storedMarks);
       const sortedRunPositions = Array.from(runPositions).sort((a, b) => b - a);
 
       sortedRunPositions.forEach((pos) => {
@@ -457,7 +457,7 @@ function stableStringifyInlineProps(inlineProps) {
  * @param {import('prosemirror-state').Selection} originalSelection
  * @returns {{ mapReplacement: (startPos: number, nodeSize: number, replacement: Fragment) => void, finalize: () => void }|null}
  */
-function createSelectionPreserver(tr, originalSelection) {
+function createSelectionPreserver(tr, originalSelection, originalStoredMarks = null) {
   if (!originalSelection) return null;
 
   const isTextSelection = originalSelection instanceof TextSelection;
@@ -534,6 +534,9 @@ function createSelectionPreserver(tr, originalSelection) {
     if (!tr.docChanged) return;
     if (isTextSelection && preservedAnchor != null && preservedHead != null) {
       tr.setSelection(TextSelection.create(tr.doc, preservedAnchor, preservedHead));
+      if (preservedAnchor === preservedHead && originalStoredMarks !== null) {
+        tr.setStoredMarks(originalStoredMarks);
+      }
       return;
     }
     tr.setSelection(originalSelection.map(tr.doc, tr.mapping));