@richscripts/richtexteditor 2.6.3 → 2.6.4

package/richtexteditor/all_plugins.js

@@ -21718,7 +21718,17 @@ function RTE_Plugin_Comments() {
 
         var id = "cmt-" + Date.now() + "-" + Math.floor(Math.random() * 10000);
         var user = getCurrentUser();
-        var anchor = options.anchor;
+        var anchor = options.anchor || options.range || null;
+        // Accept a plain DOM Range (or Range-like) as the anchor: it has the
+        // container/offset fields but no `.text`, so until 2026-09-02 the common
+        // call add({ anchor: range }) silently recorded the comment WITHOUT a
+        // highlight. Derive the text from the range instead.
+        if (anchor && anchor.startContainer && anchor.endContainer && !anchor.text) {
+            var derived = "";
+            try { derived = typeof anchor.toString === "function" ? String(anchor.toString()) : ""; } catch (e) { derived = ""; }
+            if (!derived) { try { derived = anchor.cloneContents ? (anchor.cloneContents().textContent || "") : ""; } catch (e2) { derived = ""; } }
+            anchor = { startContainer: anchor.startContainer, startOffset: anchor.startOffset, endContainer: anchor.endContainer, endOffset: anchor.endOffset, text: derived };
+        }
         var wrappedText = "";
 
         if (anchor && anchor.startContainer && anchor.endContainer && anchor.text) {
@@ -23437,17 +23447,12 @@ function RTE_Plugin_DocumentImport() {
             openPicker({});
         });
 
-        if (editor.slashCommands && typeof editor.slashCommands.register === "function") {
-            try {
-                editor.slashCommands.register({
-                    id: "import-document",
-                    title: "Import document",
-                    description: "Open a Markdown, HTML, text, or Word (.doc) file into the editor",
-                    keywords: ["import", "open", "file", "word", "markdown", "upload"],
-                    action: function () { openPicker({}); }
-                });
-            } catch (e) {}
-        }
+        // NOTE: do NOT call editor.slashCommands.register() from here. Plugins
+        // initialise in bundle (alphabetical) order and this file sorts before
+        // "slashcommand", so editor.slashCommands does not exist yet and the guarded
+        // call silently did nothing - the "import-document" slash entry never appeared for any
+        // customer until 2026-09-02. The entry now lives in slashcommand.js, gated on
+        // typeof editor.openImportDialog === "function" (same pattern as exportToPdf).
     };
 
     function kindFromName(name) {
@@ -29588,7 +29593,7 @@ function RTE_Plugin_InsertCode() {
 			sel_lang.options.add(new Option(aliases, brush));
 
 
-			var b = sessionStorage.getItem("rte-insertcode-lang")
+			var b = null; try { b = sessionStorage.getItem("rte-insertcode-lang"); } catch (e) { } // storage throws in sandboxed / opaque-origin embeds
 			if (b) sel_lang.value = b;
 		}
 
@@ -29608,7 +29613,7 @@ function RTE_Plugin_InsertCode() {
 		btn.onclick = function () {
 			dialoginner.close();
 
-			sessionStorage.setItem("rte-insertcode-lang", sel_lang.value)
+			try { sessionStorage.setItem("rte-insertcode-lang", sel_lang.value); } catch (e) { }
 
 			if (sel_lang.value != "") {
 				var b = dp.sh.Brushes[sel_lang.value];
@@ -36441,17 +36446,12 @@ function RTE_Plugin_ReadabilityStats() {
             openDialog();
         });
 
-        if (editor.slashCommands && typeof editor.slashCommands.register === "function") {
-            try {
-                editor.slashCommands.register({
-                    id: "readability-stats",
-                    title: "Readability statistics",
-                    description: "Flesch reading ease, grade level, and reading time",
-                    keywords: ["readability", "flesch", "grade", "reading", "stats", "score"],
-                    action: function () { openDialog(); }
-                });
-            } catch (e) {}
-        }
+        // NOTE: do NOT call editor.slashCommands.register() from here. Plugins
+        // initialise in bundle (alphabetical) order and this file sorts before
+        // "slashcommand", so editor.slashCommands does not exist yet and the guarded
+        // call silently did nothing - the "readability-stats" slash entry never appeared for any
+        // customer until 2026-09-02. The entry now lives in slashcommand.js, gated on
+        // typeof editor.getReadabilityStats === "function" (same pattern as exportToPdf).
     };
 
     function currentText() {
@@ -37877,8 +37877,9 @@ if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
 //   config.sanitizerAllowStyleTags = true    // keep <style> in content
 //   config.sanitizerAllowIframes = false     // drop <iframe> outright
 //   config.sanitizerAllowedIframeHosts = ["www.youtube.com"]
-//   config.sanitizerAllowTags = ["custom-el"]
-//   config.sanitizerAllowAttributes = ["my-attr"]
+//   config.sanitizerAllowTags = ["custom-el", "x-*", /^ui-/]
+//   config.sanitizerAllowAttributes = ["my-attr", "data-cms-*"]
+//        exact names, "*" wildcards, or RegExp -- see buildMatcher()
 RTE_DefaultConfig.plugin_sanitizer = RTE_Plugin_Sanitizer;
 if (typeof RTE_DefaultConfig.contentSanitizer === "undefined") RTE_DefaultConfig.contentSanitizer = true;
 
@@ -38065,12 +38066,63 @@ function RTE_Plugin_Sanitizer() {
         return false;
     }
 
+    // Build a name matcher from a config list. Entries may be:
+    //   "my-widget"   an exact name
+    //   "my-*"        a wildcard, where * matches any run of characters
+    //   /^my-/        a RegExp
+    // The wildcard form is what makes this a workable answer to CKEditor's General
+    // HTML Support: without it an integrator has to enumerate every tag and
+    // attribute a CMS might emit, by name, which nobody does -- so the content gets
+    // unwrapped instead and the integrator concludes the editor destroys it.
+    //
+    // A pattern widens what is KEPT, never what is executed: on* handlers,
+    // javascript: URLs, <script> and iframe[srcdoc] are all handled before this is
+    // consulted, so allowing a tag or attribute by pattern cannot re-open those.
+    //
+    // Wildcards are matched by hand rather than compiled to a RegExp, so a config
+    // value can never be a regex-injection vector and no escaping table has to be
+    // kept correct.
+    function buildMatcher(list) {
+        var literal = {};
+        var globs = [];
+        var regexps = [];
+        (list || []).forEach(function (entry) {
+            if (entry instanceof RegExp) { regexps.push(entry); return; }
+            var t = String(entry).toLowerCase();
+            if (t.indexOf("*") === -1) { literal[t] = true; return; }
+            globs.push(t.split("*"));
+        });
+        function globMatches(parts, name) {
+            // parts came from splitting on "*": they must appear in order, the first
+            // anchored at the start and the last at the end.
+            var first = parts[0];
+            if (name.lastIndexOf(first, 0) !== 0) return false;
+            var last = parts[parts.length - 1];
+            if (last) {
+                if (name.length < last.length) return false;
+                if (name.indexOf(last, name.length - last.length) === -1) return false;
+            }
+            var pos = first.length;
+            for (var i = 1; i < parts.length; i++) {
+                if (!parts[i]) continue;
+                var at = name.indexOf(parts[i], pos);
+                if (at === -1) return false;
+                pos = at + parts[i].length;
+            }
+            return true;
+        }
+        return function (name) {
+            if (literal[name]) return true;
+            for (var i = 0; i < globs.length; i++) if (globMatches(globs[i], name)) return true;
+            for (var j = 0; j < regexps.length; j++) if (regexps[j].test(name)) return true;
+            return false;
+        };
+    }
+
     // --------------------------------------------------------------- engine
     function sanitizeNode(root, report) {
-        var allowExtra = {};
-        (config.sanitizerAllowTags || []).forEach(function (t) { allowExtra[String(t).toLowerCase()] = true; });
-        var attrExtra = {};
-        (config.sanitizerAllowAttributes || []).forEach(function (a) { attrExtra[String(a).toLowerCase()] = true; });
+        var allowExtra = buildMatcher(config.sanitizerAllowTags);
+        var attrExtra = buildMatcher(config.sanitizerAllowAttributes);
         var allowStyleTag = config.sanitizerAllowStyleTags === true;
 
         // Collect first: removing nodes while walking a live list skips siblings.
@@ -38079,7 +38131,7 @@ function RTE_Plugin_Sanitizer() {
             for (var i = 0; i < n.childNodes.length; i++) {
                 var c = n.childNodes[i];
                 if (c.nodeType === 1) { all.push(c); collect(c); }
-                else if (c.nodeType === 8) all.push(c);   // comments can hide markup
+                else if (c.nodeType === 8) all.push(c);   // checked, see commentEscapes()
             }
         })(root);
 
@@ -38087,7 +38139,33 @@ function RTE_Plugin_Sanitizer() {
             var el = all[i];
             if (!el.parentNode) continue;                 // already removed with an ancestor
 
-            if (el.nodeType === 8) { el.parentNode.removeChild(el); continue; }
+            if (el.nodeType === 8) {
+                // Comments used to be removed wholesale, on the stated grounds that
+                // "comments can hide markup". That reason does not survive testing:
+                // serialise <!--<script>alert(1)</script>--> and re-parse it and the
+                // script is inert -- a well-formed comment is just text.
+                //
+                // What IS unsafe is a narrow, enumerable set of comment DATA that
+                // cannot survive serialisation, because the serialiser writes the
+                // data verbatim between <!-- and -->. Re-parsing then ends the
+                // comment early and the remainder becomes live markup:
+                //
+                //   "--> <img src=x onerror=...>"  -> <!----> <img ...>-->   ESCAPES
+                //   "--!> <img ...>"               -> <!----!> <img ...>-->  ESCAPES
+                //   "> <img ...>"                  -> <!--> <img ...>-->     ESCAPES
+                //   "-> <img ...>"                 -> <!---> <img ...>-->    ESCAPES
+                //
+                // That is the WHATWG serialisation constraint, not a heuristic, so
+                // it can be enumerated rather than guessed at. Everything else is
+                // kept, which is what lets a CMS round-trip its own markers and lets
+                // an email template keep its Outlook conditional comments -- the
+                // mechanism emailtoolkit.js needs and could not previously rely on.
+                if (commentEscapes(el.data)) {
+                    note(report.removedTags, "#comment");
+                    el.parentNode.removeChild(el);
+                }
+                continue;
+            }
 
             var tag = (el.localName || el.nodeName || "").toLowerCase();
 
@@ -38115,7 +38193,7 @@ function RTE_Plugin_Sanitizer() {
                 note(report.removedTags, tag);
                 el.parentNode.removeChild(el);
                 continue;
-            } else if (!ALLOWED_TAGS[tag] && !allowExtra[tag]) {
+            } else if (!ALLOWED_TAGS[tag] && !allowExtra(tag)) {
                 // Unknown element: unwrap rather than delete, so the words a
                 // user typed inside a stray tag are not silently lost.
                 note(report.removedTags, tag);
@@ -38144,7 +38222,7 @@ function RTE_Plugin_Sanitizer() {
                     if (!isSafeUrl(value, tag, name)) { note(report.removedAttributes, tag + "[" + name + "]"); el.removeAttribute(attrs[k].name); }
                     continue;
                 }
-                if (!ALLOWED_ATTRS[name] && !attrExtra[name]) {
+                if (!ALLOWED_ATTRS[name] && !attrExtra(name)) {
                     note(report.removedAttributes, name);
                     el.removeAttribute(attrs[k].name);
                 }
@@ -38257,6 +38335,44 @@ function RTE_Plugin_Sanitizer() {
     // Measured: the payload ran locally AND replicated to the peer with its
     // onerror attribute intact.
     //
+    // THREAT MODEL -- read this before tightening or loosening the rule below.
+    //
+    // An escaping comment CANNOT BE AUTHORED AS AN HTML STRING. Feed
+    // `<!--x--> <img src=q onerror=...>-->` to setHTMLCode and the parser yields
+    // comment("x") + text + a normal <img> element, which the element/attribute
+    // filters already handle. The ONLY way to obtain a comment node whose data
+    // escapes is programmatic DOM construction -- document.createComment(), or a
+    // sync layer building nodes directly.
+    //
+    // That is why the guard lives on the DOM-level paths (the sanitise pass and the
+    // live-DOM MutationObserver) and why the string paths need nothing extra. Both
+    // string directions were measured: sender getHTMLCode, receiver setHTMLCode, and
+    // the receiver's live DOM all yield zero executable attributes, because
+    // wrapSerializers() and wrapSetters() filter on the way out and on the way in.
+    //
+    // The previous rule here deleted EVERY comment, justified only by the remark
+    // "comments can hide markup". That is false -- serialise
+    // <!--<script>alert(1)</script>--> and re-parse it and the script is inert -- and
+    // it cost the product CMS round-tripping and Outlook conditional comments (the
+    // mechanism emailtoolkit.js needs) for as long as nobody re-checked it. An
+    // unexplained restriction outlives its reason, so this one is written down.
+    //
+    // A comment's data is written verbatim between <!-- and -->, so data that
+    // contains a terminator (or opens with one) breaks out of the comment when the
+    // serialised output is re-parsed, turning the remainder into live markup.
+    // Module scope on purpose: both the sanitiser pass and the live-DOM
+    // MutationObserver below need it, and they must agree exactly on what is unsafe.
+    // Deliberately conservative -- it rejects rather than rewrites, because silently
+    // editing someone's comment text is its own kind of surprise.
+    function commentEscapes(data) {
+        var d = String(data == null ? "" : data);
+        if (d.indexOf("-->") !== -1) return true;
+        if (d.indexOf("--!>") !== -1) return true;
+        if (d.charAt(0) === ">") return true;
+        if (d.charAt(0) === "-" && d.charAt(1) === ">") return true;
+        return false;
+    }
+
     // A MutationObserver is the only place to catch every arrival path — sync,
     // drop, a third-party plugin, host-page code. It is honest to say this
     // narrows the window rather than closing it completely: the observer runs
@@ -38307,6 +38423,16 @@ function RTE_Plugin_Sanitizer() {
                 }
                 for (var a = 0; a < rec.addedNodes.length; a++) {
                     var node = rec.addedNodes[a];
+                    // Comments are preserved now, so an injected comment whose data
+                    // escapes on re-parse has to wake the sanitiser. This loop used
+                    // to skip every non-element node, which was safe only while
+                    // comments were being deleted unconditionally. The CRDT sync
+                    // path is exactly how a node arrives here without passing the
+                    // input filter -- that is the path that produced the stored XSS.
+                    if (node.nodeType === 8) {
+                        if (commentEscapes(node.data)) { suspect = true; break; }
+                        continue;
+                    }
                     if (node.nodeType !== 1) continue;      // typing inserts text: free
                     if (looksDangerous(node)) { suspect = true; break; }
                 }
@@ -38495,7 +38621,17 @@ function RTE_Plugin_ShadowDom() {
         var id = String(node.id || "");
         if (/^rte[-_]|^__rte/.test(id)) return true;
         var href = node.href || "";
-        if (!href) return false;
+        if (!href) {
+            // An inline <style> with no id and no href is what bundlers (Vite,
+            // webpack style-loader) inject for an imported theme. Recognise it by
+            // its content, or a shadow-root editor is unstyled (39,726 px toolbar,
+            // Times New Roman) exactly as before this plugin existed. 2026-09-02.
+            if (node.tagName === "STYLE") {
+                var css = node.textContent || "";
+                return /[.]richtexteditor|rte-toolbar|rte-editor|rte-dialog|[.]rte-a11y/.test(css);
+            }
+            return false;
+        }
         var base = assetBase();
         if (base && href.indexOf(base) === 0) return true;
         // Fall back to the file names this product actually ships, so an
@@ -38643,7 +38779,7 @@ function RTE_Plugin_SlashCommand() {
         editor.slashCommands = {
             register: registerCommand,
             remove: removeCommand,
-            list: function () { return commands.slice(); },
+            list: function () { refreshDefaults(); return commands.slice(); },
             open: function () { openPopup(true); },
             close: closePopup,
             isOpen: function () { return !!popupEl; }
@@ -38655,6 +38791,15 @@ function RTE_Plugin_SlashCommand() {
                 registerCommand(config.slashCommands[i]);
             }
         }
+        // Plugins initialise synchronously in bundle (alphabetical) order, so at
+        // this point every plugin sorting AFTER "slashcommand" (tabletools,
+        // textdirection, watermark, tableofcontents, typewriter, ...) has not
+        // defined its editor.* API yet and the typeof gates in
+        // buildDefaultCommands() were false: nine entries (sort asc/desc, rtl/
+        // ltr/autodir, watermark, toc, typewriter, focusmode) were missing for
+        // every customer until 2026-09-02. Rebuild once the constructor has
+        // finished (setTimeout 0 runs after all plugin inits) and again on open.
+        setTimeout(refreshDefaults, 0);
 
         injectStyles();
 
@@ -38677,7 +38822,26 @@ function RTE_Plugin_SlashCommand() {
         else commands.push(normalizeCommand(def));
     }
 
+    var removedIds = {};
+    // Rebuild the gated default entries (their typeof checks may only be true
+    // now) while keeping every custom registration and honouring remove().
+    function refreshDefaults() {
+        if (!editor) return;
+        var custom = [];
+        for (var i = 0; i < commands.length; i++) if (!commands[i]._default) custom.push(commands[i]);
+        var defaults = buildDefaultCommands();
+        var next = [];
+        for (var d = 0; d < defaults.length; d++) {
+            var id = defaults[d].id;
+            if (removedIds[id]) continue;
+            var overridden = false;
+            for (var c = 0; c < custom.length; c++) if (custom[c].id === id) { overridden = true; break; }
+            if (!overridden) next.push(defaults[d]);
+        }
+        commands = next.concat(custom);
+    }
     function removeCommand(id) {
+        removedIds[id] = true;
         var idx = findCommandIndex(id);
         if (idx >= 0) commands.splice(idx, 1);
     }
@@ -38687,12 +38851,25 @@ function RTE_Plugin_SlashCommand() {
         return -1;
     }
 
+    // Localization with an English fallback for EVERY entry (defaults, plugin
+    // register() calls, AI actions, config.slashCommands): the lang packs set
+    // config.text_<key>; __GetLangText returns the raw KEY when one is missing,
+    // so resolve only when a translation exists. Keys: text_slash_<id> (title),
+    // text_slash_<id>_desc (description), text_slash_section_<section>.
+    function L(key, fallback) {
+        try {
+            var k = String(key).toLowerCase().replace(/[^a-z0-9_]/g, "_");
+            if (config && config["text_" + k] && editor && typeof editor.getLangText === "function") return editor.getLangText(k);
+        } catch (e) { }
+        return fallback;
+    }
     function normalizeCommand(def) {
+        var section = def.section || "Blocks";
         return {
             id: def.id,
-            section: def.section || "Blocks",
-            title: def.title || def.id,
-            description: def.description || "",
+            section: L("slash_section_" + section, section),
+            title: L("slash_" + def.id, def.title || def.id),
+            description: L("slash_" + def.id + "_desc", def.description || ""),
             keywords: (def.keywords || []).slice(),
             icon: def.icon || "",
             iconSvg: def.iconSvg || "",
@@ -38743,11 +38920,13 @@ function RTE_Plugin_SlashCommand() {
         var list = [];
 
         function push(section, id, title, description, keywords, iconSvg, run) {
-            list.push(normalizeCommand({
+            var cmd = normalizeCommand({ // normalizeCommand localizes title/description/section
                 id: id, section: section, title: title,
                 description: description, keywords: keywords,
                 iconSvg: iconSvg, run: run
-            }));
+            });
+            cmd._default = true;
+            list.push(cmd);
         }
 
         push("Blocks", "heading1", "Heading 1", "Large section heading", ["h1", "title"], iconHeading("1"),
@@ -38963,7 +39142,8 @@ function RTE_Plugin_SlashCommand() {
         // Gated on the API rather than registered by the plugin itself: plugins
         // initialise in bundle order, so anything sorting before "slashcommand"
         // would call slashCommands.register() before it exists and vanish from
-        // this menu without any error. This check runs when the menu opens.
+        // this menu without any error. These checks are re-run by refreshDefaults()
+        // after all plugins have initialised and again each time the menu opens.
         if (typeof editor.exportToPdf === "function") {
             push("Tools", "exportpdf", "Export to PDF", "Real text, not a screenshot — selectable, searchable and screen-reader friendly", ["pdf", "export", "download", "save", "print", "text", "accessible", "searchable"], iconPdfText(),
                 function () { editor.exportToPdf(); });
@@ -38972,6 +39152,32 @@ function RTE_Plugin_SlashCommand() {
             push("Tools", "exportdocx", "Export to Word (.docx)", "A real OOXML document, built in the browser with no upload", ["word", "docx", "ooxml", "export", "download", "save", "office"], iconWordFile(),
                 function () { editor.exportToDocx(); });
         }
+        // documentimport.js and readabilitystats.js sort before this file, so they
+        // cannot register at init (editor.slashCommands does not exist yet); their
+        // guarded calls silently did nothing and these two entries were missing for
+        // every customer until 2026-09-02. Declared here, gated on the plugin API.
+        if (typeof editor.openImportDialog === "function") {
+            push("Tools", "import-document", "Import document", "Open a Markdown, HTML, text, or Word file into the editor", ["import", "open", "file", "word", "docx", "markdown", "upload"], iconWordFile(),
+                function () { editor.openImportDialog({}); });
+        }
+        if (typeof editor.getReadabilityStats === "function") {
+            push("Tools", "readability-stats", "Readability statistics", "Flesch reading ease, grade level, and reading time", ["readability", "flesch", "grade", "reading", "stats", "score"], iconSpell(),
+                function () { editor.execCommand("readability"); });
+        }
+        // Marketed features that had NO toolbar button and NO slash entry (reachable
+        // only via the API) until 2026-09-02. All gated on the owning plugin.
+        if (typeof editor.insertCrossReference === "function") {
+            push("Insert", "crossreference", "Cross-reference", "Insert a live reference to a heading, figure, table, or bookmark", ["cross", "reference", "xref", "see", "figure", "heading"], iconXref(),
+                function () { editor.execCommand("insertcrossreference"); });
+        }
+        if (editor.restrictedEditing) {
+            push("Tools", "restrictedediting", "Restricted editing", "Lock the document and mark only the regions others may edit", ["restrict", "lock", "protect", "editable", "region", "permission"], iconPen(),
+                function () { editor.execCommand("restrictedediting"); });
+        }
+        if (editor.dictation) {
+            push("Tools", "dictation", "Dictation", "Speak and have your words typed into the document", ["dictate", "speech", "voice", "microphone", "talk"], iconReadAloud(),
+                function () { editor.execCommand("dictation"); });
+        }
         if (typeof editor.copyAsMarkdown === "function") {
             push("Tools", "copymarkdown", "Copy as Markdown", "Copy the whole document to the clipboard as Markdown", ["markdown", "md", "copy", "clipboard", "export"], iconMarkdown(),
                 function () { editor.copyAsMarkdown(); });
@@ -39103,6 +39309,7 @@ function RTE_Plugin_SlashCommand() {
     }
 
     function openPopup(manual) {
+        refreshDefaults();
         closePopup();
         var sel = editor.getSelection();
         if (!sel || sel.rangeCount === 0) return;
@@ -43018,9 +43225,42 @@ function RTE_Plugin_YjsCollab() {
         // and the review ledger bridge.
         if (session.textSyncMode === "crdt") {
             try {
+                // 2026-09-02: the engine bundles its OWN Yjs and builds nodes with it.
+                // A doc built by the host's Yjs (npm/esm "yjs" + y-websocket - the
+                // documented path) is a FOREIGN instance: inserting engine-built nodes
+                // into it throws "Unexpected content type in insert operation" and text
+                // never syncs, while presence still works and the status still said
+                // "crdt". Yjs updates are instance-independent bytes, so bind the
+                // engine to an inner doc built with ITS Yjs and bridge updates both
+                // ways: host->inner with the engine's applyUpdate, inner->host with the
+                // host's module (options.Y or window.Y). Without the host module the
+                // outbound leg cannot be applied safely, so fail LOUDLY instead.
+                var engineY = window.RichTextEditorCrdt.Y || null;
+                var hostY = options.Y || (typeof window !== "undefined" ? window.Y : null) || null;
+                var bindDoc = doc;
+                var foreign = !!(engineY && engineY.Doc && !(doc instanceof engineY.Doc));
+                if (foreign) {
+                    if (!hostY || typeof hostY.applyUpdate !== "function" || typeof hostY.encodeStateAsUpdate !== "function") {
+                        throw new Error("yjscollab: the Y.Doc was created by a different Yjs instance than crdt-engine.js bundles. Pass your Yjs module to attach({ Y }) (or build the doc with window.RichTextEditorCrdt.Y) so text can be bridged.");
+                    }
+                    var BRIDGE = { bridge: "rte-yjs-bridge" };
+                    var inner = new engineY.Doc();
+                    engineY.applyUpdate(inner, hostY.encodeStateAsUpdate(doc), BRIDGE);
+                    var LOCAL = window.RichTextEditorCrdt.LOCAL_ORIGIN;
+                    // A host-doc write the plugin tagged as LOCAL (ledger entries) must not
+                    // make the engine re-render the editable (see flush race in the engine).
+                    var hostToInner = function (update, origin) { if (origin === BRIDGE) return; try { engineY.applyUpdate(inner, update, (LOCAL && origin === LOCAL) ? LOCAL : BRIDGE); } catch (e) { if (window.console) console.error("yjscollab bridge host->inner:", e); } };
+                    var innerToHost = function (update, origin) { if (origin === BRIDGE) return; try { hostY.applyUpdate(doc, update, BRIDGE); } catch (e) { if (window.console) console.error("yjscollab bridge inner->host:", e); } };
+                    doc.on("update", hostToInner);
+                    inner.on("update", innerToHost);
+                    session.cleanup.push(function () { try { doc.off("update", hostToInner); } catch (e) { } try { inner.off("update", innerToHost); } catch (e) { } try { inner.destroy(); } catch (e) { } });
+                    session.yjsBridge = true;
+                    bindDoc = inner;
+                    if (window.console && console.info) console.info("yjscollab: bridging a foreign Yjs doc into the CRDT engine (updates relayed both ways).");
+                }
                 session.crdtBinding = window.RichTextEditorCrdt.attachCrdtBinding({
                     editable: editor.getEditable(),
-                    ydoc: doc,
+                    ydoc: bindDoc,
                     provider: provider,
                     awareness: provider.awareness,
                     fragmentName: options.fragmentName || "default",
@@ -43033,6 +43273,24 @@ function RTE_Plugin_YjsCollab() {
                     try { session.crdtBinding && session.crdtBinding.dispose(); }
                     catch (ignore) { }
                 });
+                // Per-author undo. The engine ships a Y.UndoManager scoped to LOCAL_ORIGIN
+                // (undo.ts) but nothing attached it, so Ctrl+Z ran the core DOM-snapshot
+                // undo and reverted OTHER people's edits on every peer (2026-09-02). Route
+                // undo/redo to the engine while crdt mode is active.
+                try {
+                    if (typeof window.RichTextEditorCrdt.attachUndoManager === "function" && session.crdtBinding && session.crdtBinding.fragment) {
+                        session.undoManager = window.RichTextEditorCrdt.attachUndoManager({ fragment: session.crdtBinding.fragment });
+                        var undoHook = function (state) { if (!session || !session.undoManager) return; state.returnValue = true; state.stopBubble = true; try { session.undoManager.undo(); } catch (e) { } };
+                        var redoHook = function (state) { if (!session || !session.undoManager) return; state.returnValue = true; state.stopBubble = true; try { session.undoManager.redo(); } catch (e) { } };
+                        editor.attachEvent("exec_command_undo", undoHook);
+                        editor.attachEvent("exec_command_redo", redoHook);
+                        session.cleanup.push(function () {
+                            try { if (typeof editor.detachEvent === "function") { editor.detachEvent("exec_command_undo", undoHook); editor.detachEvent("exec_command_redo", redoHook); } } catch (e) { }
+                            try { session.undoManager && session.undoManager.destroy(); } catch (e) { }
+                            session.undoManager = null;
+                        });
+                    }
+                } catch (undoErr) { if (window.console) console.warn("yjscollab: undo manager not attached:", undoErr); }
             } catch (err) {
                 session.fallbackReason = "crdt-attach-failed";
                 session.crdtError = err;
@@ -43065,7 +43323,7 @@ function RTE_Plugin_YjsCollab() {
         }
         return {
             attached: true,
-            textSyncMode: session.textSyncMode,
+            textSyncMode: session.textSyncMode, yjsBridge: !!session.yjsBridge,
             requestedTextSync: session.requestedTextSync,
             fallbackReason: session.fallbackReason || null,
             peerCount: getRemotePeers().length
@@ -43310,6 +43568,52 @@ function RTE_Plugin_YjsCollab() {
             lastKnownHtml = localInitial;
         }
 
+        // --- IME composition gate (legacy snapshot mode) ---------------------
+        // setEditorHtml() replaces the whole document. Doing that while an IME
+        // is composing swaps the live text node out from under it, so the
+        // commit lands at a stale offset and the raw buffer survives: composing
+        // "shi" and committing a character while a collaborator typed produced
+        // "Xbasesh<char>i" on BOTH peers (2026-09-03 — the same corruption the
+        // crdt binding had, on the deprecated-but-supported path v2.0 customers
+        // still run). Hold the repaint until the composition commits.
+        var composing = false;
+        var pendingRemoteHtml = null;
+        var compositionDoc = (editor.getDocument && editor.getDocument()) || null;
+        if (compositionDoc) {
+            var onCompStart = function () { composing = true; };
+            var onCompEnd = function () {
+                if (!composing) return;
+                composing = false;
+                setTimeout(function () {
+                    if (pendingRemoteHtml !== null) {
+                    // Deliberately NOT repainting: that would discard the
+                    // character the IME just committed. Adopt the remote text as
+                    // the diff baseline instead, so the local push that follows
+                    // is computed against what the peers actually hold. Legacy
+                    // mode is documented last-write-wins on same-paragraph
+                    // conflicts, so the local commit winning is correct here —
+                    // corrupted text was not.
+                        lastKnownHtml = pendingRemoteHtml;
+                        pendingRemoteHtml = null;
+                    }
+                    // Push explicitly. The commit's DOM mutation is delivered to
+                    // the MutationObserver BEFORE compositionend fires, so it was
+                    // dropped by the `composing` guard — without this the
+                    // committed character never reaches the peers at all
+                    // (measured: A "base<char>", B "base").
+                    onEditorMutation();
+                }, 0);
+            };
+            // Bound on the DOCUMENT, not the body: some skins remount the body
+            // (see attachMutationObserver below) and composition events bubble.
+            compositionDoc.addEventListener("compositionstart", onCompStart, true);
+            compositionDoc.addEventListener("compositionend", onCompEnd, true);
+            session.cleanup.push(function () {
+                compositionDoc.removeEventListener("compositionstart", onCompStart, true);
+                compositionDoc.removeEventListener("compositionend", onCompEnd, true);
+            });
+        }
+
         // Y.Text → editor.
         var onTextChange = function (event, transaction) {
             if (pushing) return;
@@ -43317,6 +43621,7 @@ function RTE_Plugin_YjsCollab() {
             if (transaction && transaction.local) return;
             var fresh = session.textMap.toString();
             if (fresh === lastKnownHtml) return;
+            if (composing) { pendingRemoteHtml = fresh; return; }
             setEditorHtml(fresh);
             lastKnownHtml = fresh;
             // 2026-05-28 setEditorHtml writes into editable.innerHTML; if that
@@ -43331,6 +43636,9 @@ function RTE_Plugin_YjsCollab() {
         // Editor DOM → Y.Text. Debounced so bursts collapse to one CRDT diff.
         var onEditorMutation = function () {
             if (applying) return;
+            // Intermediate IME buffers are not real edits; the commit fires its
+            // own mutation. Pushing them also races the composition gate above.
+            if (composing) return;
             if (pendingPushTimer) return;
             // 2026-05-28 Re-attach observer if the body was remounted since last
             // mutation. Cheap no-op when body is unchanged.
@@ -43418,17 +43726,17 @@ function RTE_Plugin_YjsCollab() {
 
         ledger.add = function (entry) {
             var result = originalAdd.call(ledger, entry);
-            if (result && !echoGuard) session.ledgerMap.set(result.id, cloneEntry(result));
+            if (result && !echoGuard) ledgerWrite(function () { session.ledgerMap.set(result.id, cloneEntry(result)); });
             return result;
         };
         ledger.update = function (id, patch) {
             var result = originalUpdate.call(ledger, id, patch);
-            if (result && !echoGuard) session.ledgerMap.set(result.id, cloneEntry(result));
+            if (result && !echoGuard) ledgerWrite(function () { session.ledgerMap.set(result.id, cloneEntry(result)); });
             return result;
         };
         ledger.remove = function (id) {
             var result = originalRemove.call(ledger, id);
-            if (result && !echoGuard) session.ledgerMap.delete(id);
+            if (result && !echoGuard) ledgerWrite(function () { session.ledgerMap.delete(id); });
             return result;
         };
 
@@ -43462,6 +43770,16 @@ function RTE_Plugin_YjsCollab() {
         });
     }
 
+    // Ledger writes are the plugin's own (non-text) Y.Doc transactions. In crdt
+    // mode they are tagged with the engine's LOCAL_ORIGIN so the engine does not
+    // re-render the editable for them - a re-render between a DOM mutation and
+    // the observer flush discarded that mutation (2026-09-02: comment anchors
+    // vanished the instant the ledger entry was written).
+    function ledgerWrite(fn) {
+        var origin = (session && session.textSyncMode === "crdt" && window.RichTextEditorCrdt) ? window.RichTextEditorCrdt.LOCAL_ORIGIN : null;
+        if (origin && session && session.doc && typeof session.doc.transact === "function") { session.doc.transact(fn, origin); }
+        else { fn(); }
+    }
     function seedLedgerFromRemote() {
         if (!editor.reviewLedger || !session.ledgerMap) return;
         echoGuard = true;