diff --git a/CHANGELOG.md b/CHANGELOG.md
index ae68cca2..8a43d4d0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,15 +15,6 @@ All notable changes to `carve-grammars` are documented here.
   `carveSpan` mark carrying the language for `{:fr}`, `{:de-DE}`, `{:}`, a
   language beside another attribute, and the long `lang="fr"` spelling.
 
-- **A quote's `^ …` attribution stays editable and survives an edit.** The
-  engine now carries it as an `attribution` field on `block_quote` rather than
-  a `figure`/`figcaption` pair, and the loader read that field nowhere - so the
-  line survived only in the whole-document source envelope, which the first
-  edit invalidates. Editing a quote silently dropped its attribution. It now
-  projects onto the existing `carveCaption` node, appended inside the quote
-  where the engine renders it, and the serializer writes it back as a `^ …`
-  line after the quote.
-
 ## 0.1.4 - 2026-08-11
 
 ### Added
diff --git a/package-lock.json b/package-lock.json
index e17393b0..a2d81bda 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,7 +9,7 @@
       "version": "0.1.4",
       "license": "MIT",
       "dependencies": {
-        "@markup-carve/carve": "github:markup-carve/carve-js#8d38a03cc8664e761f81baa02a1bf54e7dde96a4"
+        "@markup-carve/carve": "github:markup-carve/carve-js#2bfa5cfe9e950212b5cb286251c533a147e01df2"
       },
       "devDependencies": {
         "@shikijs/themes": "^3.13.0",
@@ -83,8 +83,8 @@
     },
     "node_modules/@markup-carve/carve": {
       "version": "0.1.3",
-      "resolved": "git+ssh://git@github.com/markup-carve/carve-js.git#8d38a03cc8664e761f81baa02a1bf54e7dde96a4",
-      "integrity": "sha512-bgWqsw+GotXoqZDAzuSDT3Rb4EoYlbSPlYhlb1pmEkGE531NnWnrZ4ndS/kkW/5bCd+ypS0hK6HOuFghQNa3Rw==",
+      "resolved": "git+ssh://git@github.com/markup-carve/carve-js.git#2bfa5cfe9e950212b5cb286251c533a147e01df2",
+      "integrity": "sha512-zlRgQwahclqdPbS54JAHEN3fXrtJbyHek76le7PbCwVkhIa2UtNZWkpt3ikZMZu7EkPN8qu9Bj0HbjYlIb/Xpw==",
       "license": "MIT",
       "dependencies": {
         "parse5": "^7.3.0"
diff --git a/package.json b/package.json
index 0bf1c356..7dc038bf 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,7 @@
   "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/coverage-test.js && node tests/schema-map-test.js && node tests/snapshot-test.js && node tests/roundtrip-test.js && node tests/mounted-roundtrip-test.js && node tests/serializer-test.js && node tests/tabs-roundtrip-test.js && node tests/parse-test.js && node tests/language-attribute-test.js && node tests/blockquote-attribution-test.js && node tests/grammar-test.js && node tests/shiki-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",
+    "test": "npm run test:types && node tests/carve-editor-test.js && node tests/block-battery-test.js && node tests/coverage-test.js && node tests/schema-map-test.js && node tests/snapshot-test.js && node tests/roundtrip-test.js && node tests/mounted-roundtrip-test.js && node tests/serializer-test.js && node tests/tabs-roundtrip-test.js && node tests/parse-test.js && node tests/language-attribute-test.js && node tests/blockquote-caption-test.js && node tests/grammar-test.js && node tests/shiki-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",
     "test:types": "tsc -p tsconfig.types.json",
     "test:coverage": "node tests/coverage-test.js",
     "test:snapshot": "node tests/snapshot-test.js",
@@ -78,7 +78,7 @@
     "./tiptap/schema-map.json": "./tiptap/schema-map.json"
   },
   "dependencies": {
-    "@markup-carve/carve": "github:markup-carve/carve-js#8d38a03cc8664e761f81baa02a1bf54e7dde96a4"
+    "@markup-carve/carve": "github:markup-carve/carve-js#2bfa5cfe9e950212b5cb286251c533a147e01df2"
   },
   "peerDependencies": {
     "@shikijs/themes": "^2 || ^3",
diff --git a/tests/blockquote-attribution-test.js b/tests/blockquote-attribution-test.js
deleted file mode 100644
index 9e4212af..00000000
--- a/tests/blockquote-attribution-test.js
+++ /dev/null
@@ -1,313 +0,0 @@
-/**
- * A quote's `^ …` attribution has to stay EDITABLE, and survive an edit.
- *
- * markup-carve/carve-js#1033 made a caption on a quote the quote's own
- * `attribution` field on `block_quote`, rather than a `figure`/`figcaption`
- * pair wrapped around it. Before that, `^ Steve Jobs` reached the editor as a
- * real `carveFigure`/`carveCaption` pair; after it, the loader read the field
- * nowhere and the line survived only inside the whole-document `carveSource`
- * envelope.
- *
- * That envelope is keyed to a fingerprint of the untouched document, so the
- * FIRST EDIT invalidates it and the serializer falls back to the editable
- * projection - which did not carry the attribution. Editing a quote silently
- * dropped its attribution. A load-only assertion cannot see that: the envelope
- * still holds the whole source at load time, so a check that only inspects the
- * loaded string passes while the user-visible bug is intact. Every row below
- * therefore mounts a real editor, makes an UNRELATED edit, and reads what the
- * pane would write back.
- *
- * The projection is `carveCaption`, the caption node this schema already has,
- * appended inside the quote - which is where the engine renders it, as a
- * `<footer>` within the `<blockquote>`. No node type is added or renamed and no
- * node's shape changes; `tiptap/schema-map.json` is a published contract.
- */
-import assert from 'node:assert';
-import { readFileSync } from 'node:fs';
-import { Window } from 'happy-dom';
-import { CORPUS_DIR } from './lib/corpus.js';
-
-const win = new Window({ url: 'http://localhost/' });
-globalThis.window = win;
-globalThis.document = win.document;
-for (const key of ['DOMParser', 'Node', 'Element', 'HTMLElement', 'navigator', 'getComputedStyle', 'MutationObserver']) {
-    if (globalThis[key] === undefined && win[key] !== undefined) {
-        try { globalThis[key] = win[key]; } catch { /* read-only global - ignore */ }
-    }
-}
-
-const { Editor } = await import('@tiptap/core');
-const { CarveKit, carveToProseMirror, serializeToCarve } = await import('../tiptap/index.js');
-
-const load = (source) => carveToProseMirror(source, { unsupported: 'preserve' });
-const corpus = (name) => readFileSync(`${CORPUS_DIR}/${name}.crv`, 'utf8');
-
-/**
- * The attribution text carried by an EDITABLE node: a `carveCaption` sitting
- * inside a `blockquote`. Deliberately narrow. Reading any `carveCaption`
- * anywhere would also count an ordinary figure caption, and reading the
- * document's `carveSource` attr would count the very envelope whose loss is
- * the bug.
- */
-function editableAttributions(doc) {
-    const found = [];
-    const walk = (node) => {
-        if (node.type === 'blockquote') {
-            for (const child of node.content || []) {
-                if (child.type === 'carveCaption') found.push(plainText(child));
-            }
-        }
-        for (const child of node.content || []) walk(child);
-    };
-    walk(doc);
-    return found;
-}
-
-function plainText(node) {
-    if (node.type === 'text') return node.text || '';
-    return (node.content || []).map(plainText).join('');
-}
-
-/**
- * Mount, edit something that is NOT the attribution, and serialize the whole
- * document - envelope included. The edit is the point: it invalidates the
- * `carveSource` fingerprint, so what comes back is the editable projection.
- */
-function mountEditSerialize(source) {
-    const editor = new Editor({ extensions: [CarveKit], content: load(source) });
-    try {
-        // Position 1 is inside the document's first block in every row here,
-        // and never inside the trailing caption.
-        editor.commands.insertContentAt(1, 'EDITED');
-        return serializeToCarve(editor.getJSON());
-    } finally {
-        editor.destroy();
-    }
-}
-
-/** Serialize the untouched editable projection, envelope stripped. */
-function projection(source) {
-    return serializeToCarve({ ...load(source), attrs: undefined });
-}
-
-// `written` is the exact editable projection. Two notes on it, both properties
-// of the serializer at large rather than of this change:
-//  - it never writes the document's final newline, so the corpus source is
-//    matched against `written + '\n'`;
-//  - a blank line between a quote and its attribution is source LAYOUT, not
-//    document content: both spellings parse to the identical AST, and the
-//    attached form is written back. 55 and 282 are the two rows where that
-//    shows, and they are spelled out rather than normalized away.
-const CASES = [
-    {
-        name: '05-lists-20',
-        source: corpus('05-lists-20'),
-        attributions: ['Steve Jobs'],
-        written: 'Intro\n\n> Stay hungry\n^ Steve Jobs',
-        byteIdentical: true,
-    },
-    {
-        name: '07-blockquote-with-attribution',
-        source: corpus('07-blockquote-with-attribution'),
-        attributions: ['Steve Jobs'],
-        written: '> Stay hungry, stay foolish.\n^ Steve Jobs',
-        byteIdentical: true,
-    },
-    {
-        name: '55-blockquote-caption-after-a-blank-line',
-        source: corpus('55-blockquote-caption-after-a-blank-line'),
-        attributions: ['Source: Someone'],
-        written: '> quote text\n^ Source: Someone',
-        // The source spells the attribution one blank line down. Same AST,
-        // different layout; the projection writes the attached form.
-        byteIdentical: false,
-    },
-    {
-        name: '282-two-blank-lines-detach-a-caption-5',
-        source: corpus('282-two-blank-lines-detach-a-caption-5'),
-        attributions: ['Source: the cited work'],
-        written: '> the cited line\n^ Source: the cited work',
-        byteIdentical: false,
-    },
-    // An attribution carrying inline markup, so no row can pass by a reading
-    // that only ever moves a bare string.
-    {
-        name: 'emphasized attribution',
-        source: '> Quoted\n^ /Ada Lovelace/, 1843\n',
-        attributions: ['Ada Lovelace, 1843'],
-        written: '> Quoted\n^ /Ada Lovelace/, 1843',
-        byteIdentical: true,
-    },
-];
-
-const fails = [];
-let pass = 0;
-
-/**
- * A shape check that REPORTS rather than throws, so one run of a reverted
- * projection lists every symptom instead of stopping at the first.
- */
-function same(actual, expected, message) {
-    if (JSON.stringify(actual) === JSON.stringify(expected)) {
-        pass++;
-        return;
-    }
-    fails.push(`${message}: got ${JSON.stringify(actual)}, expected ${JSON.stringify(expected)}`);
-}
-
-for (const { name, source, attributions, written, byteIdentical } of CASES) {
-    const got = editableAttributions(load(source));
-    if (JSON.stringify(got) === JSON.stringify(attributions)) {
-        pass++;
-    } else {
-        fails.push(`loader: ${name} carries ${JSON.stringify(got)} in an editable node, expected ${JSON.stringify(attributions)}`);
-    }
-
-    const projected = projection(source);
-    if (projected === written) {
-        pass++;
-    } else {
-        fails.push(`projection: ${name} wrote ${JSON.stringify(projected)}, expected ${JSON.stringify(written)}`);
-    }
-
-    if (byteIdentical) {
-        if (`${projected}\n` === source) {
-            pass++;
-        } else {
-            fails.push(`byte identity: ${name} wrote ${JSON.stringify(`${projected}\n`)}, source is ${JSON.stringify(source)}`);
-        }
-    } else {
-        // Not byte-identical by construction; assert the ONLY difference is the
-        // blank line, so a real content loss cannot hide behind this branch.
-        if (`${projected}\n` === source.replace(/\n\n\^/, '\n^')) {
-            pass++;
-        } else {
-            fails.push(`layout normalization: ${name} wrote ${JSON.stringify(`${projected}\n`)}, which differs from ${JSON.stringify(source)} by more than the blank line`);
-        }
-    }
-
-    // The regression itself: an edit elsewhere must not cost the attribution.
-    const edited = mountEditSerialize(source);
-    const expectedLine = `^ ${written.slice(written.lastIndexOf('^ ') + 2)}`;
-    if (edited.includes('EDITED') && edited.includes(expectedLine)) {
-        pass++;
-    } else {
-        fails.push(`after an unrelated edit: ${name} wrote ${JSON.stringify(edited)}, expected it to contain ${JSON.stringify(expectedLine)}`);
-    }
-}
-
-// A quote whose ONLY child is the attribution is reachable in the editor by
-// deleting the quoted paragraph, and it is the one shape where writing the
-// caption the obvious way destroys it. `> ^ x` reparses as literal text inside
-// the quote (the attribution is gone on the next load) and a bare `^ x` is a
-// top-level paragraph (the quote is gone). Both preserve the bytes and lose the
-// document, which is why this is asserted on the reparse rather than the string.
-{
-    const captionOnly = {
-        type: 'doc',
-        content: [{
-            type: 'blockquote',
-            content: [{ type: 'carveCaption', content: [{ type: 'text', text: 'Only an attribution' }] }],
-        }],
-    };
-    const written = serializeToCarve(captionOnly);
-    same(written, '>\n^ Only an attribution',
-        'a quote holding only its attribution is not written as an empty quote plus a `^ …` line');
-    same(editableAttributions(load(`${written}\n`)), ['Only an attribution'],
-        'a quote holding only its attribution does not survive its own round trip');
-    same(serializeToCarve({ ...load(`${written}\n`), attrs: undefined }), written,
-        'a quote holding only its attribution is not a fixed point');
-}
-
-// The loader appends the attribution last, but an editor need not keep it
-// there: pressing Enter at the end of the attribution leaves a paragraph after
-// it. A serializer that recognized the attribution by POSITION would prefix it
-// as `> ^ src`, which reparses into the quoted paragraph as literal text - the
-// same silent loss this change exists to remove, one edit further along.
-{
-    const captionMidQuote = {
-        type: 'doc',
-        content: [{
-            type: 'blockquote',
-            content: [
-                { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-                { type: 'carveCaption', content: [{ type: 'text', text: 'src' }] },
-                { type: 'paragraph', content: [{ type: 'text', text: 'b' }] },
-            ],
-        }],
-    };
-    const written = serializeToCarve(captionMidQuote);
-    same(written, '> a\n>\n> b\n^ src',
-        'an attribution that is not the last child is written inside the quote');
-    same(editableAttributions(load(`${written}\n`)), ['src'],
-        'an attribution that is not the last child does not survive the round trip');
-}
-
-// Several captions in one quote are reachable by pressing Enter inside the
-// attribution, which splits the node. The model has room for one, so they are
-// joined. Consecutive `^ …` lines would not do: the engine reads only the first
-// as the attribution and reparses the rest as paragraphs OUTSIDE the quote,
-// where they render with a literal caret.
-{
-    const twoCaptions = {
-        type: 'doc',
-        content: [{
-            type: 'blockquote',
-            content: [
-                { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-                { type: 'carveCaption', content: [{ type: 'text', text: 'one' }] },
-                { type: 'carveCaption', content: [{ type: 'text', text: 'two' }] },
-            ],
-        }],
-    };
-    const written = serializeToCarve(twoCaptions);
-    same(written, '> a\n^ one two',
-        'several captions in a quote are not joined into one attribution');
-    const reloaded = load(`${written}\n`);
-    same(editableAttributions(reloaded), ['one two'],
-        'several captions in a quote do not survive as one attribution');
-    same(reloaded.content.length, 1,
-        'several captions in a quote ejected a paragraph out of the quote');
-}
-
-// Emptying an attribution in the editor leaves a `carveCaption` with no
-// content. `^` on its own is not an attribution marker to the engine - it glues
-// onto the quoted paragraph as literal text, corrupting the quote's own
-// content - so an empty caption is written as nothing at all.
-{
-    const emptyCaption = {
-        type: 'doc',
-        content: [{
-            type: 'blockquote',
-            content: [
-                { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-                { type: 'carveCaption' },
-            ],
-        }],
-    };
-    const written = serializeToCarve(emptyCaption);
-    same(written, '> a',
-        'an emptied attribution writes a caret that the engine reads as quoted text');
-    same(load(`${written}\n`).content[0].content,
-        [{ type: 'paragraph', content: [{ type: 'text', text: 'a' }] }],
-        'an emptied attribution corrupted the quoted paragraph on reload');
-}
-
-// The probe has to answer both ways. One that always reports an attribution
-// would pass every row above without reading anything.
-assert.deepStrictEqual(editableAttributions(load('> Just a quote\n')), [],
-    'editableAttributions reports an attribution for a quote that has none');
-assert.deepStrictEqual(editableAttributions(load('A plain sentence.\n')), [],
-    'editableAttributions reports an attribution in a document with no quote');
-// A figure caption is a caption too, and it is NOT an attribution. If the probe
-// counted it, the rows above would pass for the wrong reason.
-assert.deepStrictEqual(editableAttributions(load('![Alt](x.png)\n^ A figure caption\n')), [],
-    'editableAttributions counts an ordinary figure caption as a quote attribution');
-
-if (fails.length) {
-    console.error(`blockquote attribution: ${fails.length} failing`);
-    for (const f of fails) console.error(`  ${f}`);
-    process.exit(1);
-}
-
-console.log(`blockquote attribution: ${pass} checks pass across ${CASES.length} documents`);
diff --git a/tests/blockquote-caption-test.js b/tests/blockquote-caption-test.js
new file mode 100644
index 00000000..a863ac86
--- /dev/null
+++ b/tests/blockquote-caption-test.js
@@ -0,0 +1,200 @@
+/**
+ * A quote's `^ …` caption has to stay EDITABLE, and survive an edit.
+ *
+ * markup-carve/carve#1213 withdrew the attribution model: a caption on a quote
+ * is a caption like any other, so the engine emits a `figure` whose target is
+ * the quote and the loader projects that onto `carveFigure` + `carveCaption`,
+ * the pair this schema already has.
+ *
+ * The property this file pins is older than either model and survives both. The
+ * whole-document `carveSource` envelope is keyed to a fingerprint of the
+ * untouched document, so the FIRST EDIT invalidates it and the serializer falls
+ * back to the editable projection. If the caption reaches the editor only inside
+ * that envelope, editing anything at all silently drops it. A load-only
+ * assertion cannot see that - the envelope still holds the whole source at load
+ * time - so every row below mounts a real editor, makes an UNRELATED edit, and
+ * reads what the pane would write back.
+ *
+ * This replaces `blockquote-attribution-test.js`, which pinned the same property
+ * against the withdrawn `attribution` field. Its four extra cases were about a
+ * `carveCaption` sitting INSIDE a `blockquote`, a shape this projection does not
+ * produce, so they went with the field.
+ */
+import assert from 'node:assert';
+import { readFileSync } from 'node:fs';
+import { Window } from 'happy-dom';
+import { CORPUS_DIR } from './lib/corpus.js';
+
+const win = new Window({ url: 'http://localhost/' });
+globalThis.window = win;
+globalThis.document = win.document;
+for (const key of ['DOMParser', 'Node', 'Element', 'HTMLElement', 'navigator', 'getComputedStyle', 'MutationObserver']) {
+    if (globalThis[key] === undefined && win[key] !== undefined) {
+        try { globalThis[key] = win[key]; } catch { /* read-only global - ignore */ }
+    }
+}
+
+const { Editor } = await import('@tiptap/core');
+const { CarveKit, carveToProseMirror, serializeToCarve } = await import('../tiptap/index.js');
+
+const load = (source) => carveToProseMirror(source, { unsupported: 'preserve' });
+const corpus = (name) => readFileSync(`${CORPUS_DIR}/${name}.crv`, 'utf8');
+
+/**
+ * The caption text of a figure WHOSE TARGET IS A QUOTE, carried by editable
+ * nodes. Deliberately narrow: counting any `carveCaption` anywhere would also
+ * count an ordinary image caption, and reading the document's `carveSource`
+ * attr would count the very envelope whose loss is the bug.
+ */
+function editableQuoteCaptions(doc) {
+    const found = [];
+    const walk = (node) => {
+        if (node.type === 'carveFigure') {
+            const children = node.content || [];
+            const quoted = children.some((child) => child.type === 'blockquote');
+            if (quoted) {
+                for (const child of children) {
+                    if (child.type === 'carveCaption') found.push(plainText(child));
+                }
+            }
+        }
+        for (const child of node.content || []) walk(child);
+    };
+    walk(doc);
+    return found;
+}
+
+function plainText(node) {
+    if (node.type === 'text') return node.text || '';
+    return (node.content || []).map(plainText).join('');
+}
+
+/**
+ * Mount, edit something that is NOT the caption, and serialize the whole
+ * document - envelope included. The edit is the point: it invalidates the
+ * `carveSource` fingerprint, so what comes back is the editable projection.
+ */
+function mountEditSerialize(source) {
+    const editor = new Editor({ extensions: [CarveKit], content: load(source) });
+    try {
+        editor.commands.insertContentAt(1, 'EDITED');
+        return serializeToCarve(editor.getJSON());
+    } finally {
+        editor.destroy();
+    }
+}
+
+/** Serialize the untouched editable projection, envelope stripped. */
+function projection(source) {
+    return serializeToCarve({ ...load(source), attrs: undefined });
+}
+
+// `written` is the exact editable projection. Two notes on it, both properties
+// of the serializer at large rather than of this change:
+//  - it never writes the document's final newline, so the corpus source is
+//    matched against `written + '\n'`;
+//  - a blank line between a quote and its caption is source LAYOUT, not document
+//    content: both spellings parse to the identical AST, and the attached form
+//    is written back. 55 and 282 are the two rows where that shows.
+const CASES = [
+    {
+        name: '05-lists-20',
+        source: corpus('05-lists-20'),
+        captions: ['Steve Jobs'],
+        written: 'Intro\n\n> Stay hungry\n^ Steve Jobs',
+        byteIdentical: true,
+    },
+    {
+        name: '07-blockquote-with-attribution',
+        source: corpus('07-blockquote-with-attribution'),
+        captions: ['Steve Jobs'],
+        written: '> Stay hungry, stay foolish.\n^ Steve Jobs',
+        byteIdentical: true,
+    },
+    {
+        name: '55-blockquote-caption-after-a-blank-line',
+        source: corpus('55-blockquote-caption-after-a-blank-line'),
+        captions: ['Source: Someone'],
+        written: '> quote text\n^ Source: Someone',
+        byteIdentical: false,
+    },
+    {
+        name: '282-two-blank-lines-detach-a-caption-5',
+        source: corpus('282-two-blank-lines-detach-a-caption-5'),
+        captions: ['Source: the cited work'],
+        written: '> the cited line\n^ Source: the cited work',
+        byteIdentical: false,
+    },
+    // A caption carrying inline markup, so no row can pass by a reading that
+    // only ever moves a bare string.
+    {
+        name: 'emphasized caption',
+        source: '> Quoted\n^ /Ada Lovelace/, 1843\n',
+        captions: ['Ada Lovelace, 1843'],
+        written: '> Quoted\n^ /Ada Lovelace/, 1843',
+        byteIdentical: true,
+    },
+];
+
+const fails = [];
+let pass = 0;
+
+for (const { name, source, captions, written, byteIdentical } of CASES) {
+    const got = editableQuoteCaptions(load(source));
+    if (JSON.stringify(got) === JSON.stringify(captions)) {
+        pass++;
+    } else {
+        fails.push(`loader: ${name} carries ${JSON.stringify(got)} in an editable node, expected ${JSON.stringify(captions)}`);
+    }
+
+    const projected = projection(source);
+    if (projected === written) {
+        pass++;
+    } else {
+        fails.push(`projection: ${name} wrote ${JSON.stringify(projected)}, expected ${JSON.stringify(written)}`);
+    }
+
+    if (byteIdentical) {
+        if (`${projected}\n` === source) {
+            pass++;
+        } else {
+            fails.push(`byte identity: ${name} wrote ${JSON.stringify(`${projected}\n`)}, source is ${JSON.stringify(source)}`);
+        }
+    } else {
+        // Not byte-identical by construction; assert the ONLY difference is the
+        // blank line, so a real content loss cannot hide behind this branch.
+        if (`${projected}\n` === source.replace(/\n\n\^/, '\n^')) {
+            pass++;
+        } else {
+            fails.push(`layout normalization: ${name} wrote ${JSON.stringify(`${projected}\n`)}, which differs from ${JSON.stringify(source)} by more than the blank line`);
+        }
+    }
+
+    // The regression itself: an edit elsewhere must not cost the caption.
+    const edited = mountEditSerialize(source);
+    const expectedLine = `^ ${written.slice(written.lastIndexOf('^ ') + 2)}`;
+    if (edited.includes('EDITED') && edited.includes(expectedLine)) {
+        pass++;
+    } else {
+        fails.push(`after an unrelated edit: ${name} wrote ${JSON.stringify(edited)}, expected it to contain ${JSON.stringify(expectedLine)}`);
+    }
+}
+
+// The probe has to answer both ways. One that always reports a caption would
+// pass every row above without reading anything.
+assert.deepStrictEqual(editableQuoteCaptions(load('> Just a quote\n')), [],
+    'editableQuoteCaptions reports a caption for a quote that has none');
+assert.deepStrictEqual(editableQuoteCaptions(load('A plain sentence.\n')), [],
+    'editableQuoteCaptions reports a caption in a document with no quote');
+// An image caption is a caption too, and its figure targets no quote. If the
+// probe counted it, the rows above would pass for the wrong reason.
+assert.deepStrictEqual(editableQuoteCaptions(load('![Alt](x.png)\n^ A figure caption\n')), [],
+    'editableQuoteCaptions counts an ordinary image caption as a quote caption');
+
+if (fails.length) {
+    console.error(`blockquote caption: ${fails.length} failing`);
+    for (const f of fails) console.error(`  ${f}`);
+    process.exit(1);
+}
+
+console.log(`blockquote caption: ${pass} checks pass across ${CASES.length} documents`);
diff --git a/tests/mounted-roundtrip-test.js b/tests/mounted-roundtrip-test.js
index 59e5ac2e..a516847b 100644
--- a/tests/mounted-roundtrip-test.js
+++ b/tests/mounted-roundtrip-test.js
@@ -58,30 +58,29 @@ const fixed = [
     // `@markup-carve/carve` pin moved. Protected because it is the construct
     // that pin bump exists for.
     '296-a-language-attribute-and-lang-are-one-key-4',
-    // A quote's `^ …` attribution, projected onto `carveCaption`. Protected
-    // because the failure mode is silent content loss on the first edit, not a
-    // visible fallback.
+    // A caption on a quote is a figure caption again (markup-carve/carve#1213),
+    // so the loader builds a real `carveFigure`/`carveCaption` pair for these
+    // four and they are render-equivalent through a mount. Protected because the
+    // failure mode is silent content loss on the first edit rather than a
+    // visible fallback: the caption would survive only inside the
+    // whole-document `carveSource` envelope, which that edit invalidates.
     '05-lists-20',
     '07-blockquote-with-attribution',
     '55-blockquote-caption-after-a-blank-line',
     '282-two-blank-lines-detach-a-caption-5',
 ];
 for (const name of fixed) assert.ok(!changed.includes(name), `${name} regressed after editor mount`);
-// 177 -> 173: the four documents the projection now carries, which the
-// `@markup-carve/carve` pin bump had dropped. markup-carve/carve-js#1033 made a caption on a
-// quote the quote's `attribution` field instead of a `<figure>`/`<figcaption>`
-// pair wrapped around it, and the loader read that field nowhere, so the line
-// survived only in the whole-document `carveSource` envelope - which the first
-// edit invalidates. The loader now projects `attribution` onto `carveCaption`,
-// appended inside the quote where the engine renders it, and the serializer
-// writes that trailing caption back unprefixed. Recovered:
-//   05-lists-20, 07-blockquote-with-attribution,
-//   55-blockquote-caption-after-a-blank-line and
-//   282-two-blank-lines-detach-a-caption-5.
-// The set difference against the previous projection is exactly those four;
-// nothing else moved in either direction. See tests/blockquote-attribution-test.js.
+// 177 -> 173 when the `@markup-carve/carve` pin moved onto the withdrawal of
+// PART 9 section 4a (markup-carve/carve#1213). Every mover was read:
 //
-// The remaining known movers from that pin bump are unchanged and still stand:
+// - Four came back: 05-lists-20, 07-blockquote-with-attribution,
+//   55-blockquote-caption-after-a-blank-line and
+//   282-two-blank-lines-detach-a-caption-5. carve-js#1033 had made a caption on
+//   a quote the quote's own `attribution` field, which the loader read nowhere,
+//   so the line survived only in the `carveSource` envelope and the first edit
+//   dropped it. The engine emits a `figure` whose target is the quote again, so
+//   the loader builds the `carveFigure`/`carveCaption` pair it always did and
+//   the four are render-equivalent. They are in the protected list above.
 // - Two are the language attribute reaching a place the projection cannot
 //   carry it yet: a block-level `{:de}` on a blockquote
 //   (294-a-language-attribute-is-exact-sugar-for-lang-3) and the boolean
diff --git a/tiptap/carve-to-pm.js b/tiptap/carve-to-pm.js
index 787c6ac7..a817199f 100644
--- a/tiptap/carve-to-pm.js
+++ b/tiptap/carve-to-pm.js
@@ -410,23 +410,8 @@ function convertBlock(node, ctx) {
         }
 
         case 'blockquote':
-        case 'block_quote': {
-            const content = convertBlocks(node.children || [], ctx);
-            // A `^ …` line under a quote is the quote's ATTRIBUTION, an inline
-            // field on `block_quote` rather than a `figure`/`figcaption` pair
-            // wrapped around it (markup-carve/carve-js#1033). Read nowhere, it
-            // survived only in the whole-document `carveSource` envelope, which
-            // the first edit invalidates - so editing a quote dropped its
-            // attribution. It projects onto `carveCaption`, the caption node
-            // this schema already has, appended INSIDE the quote because that
-            // is where the engine renders it (`<footer>` within `<blockquote>`,
-            // not a `<figure>` around it). No node type or node shape changes.
-            const attribution = node.attribution;
-            if (Array.isArray(attribution) && attribution.length > 0) {
-                content.push({ type: 'carveCaption', content: convertInline(attribution, ctx) });
-            }
-            return { type: 'blockquote', content };
-        }
+        case 'block_quote':
+            return { type: 'blockquote', content: convertBlocks(node.children || [], ctx) };
 
         case 'code-block':
         case 'code_block': {
diff --git a/tiptap/schema-map.json b/tiptap/schema-map.json
index d3565804..5168bd8c 100644
--- a/tiptap/schema-map.json
+++ b/tiptap/schema-map.json
@@ -27,8 +27,7 @@
     },
     "block_quote": {
       "kind": "node",
-      "pm": "blockquote",
-      "notes": "the optional `attribution` inline field projects onto a trailing `carveCaption` child of the blockquote, matching where the engine renders it (a `<footer>` inside the quote); a bridge that ignores the field drops the `^ …` line on the first edit"
+      "pm": "blockquote"
     },
     "code_block": {
       "kind": "node",
diff --git a/tiptap/serializer.js b/tiptap/serializer.js
index 0b853c10..0d270d4c 100644
--- a/tiptap/serializer.js
+++ b/tiptap/serializer.js
@@ -281,69 +281,22 @@ export function serializeToCarve(doc) {
                 });
                 break;
 
-            case 'blockquote': {
+            case 'blockquote':
                 const quoteAttrs = serializeAttributes(node.attrs);
                 if (quoteAttrs) output += quoteAttrs + '\n';
-                // A `carveCaption` child of a quote is the quote's ATTRIBUTION,
-                // which the loader appends inside the quote. It is written
-                // UNPREFIXED after the quote: `> ^ Steve Jobs` is not a quieter
-                // spelling of the same document, it reparses as literal text in
-                // the quoted paragraph.
-                //
-                // Extracted by TYPE rather than by position. The loader always
-                // appends it last, but an editor need not keep it there -
-                // pressing Enter at the end of the attribution puts a paragraph
-                // after it - and a position test would then prefix it and lose
-                // it. The engine's model has the attribution at the end of the
-                // quote regardless, so moving it there is the projection, not a
-                // rewrite.
-                const all = node.content || [];
-                const children = all.filter((child) => child.type !== 'carveCaption');
-                // A quote carries at most ONE attribution, so several captions
-                // are a shape the model has no room for - reachable by pressing
-                // Enter inside an attribution, which splits the node in two.
-                // They are joined into one line rather than written as
-                // consecutive `^ …` lines: the engine reads only the first such
-                // line as the attribution and the rest as paragraphs, so that
-                // spelling ejects the author's text out of the quote and renders
-                // it with a literal caret. Dropping the extras instead would be
-                // the silent content loss this projection exists to remove.
-                //
-                // An EMPTY caption is not an attribution and is written as
-                // nothing at all. `^` on its own is not an attribution marker to
-                // the engine either: it glues onto the quoted paragraph as
-                // literal text, which corrupts the quote's own content. Emptying
-                // an attribution in the editor is how that shape arises.
-                const attributionText = all
-                    .filter((child) => child.type === 'carveCaption')
-                    .map((caption) => serializeInline(caption.content))
-                    .filter((part) => part !== '')
-                    .join(' ');
-                // A quote whose only children are captions is reachable by
-                // deleting the quoted paragraph in the editor. It needs a bare
-                // `>` line: dropping the marker writes `^ …` at top level,
-                // which is a paragraph and loses the quote, while keeping the
-                // caption inside writes `> ^ …`, which loses the attribution.
-                // `>` alone plus an unprefixed `^ …` reparses to exactly this
-                // document, an empty quote carrying an attribution.
-                if (all.length > 0 && children.length === 0) output += '>\n';
                 // Serialize each child block with proper blank line separation
-                children.forEach((child, i) => {
+                (node.content || []).forEach((child, i) => {
                     const childText = serializeNodeToString(child);
                     // Prefix each line with >
                     childText.split('\n').forEach(line => {
                         output += '> ' + line + '\n';
                     });
                     // Add blank line between blocks (> followed by empty line)
-                    if (i < children.length - 1) {
+                    if (i < (node.content || []).length - 1) {
                         output += '>\n';
                     }
                 });
-                if (attributionText !== '') {
-                    output += '^ ' + attributionText + '\n';
-                }
                 break;
-            }
 
             case 'codeBlock': {
                 const lang = node.attrs?.language || '';