@ai-matrx/context-menu 0.0.0 → 0.1.1

package/dist/engine.cjs

@@ -0,0 +1,3069 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/engine/index.ts
+var engine_exports = {};
+__export(engine_exports, {
+  CONTEXT_MENU_ENGINE_ID_PREFIXES: () => CONTEXT_MENU_ENGINE_ID_PREFIXES,
+  CONTEXT_MENU_ENGINE_ROWS: () => CONTEXT_MENU_ENGINE_ROWS,
+  CONTEXT_MENU_SELECTION_HOST_KEY: () => CONTEXT_MENU_SELECTION_HOST_KEY,
+  CONTEXT_REGION_TRIGGER_ATTRS: () => CONTEXT_REGION_TRIGGER_ATTRS,
+  DEFAULT_CONTEXT_MENU_HOST: () => DEFAULT_CONTEXT_MENU_HOST,
+  FIELD_PREVIEW_MAX: () => FIELD_PREVIEW_MAX,
+  MANAGED_CONTEXT_MENU_AGENT_CONFIG: () => MANAGED_CONTEXT_MENU_AGENT_CONFIG,
+  OWN_ROWS_MAX: () => OWN_ROWS_MAX,
+  PROPOSED_MENU_GROUPING: () => PROPOSED_MENU_GROUPING,
+  RECORD_MENU_ATTR: () => RECORD_MENU_ATTR,
+  REGROUP_ID_PREFIX: () => REGROUP_ID_PREFIX,
+  STRIP_MAX: () => STRIP_MAX,
+  actionLabel: () => actionLabel,
+  actionsAlreadyHere: () => actionsAlreadyHere,
+  auditRegroup: () => auditRegroup,
+  auditSurfaceScope: () => auditSurfaceScope,
+  buildDefaultTableRowMenuDescriptor: () => buildDefaultTableRowMenuDescriptor,
+  buildEditableWidgetHandle: () => buildEditableWidgetHandle,
+  buildJsonMenuSection: () => buildJsonMenuSection,
+  buildMenuModel: () => buildMenuModel,
+  buildSelectionWriteBack: () => buildSelectionWriteBack,
+  chatMessageSubject: () => chatMessageSubject,
+  clickedKind: () => clickedKind,
+  configureContextMenuHost: () => configureContextMenuHost,
+  contextMenuActionsFromModel: () => contextMenuActionsFromModel,
+  contextMenuHostOf: () => contextMenuHostOf,
+  contextMenuProvider: () => contextMenuProvider,
+  contextMenuSelectionProvider: () => contextMenuSelectionProvider,
+  createDefaultTableRowMenuDescriptor: () => createDefaultTableRowMenuDescriptor,
+  createTableRowMenuDescriptor: () => createTableRowMenuDescriptor,
+  currentModel: () => currentModel,
+  destinationFor: () => destinationFor,
+  detectInertMenu: () => detectInertMenu,
+  drawnPlaces: () => drawnPlaces,
+  editorTextAgentCallbacks: () => editorTextAgentCallbacks,
+  eventMatchesCombo: () => eventMatchesCombo,
+  fieldLabelOf: () => fieldLabelOf,
+  fieldPreview: () => fieldPreview,
+  findComboMatch: () => findComboMatch,
+  getContextMenuHost: () => getContextMenuHost,
+  hasActionable: () => hasActionable,
+  hasActionableContent: () => hasActionableContent,
+  hasEditorInsertTarget: () => hasEditorInsertTarget,
+  headerPreview: () => headerPreview,
+  insertIntoEditor: () => insertIntoEditor,
+  itemMenuConfigToExtraSections: () => itemMenuConfigToExtraSections,
+  itemToastPromise: () => toastPromise,
+  joinExtraSections: () => joinExtraSections,
+  joinRowAndSurfaceContext: () => joinRowAndSurfaceContext,
+  jsonSectionLabel: () => jsonSectionLabel,
+  liftPrimarySections: () => liftPrimarySections,
+  matchRule: () => matchRule,
+  menuEngineRevision: () => menuEngineRevision,
+  menuHeader: () => menuHeader,
+  menuHeaderContent: () => menuHeaderContent,
+  mergeFieldName: () => mergeFieldName,
+  mergeResolvedContextData: () => mergeResolvedContextData,
+  modelRevision: () => modelRevision,
+  namedHeader: () => namedHeader,
+  openContextMenuForElement: () => openContextMenuForElement,
+  openRecordMenu: () => openRecordMenu,
+  ownParagraph: () => ownParagraph,
+  parseKeyCombo: () => parseKeyCombo,
+  proposedArrangement: () => proposedArrangement,
+  recordMenuChanged: () => recordMenuChanged,
+  recordMenusRevision: () => recordMenusRevision,
+  registerRecordMenu: () => registerRecordMenu,
+  registerTableRowContextResolver: () => registerTableRowContextResolver,
+  registryTreeNodes: () => registryTreeNodes,
+  regroupResolved: () => regroupResolved,
+  reportMenuDiagnostics: () => reportMenuDiagnostics,
+  resetContextMenuHost: () => resetContextMenuHost,
+  resolveActionText: () => resolveActionText,
+  resolveApplicationScope: () => resolveApplicationScope,
+  resolveEffectiveEntity: () => resolveEffectiveEntity,
+  resolveEffectiveEntityWithDom: () => resolveEffectiveEntityWithDom,
+  resolveRecordMenu: () => resolveRecordMenu,
+  resolveTableRowItem: () => resolveTableRowItem,
+  resolveTableRowMenuDescriptor: () => resolveTableRowMenuDescriptor,
+  rowRecordName: () => rowRecordName,
+  sniffEntityFromDom: () => sniffEntityFromDom,
+  subscribeRecordMenus: () => subscribeRecordMenus,
+  tableRowEditCommands: () => tableRowEditCommands,
+  tableTextAtTarget: () => tableTextAtTarget,
+  topLevelRowCount: () => topLevelRowCount,
+  useContextMenuHostBindings: () => useContextMenuHostBindings
+});
+module.exports = __toCommonJS(engine_exports);
+
+// src/engine/types.ts
+var types_exports = {};
+__reExport(types_exports, require("@ai-matrx/chat/context-menu/types"));
+
+// src/engine/index.ts
+__reExport(engine_exports, types_exports, module.exports);
+
+// src/engine/host/port.ts
+var import_confirm_opener = require("@ai-matrx/kit/confirm-opener");
+function unwired(name) {
+  const announced = slot().announced;
+  if (announced.has(name)) return;
+  announced.add(name);
+  console.warn(`[context-menu] host port "${name}" is not wired \u2014 configureContextMenuHost({ ${name} }).`);
+}
+function unwiredFn(name) {
+  return () => unwired(name);
+}
+var DEFAULT_QUICK_ACTIONS = {
+  openChatWindow: unwiredFn("quickActions.openChatWindow"),
+  openQuickChat: unwiredFn("quickActions.openQuickChat"),
+  openQuickData: unwiredFn("quickActions.openQuickData"),
+  openQuickFiles: unwiredFn("quickActions.openQuickFiles"),
+  openQuickNotes: unwiredFn("quickActions.openQuickNotes"),
+  openQuickTasks: unwiredFn("quickActions.openQuickTasks"),
+  openVoicePad: unwiredFn("quickActions.openVoicePad")
+};
+var DEFAULT_BINDINGS = {
+  isAdminDebugger: false,
+  hasAdminPower: false,
+  isDebugMode: false,
+  isAdminIndicatorOpen: false,
+  hasCompareBase: false,
+  activeScopeIds: null,
+  toggleDebugMode: unwiredFn("useBindings.toggleDebugMode"),
+  toggleAdminIndicator: unwiredFn("useBindings.toggleAdminIndicator"),
+  setCompareBase: unwiredFn("useBindings.setCompareBase"),
+  openCompareWithBase: async () => {
+    unwired("useBindings.openCompareWithBase");
+    return false;
+  },
+  openListenSummaryWindow: unwiredFn("useBindings.openListenSummaryWindow"),
+  openDiffWindow: unwiredFn("useBindings.openDiffWindow"),
+  openFindReplace: unwiredFn("useBindings.openFindReplace"),
+  openReferencePicker: unwiredFn("useBindings.openReferencePicker"),
+  openContextAssignment: unwiredFn("useBindings.openContextAssignment"),
+  openLinkRecordSheet: unwiredFn("useBindings.openLinkRecordSheet"),
+  openShareModalWindow: unwiredFn("useBindings.openShareModalWindow"),
+  openStateViewer: unwiredFn("useBindings.openStateViewer"),
+  openSurfaceInspector: unwiredFn("useBindings.openSurfaceInspector"),
+  openSurfaceContextWindow: unwiredFn("useBindings.openSurfaceContextWindow"),
+  openBindAgent: unwiredFn("useBindings.openBindAgent"),
+  quickActions: DEFAULT_QUICK_ACTIONS
+};
+var EMPTY_RENDER_DEFINITIONS = [];
+var DEFAULT_CONTEXT_MENU_HOST = {
+  useBindings: () => DEFAULT_BINDINGS,
+  getSurfaceManifest: () => void 0,
+  selectRenderDefinitions: () => EMPTY_RENDER_DEFINITIONS,
+  confirm: import_confirm_opener.confirm,
+  showManualCopy: () => unwired("showManualCopy"),
+  listeningHomeSurface: "matrx-user/assistant-message",
+  DocumentAgentReview: null
+};
+var SLOT = /* @__PURE__ */ Symbol.for("ai-matrx.context-menu.host");
+function slot() {
+  const g = globalThis;
+  let s = g[SLOT];
+  if (!s) {
+    s = { host: DEFAULT_CONTEXT_MENU_HOST, announced: /* @__PURE__ */ new Set() };
+    g[SLOT] = s;
+  }
+  return s;
+}
+function configureContextMenuHost(host) {
+  slot().host = { ...slot().host, ...host };
+}
+function getContextMenuHost() {
+  return slot().host;
+}
+function resetContextMenuHost() {
+  slot().host = DEFAULT_CONTEXT_MENU_HOST;
+  slot().announced.clear();
+}
+function useContextMenuHostBindings() {
+  return getContextMenuHost().useBindings();
+}
+
+// src/engine/utils/build-application-scope.ts
+var build_application_scope_exports = {};
+__reExport(build_application_scope_exports, require("@ai-matrx/chat/context-menu/utils/build-application-scope"));
+
+// src/engine/index.ts
+__reExport(engine_exports, build_application_scope_exports, module.exports);
+
+// src/engine/utils/availability.ts
+var availability_exports = {};
+__reExport(availability_exports, require("@ai-matrx/chat/context-menu/utils/availability"));
+
+// src/engine/index.ts
+__reExport(engine_exports, availability_exports, module.exports);
+
+// src/engine/utils/open-context-menu.ts
+function openContextMenuForElement(element) {
+  if (!element) return;
+  const rect = element.getBoundingClientRect();
+  element.dispatchEvent(
+    new MouseEvent("contextmenu", {
+      bubbles: true,
+      cancelable: true,
+      view: element.ownerDocument.defaultView ?? window,
+      button: 2,
+      buttons: 2,
+      clientX: rect.left + rect.width / 2,
+      clientY: rect.top + rect.height / 2
+    })
+  );
+}
+
+// src/engine/utils/selection-tracking.ts
+var selection_tracking_exports = {};
+__reExport(selection_tracking_exports, require("@ai-matrx/chat/context-menu/utils/selection-tracking"));
+
+// src/engine/index.ts
+__reExport(engine_exports, selection_tracking_exports, module.exports);
+
+// src/engine/utils/menu-deadline.ts
+var menu_deadline_exports = {};
+__reExport(menu_deadline_exports, require("@ai-matrx/chat/context-menu/utils/menu-deadline"));
+
+// src/engine/index.ts
+__reExport(engine_exports, menu_deadline_exports, module.exports);
+
+// src/engine/utils/resolveMarkdownContext.ts
+var resolveMarkdownContext_exports = {};
+__reExport(resolveMarkdownContext_exports, require("@ai-matrx/chat/context-menu/utils/resolveMarkdownContext"));
+
+// src/engine/index.ts
+__reExport(engine_exports, resolveMarkdownContext_exports, module.exports);
+
+// src/engine/model/requirement-gate.ts
+var requirement_gate_exports = {};
+__reExport(requirement_gate_exports, require("@ai-matrx/chat/context-menu/model/requirement-gate"));
+
+// src/engine/index.ts
+__reExport(engine_exports, requirement_gate_exports, module.exports);
+
+// src/engine/model/menu-model.ts
+var import_EditInPlace = require("@ai-matrx/rich-editor/in-place/EditInPlace");
+
+// src/engine/utils/key-combo.ts
+var MOD_ALIASES = {
+  alt: "alt",
+  option: "alt",
+  opt: "alt",
+  "\u2325": "alt",
+  shift: "shift",
+  "\u21E7": "shift",
+  ctrl: "ctrl",
+  control: "ctrl",
+  "\u2303": "ctrl",
+  cmd: "meta",
+  command: "meta",
+  meta: "meta",
+  "\u2318": "meta",
+  win: "meta",
+  mod: "mod"
+};
+function isApplePlatform() {
+  if (typeof navigator === "undefined") return false;
+  return /mac|iphone|ipad|ipod/i.test(navigator.platform || navigator.userAgent || "");
+}
+function parseKeyCombo(raw) {
+  if (!raw) return null;
+  const parts = raw.split(/\s*\+\s*/).map((p) => p.trim()).filter(Boolean);
+  if (parts.length < 2) return null;
+  const combo = { alt: false, shift: false, ctrl: false, meta: false, code: null, key: null };
+  const last = parts[parts.length - 1];
+  for (const part of parts.slice(0, -1)) {
+    const mod = MOD_ALIASES[part.toLowerCase()];
+    if (!mod) return null;
+    if (mod === "mod") combo[isApplePlatform() ? "meta" : "ctrl"] = true;
+    else combo[mod] = true;
+  }
+  if (/^[a-z]$/i.test(last)) combo.code = `Key${last.toUpperCase()}`;
+  else if (/^[0-9]$/.test(last)) combo.code = `Digit${last}`;
+  else combo.key = last.toLowerCase();
+  if (!combo.alt && !combo.ctrl && !combo.meta) return null;
+  if ((combo.ctrl || combo.meta) && combo.shift && !combo.alt && combo.code === "KeyK") return null;
+  return combo;
+}
+function eventMatchesCombo(e, combo) {
+  if (!!e.altKey !== combo.alt || !!e.shiftKey !== combo.shift) return false;
+  if (!!e.ctrlKey !== combo.ctrl || !!e.metaKey !== combo.meta) return false;
+  if (combo.code) return e.code === combo.code;
+  return !!combo.key && (e.key ?? "").toLowerCase() === combo.key;
+}
+function findComboMatch(e, items, comboOf) {
+  if (!e.altKey && !e.ctrlKey && !e.metaKey) return null;
+  for (const item of items) {
+    const combo = parseKeyCombo(comboOf(item));
+    if (combo && eventMatchesCombo(e, combo)) return item;
+  }
+  return null;
+}
+
+// src/engine/model/menu-model.ts
+var import_lucide_react2 = require("lucide-react");
+var import_constants2 = require("@ai-matrx/chat/agents/shortcuts/constants");
+var import_menuStructure2 = require("@ai-matrx/rich-content/rich-document/variants/shared/menuStructure");
+
+// src/engine/utils/json-menu-actions.ts
+var import_json_format = require("@ai-matrx/kit/json-format");
+var import_json_format2 = require("@ai-matrx/kit/json-format");
+function lineCount(text) {
+  let n = text === "" ? 0 : 1;
+  for (let i = 0; i < text.length; i++) if (text[i] === "\n") n++;
+  return n;
+}
+function sizeHint(before, after) {
+  const b = lineCount(before);
+  const a = lineCount(after);
+  if (b !== a) {
+    return `${b} line${b !== 1 ? "s" : ""} -> ${a} line${a !== 1 ? "s" : ""}`;
+  }
+  return `${before.length} -> ${after.length} chars`;
+}
+function shapePreservingStyle(detection) {
+  return detection.payload.includes("\n") ? "pretty" : "minify";
+}
+function buildJsonMenuSection(params) {
+  const { text, canWrite, onReplace, onCopy } = params;
+  if (!text.trim()) return null;
+  const detection = (0, import_json_format.detectJson)(text);
+  if (!detection.looksLikeJson) return null;
+  if (!detection.ok) {
+    return {
+      detection,
+      writes: false,
+      actions: [
+        {
+          id: "json-invalid",
+          label: "Invalid JSON",
+          hint: detection.error,
+          disabled: true,
+          run: () => {
+          }
+        }
+      ]
+    };
+  }
+  const apply = (next) => {
+    if (canWrite) onReplace(next);
+    else void onCopy(next);
+  };
+  const verb = canWrite ? "" : "Copy ";
+  const actions = [];
+  const addFormat = (id, label, style, fence = "preserve", sortKeys = false) => {
+    const result = (0, import_json_format2.formatJsonText)(text, { style, fence, sortKeys });
+    if (!result.ok) return;
+    if (canWrite && !result.changed) return;
+    actions.push({
+      id,
+      label,
+      hint: result.changed ? sizeHint(text, result.text) : void 0,
+      run: () => apply(result.text)
+    });
+  };
+  addFormat("json-condense", `${verb}Condense`, "compact");
+  addFormat("json-minify", `${verb}Minify (one line)`, "minify");
+  addFormat("json-expand", `${verb}Expand`, "pretty");
+  addFormat(
+    "json-sort-keys",
+    `${verb}Sort keys A-Z`,
+    shapePreservingStyle(detection),
+    "preserve",
+    true
+  );
+  if (detection.fence) {
+    addFormat(
+      "json-strip-fence",
+      `${verb}Remove code fence`,
+      shapePreservingStyle(detection),
+      "strip"
+    );
+  } else {
+    addFormat(
+      "json-add-fence",
+      `${verb}Wrap in json code fence`,
+      shapePreservingStyle(detection),
+      "add"
+    );
+  }
+  if (canWrite) {
+    const minified = (0, import_json_format2.formatJsonText)(text, { style: "minify", fence: "strip" });
+    if (minified.ok) {
+      actions.push({
+        id: "json-copy-minified",
+        label: "Copy minified",
+        hint: sizeHint(text, minified.text),
+        run: () => void onCopy(minified.text)
+      });
+    }
+  }
+  if (actions.length === 0) return null;
+  return { detection, writes: canWrite, actions };
+}
+function jsonSectionLabel(section) {
+  const { detection } = section;
+  if (!detection.ok) return "JSON (invalid)";
+  const n = detection.lineCount;
+  const kind = detection.root === "array" ? "array" : "object";
+  return `JSON ${kind} \xB7 ${n} line${n !== 1 ? "s" : ""}`;
+}
+
+// src/engine/utils/compact.ts
+function compact(value) {
+  const out = {};
+  for (const [key, v] of Object.entries(value)) if (v !== void 0) out[key] = v;
+  return out;
+}
+
+// src/engine/utils/field-menu-header.ts
+function fieldLabelOf(element) {
+  if (!element) return null;
+  const clean = (s) => (s ?? "").replace(/\s+/g, " ").replace(/\s*\*$/, "").trim() || null;
+  const aria = clean(element.getAttribute("aria-label"));
+  if (aria) return aria;
+  const labelledBy = element.getAttribute("aria-labelledby");
+  if (labelledBy) {
+    const text = labelledBy.split(/\s+/).map((id2) => element.ownerDocument?.getElementById(id2)?.textContent ?? "").join(" ");
+    if (clean(text)) return clean(text);
+  }
+  const labels = element.labels;
+  if (labels && labels.length > 0) {
+    const text = clean(labels[0]?.textContent);
+    if (text) return text;
+  }
+  const id = element.getAttribute("id");
+  if (id && element.ownerDocument) {
+    const label = element.ownerDocument.querySelector(`label[for="${CSS.escape(id)}"]`);
+    if (clean(label?.textContent)) return clean(label?.textContent);
+  }
+  return null;
+}
+var MERGE_FIELD = /\{\{\s*([^{}]+?)\s*\}\}/g;
+function mergeFieldName(token) {
+  const words = token.replace(/[._-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").trim().toLowerCase();
+  return words ? words[0].toUpperCase() + words.slice(1) : token;
+}
+var FIELD_PREVIEW_MAX = 60;
+function fieldPreview(text) {
+  const withoutFields = text.replace(MERGE_FIELD, "").replace(/[\s\p{P}]+/gu, "");
+  if (!withoutFields) return "";
+  const readable = text.replace(MERGE_FIELD, (_, name) => mergeFieldName(name)).replace(/\s+/g, " ").trim();
+  return readable.length > FIELD_PREVIEW_MAX ? `${readable.slice(0, FIELD_PREVIEW_MAX - 1).trimEnd()}\u2026` : readable;
+}
+
+// src/engine/utils/already-here.ts
+var SAVE_INTO_WHERE_YOU_ARE = [
+  { sourceType: "note", surface: "matrx-user/notes", actionId: "save-to-notes" },
+  { sourceType: "task", surface: "matrx-user/tasks", actionId: "save-to-task" }
+];
+var OPEN_WHERE_YOU_ARE = [
+  // The Feedback window's menus offered "Submit feedback" — reopening itself.
+  { surface: "matrx-user/feedback", actionId: "submit-feedback" }
+];
+var EDITOR_DOORS = ["edit", "open-fullscreen-editor"];
+function actionsAlreadyHere(where) {
+  const out = [];
+  for (const rule of SAVE_INTO_WHERE_YOU_ARE) {
+    if (where.sourceType === rule.sourceType || where.surfaceName === rule.surface) out.push(rule.actionId);
+  }
+  for (const rule of OPEN_WHERE_YOU_ARE) {
+    if (where.surfaceName === rule.surface) out.push(rule.actionId);
+  }
+  const ownPage = SAVE_INTO_WHERE_YOU_ARE.some(
+    (rule) => where.sourceType === rule.sourceType || where.surfaceName === rule.surface
+  );
+  if (where.isEditable || ownPage) out.push(...EDITOR_DOORS);
+  return [...new Set(out)];
+}
+
+// src/engine/utils/editor-text-agent.ts
+function editorTextAgentCallbacks(callbacks, source, adapter, request) {
+  if (callbacks?.onRequestTextAgentAction || !request) return callbacks;
+  if (source.type === "raw" || source.readOnly || typeof adapter.edit !== "function") return callbacks;
+  return { ...callbacks ?? {}, onRequestTextAgentAction: request };
+}
+
+// src/engine/hooks/useContextMenuActions.ts
+var import_react = require("react");
+var import_clipboard = require("@ai-matrx/kit/clipboard");
+var import_lucide_react = require("lucide-react");
+var import_route_to_surface = require("@ai-matrx/chat/surfaces/utils/route-to-surface");
+var import_surface_display = require("@ai-matrx/chat/surfaces/utils/surface-display");
+var import_fetchRelatedSurfaces = require("@ai-matrx/chat/surfaces/runtime/fetchRelatedSurfaces");
+var import_icons = require("@ai-matrx/icons");
+var import_hooks = require("@ai-matrx/chat/store/hooks");
+var import_identity = require("@ai-matrx/chat/host/identity");
+var import_org = require("@ai-matrx/chat/host/org");
+var import_useAgentLauncher = require("@ai-matrx/chat/agents/hooks/useAgentLauncher");
+var import_react2 = require("@ai-matrx/media/react");
+var import_speech = require("@ai-matrx/media/speech");
+var import_useSurfaceConfig = require("@ai-matrx/chat/surfaces/hooks/useSurfaceConfig");
+
+// src/engine/utils/editor-text-insertion.ts
+function insertTextAtCursor(editorId, text) {
+  try {
+    const editor = document.querySelector(
+      `[data-editor-id="${editorId}"]`
+    );
+    if (!editor) {
+      console.error("[editor-text-insertion] Editor not found:", editorId);
+      return false;
+    }
+    editor.focus();
+    const selection = window.getSelection();
+    if (!selection) {
+      console.error("[editor-text-insertion] Selection not available");
+      return false;
+    }
+    let range;
+    if (selection.rangeCount > 0) {
+      range = selection.getRangeAt(0);
+    } else {
+      range = document.createRange();
+      const lastNode = editor.lastChild;
+      if (lastNode) {
+        if (lastNode.nodeType === Node.TEXT_NODE) {
+          range.setStart(lastNode, lastNode.textContent?.length ?? 0);
+        } else {
+          range.setStartAfter(lastNode);
+        }
+      } else {
+        range.setStart(editor, 0);
+      }
+      range.collapse(true);
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+    if (!range.collapsed) {
+      range.deleteContents();
+    }
+    const textNode = document.createTextNode(text);
+    range.insertNode(textNode);
+    range.setStartAfter(textNode);
+    range.setEndAfter(textNode);
+    selection.removeAllRanges();
+    selection.addRange(range);
+    editor.focus();
+    return true;
+  } catch (error) {
+    console.error("[editor-text-insertion] Error inserting text:", error);
+    return false;
+  }
+}
+
+// src/engine/utils/insert-into-editor.ts
+var import_text_insertion = require("@ai-matrx/rich-editor/core/text-insertion");
+function hasEditorInsertTarget(targets) {
+  return Boolean(targets.editorId) || Boolean(targets.getTextarea) || Boolean(targets.insertAtCaret);
+}
+function insertIntoEditor(targets, text) {
+  const shaped = typeof text === "string" ? { editor: text, textarea: () => text, caret: text } : text;
+  const { editorId, getTextarea, insertAtCaret, onTextReplace } = targets;
+  const placement = shaped.placement ?? "inline";
+  if (editorId) {
+    const took = attempt("editor", () => {
+      if (placement === "block") moveEditorCaretToLineEnd(editorId);
+      return insertTextAtCursor(editorId, shaped.editor);
+    });
+    if (took) return "editor";
+  }
+  const field = editorId ? null : getTextarea?.() ?? null;
+  if (field) {
+    const took = attempt("textarea", () => {
+      if (placement === "block" && field.selectionStart === field.selectionEnd) {
+        const at = (0, import_text_insertion.blockBoundary)(field.value, field.selectionStart, field.selectionEnd, "nearest");
+        field.setSelectionRange(at, at);
+      }
+      return (0, import_text_insertion.insertTextAtTextareaCursor)(field, shaped.textarea(field), onTextReplace);
+    });
+    if (took) return "textarea";
+  }
+  if (insertAtCaret && attempt("caret", () => insertAtCaret(shaped.caret, placement))) return "caret";
+  return null;
+}
+function attempt(target, insert) {
+  try {
+    return insert();
+  } catch (error) {
+    console.error(`[ContextMenuV3] ${target} insert failed`, error);
+    return false;
+  }
+}
+function moveEditorCaretToLineEnd(editorId) {
+  const editor = document.querySelector(`[data-editor-id="${editorId}"]`);
+  const selection = window.getSelection();
+  if (!editor || !selection || selection.rangeCount === 0) return;
+  const range = selection.getRangeAt(0);
+  if (!range.collapsed || !editor.contains(range.startContainer)) return;
+  const node = range.startContainer;
+  if (node.nodeType !== Node.TEXT_NODE) return;
+  const text = node.textContent ?? "";
+  const at = (0, import_text_insertion.blockBoundary)(text, range.startOffset, range.startOffset, "nearest");
+  const next = document.createRange();
+  next.setStart(node, at);
+  next.collapse(true);
+  selection.removeAllRanges();
+  selection.addRange(next);
+}
+function ownParagraph(block, field) {
+  const before = field.value.slice(0, field.selectionStart);
+  const after = field.value.slice(field.selectionEnd);
+  const lead = before.length === 0 || before.endsWith("\n\n") ? "" : before.endsWith("\n") ? "\n" : "\n\n";
+  const tail = after.length === 0 || after.startsWith("\n\n") ? "" : after.startsWith("\n") ? "\n" : "\n\n";
+  return `${lead}${block}${tail}`;
+}
+
+// src/engine/hooks/useContextMenuActions.ts
+var import_provider = require("@ai-matrx/rich-content/rich-document/actions/provider");
+var import_menuStructure = require("@ai-matrx/rich-content/rich-document/variants/shared/menuStructure");
+var import_sources = require("@ai-matrx/rich-content/rich-document/actions/sources/index");
+var import_raw = require("@ai-matrx/rich-content/rich-document/actions/sources/raw");
+var import_constants = require("@ai-matrx/chat/agents/shortcuts/constants");
+var import_baseline2 = require("@ai-matrx/chat/surfaces/manifests/_baseline.manifest");
+var import_useSurfaceConfig2 = require("@ai-matrx/chat/surfaces/hooks/useSurfaceConfig");
+var import_useSurfaceBoundAgents = require("@ai-matrx/chat/surfaces/hooks/useSurfaceBoundAgents");
+
+// src/engine/value-resolution.ts
+var import_baseline_scope = require("@ai-matrx/chat/surfaces/utils/baseline-scope");
+var import_baseline = require("@ai-matrx/chat/surfaces/manifests/_baseline.manifest");
+var import_SurfaceRuntimeContext = require("@ai-matrx/chat/surfaces/runtime/SurfaceRuntimeContext");
+var SKIP_MERGE_KEYS = /* @__PURE__ */ new Set([types_exports.CONTEXT_MENU_ENTITY_KEY, types_exports.CONTEXT_MENU_HEADING_KEY]);
+var isDev = process.env.NODE_ENV !== "production";
+function strOf(value) {
+  return typeof value === "string" ? value : "";
+}
+function adoptMountedRuntimeScope(surfaceName) {
+  try {
+    const mounted = surfaceName ? (0, import_SurfaceRuntimeContext.getSurfaceRuntimeForName)(surfaceName) : (0, import_SurfaceRuntimeContext.getSurfaceRuntime)();
+    if (!mounted) return null;
+    const payload = mounted.getScope();
+    if (payload && typeof payload.then === "function")
+      return null;
+    return payload;
+  } catch (err) {
+    if (isDev)
+      console.error(
+        "[ContextMenuV3] mounted SurfaceRuntime threw in getScope() \u2014 menu scope falls back to the surface's own values",
+        err
+      );
+    return null;
+  }
+}
+function isEmptyValue(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (typeof value === "object" && !Array.isArray(value))
+    return Object.keys(value).length === 0;
+  return false;
+}
+function resolveApplicationScope(args) {
+  const base = buildFromMenuContext(args);
+  const surfaceAnswered = new Set(
+    Object.keys(args.contextData ?? {}).filter((k) => !SKIP_MERGE_KEYS.has(k))
+  );
+  if (args.getApplicationScope) {
+    const live = args.getApplicationScope();
+    for (const [k, v] of Object.entries(live)) {
+      if (SKIP_MERGE_KEYS.has(k) || v === void 0) continue;
+      base[k] = v;
+      surfaceAnswered.add(k);
+    }
+  }
+  const runtime = adoptMountedRuntimeScope(args.surfaceName);
+  if (runtime) {
+    for (const [k, v] of Object.entries(runtime)) {
+      if (SKIP_MERGE_KEYS.has(k) || v === void 0) continue;
+      if (surfaceAnswered.has(k)) continue;
+      if (isEmptyValue(base[k])) base[k] = v;
+    }
+  }
+  if (args.ambient && !surfaceAnswered.has("ambient") && isEmptyValue(base.ambient))
+    base.ambient = args.ambient;
+  const hasContent = strOf(base.content).trim().length > 0;
+  if (!args.getApplicationScope && !hasContent && args.fallbackContent && args.fallbackContent.trim()) {
+    base.content = args.fallbackContent;
+  }
+  return (0, import_baseline_scope.withBaselineScope)(base);
+}
+function buildFromMenuContext(args) {
+  const { selectedText, selectionRange, contextData: cd } = args;
+  let textBefore = "";
+  let textAfter = "";
+  let fullContent = "";
+  if (selectionRange && selectionRange.type === "editable" && selectionRange.element) {
+    const value = selectionRange.element.value ?? "";
+    fullContent = value;
+    textBefore = value.substring(0, selectionRange.start ?? 0);
+    textAfter = value.substring(selectionRange.end ?? 0);
+  }
+  const scope = {};
+  for (const [k, v] of Object.entries(cd)) {
+    if (SKIP_MERGE_KEYS.has(k) || v === void 0) continue;
+    scope[k] = v;
+  }
+  if (typeof cd.context === "string") {
+    scope.context = { raw: cd.context };
+  } else if (cd.context !== void 0 && typeof cd.context !== "string") {
+    scope.context = cd.context;
+  } else if (scope.context === void 0) {
+    scope.context = {};
+  }
+  scope.selection = selectedText;
+  scope.text_before = textBefore;
+  scope.text_after = textAfter;
+  if (typeof cd.content === "string") {
+    scope.content = cd.content;
+  } else if (fullContent) {
+    scope.content = fullContent;
+  } else if (scope.content === void 0) {
+    scope.content = "";
+  }
+  const activeText = scope.active_text;
+  if (scope.selection === "" && typeof activeText === "string" && activeText.length > 0) {
+    scope.selection = activeText;
+  }
+  return scope;
+}
+function resolveActionText(scope) {
+  const selection = strOf(scope.selection).trim();
+  if (selection) return { text: strOf(scope.selection), source: "selection" };
+  const content = strOf(scope.content).trim();
+  if (content) return { text: strOf(scope.content), source: "content" };
+  return { text: "", source: "none" };
+}
+function hasActionableContent(scope) {
+  return resolveActionText(scope).source !== "none";
+}
+function detectInertMenu(args) {
+  const reasons = [];
+  const selection = strOf(args.scope.selection).trim();
+  const content = strOf(args.scope.content).trim();
+  const baseline = new Set(
+    import_baseline.BASELINE_VALUE_NAMES
+  );
+  const hasApplicationScope = Object.entries(args.scope).some(
+    ([key, value]) => !baseline.has(key) && !isEmptyValue(value)
+  );
+  if (!selection) reasons.push("no selection");
+  if (!content) reasons.push("no resolvable content (and no DOM-text fallback)");
+  const inert = !args.isEditable && !selection && !content && !hasApplicationScope && !args.hasExtraSections;
+  return { inert, reasons };
+}
+function auditSurfaceScope(surfaceName, scope) {
+  if (!surfaceName) return [];
+  const manifest = getContextMenuHost().getSurfaceManifest(surfaceName);
+  if (!manifest) {
+    return [
+      `surface "${surfaceName}" has no registered manifest \u2014 its declared values cannot be verified`
+    ];
+  }
+  const baseline = new Set(import_baseline.BASELINE_VALUE_NAMES);
+  const warnings = [];
+  for (const value of manifest.values) {
+    if (baseline.has(value.name)) continue;
+    if (!value.alwaysAvailable) continue;
+    const present = scope[value.name];
+    if (!(value.name in scope) || present === void 0 || present === null) {
+      warnings.push(
+        `declared value "${value.name}" is alwaysAvailable but was not emitted into the scope`
+      );
+    }
+  }
+  return warnings;
+}
+function reportMenuDiagnostics(args) {
+  const diag = detectInertMenu(args);
+  if (!isDev) return diag;
+  const label = args.surfaceName ?? "(no surfaceName)";
+  if (diag.inert) {
+    console.error(
+      `%c[ContextMenuV3] INERT MENU on "${label}"%c \u2014 opened with nothing to act on (${diag.reasons.join(
+        ", "
+      )}). This is the "fake menu" defect: the surface must provide a selection, contextData.content, getApplicationScope(), or render selectable content the DOM fallback can read.`,
+      "color:#ef4444;font-weight:bold",
+      "color:inherit",
+      { scopeKeys: Object.keys(args.scope) }
+    );
+  }
+  const valueWarnings = auditSurfaceScope(args.surfaceName, args.scope);
+  if (valueWarnings.length > 0) {
+    console.error(
+      `%c[ContextMenuV3] VALUE MAPPING GAP on "${label}"%c \u2014 ${valueWarnings.join(
+        "; "
+      )}. Shortcuts/agents bound to these values will receive nothing.`,
+      "color:#f59e0b;font-weight:bold",
+      "color:inherit"
+    );
+  }
+  return diag;
+}
+
+// src/engine/utils/selection-write-back.ts
+function isField(el) {
+  return typeof HTMLTextAreaElement !== "undefined" && el instanceof HTMLTextAreaElement || typeof HTMLInputElement !== "undefined" && el instanceof HTMLInputElement;
+}
+function buildSelectionWriteBack(args) {
+  const {
+    originalText,
+    textSource,
+    selectionRange,
+    onTextReplace,
+    onTextInsertAfter,
+    insertAtCaret
+  } = args;
+  if (!originalText) return null;
+  const fieldEl = selectionRange?.type === "editable" && isField(selectionRange.element) ? selectionRange.element : null;
+  if (fieldEl) {
+    let anchorText = originalText;
+    let anchorStart = textSource === "selection" ? selectionRange.start : 0;
+    const locate = () => {
+      if (!fieldEl.isConnected) return null;
+      const value = fieldEl.value;
+      if (value.slice(anchorStart, anchorStart + anchorText.length) === anchorText) {
+        return { start: anchorStart, end: anchorStart + anchorText.length };
+      }
+      const first = value.indexOf(anchorText);
+      if (first === -1 || value.indexOf(anchorText, first + 1) !== -1) {
+        return null;
+      }
+      return { start: first, end: first + anchorText.length };
+    };
+    const write = (start, end, insert) => {
+      const value = fieldEl.value;
+      const next = value.slice(0, start) + insert + value.slice(end);
+      if (onTextReplace) onTextReplace(next);
+      else (0, selection_tracking_exports.spliceInputValue)(fieldEl, start, end, insert);
+    };
+    return {
+      originalText,
+      replace: (text) => {
+        const at = locate();
+        if (!at) return false;
+        write(at.start, at.end, text);
+        anchorStart = at.start;
+        anchorText = text;
+        return true;
+      },
+      insertBelow: (text) => {
+        const at = locate();
+        if (!at) return false;
+        const block = "\n\n" + text;
+        write(at.end, at.end, block);
+        anchorStart = at.end + 2;
+        anchorText = text;
+        return true;
+      }
+    };
+  }
+  if (textSource !== "selection") return null;
+  if (!insertAtCaret && !onTextInsertAfter) return null;
+  return {
+    originalText,
+    replace: (text) => insertAtCaret ? insertAtCaret(text) : false,
+    insertBelow: (text) => {
+      if (!onTextInsertAfter) return false;
+      onTextInsertAfter(text);
+      return true;
+    }
+  };
+}
+
+// src/engine/hooks/useContextMenuActions.ts
+var import_launch_widget_handles = require("@ai-matrx/chat/agents/utils/launch-widget-handles");
+
+// src/engine/managed-agent-launch.ts
+var MANAGED_CONTEXT_MENU_AGENT_CONFIG = {
+  displayMode: "flexible-panel",
+  allowChat: true,
+  showVariablePanel: true
+};
+
+// src/engine/hooks/useContextMenuActions.ts
+var import_domain = require("@ai-matrx/icons/domain");
+var PLACEMENT_LABEL_OVERRIDE = {
+  [import_constants.PLACEMENT_TYPES.USER_TOOL]: "My Items",
+  [import_constants.PLACEMENT_TYPES.ORGANIZATION_TOOL]: "Org Items"
+};
+var PLACEMENT_COLOR = {
+  [import_constants.PLACEMENT_TYPES.AI_ACTION]: "#0ea5e9",
+  [import_constants.PLACEMENT_TYPES.CONTENT_BLOCK]: "#8b5cf6",
+  [import_constants.PLACEMENT_TYPES.ORGANIZATION_TOOL]: "#f59e0b",
+  [import_constants.PLACEMENT_TYPES.USER_TOOL]: "#10b981"
+};
+function getPlacementIcon(placementType) {
+  switch (placementType) {
+    case import_constants.PLACEMENT_TYPES.AI_ACTION:
+      return import_lucide_react.Rocket;
+    case import_constants.PLACEMENT_TYPES.CONTENT_BLOCK:
+      return import_lucide_react.FileText;
+    case import_constants.PLACEMENT_TYPES.ORGANIZATION_TOOL:
+      return import_lucide_react.Building;
+    case import_constants.PLACEMENT_TYPES.USER_TOOL:
+      return import_lucide_react.User;
+    default:
+      return import_lucide_react.FileText;
+  }
+}
+function getPlacementLabel(placementType) {
+  return PLACEMENT_LABEL_OVERRIDE[placementType] ?? import_constants.PLACEMENT_TYPE_META[placementType]?.label ?? placementType;
+}
+function resolveIcon(iconName, fallback = "FileText") {
+  return (0, import_icons.getIconComponent)(iconName ?? fallback, fallback);
+}
+function resolveRichActionView(action, ctx) {
+  const label = typeof action.label === "function" ? action.label(ctx) : action.label;
+  const disabledResult = action.disabled?.(ctx);
+  const disabled = typeof disabledResult === "object" ? true : Boolean(disabledResult);
+  return { label, disabled };
+}
+
+// src/engine/model/menu-model.ts
+var import_domain2 = require("@ai-matrx/icons/domain");
+function withEditInPlace(sections) {
+  if (!(0, import_EditInPlace.hasEditInPlaceTarget)()) return sections;
+  const edit = {
+    kind: "item",
+    id: "edit-in-place",
+    label: "Edit",
+    icon: import_lucide_react2.Pencil,
+    iconClassName: "text-muted-foreground",
+    onSelect: () => void (0, import_EditInPlace.openEditInPlaceFromLastInteraction)()
+  };
+  return [{ id: "edit-in-place", group: "editable", nodes: [edit] }, ...sections];
+}
+function hasActionable(nodes) {
+  return nodes.some((n) => {
+    if (n.kind === "separator" || n.kind === "label") return false;
+    if (n.kind === "submenu") return hasActionable(n.children);
+    return true;
+  });
+}
+function compactNodes(nodes) {
+  return nodes.filter((node) => node !== null);
+}
+function fromExtraItem(item) {
+  const id = `x:${item.id}`;
+  switch (item.kind) {
+    case "separator":
+      return { kind: "separator", id };
+    case "submenu":
+      return {
+        kind: "submenu",
+        id,
+        label: item.label,
+        icon: item.icon,
+        disabled: item.disabled,
+        children: item.children.map(fromExtraItem)
+      };
+    case "checkbox":
+      return {
+        kind: "checkbox",
+        id,
+        label: item.label,
+        icon: item.icon,
+        description: item.description,
+        hint: item.hint,
+        checked: item.checked,
+        disabled: item.disabled,
+        onCheckedChange: item.onCheckedChange
+      };
+    case "link":
+      return {
+        kind: "link",
+        id,
+        label: item.label,
+        icon: item.icon,
+        description: item.description,
+        hint: item.hint,
+        href: item.href,
+        target: item.target,
+        disabled: item.disabled
+      };
+    case "item":
+    default:
+      return {
+        kind: "item",
+        id,
+        label: item.label,
+        icon: item.icon,
+        description: item.description,
+        hint: item.hint,
+        disabled: item.disabled,
+        destructive: item.destructive,
+        onSelect: item.onSelect
+      };
+  }
+}
+function extrasByAnchor(extraSections) {
+  const out = {
+    "after-clipboard": [],
+    "after-compare": [],
+    "after-placements": []
+  };
+  for (const s of extraSections ?? []) {
+    const anchor = s.anchor ?? "after-compare";
+    out[anchor].push({
+      id: `extra:${s.id}`,
+      group: "surface",
+      label: s.label,
+      icon: s.icon,
+      primary: s.primary === true ? true : void 0,
+      nodes: s.items.map(fromExtraItem)
+    });
+  }
+  return out;
+}
+function liftPrimarySections(sections) {
+  const primary = sections.filter((s) => s.primary);
+  if (primary.length === 0) return sections;
+  return [...primary, ...sections.filter((s) => !s.primary)];
+}
+function richActionNode(action, ctx) {
+  const { label, disabled } = resolveRichActionView(action, ctx);
+  return {
+    kind: "item",
+    id: `rich:${action.id}`,
+    label,
+    icon: action.icon,
+    iconClassName: action.iconColor ?? void 0,
+    disabled,
+    onSelect: () => void action.run(ctx)
+  };
+}
+function registryTreeNodes(actions, ctx, aiExtras) {
+  const tree = (0, import_menuStructure2.buildMenuTree)(actions, { aiSlot: aiExtras.length > 0 });
+  const nodes = tree.topLevel.map((a) => richActionNode(a, ctx));
+  for (const sub of (0, import_menuStructure2.withAiSlot)(tree.submenus, aiExtras.length > 0)) {
+    const children = sub.actions.map((a) => richActionNode(a, ctx));
+    const isAi = sub.label === import_menuStructure2.AI_SUBMENU_LABEL;
+    if (isAi && aiExtras.length > 0) {
+      if (children.length > 0) children.push({ kind: "separator", id: "rich-ai:sep" });
+      children.push(...aiExtras);
+    }
+    nodes.push({
+      kind: "submenu",
+      id: `rich-sub:${sub.label.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`,
+      label: sub.label,
+      icon: sub.icon,
+      width: isAi ? "w-64" : void 0,
+      children
+    });
+  }
+  nodes.push(...tree.extras.map((a) => richActionNode(a, ctx)));
+  return nodes;
+}
+function categoryGroupNode(group, m) {
+  const { category, items, children } = group;
+  const children_ = items.map((entry) => {
+    const isDisabled = entry.entryType === "agent_shortcut" && !entry.agentId;
+    const hint = (
+      // Advertised only when the shell's key listener can run it (key-combo.ts).
+      entry.entryType === "agent_shortcut" && entry.keyboardShortcut && parseKeyCombo(entry.keyboardShortcut) ? entry.keyboardShortcut : isDisabled ? "Not configured" : void 0
+    );
+    return {
+      kind: "item",
+      id: `entry:${entry.id}`,
+      label: entry.label,
+      icon: resolveIcon(entry.iconName),
+      // Phase 6.7: there is no "legacy match" row any more. Availability is
+      // derived (requirement-gate.ts) — an item either QUALIFIES here or is
+      // absent. Nothing renders red to advertise a backfill backlog.
+      hint,
+      disabled: isDisabled,
+      onSelect: () => m.handleEntrySelect(entry)
+    };
+  });
+  if (children.length > 0) {
+    if (items.length > 0) children_.push({ kind: "separator", id: `${category.id}:sep` });
+    for (const child of children) children_.push(categoryGroupNode(child, m));
+  }
+  return {
+    kind: "submenu",
+    id: `cat:${category.id}`,
+    label: category.label,
+    icon: resolveIcon(category.iconName),
+    iconStyle: { color: category.color || "currentColor" },
+    disabled: items.length === 0 && children.length === 0,
+    emptyLabel: `No items in ${category.label}`,
+    width: "w-64",
+    children: children_
+  };
+}
+function placementNode(placementType, m) {
+  const mode = m.resolvedPlacementMode[placementType];
+  if (mode === "hide") return null;
+  const groups = m.grouped[placementType] || [];
+  const hasCategories = groups.length > 0;
+  const label = getPlacementLabel(placementType);
+  const color = PLACEMENT_COLOR[placementType];
+  if (!hasCategories && m.librariesError && mode !== "disable") {
+    return failedLibraryNode(`placement:${placementType}`, label, getPlacementIcon(placementType), m, placementType);
+  }
+  return {
+    kind: "submenu",
+    id: `placement:${placementType}`,
+    label,
+    icon: getPlacementIcon(placementType),
+    iconStyle: color ? { color } : void 0,
+    disabled: mode === "disable" || !hasCategories,
+    loading: m.loading && !hasCategories,
+    emptyLabel: `No ${label}`,
+    width: "w-64",
+    placement: placementType,
+    children: groups.map((g) => categoryGroupNode(g, m))
+  };
+}
+function failedLibraryNode(id, label, icon4, m, placement) {
+  return {
+    kind: "submenu",
+    id,
+    label,
+    icon: icon4,
+    width: "w-64",
+    placement,
+    children: [
+      {
+        kind: "item",
+        id: `${id}:retry`,
+        label: "Couldn't load. Retry",
+        icon: import_lucide_react2.RotateCcw,
+        keepsMenuOpen: true,
+        onSelect: m.retryLibraries
+      }
+    ]
+  };
+}
+function boundAgentsNode(m) {
+  const mode = m.resolvedPlacementMode["bound-agent"];
+  if (mode === "hide") return null;
+  const sections = m.boundAgentSections.filter((s) => s.agents.length > 0);
+  const hasAgents = sections.length > 0;
+  if (!hasAgents && m.boundAgentsError && !m.boundAgentsLoading && mode !== "disable") {
+    return failedLibraryNode("placement:bound-agent", "Agents", import_domain2.AGENT_ICON, m, "bound-agent");
+  }
+  const children = [];
+  sections.forEach((section, idx) => {
+    if (idx > 0) children.push({ kind: "separator", id: `agents:${section.key}:sep` });
+    children.push({
+      kind: "label",
+      id: `agents:${section.key}:label`,
+      label: section.label.toUpperCase()
+    });
+    for (const agent of section.agents) {
+      children.push({
+        kind: "item",
+        id: `agent:${section.key}:${agent.agentId}`,
+        label: agent.name,
+        icon: import_domain2.AGENT_ICON,
+        iconClassName: "text-indigo-500/80",
+        onSelect: () => void m.handleBoundAgentExecute(agent)
+      });
+    }
+  });
+  return {
+    kind: "submenu",
+    id: "placement:bound-agent",
+    label: "Agents",
+    icon: import_domain2.AGENT_ICON,
+    iconClassName: "text-indigo-500",
+    disabled: mode === "disable" || !hasAgents && !m.boundAgentsLoading,
+    loading: m.boundAgentsLoading,
+    emptyLabel: m.boundAgentsLoading && !hasAgents ? "Loading\u2026" : "No agents available",
+    width: "w-64",
+    placement: "bound-agent",
+    children
+  };
+}
+function buildMenuModel(m, props) {
+  const {
+    extraSections,
+    isEditable,
+    onSave,
+    onDelete,
+    onUndo,
+    onRedo,
+    canUndo,
+    canRedo,
+    undoHint,
+    redoHint,
+    onViewHistory,
+    hasHistory,
+    selectedText,
+    entity,
+    selectionRange,
+    getTextarea,
+    recordActionsOnly = false
+  } = props;
+  const { actionText, quickActions } = m;
+  const header = actionText.source === "selection" ? { label: "Selected", text: actionText.text } : actionText.source === "content" ? { label: "Content", text: actionText.text } : null;
+  const copy = {
+    kind: "item",
+    id: "copy",
+    label: "Copy",
+    icon: import_lucide_react2.Copy,
+    iconClassName: "text-emerald-500",
+    disabled: actionText.source === "none",
+    onSelect: () => void m.handleCopy()
+  };
+  const speak = {
+    kind: "item",
+    id: "speak",
+    label: "Speak",
+    icon: import_lucide_react2.Volume2,
+    iconClassName: "text-sky-500",
+    disabled: actionText.source === "none",
+    onSelect: m.handleSpeak
+  };
+  const listenDisabled = actionText.source === "none" || !m.spokenSummaryAvailable;
+  const hasRegistry = m.registryActions.length > 0;
+  const spokenSummary = {
+    kind: "item",
+    id: "spoken-summary",
+    label: "Summarize without playing",
+    icon: import_lucide_react2.Headphones,
+    iconClassName: "text-violet-500",
+    disabled: listenDisabled,
+    onSelect: m.handleSpokenSummary
+  };
+  const spokenSummaryLive = {
+    kind: "item",
+    id: "spoken-summary-live",
+    label: "Summarize & listen",
+    icon: import_lucide_react2.AudioLines,
+    iconClassName: "text-violet-500",
+    disabled: listenDisabled,
+    onSelect: m.handleSpokenSummaryLive
+  };
+  const listen = hasRegistry ? null : {
+    kind: "submenu",
+    id: "listen",
+    label: "Listen",
+    icon: import_lucide_react2.Headphones,
+    iconClassName: "text-violet-500",
+    disabled: listenDisabled,
+    children: [spokenSummary, spokenSummaryLive]
+  };
+  const copyAs = !hasRegistry && m.copyVariantActions.length > 0 ? {
+    kind: "submenu",
+    id: "copy-as",
+    label: "Copy as",
+    icon: import_lucide_react2.Copy,
+    iconClassName: "text-emerald-500",
+    children: m.copyVariantActions.map((a) => richActionNode(a, m.richDocCtx))
+  } : null;
+  const json = m.jsonSection ? {
+    kind: "submenu",
+    id: "json",
+    label: jsonSectionLabel(m.jsonSection),
+    icon: import_lucide_react2.Braces,
+    iconClassName: "text-amber-500",
+    width: "w-72",
+    children: m.jsonSection.actions.map((action) => ({
+      kind: "item",
+      id: `json:${action.id}`,
+      label: action.label,
+      hint: action.hint,
+      disabled: action.disabled,
+      onSelect: () => void action.run()
+    }))
+  } : null;
+  const cut = {
+    kind: "item",
+    id: "cut",
+    label: "Cut",
+    icon: import_lucide_react2.Scissors,
+    iconClassName: "text-emerald-500",
+    disabled: !isEditable || !selectedText,
+    onSelect: () => void m.handleCut()
+  };
+  const paste = {
+    kind: "item",
+    id: "paste",
+    label: "Paste",
+    icon: import_lucide_react2.Clipboard,
+    iconClassName: "text-emerald-500",
+    disabled: !isEditable,
+    onSelect: () => void m.handlePaste()
+  };
+  const selectAll = {
+    kind: "item",
+    id: "select-all",
+    label: "Select All",
+    icon: import_lucide_react2.Type,
+    iconClassName: "text-muted-foreground",
+    // Select All acts on a captured selection's container, or an editable
+    // surface's own field. With neither (right-click on a table row or on
+    // read-only content without selecting) it would do nothing — a dead row,
+    // so it is absent (R1 b), not offered.
+    disabled: !selectionRange && !(isEditable && getTextarea),
+    onSelect: m.handleSelectAll
+  };
+  const find = {
+    kind: "item",
+    id: "find",
+    label: "Find & Replace",
+    icon: import_lucide_react2.Search,
+    iconClassName: "text-muted-foreground",
+    onSelect: m.handleFind
+  };
+  const insertReference = {
+    kind: "item",
+    id: "insert-reference",
+    label: isEditable ? "Insert reference\u2026" : "Copy reference\u2026",
+    icon: import_lucide_react2.AtSign,
+    iconClassName: "text-primary",
+    onSelect: m.handleInsertReference
+  };
+  const chat = {
+    kind: "item",
+    id: "chat",
+    label: "Chat",
+    icon: import_lucide_react2.MessageSquare,
+    iconClassName: "text-primary",
+    onSelect: () => quickActions.openChatWindow()
+  };
+  const undo = {
+    kind: "item",
+    id: "undo",
+    label: "Undo",
+    icon: import_lucide_react2.Undo2,
+    iconClassName: "text-sky-500",
+    hint: undoHint,
+    disabled: onUndo ? !canUndo : !m.canNativeUndo,
+    onSelect: m.handleUndo
+  };
+  const redo = {
+    kind: "item",
+    id: "redo",
+    label: "Redo",
+    icon: import_lucide_react2.Redo2,
+    iconClassName: "text-sky-500",
+    hint: redoHint,
+    disabled: onRedo ? !canRedo : !m.canNativeUndo,
+    onSelect: m.handleRedo
+  };
+  const viewHistory = {
+    kind: "item",
+    id: "view-history",
+    label: "View History",
+    icon: import_lucide_react2.History,
+    iconClassName: "text-violet-500",
+    disabled: !onViewHistory || !hasHistory,
+    onSelect: () => onViewHistory?.()
+  };
+  const compare = hasRegistry ? null : {
+    kind: "submenu",
+    id: "compare",
+    label: "Compare",
+    icon: import_lucide_react2.GitCompareArrows,
+    iconClassName: "text-amber-500",
+    children: [
+      {
+        kind: "item",
+        id: "compare:clipboard",
+        label: "Compare with clipboard",
+        icon: import_lucide_react2.Clipboard,
+        onSelect: () => void m.handleCompareClipboard()
+      },
+      {
+        kind: "item",
+        id: "compare:set-base",
+        label: "Set as compare base",
+        icon: import_lucide_react2.Pin,
+        description: actionText.source === "selection" ? "Use selection" : "Use content",
+        onSelect: m.handleSetCompareBase
+      },
+      {
+        kind: "item",
+        id: "compare:with-base",
+        label: "Compare with base",
+        icon: import_lucide_react2.GitCompareArrows,
+        description: m.hasCompareBase ? void 0 : "No base set yet",
+        disabled: !m.hasCompareBase,
+        onSelect: () => void m.handleCompareWithBase()
+      }
+    ]
+  };
+  const exportMenu = !hasRegistry && m.exportActions.length > 0 ? {
+    kind: "submenu",
+    id: "export",
+    label: "Export",
+    icon: import_lucide_react2.Download,
+    iconClassName: "text-amber-500",
+    children: m.exportActions.map((a) => richActionNode(a, m.richDocCtx))
+  } : null;
+  const convert = !hasRegistry && m.convertActions.length > 0 ? {
+    kind: "submenu",
+    id: "convert",
+    label: "Convert",
+    icon: import_lucide_react2.Replace,
+    iconClassName: "text-violet-500",
+    children: m.convertActions.map((a) => richActionNode(a, m.richDocCtx))
+  } : null;
+  const attach = entity ? {
+    kind: "item",
+    id: "attach",
+    label: "Attach To",
+    icon: import_lucide_react2.Link2,
+    iconClassName: "text-sky-500",
+    onSelect: m.handleAttach
+  } : null;
+  const linkRecord = entity ? {
+    kind: "item",
+    id: "link-record",
+    label: "Link a record\u2026",
+    icon: import_lucide_react2.Link,
+    iconClassName: "text-sky-500",
+    onSelect: m.handleLinkRecord
+  } : null;
+  const share = entity?.resourceType ? {
+    kind: "item",
+    id: "share",
+    label: "Share",
+    icon: import_lucide_react2.Share2,
+    iconClassName: "text-emerald-500",
+    onSelect: m.handleShare
+  } : null;
+  const libraryNodes = [
+    placementNode(import_constants2.PLACEMENT_TYPES.AI_ACTION, m),
+    boundAgentsNode(m),
+    placementNode(import_constants2.PLACEMENT_TYPES.CONTENT_BLOCK, m),
+    placementNode(import_constants2.PLACEMENT_TYPES.USER_TOOL, m),
+    placementNode(import_constants2.PLACEMENT_TYPES.ORGANIZATION_TOOL, m)
+  ].filter((n) => n !== null);
+  const registry2 = hasRegistry ? registryTreeNodes(m.registryActions, m.richDocCtx, libraryNodes) : null;
+  const placements = hasRegistry ? [] : libraryNodes;
+  const quickMode = m.resolvedPlacementMode["quick-action"];
+  const quick = quickMode === "hide" ? null : {
+    kind: "submenu",
+    id: "quick-actions",
+    label: "Quick Actions",
+    icon: import_lucide_react2.Zap,
+    iconClassName: "text-pink-500",
+    disabled: quickMode === "disable",
+    width: "w-56",
+    children: [
+      { kind: "item", id: "qa:notes", label: "Notes", icon: import_lucide_react2.StickyNote, onSelect: () => quickActions.openQuickNotes() },
+      { kind: "item", id: "qa:tasks", label: "Tasks", icon: import_lucide_react2.CheckSquare, onSelect: () => quickActions.openQuickTasks() },
+      { kind: "item", id: "qa:chat", label: "Chat", icon: import_lucide_react2.MessageSquare, onSelect: () => quickActions.openQuickChat() },
+      { kind: "item", id: "qa:data", label: "Data", icon: import_lucide_react2.Database, onSelect: () => quickActions.openQuickData() },
+      { kind: "item", id: "qa:files", label: "Files", icon: import_lucide_react2.FolderOpen, onSelect: () => quickActions.openQuickFiles() },
+      { kind: "item", id: "qa:voice", label: "Voice Input", icon: import_lucide_react2.Mic, onSelect: () => quickActions.openVoicePad() }
+    ]
+  };
+  const save = isEditable && onSave ? {
+    kind: "item",
+    id: "save",
+    label: "Save",
+    icon: import_lucide_react2.Save,
+    iconClassName: "text-emerald-500",
+    onSelect: () => onSave()
+  } : null;
+  const del = isEditable && onDelete ? {
+    kind: "item",
+    id: "delete",
+    label: "Delete",
+    icon: import_lucide_react2.Trash2,
+    destructive: true,
+    onSelect: () => void m.handleDelete()
+  } : null;
+  const admin = m.isAdmin ? {
+    kind: "submenu",
+    id: "admin",
+    label: "Admin Tools",
+    icon: import_lucide_react2.Shield,
+    iconClassName: "text-rose-500",
+    width: "w-56",
+    children: [
+      {
+        kind: "item",
+        id: "admin:debug",
+        label: `${m.isDebugMode ? "Disable" : "Enable"} Debug Mode`,
+        icon: m.isDebugMode ? import_lucide_react2.EyeOff : import_lucide_react2.Eye,
+        iconClassName: m.isDebugMode ? "text-amber-600 dark:text-amber-400" : void 0,
+        onSelect: m.handleToggleDebugMode
+      },
+      {
+        kind: "item",
+        id: "admin:values",
+        label: "Context Values",
+        icon: import_lucide_react2.Bug,
+        className: "text-amber-600 dark:text-amber-400",
+        onSelect: m.handleInspectValues
+      },
+      ...m.isDebugMode ? [
+        {
+          kind: "item",
+          id: "admin:state",
+          label: "Redux State",
+          icon: import_lucide_react2.Database,
+          className: "text-amber-600 dark:text-amber-400",
+          onSelect: m.handleInspectState
+        }
+      ] : [],
+      { kind: "separator", id: "admin:sep" },
+      {
+        kind: "item",
+        id: "admin:indicator",
+        label: `${m.isAdminIndicatorOpen ? "Hide" : "Show"} Admin Indicator`,
+        icon: m.isAdminIndicatorOpen ? import_lucide_react2.Eye : import_lucide_react2.EyeOff,
+        iconClassName: m.isAdminIndicatorOpen ? "text-green-600 dark:text-green-400" : void 0,
+        onSelect: m.handleToggleAdminIndicator
+      }
+    ]
+  } : null;
+  const extras = extrasByAnchor(extraSections);
+  const surfaceInfo = {
+    id: "surface-info",
+    group: "surface-info",
+    nodes: m.surfaceSection.items.map(fromExtraItem)
+  };
+  if (recordActionsOnly) {
+    const recordSections = [];
+    const recordHasDocument = hasRegistry && m.richDocCtx?.source?.type !== "raw";
+    const clipboardRecord = compactNodes([recordHasDocument ? copy : null, recordHasDocument ? copyAs : null, recordHasDocument ? json : null]);
+    if (clipboardRecord.length > 0) {
+      recordSections.push({ id: "clipboard", group: "clipboard", nodes: clipboardRecord });
+    }
+    if (registry2 && recordHasDocument) recordSections.push({ id: "registry", group: "document", nodes: registry2 });
+    recordSections.push(...extras["after-clipboard"]);
+    if (recordHasDocument && (exportMenu || convert)) {
+      recordSections.push({ id: "document-out", group: "document", nodes: compactNodes([exportMenu, convert]) });
+    }
+    if (attach || linkRecord || share) {
+      recordSections.push({ id: "share", group: "share", nodes: compactNodes([attach, linkRecord, share]) });
+    }
+    recordSections.push(...extras["after-compare"]);
+    recordSections.push(...extras["after-placements"]);
+    if (save || del) recordSections.push({ id: "editable", group: "editable", nodes: compactNodes([save, del]) });
+    if (admin) recordSections.push({ id: "admin", group: "admin", nodes: [admin] });
+    recordSections.push(surfaceInfo);
+    return {
+      header,
+      sections: withEditInPlace(liftPrimarySections(recordSections)),
+      roles: {
+        copy,
+        speak,
+        listen: null,
+        copyAs,
+        json,
+        cut,
+        paste,
+        selectAll,
+        find,
+        insertReference,
+        chat,
+        undo,
+        redo,
+        viewHistory,
+        compare: null,
+        exportMenu,
+        convert,
+        attach,
+        linkRecord,
+        share,
+        placements: [],
+        registry: registry2,
+        quickActions: null,
+        save,
+        del,
+        admin,
+        extras,
+        surfaceInfo
+      }
+    };
+  }
+  const sections = [];
+  sections.push({
+    id: "clipboard",
+    group: "clipboard",
+    nodes: compactNodes([
+      copy,
+      speak,
+      listen,
+      copyAs,
+      json,
+      cut,
+      paste,
+      selectAll,
+      find,
+      insertReference
+    ])
+  });
+  if (registry2) sections.push({ id: "registry", group: "document", nodes: registry2 });
+  sections.push(...extras["after-clipboard"]);
+  sections.push({ id: "tools", group: "tools", nodes: [chat] });
+  sections.push({
+    id: "history",
+    group: "history",
+    nodes: compactNodes([undo, redo, viewHistory])
+  });
+  if (compare) sections.push({ id: "compare", group: "tools", nodes: [compare] });
+  if (exportMenu || convert) {
+    sections.push({ id: "document-out", group: "document", nodes: compactNodes([exportMenu, convert]) });
+  }
+  if (attach || linkRecord || share) {
+    sections.push({ id: "share", group: "share", nodes: compactNodes([attach, linkRecord, share]) });
+  }
+  sections.push(...extras["after-compare"]);
+  if (placements.length > 0) sections.push({ id: "placements", group: "ai", nodes: placements });
+  sections.push(...extras["after-placements"]);
+  if (quick) {
+    sections.push({
+      id: "quick",
+      group: "quick",
+      joinPrevious: extras["after-placements"].length === 0,
+      nodes: [quick]
+    });
+  }
+  if (save || del) {
+    sections.push({
+      id: "editable",
+      group: "editable",
+      nodes: compactNodes([save, del])
+    });
+  }
+  if (admin) sections.push({ id: "admin", group: "admin", nodes: [admin] });
+  sections.push(surfaceInfo);
+  return {
+    header,
+    sections: withEditInPlace(liftPrimarySections(sections)),
+    roles: {
+      copy,
+      speak,
+      listen,
+      copyAs,
+      json,
+      cut,
+      paste,
+      selectAll,
+      find,
+      insertReference,
+      chat,
+      undo,
+      redo,
+      viewHistory,
+      compare,
+      exportMenu,
+      convert,
+      attach,
+      linkRecord,
+      share,
+      placements,
+      registry: registry2,
+      quickActions: quick,
+      save,
+      del,
+      admin,
+      extras,
+      surfaceInfo
+    }
+  };
+}
+
+// src/engine/table-row-item.ts
+var import_declare = require("@ai-matrx/alchemy/declare");
+var import_surface = require("@ai-matrx/alchemy/surface");
+var TableRowMenu = class {
+  constructor(descriptor) {
+    this.descriptor = descriptor;
+  }
+  descriptor;
+};
+function createTableRowMenuDescriptor(descriptor) {
+  return new TableRowMenu(descriptor);
+}
+function isCommand(value) {
+  return typeof value === "function";
+}
+function tableRowEditCommands(controls) {
+  if (typeof controls !== "object" || controls === null) return {};
+  const read = (key) => {
+    const value = Reflect.get(controls, key);
+    return isCommand(value) ? value : void 0;
+  };
+  return compact({
+    beginEdit: read("beginEdit"),
+    saveEdits: read("saveEdits"),
+    cancelEdits: read("cancelEdits")
+  });
+}
+function createDefaultTableRowMenuDescriptor(payload) {
+  if (payload.level !== "row") return null;
+  return createTableRowMenuDescriptor(
+    buildDefaultTableRowMenuDescriptor(
+      payload.row,
+      tableRowEditCommands(payload.controls)
+    )
+  );
+}
+function buildDefaultTableRowMenuDescriptor(row, controls) {
+  const items = [
+    ...controls.beginEdit ? [{ kind: "item", id: "table-edit-row", label: "Edit row", onSelect: controls.beginEdit }] : [],
+    ...controls.saveEdits ? [{ kind: "item", id: "table-save-row", label: "Save changes", onSelect: () => void controls.saveEdits?.() }] : [],
+    ...controls.cancelEdits ? [{ kind: "item", id: "table-discard-row", label: "Discard changes", onSelect: controls.cancelEdits }] : []
+  ];
+  return {
+    context: {
+      content: JSON.stringify(row, null, 2) ?? String(row),
+      context: row,
+      __entity: null
+    },
+    extraSections: items.length === 0 ? [] : [{ id: "table-row", label: "Row", primary: true, anchor: "after-clipboard", items }]
+  };
+}
+function rowElement(tableId, rowId) {
+  if (typeof document === "undefined") return null;
+  const table = Array.from(document.querySelectorAll("[data-matrx-table-id]")).find((el) => el.dataset.matrxTableId === tableId);
+  return Array.from(table?.querySelectorAll("[data-row-id]") ?? []).find((el) => el.dataset.rowId === rowId) ?? null;
+}
+function rowIsReadOnly(descriptor) {
+  return !descriptor.extraSections.some((section) => section.items.some((item) => "id" in item && item.id === "table-edit-row"));
+}
+function registerTableRowContextResolver(tableId, resolve) {
+  return import_surface.itemSources.register(tableId, (target) => {
+    const token = resolve({
+      tableId,
+      level: target.level,
+      ...target.itemId ? { rowId: target.itemId } : {},
+      ...target.partId ? { columnId: target.partId } : {}
+    });
+    if (!(token instanceof TableRowMenu)) return null;
+    const descriptor = token.descriptor;
+    const rowId = target.itemId ?? "";
+    return {
+      item: {
+        itemType: import_declare.TABLE_ROW_ITEM,
+        identity: { table_id: tableId, row_id: rowId },
+        level: target.level,
+        readOnly: rowIsReadOnly(descriptor),
+        readValues: async () => ({
+          table_id: tableId,
+          row_id: rowId,
+          shown: shownWords(rowElement(tableId, rowId)),
+          row: descriptor.context.context
+        })
+      },
+      host: descriptor
+    };
+  });
+}
+function resolveTableRowItem(target) {
+  const row = target?.closest("[data-row-id]");
+  const tableId = row?.closest("[data-matrx-table-id]")?.dataset.matrxTableId;
+  const rowId = row?.dataset.rowId;
+  if (!tableId || !rowId) return null;
+  const hit = import_surface.itemSources.resolve({ containerId: tableId, level: "row", itemId: rowId });
+  const descriptor = hit?.host ?? null;
+  if (!hit || !descriptor) return null;
+  const { readValues: _raw, ...item } = hit.item;
+  return { item, menu: headedMenu(descriptor, target, row) };
+}
+function resolveTableRowMenuDescriptor(target) {
+  return resolveTableRowItem(target)?.menu ?? null;
+}
+function headedMenu(descriptor, target, row) {
+  const cell = target?.closest("td, [role='gridcell']");
+  const shown = shownWords(cell ?? row);
+  const ownHeading = descriptor.context[types_exports.CONTEXT_MENU_HEADING_KEY];
+  const recordName = ownHeading ? "" : rowRecordName(row);
+  const context = {
+    ...descriptor.context,
+    ...shown ? { content: shown } : {},
+    ...recordName ? { [types_exports.CONTEXT_MENU_HEADING_KEY]: { label: "Row", text: recordName } } : {}
+  };
+  const headed = ownHeading?.text ?? recordName;
+  const same = (label) => typeof headed === "string" && !!label && label.trim().toLowerCase() === headed.trim().toLowerCase();
+  const extraSections = descriptor.extraSections.map(
+    (section) => section.primary && same(section.label) ? { ...section, label: "Row" } : section
+  );
+  const changedSections = extraSections.some((section, i) => section !== descriptor.extraSections[i]);
+  return shown || recordName || changedSections ? { ...descriptor, context, extraSections } : descriptor;
+}
+function rowRecordName(row) {
+  if (!row) return "";
+  for (const cell of Array.from(row.querySelectorAll("td[data-matrx-table-column-id], [role='gridcell'][data-matrx-table-column-id]"))) {
+    const words = primaryLine(cell);
+    if (words) return words.length > 120 ? `${words.slice(0, 119)}\u2026` : words;
+  }
+  return "";
+}
+var LINE_BREAKING = "div, p, li, br, tr, h1, h2, h3, h4, h5, h6, section, article, header, footer, dd, dt";
+function primaryLine(element) {
+  const copy = element.cloneNode(true);
+  copy.querySelectorAll("button, [aria-hidden='true'], input, textarea, select").forEach((node) => node.remove());
+  copy.querySelectorAll(LINE_BREAKING).forEach((node) => node.before("\n"));
+  const lines = (copy.textContent ?? "").split("\n").map((line) => line.replace(/\s+/g, " ").trim()).filter((line) => line && line !== "\u2014");
+  return lines[0] ?? "";
+}
+function shownWords(element) {
+  if (!element) return "";
+  const cells = element.querySelectorAll("td, [role='gridcell']");
+  const text = cells.length > 1 ? Array.from(cells).map(primaryLine).filter(Boolean).join(" \xB7 ") : primaryLine(element);
+  return text.length > 200 ? `${text.slice(0, 199)}\u2026` : text;
+}
+
+// src/engine/regroup/grouping.ts
+var import_menu = require("@ai-matrx/alchemy/menu");
+var REGROUP_ID_PREFIX = "regroup:";
+function actionLabel(action, target) {
+  try {
+    return typeof action.label === "function" ? action.label(target) : action.label;
+  } catch {
+    return action.id;
+  }
+}
+function isPageOwn(action) {
+  const section = action.section;
+  return Boolean(section && (section.primary || section.kind === "target"));
+}
+function labelOf(action, target) {
+  if (typeof action.label === "string") return action.label;
+  return target ? actionLabel(action, target) : "";
+}
+function ruleMatches(rule, action, target) {
+  const w = rule.when;
+  if (w.pageOwnLabels && isPageOwn(action)) {
+    const label = labelOf(action, target);
+    if (label && w.pageOwnLabels.some((p) => new RegExp(p, "i").test(label))) return true;
+  }
+  if (w.ids?.includes(action.id)) return true;
+  if (w.idPrefixes?.some((p) => action.id.startsWith(p))) return true;
+  if (w.categories?.includes(action.category)) return true;
+  if (w.pageOwn && isPageOwn(action)) return true;
+  return false;
+}
+function matchRule(grouping, action, target) {
+  return grouping.rules.find((r) => ruleMatches(r, action, target)) ?? null;
+}
+function destinationFor(grouping, action, target) {
+  return matchRule(grouping, action, target)?.to ?? grouping.fallback;
+}
+var sameName = (label) => label.toLowerCase().replace(/[….]+$/g, "").replace(/\s+/g, " ").trim();
+function drawnOrder(model) {
+  const order = /* @__PURE__ */ new Map();
+  const walk = (nodes) => {
+    for (const n of nodes) {
+      if (!order.has(n.id)) order.set(n.id, order.size);
+      if (n.kind === "submenu") walk(n.children);
+    }
+  };
+  for (const s of model.sections) walk(s.nodes);
+  return order;
+}
+function currentModel(target, resolved) {
+  return (0, import_menu.buildMenuModel)(target, resolved, { headingPolicy: "inline" });
+}
+function regroupResolved(target, resolved, grouping, options) {
+  const order = drawnOrder(currentModel(target, resolved));
+  const pos = (r) => order.get(r.action.id) ?? Number.MAX_SAFE_INTEGER;
+  const groupDef = new Map(grouping.groups.map((g) => [g.key, g]));
+  const top = [];
+  const home = /* @__PURE__ */ new Map();
+  const wanted = /* @__PURE__ */ new Map();
+  const present = new Map(resolved.map((r) => [r.action.id, r]));
+  const twinOf = (r) => {
+    const rule = matchRule(grouping, r.action, target);
+    for (const id of rule?.mergeWithIds ?? []) {
+      const twin = present.get(id);
+      if (twin && twin !== r) return twin;
+    }
+    return null;
+  };
+  const mergedInto = /* @__PURE__ */ new Map();
+  const pageVersionOf = /* @__PURE__ */ new Map();
+  for (const r of resolved) {
+    if (r.action.expand) continue;
+    const twin = twinOf(r);
+    if (!twin || pageVersionOf.has(twin.action.id)) continue;
+    mergedInto.set(r.action.id, twin);
+    pageVersionOf.set(twin.action.id, r);
+  }
+  const withPageHandler = (r) => {
+    const page = pageVersionOf.get(r.action.id);
+    if (!page) return r;
+    const { href: _generalHref, ...general } = r.action;
+    void _generalHref;
+    const action = {
+      ...general,
+      run: page.action.run,
+      ...page.action.href !== void 0 ? { href: page.action.href } : {}
+    };
+    return { ...r, action };
+  };
+  for (const original of resolved) {
+    if (mergedInto.has(original.action.id)) continue;
+    const r = withPageHandler(original);
+    const to = destinationFor(grouping, r.action, target);
+    if (to.kind === "group" && groupDef.has(to.key)) {
+      if (r.eligibility.status !== "available") {
+        top.push(r);
+        home.set(r.action.id, { kind: "top", note: "greyed here, so it stays visible with its reason" });
+        continue;
+      }
+      const list = wanted.get(to.key) ?? [];
+      list.push(r);
+      wanted.set(to.key, list);
+      continue;
+    }
+    if (to.kind === "page-first") {
+      const section = r.action.section;
+      top.push(
+        section ? { ...r, action: { ...r.action, section: { ...section, primary: true } } } : r
+      );
+      home.set(r.action.id, { kind: "page-first" });
+      continue;
+    }
+    top.push(r);
+    home.set(r.action.id, { kind: "top" });
+  }
+  const members = /* @__PURE__ */ new Map();
+  const groupActions = [];
+  for (const def of grouping.groups) {
+    const list = (wanted.get(def.key) ?? []).slice().sort((a, b) => pos(a) - pos(b));
+    if (list.length === 0) continue;
+    if (list.length < grouping.minMembers) {
+      for (const r of list) {
+        top.push(r);
+        home.set(r.action.id, { kind: "top", note: `the only row for ${def.label}` });
+      }
+      continue;
+    }
+    const kept = [];
+    const byName = /* @__PURE__ */ new Map();
+    for (const r of list) {
+      const name = sameName(actionLabel(r.action, target));
+      const first = options.mergeSameName ? byName.get(name) : void 0;
+      if (first) {
+        home.set(r.action.id, {
+          kind: "merged",
+          intoId: first.action.id,
+          intoLabel: actionLabel(first.action, target),
+          groupLabel: def.label
+        });
+        continue;
+      }
+      byName.set(name, r);
+      kept.push(r);
+      home.set(r.action.id, { kind: "group", key: def.key, label: def.label });
+    }
+    members.set(def.key, kept);
+    const children = kept.map((r) => r.action);
+    const submenu2 = {
+      id: `${REGROUP_ID_PREFIX}${def.key}`,
+      label: def.label,
+      category: def.category,
+      order: def.order,
+      ...def.icon ? { icon: def.icon } : {},
+      // Still loading at the source when any member is.
+      pending: (t) => children.some((c) => Boolean(c.expand && c.pending?.(t))),
+      eligible: () => ({ status: "available" }),
+      expand: async () => children,
+      run: () => void 0
+    };
+    groupActions.push({ action: submenu2, eligibility: { status: "available" } });
+  }
+  for (const [id, twin] of mergedInto) {
+    const at = home.get(twin.action.id);
+    home.set(id, {
+      kind: "merged",
+      intoId: twin.action.id,
+      intoLabel: actionLabel(twin.action, target),
+      groupLabel: at?.kind === "group" ? at.label : at?.kind === "merged" ? at.groupLabel : "",
+      pageActionKept: true
+    });
+  }
+  return { resolved: [...top, ...groupActions], members, home };
+}
+function drawnPlaces(model, arrangement) {
+  const arranged = (0, import_menu.context)(model, arrangement);
+  const places = /* @__PURE__ */ new Map();
+  for (const leaf of arranged.strip) places.set(leaf.actionId ?? leaf.id, "Icon strip");
+  arranged.sections.forEach((section, index) => {
+    const heading = section.label ? `"${section.label}" section` : "";
+    for (const node of section.nodes) {
+      if (node.kind === "separator" || node.kind === "label") continue;
+      if (node.kind === "submenu" && node.id.endsWith(":fold")) {
+        for (const child of node.children) {
+          if (child.kind === "separator" || child.kind === "label") continue;
+          places.set(child.actionId ?? child.id, `${node.label} \u25B8`);
+        }
+        continue;
+      }
+      places.set(node.actionId ?? node.id, heading ? `Top level \xB7 ${heading}` : index === 0 && section.primary ? "Top level \xB7 first" : "Top level");
+    }
+  });
+  return places;
+}
+function topLevelRowCount(model, arrangement) {
+  const arranged = (0, import_menu.context)(model, arrangement);
+  let rows = arranged.strip.length > 0 ? 1 : 0;
+  for (const section of arranged.sections) {
+    rows += section.nodes.filter((n) => n.kind !== "separator" && n.kind !== "label").length;
+  }
+  return rows;
+}
+function auditRegroup(target, resolved, grouping, options, arrangement, regroup = regroupResolved) {
+  const result = regroup(target, resolved, grouping, options);
+  const current = currentModel(target, resolved);
+  const proposed = currentModel(target, result.resolved);
+  const currentPlaces = drawnPlaces(current, arrangement);
+  const proposedPlaces = drawnPlaces(proposed, arrangement);
+  const held = /* @__PURE__ */ new Set();
+  for (const r of result.resolved) if (!r.action.id.startsWith(REGROUP_ID_PREFIX)) held.add(r.action.id);
+  for (const list of result.members.values()) for (const r of list) held.add(r.action.id);
+  const rows = resolved.map((r) => {
+    const home = result.home.get(r.action.id) ?? null;
+    let proposedPlace = "";
+    if (held.has(r.action.id)) {
+      proposedPlace = home?.kind === "group" ? `${home.label} \u25B8` : proposedPlaces.get(r.action.id) ?? "Top level";
+    } else if (home?.kind === "merged" && held.has(home.intoId)) {
+      proposedPlace = home.groupLabel ? `${home.groupLabel} \u25B8 ${home.intoLabel}` : `Top level \xB7 ${home.intoLabel}`;
+    }
+    return {
+      id: r.action.id,
+      label: actionLabel(r.action, target),
+      category: r.action.category,
+      isSubmenu: Boolean(r.action.expand),
+      pageOwn: isPageOwn(r.action),
+      current: currentPlaces.get(r.action.id) ?? "Top level",
+      proposed: proposedPlace ? home : null,
+      proposedPlace
+    };
+  });
+  return {
+    rows,
+    lost: rows.filter((row) => !row.proposedPlace),
+    currentRows: topLevelRowCount(current, arrangement),
+    proposedRows: topLevelRowCount(proposed, arrangement)
+  };
+}
+
+// src/engine/regroup/engine-rows.ts
+var CONTEXT_MENU_ENGINE_ROWS = [
+  { id: "cm:copy", label: "Copy", category: "clipboard" },
+  { id: "cm:cut", label: "Cut", category: "clipboard" },
+  { id: "cm:paste", label: "Paste", category: "clipboard" },
+  { id: "cm:undo", label: "Undo", category: "clipboard" },
+  { id: "cm:redo", label: "Redo", category: "clipboard" },
+  { id: "cm:find", label: "Find & Replace", category: "clipboard" },
+  { id: "cm:speak", label: "Speak", category: "clipboard" },
+  { id: "cm:listen", label: "Listen", category: "clipboard" },
+  { id: "cm:copy-as", label: "Copy as", category: "clipboard" },
+  { id: "cm:json", label: "JSON", category: "clipboard" },
+  { id: "cm:select-all", label: "Select All", category: "edit" },
+  { id: "cm:insert-reference", label: "Insert / Copy reference\u2026", category: "edit" },
+  { id: "cm:chat", label: "Chat", category: "app" },
+  { id: "cm:view-history", label: "View History", category: "history" },
+  { id: "cm:compare", label: "Compare", category: "app" },
+  { id: "cm:export", label: "Export", category: "save" },
+  { id: "cm:convert", label: "Convert", category: "save" },
+  { id: "cm:attach", label: "Attach To", category: "share" },
+  { id: "cm:share", label: "Share", category: "share" },
+  { id: "cm:placement:ai-action", label: "AI Actions", category: "ai" },
+  { id: "cm:placement:content-block", label: "Content blocks", category: "ai" },
+  { id: "cm:placement:organization-tool", label: "Org Items", category: "ai" },
+  { id: "cm:placement:user-tool", label: "My Items", category: "ai" },
+  { id: "cm:placement:quick-action", label: "Quick actions (placement)", category: "ai" },
+  { id: "cm:placement:bound-agent", label: "Agents", category: "ai" },
+  { id: "cm:quick-actions", label: "Quick Actions", category: "feedback" },
+  { id: "cm:save", label: "Save", category: "edit" },
+  { id: "cm:delete", label: "Delete", category: "edit" },
+  { id: "cm:admin", label: "Admin Tools", category: "admin" },
+  { id: "cm:x:surface", label: "This page (location, context, agents)", category: "surface-info" }
+];
+var CONTEXT_MENU_ENGINE_ID_PREFIXES = ["cm:placement:", "cm:cat:", "cm:agents", "cm:entry:"];
+
+// src/engine/regroup/proposed-grouping.ts
+var import_lucide_react3 = require("lucide-react");
+var import_alchemy_icon_keys = require("@ai-matrx/rich-content/utils/alchemy-icon-keys");
+var import_domain3 = require("@ai-matrx/icons/domain");
+var icon = (c) => (0, import_alchemy_icon_keys.registerAlchemyIcon)(c);
+var PROPOSED_MENU_GROUPING = {
+  name: "v2 \u2014 grouped by what you get",
+  minMembers: 2,
+  // `category` + `order` place each submenu row among the others (the package's
+  // group order): Edit, Copy, Download, Convert to, Publish, Share, Organize,
+  // History, AI, Read aloud, Compare, Feedback, Admin.
+  groups: [
+    { key: "edit", label: "Edit", definition: "Change this item where it is: edit, rewrite, open in an editor, run, delete.", icon: icon(import_lucide_react3.Pencil), category: "edit", order: 0 },
+    { key: "copy", label: "Copy", definition: "It lands on your clipboard, in the form you pick: text, Markdown, rich text, HTML, a table, JSON, a reference.", icon: icon(import_lucide_react3.Copy), category: "copy", order: 0 },
+    { key: "download", label: "Download", definition: "It becomes a file outside the app: Markdown, PDF, Word, HTML \u2014 or a printout.", icon: icon(import_lucide_react3.Download), category: "export", order: 0 },
+    { key: "convert", label: "Convert to", definition: "It becomes a new thing inside the app: a note, document, task, file, flashcards, quiz, template, contact, data table.", icon: icon(import_lucide_react3.ArrowRightLeft), category: "save", order: 0 },
+    { key: "publish", label: "Publish", definition: "It goes out to the world: a public web page or published HTML anyone with the link can open.", icon: icon(import_lucide_react3.Globe), category: "share", order: 0 },
+    { key: "share", label: "Share", definition: "It goes to specific people or places: share with someone, send to Google Docs, email it.", icon: icon(import_lucide_react3.Share2), category: "share", order: 1 },
+    { key: "organize", label: "Organize", definition: "It stays what it is, but gets filed: attached to a project or context, pinned, annotated.", icon: icon(import_lucide_react3.Tags), category: "history", order: 0 },
+    { key: "history", label: "History", definition: "Earlier versions: view the history, fork from a point in it.", icon: icon(import_lucide_react3.History), category: "history", order: 1 },
+    { key: "ai", label: "AI", definition: "An AI works on it: ask, chat, run an agent or AI action, regenerate.", icon: icon(import_domain3.AGENT_ICON), category: "ai", order: 0 },
+    { key: "listen", label: "Read aloud", definition: "You hear it: read it aloud, a spoken summary, the voice settings.", icon: icon(import_lucide_react3.Volume2), category: "listen", order: 0 },
+    { key: "compare", label: "Compare", definition: "You see it side by side with something else: the clipboard or a saved base.", icon: icon(import_lucide_react3.GitCompareArrows), category: "study", order: 0 },
+    { key: "feedback", label: "Feedback", definition: "Tell us how it went: thumbs up or down, report a problem.", icon: icon(import_lucide_react3.ThumbsUp), category: "feedback", order: 1 },
+    { key: "admin", label: "Admin", definition: "Creator and admin tools: inspect, debug, server-side message surgery. Admins only.", icon: icon(import_lucide_react3.Shield), category: "admin", order: 0 }
+  ],
+  rules: [
+    // ── The page's own rows that DUPLICATE a category (Arman, 2026-09-28: "the
+    // more of that we do, the better"): they move into that category, and merge
+    // into the universal row that does the same thing when it is in the menu.
+    // Only genuinely unique record actions (Open, Take, Duplicate, Move to Trash…)
+    // stay at the top.
+    { when: { pageOwnLabels: ["^copy( to clipboard)?$"] }, to: { kind: "group", key: "copy" }, mergeWithIds: ["cm:copy", "copy"] },
+    { when: { pageOwnLabels: ["^copy\\b"] }, to: { kind: "group", key: "copy" } },
+    {
+      when: { pageOwnLabels: ["^(export|download)( as)? markdown"] },
+      to: { kind: "group", key: "download" },
+      mergeWithIds: ["save-as-file"]
+    },
+    { when: { pageOwnLabels: ["^(export|download)\\b", "^print\\b"] }, to: { kind: "group", key: "download" } },
+    { when: { pageOwnLabels: ["^share( link)?\u2026?$"] }, to: { kind: "group", key: "share" }, mergeWithIds: ["cm:share"] },
+    { when: { pageOwnLabels: ["^(share|send|email)\\b"] }, to: { kind: "group", key: "share" } },
+    { when: { pageOwnLabels: ["^publish\\b"] }, to: { kind: "group", key: "publish" } },
+    { when: { pageOwnLabels: ["^(convert|save to|save as|create (a )?(task|note|document))\\b"] }, to: { kind: "group", key: "convert" } },
+    { when: { pageOwnLabels: ["^(move to folder|add tags?|tags?|attach)\\b"] }, to: { kind: "group", key: "organize" } },
+    { when: { pageOwnLabels: ["^(read aloud|listen)\\b"] }, to: { kind: "group", key: "listen" } },
+    { when: { pageOwnLabels: ["^compare\\b"] }, to: { kind: "group", key: "compare" } },
+    { when: { pageOwnLabels: ["^save$"] }, to: { kind: "top" }, mergeWithIds: ["cm:save"] },
+    // A conversation's own rows, by id (their labels are computed at open).
+    {
+      when: { ids: ["conversation-copy-plain", "conversation-copy-markdown", "conversation-copy-formatted", "conversation-copy-for-ai", "conversation-copy-link"] },
+      to: { kind: "group", key: "copy" }
+    },
+    { when: { idPrefixes: ["conversation-download-"] }, to: { kind: "group", key: "download" } },
+    {
+      when: { ids: ["conversation-save-to-notes", "conversation-create-document", "conversation-create-task"] },
+      to: { kind: "group", key: "convert" }
+    },
+    { when: { ids: ["conversation-share", "conversation-email-to-me"] }, to: { kind: "group", key: "share" } },
+    { when: { ids: ["conversation-open-in-new-chat"] }, to: { kind: "group", key: "ai" } },
+    { when: { ids: ["conversation-rename", "conversation-duplicate"] }, to: { kind: "group", key: "edit" } },
+    // The clicked thing's remaining own rows (a quiz row's Open / Take / Archive,
+    // a note's Duplicate / Move to Trash) come first, as they are.
+    { when: { pageOwn: true }, to: { kind: "page-first" } },
+    // The universal verb strip (icons across the top) stays exactly as it is.
+    {
+      when: { ids: ["cm:copy", "cm:cut", "cm:paste", "cm:undo", "cm:redo", "cm:find", "copy", "cm:select-all"] },
+      to: { kind: "top" }
+    },
+    // Quick Actions is already one submenu of quick tools; the page submenu is last;
+    // an editor's own Save / Delete stay one click away.
+    { when: { ids: ["cm:quick-actions", "cm:save", "cm:delete"], categories: ["surface-info"] }, to: { kind: "top" } },
+    {
+      when: {
+        ids: ["cm:copy-as", "cm:json", "cm:insert-reference", "copy-html-page", "conversation-copy-link"],
+        categories: ["copy"]
+      },
+      to: { kind: "group", key: "copy" }
+    },
+    {
+      when: { ids: ["cm:export", "save-as-file", "download-pdf", "download-docx", "download-html", "print", "full-print"] },
+      to: { kind: "group", key: "download" }
+    },
+    { when: { ids: ["html-preview", "share-webpage"] }, to: { kind: "group", key: "publish" } },
+    {
+      when: { ids: ["cm:share", "send-google-doc", "email-to-me", "conversation-share"] },
+      to: { kind: "group", key: "share" }
+    },
+    {
+      when: { ids: ["cm:attach", "set-context-value", "pin-message", "notes-and-comments"] },
+      to: { kind: "group", key: "organize" }
+    },
+    {
+      when: { ids: ["cm:view-history", "edit-history", "fork-at-message", "fork-and-regenerate"] },
+      to: { kind: "group", key: "history" }
+    },
+    {
+      when: { ids: ["cm:compare", "compare-with-clipboard", "set-compare-base", "compare-with-base"] },
+      to: { kind: "group", key: "compare" }
+    },
+    {
+      when: { ids: ["cm:speak", "cm:listen", "tts-voice-settings"], categories: ["listen"] },
+      to: { kind: "group", key: "listen" }
+    },
+    {
+      when: {
+        ids: ["cm:chat", "regenerate-response", "regenerate-latest", "continue-in-chat", "send-to-agent", "code-block-chart"],
+        idPrefixes: ["cm:placement:", "cm:cat:", "cm:agents"],
+        categories: ["ai", "ask"]
+      },
+      to: { kind: "group", key: "ai" }
+    },
+    {
+      when: {
+        ids: [
+          "edit",
+          "edit-and-resubmit",
+          "open-fullscreen-editor",
+          "delete-message",
+          "code-block-open-in-editor",
+          "code-block-apply-to-file",
+          "code-block-run",
+          "replace-selection",
+          "insert-below",
+          "conversation-rename",
+          "conversation-duplicate"
+        ]
+      },
+      to: { kind: "group", key: "edit" }
+    },
+    { when: { ids: ["thumbs-up", "thumbs-down", "submit-feedback"], categories: ["feedback"] }, to: { kind: "group", key: "feedback" } },
+    { when: { ids: ["cm:admin"], categories: ["creator", "admin"] }, to: { kind: "group", key: "admin" } },
+    // Everything that makes a new thing in the app — checked after the rows
+    // above because the registry files several of them under "save".
+    { when: { ids: ["cm:convert", "add-to-rulebook"], categories: ["save", "study", "export"] }, to: { kind: "group", key: "convert" } }
+  ],
+  // A row no rule names stays at the top level where the package places it —
+  // and the demo's Categories section lists it under "No category yet".
+  fallback: { kind: "top" }
+};
+
+// src/engine/record-menu-registry.ts
+var RECORD_MENU_ATTR = "data-record-menu";
+var registry = /* @__PURE__ */ new Map();
+var revision = 0;
+var listeners = /* @__PURE__ */ new Set();
+function recordMenuChanged() {
+  revision += 1;
+  for (const listener of listeners) listener();
+}
+function subscribeRecordMenus(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function recordMenusRevision() {
+  return revision;
+}
+function registerRecordMenu(key, get) {
+  registry.set(key, get);
+  return () => {
+    if (registry.get(key) === get) registry.delete(key);
+  };
+}
+function resolveRecordMenu(target) {
+  const key = target?.closest?.(`[${RECORD_MENU_ATTR}]`)?.getAttribute(RECORD_MENU_ATTR);
+  if (!key) return null;
+  return registry.get(key)?.() ?? null;
+}
+var TRIGGER = '[data-alchemy-trigger="context"]';
+function contentTrigger(root) {
+  const inner = root.querySelector(`${TRIGGER}[data-content-source]`);
+  if (inner) return inner;
+  if (root.matches(TRIGGER)) return root;
+  return root.querySelector(TRIGGER) ?? root.closest(TRIGGER);
+}
+function openRecordMenu(key, anchor) {
+  const doc = anchor.ownerDocument;
+  const root = [...doc.querySelectorAll(`[${RECORD_MENU_ATTR}]`)].find(
+    (el) => el.getAttribute(RECORD_MENU_ATTR) === key
+  );
+  const trigger = root ? contentTrigger(root) : null;
+  if (!trigger) return false;
+  const rect = anchor.getBoundingClientRect();
+  trigger.dispatchEvent(
+    new MouseEvent("contextmenu", {
+      bubbles: true,
+      cancelable: true,
+      view: doc.defaultView ?? window,
+      button: 2,
+      buttons: 2,
+      clientX: rect.left + rect.width / 2,
+      clientY: rect.bottom
+    })
+  );
+  return true;
+}
+
+// src/engine/proposed/proposed-arrangement.ts
+var import_lucide_react4 = require("lucide-react");
+var import_domain4 = require("@ai-matrx/icons/domain");
+var import_alchemy_icon_keys2 = require("@ai-matrx/rich-content/utils/alchemy-icon-keys");
+var icon2 = (c) => (0, import_alchemy_icon_keys2.registerAlchemyIcon)(c);
+var STRIP_MAX = 6;
+var OWN_ROWS_MAX = 4;
+var SLOT2 = {
+  copy: { key: "copy", ids: ["cm:copy", "copy"], ownLabels: [/^copy( to clipboard)?$/i] },
+  cut: { key: "cut", ids: ["cm:cut"] },
+  paste: { key: "paste", ids: ["cm:paste"] },
+  undo: { key: "undo", ids: ["cm:undo"] },
+  redo: { key: "redo", ids: ["cm:redo"] },
+  find: { key: "find", ids: ["cm:find"] },
+  speak: { key: "speak", ids: ["cm:speak"] },
+  share: { key: "share", ownLabels: [/^share\b/i], ids: ["cm:share"] },
+  duplicate: { key: "duplicate", ownLabels: [/^duplicate\b/i, /^make a copy\b/i] },
+  favorite: { key: "favorite", ownLabels: [/favou?rite/i, /^(un)?star\b/i] },
+  download: { key: "download", ownLabels: [/^(export|download)\b/i] },
+  archive: { key: "archive", ownLabels: [/^archive\b/i, /^delete\b/i, /^move to trash\b/i] }
+};
+var STRIP_FOR = {
+  thing: ["copy", "share", "duplicate", "favorite", "download", "archive"],
+  editable: ["cut", "copy", "paste", "undo", "redo", "find"],
+  text: ["copy", "speak", "find", "share"]
+};
+var PAGE_TEXT_FILE_IDS = /* @__PURE__ */ new Set(["save-as-pdf"]);
+var OPEN_ROW = /^open( record)?$/i;
+var LINK_A_RECORD = /^link a record/i;
+var FOLDS_INTO_SHARE = [/^copy link\b/i, /^share link\b/i];
+var SAVE_SHARE_GROUPS = ["copy", "download", "convert", "publish", "share"];
+var ORGANIZE_GROUPS = /* @__PURE__ */ new Set(["organize", "history", "compare"]);
+var AI_ORDER = [
+  "cm:chat",
+  "cm:placement:ai-action",
+  "cm:placement:bound-agent",
+  "cm:agents",
+  "cm:placement:user-tool",
+  "cm:placement:organization-tool",
+  "cm:placement:content-block",
+  /^send to (another )?agent/i,
+  /^custom agent/i
+];
+var AI_LABELS = [/^summari[sz]e\b/i, /^send to (another )?agent/i, /^custom agent/i];
+function isOwn(action) {
+  if (action.id.startsWith("cm:x:") && !action.id.startsWith("cm:x:surface")) return true;
+  const s = action.section;
+  return Boolean(s && (s.primary || s.kind === "target"));
+}
+function clickedKind(target, resolved) {
+  if (!target.readOnly && resolved.some((r) => r.action.id === "cm:paste")) return "editable";
+  if (resolved.some((r) => isOwn(r.action))) return "thing";
+  return "text";
+}
+function submenu(id, label, category, iconKey, children, order = 0) {
+  const action = {
+    id: `proposed:${id}`,
+    label,
+    category,
+    order,
+    icon: iconKey,
+    pending: (t) => children.some((c) => Boolean(c.expand && c.pending?.(t))),
+    eligible: () => ({ status: "available" }),
+    expand: async () => children,
+    run: () => void 0
+  };
+  return { action, eligibility: { status: "available" } };
+}
+function plain(action, extra = {}) {
+  const { section: _section, ...rest } = action;
+  void _section;
+  return { ...rest, ...extra };
+}
+function proposedArrangement(target, resolved, { noun }) {
+  const kind = clickedKind(target, resolved);
+  const label = (r) => actionLabel(r.action, target);
+  const groupOf = (r) => {
+    const to = matchRule(PROPOSED_MENU_GROUPING, r.action, target)?.to;
+    return to?.kind === "group" ? to.key : null;
+  };
+  const used = /* @__PURE__ */ new Set();
+  const ownsDownload = resolved.some((r) => isOwn(r.action) && SLOT2.download.ownLabels.some((re) => re.test(label(r))));
+  if (ownsDownload) {
+    for (const r of resolved) {
+      if (!isOwn(r.action) && (groupOf(r) === "download" || PAGE_TEXT_FILE_IDS.has(r.action.id))) used.add(r.action.id);
+    }
+  }
+  const strip = [];
+  for (const key of STRIP_FOR[kind]) {
+    if (strip.length >= STRIP_MAX) break;
+    const slot2 = SLOT2[key];
+    const pick = resolved.find(
+      (r) => !used.has(r.action.id) && !r.action.expand && isOwn(r.action) && slot2.ownLabels?.some((re) => re.test(label(r)))
+    ) ?? resolved.find((r) => !used.has(r.action.id) && !r.action.expand && slot2.ids?.includes(r.action.id));
+    if (!pick) continue;
+    used.add(pick.action.id);
+    if (key === "share") {
+      for (const r of resolved) if (r.action.id === "cm:share") used.add(r.action.id);
+    }
+    if (key === "copy") {
+      for (const r of resolved) if (r.action.id === "cm:copy") used.add(r.action.id);
+    }
+    strip.push({
+      ...pick,
+      action: plain(pick.action, {
+        category: "clipboard",
+        order: strip.length,
+        ...key === "archive" ? { destructive: true, icon: pick.action.icon ?? icon2(import_lucide_react4.Archive) } : {},
+        ...key === "copy" && !pick.action.icon ? { icon: icon2(import_lucide_react4.Copy) } : {}
+      })
+    });
+  }
+  const hasShare = strip.some((r) => /^share\b/i.test(label(r)));
+  const ownCandidates = resolved.filter((r) => {
+    if (used.has(r.action.id)) return false;
+    const g = groupOf(r);
+    if (g && SAVE_SHARE_GROUPS.includes(g) && !(hasShare && FOLDS_INTO_SHARE.some((re) => re.test(label(r))))) return false;
+    if (isOwn(r.action)) return true;
+    return kind === "editable" && (groupOf(r) === "edit" || r.action.id === "cm:save" || r.action.id === "cm:delete");
+  });
+  const lead = (re) => {
+    const at = ownCandidates.findIndex((r) => re.test(label(r)));
+    return at >= 0 ? ownCandidates.splice(at, 1)[0] : null;
+  };
+  const openRow = lead(OPEN_ROW);
+  const linkRow = lead(LINK_A_RECORD);
+  ownCandidates.unshift(...[openRow, linkRow].filter((r) => r !== null));
+  const own = [];
+  const more = [];
+  for (const r of ownCandidates) {
+    used.add(r.action.id);
+    const folds = hasShare && FOLDS_INTO_SHARE.some((re) => re.test(label(r)));
+    if (!folds && own.length < OWN_ROWS_MAX && !r.action.expand) {
+      const destructive = SLOT2.archive.ownLabels.some((re) => re.test(label(r)));
+      own.push({ ...r, action: plain(r.action, { category: "edit", order: own.length, ...destructive ? { destructive: true } : {} }) });
+    } else {
+      more.push(plain(r.action));
+    }
+  }
+  const top = [...strip, ...own];
+  if (more.length) top.push(submenu("more", `More ${noun} options`, "edit", icon2(import_lucide_react4.Ellipsis), more, OWN_ROWS_MAX));
+  const ai = [];
+  const saveShare = /* @__PURE__ */ new Map();
+  const organize = [];
+  const tools = [];
+  for (const r of resolved) {
+    if (used.has(r.action.id)) continue;
+    used.add(r.action.id);
+    const g = groupOf(r);
+    if (g === "ai" || r.action.category === "ai" || r.action.category === "ask" || AI_LABELS.some((re) => re.test(label(r)))) {
+      ai.push(plain(r.action));
+    } else if (g && SAVE_SHARE_GROUPS.includes(g)) {
+      const list = saveShare.get(g) ?? [];
+      list.push(plain(r.action));
+      saveShare.set(g, list);
+    } else if (g && ORGANIZE_GROUPS.has(g)) {
+      organize.push(plain(r.action));
+    } else {
+      tools.push(plain(r.action));
+    }
+  }
+  const aiRank = (a) => {
+    const i = AI_ORDER.findIndex((p) => typeof p === "string" ? a.id === p || a.id.startsWith(p) : p.test(String(a.label)));
+    return i === -1 ? AI_ORDER.length : i;
+  };
+  ai.sort((a, b) => aiRank(a) - aiRank(b));
+  top.push(submenu("intelligence", "Intelligence", "ai", icon2(import_domain4.INTELLIGENCE_ICON), ai));
+  const saveShareRows = [];
+  for (const g of SAVE_SHARE_GROUPS) {
+    const rows = saveShare.get(g) ?? [];
+    rows.forEach((a, i) => saveShareRows.push(i === 0 && saveShareRows.length > 0 ? { ...a, startsGroup: true } : a));
+  }
+  if (saveShareRows.length) top.push(submenu("save-share", "Save & share", "app", icon2(import_lucide_react4.Share2), saveShareRows));
+  if (organize.length) top.push(submenu("organize", "Organize", "app", icon2(import_lucide_react4.FolderTree), organize, 1));
+  if (tools.length) top.push(submenu("tools", "Tools", "feedback", icon2(import_lucide_react4.Wrench), tools));
+  return top;
+}
+
+// src/engine/utils/per-row-entity.ts
+var isDev2 = process.env.NODE_ENV !== "production";
+function resolveEffectiveEntity(entityProp, resolved) {
+  if (!resolved || !(types_exports.CONTEXT_MENU_ENTITY_KEY in resolved)) return entityProp;
+  const perRow = resolved[types_exports.CONTEXT_MENU_ENTITY_KEY];
+  if (perRow === null || perRow === void 0) return void 0;
+  const candidate = perRow;
+  if (typeof perRow !== "object" || typeof candidate.type !== "string" || !candidate.type || typeof candidate.id !== "string" || !candidate.id) {
+    if (isDev2) {
+      console.error(
+        `%c[ContextMenuV3] MALFORMED PER-ROW ENTITY%c \u2014 resolveContextOnOpen returned "${types_exports.CONTEXT_MENU_ENTITY_KEY}" without a string type + id, so Attach To / Share would target nothing. Falling back to the menu-level entity.`,
+        "color:#ef4444;font-weight:bold",
+        "color:inherit",
+        { received: perRow }
+      );
+    }
+    return entityProp;
+  }
+  return candidate;
+}
+function mergeResolvedContextData(contextData, resolved) {
+  const merged = {
+    ...contextData ?? {},
+    ...resolved ?? {}
+  };
+  delete merged[types_exports.CONTEXT_MENU_ENTITY_KEY];
+  return merged;
+}
+function joinRowAndSurfaceContext(row, surface) {
+  if (!row) return surface ?? null;
+  if (!surface) return row;
+  const rowNamesEntity = row[types_exports.CONTEXT_MENU_ENTITY_KEY] !== null && row[types_exports.CONTEXT_MENU_ENTITY_KEY] !== void 0;
+  return {
+    ...surface,
+    ...row,
+    ...!rowNamesEntity && types_exports.CONTEXT_MENU_ENTITY_KEY in surface ? { [types_exports.CONTEXT_MENU_ENTITY_KEY]: surface[types_exports.CONTEXT_MENU_ENTITY_KEY] } : {}
+  };
+}
+var TOKEN_SHAPE = /^[a-z][a-z0-9_]*$/;
+function sniffEntityFromDom(target) {
+  const host = target?.closest?.("[data-entity-type][data-entity-id]");
+  if (!(host instanceof HTMLElement)) return null;
+  const type = host.getAttribute("data-entity-type")?.trim() ?? "";
+  const id = host.getAttribute("data-entity-id")?.trim() ?? "";
+  if (!type || !id) return null;
+  if (!TOKEN_SHAPE.test(type)) {
+    if (isDev2) {
+      console.error(
+        `%c[ContextMenuV3] MALFORMED data-entity-type%c \u2014 "${type}" is not an entity token (expected snake_case, e.g. "seo_keyword"), so Attach To / Share would target nothing. Fix the attribute or drop it.`,
+        "color:#ef4444;font-weight:bold",
+        "color:inherit",
+        { element: host }
+      );
+    }
+    return null;
+  }
+  const title = host.getAttribute("data-entity-title")?.trim() || (host.textContent ?? "").trim().slice(0, 120) || id;
+  const resourceType = host.getAttribute("data-entity-resource")?.trim();
+  return {
+    type,
+    id,
+    title,
+    ...resourceType ? { resourceType } : {}
+  };
+}
+function resolveEffectiveEntityWithDom(entityProp, resolved, target) {
+  const surfaceSpoke = !!resolved && types_exports.CONTEXT_MENU_ENTITY_KEY in resolved;
+  if (surfaceSpoke) return resolveEffectiveEntity(entityProp, resolved);
+  return sniffEntityFromDom(target) ?? entityProp;
+}
+
+// src/engine/utils/join-extra-sections.ts
+function isRow(item) {
+  return item.kind !== "separator";
+}
+function tidySeparators(items) {
+  const out = [];
+  for (const item of items) {
+    if (!isRow(item) && (out.length === 0 || !isRow(out[out.length - 1]))) continue;
+    out.push(item);
+  }
+  while (out.length > 0 && !isRow(out[out.length - 1])) out.pop();
+  return out;
+}
+function joinExtraSections(...sources) {
+  const present = sources.filter((s) => Array.isArray(s));
+  if (present.length === 0) return void 0;
+  if (present.length === 1) return present[0];
+  const taken = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const source of present) {
+    const ownIds = /* @__PURE__ */ new Set();
+    for (const section of source) {
+      const kept = section.items.filter((item) => !isRow(item) || !taken.has(item.id));
+      for (const item of kept) if (isRow(item)) ownIds.add(item.id);
+      if (kept.length === section.items.length) {
+        out.push(section);
+        continue;
+      }
+      const items = tidySeparators(kept);
+      if (items.some(isRow)) out.push({ ...section, items });
+    }
+    for (const id of ownIds) taken.add(id);
+  }
+  return out;
+}
+
+// src/engine/utils/widget-handle.ts
+function setFieldValue(el, next, caret) {
+  const setter = Object.getOwnPropertyDescriptor(
+    HTMLTextAreaElement.prototype,
+    "value"
+  )?.set;
+  if (setter) setter.call(el, next);
+  else el.value = next;
+  el.dispatchEvent(new Event("input", { bubbles: true }));
+  try {
+    el.setSelectionRange(caret, caret);
+  } catch {
+  }
+}
+function buildEditableWidgetHandle(args) {
+  const {
+    getTextarea,
+    onTextReplace,
+    onTextInsertBefore,
+    onTextInsertAfter,
+    getApplicationScope
+  } = args;
+  const field = () => getTextarea?.() ?? null;
+  const readCurrent = () => {
+    const el = field();
+    if (el) return el.value;
+    const content = getApplicationScope?.().content;
+    return typeof content === "string" ? content : null;
+  };
+  const writeFull = (next) => {
+    if (onTextReplace) {
+      onTextReplace(next);
+      return;
+    }
+    const el = field();
+    if (!el) throw new Error("Surface has no writable target");
+    setFieldValue(el, next, next.length);
+  };
+  const canWrite = Boolean(onTextReplace) || Boolean(getTextarea);
+  const canRead = Boolean(getTextarea) || Boolean(getApplicationScope);
+  if (!canWrite) return null;
+  const handle = {
+    onTextReplace: ({ text }) => writeFull(text),
+    ...canRead ? { readText: readCurrent } : {}
+  };
+  if (onTextInsertBefore || getTextarea) {
+    handle.onTextInsertBefore = ({ text }) => {
+      if (onTextInsertBefore) return onTextInsertBefore(text);
+      const el = field();
+      if (!el) throw new Error("Surface has no writable target");
+      const at = el.selectionStart ?? 0;
+      setFieldValue(
+        el,
+        el.value.slice(0, at) + text + el.value.slice(at),
+        at + text.length
+      );
+    };
+  }
+  if (onTextInsertAfter || getTextarea) {
+    handle.onTextInsertAfter = ({ text }) => {
+      if (onTextInsertAfter) return onTextInsertAfter(text);
+      const el = field();
+      if (!el) throw new Error("Surface has no writable target");
+      const at = el.selectionEnd ?? el.value.length;
+      setFieldValue(
+        el,
+        el.value.slice(0, at) + text + el.value.slice(at),
+        at + text.length
+      );
+    };
+  }
+  if (canRead) {
+    handle.onTextPrepend = ({ text }) => {
+      const current = readCurrent();
+      if (current === null) throw new Error("Surface content is unreadable");
+      writeFull(text + current);
+    };
+    handle.onTextAppend = ({ text }) => {
+      const current = readCurrent();
+      if (current === null) throw new Error("Surface content is unreadable");
+      writeFull(current + text);
+    };
+    handle.onTextPatch = ({ search_text, replacement_text }) => {
+      const current = readCurrent();
+      if (current === null) throw new Error("Surface content is unreadable");
+      const idx = current.indexOf(search_text);
+      if (idx === -1)
+        throw new Error("search_text not found in surface content");
+      writeFull(
+        current.slice(0, idx) + replacement_text + current.slice(idx + search_text.length)
+      );
+    };
+  }
+  return handle;
+}
+
+// src/engine/utils/table-at-target.ts
+var import_table_shape = require("@ai-matrx/records-ui/table-shape");
+function tableTextAtTarget(target) {
+  const table = target?.closest("table");
+  if (!table) return null;
+  const text = (0, import_table_shape.shapeTextOfNode)(table.cloneNode(true));
+  return text.trim() ? text : null;
+}
+
+// src/engine/region-trigger-attrs.ts
+var CONTEXT_REGION_TRIGGER_ATTRS = {
+  "data-alchemy-trigger": "context"
+};
+
+// src/engine/item/itemMenuToV3.ts
+var import_item = require("@ai-matrx/design-system/item");
+var import_notify = require("@ai-matrx/chat/host/notify");
+var iconOf = (entry) => entry.icon;
+var toastPromise = (promise, messages) => {
+  import_notify.toast.promise(promise, messages);
+};
+function runCommand(entry) {
+  (0, import_item.runCommand)(entry, toastPromise);
+}
+function entryToExtraItem(entry) {
+  const description = entry.disabled && entry.disabledReason ? entry.disabledReason : entry.description;
+  if ((0, import_item.isSubmenu)(entry)) {
+    return compact({
+      kind: "submenu",
+      id: entry.id,
+      label: entry.label,
+      icon: iconOf(entry),
+      disabled: entry.disabled,
+      children: submenuChildren(entry.sections)
+    });
+  }
+  if ((0, import_item.isCheckbox)(entry)) {
+    return compact({
+      kind: "checkbox",
+      id: entry.id,
+      label: entry.label,
+      icon: iconOf(entry),
+      description,
+      checked: entry.checked,
+      onCheckedChange: (next) => (0, import_item.runToggle)(entry, next),
+      disabled: entry.disabled,
+      hint: entry.shortcut ?? entry.shortcutKey?.toUpperCase()
+    });
+  }
+  if ((0, import_item.isLink)(entry)) {
+    return compact({
+      kind: "link",
+      id: entry.id,
+      label: entry.label,
+      icon: iconOf(entry),
+      description,
+      href: entry.href,
+      target: entry.target,
+      disabled: entry.disabled
+    });
+  }
+  return compact({
+    kind: "item",
+    id: entry.id,
+    label: entry.label,
+    icon: iconOf(entry),
+    description,
+    destructive: entry.tone === "destructive",
+    disabled: entry.disabled,
+    hint: entry.shortcut ?? entry.shortcutKey?.toUpperCase(),
+    onSelect: () => runCommand(entry)
+  });
+}
+function submenuChildren(sections) {
+  const visible = sections.map((s) => ({ ...s, items: s.items.filter((e) => !e.hidden) })).filter((s) => s.items.length > 0);
+  const out = [];
+  visible.forEach((section, i) => {
+    if (i > 0)
+      out.push({
+        kind: "separator",
+        id: `sep-${section.id ?? section.label ?? i}`
+      });
+    out.push(...section.items.map(entryToExtraItem));
+  });
+  return out;
+}
+function itemMenuConfigToExtraSections(config) {
+  const sections = config.sections.map((s, i) => compact({
+    id: String(s.id ?? s.label ?? `im-${i}`),
+    label: s.label,
+    anchor: "after-clipboard",
+    items: s.items.filter((e) => !e.hidden).map(entryToExtraItem)
+  })).filter((s) => s.items.length > 0);
+  const title = config.header?.title;
+  const first = sections[0];
+  if (title && first && !first.label) {
+    sections[0] = { ...first, label: title };
+  }
+  return sections;
+}
+
+// src/engine/alchemy-provider.ts
+var import_alchemy_icon_keys3 = require("@ai-matrx/rich-content/utils/alchemy-icon-keys");
+var import_turn_trust_strip = require("@ai-matrx/chat/agents/conversation-export/turn-trust-strip");
+var import_source = require("@ai-matrx/content-ir/source");
+function contextMenuHostOf(target) {
+  const host = target.host;
+  if (!host) return null;
+  if (host.kind === "context-menu" && typeof host.instanceId === "string") {
+    return host;
+  }
+  return host.contextMenu ?? null;
+}
+var VERBS = {
+  copy: { verb: "copy", sentence: "Select text, or right-click content, to copy it." },
+  cut: { verb: "cut", sentence: "Cut works on selected text in an editable field." },
+  paste: { verb: "paste", sentence: "Paste works in an editable field." },
+  undo: { verb: "undo", sentence: "Nothing to undo here." },
+  redo: { verb: "redo", sentence: "Nothing to redo here." },
+  find: { verb: "find", sentence: "Find works where there is text." }
+};
+var EDIT_ONLY_VERBS = /* @__PURE__ */ new Set(["cut", "paste", "undo", "redo"]);
+var CATEGORY_OF = {
+  clipboard: "clipboard",
+  tools: "app",
+  history: "history",
+  share: "share",
+  document: "save",
+  surface: "edit",
+  ai: "ai",
+  quick: "feedback",
+  editable: "edit",
+  admin: "admin",
+  "surface-info": "surface-info"
+};
+var NON_VERB_CLIPBOARD = {
+  "select-all": "edit",
+  "insert-reference": "edit"
+};
+var INSERTS_CONTENT = /* @__PURE__ */ new Set(["placement:content-block"]);
+function findNodeById(nodes, id) {
+  for (const n of nodes) {
+    if (n.id === id) return n;
+    if (n.kind === "submenu") {
+      const hit = findNodeById(n.children, id);
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+var available = { status: "available" };
+var absent = { status: "absent" };
+function icon3(node) {
+  return node.icon ? (0, import_alchemy_icon_keys3.registerAlchemyIcon)(node.icon) : void 0;
+}
+function startGroup(a) {
+  Object.assign(a, { startsGroup: true });
+}
+function toAction(node, place, instanceId, opts = {}) {
+  if (node.kind === "separator" || node.kind === "label") return null;
+  const id = `cm:${node.id}`;
+  const own = (t) => contextMenuHostOf(t)?.instanceId === instanceId;
+  const base = {
+    id,
+    label: node.label,
+    category: place.category,
+    order: place.order,
+    ...place.section ? { section: place.section } : {},
+    .../* @__PURE__ */ ((key) => key ? { icon: key } : {})(icon3(node)),
+    ..."iconClassName" in node && node.iconClassName ? { iconTone: node.iconClassName } : {},
+    ..."description" in node && node.description ? { description: node.description } : {},
+    ..."hint" in node && node.hint ? { hint: node.hint } : {}
+  };
+  if (node.kind === "submenu") {
+    const inserts = INSERTS_CONTENT.has(node.id);
+    return {
+      ...base,
+      // Still loading at the source: every layout shows "Loading…" on the row.
+      pending: () => Boolean(node.loading),
+      eligible: (t) => {
+        if (!own(t)) return absent;
+        if (inserts && (t.readOnly || opts.editable === false)) return absent;
+        if (node.loading) return available;
+        return !node.disabled && hasRows(node.children) ? available : absent;
+      },
+      expand: async (t) => {
+        let current = node;
+        for (let i = 0; current.kind === "submenu" && current.loading && opts.nextModel && i < 20; i++) {
+          const next = await opts.nextModel();
+          const found = next.sections.map((s) => findNodeById(s.nodes, node.id)).find(Boolean);
+          if (!found) return [];
+          current = found;
+        }
+        if (current.kind !== "submenu") return [];
+        void t;
+        const rows = [];
+        let startsNext = false;
+        for (const child of current.children) {
+          if (child.kind === "separator") {
+            startsNext = rows.length > 0;
+            continue;
+          }
+          if (unusable(child)) continue;
+          const a = toAction(child, { ...place, section: void 0, order: rows.length }, instanceId, opts);
+          if (!a) continue;
+          if (startsNext) startGroup(a);
+          startsNext = false;
+          rows.push(a);
+        }
+        return rows;
+      },
+      run: () => void 0
+    };
+  }
+  if (node.kind === "link") {
+    return { ...base, href: node.href, eligible: (t) => own(t) && !node.disabled ? available : absent, run: () => void 0 };
+  }
+  if (node.kind === "checkbox") {
+    return {
+      ...base,
+      toggle: true,
+      pressed: () => node.checked,
+      eligible: (t) => own(t) && !node.disabled ? available : absent,
+      run: () => node.onCheckedChange(!node.checked)
+    };
+  }
+  const verb = place.category === "clipboard" ? VERBS[node.id] : void 0;
+  return {
+    ...base,
+    ...verb ? { verb: verb.verb } : {},
+    ...node.destructive ? { destructive: true } : {},
+    ...node.keepsMenuOpen ? { keepsMenuOpen: true } : {},
+    eligible: (t) => {
+      if (!own(t)) return absent;
+      if (!node.disabled) return available;
+      if (verb && (t.readOnly || opts.editable === false) && EDIT_ONLY_VERBS.has(verb.verb)) return absent;
+      if (verb) return { status: "unavailable-verb", verb: verb.verb, sentence: verb.sentence };
+      const reason = "description" in node && typeof node.description === "string" ? node.description.trim() : "";
+      return reason ? { status: "unavailable", sentence: reason } : absent;
+    },
+    run: () => node.onSelect()
+  };
+}
+function unusable(node) {
+  if (node.kind === "separator" || node.kind === "label") return false;
+  if (node.kind === "submenu") return !node.loading && (Boolean(node.disabled) || !hasRows(node.children));
+  if (!("disabled" in node) || !node.disabled) return false;
+  return !("description" in node && typeof node.description === "string" && node.description.trim());
+}
+function hasRows(nodes) {
+  return nodes.some((n) => n.kind === "submenu" ? n.loading || hasRows(n.children) : n.kind !== "separator" && n.kind !== "label");
+}
+function contextMenuActionsFromModel(model, instanceId, opts = {}) {
+  const out = [];
+  model.sections.forEach((section, sectionIndex) => {
+    const base = sectionIndex * 100;
+    if (section.id === "registry") {
+      section.nodes.forEach((node, i) => {
+        if (node.kind !== "submenu" || !node.id.startsWith("rich-sub:")) return;
+        const libraries = node.children.filter((c) => !c.id.startsWith("rich") && c.kind !== "separator");
+        libraries.forEach((lib, j) => {
+          const a = toAction(
+            lib,
+            {
+              category: "ai",
+              order: 5e3 + i * 50 + j
+            },
+            instanceId,
+            opts
+          );
+          if (a) out.push(a);
+        });
+      });
+      return;
+    }
+    const named = section.group === "history" ? { id: "cm-history", label: "History" } : section.label ? {
+      id: `cm-${section.id}`,
+      label: section.label,
+      ...section.primary ? { primary: true } : {},
+      // A surface section's label is the clicked thing's own name.
+      ...section.group === "surface" ? { kind: "target" } : {}
+    } : void 0;
+    let groupStarts = false;
+    section.nodes.forEach((node, i) => {
+      if (node.kind === "separator") {
+        groupStarts = true;
+        return;
+      }
+      const category = section.group === "clipboard" ? NON_VERB_CLIPBOARD[node.id] ?? "clipboard" : CATEGORY_OF[section.group];
+      const isHistoryVerb = section.group === "history" && (node.id === "undo" || node.id === "redo");
+      const a = toAction(
+        node,
+        {
+          category: isHistoryVerb ? "clipboard" : category,
+          ...named && !isHistoryVerb ? { section: named } : {},
+          order: base + i
+        },
+        instanceId,
+        opts
+      );
+      if (a) {
+        if (groupStarts) startGroup(a);
+        groupStarts = false;
+        out.push(a);
+      }
+    });
+  });
+  return out;
+}
+function contextMenuProvider(instanceId, actions) {
+  return {
+    id: `context-menu:${instanceId}`,
+    tier: "T1",
+    actions: (target) => contextMenuHostOf(target)?.instanceId === instanceId ? actions() : []
+  };
+}
+function modelRevision(model) {
+  const walk = (nodes) => nodes.map(
+    (n) => n.kind === "submenu" ? `${n.id}${n.disabled ? "!" : ""}${n.loading ? "~" : ""}[${walk(n.children)}]` : `${n.id}${"disabled" in n && n.disabled ? "!" : ""}${n.kind === "checkbox" && n.checked ? "*" : ""}${"label" in n ? `:${n.label}` : ""}`
+  ).join(",");
+  return model.sections.map((s) => `${s.id}(${walk(s.nodes)})`).join("|");
+}
+function menuHeaderContent(actionText) {
+  if (actionText.source === "none") return null;
+  return headerPreview((0, import_turn_trust_strip.stripTurnTrust)(actionText.text));
+}
+function chatMessageSubject(args) {
+  const { state, source, extensions, contextData } = args;
+  const read = (conversationId, messageId) => typeof conversationId === "string" && typeof messageId === "string" ? state.messages?.byConversationId?.[conversationId]?.byId?.[messageId] : void 0;
+  if (source?.type === "chat-message") {
+    const record2 = read(source.conversationId, source.messageId);
+    const role = record2?.role ?? (extensions?.type === "chat-message" ? extensions.role : null);
+    return role ? { role: String(role), createdAt: record2?.createdAt ?? null } : null;
+  }
+  const record = read(contextData?.conversationId, contextData?.messageId);
+  return record?.role ? { role: String(record.role), createdAt: record.createdAt ?? null } : null;
+}
+function menuHeader(actionText, fieldLabel, message) {
+  if (message && actionText.source !== "selection" && actionText.source !== "none") {
+    const who = message.role === "user" ? "Your message" : message.role === "assistant" ? "AI answer" : "Message";
+    const at = message.createdAt ? new Date(message.createdAt) : null;
+    const when = at && !Number.isNaN(at.getTime()) ? ` \xB7 ${at.toLocaleString(void 0, { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" })}` : "";
+    return { content: "", contentLabel: `${who}${when}` };
+  }
+  if (fieldLabel && actionText.source !== "selection") {
+    return { content: fieldPreview(headerPreview((0, import_turn_trust_strip.stripTurnTrust)(actionText.text))), contentLabel: fieldLabel };
+  }
+  return { content: menuHeaderContent(actionText), contentLabel: null };
+}
+function headerPreview(text) {
+  const blocks = text.replace(/^\s{0,3}(?:```|~~~).*$/gm, "").replace(/^\s{0,3}#{1,6}\s+/gm, "").replace(/^\s{0,3}>\s?/gm, "").replace(/^\s{0,3}(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?/gm, "");
+  return (0, import_source.markdownToPlainText)(blocks).replace(/\s*\n+\s*/g, " ").trim();
+}
+function namedHeader(heading, actionText) {
+  if (!heading || actionText.source === "selection") return null;
+  return { content: heading.text, contentLabel: heading.label };
+}
+function menuEngineRevision(drawn, header) {
+  return `${drawn}\0${header.contentLabel ?? ""}\0${header.content ?? ""}`;
+}
+
+// src/engine/selection-provider.ts
+var import_domain5 = require("@ai-matrx/icons/domain");
+var import_alchemy_icon_keys4 = require("@ai-matrx/rich-content/utils/alchemy-icon-keys");
+var import_selection_actions = require("@ai-matrx/rich-content/selection-toolbar/selection-actions");
+var CONTEXT_MENU_SELECTION_HOST_KEY = "contextMenuSelection";
+function menuOf(target) {
+  const half = (0, import_selection_actions.hostHalf)(target, CONTEXT_MENU_SELECTION_HOST_KEY);
+  return half?.kind === "context-menu-selection" ? half : null;
+}
+var ASK_AI = {
+  id: "selection:ai",
+  label: "Ask AI",
+  description: "AI actions, agents, copy and export for the selected text",
+  icon: (0, import_alchemy_icon_keys4.registerAlchemyIcon)(import_domain5.AGENT_ICON),
+  category: "ai",
+  order: 0,
+  placement: "primary",
+  preserveSelection: true,
+  eligible: (t) => menuOf(t) && (0, import_selection_actions.shownInSelectionMode)(ASK_AI.id, t) ? { status: "available" } : { status: "absent" },
+  run: (t) => {
+    const menu = menuOf(t);
+    if (!menu) return;
+    (0, import_selection_actions.selectionToolbarHostOf)(t)?.ui.close();
+    menu.open();
+  }
+};
+var contextMenuSelectionProvider = {
+  id: "context-menu-selection",
+  tier: "T0",
+  declaredIds: () => [ASK_AI.id],
+  actions: (target) => menuOf(target) ? (0, import_selection_actions.placeSelectionActions)([ASK_AI], target) : []
+};
+(0, import_selection_actions.declareSelectionProvider)(contextMenuSelectionProvider);
+//# sourceMappingURL=engine.cjs.map