@ai-matrx/context-menu 0.0.0 → 0.1.1

package/dist/react.js

@@ -0,0 +1,3345 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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"));
+
+// 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/ContextMenuV3.tsx
+import React, { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { useIsMobile } from "@ai-matrx/kit/media-query";
+import { useSelectionZone } from "@ai-matrx/rich-content/selection-toolbar/selection-zones";
+
+// src/engine/selection-provider.ts
+import { AGENT_ICON } from "@ai-matrx/icons/domain";
+import { registerAlchemyIcon } from "@ai-matrx/rich-content/utils/alchemy-icon-keys";
+import {
+  declareSelectionProvider,
+  placeSelectionActions,
+  hostHalf,
+  selectionToolbarHostOf,
+  shownInSelectionMode
+} from "@ai-matrx/rich-content/selection-toolbar/selection-actions";
+var CONTEXT_MENU_SELECTION_HOST_KEY = "contextMenuSelection";
+function menuOf(target) {
+  const half = 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: registerAlchemyIcon(AGENT_ICON),
+  category: "ai",
+  order: 0,
+  placement: "primary",
+  preserveSelection: true,
+  eligible: (t) => menuOf(t) && shownInSelectionMode(ASK_AI.id, t) ? { status: "available" } : { status: "absent" },
+  run: (t) => {
+    const menu = menuOf(t);
+    if (!menu) return;
+    selectionToolbarHostOf(t)?.ui.close();
+    menu.open();
+  }
+};
+var contextMenuSelectionProvider = {
+  id: "context-menu-selection",
+  tier: "T0",
+  declaredIds: () => [ASK_AI.id],
+  actions: (target) => menuOf(target) ? placeSelectionActions([ASK_AI], target) : []
+};
+declareSelectionProvider(contextMenuSelectionProvider);
+
+// src/engine/utils/selection-tracking.ts
+var selection_tracking_exports = {};
+__reExport(selection_tracking_exports, selection_tracking_star);
+import * as selection_tracking_star from "@ai-matrx/chat/context-menu/utils/selection-tracking";
+
+// src/engine/types.ts
+var types_exports = {};
+__reExport(types_exports, types_star);
+import * as types_star from "@ai-matrx/chat/context-menu/types";
+
+// src/engine/utils/per-row-entity.ts
+var isDev = 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 (isDev) {
+      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 (isDev) {
+      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 } : {}
+  };
+}
+
+// src/engine/menu-presence.tsx
+import { createContext, useContext } from "react";
+var MenuPresenceContext = createContext(false);
+var MenuPresenceProvider = MenuPresenceContext.Provider;
+function useIsInsideContextMenu() {
+  return useContext(MenuPresenceContext);
+}
+var RegistryMenuSourceContext = createContext(null);
+var RegistryMenuSourceProvider = RegistryMenuSourceContext.Provider;
+function useRegistryMenuSource() {
+  return useContext(RegistryMenuSourceContext);
+}
+function sameContentSource(a, b) {
+  if (!a || !b || a.type !== b.type) return false;
+  return contentSourceKey(a) === contentSourceKey(b);
+}
+function contentSourceKey(s) {
+  return JSON.stringify(
+    Object.fromEntries(
+      Object.entries(s).filter(([k]) => k !== "readOnly").sort(([x], [y]) => x.localeCompare(y))
+    )
+  );
+}
+
+// src/engine/ContextMenuV3.tsx
+import { useOptionalWidgetHandle } from "@ai-matrx/chat/agents/hooks/useWidgetHandle";
+
+// 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/table-row-item.ts
+import { TABLE_ROW_ITEM } from "@ai-matrx/alchemy/declare";
+import { itemSources } from "@ai-matrx/alchemy/surface";
+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 = 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 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/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 subscribeRecordMenus(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function recordMenusRevision() {
+  return revision;
+}
+function resolveRecordMenu(target) {
+  const key = target?.closest?.(`[${RECORD_MENU_ATTR}]`)?.getAttribute(RECORD_MENU_ATTR);
+  if (!key) return null;
+  return registry.get(key)?.() ?? null;
+}
+
+// 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/region-trigger-attrs.ts
+var CONTEXT_REGION_TRIGGER_ATTRS = {
+  "data-alchemy-trigger": "context"
+};
+
+// src/engine/utils/table-at-target.ts
+import { shapeTextOfNode } from "@ai-matrx/records-ui/table-shape";
+function tableTextAtTarget(target) {
+  const table = target?.closest("table");
+  if (!table) return null;
+  const text = shapeTextOfNode(table.cloneNode(true));
+  return text.trim() ? text : null;
+}
+
+// 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/ContextMenuV3.tsx
+import { ReactReduxContext } from "react-redux";
+
+// src/engine/host/port.ts
+import { confirm as kitConfirm } from "@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: kitConfirm,
+  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 getContextMenuHost() {
+  return slot().host;
+}
+function useContextMenuHostBindings() {
+  return getContextMenuHost().useBindings();
+}
+
+// src/engine/ContextMenuV3.tsx
+import { selectAllShortcutsArray } from "@ai-matrx/chat/agents/redux/agent-shortcuts/selectors";
+import { fetchUnifiedMenu } from "@ai-matrx/chat/agents/redux/agent-shortcuts/thunks";
+import { jsx, jsxs } from "react/jsx-runtime";
+var NON_TEXT_INPUT_TYPES = /* @__PURE__ */ new Set([
+  "button",
+  "checkbox",
+  "color",
+  "file",
+  "image",
+  "radio",
+  "range",
+  "reset",
+  "submit"
+]);
+var NATIVE_TEXT_YIELD = /* @__PURE__ */ new WeakMap();
+function yieldsToNativeTextMenu(target) {
+  if (!(target instanceof HTMLElement)) return false;
+  if (target.isContentEditable) return true;
+  if (target instanceof HTMLTextAreaElement)
+    return !target.readOnly && !target.disabled;
+  if (target instanceof HTMLInputElement)
+    return !NON_TEXT_INPUT_TYPES.has(target.type) && !target.readOnly && !target.disabled;
+  return false;
+}
+function reachedThroughPortal(e) {
+  const { target, currentTarget } = e;
+  return target instanceof Node && currentTarget instanceof Node && !currentTarget.contains(target);
+}
+function isInsideOpenMenu(target) {
+  return target instanceof Element && Boolean(target.closest('[data-alchemy-layout], [role="menu"]'));
+}
+var MENU_CONTENT_SLOT = /* @__PURE__ */ Symbol.for("ai-matrx.context-menu.menu-content");
+function menuContentSlot() {
+  const g = globalThis;
+  return g[MENU_CONTENT_SLOT] ??= { module: null, warm: null };
+}
+function loadMenuContent() {
+  return import("@ai-matrx/context-menu/menu-content").then((m) => {
+    menuContentSlot().module = m;
+    return m;
+  });
+}
+function useMenuContentModule() {
+  const [mod, setMod] = useState(() => menuContentSlot().module);
+  useEffect(() => {
+    if (mod) return;
+    let live = true;
+    loadMenuContent().then(
+      (m) => {
+        if (live) setMod(m);
+      },
+      (error) => console.error("[ContextMenuV3] could not load the menu", error)
+    );
+    return () => {
+      live = false;
+    };
+  }, [mod]);
+  return mod;
+}
+function AlchemyMenuContent(props) {
+  const mod = useMenuContentModule();
+  return mod ? /* @__PURE__ */ jsx(mod.AlchemyMenuContent, { ...props }) : null;
+}
+function warmMenuContent() {
+  const slot2 = menuContentSlot();
+  if (!slot2.warm) {
+    slot2.warm = loadMenuContent().catch((error) => {
+      slot2.warm = null;
+      console.error("[ContextMenuV3] could not warm the menu; the first open will load it", error);
+    });
+  }
+  return menuContentSlot().warm ?? Promise.resolve();
+}
+function useWarmMenuContentWhenIdle() {
+  useEffect(() => {
+    if (menuContentSlot().warm) return;
+    if (typeof window.requestIdleCallback === "function") {
+      const id2 = window.requestIdleCallback(() => void warmMenuContent(), { timeout: 4e3 });
+      return () => window.cancelIdleCallback(id2);
+    }
+    const id = window.setTimeout(() => void warmMenuContent(), 1500);
+    return () => window.clearTimeout(id);
+  }, []);
+}
+function ShortcutKeyRunner(props) {
+  const mod = useMenuContentModule();
+  return mod ? /* @__PURE__ */ jsx(mod.ShortcutKeyRunner, { ...props }) : null;
+}
+var KEY_RUN_CLAIMED = "__alchemyShortcutKeyClaimed";
+function DocumentAgentReviewHost(props) {
+  const Review = getContextMenuHost().DocumentAgentReview;
+  React.useEffect(() => {
+    if (!Review) {
+      console.warn('[context-menu] host port "DocumentAgentReview" is not wired \u2014 the review request was dropped.');
+      props.onClose();
+    }
+  }, [Review, props]);
+  return Review ? /* @__PURE__ */ jsx(Review, { ...props }) : null;
+}
+var PALETTE_KEY = /* @__PURE__ */ Symbol.for("ai-matrx.context-menu.palette");
+function paletteRegistry() {
+  const g = globalThis;
+  let reg = g[PALETTE_KEY];
+  if (!reg) {
+    reg = { openers: /* @__PURE__ */ new Map(), pointer: null, focus: null, pointerDown: null, seq: 0, installed: false };
+    g[PALETTE_KEY] = reg;
+  }
+  if (!reg.installed && typeof document !== "undefined") {
+    reg.installed = true;
+    const r = reg;
+    document.addEventListener("keydown", (e) => {
+      if (e.defaultPrevented) return;
+      if (!(e.metaKey || e.ctrlKey) || !e.shiftKey || e.key.toLowerCase() !== "k") return;
+      const target = paletteTarget(r);
+      const open = target ? r.openers.get(target.id) : void 0;
+      if (!target || !open) return;
+      e.preventDefault();
+      open(target.element);
+    });
+  }
+  return reg;
+}
+function paletteTarget(r) {
+  const live = (c) => c && c.element.isConnected && r.openers.has(c.id) ? c : null;
+  const pointer = live(r.pointer);
+  const focus = live(r.focus);
+  if (!focus) return pointer;
+  if (!pointer) return focus;
+  if (focus.seq < pointer.seq) return pointer;
+  const down = r.pointerDown;
+  const causedByPress = !!down && focus.element.contains(down.element) && focus.at - down.at < 1e3;
+  return causedByPress ? pointer : focus;
+}
+var CLAIMED = "__alchemyPaletteClaimed";
+function ContextMenuV3({
+  children,
+  sourceFeature,
+  surfaceName,
+  menuVersion = 1,
+  getApplicationScope,
+  contextData = {},
+  resolveContextOnOpen,
+  contentSource,
+  entity,
+  excludedRichActions,
+  recordActionsOnly = false,
+  subjectFold,
+  extraRichActions,
+  richDocCtxExtras,
+  placementMode,
+  extraSections,
+  resolveExtraSectionsOnOpen,
+  onUndo,
+  onRedo,
+  canUndo = false,
+  canRedo = false,
+  undoHint,
+  redoHint,
+  onViewHistory,
+  hasHistory = false,
+  scope = "global",
+  scopeId = null,
+  className,
+  menuLayout = types_exports.DEFAULT_MENU_LAYOUT,
+  menuDensity = types_exports.DEFAULT_MENU_DENSITY,
+  suppressed = false,
+  onMenuOpenChange,
+  onCloseAutoFocus,
+  isEditable,
+  editorId,
+  getTextarea,
+  insertAtCaret,
+  onContentInserted,
+  onTextReplace,
+  onTextInsertBefore,
+  onTextInsertAfter,
+  onSave,
+  onDelete
+}) {
+  const [selectedText, setSelectedText] = useState("");
+  const [selectionRange, setSelectionRange] = useState(
+    null
+  );
+  const [fallbackContent, setFallbackContent] = useState("");
+  const [menuOpen, setMenuOpen] = useState(false);
+  const [textAgentReview, setTextAgentReview] = useState(null);
+  const requestTextAgentReview = useCallback(
+    (actionId, ctx) => setTextAgentReview({ actionId, ctx }),
+    []
+  );
+  const [dropdownOpen, setDropdownOpen] = useState(false);
+  const isMobile = useIsMobile();
+  const [sheetOpen, setSheetOpen] = useState(false);
+  const [paletteOpen, setPaletteOpen] = useState(false);
+  const [keyRun, setKeyRun] = useState(null);
+  const store = React.useContext(ReactReduxContext)?.store;
+  const [menuPoint, setMenuPoint] = useState({ x: 0, y: 0 });
+  const [openSeq, setOpenSeq] = useState(0);
+  useWarmMenuContentWhenIdle();
+  const capturedSelection = useRef(null);
+  const selectionLocked = useRef(false);
+  const lastMousePos = useRef(null);
+  const selectionOwnerRef = useRef(null);
+  const [selectionOwner, setSelectionOwnerState] = useState(null);
+  const setSelectionOwner = useCallback((node) => {
+    selectionOwnerRef.current = node;
+    setSelectionOwnerState(node);
+  }, []);
+  const longPressTimer = useRef(null);
+  const touchStart = useRef(null);
+  const [openTarget, setOpenTarget] = useState(null);
+  const recordRevision = useSyncExternalStore(
+    subscribeRecordMenus,
+    recordMenusRevision,
+    recordMenusRevision
+  );
+  const [resolvedContext, setResolvedContext] = useState(null);
+  const [resolvedItem, setResolvedItem] = useState(null);
+  const [resolvedExtraSections, setResolvedExtraSections] = useState(void 0);
+  const [rowJoinsSurfaceSections, setRowJoinsSurfaceSections] = useState(false);
+  const [sniffedEntity, setSniffedEntity] = useState(null);
+  const skipSelectionRestoreRef = useRef(false);
+  const widgetHandle = isEditable ? buildEditableWidgetHandle({
+    getTextarea,
+    onTextReplace,
+    onTextInsertBefore,
+    onTextInsertAfter,
+    getApplicationScope
+  }) : null;
+  const widgetHandleId = useOptionalWidgetHandle(widgetHandle);
+  const getEffectiveContextData = () => mergeResolvedContextData(
+    contextData,
+    resolvedContext
+  );
+  const surfaceSpokeAboutEntity = !!resolvedContext && types_exports.CONTEXT_MENU_ENTITY_KEY in resolvedContext;
+  const effectiveEntity = surfaceSpokeAboutEntity ? resolveEffectiveEntity(entity, resolvedContext) : sniffedEntity ?? entity;
+  useEffect(() => {
+    const handleSelection = () => {
+      if (selectionLocked.current) return;
+      const owner = selectionOwnerRef.current;
+      const selection = window.getSelection();
+      const anchor = selection?.anchorNode ?? null;
+      const active = document.activeElement;
+      const ownsSelection = owner != null && (anchor != null && owner.contains(anchor) || (active instanceof HTMLTextAreaElement || active instanceof HTMLInputElement) && owner.contains(active));
+      if (!ownsSelection) {
+        setSelectedText("");
+        return;
+      }
+      const text = !selection || selection.isCollapsed ? "" : selection.toString().trim();
+      setSelectedText(text);
+    };
+    document.addEventListener("selectionchange", handleSelection);
+    return () => document.removeEventListener("selectionchange", handleSelection);
+  }, []);
+  useEffect(() => {
+    const handleMouseMove = (e) => {
+      lastMousePos.current = { x: e.clientX, y: e.clientY };
+    };
+    document.addEventListener("mousemove", handleMouseMove, { passive: true });
+    return () => document.removeEventListener("mousemove", handleMouseMove);
+  }, []);
+  const handleMouseDown = (e) => {
+    if (suppressed) return;
+    if (reachedThroughPortal(e)) return;
+    if (e.button !== 2) return;
+    if (!isEditable && yieldsToNativeTextMenu(e.target)) return;
+    const target = e.target;
+    resolvePerTargetContext(target);
+    selectionLocked.current = true;
+    if (target instanceof HTMLTextAreaElement || target instanceof HTMLInputElement) {
+      const captured = (0, selection_tracking_exports.captureTextareaSelection)(target);
+      capturedSelection.current = captured;
+      setSelectedText(captured.text);
+    } else {
+      const captured = (0, selection_tracking_exports.captureDomSelection)();
+      capturedSelection.current = captured;
+      setSelectedText(captured.text);
+    }
+  };
+  const resolvePerTargetContext = (target) => {
+    const rowHit = resolveTableRowItem(target);
+    const rowMenu = rowHit?.menu ?? null;
+    setResolvedItem(rowHit?.item ?? null);
+    const answered = joinRowAndSurfaceContext(
+      rowMenu?.context,
+      resolveContextOnOpen ? resolveContextOnOpen(target) : null
+    );
+    setOpenTarget(target);
+    setResolvedContext(answered);
+    const surfaceSections = resolveExtraSectionsOnOpen?.(target);
+    const ownSections = joinExtraSections(rowMenu?.extraSections, surfaceSections);
+    setRowJoinsSurfaceSections(!!rowMenu && !surfaceSections);
+    const record = resolveRecordMenu(target);
+    setResolvedExtraSections(
+      record?.extraSections.length ? joinExtraSections(ownSections ?? extraSections ?? [], record.extraSections) : ownSections
+    );
+    setSniffedEntity(sniffEntityFromDom(target) ?? (entity ? null : record?.entity ?? null));
+  };
+  const captureContext = (target, containerEl) => {
+    resolvePerTargetContext(target);
+    let captured = capturedSelection.current;
+    const scopeEl = target instanceof HTMLTextAreaElement || target instanceof HTMLInputElement ? target : target.closest('[contenteditable="true"], [contenteditable=""]') ?? containerEl;
+    if (captured?.range && !scopeEl.contains(captured.range.commonAncestorContainer)) {
+      captured = null;
+    }
+    if (!captured || !captured.text) {
+      captured = target instanceof HTMLTextAreaElement || target instanceof HTMLInputElement ? (0, selection_tracking_exports.captureTextareaSelection)(target) : (0, selection_tracking_exports.captureDomSelection)();
+      capturedSelection.current = captured;
+      selectionLocked.current = true;
+    }
+    if (target instanceof HTMLTextAreaElement || target instanceof HTMLInputElement) {
+      const remembered = captured?.editable && captured.editable.element === target && captured.editable.start !== captured.editable.end ? captured.editable : null;
+      const { start, end } = remembered ?? (0, selection_tracking_exports.getEditableSelectionOffsets)(target);
+      if (remembered) {
+        const live = (0, selection_tracking_exports.getEditableSelectionOffsets)(target);
+        if (live.start !== start || live.end !== end) {
+          try {
+            target.setSelectionRange(start, end);
+          } catch {
+          }
+        }
+      }
+      setSelectedText(captured?.text || "");
+      setSelectionRange({
+        type: "editable",
+        element: target,
+        start,
+        end,
+        range: null,
+        containerElement: null
+      });
+      setFallbackContent(target.value ?? "");
+    } else {
+      let containerElement = containerEl;
+      if (!containerElement.hasAttribute("data-alchemy-trigger")) {
+        const trigger = containerElement.querySelector(
+          "[data-alchemy-trigger]"
+        );
+        if (trigger instanceof HTMLElement) containerElement = trigger;
+      }
+      setSelectedText(captured?.text || "");
+      setSelectionRange({
+        type: "non-editable",
+        // A contenteditable FIELD the right-click landed in (a rich or chip
+        // editor): recorded so the menu header can name the field instead of
+        // dumping its raw text. Every reader of `.element` gates on
+        // `type === "editable"`, so this changes nothing else.
+        element: target.closest('[contenteditable="true"], [contenteditable=""]'),
+        start: 0,
+        end: 0,
+        range: captured?.range || null,
+        containerElement
+      });
+      setFallbackContent((0, selection_tracking_exports.extractElementText)(containerElement));
+    }
+  };
+  const handleContextMenu = (e) => {
+    if (suppressed) return;
+    if (e.defaultPrevented) return;
+    e.preventDefault();
+    captureContext(e.target, e.currentTarget);
+    setMenuPoint({ x: e.clientX, y: e.clientY });
+    setOpenSeq((n) => n + 1);
+    setMenuOpen(true);
+    onMenuOpenChange?.(true);
+  };
+  const handleMenuClose = () => {
+    setMenuOpen(false);
+    selectionLocked.current = false;
+    capturedSelection.current = null;
+    if (skipSelectionRestoreRef.current) {
+      skipSelectionRestoreRef.current = false;
+      return;
+    }
+    if (!selectionRange) return;
+    if (selectionRange.type === "editable") {
+      const { element, start, end } = selectionRange;
+      if (element instanceof HTMLTextAreaElement || element instanceof HTMLInputElement) {
+        (0, selection_tracking_exports.restoreTextareaSelection)(element, start, end);
+      }
+    } else if (selectionRange.range) {
+      (0, selection_tracking_exports.restoreDomSelection)(selectionRange.range);
+    }
+  };
+  const handleDropdownClose = (open) => {
+    onMenuOpenChange?.(open);
+    setDropdownOpen(open);
+    if (!open) {
+      selectionLocked.current = false;
+      capturedSelection.current = null;
+    }
+  };
+  const openFromSelection = () => {
+    if (suppressed) return;
+    selectionLocked.current = true;
+    const sel = window.getSelection();
+    const container = sel && sel.rangeCount > 0 ? sel.getRangeAt(0).commonAncestorContainer.parentElement ?? null : null;
+    resolvePerTargetContext(container);
+    setFallbackContent((0, selection_tracking_exports.extractElementText)(container));
+    if (isMobile) {
+      setSelectedText(sel?.toString().trim() || selectedText);
+      setSelectionRange({
+        type: "non-editable",
+        element: null,
+        start: 0,
+        end: 0,
+        range: sel && sel.rangeCount > 0 ? sel.getRangeAt(0) : null,
+        containerElement: container
+      });
+      setOpenSeq((n) => n + 1);
+      setSheetOpen(true);
+      return;
+    }
+    const rect = (0, selection_tracking_exports.getSelectionRect)();
+    const at = rect ? { x: rect.left, y: rect.bottom + 4 } : lastMousePos.current ?? { x: 16, y: 16 };
+    setMenuPoint(at);
+    setOpenSeq((n) => n + 1);
+    setDropdownOpen(true);
+  };
+  const selectionHost = { kind: "context-menu-selection", open: openFromSelection };
+  useSelectionZone(selectionOwner, {
+    // A suppressed menu (the text is streaming) keeps the toolbar away until it settles.
+    suppress: suppressed,
+    host: { [CONTEXT_MENU_SELECTION_HOST_KEY]: selectionHost }
+  });
+  const clearLongPress = () => {
+    if (longPressTimer.current !== null) {
+      clearTimeout(longPressTimer.current);
+      longPressTimer.current = null;
+    }
+  };
+  const handleTouchStart = (e) => {
+    if (suppressed) return;
+    if (reachedThroughPortal(e)) return;
+    if (!isEditable && yieldsToNativeTextMenu(e.target)) return;
+    e.stopPropagation();
+    const t = e.touches[0];
+    if (!t) return;
+    touchStart.current = {
+      x: t.clientX,
+      y: t.clientY,
+      target: e.target,
+      container: e.currentTarget
+    };
+    clearLongPress();
+    longPressTimer.current = window.setTimeout(() => {
+      const info = touchStart.current;
+      if (!info) return;
+      captureContext(info.target, info.container);
+      setOpenSeq((n) => n + 1);
+      setSheetOpen(true);
+    }, 480);
+  };
+  const handleTouchMove = (e) => {
+    const info = touchStart.current;
+    const t = e.touches[0];
+    if (!info || !t) return;
+    if (Math.abs(t.clientX - info.x) > 10 || Math.abs(t.clientY - info.y) > 10)
+      clearLongPress();
+  };
+  const handleTouchEnd = () => clearLongPress();
+  const handleSheetOpenChange = (open) => {
+    onMenuOpenChange?.(open);
+    setSheetOpen(open);
+    if (!open) {
+      selectionLocked.current = false;
+      capturedSelection.current = null;
+    }
+  };
+  const menuContentProps = compact({
+    sourceFeature,
+    surfaceName,
+    menuVersion,
+    // A row descriptor owns this invocation's values. Preserve page-level live
+    // values for empty space, but never let them overwrite the clicked row.
+    getApplicationScope: resolvedContext ? () => ({ ...getApplicationScope?.() ?? {}, ...getEffectiveContextData() }) : getApplicationScope,
+    contextData: getEffectiveContextData(),
+    heading: readContextMenuHeading(resolvedContext) ?? recordHeadingAt(openTarget, recordRevision),
+    item: resolvedItem,
+    contentSource,
+    entity: effectiveEntity,
+    excludedRichActions,
+    recordActionsOnly,
+    subjectFold,
+    // The hook adds it only where the source can be saved and no host supplied one.
+    requestTextAgentReview,
+    extraRichActions,
+    // The table the click landed on rides to "Save to a table" beside the host's own extras.
+    richDocCtxExtras: {
+      ...richDocCtxExtras,
+      callbacks: {
+        ...richDocCtxExtras?.callbacks,
+        tableAtTarget: () => tableTextAtTarget(openTarget)
+      }
+      // Spreading an optional bag leaves its Pick'd keys optional; the hook spreads it over defaults.
+    },
+    selectedText,
+    selectionRange,
+    fallbackContent,
+    placementMode,
+    scope,
+    scopeId,
+    extraSections: resolvedExtraSections ? rowJoinsSurfaceSections ? joinExtraSections(resolvedExtraSections, extraSections) : resolvedExtraSections : extraSections,
+    menuLayout,
+    menuDensity,
+    isEditable,
+    editorId,
+    getTextarea,
+    insertAtCaret,
+    onContentInserted,
+    onTextReplace,
+    onTextInsertBefore,
+    onTextInsertAfter,
+    onSave,
+    onDelete,
+    onUndo,
+    onRedo,
+    canUndo,
+    canRedo,
+    undoHint,
+    redoHint,
+    onViewHistory,
+    hasHistory,
+    widgetHandleId,
+    suppressSelectionRestore: () => {
+      skipSelectionRestoreRef.current = true;
+    }
+  });
+  const canSlotChildren = React.Children.count(children) === 1 && React.isValidElement(children) && typeof children.type === "string";
+  const paletteIdRef = useRef(null);
+  paletteIdRef.current ??= /* @__PURE__ */ Symbol("context-menu-surface");
+  const openPaletteAt = (element) => {
+    if (suppressed) return;
+    const container = selectionOwnerRef.current ?? element;
+    captureContext(element, container);
+    setOpenSeq((n) => n + 1);
+    setPaletteOpen(true);
+    onMenuOpenChange?.(true);
+  };
+  const openPaletteRef = useRef(openPaletteAt);
+  useEffect(() => {
+    openPaletteRef.current = openPaletteAt;
+  });
+  useEffect(() => {
+    const reg = paletteRegistry();
+    const id = paletteIdRef.current;
+    reg.openers.set(id, (el) => openPaletteRef.current(el));
+    return () => {
+      reg.openers.delete(id);
+      if (reg.pointer?.id === id) reg.pointer = null;
+      if (reg.focus?.id === id) reg.focus = null;
+    };
+  }, []);
+  const claim = (kind) => (e) => {
+    const native = e.nativeEvent;
+    if (native[CLAIMED]) return;
+    native[CLAIMED] = true;
+    const reg = paletteRegistry();
+    const now = Date.now();
+    if (e.type === "pointerdown") reg.pointerDown = { element: e.target, at: now };
+    reg.seq += 1;
+    reg[kind] = { id: paletteIdRef.current, element: e.target, seq: reg.seq, at: now };
+  };
+  const mode = sheetOpen ? "sheet" : paletteOpen ? "palette" : menuOpen || dropdownOpen ? "context" : null;
+  const closeActive = () => {
+    if (sheetOpen) handleSheetOpenChange(false);
+    else if (paletteOpen) {
+      setPaletteOpen(false);
+      onMenuOpenChange?.(false);
+      handleMenuClose();
+    } else if (dropdownOpen) handleDropdownClose(false);
+    else {
+      onMenuOpenChange?.(false);
+      handleMenuClose();
+    }
+  };
+  const handleShortcutKeyDown = (e) => {
+    const native = e.nativeEvent;
+    if (native[KEY_RUN_CLAIMED] || e.defaultPrevented || suppressed || e.repeat) return;
+    if (reachedThroughPortal(e)) return;
+    if (!store || !e.altKey && !e.ctrlKey && !e.metaKey) return;
+    const matchOf = (event) => findComboMatch(
+      event,
+      selectAllShortcutsArray(store.getState()).filter((s) => s.isActive !== false),
+      (s) => s.keyboardShortcut
+    );
+    const target = e.target;
+    const owner = selectionOwnerRef.current ?? e.currentTarget;
+    const run = (match2) => {
+      captureContext(target, owner);
+      setOpenSeq((n) => n + 1);
+      setKeyRun({ id: match2.id, label: match2.label });
+    };
+    const loading = loadShortcuts();
+    const match = matchOf(e.nativeEvent);
+    if (!match) {
+      if (loading) {
+        const event = e.nativeEvent;
+        void loading.then(() => {
+          const late = matchOf(event);
+          if (late) run(late);
+        });
+      }
+      return;
+    }
+    native[KEY_RUN_CLAIMED] = true;
+    e.preventDefault();
+    e.stopPropagation();
+    run(match);
+  };
+  const shortcutsLoad = useRef(null);
+  const shortcutsLoaded = useRef(false);
+  const loadShortcuts = () => {
+    if (!store || !isEditable || shortcutsLoaded.current) return null;
+    if (!shortcutsLoad.current) {
+      shortcutsLoad.current = store.dispatch(fetchUnifiedMenu({ scope, scopeId })).catch(() => void 0).finally(() => {
+        shortcutsLoaded.current = true;
+      });
+    }
+    return shortcutsLoad.current;
+  };
+  const finishKeyRun = () => {
+    setKeyRun(null);
+    selectionLocked.current = false;
+    capturedSelection.current = null;
+  };
+  const triggerProps = {
+    ...CONTEXT_REGION_TRIGGER_ATTRS,
+    // Radix-compatible open state, for styles that key on it.
+    "data-state": mode ? "open" : "closed",
+    // Lets a ⋯ beside (not inside) this content open THIS menu.
+    "data-content-source": contentSource ? contentSourceKey(contentSource) : void 0,
+    onContextMenuCapture: (e) => {
+      if (reachedThroughPortal(e)) return;
+      if (!isEditable && yieldsToNativeTextMenu(e.target))
+        NATIVE_TEXT_YIELD.set(e.nativeEvent, e.currentTarget);
+    },
+    onContextMenu: (e) => {
+      if (reachedThroughPortal(e)) {
+        if (isInsideOpenMenu(e.target)) e.preventDefault();
+        return;
+      }
+      const yielder = NATIVE_TEXT_YIELD.get(e.nativeEvent);
+      if (yielder && (!isEditable || !yielder.contains(e.currentTarget))) return;
+      if (isMobile) {
+        if (suppressed) return;
+        if (!isEditable && yieldsToNativeTextMenu(e.target)) return;
+        e.stopPropagation();
+        e.preventDefault();
+        captureContext(e.target, e.currentTarget);
+        setOpenSeq((n) => n + 1);
+        setSheetOpen(true);
+        return;
+      }
+      handleContextMenu(e);
+    },
+    onMouseDown: isMobile ? void 0 : handleMouseDown,
+    // The palette key is answered by the ONE page listener (paletteTarget), so
+    // a click that focused an OUTER surface cannot steal it from the inner one.
+    onPointerOver: claim("pointer"),
+    onPointerDown: claim("pointer"),
+    onFocus: claim("focus"),
+    onKeyDown: handleShortcutKeyDown,
+    ...isMobile ? {
+      onTouchStart: handleTouchStart,
+      onTouchMove: handleTouchMove,
+      onTouchEnd: handleTouchEnd,
+      onTouchCancel: handleTouchEnd
+    } : {}
+  };
+  return /* @__PURE__ */ jsx(MenuPresenceProvider, { value: true, children: /* @__PURE__ */ jsxs(RegistryMenuSourceProvider, { value: contentSource ?? null, children: [
+    canSlotChildren ? /* @__PURE__ */ jsx(Slot, { ref: setSelectionOwner, ...triggerProps, children }) : /* @__PURE__ */ jsx("div", { ref: setSelectionOwner, style: { display: "contents" }, ...triggerProps, children }),
+    mode ? /* @__PURE__ */ jsx(
+      AlchemyMenuContent,
+      {
+        ...menuContentProps,
+        mode,
+        point: menuPoint,
+        open: true,
+        onOpenChange: (open) => {
+          if (!open) closeActive();
+        }
+      },
+      openSeq
+    ) : null,
+    keyRun && !mode ? /* @__PURE__ */ jsx(
+      ShortcutKeyRunner,
+      {
+        ...menuContentProps,
+        shortcutId: keyRun.id,
+        shortcutLabel: keyRun.label,
+        onDone: finishKeyRun
+      },
+      `key-run-${openSeq}`
+    ) : null,
+    textAgentReview ? /* @__PURE__ */ jsx(
+      DocumentAgentReviewHost,
+      {
+        actionId: textAgentReview.actionId,
+        ctx: textAgentReview.ctx,
+        onClose: () => setTextAgentReview(null)
+      }
+    ) : null
+  ] }) });
+}
+function recordHeadingAt(target, _revision) {
+  return readContextMenuHeading({
+    [types_exports.CONTEXT_MENU_HEADING_KEY]: resolveRecordMenu(target)?.heading ?? null
+  });
+}
+function readContextMenuHeading(resolved) {
+  if (!resolved || typeof resolved !== "object") return null;
+  const heading = resolved[types_exports.CONTEXT_MENU_HEADING_KEY];
+  if (!heading || typeof heading !== "object") return null;
+  const { label, text } = heading;
+  return typeof label === "string" && typeof text === "string" && label.trim() ? { label: label.trim(), text } : null;
+}
+
+// src/engine/EditableContextMenu.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function EditableContextMenu(props) {
+  return /* @__PURE__ */ jsx2(ContextMenuV3, { ...props, isEditable: true });
+}
+
+// src/engine/NonEditableContextMenu.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function NonEditableContextMenu(props) {
+  return /* @__PURE__ */ jsx3(ContextMenuV3, { ...props, isEditable: false });
+}
+
+// src/engine/PageSurfaceMenu.tsx
+import { useActivePageSurface } from "@ai-matrx/chat/surfaces/runtime/useActivePageSurface";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function PageSurfaceMenu({
+  sourceFeature,
+  children
+}) {
+  const active = useActivePageSurface();
+  return /* @__PURE__ */ jsx4(
+    NonEditableContextMenu,
+    {
+      sourceFeature,
+      ...compact({ surfaceName: active.surfaceName ?? void 0 }),
+      getApplicationScope: () => {
+        const scope = active.runtime?.getScope();
+        return scope && !(scope instanceof Promise) ? scope : {};
+      },
+      contentSource: { type: "raw" },
+      contextData: { content: "" },
+      children
+    }
+  );
+}
+
+// src/engine/regroup/RegroupContext.tsx
+import * as React2 from "react";
+import { AlchemyActionsProvider, useAlchemyActions } from "@ai-matrx/alchemy/react/host";
+
+// src/engine/regroup/grouping.ts
+import {
+  buildMenuModel,
+  context as arrangeContext
+} from "@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 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 submenu = {
+      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: submenu, 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 };
+}
+
+// src/engine/regroup/RegroupContext.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var MenuRegroupContext = React2.createContext(null);
+function MenuRegroupProvider({ value, children }) {
+  return /* @__PURE__ */ jsx5(MenuRegroupContext.Provider, { value, children });
+}
+function regroupingRegistry(inner, first) {
+  let inputs = first;
+  const read = () => inputs;
+  return {
+    update(next) {
+      inputs = next;
+    },
+    register: (provider) => inner.register(provider),
+    providers: () => inner.providers(),
+    subscribe: (listener) => inner.subscribe(listener),
+    // By-id lookup (alchemy 0.12): regrouping changes how a menu is arranged, never which Action an id names.
+    get: (id, target) => inner.get(id, target),
+    async resolve(target, restrict) {
+      const list = await inner.resolve(target, restrict);
+      const { value, arrangement, close } = read();
+      if (!value) return list;
+      value.onResolved?.({ target, resolved: list, arrangement }, close);
+      if (value.transform) return value.transform(target, list);
+      if (!value.grouping) return list;
+      return regroupResolved(target, list, value.grouping, { mergeSameName: value.mergeSameName }).resolved;
+    }
+  };
+}
+function RegroupBoundary({
+  arrangement,
+  close,
+  children
+}) {
+  const value = React2.useContext(MenuRegroupContext);
+  const { registry: registry2, ports } = useAlchemyActions();
+  const [view] = React2.useState(
+    () => value ? regroupingRegistry(registry2, { value, arrangement, close }) : null
+  );
+  React2.useLayoutEffect(() => {
+    view?.update({ value, arrangement, close });
+  });
+  if (!view) return children;
+  return /* @__PURE__ */ jsx5(AlchemyActionsProvider, { ports, registry: view, children });
+}
+
+// src/engine/item/ItemMenuHostBinding.tsx
+import { ItemMenuHostProvider } from "@ai-matrx/design-system/item";
+
+// src/engine/item/ItemContextMenuV3.tsx
+import { useState as useState3 } from "react";
+import { resolveItemMenuConfig } from "@ai-matrx/design-system/item";
+
+// src/engine/item/itemMenuToV3.ts
+import {
+  isCheckbox,
+  isLink,
+  isSubmenu,
+  runCommand as runItemCommand,
+  runToggle
+} from "@ai-matrx/design-system/item";
+import { toast } from "@ai-matrx/chat/host/notify";
+var iconOf = (entry) => entry.icon;
+var toastPromise = (promise, messages) => {
+  toast.promise(promise, messages);
+};
+function runCommand(entry) {
+  runItemCommand(entry, toastPromise);
+}
+function entryToExtraItem(entry) {
+  const description = entry.disabled && entry.disabledReason ? entry.disabledReason : entry.description;
+  if (isSubmenu(entry)) {
+    return compact({
+      kind: "submenu",
+      id: entry.id,
+      label: entry.label,
+      icon: iconOf(entry),
+      disabled: entry.disabled,
+      children: submenuChildren(entry.sections)
+    });
+  }
+  if (isCheckbox(entry)) {
+    return compact({
+      kind: "checkbox",
+      id: entry.id,
+      label: entry.label,
+      icon: iconOf(entry),
+      description,
+      checked: entry.checked,
+      onCheckedChange: (next) => runToggle(entry, next),
+      disabled: entry.disabled,
+      hint: entry.shortcut ?? entry.shortcutKey?.toUpperCase()
+    });
+  }
+  if (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/item/ItemContextMenuV3.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+function ItemContextMenuV3({
+  config,
+  children,
+  sourceFeature,
+  surfaceName,
+  entity,
+  getApplicationScope,
+  resolveItemOnOpen,
+  onOpenChange,
+  onCloseAutoFocus
+}) {
+  const [resolved, setResolved] = useState3(null);
+  return /* @__PURE__ */ jsx6(
+    NonEditableContextMenu,
+    {
+      sourceFeature,
+      ...compact({ surfaceName, entity, getApplicationScope }),
+      resolveContextOnOpen: (target) => {
+        const item = resolveItemOnOpen?.(target);
+        setResolved(resolveItemMenuConfig(item?.config ?? config));
+        const context = item?.context ?? null;
+        if (entity?.title && !(context && context[types_exports.CONTEXT_MENU_HEADING_KEY])) {
+          const type = String(entity.type ?? "Item").replace(/[_-]+/g, " ");
+          return {
+            ...context ?? {},
+            [types_exports.CONTEXT_MENU_HEADING_KEY]: {
+              label: type.charAt(0).toUpperCase() + type.slice(1),
+              text: entity.title
+            }
+          };
+        }
+        return context;
+      },
+      extraSections: resolved ? itemMenuConfigToExtraSections(resolved) : [],
+      ...compact({ onMenuOpenChange: onOpenChange, onCloseAutoFocus }),
+      children
+    }
+  );
+}
+
+// src/engine/item/ItemMenuHostBinding.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var HOST = {
+  // The package's surface fields are open strings; every website row passes chat's closed registries.
+  ContextMenu: ItemContextMenuV3,
+  toastPromise
+};
+function ItemMenuHostBinding({ children }) {
+  return /* @__PURE__ */ jsx7(ItemMenuHostProvider, { host: HOST, children });
+}
+
+// src/engine/components/OpenSurfaceMenuButton.tsx
+import * as React3 from "react";
+import { MoreHorizontal } from "lucide-react";
+import { Button } from "@ai-matrx/design-system";
+import { cn } from "@ai-matrx/design-system/cn";
+import { jsx as jsx8 } from "react/jsx-runtime";
+function OpenSurfaceMenuButton({
+  getSurface,
+  label = "More actions",
+  className
+}) {
+  const buttonRef = React3.useRef(null);
+  return /* @__PURE__ */ jsx8(
+    Button,
+    {
+      ref: buttonRef,
+      type: "button",
+      variant: "ghost",
+      size: "icon",
+      className: cn("h-8 w-8 p-0", className),
+      "aria-label": label,
+      "aria-haspopup": "menu",
+      onClick: () => {
+        const surface = getSurface();
+        const button = buttonRef.current;
+        if (!surface || !button) return;
+        const rect = button.getBoundingClientRect();
+        surface.dispatchEvent(
+          new MouseEvent("contextmenu", {
+            bubbles: true,
+            cancelable: true,
+            view: window,
+            button: 2,
+            buttons: 2,
+            clientX: rect.left + rect.width / 2,
+            clientY: rect.bottom
+          })
+        );
+      },
+      children: /* @__PURE__ */ jsx8(MoreHorizontal, { className: "h-4 w-4" })
+    }
+  );
+}
+
+// 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;
+}
+
+// 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
+import { useEffect as useEffect2, useMemo as useMemo2 } from "react";
+import { copyText as kitCopyText, readText as kitReadText } from "@ai-matrx/kit/clipboard";
+import {
+  AppWindow,
+  Braces,
+  Building,
+  ClipboardCopy,
+  FileText,
+  Info,
+  Layers,
+  Plus,
+  Rocket,
+  ShieldCheck,
+  User
+} from "lucide-react";
+import { detectActiveSurface } from "@ai-matrx/chat/surfaces/utils/route-to-surface";
+import { getSurfaceDisplayLabel } from "@ai-matrx/chat/surfaces/utils/surface-display";
+import { getRelatedSurfaces } from "@ai-matrx/chat/surfaces/runtime/fetchRelatedSurfaces";
+import { getIconComponent } from "@ai-matrx/icons";
+import { useAppDispatch as useAppDispatch2, useAppSelector as useAppSelector2, useAppStore } from "@ai-matrx/chat/store/hooks";
+import { selectUserId } from "@ai-matrx/chat/host/identity";
+
+// src/engine/utils/notify.ts
+import { toast as notify } from "@ai-matrx/chat/host/notify";
+function toast2(props) {
+  const { title, description, variant, duration } = props;
+  const message = title ?? description ?? "";
+  const options = {
+    ...title !== void 0 && description !== void 0 ? { description } : {},
+    ...duration !== void 0 ? { duration } : {}
+  };
+  if (variant === "destructive") notify.error(message, options);
+  else if (variant === "success") notify.success(message, options);
+  else if (variant === "warning") notify.warning(message, options);
+  else if (variant === "info") notify.info(message, options);
+  else notify.message(message, options);
+}
+
+// src/engine/hooks/useContextMenuActions.ts
+import { selectOrganizationId } from "@ai-matrx/chat/host/org";
+import { useAgentLauncher } from "@ai-matrx/chat/agents/hooks/useAgentLauncher";
+import { useSpeech } from "@ai-matrx/media/react";
+import { primeAudioOutput } from "@ai-matrx/media/speech";
+import { useSurfaceAgentRoles } from "@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
+import { blockBoundary, insertTextAtTextareaCursor } from "@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 = blockBoundary(field.value, field.selectionStart, field.selectionEnd, "nearest");
+        field.setSelectionRange(at, at);
+      }
+      return 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 = 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
+import { resolveActions } from "@ai-matrx/rich-content/rich-document/actions/provider";
+import { registryMenuActions } from "@ai-matrx/rich-content/rich-document/variants/shared/menuStructure";
+import { getSourceAdapter } from "@ai-matrx/rich-content/rich-document/actions/sources/index";
+import { shortHash } from "@ai-matrx/rich-content/rich-document/actions/sources/raw";
+import {
+  placementGroupKey as placementGroupKey2,
+  PLACEMENT_TYPES,
+  PLACEMENT_TYPE_META
+} from "@ai-matrx/chat/agents/shortcuts/constants";
+
+// src/engine/hooks/useUnifiedAgentContextMenu.ts
+import { useMemo, useState as useState4, useCallback as useCallback2 } from "react";
+import { useAppDispatch, useAppSelector } from "@ai-matrx/chat/store/hooks";
+import {
+  fetchUnifiedMenu as fetchUnifiedMenu2,
+  unifiedMenuLoadedKey
+} from "@ai-matrx/chat/agents/redux/agent-shortcuts/thunks";
+
+// src/engine/utils/menu-deadline.ts
+var menu_deadline_exports = {};
+__reExport(menu_deadline_exports, menu_deadline_star);
+import * as menu_deadline_star from "@ai-matrx/chat/context-menu/utils/menu-deadline";
+
+// src/engine/hooks/useUnifiedAgentContextMenu.ts
+import { selectAllShortcutsArray as selectAllShortcutsArray2 } from "@ai-matrx/chat/agents/redux/agent-shortcuts/selectors";
+import { selectAllCategoriesArray } from "@ai-matrx/chat/agents/redux/agent-shortcut-categories/selectors";
+import { resolveRowScope } from "@ai-matrx/chat/agents/redux/shared/scope";
+import { placementGroupKey } from "@ai-matrx/chat/agents/shortcuts/constants";
+
+// src/engine/model/requirement-gate.ts
+var requirement_gate_exports = {};
+__reExport(requirement_gate_exports, requirement_gate_star);
+import * as requirement_gate_star from "@ai-matrx/chat/context-menu/model/requirement-gate";
+
+// src/engine/hooks/useUnifiedAgentContextMenu.ts
+var SELECTION_DEPENDENT_KEYS = /* @__PURE__ */ new Set(["selection"]);
+var SCOPE_PRIORITY = {
+  task: 5,
+  project: 4,
+  user: 3,
+  organization: 2,
+  global: 1
+};
+var SPECIFICITY = {
+  surface: 3,
+  domain: 2,
+  global: 1
+};
+function specificityOf(item) {
+  return SPECIFICITY[(0, requirement_gate_exports.readMenuScope)({ id: "", surfaceName: item.surfaceName ?? null }).level];
+}
+function beats(a, b) {
+  const byOwner = SCOPE_PRIORITY[a.scopeLevel] - SCOPE_PRIORITY[b.scopeLevel];
+  if (byOwner !== 0) return byOwner > 0;
+  const bySpecificity = specificityOf(a) - specificityOf(b);
+  if (bySpecificity !== 0) return bySpecificity > 0;
+  return a.id < b.id;
+}
+function dedupeByPrecedence(items, keyFn) {
+  const winners = /* @__PURE__ */ new Map();
+  const passthrough = [];
+  for (const item of items) {
+    const key = keyFn(item);
+    if (!key) {
+      passthrough.push(item);
+      continue;
+    }
+    const existing = winners.get(key);
+    if (!existing || beats(item, existing)) winners.set(key, item);
+  }
+  return [...winners.values(), ...passthrough];
+}
+function buildCategoryGroups(args) {
+  const {
+    placementTypes,
+    surfaceName = null,
+    availableKeys,
+    hasSelection,
+    excludedItemIds,
+    shortcuts,
+    categories,
+    contentBlocks
+  } = args;
+  if (placementTypes.length === 0) return [];
+  const placementSet = new Set(placementTypes);
+  const scopedCategories = categories.filter(
+    (c) => c.isActive !== false && placementSet.has(placementGroupKey(c.placementType))
+  ).map((c) => ({ ...c, scopeLevel: resolveRowScope(c) }));
+  const scopedShortcuts = shortcuts.filter((s) => s.isActive !== false).map((s) => ({
+    ...s,
+    entryType: "agent_shortcut",
+    scopeLevel: resolveRowScope(s)
+  }));
+  const scopedBlocks = contentBlocks.filter((b) => b.isActive !== false).map((b) => ({
+    ...b,
+    entryType: "content_block",
+    scopeLevel: resolveRowScope(b)
+  }));
+  const offerCtx = compact({
+    surfaceName,
+    availableKeys,
+    excludedItemIds
+  });
+  const filteredShortcuts = scopedShortcuts.filter((s) => {
+    if (!(0, requirement_gate_exports.decideOffer)(s, offerCtx).offered) return false;
+    if (hasSelection) return true;
+    return !(0, requirement_gate_exports.requirementsOf)(s).some((key) => SELECTION_DEPENDENT_KEYS.has(key));
+  });
+  const filteredBlocks = scopedBlocks.filter(
+    (b) => !excludedItemIds?.has(b.id)
+  );
+  const dedupedShortcuts = dedupeByPrecedence(filteredShortcuts, (s) => {
+    if (s.keyboardShortcut) return `kbd:${s.keyboardShortcut}`;
+    return `label:${s.categoryId}:${s.label}`;
+  });
+  const dedupedBlocks = dedupeByPrecedence(
+    filteredBlocks,
+    (b) => `block:${b.categoryId ?? "_none"}:${b.blockId}`
+  );
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const s of dedupedShortcuts) {
+    if (!byCategory.has(s.categoryId)) byCategory.set(s.categoryId, []);
+    byCategory.get(s.categoryId).push(s);
+  }
+  for (const b of dedupedBlocks) {
+    const cid = b.categoryId;
+    if (!cid) continue;
+    if (!byCategory.has(cid)) byCategory.set(cid, []);
+    byCategory.get(cid).push(b);
+  }
+  const dedupedCategories = dedupeByPrecedence(
+    scopedCategories,
+    (c) => `${c.placementType}:${c.parentCategoryId ?? "_root"}:${c.label}`
+  );
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const cat of dedupedCategories) {
+    nodeMap.set(cat.id, {
+      category: cat,
+      items: (byCategory.get(cat.id) ?? []).slice().sort((x, y) => (x.sortOrder ?? 0) - (y.sortOrder ?? 0)),
+      children: []
+    });
+  }
+  const roots = [];
+  for (const cat of dedupedCategories) {
+    const node = nodeMap.get(cat.id);
+    if (cat.parentCategoryId && nodeMap.has(cat.parentCategoryId)) {
+      nodeMap.get(cat.parentCategoryId).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  const sortNodes = (nodes) => {
+    nodes.sort(
+      (a, b) => (a.category.sortOrder ?? 0) - (b.category.sortOrder ?? 0) || a.category.label.localeCompare(b.category.label)
+    );
+    for (const n of nodes) sortNodes(n.children);
+  };
+  sortNodes(roots);
+  return roots;
+}
+function useUnifiedAgentContextMenu(args) {
+  const {
+    placementTypes,
+    surfaceName = null,
+    availableKeys,
+    hasSelection,
+    excludedItemIds,
+    enabled = true,
+    scope = "global",
+    scopeId = null
+  } = args;
+  const dispatch = useAppDispatch();
+  const shortcuts = useAppSelector(selectAllShortcutsArray2);
+  const categories = useAppSelector(selectAllCategoriesArray);
+  const contentBlocks = useAppSelector((state) => getContextMenuHost().selectRenderDefinitions(state));
+  const rowsInHand = useAppSelector(
+    (state) => state.agentShortcut.contextLoaded?.[unifiedMenuLoadedKey({ scope, scopeId })] ?? false
+  );
+  const [error, setError] = useState4(null);
+  const refresh = useCallback2(async () => {
+    if (!enabled || placementTypes.length === 0) return;
+    try {
+      setError(null);
+      await (0, menu_deadline_exports.withMenuDeadline)(
+        dispatch(fetchUnifiedMenu2({ scope, scopeId })).unwrap(),
+        "Loading the menu's AI actions"
+      );
+    } catch (err) {
+      if (err?.name === "ConditionError") return;
+      setError(err instanceof Error ? err.message : "Failed to load menu");
+    }
+  }, [dispatch, enabled, placementTypes.length, scope, scopeId]);
+  const categoryGroups = useMemo(() => {
+    if (!enabled) return [];
+    return buildCategoryGroups({
+      placementTypes,
+      surfaceName,
+      availableKeys,
+      hasSelection,
+      excludedItemIds,
+      shortcuts,
+      categories,
+      contentBlocks: [...contentBlocks]
+    });
+  }, [
+    enabled,
+    placementTypes,
+    categories,
+    shortcuts,
+    contentBlocks,
+    surfaceName,
+    availableKeys,
+    hasSelection,
+    excludedItemIds
+  ]);
+  return {
+    categoryGroups,
+    loading: enabled && placementTypes.length > 0 && !rowsInHand && error === null,
+    // Rows in hand end a failure too: a fetch that landed after the menu's
+    // deadline must not leave a "Couldn't load" row beside the rows it brought.
+    error: rowsInHand ? null : error,
+    refresh
+  };
+}
+
+// src/engine/hooks/useContextMenuActions.ts
+import { BASELINE_VALUE_NAMES as BASELINE_VALUE_NAMES2 } from "@ai-matrx/chat/surfaces/manifests/_baseline.manifest";
+import { useSurfaceConfig } from "@ai-matrx/chat/surfaces/hooks/useSurfaceConfig";
+import { useSurfaceBoundAgents } from "@ai-matrx/chat/surfaces/hooks/useSurfaceBoundAgents";
+
+// src/engine/value-resolution.ts
+import { withBaselineScope } from "@ai-matrx/chat/surfaces/utils/baseline-scope";
+import {
+  BASELINE_VALUE_NAMES
+} from "@ai-matrx/chat/surfaces/manifests/_baseline.manifest";
+import {
+  getSurfaceRuntime,
+  getSurfaceRuntimeForName
+} from "@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 isDev2 = process.env.NODE_ENV !== "production";
+function strOf(value) {
+  return typeof value === "string" ? value : "";
+}
+function adoptMountedRuntimeScope(surfaceName) {
+  try {
+    const mounted = surfaceName ? getSurfaceRuntimeForName(surfaceName) : getSurfaceRuntime();
+    if (!mounted) return null;
+    const payload = mounted.getScope();
+    if (payload && typeof payload.then === "function")
+      return null;
+    return payload;
+  } catch (err) {
+    if (isDev2)
+      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 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 detectInertMenu(args) {
+  const reasons = [];
+  const selection = strOf(args.scope.selection).trim();
+  const content = strOf(args.scope.content).trim();
+  const baseline = new Set(
+    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(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 (!isDev2) 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
+import { registerLaunchWidgetHandle } from "@ai-matrx/chat/agents/utils/launch-widget-handles";
+
+// src/engine/utils/json-menu-actions.ts
+import { detectJson } from "@ai-matrx/kit/json-format";
+import { formatJsonText } from "@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 = 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 = 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 = 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 };
+}
+
+// src/engine/managed-agent-launch.ts
+var MANAGED_CONTEXT_MENU_AGENT_CONFIG = {
+  displayMode: "flexible-panel",
+  allowChat: true,
+  showVariablePanel: true
+};
+
+// src/engine/hooks/useContextMenuActions.ts
+import { AGENT_ICON as AGENT_ICON2 } from "@ai-matrx/icons/domain";
+var DEFAULT_PLACEMENT_MODE = {
+  "ai-action": "show",
+  "bound-agent": "show",
+  "content-block": "show",
+  "organization-tool": "show",
+  "user-tool": "show",
+  "quick-action": "show"
+};
+var ALL_DB_PLACEMENTS = [
+  "ai-action",
+  "content-block",
+  "organization-tool",
+  "user-tool"
+];
+var PLACEMENT_LABEL_OVERRIDE = {
+  [PLACEMENT_TYPES.USER_TOOL]: "My Items",
+  [PLACEMENT_TYPES.ORGANIZATION_TOOL]: "Org Items"
+};
+var PLACEMENT_COLOR = {
+  [PLACEMENT_TYPES.AI_ACTION]: "#0ea5e9",
+  [PLACEMENT_TYPES.CONTENT_BLOCK]: "#8b5cf6",
+  [PLACEMENT_TYPES.ORGANIZATION_TOOL]: "#f59e0b",
+  [PLACEMENT_TYPES.USER_TOOL]: "#10b981"
+};
+function getPlacementIcon(placementType) {
+  switch (placementType) {
+    case PLACEMENT_TYPES.AI_ACTION:
+      return Rocket;
+    case PLACEMENT_TYPES.CONTENT_BLOCK:
+      return FileText;
+    case PLACEMENT_TYPES.ORGANIZATION_TOOL:
+      return Building;
+    case PLACEMENT_TYPES.USER_TOOL:
+      return User;
+    default:
+      return FileText;
+  }
+}
+function getPlacementLabel(placementType) {
+  return PLACEMENT_LABEL_OVERRIDE[placementType] ?? PLACEMENT_TYPE_META[placementType]?.label ?? placementType;
+}
+function resolveIcon(iconName, fallback = "FileText") {
+  return getIconComponent(iconName ?? fallback, fallback);
+}
+function groupsByPlacement(groups) {
+  const map = {};
+  for (const g of groups) {
+    (map[placementGroupKey2(g.category.placementType)] ??= []).push(g);
+  }
+  return map;
+}
+function hasItemsRecursive(group) {
+  if (group.items.length > 0) return true;
+  return group.children.some(hasItemsRecursive);
+}
+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 };
+}
+function useContextMenuActions(props) {
+  const {
+    sourceFeature,
+    surfaceName,
+    menuVersion,
+    getApplicationScope,
+    contextData,
+    selectedText,
+    selectionRange,
+    fallbackContent,
+    placementMode,
+    scope: shortcutScope,
+    scopeId,
+    extraSections,
+    isEditable,
+    editorId,
+    getTextarea,
+    insertAtCaret,
+    onContentInserted,
+    onTextReplace,
+    onTextInsertAfter,
+    onDelete,
+    onUndo,
+    onRedo,
+    widgetHandleId
+  } = props;
+  const dispatch = useAppDispatch2();
+  const store = useAppStore();
+  const host = useContextMenuHostBindings();
+  const entity = props.entity;
+  const resolvedPlacementMode = {
+    ...DEFAULT_PLACEMENT_MODE,
+    ...placementMode ?? {}
+  };
+  const dbPlacementTypes = ALL_DB_PLACEMENTS.filter(
+    (p) => resolvedPlacementMode[p] !== "hide"
+  );
+  const activeOrganizationId = useAppSelector2(selectOrganizationId);
+  const activeScopeIds = host.activeScopeIds;
+  const scope = resolveApplicationScope({
+    getApplicationScope,
+    contextData,
+    selectedText,
+    selectionRange,
+    fallbackContent,
+    surfaceName,
+    ambient: {
+      active_organization_id: activeOrganizationId ?? null,
+      active_scope_ids: activeScopeIds ?? [],
+      surface_name: surfaceName ?? null
+    }
+  });
+  const scopeKeySignature = Object.keys(scope).sort().join("|");
+  const availableKeys = useMemo2(
+    () => (0, requirement_gate_exports.buildAvailableKeys)(compact({
+      baselineValueNames: BASELINE_VALUE_NAMES2,
+      declaredValueNames: surfaceName ? getContextMenuHost().getSurfaceManifest(surfaceName)?.values.map((v) => v.name) : void 0,
+      // `scope` is rebuilt every render but its KEY SET is stable for an
+      // open, so the signature — not the object — is the dependency.
+      runtimeScopeKeys: scopeKeySignature.split("|").filter(Boolean)
+    })),
+    [surfaceName, scopeKeySignature]
+  );
+  const { getNamespace: getSurfaceNamespace } = useSurfaceConfig(
+    surfaceName ?? "matrx-unregistered/context-menu"
+  );
+  const menuSurfaceConfig = getSurfaceNamespace("menu");
+  const excludedItemIds = useMemo2(
+    () => new Set(menuSurfaceConfig?.excludedItemIds ?? []),
+    [menuSurfaceConfig]
+  );
+  const {
+    categoryGroups,
+    loading,
+    error: librariesError,
+    refresh
+  } = useUnifiedAgentContextMenu({
+    placementTypes: dbPlacementTypes,
+    surfaceName,
+    availableKeys,
+    hasSelection: String(scope.selection ?? "").trim().length > 0,
+    excludedItemIds,
+    enabled: dbPlacementTypes.length > 0,
+    scope: shortcutScope,
+    scopeId
+  });
+  const {
+    sections: boundAgentSections,
+    loading: boundAgentsFetching,
+    settled: boundAgentsSettled,
+    error: boundAgentsError,
+    refresh: refreshBoundAgents
+  } = useSurfaceBoundAgents(surfaceName, { isEditable });
+  const boundAgentsLoading = boundAgentsFetching || !boundAgentsSettled;
+  const { launchShortcut, launchAgent } = useAgentLauncher();
+  const { speak } = useSpeech({ processMarkdown: true, label: "Selected text" });
+  const { roles: surfaceAgentRoles } = useSurfaceAgentRoles(
+    surfaceName ?? "matrx-unregistered/context-menu"
+  );
+  const {
+    openListenSummaryWindow,
+    quickActions,
+    openDiffWindow,
+    openFindReplace,
+    openReferencePicker,
+    openContextAssignment,
+    openLinkRecordSheet,
+    openShareModalWindow,
+    openStateViewer,
+    openSurfaceInspector,
+    hasCompareBase
+  } = host;
+  const currentUserId = useAppSelector2(selectUserId);
+  const isAdmin = host.isAdminDebugger;
+  const hasAdminPower = host.hasAdminPower;
+  const organizationId = useAppSelector2(selectOrganizationId);
+  const isDebugMode = host.isDebugMode;
+  const isAdminIndicatorOpen = host.isAdminIndicatorOpen;
+  useEffect2(() => {
+    void refresh();
+    void refreshBoundAgents();
+  }, []);
+  const actionText = resolveActionText(scope);
+  const richDocSource = props.contentSource ?? { type: "raw" };
+  const richDocAdapter = getSourceAdapter(richDocSource.type);
+  const richPrefix = richDocSource.type === "raw" ? `${richDocAdapter.instanceKeyPrefix(richDocSource)}-${shortHash(actionText.text).slice(0, 8)}` : richDocAdapter.instanceKeyPrefix(richDocSource);
+  const richDocCtx = {
+    content: actionText.text,
+    source: richDocSource,
+    metadata: null,
+    dispatch,
+    getState: store.getState,
+    organizationId,
+    isAuthenticated: Boolean(currentUserId),
+    isAdmin: hasAdminPower,
+    isCreator: false,
+    surfaceKey: surfaceName ?? null,
+    onClose: () => {
+    },
+    instanceKey: (prefix) => `${richPrefix}-${prefix}`,
+    sourceAdapter: richDocAdapter,
+    applicationScope: scope,
+    ...props.richDocCtxExtras ?? {}
+  };
+  const textAgentCallbacks = editorTextAgentCallbacks(richDocCtx.callbacks, richDocSource, richDocAdapter, props.requestTextAgentReview);
+  if (textAgentCallbacks) richDocCtx.callbacks = textAgentCallbacks;
+  const excludedRichActionIds = [
+    ...props.excludedRichActions ?? [],
+    ...actionsAlreadyHere({
+      sourceType: richDocSource.type,
+      surfaceName,
+      isEditable: Boolean(isEditable)
+    })
+  ];
+  const richActions = actionText.source !== "none" ? resolveActions(richDocCtx, compact({
+    exclude: excludedRichActionIds,
+    extra: props.extraRichActions
+  })) : [];
+  const registryActions = registryMenuActions(richActions);
+  const copyVariantActions = richActions.filter((a) => a.category === "copy");
+  const exportActions = richActions.filter(
+    (a) => a.category === "export" || a.id === "save-as-file"
+  );
+  const convertActions = richActions.filter(
+    (a) => a.category === "save" && a.id !== "save-as-file"
+  );
+  useEffect2(() => {
+    reportMenuDiagnostics({
+      surfaceName,
+      scope,
+      isEditable,
+      hasExtraSections: Boolean(extraSections && extraSections.length > 0)
+    });
+  }, []);
+  const handleCopy = async () => {
+    if (!actionText.text) return;
+    if (!await kitCopyText(actionText.text)) {
+      getContextMenuHost().showManualCopy({ text: actionText.text });
+    }
+  };
+  const handleSpeak = () => {
+    if (actionText.text.trim()) speak(actionText.text);
+  };
+  const { roles: listenHomeRoles } = useSurfaceAgentRoles(
+    getContextMenuHost().listeningHomeSurface
+  );
+  const spokenSummaryRole = surfaceAgentRoles.spoken_summary?.effectiveAgentId ? surfaceAgentRoles.spoken_summary : listenHomeRoles.spoken_summary;
+  const spokenSummaryAgentId = spokenSummaryRole?.effectiveAgentId ?? null;
+  const openSpokenSummary = (autoPlay) => {
+    if (!spokenSummaryAgentId || !actionText.text.trim()) return;
+    primeAudioOutput();
+    openListenSummaryWindow({
+      agentId: spokenSummaryAgentId,
+      agentName: spokenSummaryRole?.role.label ?? null,
+      sourceText: actionText.text,
+      style: "Extremely Concise Summary",
+      autoPlay
+    });
+  };
+  const handleSpokenSummary = () => openSpokenSummary(false);
+  const handleSpokenSummaryLive = () => openSpokenSummary(true);
+  const handleCut = async () => {
+    if (!selectionRange || selectionRange.type !== "editable") return;
+    const element = selectionRange.element;
+    if (!(element instanceof HTMLTextAreaElement) && !(element instanceof HTMLInputElement))
+      return;
+    const { start, end } = selectionRange;
+    const cutText = element.value.substring(start, end);
+    if (!await kitCopyText(cutText)) {
+      getContextMenuHost().showManualCopy({ text: cutText, title: "Copy manually (cut was blocked)" });
+      return;
+    }
+    if (onTextReplace) {
+      onTextReplace(
+        element.value.substring(0, start) + element.value.substring(end)
+      );
+    } else {
+      (0, selection_tracking_exports.spliceInputValue)(element, start, end, "");
+    }
+  };
+  const handlePaste = async () => {
+    if (!isEditable || !selectionRange || selectionRange.type !== "editable")
+      return;
+    const element = selectionRange.element;
+    if (!(element instanceof HTMLTextAreaElement) && !(element instanceof HTMLInputElement))
+      return;
+    const text = await kitReadText();
+    if (text === null) {
+      toast2({ title: "Couldn't read the clipboard", variant: "destructive" });
+      return;
+    }
+    const { start, end } = selectionRange;
+    if (onTextReplace) {
+      onTextReplace(
+        element.value.substring(0, start) + text + element.value.substring(end)
+      );
+    } else {
+      (0, selection_tracking_exports.spliceInputValue)(element, start, end, text);
+    }
+  };
+  const editableTarget = isEditable && selectionRange?.type === "editable" ? selectionRange.element : null;
+  const canWriteJson = editableTarget instanceof HTMLTextAreaElement || editableTarget instanceof HTMLInputElement;
+  const jsonSection = buildJsonMenuSection({
+    text: actionText.text,
+    canWrite: canWriteJson,
+    onReplace: (next) => {
+      if (!canWriteJson || !selectionRange || selectionRange.type !== "editable")
+        return;
+      const element = selectionRange.element;
+      if (!(element instanceof HTMLTextAreaElement) && !(element instanceof HTMLInputElement))
+        return;
+      const { start, end } = actionText.source === "selection" ? selectionRange : { start: 0, end: element.value.length };
+      if (onTextReplace) {
+        onTextReplace(
+          element.value.substring(0, start) + next + element.value.substring(end)
+        );
+      } else {
+        (0, selection_tracking_exports.spliceInputValue)(element, start, end, next);
+      }
+    },
+    onCopy: async (next) => {
+      if (await kitCopyText(next)) {
+        toast2({ title: "Copied", description: "JSON copied to clipboard." });
+      } else {
+        getContextMenuHost().showManualCopy({ text: next });
+      }
+    }
+  });
+  const handleSelectAll = () => {
+    if (!selectionRange) {
+      const field = getTextarea?.();
+      if (field) {
+        requestAnimationFrame(() => {
+          field.focus();
+          field.select();
+        });
+      }
+      return;
+    }
+    if (selectionRange.type === "editable") {
+      const element = selectionRange.element;
+      if (element instanceof HTMLTextAreaElement || element instanceof HTMLInputElement) {
+        requestAnimationFrame(() => {
+          element.focus();
+          element.select();
+        });
+      }
+    } else {
+      const container = selectionRange.containerElement;
+      if (!container) return;
+      requestAnimationFrame(() => {
+        try {
+          const range = document.createRange();
+          range.selectNodeContents(container);
+          const selection = window.getSelection();
+          if (selection) {
+            selection.removeAllRanges();
+            selection.addRange(range);
+          }
+        } catch {
+        }
+      });
+    }
+  };
+  const editableElement = (() => {
+    const fromRange = selectionRange?.type === "editable" ? selectionRange.element : null;
+    const el = fromRange ?? getTextarea?.() ?? null;
+    return el instanceof HTMLTextAreaElement || el instanceof HTMLInputElement ? el : null;
+  })();
+  const canNativeUndo = Boolean(isEditable && editableElement);
+  const runNativeEdit = (command) => {
+    if (!editableElement) return;
+    editableElement.focus();
+    try {
+      document.execCommand(command);
+    } catch (err) {
+      console.error(`[ContextMenuV3] native ${command} failed`, err);
+    }
+  };
+  const handleUndo = () => onUndo ? onUndo() : runNativeEdit("undo");
+  const handleRedo = () => onRedo ? onRedo() : runNativeEdit("redo");
+  const compareContent = () => actionText.source === "selection" ? { content: actionText.text, label: "Selection" } : { content: actionText.text, label: "Current" };
+  const handleCompareClipboard = async () => {
+    const { content, label } = compareContent();
+    const clip = await kitReadText();
+    if (clip === null) {
+      toast2({ title: "Couldn't read the clipboard", variant: "destructive" });
+      return;
+    }
+    if (!clip) {
+      toast2({ title: "Clipboard is empty" });
+      return;
+    }
+    openDiffWindow({
+      original: content,
+      modified: clip,
+      originalLabel: label,
+      modifiedLabel: "Clipboard",
+      title: "Compare with clipboard",
+      engine: "light"
+    });
+  };
+  const handleSetCompareBase = () => {
+    const { content, label } = compareContent();
+    host.setCompareBase({ content, label, language: null });
+    toast2({
+      title: "Set as compare base",
+      description: "Open another item and choose \u201CCompare with base\u201D."
+    });
+  };
+  const handleCompareWithBase = async () => {
+    const { content, label } = compareContent();
+    const opened = await host.openCompareWithBase({ current: content, currentLabel: label });
+    if (!opened) {
+      toast2({
+        title: "No compare base set",
+        description: "Choose \u201CSet as compare base\u201D on another item first."
+      });
+    }
+  };
+  const launchWidgetHandleId = () => registerLaunchWidgetHandle(
+    widgetHandleId,
+    isEditable ? buildSelectionWriteBack({
+      originalText: actionText.text,
+      textSource: actionText.source,
+      selectionRange,
+      onTextReplace,
+      onTextInsertAfter,
+      insertAtCaret
+    }) : null
+  );
+  const handleShortcutExecute = async (entry) => {
+    if (!entry.agentId) {
+      toast2({
+        title: "Agent Not Connected",
+        description: `"${entry.label}" has no connected agent. Configure it in the admin panel.`,
+        variant: "destructive"
+      });
+      return;
+    }
+    const resultDisplay = entry.displayMode ?? "modal-full";
+    try {
+      await launchShortcut(entry.id, scope, {
+        surfaceKey: `${sourceFeature}:${entry.id}`,
+        sourceFeature,
+        config: { displayMode: resultDisplay },
+        runtime: compact({
+          originalText: actionText.text,
+          surfaceName,
+          // Editable surfaces: let the agent stream widget_text_* edits
+          // straight into the surface, and give the person Replace / Insert
+          // below on the result (undefined on read-only — no tools).
+          widgetHandleId: launchWidgetHandleId()
+        })
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "An unknown error occurred";
+      toast2({
+        title: "Execution Failed",
+        description: `${entry.label}: ${message}`,
+        variant: "destructive"
+      });
+    }
+  };
+  const handleBoundAgentExecute = async (entry) => {
+    try {
+      await launchAgent(entry.agentId, {
+        surfaceKey: `${sourceFeature}:bound-agent:${entry.agentId}`,
+        sourceFeature,
+        // Managed entries share the WindowPanel default. autoRun is deliberately
+        // absent so the safe open-and-wait default remains authoritative.
+        config: MANAGED_CONTEXT_MENU_AGENT_CONFIG,
+        runtime: compact({
+          applicationScope: scope,
+          originalText: actionText.text,
+          surfaceName,
+          widgetHandleId: launchWidgetHandleId()
+        })
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "An unknown error occurred";
+      toast2({
+        title: "Execution Failed",
+        description: `${entry.name}: ${message}`,
+        variant: "destructive"
+      });
+    }
+  };
+  const insertTargets = { editorId, getTextarea, insertAtCaret, onTextReplace };
+  const handleContentBlockInsert = (entry) => {
+    const template = entry.template;
+    if (insertIntoEditor(insertTargets, template)) {
+      onContentInserted?.();
+      return;
+    }
+    void kitCopyText(template).then((copied) => {
+      if (copied) {
+        toast2({
+          title: "Copied to clipboard",
+          description: `"${entry.label}" can't be inserted here \u2014 this surface isn't editable.`
+        });
+      } else {
+        getContextMenuHost().showManualCopy({ text: template });
+      }
+    });
+  };
+  const handleEntrySelect = (entry) => {
+    if (entry.entryType === "agent_shortcut") void handleShortcutExecute(entry);
+    else handleContentBlockInsert(entry);
+  };
+  const handleDelete = async () => {
+    if (!onDelete) return;
+    const ok = await getContextMenuHost().confirm({
+      title: "Delete this item?",
+      description: "This action cannot be undone.",
+      confirmLabel: "Delete",
+      variant: "destructive"
+    });
+    if (ok) onDelete();
+  };
+  const handleFind = () => {
+    props.suppressSelectionRestore();
+    openFindReplace({
+      getTargetElement: () => selectionRange?.type === "editable" ? selectionRange.element : null,
+      onReplace: onTextReplace
+    });
+  };
+  const canInsertReference = isEditable && hasEditorInsertTarget(insertTargets);
+  const copyReference = (pick) => {
+    void kitCopyText(pick.fence).then((copied) => {
+      if (copied) {
+        toast2({
+          title: "Reference copied",
+          description: pick.title ? `Paste it anywhere to link "${pick.title}".` : "Paste it anywhere to render the link."
+        });
+      } else {
+        getContextMenuHost().showManualCopy({ text: pick.fence, title: "Copy the reference" });
+      }
+    });
+  };
+  const insertReference = (pick) => {
+    const inserted = insertIntoEditor(insertTargets, {
+      editor: `
+${pick.fence}
+`,
+      textarea: (field) => ownParagraph(pick.fence, field),
+      caret: pick.fence,
+      placement: "block"
+    });
+    if (inserted) {
+      onContentInserted?.();
+      return;
+    }
+    toast2({
+      title: "Copied instead",
+      description: "Couldn't insert here. Paste it where you want it."
+    });
+    copyReference(pick);
+  };
+  const handleInsertReference = () => {
+    props.suppressSelectionRestore();
+    openReferencePicker({
+      mode: canInsertReference ? "insert" : "copy",
+      onPicked: (pick) => {
+        if (pick.delivery === "insert" && canInsertReference) insertReference(pick);
+        else copyReference(pick);
+      }
+    });
+  };
+  const handleAttach = () => {
+    if (!entity) return;
+    openContextAssignment({
+      subject: {
+        entityType: entity.type,
+        entityId: entity.id,
+        title: entity.title
+      }
+    });
+  };
+  const handleLinkRecord = () => {
+    if (!entity) return;
+    openLinkRecordSheet({ target: { token: entity.type, id: entity.id, title: entity.title } });
+  };
+  const handleShare = () => {
+    if (!entity?.resourceType) return;
+    openShareModalWindow({
+      resourceType: entity.resourceType,
+      resourceId: entity.id,
+      resourceName: entity.title
+    });
+  };
+  const { openSurfaceContextWindow, openBindAgent } = host;
+  const resolvedSurfaceName = surfaceName ?? detectActiveSurface();
+  const surfaceLabel = resolvedSurfaceName ? getSurfaceDisplayLabel(resolvedSurfaceName) : "This page";
+  const related = getRelatedSurfaces(resolvedSurfaceName);
+  const copyText = (text) => {
+    void kitCopyText(text).then((copied) => {
+      if (copied) toast2({ title: "Copied", description: text });
+      else getContextMenuHost().showManualCopy({ text });
+    });
+  };
+  const surfaceAgentItems = [];
+  boundAgentSections.filter((section) => section.agents.length > 0).forEach((section, idx) => {
+    if (idx > 0)
+      surfaceAgentItems.push({ kind: "separator", id: `sa:${section.key}:sep` });
+    for (const agent of section.agents) {
+      surfaceAgentItems.push({
+        kind: "item",
+        id: `sa:${section.key}:${agent.agentId}`,
+        label: agent.name,
+        description: agent.organizationName ? `${section.label} \xB7 ${agent.organizationName}` : section.label,
+        icon: AGENT_ICON2,
+        onSelect: () => void handleBoundAgentExecute(agent)
+      });
+    }
+  });
+  if (surfaceAgentItems.length > 0)
+    surfaceAgentItems.push({ kind: "separator", id: "sa:bind-sep" });
+  surfaceAgentItems.push({
+    kind: "item",
+    id: "sa:bind",
+    label: "Bind an agent to this page\u2026",
+    icon: Plus,
+    disabled: !resolvedSurfaceName,
+    onSelect: () => {
+      if (resolvedSurfaceName) openBindAgent({ surfaceName: resolvedSurfaceName });
+    }
+  });
+  const relatedItems = [
+    ...related.ancestry,
+    ...related.children
+  ].map((ref) => ({
+    kind: "item",
+    id: `sr:${ref.name}`,
+    label: ref.label,
+    description: `${ref.kind === "ancestor" ? "Parent" : "Child"} \xB7 ${ref.name}`,
+    icon: AppWindow,
+    onSelect: () => openSurfaceContextWindow({ surfaceName: ref.name, isEditable: false })
+  }));
+  const surfaceChildren = [
+    // The surface key is an engineer's handle — admin-only (cold walk 20),
+    // like the Agents panel's sub-line. Everyone else sees the label only.
+    ...isAdmin ? [
+      {
+        kind: "item",
+        id: "surface:location",
+        label: resolvedSurfaceName ?? "No surface registered for this page",
+        ...resolvedSurfaceName ? { description: "Surface location \xB7 click to copy" } : {},
+        icon: ClipboardCopy,
+        disabled: !resolvedSurfaceName,
+        onSelect: () => resolvedSurfaceName && copyText(resolvedSurfaceName)
+      },
+      { kind: "separator", id: "surface:sep1" }
+    ] : [],
+    {
+      kind: "item",
+      id: "surface:context",
+      label: "Surface Context",
+      description: "Live page values",
+      icon: Braces,
+      disabled: !resolvedSurfaceName,
+      onSelect: () => {
+        if (!resolvedSurfaceName) return;
+        openSurfaceContextWindow({
+          surfaceName: resolvedSurfaceName,
+          isEditable: Boolean(isEditable)
+        });
+      }
+    },
+    ...hasAdminPower ? [
+      {
+        kind: "item",
+        id: "surface:context-admin",
+        label: "Surface Context Admin",
+        description: "Contract, provenance & settings",
+        icon: ShieldCheck,
+        onSelect: () => openSurfaceInspector({
+          surfaceName: resolvedSurfaceName ?? null,
+          scope,
+          isEditable: Boolean(isEditable),
+          preferRuntime: true
+        })
+      }
+    ] : [],
+    { kind: "separator", id: "surface:sep2" },
+    {
+      kind: "submenu",
+      id: "surface:agents",
+      label: "Agents on this page",
+      icon: AGENT_ICON2,
+      children: surfaceAgentItems
+    },
+    ...relatedItems.length > 0 ? [
+      {
+        kind: "submenu",
+        id: "surface:related",
+        label: "Related surfaces",
+        icon: Layers,
+        children: relatedItems
+      }
+    ] : [],
+    ...isAdmin ? [
+      { kind: "separator", id: "surface:sep3" },
+      {
+        kind: "item",
+        id: "surface:version",
+        label: `Menu v3.${types_exports.CANONICAL_MENU_VERSION_V3} \xB7 V${menuVersion}`,
+        description: "Menu revision \xB7 surface wiring version",
+        icon: Info,
+        onSelect: () => copyText(
+          `${resolvedSurfaceName ?? "(no surface)"} \xB7 v3.${types_exports.CANONICAL_MENU_VERSION_V3} \xB7 V${menuVersion}`
+        )
+      }
+    ] : []
+  ];
+  const surfaceSection = {
+    id: "surface-info",
+    items: [
+      {
+        kind: "submenu",
+        id: "surface",
+        label: surfaceLabel,
+        icon: AppWindow,
+        children: surfaceChildren
+      }
+    ]
+  };
+  const handleInspectValues = () => {
+    openSurfaceInspector({
+      surfaceName: surfaceName ?? null,
+      scope,
+      isEditable: Boolean(isEditable)
+    });
+  };
+  const handleInspectState = () => {
+    openStateViewer();
+  };
+  const handleToggleDebugMode = () => {
+    host.toggleDebugMode();
+  };
+  const handleToggleAdminIndicator = () => {
+    host.toggleAdminIndicator();
+  };
+  return {
+    scope,
+    actionText,
+    // A textarea/input, or a contenteditable field (chip / rich editor), names
+    // itself in the header — never "Content: {{reply.body}}".
+    fieldLabel: isEditable && selectionRange ? fieldLabelOf(selectionRange.element) : null,
+    jsonSection,
+    resolvedPlacementMode,
+    categoryGroups,
+    grouped: groupsByPlacement(categoryGroups),
+    loading,
+    librariesError,
+    boundAgentSections,
+    boundAgentsLoading,
+    boundAgentsError,
+    excludedRichActionIds,
+    retryLibraries: () => {
+      void refresh();
+      void refreshBoundAgents();
+    },
+    richDocCtx,
+    registryActions,
+    copyVariantActions,
+    exportActions,
+    convertActions,
+    hasCompareBase,
+    isAdmin,
+    isDebugMode,
+    isAdminIndicatorOpen,
+    canNativeUndo,
+    handleCopy,
+    handleSpeak,
+    handleSpokenSummary,
+    handleSpokenSummaryLive,
+    spokenSummaryAvailable: Boolean(spokenSummaryAgentId),
+    handleCut,
+    handlePaste,
+    handleSelectAll,
+    handleUndo,
+    handleRedo,
+    handleCompareClipboard,
+    handleSetCompareBase,
+    handleCompareWithBase,
+    handleShortcutExecute,
+    handleBoundAgentExecute,
+    handleContentBlockInsert,
+    handleEntrySelect,
+    handleDelete,
+    handleFind,
+    handleInsertReference,
+    handleAttach,
+    handleLinkRecord,
+    handleShare,
+    handleInspectValues,
+    handleInspectState,
+    handleToggleDebugMode,
+    handleToggleAdminIndicator,
+    quickActions,
+    surfaceSection
+  };
+}
+export {
+  ALL_DB_PLACEMENTS,
+  ContextMenuV3,
+  DEFAULT_PLACEMENT_MODE,
+  EditableContextMenu,
+  ItemContextMenuV3,
+  ItemMenuHostBinding,
+  MenuPresenceProvider,
+  MenuRegroupContext,
+  MenuRegroupProvider,
+  NonEditableContextMenu,
+  OpenSurfaceMenuButton,
+  PLACEMENT_COLOR,
+  PLACEMENT_LABEL_OVERRIDE,
+  PageSurfaceMenu,
+  RegistryMenuSourceProvider,
+  RegroupBoundary,
+  buildCategoryGroups,
+  contentSourceKey,
+  getPlacementIcon,
+  getPlacementLabel,
+  groupsByPlacement,
+  hasItemsRecursive,
+  reachedThroughPortal,
+  resolveIcon,
+  resolveRichActionView,
+  sameContentSource,
+  useContextMenuActions,
+  useIsInsideContextMenu,
+  useRegistryMenuSource,
+  useUnifiedAgentContextMenu,
+  warmMenuContent
+};
+//# sourceMappingURL=react.js.map