@@ -415,6 +415,8 @@ function VersionMerge({
         fragment: setup.afterDoc.get("doc"),
         provider: { awareness: setup.diffAwareness },
         user: USER_A,
+        // The gallery shows the experimental diff refinements.
+        experimental: { lostContentAttribution: true },
       },
     }),
   );
 
@@ -1103,8 +1103,8 @@ export const scenarios: SuggestionScenario[] = [
     id: "concurrent-move-into-deleted-block",
     feedback: [
       {
-        severity: "high",
-        note: "X is lost: B's move inserts a copy into Parent, which A deletes. Versioning shows X as deleted by B, though B only moved it, and doesn't show Child at all. To be fixed by #3166.",
+        severity: "info",
+        note: "X is lost: B's move inserts a copy into Parent, which A deletes. Versioning shows X deleted without an author: B only moved it, and A never saw it there.",
       },
     ],
     title: "Move a block into a block that is deleted",
@@ -1133,8 +1133,8 @@ export const scenarios: SuggestionScenario[] = [
     id: "concurrent-delete-parent-vs-child-type",
     feedback: [
       {
-        severity: "high",
-        note: "B's type change is lost with Parent. Versioning shows Parent as deleted by A, but doesn't show Child at all. To be fixed by #3166.",
+        severity: "info",
+        note: "B's type change is lost with Parent. Versioning shows Parent deleted by A, and Child deleted without an author: B's change replaced Child with a copy that was lost, and the diff can't tell who to credit.",
       },
     ],
     title: "Delete a parent vs change its child's type",
 
@@ -297,8 +297,7 @@ describe("AttributionExtension user loading", () => {
     });
   });
 
-  // To be fixed by #3166.
-  it.fails("does not show a change to a block's id", () => {
+  it("does not show a change to a block's id", () => {
     const { editor } = createEditor();
     editor.replaceBlocks(editor.document, [
       { type: "paragraph", content: "hello" },
 
@@ -230,19 +230,16 @@ export const AttributionExtension = createExtension(
             .map((id) => userStore.getUser(id)?.username ?? id)
             .filter((username) => username !== "");
 
-        // A stable identity string for a wrapper (empty if unattributed), used to
-        // (a) test whether a mark is attributed and (b) group adjacent marks with
-        // the *same* attribution under one tooltip. It's an internal grouping key,
-        // not the displayed text — that's composed in the view from `users` and
-        // the format label — so it's built from raw `data-*` (ids + format keys)
-        // and stays free of i18n/username resolution.
+        // A stable identity string for a mark wrapper, used to group nested marks
+        // with the *same* change under one tooltip. Every wrapper is a change;
+        // its author may be unknown (e.g. content removed along with a
+        // concurrently deleted block). It's an internal grouping key, not the
+        // displayed text, so it's built from raw `data-*` and stays free of
+        // i18n/username resolution.
         const attributionIdentity = (wrapper: HTMLElement) => {
           const ids = parseUserIds(wrapper.dataset["userIds"]);
-          if (ids.length === 0 && wrapper.dataset["attributes"] === undefined) {
-            return "";
-          }
           const format = parseFormatKeys(wrapper.dataset["format"]);
-          return `${wrapper.dataset["attributes"] ?? ""}:${format.join(",")}:${ids.join(",")}`;
+          return `${wrapper.tagName}:${wrapper.dataset["attributes"] ?? ""}:${format.join(",")}:${ids.join(",")}`;
         };
 
         // Build the tooltip state from a wrapper's `data-*` attributes. A
@@ -302,24 +299,6 @@ export const AttributionExtension = createExtension(
           store.setState(undefined);
         };
 
-        // The innermost attributed mark at or above `el`, skipping unattributed
-        // wrappers so an attributed ancestor still wins.
-        const innermostAttributed = (
-          el: Element | null,
-        ): HTMLElement | undefined => {
-          while (el) {
-            const wrapper = el.closest<HTMLElement>(ATTRIBUTION_MARK_SELECTOR);
-            if (!wrapper) {
-              return undefined;
-            }
-            if (attributionIdentity(wrapper)) {
-              return wrapper;
-            }
-            el = wrapper.parentElement;
-          }
-          return undefined;
-        };
-
         const nodeAttribution = (
           target: Element,
         ): { mark: HTMLElement; preview: Element } | undefined => {
@@ -356,17 +335,18 @@ export const AttributionExtension = createExtension(
           ) {
             return undefined;
           }
-          const mark = Array.from(
-            owner.querySelectorAll<HTMLElement>(ATTRIBUTION_MARK_SELECTOR),
-          ).find(attributionIdentity);
+          const mark = owner.querySelector<HTMLElement>(
+            ATTRIBUTION_MARK_SELECTOR,
+          );
           return mark ? { mark, preview: owner } : undefined;
         };
 
         const onPointerOver = (event: Event) => {
           const target = event.target instanceof Element ? event.target : null;
           const hoveredMark =
             target && dom.contains(target)
-              ? innermostAttributed(target)
+              ? (target.closest<HTMLElement>(ATTRIBUTION_MARK_SELECTOR) ??
+                undefined)
               : undefined;
           const fallback =
             target && !hoveredMark ? nodeAttribution(target) : undefined;
@@ -379,21 +359,18 @@ export const AttributionExtension = createExtension(
 
           const identity = attributionIdentity(innermost);
           // Anchor on the outermost ancestor with the *same* attribution so one
-          // tooltip covers the whole region; a differently-attributed ancestor
-          // breaks the chain, and unattributed ones are climbed past.
+          // tooltip covers the whole region; a different ancestor breaks the chain.
           let anchor = innermost;
           let el: Element | null = innermost.parentElement;
           while (el) {
             const ancestor = el.closest<HTMLElement>(ATTRIBUTION_MARK_SELECTOR);
             if (!ancestor) {
               break;
             }
-            const ancestorIdentity = attributionIdentity(ancestor);
-            if (ancestorIdentity === identity) {
-              anchor = ancestor;
-            } else if (ancestorIdentity) {
+            if (attributionIdentity(ancestor) !== identity) {
               break;
             }
+            anchor = ancestor;
             el = ancestor.parentElement;
           }
 
 
@@ -8,6 +8,7 @@ import type {
   StyleSchema,
 } from "../../schema/index.js";
 import { ForkYDocExtension } from "./ForkYDoc.js";
+import { CollaborationExtension } from "./index.js";
 import { serializeFragment } from "./snapshotCodec.js";
 import { showSnapshotPreview } from "./snapshotPreview.js";
 
@@ -59,6 +60,7 @@ export function createYVersionView<
             content,
             comparison?.content,
             comparison?.attributions,
+            editor.getExtension(CollaborationExtension)?.experimental,
           );
         },
         close() {
 
@@ -112,6 +112,16 @@ const createAttributionMarkView =
   ) =>
   ({ mark, inline }: { mark: PMMark; inline: boolean }) => {
     const editor = options?.editor;
+    // A block's id isn't content users edit, so a change to it isn't shown
+    // (e.g. a diff pairing a deleted block with the editor's empty one).
+    // Inline content may have an `id` prop of its own, which is.
+    const { id: _id, ...blockChanges } = getAttributeChanges(mark);
+    const changes = inline ? getAttributeChanges(mark) : blockChanges;
+    if (type === "attrs" && Object.keys(changes).length === 0) {
+      const dom = document.createElement(inline ? "span" : "div");
+      dom.style.display = "contents";
+      return { dom, contentDOM: dom };
+    }
     // `<ins>`/`<del>` are semantic elements. The modification mark has no
     // dedicated element, so it renders as a `<span>` inline or a `<div>` over a
     // block, matching its `parseDOM` rules.
@@ -131,7 +141,7 @@ const createAttributionMarkView =
     });
     if (type === "attrs") {
       dom.dataset["type"] = "attributes";
-      dom.dataset["attributes"] = JSON.stringify(getAttributeChanges(mark));
+      dom.dataset["attributes"] = JSON.stringify(changes);
     }
     if (type === "modification") {
       dom.dataset["type"] = "modification";
 
@@ -9,6 +9,7 @@ import { normalizeToUserStore, UserStoreOrResolver } from "../../user/index.js";
 import { AttributionExtension } from "./AttributionExtension.js";
 import { ForkYDocExtension } from "./ForkYDoc.js";
 import { RelativePositionMappingExtension } from "./RelativePositionMapping.js";
+import type { ExperimentalVersionDiffs } from "./snapshotPreview.js";
 import { SuggestionsExtension } from "./Suggestions.js";
 import { CollaborationUser, YCursorExtension } from "./YCursorPlugin.js";
 import type { GetAttributionMarkClassName } from "./YAttributionMarks.js";
@@ -66,6 +67,12 @@ export type CollaborationOptions = {
    * dropped for that mark. See {@link GetAttributionMarkClassName}.
    */
   getAttributionMarkClassName?: GetAttributionMarkClassName;
+
+  /**
+   * Experimental refinements of how version history diffs are shown. They only
+   * change what a diff shows, never what is stored.
+   */
+  experimental?: ExperimentalVersionDiffs;
 };
 
 export const CollaborationExtension = createExtension(
@@ -81,6 +88,7 @@ export const CollaborationExtension = createExtension(
     return {
       key: "collaboration",
       fragment: options.fragment,
+      experimental: options.experimental ?? {},
       userStore,
       blockNoteExtensions: [
         options.suggestionDoc
@@ -129,6 +137,7 @@ export function withCollaboration<
   };
 }
 
+export type { ExperimentalVersionDiffs } from "./snapshotPreview.js";
 export * from "./AttributionExtension.js";
 export * from "./DiffVersioningExtension.js";
 export * from "./ForkYDoc.js";
 
@@ -16,11 +16,12 @@ export type DecodedFragment = {
 export function decodeFragmentUpdate(
   fragment: Y.Node,
   content: Uint8Array,
-  opts?: { suggestionDoc?: boolean },
+  opts?: { suggestionDoc?: boolean; keepDeleted?: boolean },
 ): DecodedFragment {
-  const doc = new Y.Doc(
-    opts?.suggestionDoc ? { isSuggestionDoc: true } : undefined,
-  );
+  const doc = new Y.Doc({
+    ...(opts?.suggestionDoc ? { isSuggestionDoc: true } : {}),
+    ...(opts?.keepDeleted ? { gc: false } : {}),
+  });
   try {
     Y.applyUpdateV2(doc, content);
     return { doc, fragment: findTypeInOtherYdoc(fragment, doc) };