@agent-native/core 0.181.0 → 0.181.1-nightly-20260916144018

package/corpus/templates/content/app/components/editor/VisualEditor.tsx

@@ -89,6 +89,10 @@ import {
   type CommentTextAnchor,
 } from "./comment-anchors";
 import { buildContentSelectionPayload } from "./content-selection";
+import {
+  isEditorDraftSaveAccepted,
+  type EditorDraftSaveResult,
+} from "./editor-draft-save";
 import { AudioNode } from "./extensions/AudioNode";
 import { CodeBlock } from "./extensions/CodeBlockNode";
 import {
@@ -1339,6 +1343,13 @@ interface VisualEditorProps {
   contentUpdatedAt?: string | null;
   /** Opaque body revision used for base-aware external-edit reconciliation. */
   contentRevision?: string | null;
+  /** Latest server-confirmed body snapshot written by this editor. */
+  acknowledgedLocalSnapshot?: {
+    value: string;
+    revision: string;
+    updatedAt: string;
+    sequence: number;
+  } | null;
   collabContentRevision?: string | null;
   requestCollabSync?: () => Promise<{
     status: "synced" | "failed" | "unavailable";
@@ -1351,7 +1362,9 @@ interface VisualEditorProps {
     serverRevision: string;
   }) => void;
   onChange: (markdown: string) => void;
-  onSaveContent?: (markdown: string) => boolean | Promise<boolean>;
+  onSaveContent?: (
+    markdown: string,
+  ) => EditorDraftSaveResult | Promise<EditorDraftSaveResult>;
   onEscape?: () => void;
   /** Yjs document for collaborative editing. */
   ydoc?: YDoc | null;
@@ -2838,6 +2851,7 @@ export function VisualEditor({
   content,
   contentUpdatedAt,
   contentRevision,
+  acknowledgedLocalSnapshot,
   collabContentRevision,
   requestCollabSync,
   onBaseAwareReconcile,
@@ -3089,12 +3103,16 @@ export function VisualEditor({
       },
     ) => {
       const guards = guardsRef.current;
-      if (!guards) return false;
+      if (!guards) return "failed" as const;
       try {
         const serialized = serializeEditorDraftForPersistence(editorToPersist);
-        if (serialized === null) return options?.strict !== true;
+        if (serialized === null)
+          return options?.strict === true
+            ? ("failed" as const)
+            : ("unchanged" as const);
         const normalized = options?.markdown ?? serialized;
-        if (localFileMode && normalized === content) return true;
+        if (localFileMode && normalized === content)
+          return "unchanged" as const;
         // TipTap/Yjs can emit a local-looking empty-paragraph transaction while
         // an editor is mounting or reconciling. Content serializes that filler
         // as `<empty-block/>`, so the generic whitespace-only collab guard does
@@ -3107,24 +3125,24 @@ export function VisualEditor({
             userInitiated: options?.userInitiated === true,
           })
         ) {
-          return true;
+          return "unchanged" as const;
         }
         if (options?.immediate && onSaveContentRef.current) {
           return onSaveContentRef.current(normalized);
         }
-        if (options?.immediate) return false;
+        if (options?.immediate) return "failed" as const;
         // Don't persist an empty doc before Collaboration has seeded (would
         // clobber DB content with an empty string). `registerEmitted` records
         // this as the last-emitted value and returns false to skip the save.
-        if (!guards.registerEmitted(normalized)) return true;
+        if (!guards.registerEmitted(normalized)) return "unchanged" as const;
         setTimeout(() => onChangeRef.current(normalized), 0);
-        return true;
+        return "scheduled" as const;
       } catch (err: any) {
         toast.error(
           t("editor.markdownSerializationError", { message: err.message }),
         );
         console.error("Markdown serialization error:", err);
-        return false;
+        return "failed" as const;
       }
     },
     [content, localFileMode, t],
@@ -3134,11 +3152,13 @@ export function VisualEditor({
     const guards = guardsRef.current;
     if (!guards || guards.shouldIgnoreUpdate(transaction)) return;
     try {
-      const persisted = await persistEditorContent(editorToPersist, {
+      const saveResult = await persistEditorContent(editorToPersist, {
         immediate: true,
         userInitiated: true,
       });
-      if (!persisted) throw new Error(t("empty.genericError"));
+      if (!isEditorDraftSaveAccepted(saveResult)) {
+        throw new Error(t("empty.genericError"));
+      }
     } catch (error) {
       // The ordinary onUpdate path still queues its debounced retry. Keep the
       // immediate durability attempt from becoming an unhandled rejection,
@@ -3417,13 +3437,14 @@ export function VisualEditor({
         ) {
           return true;
         }
-        return await Promise.resolve(
+        const result = await Promise.resolve(
           persistEditorContent(editor, {
             immediate: true,
             userInitiated: true,
             strict: true,
           }),
         );
+        return isEditorDraftSaveAccepted(result);
       },
     });
     return () => onPersistenceControllerChange?.(null);
@@ -3536,10 +3557,11 @@ export function VisualEditor({
           persistCommittedImage: async () => {
             if (!committed || editor.isDestroyed || suggestingRef.current)
               return false;
-            return await persistEditorContent(editor, {
+            const result = await persistEditorContent(editor, {
               immediate: true,
               userInitiated: true,
             });
+            return isEditorDraftSaveAccepted(result);
           },
         });
         if (!committed) throw new Error(t("empty.genericError"));
@@ -3626,6 +3648,7 @@ export function VisualEditor({
     contentRevision: propsPredateAcknowledgedRestore
       ? acknowledgedRestore!.contentRevision
       : contentRevision,
+    acknowledgedLocalSnapshot,
     collabContentRevision: propsPredateAcknowledgedRestore
       ? null
       : collabContentRevision,
@@ -4084,14 +4107,18 @@ export function VisualEditor({
           suggesting={suggesting}
           notionPageId={notionPageId}
           onDraftCommitted={() =>
-            persistEditorContent(editor, { userInitiated: true })
+            Promise.resolve(
+              persistEditorContent(editor, { userInitiated: true }),
+            ).then(isEditorDraftSaveAccepted)
           }
           onDraftPersisted={(markdown) =>
-            persistEditorContent(editor, {
-              markdown,
-              immediate: true,
-              userInitiated: true,
-            })
+            Promise.resolve(
+              persistEditorContent(editor, {
+                markdown,
+                immediate: true,
+                userInitiated: true,
+              }),
+            ).then(isEditorDraftSaveAccepted)
           }
         />
       ) : null}

package/corpus/templates/content/app/components/editor/editor-draft-save.ts

@@ -0,0 +1,13 @@
+export type EditorDraftSaveResult =
+  | boolean
+  | "persisted"
+  | "retained"
+  | "scheduled"
+  | "unchanged"
+  | "failed";
+
+export function isEditorDraftSaveAccepted(
+  result: EditorDraftSaveResult,
+): boolean {
+  return result !== false && result !== "failed";
+}

package/corpus/templates/content/app/components/editor/useDocumentReconcileRecovery.ts

@@ -0,0 +1,248 @@
+import {
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+  type MutableRefObject,
+} from "react";
+
+export interface ReconcileSaveBase {
+  title: string;
+  content: string;
+  updatedAt: string | null;
+  revision?: string;
+}
+
+export interface DocumentReconcileRecoveryState {
+  reason: "conflict" | "failed" | "save-failed";
+  localDraft: string;
+  localTitle: string;
+  saving: boolean;
+}
+
+export interface ReconcileRecoveryDraft {
+  localDraft: string;
+  localTitle: string;
+}
+
+export function useDocumentReconcileRecovery({
+  save,
+  retain,
+  getDraft,
+  getTitle,
+  getSaveIdentity = getDraft,
+  stateRef,
+}: {
+  save: (
+    draft: ReconcileRecoveryDraft,
+    base?: ReconcileSaveBase,
+  ) => Promise<boolean>;
+  retain?: (draft: ReconcileRecoveryDraft) => Promise<void>;
+  getDraft: () => string;
+  getTitle?: () => string;
+  getSaveIdentity?: () => string;
+  stateRef?: MutableRefObject<DocumentReconcileRecoveryState | null>;
+}) {
+  const [state, setState] = useState<DocumentReconcileRecoveryState | null>(
+    null,
+  );
+  const internalStateRef = useRef(state);
+  const current = stateRef ?? internalStateRef;
+  const generation = useRef(0);
+  const inFlight = useRef(false);
+  const callbacks = useRef({
+    save,
+    retain,
+    getDraft,
+    getTitle,
+    getSaveIdentity,
+  });
+  callbacks.current = { save, retain, getDraft, getTitle, getSaveIdentity };
+
+  const latestDraft = useCallback(
+    (): ReconcileRecoveryDraft => ({
+      localDraft: callbacks.current.getDraft(),
+      localTitle: callbacks.current.getTitle?.() ?? "",
+    }),
+    [],
+  );
+
+  const retainLatest = useCallback(async () => {
+    if (callbacks.current.retain) await callbacks.current.retain(latestDraft());
+  }, [latestDraft]);
+
+  useEffect(
+    () => () => {
+      generation.current += 1;
+      current.current = null;
+    },
+    [],
+  );
+
+  const publish = useCallback(
+    (next: DocumentReconcileRecoveryState | null) => {
+      current.current = next;
+      setState(next);
+    },
+    [current],
+  );
+
+  const report = useCallback(
+    (reason: "conflict" | "failed", localDraft: string) => {
+      generation.current += 1;
+      publish({
+        reason,
+        localDraft,
+        localTitle: callbacks.current.getTitle?.() ?? "",
+        saving: inFlight.current,
+      });
+    },
+    [publish],
+  );
+
+  const updateDraft = useCallback(
+    (localDraft: string, localTitle = callbacks.current.getTitle?.() ?? "") => {
+      if (!current.current) return false;
+      publish({ ...current.current, localDraft, localTitle });
+      return true;
+    },
+    [current, publish],
+  );
+
+  const reportRetentionFailure = useCallback(() => {
+    const latest = current.current;
+    if (!latest) return;
+    publish({ ...latest, reason: "save-failed", saving: false });
+  }, [current, publish]);
+
+  const resolve = useCallback(
+    async (base: ReconcileSaveBase): Promise<boolean> => {
+      if (!current.current || inFlight.current) return false;
+      inFlight.current = true;
+      const started = generation.current;
+      publish({ ...current.current, saving: true });
+      let saveBase: ReconcileSaveBase | undefined = base;
+      try {
+        while (generation.current === started) {
+          const identity = callbacks.current.getSaveIdentity();
+          const draft = latestDraft();
+          const persisted = await callbacks.current.save(draft, saveBase);
+          if (generation.current !== started) {
+            await retainLatest();
+            return false;
+          }
+          if (!persisted) {
+            await retainLatest();
+            publish({
+              reason: "conflict",
+              localDraft: callbacks.current.getDraft(),
+              localTitle: callbacks.current.getTitle?.() ?? "",
+              saving: false,
+            });
+            return false;
+          }
+          if (callbacks.current.getSaveIdentity() === identity) {
+            publish(null);
+            return true;
+          }
+          saveBase = undefined;
+        }
+        await retainLatest();
+        return false;
+      } catch {
+        if (generation.current === started) {
+          try {
+            await retainLatest();
+          } catch {
+            // The visible recovery state remains the final fallback.
+          }
+          publish({
+            reason: "save-failed",
+            localDraft: callbacks.current.getDraft(),
+            localTitle: callbacks.current.getTitle?.() ?? "",
+            saving: false,
+          });
+        }
+        return false;
+      } finally {
+        inFlight.current = false;
+        if (current.current?.saving)
+          publish({ ...current.current, saving: false });
+      }
+    },
+    [current, latestDraft, publish, retainLatest],
+  );
+
+  const resolveChoice = useCallback(
+    async (
+      base: ReconcileSaveBase,
+      action: (
+        draft: ReconcileRecoveryDraft,
+        base: ReconcileSaveBase,
+      ) => Promise<boolean>,
+    ): Promise<boolean> => {
+      const snapshot = current.current;
+      if (!snapshot || inFlight.current) return false;
+      inFlight.current = true;
+      const started = generation.current;
+      publish({ ...snapshot, saving: true });
+      try {
+        const resolved = await action(
+          {
+            localDraft: snapshot.localDraft,
+            localTitle: snapshot.localTitle,
+          },
+          base,
+        );
+        if (!resolved || generation.current !== started) {
+          await retainLatest();
+          return false;
+        }
+        const latest = current.current;
+        if (
+          !latest ||
+          latest.localDraft !== snapshot.localDraft ||
+          latest.localTitle !== snapshot.localTitle
+        ) {
+          await retainLatest();
+          return false;
+        }
+        publish(null);
+        return true;
+      } catch {
+        if (generation.current === started) {
+          try {
+            await retainLatest();
+          } catch {
+            // The visible recovery state remains the final fallback.
+          }
+          const latest = current.current;
+          if (latest)
+            publish({ ...latest, reason: "save-failed", saving: false });
+        }
+        return false;
+      } finally {
+        inFlight.current = false;
+        if (current.current?.saving)
+          publish({ ...current.current, saving: false });
+      }
+    },
+    [current, publish, retainLatest],
+  );
+
+  const release = useCallback(() => {
+    generation.current += 1;
+    publish(null);
+  }, [publish]);
+
+  return {
+    state,
+    report,
+    updateDraft,
+    reportRetentionFailure,
+    resolve,
+    resolveChoice,
+    release,
+    current,
+  };
+}

package/corpus/templates/content/app/components/sidebar/NotionButton.tsx

@@ -4,6 +4,7 @@ import {
 } from "@agent-native/core/client/api-path";
 import { writeClipboardText } from "@agent-native/core/client/clipboard";
 import { useT } from "@agent-native/core/client/i18n";
+import { openOAuthPopup } from "@agent-native/core/client/oauth-popup";
 import {
   IconExternalLink,
   IconCheck,
@@ -143,7 +144,7 @@ export function NotionButton() {
       toast.error(t("sidebar.notionOAuthNotConfigured"));
       return;
     }
-    const popup = window.open("about:blank", "_blank");
+    const popup = openOAuthPopup();
     if (!popup) {
       toast.error(t("sidebar.notionOAuthNotConfigured"));
       return;

package/corpus/templates/content/app/i18n-data.ts

@@ -1154,6 +1154,16 @@ const enUS = {
     registryBlockUnreadable: "Persisted block source is unreadable.",
     blocksFieldRevisionConflict:
       "This Blocks field changed elsewhere. Your edit wasn't saved; the latest version is now shown.",
+    reconcileConflict:
+      "This page changed elsewhere. Your edits aren’t saved yet.",
+    reconcileFailed:
+      "The latest changes couldn’t be combined. Your edits aren’t saved yet.",
+    reconcileSaveFailed: "Your edits couldn’t be saved. Review and try again.",
+    reconcileSaving: "Saving your edits…",
+    reconcileReview: "Review changes",
+    reconcileReviewStale:
+      "The saved version changed again. Review the latest text before saving.",
+    reconcileRefresh: "Review latest version",
     couldNotReadLocalSourceFile: "Could not read local source file",
     couldNotSaveLocalFile: "Could not save local file",
     localFileChangedWithUnsavedEdits:
@@ -1174,6 +1184,9 @@ const enUS = {
     previewDraftSavedToHistory: "Your edits were saved to Version History",
     previewDraftSavedSeparately: "Your edits were saved as a separate page",
     previewDraftOpenSavedPage: "Open page",
+    previewDraftMoreOptions: "More options",
+    previewDraftViewFullVersions: "View full versions",
+    previewDraftShowChanges: "Show changes",
     restorePreviewDraft: "Restore draft",
     previewDraftConflict:
       "This draft conflicts with a newer page version. It was not restored.",

package/corpus/templates/content/changelog/2026-09-15-oauth-connections-now-open-reliably-in-embedded-browsers.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-15
+---
+
+Google sign-in and Notion connections now open reliably in embedded browsers

package/corpus/templates/content/docs/solutions/2026-09-02-content-suggested-edits-parity-shape.md

@@ -3,14 +3,96 @@ title: "Content Suggested Edits parity shape"
 date: 2026-09-02
 status: shape-complete
 authoritySchemaVersion: 3
-ledgerRevision: content-suggested-edits-shape-r5
-governingArtifactRevision: content-suggested-edits-shape-r5
+ledgerRevision: content-suggested-edits-shape-r7
+governingArtifactRevision: content-suggested-edits-shape-r7
 ---
 
 # Content Suggested Edits parity
 
 ## September 12 beta repair plan
 
+### September 14 reconciliation: follow-up recovery repair
+
+PR #4911 merged on September 14. Its durable persisted-draft resolution,
+body-revision and title guards, history retention, source restrictions and
+suggested-edit behavior remain the base for one focused follow-up PR from current
+`main`. The follow-up ports only the live-editor acknowledgement and recovery
+lifecycle protections that remain absent, then gives live and page-load recovery
+one shared two-choice presentation. It does not merge, deploy, diagnose the
+reported production incidents, add automatic merging or selective acceptance,
+or promote the related product records beyond their current status.
+
+The two recovery entry points retain separate lifecycles. Live-editor recovery
+allows continued typing and returns focus to the editor when review closes.
+Persisted-draft recovery settles only the exact private draft version reviewed at
+page load. Both initially show equally weighted **Keep my edits** and **Use saved
+version** actions. **Save a separate copy** and **Copy my edits** live in an
+accessible **More options** menu. Neither version is preselected or recommended.
+
+The comparison shows changed passages with nearby context and collapses long
+unchanged runs behind **View full versions**. Full versions use the ordinary
+read-only renderer, with faithful source as the fallback. Wide editor panes align
+the two versions; narrow panes stack based on available pane width. The actual
+editor route must fit at desktop, 390px and 320px, including 200% text zoom,
+without horizontal overflow or obscured actions.
+
+Implementation sequence:
+
+1. Wire explicit successful-save acknowledgements into live reconciliation so an
+   older confirmed save advances the base without replaying its bytes over newer
+   typing. An old acknowledgement cannot supersede a newer observed revision, and
+   an identical-byte external revision still reconciles normally.
+2. Guard live recovery by generation and exact reviewed base, block duplicate
+   submission, distinguish overlap/reconcile/save failures, and repeat persistence
+   when title or body changes during an in-flight recovery. Optimistic cache state
+   is never a save acknowledgement.
+3. Reuse the existing durable draft, history and resolution actions through small
+   lifecycle adapters. A stale completion cannot clear newer recovery; the
+   unchosen version remains recoverable; separate copy creates one discoverable
+   page without changing the original.
+4. Prove the combined final revision with focused tests, independent concurrency
+   and retention review, and real-interface QA through both entry points using
+   private task-owned pages and real actions. Capture representative desktop,
+   narrow, expanded, menu, pending/error and refreshed-conflict states, then clean
+   up every fixture.
+
+Additional acceptance (cumulative with C01–C08):
+
+- **D01:** Initially exactly two visible, equally weighted resolution buttons;
+  More options exposes separate-copy and exact-copy actions with correct keyboard
+  and focus behavior.
+- **D02:** The actual editor route fits desktop, narrow desktop panes, 390px and
+  320px at normal and 200% text zoom, with readable text, modest gutters, safe-area
+  actions and no page-level horizontal overflow.
+- **D03:** Title-only, body-only, deletion, disjoint and long formatted changes
+  show faithful contextual differences; expansion reveals every passage through
+  the renderer or an explicit source fallback.
+- **D04:** Both main choices survive reload and leave the unchosen version
+  access-scoped and recoverable. An unseen update refreshes comparison and
+  requires another choice.
+- **D05:** Slow, offline, failed and repeated actions acknowledge promptly, retain
+  both versions, prevent duplicate writes and retry honestly. Copy reports success
+  or failure, and separate copy opens the one created page.
+- **D06:** Human QA uses the production component and real actions in the actual
+  editor route. Replicas and historical screenshots are not acceptance evidence.
+- **E01:** Delayed confirmed own saves advance the base without false conflict or
+  lost newer typing; old acknowledgements and identical-byte external revisions
+  preserve revision ordering.
+- **E02:** Title-only and body edits during recovery saving survive completion,
+  any required follow-up save and reload. Navigation, unmount or a newer conflict
+  cannot be cleared by an older completion.
+- **E03:** Both entry points share the two-choice comparison and secondary menu
+  while retaining their own exact lifecycle. Closing live review restores editing
+  focus without releasing recovery.
+- **E04:** Overlap, reconcile failure and save failure remain distinct and
+  retryable; interface and action read-back confirm title, body and recoverability
+  for both entry paths.
+
+Destination: one ready-for-review follow-up PR against current `main`. Do not
+merge or deploy it. The product lane remains `contract_repair` for
+`content.version.field-history` and `content.history.queryable`; neither record
+becomes fully verified through this bounded repair.
+
 ### September 13 amendment: ordinary-save reliability and recovery choices
 
 Destination: extend the existing PR #4911 on `codex/content-suggestion-beta-repairs`.

package/corpus/templates/design/.generated/bridge/editor-chrome.generated.ts

@@ -1840,8 +1840,8 @@ export const editorChromeBridgeScript: string = `"use strict";
       }
       return !(isOverlayElement(el) || el.closest("[data-agent-native-edit-overlay]"));
     }
-    function serializeRuntimeLayerSnapshot() {
-      if (!document.body) return null;
+    function serializeRuntimeLayerSnapshot(excludedRoot) {
+      if (!document.body) return { ok: false, reason: "snapshot-unavailable" };
       var snapshotComputedProperties = [
         "box-sizing",
         "display",
@@ -1931,7 +1931,7 @@ export const editorChromeBridgeScript: string = `"use strict";
       for (var index = 0; index < sourceNodes.length && index < cloneNodes.length; index += 1) {
         var sourceNode = sourceNodes[index];
         var cloneNode = cloneNodes[index];
-        if (!isRuntimeLayerVisualNode(sourceNode)) {
+        if (excludedRoot?.contains(sourceNode) || !isRuntimeLayerVisualNode(sourceNode)) {
           cloneNode.setAttribute("data-an-runtime-layer-remove", "true");
           continue;
         }
@@ -2026,8 +2026,10 @@ export const editorChromeBridgeScript: string = `"use strict";
       inlineSnapshotComputedStyle(document.body, cloneBody);
       cloneBody.setAttribute("data-an-runtime-layer-snapshot", "true");
       var html = "<!doctype html><html>" + cloneBody.outerHTML + "</html>";
-      if (html.length > 2e6) return null;
+      if (html.length > 2e6)
+        return { ok: false, reason: "snapshot-too-large" };
       return {
+        ok: true,
         html,
         nodeCount,
         documentId: runtimeDocumentId
@@ -2043,7 +2045,17 @@ export const editorChromeBridgeScript: string = `"use strict";
       runtimeLayerSnapshotTimer = null;
       runtimeLayerSnapshotMaxTimer = null;
       var snapshot = serializeRuntimeLayerSnapshot();
-      if (!snapshot || snapshot.html === lastRuntimeLayerSnapshotHtml) return;
+      if (!snapshot.ok) {
+        window.parent.postMessage(
+          {
+            type: "agent-native:runtime-layer-snapshot-error",
+            payload: snapshot
+          },
+          "*"
+        );
+        return;
+      }
+      if (snapshot.html === lastRuntimeLayerSnapshotHtml) return;
       lastRuntimeLayerSnapshotHtml = snapshot.html;
       window.parent.postMessage(
         {
@@ -9739,7 +9751,7 @@ export const editorChromeBridgeScript: string = `"use strict";
       correctAbsoluteMemberClientPosition(el, desiredDropPoint);
       publishSourceDocumentProvenance(void 0, true);
     }
-    function postVisualStructureChange(el, target, origin, insertedHtml, replaced) {
+    function postVisualStructureChange(el, target, origin, insertedHtml, replaced, replacementSnapshotHtml) {
       if (!el || !target || !target.anchor) return;
       dndLog("post:structure-change", {
         el: getSelector(el),
@@ -9770,6 +9782,7 @@ export const editorChromeBridgeScript: string = `"use strict";
           // element the source file has never contained.
           insertedHtml: typeof insertedHtml === "string" ? insertedHtml : void 0,
           replaced: replaced === true ? true : void 0,
+          replacementSnapshotHtml,
           sourceRect: rectInfoForElement(el),
           anchorRect: rectInfoForElement(target.anchor),
           payload: getElementInfo(el),
@@ -14241,6 +14254,12 @@ export const editorChromeBridgeScript: string = `"use strict";
           }
           var replaceNextSibling = insertAnchor.nextSibling;
           replaceParent.insertBefore(parsedInsertEl, insertAnchor);
+          var replacementSnapshot = serializeRuntimeLayerSnapshot(insertAnchor);
+          if (!replacementSnapshot.ok) {
+            parsedInsertEl.remove();
+            rejectInsert("replacement-" + replacementSnapshot.reason);
+            return;
+          }
           selectedEl = parsedInsertEl;
           positionOverlay(selectionOverlay, selectedEl);
           refreshOverlays();
@@ -14254,7 +14273,8 @@ export const editorChromeBridgeScript: string = `"use strict";
               prevNextSibling: replaceNextSibling
             },
             parsedInsertEl.outerHTML,
-            true
+            true,
+            replacementSnapshot.html
           );
           replaceParent.removeChild(insertAnchor);
           refreshOverlays();