@arbidocs/blocks 0.4.93 → 0.4.94

package/dist/{chunk-W2R7YVFM.js → chunk-WXLKMEMB.js}

@@ -1,17 +1,18 @@
 "use client";
-import { filterMentionCandidates, MentionMenu, findMentionQuery, extractMentions } from './chunk-AA3PT6KR.js';
+import { stylesXml, definitionBookmark, DEFINITION_BOOKMARK_PREFIX, compareTerms, groupDefinitions, definitionLabels, filterTermGroups, toDefinition, definitionIdOfBookmark, esc, parseDefinition, docxPackage, documentXml } from './chunk-D3QPYKZG.js';
+import { filterMentionCandidates, MentionMenu, findMentionQuery, listOptionId, extractMentions } from './chunk-AA3PT6KR.js';
 import { unzipSync, strFromU8, strToU8, zipSync } from 'fflate';
 import { collectReviewItems, revisionItemsOf } from '@docx-editor.dev/core/store';
 import React3, { createContext, useContext, useState, useRef, useCallback, useEffect, useLayoutEffect, useMemo } from 'react';
 import { useDocxEditor, ReviewRailContext, useEditorSnapshot, useChromeTranslate, DocxEditor, createFontSource } from '@docx-editor.dev/react';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { createPortal } from 'react-dom';
-import { Dialog, DialogContent, DialogHeader, DialogTitle, splitMarkdownBlocks, AiMarkdown } from '@arbidocs/react/ui';
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, Button, DialogFooter, cn, splitMarkdownBlocks, AiMarkdown } from '@arbidocs/react/ui';
 import { renderToStaticMarkup } from 'react-dom/server';
 import * as Y from 'yjs';
 import { DOCUMENT_COLLABORATION_VERSIONS, collaborationModule } from '@arbidocs/coedit';
 import { createHocuspocusCollaboration } from '@arbidocs/coedit/hocuspocus';
-import { Type, Ellipsis, RefreshCw, WifiOff, Check, Download, Save } from 'lucide-react';
+import { Type, Ellipsis, RefreshCw, WifiOff, Check, Download, Save, BookA, ListRestart } from 'lucide-react';
 
 function normalizeDocxExport(data) {
   const files = unzipSync(new Uint8Array(data));
@@ -508,18 +509,18 @@ function ReviewCardSlot({ children }) {
 var DocxEditorReview = Object.assign(DocxEditorReviewRail, { Card: ReviewCardSlot });
 
 // src/docx/mentions.ts
-function mentionCandidates(mentions) {
+function mentionCandidates(mentions2) {
   return [
     { id: "arbi", label: "ARBI", kind: "assistant" },
-    ...mentions.filter((person) => person.name.trim()).map((person) => ({
+    ...mentions2.filter((person) => person.name.trim()).map((person) => ({
       id: person.id,
       label: person.name,
       kind: person.kind === "agent" ? "assistant" : "user"
     }))
   ];
 }
-function mentionedDocxRecipients(text, mentions) {
-  return extractMentions(text, mentionCandidates(mentions)).map((person) => person.id);
+function mentionedDocxRecipients(text, mentions2) {
+  return extractMentions(text, mentionCandidates(mentions2)).map((person) => person.id);
 }
 var ActivityContext = createContext({});
 function DocxCommentActivity() {
@@ -602,7 +603,7 @@ function DocxCommentActivity() {
 }
 function DocxMentions({
   children,
-  mentions = [],
+  mentions: mentions2 = [],
   initialCommentId,
   requestAgent,
   getAgentStatus,
@@ -661,7 +662,7 @@ function DocxMentions({
   const [suggestions, setSuggestions] = useState(null);
   const [selected, setSelected] = useState(0);
   const candidates = filterMentionCandidates(
-    mentionCandidates(mentions),
+    mentionCandidates(mentions2),
     suggestions?.query || ""
   ).slice(0, 8);
   useEffect(() => {
@@ -682,7 +683,7 @@ function DocxMentions({
         }));
     };
     const hasAgent = submission.recipientIds.some(
-      (id) => id === "arbi" || mentions.some((person) => person.id === id && person.kind === "agent")
+      (id) => id === "arbi" || mentions2.some((person) => person.id === id && person.kind === "agent")
     );
     if (hasAgent) update("delivering");
     void requestAgent({
@@ -716,7 +717,7 @@ function DocxMentions({
         "error"
       );
     });
-  }, [review.items, requestAgent, getAgentStatus, mentions, notify]);
+  }, [review.items, requestAgent, getAgentStatus, mentions2, notify]);
   const choose = (name) => {
     const field = input.current;
     if (!field || !suggestions) return;
@@ -734,7 +735,7 @@ function DocxMentions({
       '[data-testid="review-draft-input"], [data-testid="review-reply-input"]'
     );
     if (!field || field.readOnly || !requestAgent) return false;
-    const recipientIds = mentionedDocxRecipients(field.value, mentions);
+    const recipientIds = mentionedDocxRecipients(field.value, mentions2);
     if (!recipientIds.length) return false;
     pending.current = {
       ids: new Set(review.items.filter((i) => i.kind === "comment").map((i) => i.item.id)),
@@ -781,7 +782,7 @@ function DocxMentions({
           (entry) => entry.kind === "comment" && entry.parentId === commentId
         );
         const author = replies.at(-1)?.author || target.author;
-        const agent = mentions.find((person) => person.kind === "agent" && person.name === author);
+        const agent = mentions2.find((person) => person.kind === "agent" && person.name === author);
         if (agent || author === "ARBI" || author === "Assistant")
           prefixMention(
             field,
@@ -859,7 +860,7 @@ function DocxMentions({
                 onMouseDown: (event) => event.preventDefault(),
                 onClick: (event) => {
                   event.stopPropagation();
-                  if (!mentionedDocxRecipients(field.value, mentions).includes("arbi"))
+                  if (!mentionedDocxRecipients(field.value, mentions2).includes("arbi"))
                     prefixMention(field);
                   else field.focus();
                 },
@@ -904,6 +905,869 @@ function DocxMentions({
     }
   ) });
 }
+
+// src/docx/definitions/fragment.ts
+var DEFINED_TERM_STYLE = "DefinedTerm";
+var FRAGMENT_STYLES = stylesXml(
+  "",
+  `<w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/><w:qFormat/></w:style><w:style w:type="character" w:customStyle="1" w:styleId="${DEFINED_TERM_STYLE}"><w:name w:val="Defined Term"/><w:rPr><w:u w:val="dotted" w:color="7F7F7F"/></w:rPr></w:style>`
+);
+var textRun = (text, props = "") => `<w:r>${props ? `<w:rPr>${props}</w:rPr>` : ""}<w:t xml:space="preserve">${esc(text)}</w:t></w:r>`;
+function definitionTooltip(definition) {
+  const line = `\u201C${definition.term}\u201D${definition.rest}`.replace(/\s+/g, " ").trim();
+  return line.length > 255 ? `${line.slice(0, 254)}\u2026` : line;
+}
+var definitionParagraphText = (definition) => `\u201C${definition.term}\u201D${definition.rest}`;
+function definitionParagraphXml(definition, bookmark, id = 0) {
+  return `<w:p><w:bookmarkStart w:id="${id}" w:name="${esc(bookmark)}"/>${textRun("\u201C")}${textRun(
+    definition.term,
+    "<w:b/>"
+  )}${textRun("\u201D")}<w:bookmarkEnd w:id="${id}"/>${textRun(definition.rest)}</w:p>`;
+}
+function headingParagraphXml(text, styleId) {
+  return styleId ? `<w:p><w:pPr><w:pStyle w:val="${esc(styleId)}"/></w:pPr>${textRun(text)}</w:p>` : `<w:p><w:pPr><w:keepNext/></w:pPr>${textRun(text, "<w:b/>")}</w:p>`;
+}
+function termLinkXml(term, bookmark, tooltip) {
+  return `<w:p><w:hyperlink w:anchor="${esc(bookmark)}" w:tooltip="${esc(tooltip)}" w:history="1">${textRun(
+    term,
+    `<w:rStyle w:val="${DEFINED_TERM_STYLE}"/>`
+  )}</w:hyperlink></w:p>`;
+}
+function base64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768)
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(binary);
+}
+function fragmentHtml(body, covered2) {
+  const bytes = docxPackage({
+    document: documentXml(body),
+    styles: FRAGMENT_STYLES,
+    title: "Defined terms"
+  });
+  return `<div data-docx-fragment="${base64(bytes)}" data-docx-fragment-end="${covered2 ? "covered" : "open"}"></div>`;
+}
+
+// src/docx/definitions/commands.ts
+var DEFINITIONS_HEADING = "Definitions";
+var SECTION_TITLE = /^(definitions?(\s*(and|&)\s*interpretations?)?|interpretations?(\s*(and|&)\s*definitions?)?|defined\s+terms|glossary)$/i;
+var NUMBERING = /^(?:(?:clause|section|article|schedule|part)\s+)?(?:[0-9]+(?:\.[0-9]+)*|[A-Z]|[ivxlc]+)[.):]?\s+(?:[-–—]\s*)?/i;
+function isDefinitionsTitle(paragraph) {
+  if (!paragraph.topLevel) return false;
+  const title = paragraph.text.trim().replace(NUMBERING, "").replace(/[.:]+$/, "").trim();
+  return SECTION_TITLE.test(title) && (paragraph.heading || title.length <= 40);
+}
+function findDefinitionsSection(paragraphs) {
+  const title = paragraphs.findIndex(isDefinitionsTitle);
+  if (title < 0) return null;
+  let end = title + 1;
+  while (end < paragraphs.length && paragraphs[end].topLevel && !paragraphs[end].heading) end++;
+  return { title, start: title + 1, end };
+}
+var termOf = (paragraph) => parseDefinition(paragraph.text)?.term ?? null;
+function insertionIndex(paragraphs, section, term, skip = /* @__PURE__ */ new Set()) {
+  let afterLast = section.start;
+  for (let i = section.start; i < section.end; i++) {
+    if (skip.has(paragraphs[i].id)) continue;
+    const other = termOf(paragraphs[i]);
+    if (other === null) continue;
+    if (compareTerms(other, term) > 0) return i;
+    afterLast = i + 1;
+  }
+  return afterLast;
+}
+var headingStyle = (paragraphs) => paragraphs.find((p) => p.topLevel && p.heading && p.styleId)?.styleId;
+function insertParagraphs(port, index, body, count, keep) {
+  const before = port.paragraphs();
+  const kept = keep ? before.findIndex((p) => p.id === keep.paragraphId) : -1;
+  if (index < before.length) {
+    port.setCaret({ paragraphId: before[index].id, offset: 0 });
+  } else {
+    const last = before[before.length - 1];
+    port.setCaret({ paragraphId: last.id, offset: last.text.length });
+    port.splitParagraph();
+    const opened = port.paragraphs();
+    port.setCaret({ paragraphId: opened[opened.length - 1].id, offset: 0 });
+  }
+  if (!port.paste(body, "", true)) throw new Error("The definition could not be added.");
+  if (!keep || kept < 0) return keep;
+  const after = port.paragraphs();
+  const moved = index <= kept ? kept + count : kept;
+  return { paragraphId: after[moved]?.id ?? keep.paragraphId, offset: keep.offset };
+}
+function addDefinition(port, definition, keep) {
+  const paragraphs = port.paragraphs();
+  const section = findDefinitionsSection(paragraphs);
+  const paragraph = definitionParagraphXml(definition, definitionBookmark(definition.id));
+  if (section)
+    return insertParagraphs(
+      port,
+      insertionIndex(paragraphs, section, definition.term),
+      paragraph,
+      1,
+      keep
+    );
+  return insertParagraphs(
+    port,
+    paragraphs.length,
+    headingParagraphXml(DEFINITIONS_HEADING, headingStyle(paragraphs)) + paragraph,
+    2,
+    keep
+  );
+}
+var hasBookmark = (paragraphs, name) => paragraphs.some((p) => p.bookmarks.includes(name));
+function insertDefinedTerm(port, definition, options = {}) {
+  const start = port.caret();
+  if (!start) throw new Error("Place the cursor where the term should go.");
+  let caret = start;
+  if (options.replace) {
+    caret = { paragraphId: start.paragraphId, offset: Math.max(0, start.offset - options.replace) };
+    port.deleteRange(caret, start);
+  }
+  const bookmark = definitionBookmark(definition.id);
+  const addedDefinition = !hasBookmark(port.paragraphs(), bookmark);
+  if (addedDefinition) caret = addDefinition(port, definition, caret) ?? caret;
+  port.setCaret(caret);
+  if (!port.paste(
+    termLinkXml(definition.term, bookmark, definitionTooltip(definition)),
+    definition.term,
+    false
+  ))
+    throw new Error("The term could not be inserted.");
+  port.setCaret({ paragraphId: caret.paragraphId, offset: caret.offset + definition.term.length });
+  return { addedDefinition };
+}
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var mentions = (text, term) => new RegExp(`(^|[^\\p{L}\\p{N}])${escapeRegExp(term)}($|[^\\p{L}\\p{N}])`, "iu").test(text);
+function updateDefinitions(port, definitions) {
+  const result = {
+    added: [],
+    refreshed: [],
+    reordered: [],
+    unused: [],
+    unknown: []
+  };
+  let paragraphs = port.paragraphs();
+  const linked = new Set(
+    paragraphs.flatMap(
+      (p) => p.links.map((l) => l.anchor).filter((a) => a.startsWith(DEFINITION_BOOKMARK_PREFIX))
+    )
+  );
+  const declared = /* @__PURE__ */ new Map();
+  for (const p of paragraphs)
+    for (const b of p.bookmarks)
+      if (b.startsWith(DEFINITION_BOOKMARK_PREFIX) && !declared.has(b)) declared.set(b, p);
+  const factOf = (bookmark) => {
+    const id = definitionIdOfBookmark(bookmark);
+    return id ? definitions.get(id) : void 0;
+  };
+  for (const bookmark of [...linked, ...declared.keys()])
+    if (!factOf(bookmark) && !result.unknown.includes(bookmark)) result.unknown.push(bookmark);
+  const section = findDefinitionsSection(paragraphs);
+  const rewrite = /* @__PURE__ */ new Map();
+  for (const [bookmark, paragraph] of declared) {
+    const fact = factOf(bookmark);
+    if (fact && paragraph.text !== definitionParagraphText(fact)) {
+      rewrite.set(paragraph.id, fact);
+      result.refreshed.push(fact.term);
+    }
+  }
+  if (section) {
+    let previous = null;
+    for (let i = section.start; i < section.end; i++) {
+      const p = paragraphs[i];
+      const term = termOf(p);
+      if (term === null) continue;
+      const bookmark = p.bookmarks.find((b) => b.startsWith(DEFINITION_BOOKMARK_PREFIX));
+      const fact = bookmark ? factOf(bookmark) : void 0;
+      if (previous !== null && compareTerms(term, previous) < 0 && fact) {
+        if (!rewrite.has(p.id)) result.reordered.push(fact.term);
+        rewrite.set(p.id, fact);
+        continue;
+      }
+      previous = term;
+    }
+  }
+  for (const id of [...rewrite.keys()].reverse()) {
+    const index = paragraphs.findIndex((p) => p.id === id);
+    const previous = paragraphs[index - 1];
+    const target = paragraphs[index];
+    if (!previous) continue;
+    port.deleteRange(
+      { paragraphId: previous.id, offset: previous.text.length },
+      { paragraphId: target.id, offset: target.text.length }
+    );
+    paragraphs = port.paragraphs();
+  }
+  const toAdd = [...rewrite.values()];
+  for (const bookmark of linked) {
+    const fact = factOf(bookmark);
+    if (fact && !declared.has(bookmark) && !toAdd.some((d) => d.id === fact.id)) {
+      toAdd.push(fact);
+      result.added.push(fact.term);
+    }
+  }
+  toAdd.sort((a, b) => compareTerms(a.term, b.term));
+  for (const definition of toAdd) addDefinition(port, definition);
+  paragraphs = port.paragraphs();
+  const after = findDefinitionsSection(paragraphs);
+  if (after) {
+    const inSection = (i) => i >= after.title && i < after.end;
+    const outside = paragraphs.filter((_, i) => !inSection(i));
+    const linkedNow = new Set(outside.flatMap((p) => p.links.map((l) => l.anchor)));
+    const outsideText = outside.map((p) => p.text).join("\n");
+    for (let i = after.start; i < after.end; i++) {
+      const p = paragraphs[i];
+      const term = termOf(p);
+      if (term === null) continue;
+      const used = p.bookmarks.some((b) => linkedNow.has(b)) || mentions(outsideText, term);
+      if (!used) result.unused.push({ term, paragraphId: p.id });
+    }
+  }
+  return result;
+}
+function definitionOfAnchor(anchor, definitions) {
+  const id = definitionIdOfBookmark(anchor.replace(/^#/, ""));
+  return id ? definitions.get(id) : void 0;
+}
+
+// src/docx/definitions/port.ts
+var attr = (node, name) => node.attributes?.find((a) => a.localName === name)?.value;
+var HEADING_STYLE = /^(heading|berschrift|titre|t[ií]tulo|titolo|kop)\s*\d/i;
+function readParagraphs(root) {
+  const out = [];
+  const body = root.children?.find((n) => n.kind === "body") ?? root;
+  const visit = (node, topLevel, pending) => {
+    for (const child of node.children ?? []) {
+      if (child.kind === "paragraph") {
+        out.push(readParagraph(child, topLevel, pending.splice(0)));
+      } else if (child.localName === "bookmarkStart") {
+        const name = attr(child, "name");
+        if (name) pending.push(name);
+      } else if (child.localName === "tbl" || child.localName === "tr" || child.localName === "tc") {
+        visit(child, false, pending);
+      } else if (child.localName === "sdt" || child.localName === "sdtContent") {
+        visit(child, topLevel, pending);
+      }
+    }
+  };
+  visit(body, true, []);
+  return out;
+}
+function readParagraph(node, topLevel, bookmarks) {
+  let text = "";
+  const links = [];
+  let styleId;
+  let outline = false;
+  const walk = (n, link) => {
+    for (const c of n.children ?? []) {
+      if (c.kind === "paragraphProperties" || c.localName === "pPr") {
+        for (const p of c.children ?? []) {
+          if (p.localName === "pStyle") styleId = attr(p, "val");
+          if (p.localName === "outlineLvl" && Number(attr(p, "val")) < 9) outline = true;
+        }
+        continue;
+      }
+      if (c.localName === "delText" || c.localName === "del" || c.localName === "rPr") continue;
+      if (c.localName === "bookmarkStart") {
+        const name = attr(c, "name");
+        if (name) bookmarks.push(name);
+        continue;
+      }
+      if (c.localName === "hyperlink") {
+        const anchor = attr(c, "anchor");
+        const next = anchor ? { anchor, text: "" } : void 0;
+        walk(c, next ?? link);
+        if (next) links.push(next);
+        continue;
+      }
+      if (c.kind === "textValue") {
+        text += c.value ?? "";
+        if (link) link.text += c.value ?? "";
+        continue;
+      }
+      if (c.localName === "tab") text += "	";
+      walk(c, link);
+    }
+  };
+  walk(node);
+  return {
+    id: node.id,
+    text,
+    heading: outline || !!styleId && HEADING_STYLE.test(styleId),
+    styleId,
+    topLevel,
+    bookmarks,
+    links
+  };
+}
+function editorPort(editor) {
+  const surface = () => {
+    const s = editor.surface;
+    if (!s) throw new Error("The document is not open.");
+    return s;
+  };
+  return {
+    paragraphs: () => readParagraphs(surface().session.part().root),
+    caret: () => {
+      const selection = surface().state().selection;
+      if (!selection) return null;
+      const { anchor, head } = selection;
+      return anchor.paragraphId === head.paragraphId && anchor.offset === head.offset ? { paragraphId: anchor.paragraphId, offset: anchor.offset } : null;
+    },
+    setCaret: (point) => surface().setSelection({ anchor: point, head: point }),
+    deleteRange: (from, to) => {
+      surface().setSelection({ anchor: from, head: to });
+      surface().deleteSelection();
+    },
+    paste: (body, text, covered2) => editor.exec({ type: "paste", text, html: fragmentHtml(body, covered2) }).ok,
+    splitParagraph: () => surface().splitParagraph()
+  };
+}
+function withDirectEditing(editor, fn) {
+  const mode = editor.getEditingMode();
+  if (mode === "viewing") throw new Error("This document is read only.");
+  if (mode === "suggesting") editor.setEditingMode("editing");
+  try {
+    return fn();
+  } finally {
+    if (mode === "suggesting") editor.setEditingMode("suggesting");
+  }
+}
+function holdCaret(editor, timeoutMs = 5e3) {
+  const surface = editor.surface;
+  const selection = surface?.state().selection;
+  if (!surface || !selection) return;
+  const { paragraphId, offset } = selection.head;
+  const paraId = surface.session.paraIdOf(paragraphId);
+  if (!paraId) return;
+  let done = false;
+  const stop = () => {
+    done = true;
+    offChange();
+    offSelection();
+    clearTimeout(timer);
+  };
+  const restore = () => {
+    if (done) return;
+    const now = surface.state().selection;
+    const node = surface.session.nodeIdOf(paraId);
+    if (!now || !node) return;
+    if (now.head.offset !== offset || now.head.paragraphId !== paragraphId) return stop();
+    if (node === paragraphId) return;
+    stop();
+    const point = { paragraphId: node, offset };
+    surface.setSelection({ anchor: point, head: point });
+  };
+  const offChange = editor.on("change", restore);
+  const offSelection = editor.on("selectionChange", restore);
+  const timer = setTimeout(stop, timeoutMs);
+}
+var DEFINED_TERM_TRIGGER = "@@";
+var TRIGGER_QUERY = /(?:^|[\s([{"“‘'])@@([^@\n\t]{0,40})$/;
+var MAX_GROUPS = 8;
+var STALE_AFTER_MS = 3e4;
+var DEFAULT_DEFINED_TERMS_LABELS = {
+  insert: "Defined term",
+  update: "Update definitions",
+  search: "Search defined terms",
+  allAgreements: "All definitions",
+  loading: "Loading definitions\u2026",
+  empty: "No definitions yet. Label a fact \u201CDefinitions\u201D to use it here.",
+  noMatch: "No defined term matches.",
+  hint: "Enter to insert \xB7 Esc to close",
+  preferred: "Preferred",
+  alsoIn: (source) => `Also defined${source ? ` in ${source}` : ""}`,
+  updated: "Definitions updated",
+  updateSummary: (r) => [
+    r.added.length ? `${r.added.length} added` : "",
+    r.refreshed.length ? `${r.refreshed.length} reworded` : "",
+    r.reordered.length ? `${r.reordered.length} reordered` : ""
+  ].filter(Boolean).join(" \xB7 ") || "The Definitions section is up to date.",
+  unusedTitle: "Defined but never used",
+  unusedNone: "Every definition in the section is used.",
+  unknownTitle: "Links to definitions that no longer exist",
+  show: "Show",
+  close: "Close"
+};
+var DefinedTermsContext = createContext(null);
+var useDefinedTerms = () => useContext(DefinedTermsContext);
+function rowsOf(groups) {
+  return groups.flatMap(
+    (group) => group.definitions.map((definition, i) => ({ group, definition, variant: i > 0 }))
+  );
+}
+var sourceOf = (d) => [d.source, ...(d.labels ?? []).map((l) => l.name)].filter(Boolean).join(" \xB7 ");
+function DefinedTermsProvider({
+  children,
+  load,
+  editable,
+  notify,
+  labels
+}) {
+  const editor = useDocxEditor();
+  const l = useMemo(() => ({ ...DEFAULT_DEFINED_TERMS_LABELS, ...labels }), [labels]);
+  const [sources, setSources] = useState(null);
+  const loadedAt = useRef(0);
+  const loading = useRef(null);
+  const [labelId, setLabelId] = useState(null);
+  const [picker, setPicker] = useState(null);
+  const [selected, setSelected] = useState(0);
+  const [report, setReport] = useState(null);
+  const marker = useRef(null);
+  const dismissedAt = useRef(null);
+  const refresh = useCallback(
+    (force = false) => {
+      if (!load) return Promise.resolve([]);
+      if (!force && sources && Date.now() - loadedAt.current < STALE_AFTER_MS)
+        return Promise.resolve(sources);
+      if (!loading.current)
+        loading.current = load().then((list) => {
+          loadedAt.current = Date.now();
+          setSources(list);
+          return list;
+        }).catch((error) => {
+          notify?.(
+            error instanceof Error ? error.message : "Could not load definitions.",
+            "error"
+          );
+          setSources((previous) => previous ?? []);
+          return sources ?? [];
+        }).finally(() => {
+          loading.current = null;
+        });
+      return loading.current;
+    },
+    [load, sources, notify]
+  );
+  const all = useMemo(() => groupDefinitions(sources ?? []).groups, [sources]);
+  const byId = useMemo(
+    () => new Map(all.flatMap((g) => g.definitions).map((d) => [d.id, d])),
+    [all]
+  );
+  const agreements = useMemo(() => definitionLabels(sources ?? []), [sources]);
+  const groups = useMemo(
+    () => picker ? filterTermGroups(groupDefinitions(sources ?? [], { labelId }).groups, picker.query).slice(
+      0,
+      MAX_GROUPS
+    ) : [],
+    [sources, labelId, picker]
+  );
+  const rows = useMemo(() => rowsOf(groups), [groups]);
+  useEffect(() => setSelected(0), [picker?.query, labelId]);
+  const container = () => marker.current?.closest(".native-docx-viewer") ?? document.body;
+  const [viewer, setViewer] = useState(null);
+  useEffect(() => setViewer(container()), []);
+  const refreshRef = useRef(refresh);
+  refreshRef.current = refresh;
+  const firstHover = useCallback(() => void refreshRef.current(), []);
+  const caretRect = () => container().querySelector(".docx-editor-one-surface__caret")?.getBoundingClientRect();
+  const run = useCallback(
+    (fn) => {
+      if (!editor) return void 0;
+      try {
+        return withDirectEditing(editor, fn);
+      } catch (error) {
+        notify?.(error instanceof Error ? error.message : "Could not change the document.", "error");
+        return void 0;
+      }
+    },
+    [editor, notify]
+  );
+  const pick = useCallback(
+    (row) => {
+      if (!editor || !picker || !row) return;
+      const port = editorPort(editor);
+      const result = run(() => {
+        if (picker.mode === "search" && picker.caret) port.setCaret(picker.caret);
+        return insertDefinedTerm(port, row.definition, {
+          replace: picker.mode === "typing" ? DEFINED_TERM_TRIGGER.length + picker.query.length : 0
+        });
+      });
+      setPicker(null);
+      editor.surface?.focus();
+      if (result) holdCaret(editor);
+      if (result?.addedDefinition)
+        notify?.(`\u201C${row.definition.term}\u201D added to the Definitions section.`, "success");
+    },
+    [editor, picker, run, notify]
+  );
+  const openPicker = useCallback(
+    (anchor) => {
+      if (!editor || !editable) return;
+      const caret = editorPort(editor).caret();
+      const rect = caretRect() ?? anchor?.getBoundingClientRect();
+      void refresh();
+      setPicker({
+        mode: "search",
+        query: "",
+        left: rect?.left ?? 120,
+        top: (rect?.bottom ?? 120) + 4,
+        caret
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [editor, editable, refresh]
+  );
+  useEffect(() => {
+    if (!editor || !editable || !load) return;
+    let frame = 0;
+    const check = () => {
+      cancelAnimationFrame(frame);
+      frame = requestAnimationFrame(() => {
+        const port = editorPort(editor);
+        const caret = port.caret();
+        const paragraph = caret && port.paragraphs().find((p) => p.id === caret.paragraphId);
+        const match = paragraph && TRIGGER_QUERY.exec(paragraph.text.slice(0, caret.offset));
+        setPicker((current) => {
+          if (current?.mode === "search") return current;
+          if (!match || !caret) return null;
+          const key = `${caret.paragraphId}:${caret.offset - match[1].length}`;
+          if (dismissedAt.current === key) return null;
+          const rect = caretRect();
+          return {
+            mode: "typing",
+            query: match[1],
+            left: current?.left ?? rect?.left ?? 120,
+            top: current?.top ?? (rect?.bottom ?? 120) + 4,
+            caret
+          };
+        });
+        if (match) void refresh();
+      });
+    };
+    const offChange = editor.on("change", check);
+    const offSelection = editor.on("selectionChange", check);
+    return () => {
+      cancelAnimationFrame(frame);
+      offChange();
+      offSelection();
+    };
+  }, [editor, editable, load, refresh]);
+  useEffect(() => {
+    if (picker?.mode !== "typing") return;
+    const keys = (event) => {
+      if (event.key === "Escape") {
+        dismissedAt.current = picker.caret ? `${picker.caret.paragraphId}:${picker.caret.offset - picker.query.length}` : null;
+        setPicker(null);
+      } else if (!rows.length) return;
+      else if (event.key === "ArrowDown") setSelected((i) => (i + 1) % rows.length);
+      else if (event.key === "ArrowUp") setSelected((i) => (i - 1 + rows.length) % rows.length);
+      else if (event.key === "Enter" || event.key === "Tab") pick(rows[selected] ?? rows[0]);
+      else return;
+      event.preventDefault();
+      event.stopPropagation();
+    };
+    window.addEventListener("keydown", keys, true);
+    return () => window.removeEventListener("keydown", keys, true);
+  }, [picker, rows, selected, pick]);
+  const update = useCallback(() => {
+    if (!editor || !editable) return;
+    void refresh(true).then((list) => {
+      const definitions = new Map(
+        list.flatMap((s) => {
+          const d = toDefinition(s);
+          return d ? [[d.id, d]] : [];
+        })
+      );
+      const surface = editor.surface;
+      const before = surface?.state().selection?.head;
+      const paraId = before && surface?.session.paraIdOf(before.paragraphId);
+      const result = run(() => updateDefinitions(editorPort(editor), definitions));
+      const node = paraId && surface?.session.nodeIdOf(paraId);
+      if (result && before && node) {
+        const point = { paragraphId: node, offset: before.offset };
+        surface.setSelection({ anchor: point, head: point });
+        holdCaret(editor);
+      }
+      if (result) setReport(result);
+    });
+  }, [editor, editable, refresh, run]);
+  const value = useMemo(
+    () => load && editable ? { openPicker, update, labels: l } : null,
+    [load, editable, openPicker, update, l]
+  );
+  return /* @__PURE__ */ jsxs(DefinedTermsContext.Provider, { value, children: [
+    /* @__PURE__ */ jsx("span", { ref: marker, hidden: true }),
+    children,
+    load && /* @__PURE__ */ jsx(
+      DefinedTermHover,
+      {
+        root: viewer,
+        resolve: (anchor) => definitionOfAnchor(anchor, byId),
+        onFirstHover: firstHover
+      }
+    ),
+    picker && createPortal(
+      /* @__PURE__ */ jsx(
+        DefinedTermMenu,
+        {
+          picker,
+          rows,
+          loading: sources === null,
+          selected,
+          setSelected,
+          agreements,
+          labelId,
+          setLabelId,
+          onQuery: (query) => setPicker((p) => p ? { ...p, query } : p),
+          onPick: pick,
+          onClose: () => {
+            setPicker(null);
+            editor?.surface?.focus();
+          },
+          labels: l
+        }
+      ),
+      document.body
+    ),
+    /* @__PURE__ */ jsx(Dialog, { open: !!report, onOpenChange: (open) => !open && setReport(null), children: /* @__PURE__ */ jsxs(
+      DialogContent,
+      {
+        className: "max-h-[85dvh] overflow-y-auto",
+        "data-testid": "docx-definitions-report",
+        children: [
+          /* @__PURE__ */ jsxs(DialogHeader, { children: [
+            /* @__PURE__ */ jsx(DialogTitle, { children: l.updated }),
+            /* @__PURE__ */ jsx(DialogDescription, { children: report && l.updateSummary(report) })
+          ] }),
+          report && /* @__PURE__ */ jsxs("div", { className: "space-y-4 text-sm", children: [
+            /* @__PURE__ */ jsxs("section", { children: [
+              /* @__PURE__ */ jsx("h3", { className: "mb-1 font-medium", children: l.unusedTitle }),
+              report.unused.length ? /* @__PURE__ */ jsx("ul", { className: "space-y-1", "data-testid": "docx-definitions-unused", children: report.unused.map((u) => /* @__PURE__ */ jsxs("li", { className: "flex items-center justify-between gap-2", children: [
+                /* @__PURE__ */ jsx("span", { children: u.term }),
+                /* @__PURE__ */ jsx(
+                  Button,
+                  {
+                    size: "sm",
+                    variant: "ghost",
+                    onClick: () => {
+                      const surface = editor?.surface;
+                      surface?.setSelection({
+                        anchor: { paragraphId: u.paragraphId, offset: 0 },
+                        head: { paragraphId: u.paragraphId, offset: 0 }
+                      });
+                      surface?.revealParagraph(u.paragraphId);
+                      setReport(null);
+                    },
+                    children: l.show
+                  }
+                )
+              ] }, u.paragraphId)) }) : /* @__PURE__ */ jsx("p", { className: "text-muted-foreground", children: l.unusedNone })
+            ] }),
+            report.unknown.length > 0 && /* @__PURE__ */ jsxs("section", { children: [
+              /* @__PURE__ */ jsx("h3", { className: "mb-1 font-medium", children: l.unknownTitle }),
+              /* @__PURE__ */ jsx("ul", { className: "list-disc pl-5 text-muted-foreground", children: report.unknown.map((name) => /* @__PURE__ */ jsx("li", { children: name }, name)) })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx(DialogFooter, { children: /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: () => setReport(null), children: l.close }) })
+        ]
+      }
+    ) })
+  ] });
+}
+function DefinedTermMenu({
+  picker,
+  rows,
+  loading,
+  selected,
+  setSelected,
+  agreements,
+  labelId,
+  setLabelId,
+  onQuery,
+  onPick,
+  onClose,
+  labels: l
+}) {
+  const listboxId = React3.useId();
+  const element = useRef(null);
+  const search = picker.mode === "search";
+  useEffect(() => {
+    const dismiss = (event) => {
+      if (!element.current?.contains(event.target)) onClose();
+    };
+    document.addEventListener("pointerdown", dismiss);
+    return () => document.removeEventListener("pointerdown", dismiss);
+  }, [onClose]);
+  useEffect(() => {
+    element.current?.querySelector(`[data-index="${selected}"]`)?.scrollIntoView?.({ block: "nearest" });
+  }, [selected]);
+  const left = Math.max(8, Math.min(picker.left, window.innerWidth - 368));
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: element,
+      className: "native-docx-term-menu rounded-md border border-border bg-popover text-popover-foreground shadow-lg",
+      style: { position: "fixed", left, top: picker.top, width: 360, zIndex: 1e3 },
+      "data-testid": "docx-defined-term-menu",
+      onMouseDown: (event) => {
+        if (!(event.target instanceof HTMLInputElement || event.target instanceof HTMLSelectElement))
+          event.preventDefault();
+      },
+      children: [
+        (search || agreements.length > 0) && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 border-b border-border/50 p-2", children: [
+          search && /* @__PURE__ */ jsx(
+            "input",
+            {
+              autoFocus: true,
+              className: "min-w-0 flex-1 rounded border border-border bg-background px-2 py-1 text-sm",
+              placeholder: l.search,
+              "aria-label": l.search,
+              role: "combobox",
+              "aria-expanded": true,
+              "aria-controls": listboxId,
+              "aria-activedescendant": rows.length ? listOptionId(listboxId, selected) : void 0,
+              value: picker.query,
+              "data-testid": "docx-defined-term-search",
+              onChange: (event) => onQuery(event.target.value),
+              onKeyDown: (event) => {
+                if (event.key === "Escape") onClose();
+                else if (!rows.length) return;
+                else if (event.key === "ArrowDown") setSelected((selected + 1) % rows.length);
+                else if (event.key === "ArrowUp")
+                  setSelected((selected - 1 + rows.length) % rows.length);
+                else if (event.key === "Enter") onPick(rows[selected] ?? rows[0]);
+                else return;
+                event.preventDefault();
+              }
+            }
+          ),
+          agreements.length > 0 && /* @__PURE__ */ jsxs(
+            "select",
+            {
+              className: "max-w-[45%] rounded border border-border bg-background px-1 py-1 text-xs",
+              "aria-label": "Narrow to",
+              value: labelId ?? "",
+              "data-testid": "docx-defined-term-label",
+              onChange: (event) => setLabelId(event.target.value || null),
+              children: [
+                /* @__PURE__ */ jsx("option", { value: "", children: l.allAgreements }),
+                agreements.map((a) => /* @__PURE__ */ jsx("option", { value: a.id, children: a.name }, a.id))
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "border-b border-border/50 px-3 py-1.5 text-xs text-muted-foreground", children: l.hint }),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            id: listboxId,
+            role: "listbox",
+            "aria-label": l.search,
+            className: "scrollbar-subtle max-h-72 overflow-y-auto py-1",
+            children: [
+              rows.length === 0 && /* @__PURE__ */ jsx("p", { className: "px-3 py-2 text-sm text-muted-foreground", children: loading ? l.loading : picker.query ? l.noMatch : l.empty }),
+              rows.map((row, index) => /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  id: listOptionId(listboxId, index),
+                  role: "option",
+                  "aria-selected": index === selected,
+                  "data-index": index,
+                  "data-testid": `docx-defined-term-${row.definition.id}`,
+                  className: cn(
+                    "cursor-pointer px-3 py-1.5 text-sm",
+                    row.variant && "pl-6",
+                    index === selected ? "bg-accent text-accent-foreground" : "hover:bg-accent/50"
+                  ),
+                  onMouseEnter: () => setSelected(index),
+                  onClick: () => onPick(row),
+                  children: [
+                    /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-2", children: [
+                      /* @__PURE__ */ jsx("span", { className: cn("shrink-0", row.variant ? "text-xs" : "font-medium"), children: row.variant ? l.alsoIn(sourceOf(row.definition)) : row.group.term }),
+                      !row.variant && sourceOf(row.definition) && /* @__PURE__ */ jsx("span", { className: "truncate text-xs text-muted-foreground", children: sourceOf(row.definition) }),
+                      !row.variant && row.group.definitions.length > 1 && row.definition.confirmed && /* @__PURE__ */ jsx("span", { className: "ml-auto shrink-0 rounded bg-muted px-1 text-[10px] uppercase text-muted-foreground", children: l.preferred })
+                    ] }),
+                    /* @__PURE__ */ jsx("p", { className: "line-clamp-2 text-xs text-muted-foreground", children: row.definition.meaning })
+                  ]
+                },
+                row.definition.id
+              ))
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function DefinedTermHover({
+  root,
+  resolve,
+  onFirstHover
+}) {
+  const [card, setCard] = useState(null);
+  const hovered = useRef(false);
+  useEffect(() => {
+    if (!root) return;
+    const over = (event) => {
+      const link = event.target?.closest?.(
+        'a.docx-hyperlink[data-docx-link-kind="internal"]'
+      );
+      const href = link?.getAttribute("href") ?? "";
+      if (!link || !href.startsWith("#_dt_")) return;
+      if (!hovered.current) {
+        hovered.current = true;
+        onFirstHover();
+      }
+      const title = link.getAttribute("title");
+      if (title) {
+        link.dataset.definition = title;
+        link.removeAttribute("title");
+      }
+      const rect = link.getBoundingClientRect();
+      setCard({
+        left: rect.left,
+        top: rect.bottom + 6,
+        anchor: href.slice(1),
+        fallback: link.dataset.definition ?? ""
+      });
+    };
+    const out = (event) => {
+      const link = event.target?.closest?.("a.docx-hyperlink");
+      if (link && !link.contains(event.relatedTarget)) setCard(null);
+    };
+    root.addEventListener("mouseover", over);
+    root.addEventListener("mouseout", out);
+    const hide = () => setCard(null);
+    window.addEventListener("keydown", hide, true);
+    window.addEventListener("pointerdown", hide, true);
+    window.addEventListener("scroll", hide, true);
+    return () => {
+      root.removeEventListener("mouseover", over);
+      root.removeEventListener("mouseout", out);
+      window.removeEventListener("keydown", hide, true);
+      window.removeEventListener("pointerdown", hide, true);
+      window.removeEventListener("scroll", hide, true);
+    };
+  }, [root, onFirstHover]);
+  if (!card) return null;
+  const definition = resolve(card.anchor);
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        role: "tooltip",
+        className: "native-docx-term-card rounded-md border border-border bg-popover p-3 text-sm text-popover-foreground shadow-lg",
+        style: {
+          position: "fixed",
+          left: Math.max(8, Math.min(card.left, window.innerWidth - 348)),
+          top: card.top,
+          width: 340,
+          zIndex: 1e3,
+          pointerEvents: "none"
+        },
+        "data-testid": "docx-defined-term-card",
+        children: definition ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("p", { className: "font-medium", children: definition.term }),
+          /* @__PURE__ */ jsx("p", { className: "mt-1 text-muted-foreground", children: definition.meaning }),
+          sourceOf(definition) && /* @__PURE__ */ jsx("p", { className: "mt-2 text-xs text-muted-foreground", children: sourceOf(definition) })
+        ] }) : /* @__PURE__ */ jsx("p", { children: card.fallback })
+      }
+    ),
+    document.body
+  );
+}
 function wordDraftHtml(markdown) {
   const template = document.createElement("template");
   template.innerHTML = renderToStaticMarkup(/* @__PURE__ */ jsx(AiMarkdown, { children: markdown }));
@@ -1089,6 +1953,38 @@ function RibbonMenu({
     )
   ] });
 }
+function DefinedTermButtons() {
+  const terms = useDefinedTerms();
+  if (!terms) return null;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: "native-docx-ribbon-trigger",
+        "aria-label": terms.labels.insert,
+        title: `${terms.labels.insert} (type @@)`,
+        "data-testid": "docx-insert-defined-term",
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: (event) => terms.openPicker(event.currentTarget),
+        children: /* @__PURE__ */ jsx(BookA, { size: 16 })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: "native-docx-ribbon-trigger",
+        "aria-label": terms.labels.update,
+        title: terms.labels.update,
+        "data-testid": "docx-update-definitions",
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: () => terms.update(),
+        children: /* @__PURE__ */ jsx(ListRestart, { size: 16 })
+      }
+    )
+  ] });
+}
 function DocxRibbon({ onSave }) {
   const [tab, setTab] = useState("Home");
   const t = useChromeTranslate();
@@ -1127,7 +2023,8 @@ function DocxRibbon({ onSave }) {
       tab === "Insert" && /* @__PURE__ */ jsxs(Fragment, { children: [
         /* @__PURE__ */ jsx(DocxEditor.Toolbar.TableInsert, {}),
         /* @__PURE__ */ jsx(DocxEditor.Toolbar.ImageInsert, {}),
-        /* @__PURE__ */ jsx(DocxEditor.Toolbar.Link, {})
+        /* @__PURE__ */ jsx(DocxEditor.Toolbar.Link, {}),
+        /* @__PURE__ */ jsx(DefinedTermButtons, {})
       ] }),
       tab === "Review" && /* @__PURE__ */ jsxs(Fragment, { children: [
         /* @__PURE__ */ jsx(DocxEditor.Toolbar.EditingMode, {}),
@@ -1449,7 +2346,7 @@ function NativeDocxEditor({
           )
         ] }),
         !ready && !error && /* @__PURE__ */ jsx("div", { className: "native-docx-error", role: "status", children: "Opening Word document\u2026" }),
-        ready && /* @__PURE__ */ jsx("div", { className: "native-docx-body docx-editor", children: /* @__PURE__ */ jsx(EditorBoundary, { children: /* @__PURE__ */ jsxs(
+        ready && /* @__PURE__ */ jsx("div", { className: "native-docx-body docx-editor", children: /* @__PURE__ */ jsx(EditorBoundary, { children: /* @__PURE__ */ jsx(
           DocxEditor.Root,
           {
             document: ready.document,
@@ -1464,52 +2361,60 @@ function NativeDocxEditor({
               if (change.source !== "load") changed();
             },
             onFontError: (e) => setError(e.message),
-            children: [
-              /* @__PURE__ */ jsx(
-                DocxEditor.RevisionMarkup,
-                {
-                  insertions: { mark: "underline", color: "blue" },
-                  deletions: { mark: "strikethrough", color: "red" },
-                  movedFrom: { mark: "doubleStrikethrough", color: "green" },
-                  movedTo: { mark: "doubleUnderline", color: "green" },
-                  trackMoves: true
-                }
-              ),
-              !stream && /* @__PURE__ */ jsx(DocxRibbon, { onSave: () => void saveVersion() }),
-              /* @__PURE__ */ jsxs(
-                "div",
-                {
-                  className: "native-docx-stage",
-                  ref: stageRef,
-                  onMouseDownCapture: (event) => {
-                    if (event.button === 2 && ref.current?.getSelectionPlacement())
-                      event.preventDefault();
-                  },
-                  children: [
-                    /* @__PURE__ */ jsxs(DocxEditor.Viewport, { className: "native-docx-viewport", children: [
-                      /* @__PURE__ */ jsx(DocxEditor.Content, {}),
-                      /* @__PURE__ */ jsx(
-                        DocxMentions,
-                        {
-                          initialCommentId,
-                          mentions: adapter.mentions,
-                          notify: adapter.notify,
-                          getAgentStatus: adapter.getAgentStatus,
-                          requestAgent: adapter.requestAgent ? (request) => adapter.requestAgent(documentId, request) : void 0,
-                          children: /* @__PURE__ */ jsx(DocxEditorReview, { children: () => /* @__PURE__ */ jsx(DocxEditorReview.Card, { children: /* @__PURE__ */ jsx(DocxCommentActivity, {}) }) })
-                        }
-                      ),
-                      /* @__PURE__ */ jsx(DocxEditor.HeaderFooterChrome, {}),
-                      /* @__PURE__ */ jsx(DocxEditor.NotesChrome, {}),
-                      /* @__PURE__ */ jsx(DocxEditor.Equation, {}),
-                      /* @__PURE__ */ jsx(DocxEditor.HyperLink, {}),
-                      /* @__PURE__ */ jsx(DocxEditor.ContextMenu, {})
-                    ] }),
-                    /* @__PURE__ */ jsx(DocxEditor.PageNumber, {})
-                  ]
-                }
-              )
-            ]
+            children: /* @__PURE__ */ jsxs(
+              DefinedTermsProvider,
+              {
+                load: adapter.definitions,
+                editable: !stream && !snapshot && ready.canEdit,
+                notify: adapter.notify,
+                children: [
+                  /* @__PURE__ */ jsx(
+                    DocxEditor.RevisionMarkup,
+                    {
+                      insertions: { mark: "underline", color: "blue" },
+                      deletions: { mark: "strikethrough", color: "red" },
+                      movedFrom: { mark: "doubleStrikethrough", color: "green" },
+                      movedTo: { mark: "doubleUnderline", color: "green" },
+                      trackMoves: true
+                    }
+                  ),
+                  !stream && /* @__PURE__ */ jsx(DocxRibbon, { onSave: () => void saveVersion() }),
+                  /* @__PURE__ */ jsxs(
+                    "div",
+                    {
+                      className: "native-docx-stage",
+                      ref: stageRef,
+                      onMouseDownCapture: (event) => {
+                        if (event.button === 2 && ref.current?.getSelectionPlacement())
+                          event.preventDefault();
+                      },
+                      children: [
+                        /* @__PURE__ */ jsxs(DocxEditor.Viewport, { className: "native-docx-viewport", children: [
+                          /* @__PURE__ */ jsx(DocxEditor.Content, {}),
+                          /* @__PURE__ */ jsx(
+                            DocxMentions,
+                            {
+                              initialCommentId,
+                              mentions: adapter.mentions,
+                              notify: adapter.notify,
+                              getAgentStatus: adapter.getAgentStatus,
+                              requestAgent: adapter.requestAgent ? (request) => adapter.requestAgent(documentId, request) : void 0,
+                              children: /* @__PURE__ */ jsx(DocxEditorReview, { children: () => /* @__PURE__ */ jsx(DocxEditorReview.Card, { children: /* @__PURE__ */ jsx(DocxCommentActivity, {}) }) })
+                            }
+                          ),
+                          /* @__PURE__ */ jsx(DocxEditor.HeaderFooterChrome, {}),
+                          /* @__PURE__ */ jsx(DocxEditor.NotesChrome, {}),
+                          /* @__PURE__ */ jsx(DocxEditor.Equation, {}),
+                          /* @__PURE__ */ jsx(DocxEditor.HyperLink, {}),
+                          /* @__PURE__ */ jsx(DocxEditor.ContextMenu, {})
+                        ] }),
+                        /* @__PURE__ */ jsx(DocxEditor.PageNumber, {})
+                      ]
+                    }
+                  )
+                ]
+              }
+            )
           }
         ) }, retry) }),
         /* @__PURE__ */ jsxs("div", { className: "native-docx-actions", children: [
@@ -1604,6 +2509,6 @@ async function loadFonts(baseUrl) {
   };
 }
 
-export { DocxCommentActivity, DocxEditorReview, DocxMentions, DocxParticipants, DocxRibbon, NativeDocxEditor, loadDocxFonts, normalizeDocxExport, reviewModule, useReview, useReviewItem };
-//# sourceMappingURL=chunk-W2R7YVFM.js.map
-//# sourceMappingURL=chunk-W2R7YVFM.js.map
+export { DEFAULT_DEFINED_TERMS_LABELS, DEFINED_TERM_TRIGGER, DefinedTermsProvider, DocxCommentActivity, DocxEditorReview, DocxMentions, DocxParticipants, DocxRibbon, NativeDocxEditor, editorPort, findDefinitionsSection, insertDefinedTerm, loadDocxFonts, normalizeDocxExport, reviewModule, updateDefinitions, useDefinedTerms, useReview, useReviewItem, withDirectEditing };
+//# sourceMappingURL=chunk-WXLKMEMB.js.map
+//# sourceMappingURL=chunk-WXLKMEMB.js.map