@markup-carve/carve-grammars 0.1.5 → 0.1.6

package/README.md

@@ -162,17 +162,21 @@ Unsupported handling:
 
 - `unsupported: 'throw'` is the default. The loader throws `UnsupportedNodeError`
   instead of silently dropping content.
-- `unsupported: 'preserve'` first builds the richest available document and
-  verifies that serializing it preserves the parsed AST. Unsupported subtrees
-  use opaque `carveUnsupported` blocks; if a mapped document is still lossy,
-  the loader falls back to one whole-document opaque block. `serializeToCarve`
-  writes its source back byte-for-byte, including edge whitespace.
-
-All corpus documents are therefore load/save lossless in preservation mode.
-Some constructs remain opaque rather than directly editable, including parts
-of figures, advanced tables, comments, raw passthrough, and source-layout edge
-cases. `tiptap/schema-map.json` is the public rich-mapping authority;
-`tests/lib/coverage.js` records why structured conversion falls back.
+- `unsupported: 'preserve'` builds the richest available document and verifies
+  its canonical serialization against the parsed AST. When authored columns,
+  delimiter choices, blank ownership, or other source layout cannot be held in
+  ProseMirror attributes, the document carries both the authored source and its
+  canonical projection. `serializeToCarve` performs a three-way merge after an
+  edit, preserving untouched authored layout while giving changed content the
+  canonical Carve spelling.
+
+All 1,538 documents and 440 categories in the pinned corpus are load/save
+lossless in preservation mode, with no whole-document fallback. Abbreviation
+definitions and uses, figures and captions, advanced tables, comments, raw
+passthrough, references, and footnotes all have structured editor mappings.
+`carveToProseMirrorWithReport()` identifies any future construct that still has
+to use a local opaque atom; `tiptap/schema-map.json` is the public mapping
+authority.
 
 ## Tab sets and code groups in the editor
 

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@markup-carve/carve-grammars",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Grammars for the Carve markup language: Tiptap editor kit + serializer, plus Prism, highlight.js and TextMate syntax-highlighting grammars",
   "type": "module",
   "main": "tiptap/index.js",
   "scripts": {
     "test": "npm run test:types && node tests/carve-editor-test.js && node tests/block-battery-test.js && node tests/smart-typography-test.js && node tests/highlight-opener-test.js && node tests/fenced-quote-opener-test.js && node tests/coverage-test.js && node tests/construct-ledger-test.js && node tests/opaque-payload-test.js && node tests/latest-syntax-test.js && node tests/schema-map-test.js && node tests/scans-are-bounded-test.js && node tests/braced-scan-equivalence-test.js && node tests/line-ambiguity-test.js && node tests/snapshot-test.js && node tests/roundtrip-test.js && node tests/node-producers-test.js && node tests/wire-fixtures-test.js && node tests/loss-report-test.js && node tests/authored-spelling-test.js && node tests/optional-corpus-test.js && node tests/mounted-roundtrip-test.js && node tests/serializer-test.js && node tests/tabs-roundtrip-test.js && node tests/panel-bar-test.js && node tests/parse-test.js && node tests/language-attribute-test.js && node tests/blockquote-caption-test.js && node tests/composite-figure-test.js && node tests/composite-figure-tiptap-test.js && node tests/grammar-test.js && node tests/shiki-test.js && node tests/alias-parity-test.js && node tests/engine-sweep-test.js && node tests/abbreviation-term-test.js && node tests/unclosed-delimiter-test.js && node tests/textmate-sweep-test.js && node tests/kroki-test.js && node tests/client-diagram-test.js && node tests/packaging-test.js && node tests/no-git-dependencies-test.js && node tests/engine-drift-test.js && node tests/surface-drift-test.js",
-    "test:types": "tsc -p tsconfig.types.json",
+    "test:types": "tsc -p tsconfig.types.json && node tests/source-merge-test.js",
     "test:citations": "node tests/spec-citations-test.js",
     "test:coverage": "node tests/coverage-test.js",
     "test:snapshot": "node tests/snapshot-test.js",
@@ -83,7 +83,8 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@markup-carve/carve": "^0.1.4"
+    "@markup-carve/carve": "^0.1.5",
+    "node-diff3": "^3.2.1"
   },
   "peerDependencies": {
     "@shikijs/themes": "^2 || ^3",

package/tiptap/carve-kit.js

@@ -32,6 +32,7 @@ import { CarveMath } from './extensions/carve-math.js';
 import { CarveFootnoteDefinition } from './extensions/carve-footnote-definition.js';
 import { CarveEmbed } from './extensions/carve-embed.js';
 import { CarveAbbreviation } from './extensions/carve-abbreviation.js';
+import { CarveAbbreviationDefinition } from './extensions/carve-abbreviation-definition.js';
 import { CarveDefinitionList, CarveDefinitionTerm, CarveDefinitionDescription } from './extensions/carve-definition-list.js';
 import { CarveUnsupported } from './extensions/carve-unsupported.js';
 import { CarveUnsupportedInline } from './extensions/carve-unsupported-inline.js';
@@ -678,6 +679,9 @@ export const CarveKit = Extension.create({
         if (this.options.carveAbbreviation !== false) {
             extensions.push(CarveAbbreviation.configure(this.options.carveAbbreviation ?? {}));
         }
+        if (this.options.carveAbbreviationDefinition !== false) {
+            extensions.push(CarveAbbreviationDefinition.configure(this.options.carveAbbreviationDefinition ?? {}));
+        }
 
         // Definition list nodes (maps to : term with definition)
         if (this.options.definitionList !== false) {

package/tiptap/carve-to-pm.js

@@ -129,20 +129,22 @@ function opaqueDocument(source, ctx = null) {
 
 function sourceEnvelope(doc, sourceLayout, ctx = null) {
     // The rich projection is kept, but writing it back would not reproduce the
-    // document, so the source rides along and the serializer replays it while
-    // the document is untouched. The FIRST EDIT invalidates the fingerprint and
-    // the projection becomes what is written - which is why this is reported.
+    // document, so the source and canonical projection ride along as the two
+    // merge bases. Edits are applied to the authored branch, preserving layout
+    // outside the changed region.
     record(ctx, 'preserved', 'document',
-        'the rich projection is not write-identical; the source envelope carries the document until it is edited');
+        'the rich projection is not write-identical; edits are merged into its authored source envelope');
 
     const clean = { ...doc };
     delete clean.attrs;
+    const projectedSource = serializeToCarve(clean);
     return {
         ...clean,
         attrs: {
             carveSource: sourceLayout.source,
             carveFingerprint: pmFingerprint(clean),
             carveSourceLayout: JSON.stringify(sourceLayout),
+            carveProjectedSource: projectedSource,
         },
     };
 }
@@ -545,7 +547,10 @@ function convertBlock(node, ctx) {
         // does not faithfully represent. Throwing routes the category to SKIP.
         case 'abbreviation-def':
         case 'abbreviation_def':
-            return unsupported('abbreviation-def', node, ctx);
+            return {
+                type: 'carveAbbreviationDefinition',
+                attrs: { abbr: node.abbr || '', expansion: node.expansion || '' },
+            };
         case 'raw-block':
         case 'raw_block':
             return {
@@ -708,7 +713,23 @@ function convertDefinitionList(node, ctx) {
     // The list's OWN attribute run. Nothing read it, so `{loose}` above a
     // definition list was gone before the projection was even mounted - the
     // node arrived with no attrs at all (markup-carve/carve-grammars#344).
-    const attrs = convertAttrs(node.attrs);
+    // Looseness is CONTENT here - a loose description renders its body in a
+    // `<p>`, a tight one bare - and PART 9 section 17 L7 leaves `{loose}` as
+    // its only spelling, since no blank line can carry it.
+    //
+    // The engine used to leave it in the attribute run and now reads it into
+    // the node's own `loose` flag, so reading `attrs` alone dropped it. Folding
+    // it back into the run rather than inventing a second slot means the
+    // existing value-less-attribute path writes it, and a mount keeps it in
+    // `carveKeyValues`, which is already declared.
+    const runAttrs = node.loose === true
+        ? {
+            ...(node.attrs || {}),
+            keyValues: { loose: '', ...(node.attrs?.keyValues || {}) },
+            order: ['loose', ...((node.attrs?.order || []).filter((k) => k !== 'loose'))],
+        }
+        : node.attrs;
+    const attrs = convertAttrs(runAttrs);
     for (const item of node.items || []) {
         for (const term of item.terms || []) {
             content.push({ type: 'definitionTerm', content: convertInline(term, ctx) });
@@ -908,6 +929,24 @@ function convertInlineNode(node, marks, ctx) {
                 ? [{ type: 'text', text: node.value, ...(marks.length ? { marks } : {}) }]
                 : [];
 
+        // Smart punctuation is a TYPOGRAPHIC reading of characters the author
+        // typed, so the characters are what the editor carries: `node.value`
+        // is the authored spelling (`--`, `...`, `"`) and `node.glyph` the
+        // rendered one. Writing the glyph would bake the engine's reading into
+        // the source and change the document; writing the value re-parses to
+        // the same node, so the round trip is byte-identical.
+        //
+        // Left unmapped, the converter THREW on ordinary prose - an em dash, an
+        // ellipsis or a typographic quote was enough - so any such document
+        // took the whole-document fallback instead of being editable.
+        case 'smart_punctuation':
+            record(ctx, 'degraded', 'smart_punctuation',
+                'the typographic reading is re-derived on parse; the authored characters survive as text');
+
+            return node.value
+                ? [{ type: 'text', text: node.value, ...(marks.length ? { marks } : {}) }]
+                : [];
+
         case 'soft-break':
         case 'soft_break':
             // A NEWLINE, not a space. A soft break is a line break the author
@@ -1120,6 +1159,24 @@ function convertInlineNode(node, marks, ctx) {
                 attrs: { content: node.content || '', delimited: Boolean(node.delimited) },
             }];
 
+        case 'abbreviation':
+            // A definition-resolved abbreviation is still editable text. The
+            // mark carries its expansion for `<abbr title>`, while `resolved`
+            // tells the writer the author used the bare term rather than an
+            // explicit semantic span.
+            if (marks.some((mark) => mark.type === 'carveAbbreviation')) {
+                return [{ type: 'text', text: node.abbr || '', ...(marks.length ? { marks } : {}) }];
+            }
+            return [{ type: 'text', text: node.abbr || '', marks: [...marks, {
+                type: 'carveAbbreviation',
+                attrs: { title: node.expansion || '', resolved: true },
+            }] }];
+
+        case 'caption_number':
+            // `#` is the authored placeholder. Its rendered number is a
+            // resolution artifact and therefore does not belong on the wire.
+            return [{ type: 'text', text: '#', ...(marks.length ? { marks } : {}) }];
+
         default: {
             const markType = INLINE_MARKS[node.type];
             if (markType) {
@@ -1164,8 +1221,15 @@ function convertSpan(node, marks, ctx) {
         // Only a lone abbr attribute round-trips through carveAbbreviation; any
         // companion id/class/other key would be dropped.
         const extraKeys = Object.keys(a.keyValues).filter((k) => k !== 'abbr');
-        if (extraKeys.length || a.id || (a.classes && a.classes.length)) throw new UnsupportedNodeError('span-abbr-plus-attrs', node);
-        return descend(node, [...marks, { type: 'carveAbbreviation', attrs: { title: a.keyValues.abbr } }], ctx);
+        const hasCompanions = extraKeys.length || a.id || (a.classes && a.classes.length);
+        const abbrMark = {
+            type: 'carveAbbreviation',
+            attrs: {
+                title: a.keyValues.abbr,
+                ...(hasCompanions ? { resolved: false, ...(convertAttrs(a) || {}) } : {}),
+            },
+        };
+        return descend(node, [...marks, abbrMark], ctx);
     }
     const attrs = convertAttrs(a) || {};
     return descend(node, [...marks, { type: 'carveSpan', attrs }], ctx);

package/tiptap/extensions/carve-abbreviation-definition.js

@@ -0,0 +1,22 @@
+import { Node, mergeAttributes } from '@tiptap/core';
+
+/** An authored document-level abbreviation definition: `*[HTML]: expansion`. */
+export const CarveAbbreviationDefinition = Node.create({
+    name: 'carveAbbreviationDefinition',
+    group: 'block',
+    atom: true,
+    addAttributes() {
+        return {
+            abbr: { default: '' },
+            expansion: { default: '' },
+        };
+    },
+    parseHTML() { return [{ tag: 'div[data-carve-abbreviation-definition]' }]; },
+    renderHTML({ HTMLAttributes, node }) {
+        return ['div', mergeAttributes(HTMLAttributes, {
+            'data-carve-abbreviation-definition': 'true',
+        }), `${node.attrs.abbr}: ${node.attrs.expansion}`];
+    },
+});
+
+export default CarveAbbreviationDefinition;

package/tiptap/extensions/carve-abbreviation.js

@@ -1,4 +1,5 @@
 import { Mark, mergeAttributes } from '@tiptap/core';
+import { attributeSlots } from './carve-attribute-slots.js';
 
 /**
  * Carve Abbreviation extension for Tiptap
@@ -32,6 +33,8 @@ export const CarveAbbreviation = Mark.create({
                     return { title: attributes.title };
                 },
             },
+            resolved: { default: false, rendered: false },
+            ...attributeSlots(['title', 'data-carve-abbreviation']),
         };
     },
 

package/tiptap/extensions/carve-source-preservation.js

@@ -1,6 +1,6 @@
 import { Extension } from '@tiptap/core';
 
-/** Lossless source envelope for a structured document that has not been edited. */
+/** Merge base for preserving authored source layout around structured edits. */
 export const CarveSourcePreservation = Extension.create({
     name: 'carveSourcePreservation',
     addGlobalAttributes() {
@@ -8,9 +8,10 @@ export const CarveSourcePreservation = Extension.create({
             {
                 types: ['doc'],
                 attributes: {
-                carveSource: { default: null, rendered: false },
-                carveFingerprint: { default: null, rendered: false },
-                carveSourceLayout: { default: null, rendered: false },
+                    carveSource: { default: null, rendered: false },
+                    carveFingerprint: { default: null, rendered: false },
+                    carveSourceLayout: { default: null, rendered: false },
+                    carveProjectedSource: { default: null, rendered: false },
                 },
             },
             {

package/tiptap/extensions/index.js

@@ -13,6 +13,7 @@ export { CarveFootnoteDefinition } from './carve-footnote-definition.js';
 export { CarveMath } from './carve-math.js';
 export { CarveEmbed } from './carve-embed.js';
 export { CarveAbbreviation } from './carve-abbreviation.js';
+export { CarveAbbreviationDefinition } from './carve-abbreviation-definition.js';
 export { CarveDefinitionList, CarveDefinitionTerm, CarveDefinitionDescription } from './carve-definition-list.js';
 export { CarveUnsupported } from './carve-unsupported.js';
 export { CarveUnsupportedInline } from './carve-unsupported-inline.js';

package/tiptap/index.d.ts

@@ -25,6 +25,8 @@ export const CarveCriticComment: Mark;
 export const CarveDiv: Node;
 export const CarveMath: Node;
 export const CarveFootnoteDefinition: Node;
+export const CarveAbbreviation: Mark;
+export const CarveAbbreviationDefinition: Node;
 export const CarveMention: Node;
 export const CarveTag: Node;
 export const CarveUnsupported: Node;

package/tiptap/index.js

@@ -47,6 +47,8 @@ export { CarveCriticComment } from './extensions/carve-critic-comment.js';
 export { CarveDiv } from './extensions/carve-div.js';
 export { CarveMath } from './extensions/carve-math.js';
 export { CarveFootnoteDefinition } from './extensions/carve-footnote-definition.js';
+export { CarveAbbreviation } from './extensions/carve-abbreviation.js';
+export { CarveAbbreviationDefinition } from './extensions/carve-abbreviation-definition.js';
 export { CarveKeymap } from './extensions/carve-keymap.js';
 export { CarveMention, CarveTag } from './extensions/carve-mention.js';
 export { CarveInlineExtension } from './extensions/carve-inline-extension.js';

package/tiptap/schema-map.json

@@ -500,10 +500,17 @@
         "id": "authored id",
         "key": "the citation key as written, without the `@`; the same string `citation.key` carries at the use site"
       }
+    },
+    "abbreviation_def": {
+      "kind": "node",
+      "pm": "carveAbbreviationDefinition",
+      "attrs": {
+        "abbr": "the defined term",
+        "expansion": "the authored expansion"
+      }
     }
   },
   "unmapped": {
-    "abbreviation_def": "abbreviation definitions ride on the doc node's attrs",
     "caption_number": "numbered captions are a resolution artifact, not editor content",
     "citation": "a citation is one item in citation_group and rides in carveCitation's items attribute rather than becoming its own ProseMirror node",
     "raw_text": "raw text is the payload of a raw block, not a node an editor holds",

package/tiptap/serializer.js

@@ -23,6 +23,7 @@
  *   space (e.g. literal `**` immediately followed by bold text) - the run
  *   merges into a longer literal delimiter run on reparse.
  */
+import { diff3Merge } from 'node-diff3';
 
 /**
  * Serialize a Tiptap/ProseMirror JSON document to Carve markup
@@ -167,6 +168,17 @@ export function serializeToCarve(doc) {
         const clean = { ...doc };
         delete clean.attrs;
         if (pmFingerprint(clean) === preservedFingerprint) return preservedSource;
+        const projectedSource = doc?.attrs?.carveProjectedSource;
+        if (typeof projectedSource === 'string') {
+            // The authored source and the editable projection are two branches
+            // from the same canonical baseline. Merge the editor's changes
+            // into the authored branch so untouched columns, blank ownership,
+            // delimiter choices and marker placement survive. Where both sides
+            // changed the same characters, the editor wins: the user changed
+            // that construct and canonical Carve is safer than stale source.
+            const currentProjection = serializeToCarve(clean);
+            return mergeAuthoredSource(preservedSource, projectedSource, currentProjection);
+        }
     }
     // A whole-document fallback is already exact Carve source. Sending it
     // through the normal block joiner and edge trimmer would corrupt precisely
@@ -241,12 +253,26 @@ export function serializeToCarve(doc) {
                 // is present: a list whose items hold one paragraph each is
                 // loose or tight purely by the blank lines between them, which
                 // no amount of looking at the items can recover.
-                const isLoose = node.attrs?.carveTight === false || (node.content || []).some((item) => {
+                const multiBlockItem = (node.content || []).some((item) => {
                     const blocks = (item.content || []).filter(
                         (b) => !['bulletList', 'orderedList', 'taskList'].includes(b.type),
                     );
                     return blocks.length > 1;
                 });
+                const isLoose = node.attrs?.carveTight === false || multiBlockItem;
+                // Blank lines between items are how looseness is normally
+                // spelled, and they need two items to sit between. A loose list
+                // of ONE item whose item holds one block has nowhere to put
+                // them, so it reads back tight and the round trip changes the
+                // document - which is why the attribute is written instead.
+                //
+                // This only became reachable when the engine consumed `{loose}`
+                // into the list's own `tight`. While it stayed an ordinary
+                // attribute, serializeAttributes wrote it and nothing was lost.
+                if (node.attrs?.carveTight === false && !multiBlockItem
+                    && (node.content || []).length < 2) {
+                    output += indent + '{loose}\n';
+                }
                 let num = node.attrs?.start || 1;
                 // `carveOlType` carries the style from the Carve AST; `type` is what Tiptap's own
                 // OrderedList records when the editor is seeded from rendered
@@ -558,6 +584,10 @@ export function serializeToCarve(doc) {
                 break;
             }
 
+            case 'carveAbbreviationDefinition':
+                output += `*[${node.attrs?.abbr || ''}]: ${node.attrs?.expansion || ''}\n`;
+                break;
+
             case 'carveCitationDefinition': {
                 // `[@key]: {metadata} entry`. The metadata block LEADS the
                 // entry text here, unlike the link reference definition above
@@ -664,6 +694,10 @@ export function serializeToCarve(doc) {
         }
     }
 
+    // The column a description's continuation blocks sit at, set by the width
+    // of the canonical `: ` separator this serializer writes.
+    const DEFINITION_CONTENT_INDENT = '  ';
+
     function serializeDefinitionList(dl) {
         const children = dl.content || [];
         // The list's own attribute run, on its own line above the first term.
@@ -684,16 +718,45 @@ export function serializeToCarve(doc) {
                 output += ':: ' + serializeInline(child.content) + '\n';
                 afterDescription = false;
             } else if (child.type === 'definitionDescription') {
-                (child.content || []).forEach(block => {
-                    if (block.type === 'paragraph') {
-                        output += ': ' + serializeInline(block.content) + '\n';
-                    } else {
-                        // For other block types, serialize with indentation.
-                        const blockText = serializeNodeToString(block);
-                        blockText.split('\n').filter(l => l).forEach(line => {
-                            output += ': ' + line + '\n';
+                // ONE description, however many blocks it holds. Every block
+                // used to get its own `: ` marker, which spells a NEW
+                // description each time - a two-paragraph definition came back
+                // as two definitions of the same term. A continuation belongs
+                // at the description's content column, which the canonical
+                // `: ` separator puts at 2 (PART 9 section 17: the separator's
+                // width sets the column).
+                const blocks = child.content || [];
+                // A bare `:` is not an empty description: it is prose, and
+                // omitting the line removes the description altogether. Carve
+                // gives empty bodies an explicit canonical spelling so their
+                // boundary survives a rich-editor round trip.
+                if (blocks.length === 0) {
+                    output += ': {empty}\n';
+                    // Unlike a body-bearing pair, the canonical empty form is
+                    // glued to the next term; a blank would end the list.
+                    afterDescription = false;
+                    return;
+                }
+                blocks.forEach((block, i) => {
+                    const text = block.type === 'paragraph'
+                        ? serializeInline(block.content)
+                        : serializeNodeToString(block).replace(/\n+$/, '');
+                    const lines = text.split('\n');
+                    if (i === 0) {
+                        // The first line rides the marker; the rest are already
+                        // below it and only need the column.
+                        output += ': ' + lines[0] + '\n';
+                        lines.slice(1).forEach(line => {
+                            output += (line ? DEFINITION_CONTENT_INDENT + line : '') + '\n';
                         });
+
+                        return;
                     }
+                    // A blank line, or the block would join the one above it.
+                    output += '\n';
+                    lines.forEach(line => {
+                        output += (line ? DEFINITION_CONTENT_INDENT + line : '') + '\n';
+                    });
                 });
                 afterDescription = true;
             }
@@ -904,7 +967,16 @@ export function serializeToCarve(doc) {
     //
     // Widening this set is a measurement, not a judgement: add a case that
     // loses its paragraph without the escape, then add the character.
-    const CONTINUATION_BLOCK_OPENER = /\n([>#])/g;
+    // Every shape that OPENS a block at column 0, so a soft-break line holding
+    // one stops being text when it is written back there.
+    //
+    // Was `>` and `#` only, which left seven others leaking. `1. outer` with a
+    // lazy `  1. inner` under it came back as `1. outer` / `1. inner` - two
+    // items where the source had one, measured against the engine rather than
+    // reasoned about. A lookahead rather than a capture, because the fix is to
+    // insert a space and never to rewrite the opener.
+    const CONTINUATION_BLOCK_OPENER =
+        /\n(?=[>#|]|[-*][ \t]|-{3,}|:{2,}|(?:[0-9]{1,9}|[A-Za-z])[.)][ \t])/g;
 
     function escapeContinuationOpeners(text) {
         // A single SPACE, not a backslash. Both keep the line as text - the
@@ -918,7 +990,7 @@ export function serializeToCarve(doc) {
         // One space is below every item's content column (the shallowest is 2,
         // for `- `), so the line stays a lazy continuation rather than becoming
         // the block it would be at that column.
-        return text.replace(CONTINUATION_BLOCK_OPENER, (match, opener) => '\n ' + opener);
+        return text.replace(CONTINUATION_BLOCK_OPENER, '\n ');
     }
 
     function serializeParagraphText(content) {
@@ -941,7 +1013,7 @@ export function serializeToCarve(doc) {
         // each such atom on its own (no marks, so this recursion terminates) and
         // hand the result to the text path as a verbatim run that still carries
         // the marks.
-        const content = (rawContent || []).map((node) => (
+        const normalized = (rawContent || []).map((node) => (
             node && node.type !== 'text' && (node.marks || []).length
                 ? {
                     type: 'text',
@@ -951,6 +1023,48 @@ export function serializeToCarve(doc) {
                 }
                 : node
         ));
+        // ProseMirror splits one marked range whenever a nested mark begins or
+        // ends.  Serializing each resulting text node independently repeats the
+        // outer delimiter (`*a *` + `*/b/*` + `* c*`) instead of keeping it open
+        // across the inner span.  Collapse runs that share their outermost mark
+        // into one verbatim text node, then recurse over their contents after
+        // removing that mark.  Recursion handles arbitrary nesting depth while
+        // leaving the escaping and bare/autolink choices in the existing text
+        // path below.
+        const sameOuterMark = (left, right) => Boolean(left && right
+            && left.type === right.type
+            && pmFingerprint(left.attrs || {}) === pmFingerprint(right.attrs || {}));
+        const groupableDelimitedMarks = new Set([
+            'bold', 'italic', 'underline', 'strike', 'highlight',
+            'superscript', 'subscript', 'carveInsert', 'carveDelete',
+        ]);
+        const content = [];
+        for (let index = 0; index < normalized.length;) {
+            const node = normalized[index];
+            const candidateOuter = node?.type === 'text' ? node.marks?.[0] : null;
+            const outer = groupableDelimitedMarks.has(candidateOuter?.type) ? candidateOuter : null;
+            let end = index + 1;
+            while (outer && end < normalized.length) {
+                const candidate = normalized[end];
+                if (candidate?.type !== 'text' || !sameOuterMark(outer, candidate.marks?.[0])) break;
+                end++;
+            }
+            if (outer && end - index > 1) {
+                const inner = normalized.slice(index, end).map((part) => ({
+                    ...part,
+                    marks: (part.marks || []).slice(1),
+                }));
+                content.push({
+                    type: 'text',
+                    text: serializeInline(inner),
+                    marks: [outer],
+                    carveVerbatim: true,
+                });
+            } else {
+                content.push(node);
+            }
+            index = end;
+        }
         if (!content) return '';
         let result = '';
         let resumeDelimitedBold = false;
@@ -1296,7 +1410,12 @@ export function serializeToCarve(doc) {
                 // syntax: with that extension enabled the `abbr` attribute is
                 // promoted to a real `<abbr title="…">`; without it, it stays a
                 // `<span abbr="…">`. (Title escaped like a link title.)
-                if (abbr) t = '[' + t + ']{abbr="' + escapeTitle(abbr.attrs?.title || '') + '"}';
+                if (abbr && !abbr.attrs?.resolved) {
+                    const attrs = { ...abbr.attrs };
+                    attrs.carveKeyValues = { ...(attrs.carveKeyValues || {}), abbr: attrs.title || '' };
+                    attrs.carveAttrOrder ||= ['abbr'];
+                    t = '[' + t + ']' + serializeAttributes(attrs, ['title', 'resolved'], true);
+                }
 
                 result += t;
             } else if (node.type === 'hardBreak') {
@@ -1365,6 +1484,33 @@ export function serializeToCarve(doc) {
     return result;
 }
 
+function mergeAuthoredSource(authored, baseline, edited) {
+    // Appending and prepending blocks are the most common editor operations.
+    // Handle them without diff alignment: repeated punctuation can otherwise
+    // make a character diff align an untouched delimiter with the new text and
+    // needlessly replace the author's spelling in the original document.
+    const appended = edited.startsWith(baseline) ? edited.slice(baseline.length) : null;
+    const baselineClose = baseline.match(/(?:^|\n)([ \t]*(?:`{3,}|~{3,}|:{3,}))$/)?.[1];
+    const authoredHasClose = !baselineClose || authored.trimEnd().endsWith(baselineClose);
+    if (appended?.startsWith('\n\n') && authoredHasClose) return authored.trimEnd() + appended;
+    if (edited.endsWith(baseline)) return edited.slice(0, -baseline.length) + authored;
+
+    const characters = Math.max(authored.length, baseline.length, edited.length) <= 20_000;
+    const tokens = characters
+        ? (source) => [...source]
+        : (source) => source.match(/[^\n]*\n|[^\n]+$/g) || [];
+    const regions = diff3Merge(tokens(authored), tokens(baseline), tokens(edited), {
+        excludeFalseConflicts: true,
+    });
+    let merged = regions.flatMap((region) => region.ok || region.conflict?.b || []).join('');
+    // Canonical projections omit structural edge whitespace. It is outside the
+    // editable tree, so a content edit must not silently remove the author's
+    // terminal line ending.
+    const ending = authored.match(/\r\n$|[\r\n]$/)?.[0];
+    if (ending && !/[\r\n]$/.test(merged)) merged += ending;
+    return merged;
+}
+
 /**
  * Escape the "structural" Carve constructs in a text run - the ones whose
  * delimiters are unambiguous regardless of flanking. Used for both plain and
@@ -1384,7 +1530,16 @@ function escapeStructural(text, trailingSafe = false) {
         .replace(/`/g, '\\`')
         .replace(/\[(?=\^)/g, '\\[')
         .replace(/\[(?=[^\]\n]*\][([{:])/g, '\\[')
-        .replace(/\{(?=[+\-~#=%])/g, '\\{')
+        // An EMPTY doubled pair is text since carve-js 0.1.5, so escaping the
+        // brace there does not protect a construct - it creates a difference.
+        // `{--}` reaches smart typography and renders an en dash; `\{--}` is
+        // the literal characters, so the escape changed the document. Skip it
+        // for the five markers whose empty pair is text, the same way the
+        // `:name:` rule below only escapes where a symbol would form.
+        //
+        // `%` is NOT among them: `{%%}` is an empty COMMENT and renders to
+        // nothing, so its brace still has a construct to protect.
+        .replace(/\{(?!([+\-~#=])\1\})(?=[+\-~#=%])/g, '\\{')
         .replace(/(^|[^\w.])@(?=[A-Za-z0-9_])/g, '$1\\@')
         .replace(/(^|[^\w])#(?=[A-Za-z0-9_])/g, '$1\\#')
         // A `:name:` symbol only opens at a word boundary, and its name starts

package/tiptap/wire-fixtures.json

@@ -505,7 +505,7 @@
     },
     {
       "name": "table-with-spans",
-      "carve": "| a || b |\n|=h |= i |\n",
+      "carve": "| a || b |\n|= h |= i |\n",
       "pm": {
         "type": "doc",
         "content": [