@ai-matrx/rich-content 0.2.10 → 0.2.15

package/dist/rich-document/variants/shared/menuStructure.js

@@ -0,0 +1,268 @@
+import {
+  Save,
+  Copy,
+  Share2,
+  Edit,
+  BarChart3,
+  Settings,
+  GitCompareArrows,
+  MessagesSquare
+} from "lucide-react";
+import { AGENT_ICON } from "@ai-matrx/icons/domain";
+const AI_SUBMENU_LABEL = "AI Actions";
+const CONVERSATION_SUBMENU_LABEL = "Conversation";
+const MENU_STRUCTURE = [
+  {
+    // The doors a reader must see without scrolling or guessing (defect D6:
+    // "Add to Rulebook" once sat twenty rows below the fold and read as
+    // missing). Every family of near-identical variants is ONE submenu row.
+    submenu: null,
+    actionIds: [
+      // A bar's primary buttons, for the menu-only hosts that have no bar
+      // (icon-only, menu variant). A menu under a bar never lists them.
+      "thumbs-up",
+      "thumbs-down",
+      "tts-play",
+      "continue-in-chat",
+      // Send THIS message onward — one family, adjacent, no heading (no
+      // approved name fits; "Ask in chat" was coined 2026-09-25).
+      "send-to-agent",
+      // An answer in a "Custom agent…" window goes back into the text it came from.
+      "apply-to-source",
+      // A good "Custom agent…" run, kept: as a shortcut or bound to the page.
+      "save-run-as-shortcut",
+      "bind-run-to-page",
+      "ask-followup",
+      "quote-into-chat",
+      "add-to-rulebook",
+      "save-to-task",
+      "pin-message",
+      // The record's Notes & comments dock (present only when it holds something).
+      "notes-and-comments",
+      "save-to-notes",
+      "summarize-and-listen",
+      "summarize-for-listening"
+    ]
+  },
+  {
+    // Everything that acts on the WHOLE conversation this message belongs to
+    // — the same verbs as the chat header's conversation menu, one row deep.
+    // Present only when the source carries a conversationId.
+    submenu: CONVERSATION_SUBMENU_LABEL,
+    icon: MessagesSquare,
+    target: true,
+    // Its rows mix find/ask/share/edit/export; "save" seats the section in
+    // the document group, right after the promoted rows and before "Save".
+    layoutCategory: "save",
+    actionIds: [
+      "conversation-find",
+      "conversation-pinned-only",
+      "conversation-share",
+      "conversation-copy-link",
+      "conversation-rename",
+      "conversation-duplicate"
+      // THE full Alchemy transfer set over the whole conversation (Arman,
+      // 2026-09-26) joins here from the host: extendMenuSection(CONVERSATION_SUBMENU_LABEL, ids).
+    ]
+  },
+  {
+    // Review-and-apply AI powers (a text field promotes these to the top —
+    // RegistryActionList; a document keeps them one row deep).
+    submenu: AI_SUBMENU_LABEL,
+    icon: AGENT_ICON,
+    inline: true,
+    actionIds: ["text-cleanup", "text-help", "text-custom-agent"]
+  },
+  {
+    // "Save" — the classic name (e5b8d01229, 2026-05-19); "Save as" was coined 2026-09-24.
+    submenu: "Save",
+    icon: Save,
+    actionIds: [
+      "save-as-message-template",
+      "save-as-flashcard",
+      // Flashcards / quiz from this message — the same family as the row
+      // above (folded 2026-09-26 to keep the menu within the 17-row D6 bound).
+      "convert-to-study",
+      "save-table-as-data",
+      "save-to-scratch",
+      "add-to-docs",
+      "save-as-file",
+      "save-to-code",
+      "save-to-files",
+      "save-code-to-scratch",
+      "save-as-pdf",
+      "save-shape-instance",
+      "save-to-contact",
+      "set-context-value"
+    ]
+  },
+  {
+    submenu: "Copy as",
+    icon: Copy,
+    actionIds: [
+      // The plain copy leads its own family (it sat as a loose top-level row
+      // beside "Copy as › plain text"; folded 2026-09-26 for the D6 bound).
+      "copy",
+      "copy-markdown",
+      "copy-plain-text",
+      "copy-with-thinking",
+      "copy-table-tsv",
+      "copy-table-csv",
+      "copy-html-source",
+      "copy-html-page"
+    ]
+  },
+  {
+    // "Export" — the classic name (e5b8d01229, 2026-05-19); "Share & export" was coined 2026-09-24.
+    submenu: "Export",
+    icon: Share2,
+    actionIds: [
+      "html-preview",
+      "share-webpage",
+      "send-google-doc",
+      "email-to-me",
+      "download-pdf",
+      "download-docx",
+      "download-html",
+      "print",
+      "full-print"
+    ]
+  },
+  {
+    submenu: "Compare",
+    icon: GitCompareArrows,
+    actionIds: [
+      "compare-with-clipboard",
+      "set-compare-base",
+      "compare-with-base"
+    ]
+  },
+  {
+    submenu: "Edit",
+    icon: Edit,
+    actionIds: [
+      "regenerate-response",
+      "regenerate-latest",
+      "edit",
+      "edit-and-resubmit",
+      "open-fullscreen-editor",
+      "edit-history",
+      "fork-at-message",
+      "fork-and-regenerate",
+      "delete-message"
+    ]
+  },
+  {
+    // Creator/admin power tools, one row: the analysis doors and the
+    // server-API test verbs (a separate "Server API (test)" row pushed the
+    // admin menu past the 17-row D6 bound).
+    submenu: "Creator tools",
+    icon: BarChart3,
+    actionIds: [
+      "analyze-response",
+      "debug-stream",
+      "server-api-admin-fork-at",
+      "server-api-admin-fork-before",
+      "server-api-admin-hide-from-model",
+      "server-api-admin-delete-this",
+      "server-api-admin-delete-from-here",
+      "server-api-admin-delete-dryrun",
+      "server-api-admin-replace-with-summary",
+      "server-api-admin-restore-compaction"
+    ]
+  },
+  {
+    // App doors that act on no content: feedback, and the read-aloud voice
+    // setting (the Listen button's settings door; a loose top-level row it
+    // was the 18th, below the fold — D6).
+    submenu: "App",
+    icon: Settings,
+    actionIds: ["submit-feedback", "tts-voice-settings"]
+  }
+];
+const PLACED_IDS = new Set(
+  MENU_STRUCTURE.flatMap((section) => section.actionIds)
+);
+const MENU_ALIASES = {
+  "regenerate-latest": "regenerate-response"
+};
+const LONE_AI_ROW_JOINS = "Edit";
+function buildMenuTree(input, options = {}) {
+  const present = new Set(input.map((a) => a.id));
+  const actions = input.filter((a) => {
+    const canonical = MENU_ALIASES[a.id];
+    return !(canonical && present.has(canonical));
+  });
+  const byId = /* @__PURE__ */ new Map();
+  for (const action of actions) byId.set(action.id, action);
+  let topLevel = [];
+  const submenus = [];
+  for (const section of MENU_STRUCTURE) {
+    const sectionActions = section.actionIds.map((id) => byId.get(id)).filter((a) => Boolean(a));
+    if (sectionActions.length === 0) continue;
+    if (section.submenu === null) {
+      topLevel = sectionActions;
+    } else {
+      submenus.push({
+        label: section.submenu,
+        icon: section.icon,
+        actions: sectionActions
+      });
+    }
+  }
+  const ai = submenus.find((s) => s.label === AI_SUBMENU_LABEL);
+  const home = submenus.find((s) => s.label === LONE_AI_ROW_JOINS);
+  if (!options.aiSlot && ai && ai.actions.length === 1 && home) {
+    home.actions = [...home.actions, ...ai.actions];
+    submenus.splice(submenus.indexOf(ai), 1);
+  }
+  const extras = actions.filter((a) => !PLACED_IDS.has(a.id));
+  return { topLevel, submenus, extras };
+}
+function registryMenuActions(actions) {
+  return actions.filter((a) => (a.renderSlot ?? "overflow") !== "primary");
+}
+function withAiSlot(submenus, hasSlot) {
+  if (!hasSlot || submenus.some((s) => s.label === AI_SUBMENU_LABEL)) return submenus;
+  const ai = {
+    label: AI_SUBMENU_LABEL,
+    icon: MENU_STRUCTURE.find((s) => s.submenu === AI_SUBMENU_LABEL)?.icon,
+    actions: []
+  };
+  const order = (label) => MENU_STRUCTURE.findIndex((s) => s.submenu === label);
+  const aiAt = order(AI_SUBMENU_LABEL);
+  const index = submenus.findIndex((s) => {
+    const at = order(s.label);
+    return at === -1 || at > aiAt;
+  });
+  if (index === -1) return [...submenus, ai];
+  return [...submenus.slice(0, index), ai, ...submenus.slice(index)];
+}
+function flattenMenuTreeIds(tree) {
+  return [
+    ...tree.topLevel.map((a) => a.id),
+    ...tree.submenus.flatMap((s) => [`submenu:${s.label}`, ...s.actions.map((a) => a.id)]),
+    ...tree.extras.map((a) => a.id)
+  ];
+}
+let structureVersion = 0;
+function menuStructureVersion() {
+  return structureVersion;
+}
+function extendMenuSection(submenu, actionIds) {
+  structureVersion++;
+  const section = MENU_STRUCTURE.find((s) => s.submenu === submenu);
+  if (!section) throw new Error(`[rich-document] no menu section named "${submenu}"`);
+  for (const id of actionIds) if (!section.actionIds.includes(id)) section.actionIds.push(id);
+}
+export {
+  AI_SUBMENU_LABEL,
+  CONVERSATION_SUBMENU_LABEL,
+  MENU_STRUCTURE,
+  buildMenuTree,
+  extendMenuSection,
+  flattenMenuTreeIds,
+  menuStructureVersion,
+  registryMenuActions,
+  withAiSlot
+};

package/dist/rich-document/variants/shared/runAction.d.ts

@@ -0,0 +1,17 @@
+import type { LucideIcon } from "lucide-react";
+import type { RichDocumentAction, RichDocumentActionContext } from "../../types.js";
+/**
+ * Fire an action's handler. Builds a fresh context via getCtx() at click
+ * time (so handlers see live content), then runs the handler fire-and-forget
+ * — handlers own their toasts/dialogs.
+ */
+export declare function runAction(action: RichDocumentAction, getCtx: () => RichDocumentActionContext): void;
+export interface ActionDisplay {
+    label: string;
+    Icon: LucideIcon;
+    iconColor?: string;
+    isDisabled: boolean;
+    disabledReason?: string;
+}
+/** Resolve an action's label / disabled-state against a context snapshot. */
+export declare function resolveActionDisplay(action: RichDocumentAction, ctx: RichDocumentActionContext): ActionDisplay;

package/dist/rich-document/variants/shared/runAction.js

@@ -0,0 +1,24 @@
+import { resolveActionLabel } from "../../actions/labels.js";
+import { holdDeliberateIntent } from "../../../host/app-bindings.js";
+function runAction(action, getCtx) {
+  const ctx = getCtx();
+  void holdDeliberateIntent(() => action.run(ctx)).catch((err) => {
+    console.error(`[RichDocument] action ${action.id} threw`, err);
+  });
+}
+function resolveActionDisplay(action, ctx) {
+  const disabledResult = action.disabled?.(ctx);
+  const isDisabled = disabledResult === true || typeof disabledResult === "object" && disabledResult !== null;
+  const disabledReason = typeof disabledResult === "object" && disabledResult !== null ? disabledResult.reason : void 0;
+  return {
+    label: resolveActionLabel(action.label, ctx),
+    Icon: action.stateIcon?.(ctx)?.icon ?? action.icon,
+    iconColor: action.iconColor,
+    isDisabled,
+    disabledReason
+  };
+}
+export {
+  resolveActionDisplay,
+  runAction
+};

package/dist/selection-toolbar/SelectionToolbarFrame.d.ts

@@ -0,0 +1,64 @@
+import * as React from "react";
+import type { ClickTarget } from "@ai-matrx/alchemy/actions";
+import type { SelectionMode } from "./selection-zones.js";
+export interface Rect {
+    left: number;
+    top: number;
+    bottom: number;
+    width: number;
+}
+/** The nearest ancestor that scrolls (or the viewport): the box the toolbar lives in. */
+export declare function scrollBoundsOf(node: Node | null): {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+type Box = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+/**
+ * The scroll box minus whatever pins itself over its top edge (a sticky page
+ * header, a fixed bar): a scroll area that runs UNDER a header has a top edge
+ * the person cannot see, and a toolbar placed "above the selection" there is
+ * clipped by it. Sampled on demand at the box's top edge, never cached.
+ */
+export declare function visibleBoxOf(box: Box, anchor: Node | null, at: {
+    left: number;
+    width: number;
+}): Box;
+/** Where the frame goes for an anchor inside a box (pure; unit-tested). */
+export declare function placeFrame(at: Rect, size: {
+    w: number;
+    h: number;
+}, box: {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}, viewport: {
+    w: number;
+    h: number;
+}): {
+    left: number;
+    top: number;
+    hidden: boolean;
+};
+export default function SelectionToolbarFrame({ seq, mode, target, text, range, rect, anchor, docked, focusSignal, panel, }: {
+    seq: number;
+    mode: SelectionMode;
+    target: ClickTarget;
+    text: string;
+    range: Range | null;
+    rect: Rect;
+    /** The node the selection lives in — its scroll container bounds the toolbar. */
+    anchor: Node | null;
+    docked: boolean;
+    /** Changes on every keyboard open (Ctrl/Cmd+Alt+M): focus the first control. */
+    focusSignal: number;
+    panel: React.ReactNode | null;
+}): React.ReactElement | null;
+export {};

package/dist/selection-toolbar/SelectionToolbarFrame.js

@@ -0,0 +1,191 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { createPortal } from "react-dom";
+import { SelectionToolbar } from "@ai-matrx/alchemy/react/selection";
+const GAP = 8;
+const EDGE = 8;
+function scrollBoundsOf(node) {
+  const view = { top: 0, bottom: window.innerHeight, left: 0, right: window.innerWidth };
+  let el = node instanceof Element ? node : node?.parentElement ?? null;
+  while (el && el !== document.body && el !== document.documentElement) {
+    const style = getComputedStyle(el);
+    if (/(auto|scroll|hidden)/.test(style.overflowY) && el.scrollHeight > el.clientHeight + 1) {
+      const r = el.getBoundingClientRect();
+      return {
+        top: Math.max(view.top, r.top),
+        bottom: Math.min(view.bottom, r.bottom),
+        left: Math.max(view.left, r.left),
+        right: Math.min(view.right, r.right)
+      };
+    }
+    el = el.parentElement;
+  }
+  return view;
+}
+function visibleBoxOf(box, anchor, at) {
+  if (typeof document.elementFromPoint !== "function") return box;
+  const x = Math.max(box.left + 1, Math.min(box.right - 1, at.left + at.width / 2));
+  const y = Math.max(0, box.top) + 1;
+  let el = document.elementFromPoint(x, y);
+  let inset = box.top;
+  while (el && el !== document.body && el !== document.documentElement) {
+    const position = getComputedStyle(el).position;
+    const owns = anchor ? el.contains(anchor) : false;
+    if ((position === "fixed" || position === "sticky") && !owns && !el.closest("[data-selection-toolbar]")) {
+      inset = Math.max(inset, el.getBoundingClientRect().bottom);
+    }
+    el = el.parentElement;
+  }
+  return { ...box, top: Math.min(inset, box.bottom) };
+}
+function placeFrame(at, size, box, viewport) {
+  const hidden = at.bottom <= box.top || at.top >= box.bottom;
+  let top = at.top - size.h - GAP;
+  if (top < box.top + EDGE) top = at.bottom + GAP;
+  top = Math.max(box.top + EDGE, Math.min(Math.min(box.bottom, viewport.h) - size.h - EDGE, top));
+  const left = Math.max(EDGE, Math.min(viewport.w - size.w - EDGE, at.left + at.width / 2 - size.w / 2));
+  return { left, top, hidden };
+}
+function SelectionToolbarFrame({
+  seq,
+  mode,
+  target,
+  text,
+  range,
+  rect,
+  anchor,
+  docked,
+  focusSignal,
+  panel
+}) {
+  const frameRef = React.useRef(null);
+  const current = React.useRef(0);
+  const [position, setPosition] = React.useState(null);
+  const place = React.useCallback(() => {
+    const frame = frameRef.current;
+    if (!frame || frame.offsetHeight === 0) return;
+    let at = rect;
+    if (range) {
+      const live = range.getBoundingClientRect();
+      if (live.width || live.height) at = { left: live.left, top: live.top, bottom: live.bottom, width: live.width };
+    }
+    const next = placeFrame(
+      at,
+      { w: frame.offsetWidth, h: frame.offsetHeight },
+      visibleBoxOf(scrollBoundsOf(anchor), anchor, at),
+      { w: window.innerWidth, h: window.innerHeight }
+    );
+    setPosition((p) => p && p.left === next.left && p.top === next.top && p.hidden === next.hidden ? p : next);
+  }, [rect, range, anchor]);
+  React.useLayoutEffect(() => {
+    if (docked) return;
+    place();
+    const frame = frameRef.current;
+    const ro = frame && typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => place()) : null;
+    if (frame) ro?.observe(frame);
+    const mo = frame && typeof MutationObserver !== "undefined" ? new MutationObserver(() => place()) : null;
+    if (frame) mo?.observe(frame, { childList: true, subtree: true });
+    window.addEventListener("scroll", place, true);
+    window.addEventListener("resize", place);
+    return () => {
+      ro?.disconnect();
+      mo?.disconnect();
+      window.removeEventListener("scroll", place, true);
+      window.removeEventListener("resize", place);
+    };
+  }, [docked, place, panel]);
+  const buttons = () => [...frameRef.current?.querySelectorAll("[role=toolbar] button:not([disabled])") ?? []];
+  React.useEffect(() => {
+    const frame = frameRef.current;
+    if (!frame || panel) return;
+    const apply = () => {
+      const list = buttons();
+      if (list.length === 0) return;
+      if (current.current >= list.length) current.current = 0;
+      list.forEach((b, i) => {
+        const want = i === current.current ? "0" : "-1";
+        if (b.getAttribute("tabindex") !== want) b.setAttribute("tabindex", want);
+      });
+    };
+    apply();
+    const mo = new MutationObserver(apply);
+    mo.observe(frame, { childList: true, subtree: true });
+    const onFocusIn = (e) => {
+      const at = buttons().indexOf(e.target);
+      if (at >= 0 && at !== current.current) {
+        current.current = at;
+        apply();
+      }
+    };
+    frame.addEventListener("focusin", onFocusIn);
+    return () => {
+      mo.disconnect();
+      frame.removeEventListener("focusin", onFocusIn);
+    };
+  }, [seq, panel]);
+  React.useEffect(() => {
+    if (!focusSignal) return;
+    let tries = 0;
+    let id = 0;
+    const focusFirst = () => {
+      const first = buttons()[0];
+      if (first) {
+        current.current = 0;
+        first.focus();
+      } else if (tries++ < 20) id = requestAnimationFrame(focusFirst);
+    };
+    id = requestAnimationFrame(focusFirst);
+    return () => cancelAnimationFrame(id);
+  }, [focusSignal]);
+  const onKeyDown = (e) => {
+    if (panel) return;
+    const keys = ["ArrowRight", "ArrowLeft", "ArrowDown", "ArrowUp", "Home", "End"];
+    if (!keys.includes(e.key)) return;
+    const list = buttons();
+    if (list.length === 0) return;
+    e.preventDefault();
+    const at = list.indexOf(document.activeElement);
+    const next = e.key === "Home" ? 0 : e.key === "End" ? list.length - 1 : e.key === "ArrowRight" || e.key === "ArrowDown" ? (at + 1) % list.length : (at - 1 + list.length) % list.length;
+    current.current = next;
+    list.forEach((b, i) => b.setAttribute("tabindex", i === next ? "0" : "-1"));
+    list[next].focus();
+  };
+  if (typeof document === "undefined") return null;
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: frameRef,
+        "data-selection-toolbar": docked ? "docked" : "floating",
+        "data-selection-mode": mode,
+        onKeyDown,
+        className: docked ? "fixed inset-x-2 z-[9999] flex justify-center" : "fixed z-[9999]",
+        style: docked ? { bottom: "calc(env(safe-area-inset-bottom, 0px) + 8px)" } : {
+          left: position?.left ?? -1e4,
+          top: position?.top ?? -1e4,
+          ...position && !position.hidden ? {} : { visibility: "hidden" }
+        },
+        children: panel ? (
+          // A panel that draws in its own layer (the record sheet) leaves this
+          // wrapper empty — then it takes no space and shows no chrome.
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              "data-selection-panel": "",
+              className: "w-[min(340px,calc(100vw-16px))] rounded-lg border border-border bg-popover p-1 text-popover-foreground shadow-lg empty:hidden",
+              children: panel
+            }
+          )
+        ) : /* @__PURE__ */ jsx(SelectionToolbar, { target, content: text, className: docked ? "max-w-full" : void 0 }, seq)
+      }
+    ),
+    document.body
+  );
+}
+export {
+  SelectionToolbarFrame as default,
+  placeFrame,
+  scrollBoundsOf,
+  visibleBoxOf
+};

package/dist/selection-toolbar/common-actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionProvider } from "@ai-matrx/alchemy/actions";
+export declare const selectionCommonProvider: ActionProvider;

package/dist/selection-toolbar/common-actions.js

@@ -0,0 +1,103 @@
+import { ClipboardCopy, NotebookPen, Table2 } from "lucide-react";
+import { hasTableShape } from "@ai-matrx/records-ui/table-shape";
+import { registerAlchemyIcon } from "../utils/alchemy-icon-keys.js";
+import {
+  SELECTION_COMMON_HOST_KEY,
+  declareSelectionProvider,
+  hostHalf,
+  placeSelectionActions,
+  selectionToolbarHostOf,
+  shownInSelectionMode
+} from "./selection-actions.js";
+function commonOf(target) {
+  const half = hostHalf(target, SELECTION_COMMON_HOST_KEY);
+  return half?.kind === "selection-common" && half.text ? half : null;
+}
+function rowsTextOf(common) {
+  if (common.shapeText && hasTableShape(common.shapeText)) return common.shapeText;
+  return common.text;
+}
+function copyEligible(id) {
+  return (t) => commonOf(t) && shownInSelectionMode(id, t) ? { status: "available" } : { status: "absent" };
+}
+function eligible(id) {
+  return (t) => commonOf(t) && !hostHalf(t, "annotation") && shownInSelectionMode(id, t) ? { status: "available" } : { status: "absent" };
+}
+const COPY_FLAVORS = [
+  { id: "selection:copy", label: "Copy", flavor: "default", order: 0, placement: "primary" },
+  { id: "selection:copy-markdown", label: "Copy markdown", flavor: "markdown", order: 1, placement: "overflow" },
+  { id: "selection:copy-text", label: "Copy text", flavor: "text", order: 2, placement: "overflow" }
+];
+const ACTIONS = [
+  // THE one copy module (copy-commands.ts, selection-copy.ts): Copy writes
+  // the formatted selection AND the knob's plain flavor (markdown by default);
+  // Copy markdown and Copy text are the explicit choices, under More.
+  ...COPY_FLAVORS.map(
+    ({ id, label, flavor, order, placement }) => ({
+      id,
+      label,
+      icon: registerAlchemyIcon(ClipboardCopy),
+      category: "copy",
+      order,
+      placement,
+      preserveSelection: true,
+      eligible: copyEligible(id),
+      run: async (t) => {
+        const common = commonOf(t);
+        if (!common) return;
+        const { copyRenderedSelection, renderedSelectionRange } = await import("./selection-copy.js");
+        const { copyRichContent } = await import("../copy/copy-commands.js");
+        const ok = renderedSelectionRange() ? await copyRenderedSelection(flavor, common.shapeText ?? common.text) : await copyRichContent(common.text, flavor, { toast: false });
+        if (ok) (await import("../host/toast.js")).toast.success(flavor === "default" ? "Copied" : flavor === "markdown" ? "Markdown copied" : "Text copied");
+      }
+    })
+  ),
+  {
+    id: "selection:save-to-notes",
+    label: "Save to notes",
+    icon: registerAlchemyIcon(NotebookPen),
+    category: "save",
+    order: 0,
+    placement: "primary",
+    preserveSelection: true,
+    eligible: eligible("selection:save-to-notes"),
+    run: (t) => {
+      const common = commonOf(t);
+      if (!common) return;
+      selectionToolbarHostOf(t)?.ui.close();
+      common.saveToNotes(common.text);
+    }
+  },
+  {
+    // THE ONE "Save to a table" (SAVE-AS-TABLE-EVERYWHERE, 2026-09-29): offered only when the
+    // selected text reads as rows — a table, a list or a few bullets, Key: value lines, CSV/TSV.
+    id: "selection:save-to-table",
+    label: "Save to a table",
+    icon: registerAlchemyIcon(Table2),
+    category: "save",
+    order: 1,
+    placement: "overflow",
+    preserveSelection: true,
+    // Offered in every mode the table allows, Read (annotated) included — only the words decide.
+    eligible: (t) => {
+      const common = commonOf(t);
+      return common && shownInSelectionMode("selection:save-to-table", t) && hasTableShape(rowsTextOf(common)) ? { status: "available" } : { status: "absent" };
+    },
+    run: (t) => {
+      const common = commonOf(t);
+      if (!common) return;
+      selectionToolbarHostOf(t)?.ui.close();
+      common.saveToTable(rowsTextOf(common));
+    }
+  }
+];
+const selectionCommonProvider = {
+  id: "selection-common",
+  tier: "T0",
+  declaredIds: () => ACTIONS.map((a) => a.id),
+  actions: (target) => commonOf(target) ? placeSelectionActions(ACTIONS, target) : []
+};
+declareSelectionProvider(selectionCommonProvider);
+export {
+  selectionCommonProvider
+};