@richscripts/richtexteditor 2.14.0 → 2.15.0

package/integrations/initialization-scope.js

@@ -0,0 +1,27 @@
+// Private framework lifecycle helper. Never abort a caller's shared controller.
+function createInitializationScope(parentSignal) {
+    var controller = typeof AbortController === "function" ? new AbortController() : null;
+    var disposed = false;
+    var forwardAbort = null;
+    function complete() {
+        if (parentSignal && forwardAbort) parentSignal.removeEventListener("abort", forwardAbort);
+        forwardAbort = null;
+        parentSignal = null;
+    }
+    if (controller && parentSignal) {
+        forwardAbort = function () { controller.abort(parentSignal.reason); };
+        if (parentSignal.aborted) forwardAbort();
+        else parentSignal.addEventListener("abort", forwardAbort, { once: true });
+    }
+    return {
+        signal: controller ? controller.signal : parentSignal,
+        complete: complete,
+        dispose: function () {
+            if (disposed) return;
+            disposed = true;
+            complete();
+            if (controller) controller.abort();
+        }
+    };
+}
+module.exports = { createInitializationScope: createInitializationScope };

package/integrations/native-mount.js

@@ -0,0 +1,30 @@
+// Native inputs are converted into a sibling editor by the core. Frameworks
+// remove their input, not that sibling; retain ownership of only the generated
+// chrome and restore the input's original visibility during teardown.
+function captureNativeMount(host) {
+    if (!host || !/^(INPUT|TEXTAREA)$/i.test(host.tagName || host.nodeName || "")) return null;
+    var previous = host.__rteIntegrationNativeMount;
+    var ownership = { host: host, parent: host.parentNode, display: previous ? previous.display : host.style && host.style.display,
+        hidden: previous ? previous.hidden : host.__rteHidden,
+        hadHidden: previous ? previous.hadHidden : Object.prototype.hasOwnProperty.call(host, "__rteHidden") };
+    host.__rteIntegrationNativeMount = ownership;
+    return ownership;
+}
+function releaseNativeMount(editor, ownership) {
+    if (!ownership) return;
+    var host = ownership.host, parent = ownership.parent, root = editor && editor.container;
+    if (root && root !== host && parent) {
+        while (root && root.parentNode !== parent) root = root.parentNode;
+        // Never remove the framework-owned input or a wrapper containing it.
+        var cursor = host, containsHost = false;
+        while (cursor) { if (cursor === root) { containsHost = true; break; } cursor = cursor.parentNode; }
+        if (root && root !== host && !containsHost && root.parentNode === parent) parent.removeChild(root);
+    }
+    if (host.__rteIntegrationNativeMount === ownership) {
+        if (host.style) host.style.display = ownership.display || "";
+        if (ownership.hadHidden) host.__rteHidden = ownership.hidden;
+        else delete host.__rteHidden;
+        delete host.__rteIntegrationNativeMount;
+    }
+}
+module.exports = { captureNativeMount: captureNativeMount, releaseNativeMount: releaseNativeMount };

package/integrations/shared.d.ts

@@ -9,6 +9,7 @@ import type {
   RichTextEditorInstance,
   RichTextEditorLinkAuditOptions,
   RichTextEditorLinkAuditResult,
+  RichTextEditorPageSetup,
   RichTextEditorStructuredDocument,
   RichTextEditorStructuredNode,
   RichTextEditorStructuredInput,
@@ -19,10 +20,24 @@ import type {
   RichTextEditorValueFormat
 } from "../index";
 
+/** An instance after the structured-content bridge has been installed. */
+export interface RichTextEditorBridgedInstance extends RichTextEditorInstance {
+  getJSON(): RichTextEditorStructuredDocument;
+  setJSON(value: RichTextEditorStructuredInput): this;
+}
+
+export interface RichTextEditorChangeCoalescer {
+  (): void;
+  flush(): void;
+  cancel(): void;
+}
+
+export function createChangeCoalescer(emit: () => void, delay?: number): RichTextEditorChangeCoalescer;
+
 export function createEditor(
   element: string | Element,
   config?: Record<string, unknown>
-): RichTextEditorInstance;
+): RichTextEditorBridgedInstance;
 
 export function auditAccessibility(
   value: RichTextEditorStructuredInput
@@ -67,6 +82,13 @@ export function getDocumentMetrics(
   }
 ): RichTextEditorDocumentMetrics;
 
+export function getDocumentPageSetup(value: RichTextEditorStructuredInput): RichTextEditorPageSetup | null;
+
+export function setDocumentPageSetup(
+  value: RichTextEditorStructuredInput,
+  pageSetup: RichTextEditorPageSetup | null
+): RichTextEditorStructuredDocument;
+
 export function getMarkdownShortcutAction(
   value: string | null | undefined
 ): {

package/integrations/shared.js

@@ -1,4 +1,5 @@
-var pendingLoadsByBasePath = {};
+var pendingLoadsByBasePath = Object.create(null);
+var failedLoadsByBasePath = Object.create(null);
 
 var INLINE_CONTAINER_TAGS = {
     a: true,
@@ -1789,7 +1790,7 @@ function parseBlockNode(node) {
         }
         var orderedListAttrs = {};
         if (startValue) {
-            orderedListAttrs.start = parseInt(startValue, 10) || 1;
+            orderedListAttrs.start = (isFinite(parseInt(startValue, 10)) ? parseInt(startValue, 10) : 1);
         }
         if (orderedListType) {
             orderedListAttrs.orderedListType = orderedListType;
@@ -2529,7 +2530,7 @@ function escapeHtml(value) {
 }
 
 function escapeAttribute(value) {
-    return escapeHtml(value).replace(/"/g, """);
+    return escapeHtml(value === undefined || value === null ? "" : String(value)).replace(/"/g, """);
 }
 
 function buildAttributeString(attrs) {
@@ -2782,7 +2783,7 @@ function serializeNode(node, inlineMode) {
 
     if (node.type === "orderedList") {
         var listAttrs = {};
-        if (node.attrs && node.attrs.start) {
+        if (node.attrs && node.attrs.start !== undefined && node.attrs.start !== null) {
             listAttrs.start = node.attrs.start;
         }
         if (node.attrs) {
@@ -3183,8 +3184,8 @@ function validateNode(node, path, mode, issues) {
 
     if (node.type === "bulletList" || node.type === "orderedList") {
         if (node.type === "orderedList" && node.attrs && node.attrs.start !== undefined) {
-            if (typeof node.attrs.start !== "number" || node.attrs.start < 1) {
-                issues.push(createValidationIssue(path + ".attrs.start", "Ordered lists require a positive numeric start value."));
+            if (typeof node.attrs.start !== "number" || !isFinite(node.attrs.start) || Math.floor(node.attrs.start) !== node.attrs.start || Math.abs(node.attrs.start) > 9007199254740991) {
+                issues.push(createValidationIssue(path + ".attrs.start", "Ordered lists require a finite safe integer start value."));
             }
         }
         if (node.type === "orderedList" && node.attrs && node.attrs.orderedListType !== undefined) {
@@ -3919,12 +3920,12 @@ function getMarkdownListMatch(line) {
         };
     }
 
-    var orderedMatch = /^(\s*)(\d+)\.\s+(.*)$/.exec(line);
+    var orderedMatch = /^(\s*)(\d{1,9})\.\s+(.*)$/.exec(line);
     if (orderedMatch) {
         return {
             indent: orderedMatch[1].length,
             ordered: true,
-            start: parseInt(orderedMatch[2], 10) || 1,
+            start: parseInt(orderedMatch[2], 10),
             text: orderedMatch[3],
             marker: orderedMatch[2] + ".",
             contentIndent: orderedMatch[1].length + orderedMatch[2].length + 2,
@@ -4914,8 +4915,13 @@ function serializeMarkdownBlocks(nodes) {
 
         if (node.type === "bulletList" || node.type === "orderedList") {
             var listParts = [];
-            var start = node.type === "orderedList" && node.attrs && node.attrs.start ? parseInt(node.attrs.start, 10) || 1 : 1;
+            var start = node.type === "orderedList" && node.attrs && node.attrs.start !== undefined ? parseInt(node.attrs.start, 10) : 1;
+            if (!isFinite(start)) start = 1;
             var listItems = node.content || [];
+            if (node.type === "orderedList" && (start < 0 || start + Math.max(0, listItems.length - 1) > 999999999)) {
+                parts.push(serializeNode(node, false));
+                continue;
+            }
             for (var itemIndex = 0; itemIndex < listItems.length; itemIndex++) {
                 var prefix = node.type === "orderedList" ? (start + itemIndex) + ". " : "- ";
                 listParts.push(serializeMarkdownListItem(listItems[itemIndex].content || [], prefix));
@@ -5060,15 +5066,28 @@ function installStructuredContentBridge() {
 }
 
 function ensureStylesheet(href) {
-    if (document.querySelector('link[data-rte-style="' + href + '"]')) {
-        return;
-    }
-
-    var link = document.createElement("link");
-    link.rel = "stylesheet";
-    link.href = href;
-    link.setAttribute("data-rte-style", href);
-    document.head.appendChild(link);
+    return new Promise(function (resolve, reject) {
+        var existing = document.querySelector('link[data-rte-style="' + href + '"]');
+        if (existing && (existing.getAttribute("data-rte-loaded") === "true" || existing.sheet)) {
+            resolve();
+            return;
+        }
+        var link = existing || document.createElement("link");
+        link.addEventListener("load", function () {
+            link.setAttribute("data-rte-loaded", "true");
+            resolve();
+        }, { once: true });
+        link.addEventListener("error", function () {
+            if (link.parentNode) link.parentNode.removeChild(link);
+            reject(new Error("Failed to load " + href));
+        }, { once: true });
+        if (!existing) {
+            link.rel = "stylesheet";
+            link.href = href;
+            link.setAttribute("data-rte-style", href);
+            document.head.appendChild(link);
+        }
+    });
 }
 
 function loadScript(src) {
@@ -5098,6 +5117,9 @@ function loadScript(src) {
             resolve(script);
         };
         script.onerror = function () {
+            // A failed tag will never fire load again. Let an explicit retry
+            // create a fresh request, without removing successfully loaded core.
+            if (script.parentNode) script.parentNode.removeChild(script);
             reject(new Error("Failed to load " + src));
         };
 
@@ -5114,18 +5136,32 @@ function loadRichTextEditorAssets(options) {
 
     var basePath = trimTrailingSlash(options && options.basePath ? options.basePath : "/richtexteditor");
 
-    if (window.RichTextEditor) {
+    // Core becomes global before plugins finish. All concurrent mounts must
+    // await the same complete attempt rather than treating core as readiness.
+    if (pendingLoadsByBasePath[basePath]) {
+        return pendingLoadsByBasePath[basePath];
+    }
+
+    if (window.RichTextEditor && !failedLoadsByBasePath[basePath]) {
         return Promise.resolve(installStructuredContentBridge());
     }
 
     if (!pendingLoadsByBasePath[basePath]) {
-        ensureStylesheet(basePath + "/rte_theme_default.css");
-        pendingLoadsByBasePath[basePath] = loadScript(basePath + "/rte.js")
+        var themeReady = ensureStylesheet(basePath + "/rte_theme_default.css");
+        var scriptsReady = loadScript(basePath + "/rte.js")
             .then(function () {
+                if (window.RTE_DefaultConfig) window.RTE_DefaultConfig.url_base = basePath;
                 return loadScript(basePath + "/plugins/all_plugins.js");
-            })
+            });
+        pendingLoadsByBasePath[basePath] = Promise.all([themeReady, scriptsReady])
             .then(function () {
+                delete failedLoadsByBasePath[basePath];
                 return installStructuredContentBridge();
+            })
+            .catch(function (error) {
+                delete pendingLoadsByBasePath[basePath];
+                failedLoadsByBasePath[basePath] = true;
+                throw error;
             });
     }
 

package/package.json

@@ -3,13 +3,15 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "A full-featured JavaScript rich text editor (WYSIWYG) with toolbar, plugins, i18n support, a built-in AI Toolkit (Ask AI, AI Chat, AI Review drawer, BYOK resolver), structured content APIs (JSON/Markdown), and an optional collaboration / review stack: slash commands, @mentions, human-author Track Changes, threaded comments, revision history, and Yjs-backed presence. Ships first-class React, Vue, Angular and Svelte bindings, a headless \"bring your own UI\" core, and server-safe conversion helpers.",
   "main": "./richtexteditor/rte.js",
   "bin": {
     "rte-migration-report": "./migration/cli.js"
   },
   "scripts": {
+    "build:angular": "node scripts/build-angular.mjs",
+    "prepack": "node scripts/build-angular.mjs",
     "test:server": "node tests/run-all.test.js",
     "test:admin": "node tests/run-all.test.js",
     "test": "node tests/run-all.test.js",
@@ -28,10 +30,12 @@
     },
     "./angular": {
       "types": "./angular/index.d.ts",
-      "default": "./angular/index.ts"
+      "default": "./angular/index.mjs"
     },
     "./react": {
       "types": "./react/index.d.ts",
+      "import": "./react/index.mjs",
+      "require": "./react/index.js",
       "default": "./react/index.js"
     },
     "./vue": {
@@ -66,7 +70,11 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "angular",
+    "angular/*.mjs",
+    "angular/*.d.ts",
+    "angular/package.json",
+    "angular/build-manifest.json",
+    "scripts/build-angular.mjs",
     "admin",
     "headless",
     "index.d.ts",
@@ -78,12 +86,26 @@
     "svelte",
     "vue"
   ],
+  "devDependencies": {
+    "@angular/common": "20.3.31",
+    "@angular/compiler": "20.3.31",
+    "@angular/compiler-cli": "20.3.31",
+    "@angular/core": "20.3.31",
+    "@angular/forms": "20.3.31",
+    "esbuild": "0.28.1",
+    "rxjs": "~7.8.2",
+    "typescript": "~5.9.3"
+  },
   "peerDependencies": {
+    "@angular/core": ">=20.3.0",
+    "@angular/forms": ">=20.3.0",
     "react": ">=18",
     "svelte": ">=3",
     "vue": ">=3"
   },
   "peerDependenciesMeta": {
+    "@angular/core": { "optional": true },
+    "@angular/forms": { "optional": true },
     "react": {
       "optional": true
     },

package/react/index.js

@@ -1,6 +1,9 @@
+"use client";
+
 var React = require("react");
 var shared = require("../integrations/shared");
 var headless = require("../headless");
+var initializationScope = require("../integrations/initialization-scope");
 
 function pluginAccessor(editorRef, name) {
     return function () {
@@ -113,6 +116,9 @@ var RichTextEditorReact = React.forwardRef(function RichTextEditorReact(props, f
     var editorRef = React.useRef(null);
     var onChangeRef = React.useRef(props.onChange);
     var lastEmittedRef = React.useRef(undefined);
+    var initialValueRef = React.useRef(props.value !== undefined ? props.value : props.defaultValue);
+    var lastKnownHtmlRef = React.useRef(null);
+    var writingValueRef = React.useRef(false);
     // 0 disables coalescing and restores the pre-2.6 behaviour of emitting
     // synchronously on every change.
     var changeDelayRef = React.useRef(props.changeDelay == null ? 120 : props.changeDelay);
@@ -127,6 +133,7 @@ var RichTextEditorReact = React.forwardRef(function RichTextEditorReact(props, f
         onErrorRef.current = props.onError;
         formatRef.current = props.valueFormat || "html";
         configRef.current = props.config || {};
+        initialValueRef.current = props.value !== undefined ? props.value : props.defaultValue;
     });
 
     React.useImperativeHandle(forwardedRef, function () {
@@ -136,8 +143,41 @@ var RichTextEditorReact = React.forwardRef(function RichTextEditorReact(props, f
     React.useEffect(function () {
         var disposed = false;
         var changeHandler = null;
+        var blurHandler = null;
         var emitChange = null;
         var activeHost = hostRef.current;
+        var ownedEditor = null;
+
+        function emitCurrentValue() {
+            var editor = ownedEditor;
+            if (!editor || writingValueRef.current) return;
+            var value = shared.getEditorValue(editor, formatRef.current);
+            var html = typeof value === "string" ? value : (typeof value.html === "string" ? value.html : editor.getHTMLCode());
+            if (html === lastKnownHtmlRef.current) return;
+            lastKnownHtmlRef.current = html;
+            lastEmittedRef.current = value;
+            if (onChangeRef.current) onChangeRef.current(value, editor);
+        }
+
+        function releaseEditor() {
+            if (emitChange) emitChange.cancel();
+            emitChange = null;
+            var editor = ownedEditor;
+            ownedEditor = null;
+            if (editorRef.current === editor) editorRef.current = null;
+            if (editor && changeHandler && typeof editor.detachEvent === "function") {
+                try { editor.detachEvent("change", changeHandler); } catch (e) { /* Continue cleanup. */ }
+            }
+            changeHandler = null;
+            if (editor && blurHandler && typeof editor.detachEvent === "function") {
+                try { editor.detachEvent("blur", blurHandler); } catch (e) { /* Continue cleanup. */ }
+            }
+            blurHandler = null;
+            if (editor && typeof editor.destroy === "function") {
+                try { editor.destroy(); } catch (e) { /* Continue cleanup. */ }
+            }
+            if (activeHost && !editorRef.current) activeHost.innerHTML = "";
+        }
 
         var readyPromise = props.autoload === false
             ? Promise.resolve().then(function () {
@@ -151,59 +191,60 @@ var RichTextEditorReact = React.forwardRef(function RichTextEditorReact(props, f
                     return;
                 }
 
-                var editor = shared.createEditor(activeHost, configRef.current);
+                // Plugins may wrap/move their container. Never give them the
+                // React-owned root: React removes that exact child on unmount.
+                var editorMount = activeHost.ownerDocument.createElement("div");
+                activeHost.appendChild(editorMount);
+                var editor = shared.createEditor(editorMount, configRef.current);
+                if (disposed) {
+                    try { editor.destroy(); } catch (e) { /* Continue cleanup. */ }
+                    return;
+                }
+                ownedEditor = editor;
                 editorRef.current = editor;
 
-                var initialValue = props.value !== undefined ? props.value : props.defaultValue;
+                var initialValue = initialValueRef.current;
                 if (initialValue !== undefined) {
                     shared.setEditorValue(editor, initialValue, formatRef.current);
                 }
+                if (disposed) return;
+                lastKnownHtmlRef.current = editor.getHTMLCode();
+                lastEmittedRef.current = undefined;
 
                 // Serialise at most once per quiet period rather than once per
                 // keystroke. lastEmittedRef lets the value-sync effect below skip a
                 // SECOND full serialisation when the parent hands back exactly what
                 // we just emitted, which is the common controlled-component case.
-                emitChange = shared.createChangeCoalescer(function () {
-                    var value = shared.getEditorValue(editor, formatRef.current);
-                    lastEmittedRef.current = value;
-                    if (onChangeRef.current) {
-                        onChangeRef.current(value, editor);
-                    }
-                }, changeDelayRef.current);
+                emitChange = shared.createChangeCoalescer(emitCurrentValue, changeDelayRef.current);
 
-                changeHandler = function () { emitChange(); };
+                changeHandler = function () { if (!disposed && !writingValueRef.current && emitChange) emitChange(); };
 
                 editor.attachEvent("change", changeHandler);
+                blurHandler = function () {
+                    if (disposed || writingValueRef.current) return;
+                    if (emitChange) emitChange.flush();
+                    emitCurrentValue();
+                };
+                editor.attachEvent("blur", blurHandler);
 
                 if (onReadyRef.current) {
                     onReadyRef.current(editor);
                 }
             })
             .catch(function (error) {
-                if (!disposed && onErrorRef.current) {
-                    onErrorRef.current(error);
+                if (!disposed) {
+                    releaseEditor();
+                    if (onErrorRef.current) onErrorRef.current(error);
                 }
             });
 
         return function () {
+            if (disposed) return;
             disposed = true;
-            // Flush before teardown or the last keystroke never reaches onChange.
-            if (emitChange) { emitChange.flush(); }
-            var ed = editorRef.current;
-            if (ed) {
-                if (changeHandler && typeof ed.detachEvent === "function") {
-                    ed.detachEvent("change", changeHandler);
-                }
-                // Tear down the editor's instance-level global listeners so an
-                // unmount (or React 18 StrictMode's mount→unmount→mount) doesn't leak.
-                if (typeof ed.destroy === "function") {
-                    try { ed.destroy(); } catch (e) { /* ignore */ }
-                }
-            }
-            if (activeHost) {
-                activeHost.innerHTML = "";
-            }
-            editorRef.current = null;
+            try {
+                if (emitChange) emitChange.flush();
+                if (changeHandler) emitCurrentValue();
+            } finally { releaseEditor(); }
         };
     }, []);
 
@@ -221,13 +262,18 @@ var RichTextEditorReact = React.forwardRef(function RichTextEditorReact(props, f
             return;
         }
         if (editorRef.current.getHTMLCode() !== nextHtml) {
-            shared.setEditorValue(editorRef.current, props.value, props.valueFormat || "html");
+            writingValueRef.current = true;
+            try { shared.setEditorValue(editorRef.current, props.value, props.valueFormat || "html"); }
+            finally { writingValueRef.current = false; }
         }
+        if (editorRef.current) lastKnownHtmlRef.current = editorRef.current.getHTMLCode();
+        lastEmittedRef.current = undefined;
     }, [props.value, props.valueFormat]);
 
     var divProps = Object.assign({}, props);
     delete divProps.assetBasePath;
     delete divProps.autoload;
+    delete divProps.changeDelay;
     delete divProps.config;
     delete divProps.defaultValue;
     delete divProps.onChange;
@@ -249,8 +295,9 @@ RichTextEditorReact.defaultProps = {
 
 // ---- Headless hook: bring-your-own-UI, Tiptap-style ----
 // const editor = useRichTextEditor({ value: "<p>Hi</p>" });
-// <button onMouseDown={e => { e.preventDefault(); editor.run("bold"); }}
-//         className={editor.state.bold ? "is-active" : ""}>B</button>
+// <button type="button" onPointerDown={e => e.preventDefault()}
+//         onClick={() => editor.run("bold")} disabled={!editor.editor}
+//         aria-pressed={!!editor.state.bold}>Bold</button>
 // <EditorContent editor={editor} />
 function useRichTextEditor(options) {
     var optionsRef = React.useRef(options || {});
@@ -259,32 +306,66 @@ function useRichTextEditor(options) {
     var stateRef = React.useRef({});
     var rerender = React.useReducer(function (c) { return (c + 1) | 0; }, 0)[1];
 
+    React.useEffect(function () { optionsRef.current = options || {}; });
+
     React.useEffect(function () {
         var disposed = false;
         var ctl = null;
-        headless.createHeadlessEditor(hostRef.current, optionsRef.current)
+        var pendingScope = null;
+        var activeHost = hostRef.current;
+        function releaseController() {
+            var owned = ctl;
+            ctl = null;
+            if (controllerRef.current === owned) controllerRef.current = null;
+            if (owned) { try { owned.destroy(); } catch (e) { /* Continue cleanup. */ } }
+            if (activeHost && !controllerRef.current) activeHost.innerHTML = "";
+        }
+        Promise.resolve().then(function () {
+            if (disposed) return null;
+            if (!activeHost) throw new Error("useRichTextEditor: render EditorContent before initialization.");
+            pendingScope = initializationScope.createInitializationScope(optionsRef.current.signal);
+            var editorMount = activeHost.ownerDocument.createElement("div");
+            activeHost.appendChild(editorMount);
+            return headless.createHeadlessEditor(editorMount, Object.assign({}, optionsRef.current, { signal: pendingScope.signal }));
+        })
             .then(function (controller) {
+                if (pendingScope) pendingScope.complete();
+                if (!controller) return;
                 if (disposed) { controller.destroy(); return; }
                 ctl = controller;
                 controllerRef.current = controller;
+                var value = optionsRef.current.value;
+                if (value != null && value !== controller.getHTML()) controller.setHTML(value);
                 controller.on("update", function (snapshot) {
+                    if (disposed) return;
                     stateRef.current = snapshot;
                     rerender();
                 });
                 stateRef.current = controller.state();
                 if (optionsRef.current.onReady) { optionsRef.current.onReady(controller); }
-                rerender();
+                if (!disposed) rerender();
             })
             .catch(function (error) {
-                if (optionsRef.current.onError) { optionsRef.current.onError(error); }
+                if (pendingScope) pendingScope.complete();
+                if (!disposed) {
+                    releaseController();
+                    if (optionsRef.current.onError) optionsRef.current.onError(error);
+                }
             });
         return function () {
+            if (disposed) return;
             disposed = true;
-            if (ctl) { ctl.destroy(); }
-            controllerRef.current = null;
+            if (pendingScope) pendingScope.dispose();
+            releaseController();
         };
     }, []);
 
+    React.useEffect(function () {
+        var controller = controllerRef.current;
+        var value = options && options.value;
+        if (controller && value != null && value !== controller.getHTML()) controller.setHTML(value);
+    }, [options && options.value]);
+
     return {
         ref: hostRef,
         get editor() { return controllerRef.current; },   // controller (null until ready)

package/react/index.mjs

@@ -0,0 +1,29 @@
+"use client";
+
+// A real ESM client boundary for React Server Component bundlers. Keep the CJS
+// implementation available to require() consumers and conventional React SSR.
+import bindings from "./index.js";
+
+export const RichTextEditor = bindings.RichTextEditor;
+export const RichTextEditorReact = bindings.RichTextEditorReact;
+export const useRichTextEditor = bindings.useRichTextEditor;
+export const EditorContent = bindings.EditorContent;
+export const auditAccessibility = bindings.auditAccessibility;
+export const auditLinks = bindings.auditLinks;
+export const createStructuredDocument = bindings.createStructuredDocument;
+export const createHeadlessEditor = bindings.createHeadlessEditor;
+export const createStructuredContent = bindings.createStructuredContent;
+export const fromMarkdown = bindings.fromMarkdown;
+export const getDocumentPageSetup = bindings.getDocumentPageSetup;
+export const getDocumentMetrics = bindings.getDocumentMetrics;
+export const getDocumentOutline = bindings.getDocumentOutline;
+export const getFootnotes = bindings.getFootnotes;
+export const getTableOfContents = bindings.getTableOfContents;
+export const getTextStatistics = bindings.getTextStatistics;
+export const loadRichTextEditorAssets = bindings.loadRichTextEditorAssets;
+export const renderHTML = bindings.renderHTML;
+export const setDocumentPageSetup = bindings.setDocumentPageSetup;
+export const syncTableOfContents = bindings.syncTableOfContents;
+export const toMarkdown = bindings.toMarkdown;
+export const validateStructuredContent = bindings.validateStructuredContent;
+export default bindings;