synabun 2.0.10 → 2.2.0

package/neural-interface/public/shared/cli-install-view.js

@@ -2,7 +2,8 @@
 // SynaBun Neural Interface — the CLI banner of the side panels: what it says
 // ═══════════════════════════════════════════
 //
-// What the Claude Code, Codex and OpenCode panels show above their transcript
+// What the Claude Code, Codex and OpenCode panels show above their transcript (and the Antigravity panel's setup
+// card words its install steps with)
 // for one CLI: nothing while it is installed, "not installed" with a one-click
 // Install (the vendor's own installer, run by the server: POST
 // /api/cli/install/:tool) and the command to run by hand, the progress of an
@@ -34,8 +35,8 @@ export const CLI_INSTALL_COPY = Object.freeze({
   stepPath: 'Adding the CLI folder to your PATH…',
   stepPathAdded: 'Added {dir} to your PATH',
   bodyMissing: 'Install it with one click from {vendor}\'s official installer, or run:',
-  bodyMissingArchive: 'Install it with one click from {vendor}\'s official release, or run:',
   bodyMissingManual: 'Install it with this command, then re-check:',
+  bodyMissingGuide: 'Follow its install guide, then re-check.',
   bodyBroken: '{label} was found at {path}, but it could not be started:',
   bodyBrokenVersion: '{label} {version} was found at {path}, but it could not be started:',
   bodyBrokenLatched: '{label} is installed, but it could not be started:',
@@ -50,8 +51,6 @@ export const CLI_INSTALL_COPY = Object.freeze({
   stepDownloadReceived: 'Downloading: {received} MB',
   stepVerify: 'Checking the download…',
   stepRun: 'Running the official installer…',
-  stepExtract: 'Unpacking…',
-  stepPlace: 'Putting it in place…',
   stepCheck: 'Checking that it starts…',
   errorOffline: 'The download server could not be reached. Check the connection and try again.',
   errorHttp: 'The download server answered with an error. Try again in a moment.',
@@ -60,7 +59,6 @@ export const CLI_INSTALL_COPY = Object.freeze({
   errorTimeout: 'The installer took too long and was stopped.',
   errorInstallerFailed: 'The official installer stopped with an error.',
   errorNotFound: 'The installer finished, but SynaBun does not find {label} afterwards.',
-  errorUnpack: 'The download could not be unpacked, so it was removed.',
   errorDisk: 'The files could not be written. Check free space and permissions, then try again.',
   errorCancelled: 'The installation was stopped.',
   errorUnsupported: 'There is no one-click install for this system. Use the command below or the install guide.',
@@ -84,24 +82,24 @@ export const CLI_VENDORS = Object.freeze({
   'claude-code': 'Anthropic',
   codex: 'OpenAI',
   opencode: 'OpenCode',
-  gemini: 'Google',
+  antigravity: 'Google',
 });
 
 /** The CLIs a server can install with one click (POST /api/cli/install/:tool). */
-export const INSTALLABLE_CLIS = Object.freeze(['claude-code', 'codex', 'opencode']);
+export const INSTALLABLE_CLIS = Object.freeze(['claude-code', 'codex', 'opencode', 'antigravity']);
 
 /** The steps an install reports (`{ type: 'step' }`), in the order they can come. */
-export const INSTALL_STEPS = Object.freeze(['start', 'download', 'verify', 'run', 'extract', 'place', 'check', 'path']);
+export const INSTALL_STEPS = Object.freeze(['start', 'download', 'verify', 'run', 'check', 'path']);
 
 const STEP_COPY = Object.freeze({
   start: 'stepStart', download: 'stepDownload', verify: 'stepVerify', run: 'stepRun',
-  extract: 'stepExtract', place: 'stepPlace', check: 'stepCheck', path: 'stepPath',
+  check: 'stepCheck', path: 'stepPath',
 });
 
 const ERROR_COPY = Object.freeze({
   offline: 'errorOffline', http: 'errorHttp', checksum: 'errorChecksum', interrupted: 'errorInterrupted',
   timeout: 'errorTimeout', 'installer-failed': 'errorInstallerFailed', 'not-found-after-install': 'errorNotFound',
-  unpack: 'errorUnpack', disk: 'errorDisk', cancelled: 'errorCancelled', unsupported: 'errorUnsupported',
+  disk: 'errorDisk', cancelled: 'errorCancelled', unsupported: 'errorUnsupported',
   refused: 'errorRefused', connection: 'errorConnection',
 });
 
@@ -375,9 +373,10 @@ export function cliBannerView({ toolKey, label = '', info = null, forced = null,
         recheck: true,
       });
     }
+    // No command at all (none from the server, and none on the page either): the guide only.
     const text = offer
-      ? t(offer.method === 'archive' ? 'bodyMissingArchive' : 'bodyMissing', { vendor: CLI_VENDORS[toolKey] || name, label: name })
-      : t('bodyMissingManual');
+      ? t('bodyMissing', { vendor: CLI_VENDORS[toolKey] || name, label: name })
+      : t(command ? 'bodyMissingManual' : 'bodyMissingGuide');
     return Object.assign(view, {
       show: true, blocked: true, kind: 'missing', tone: 'warn', icon: '!',
       title: t('titleMissing', { label: name }),

package/neural-interface/public/shared/cli-status.js

@@ -1,6 +1,6 @@
 // ═══════════════════════════════════════════
 // SynaBun — CLI Status (shared)
-// Detects whether Claude / Codex / OpenCode CLIs are installed by
+// Detects whether Claude / Codex / OpenCode / Antigravity CLIs are installed by
 // querying /api/system/tool-versions. Caches the response, fans out
 // updates to subscribers, and auto-polls (every 30s) while at least
 // one subscribed tool is not installed (missing, or found but broken).
@@ -17,33 +17,34 @@ import { cliStateOf, cliInstallOffer, INSTALLABLE_CLIS } from './cli-install-vie
 
 export { cliStateOf, cliInstallOffer };
 
-const TOOL_KEYS = ['claude-code', 'codex', 'opencode', 'gemini'];
+const TOOL_KEYS = ['claude-code', 'codex', 'opencode', 'antigravity'];
 
 // The vendors' install pages. The server's `guideUrl` wins when it sends one.
 const CLI_DOC_URLS = {
   'claude-code': 'https://code.claude.com/docs/en/setup',
   'codex':       'https://learn.chatgpt.com/docs/codex/cli',
-  'opencode':    'https://opencode.ai/docs/',
-  'gemini':      'https://github.com/google-gemini/gemini-cli',
+  'opencode':    'https://opencode.ai/v2/docs',
+  'antigravity': 'https://antigravity.google/docs/getting-started',
 };
 
 // Fallback only. The server computes the command that fits the machine (the
 // vendor's recommended installer for its system, or the package manager the
-// other CLIs came from: buildInstallCommand in lib/cli-update-planner.js) and
-// returns it as `installCommand`. These apply only before the first
-// tool-versions response.
+// other CLIs came from: buildInstallCommand in lib/cli-update-planner.js; for
+// the Antigravity CLI, the command of the install its button runs there, which
+// is Homebrew's cask on a Mac that has Homebrew) and returns it as
+// `installCommand`. These apply only before the first tool-versions response.
 const CLI_INSTALL_CMDS = {
   'claude-code': { posix: 'curl -fsSL https://claude.ai/install.sh | bash', windows: 'irm https://claude.ai/install.ps1 | iex' },
   'codex':       { posix: 'curl -fsSL https://chatgpt.com/codex/install.sh | sh', windows: 'powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"' },
-  'opencode':    { posix: 'curl -fsSL https://opencode.ai/install | bash', windows: 'npm install -g opencode-ai' },
-  'gemini':      { posix: 'npm install -g @google/gemini-cli', windows: 'npm install -g @google/gemini-cli' },
+  'opencode':    { posix: 'curl -fsSL https://opencode.ai/v2/install | bash', windows: 'winget install --id Anomaly.OpenCode --exact' },
+  'antigravity': { posix: 'curl -fsSL https://antigravity.google/cli/install.sh | bash', windows: 'irm https://antigravity.google/cli/install.ps1 | iex' },
 };
 
 const CLI_LABELS = {
   'claude-code': 'Claude Code',
   'codex':       'Codex',
   'opencode':    'OpenCode',
-  'gemini':      'Gemini CLI',
+  'antigravity': 'Antigravity CLI',
 };
 
 const POLL_INTERVAL_MS = 30000;

package/neural-interface/public/shared/constants.js

@@ -29,6 +29,7 @@ export const KEYS = {
   PANEL_PREFIX:        'neural-panel-',
   NODE_POS_3D:         'synabun-node-positions',
   NODE_POS_2D:         'synabun-node-positions-2d',
+  VIEW_VARIANT:        'neural-view-variant',    // canonical memory map variant; legacy 2D preferences migrate at boot
   MAP_VIEW:            'neural-map-view',        // 3D memory map options {neighbors, recency, grid}
   INTERFACE_CONFIG:    'neural-interface-config',
   EXPLORER_CAT_ORDER:  'neural-explorer-cat-order',
@@ -65,6 +66,7 @@ export const KEYS = {
   ACTIVE_WORKSPACE:    'neural-active-workspace',  // sessionStorage
   GRID_SNAP:           'neural-grid-snap',
   TOPRIGHT_TOOLS_HIDDEN: 'neural-topright-tools-hidden',  // the workspace tools toggle is off ('true')
+  WHITEBOARD_TOOLBAR_HIDDEN: 'neural-whiteboard-toolbar-hidden',  // the whiteboard rail (#wb-toolbar) is hidden behind the logo button ('true')
   CATEGORIES_VISIBLE:  'neural-categories-visible',
   WHITEBOARD:          'neural-whiteboard',
   WHITEBOARD_RULESET_ALERT_DISMISSED: 'neural-whiteboard-ruleset-alert-dismissed',
@@ -72,6 +74,7 @@ export const KEYS = {
   TUTORIAL_SKIPPED:    'neural-tutorial-skipped',
   TUTORIAL_STEP:       'neural-tutorial-step',
   TUTORIAL_STARTED:    'neural-tutorial-started',
+  TOUR_TIPS:           'neural-tour-tips',
   ONBOARDING_EXPLORE:  'neural-onboarding-explore',
   ONBOARDING_CLI:      'neural-onboarding-cli',
   ONBOARDING_MODEL:    'neural-onboarding-model',
@@ -120,13 +123,12 @@ export const DEFAULT_KEYBINDS = {
   'toggle-help':         '?',
   'toggle-explorer':     'f',
   'toggle-focus-mode':   'v',
-  'toggle-minimap':      'm',
   'open-keybinds':       'n',
   'launch-assistant':    'a',
   'toggle-assistant':    'Ctrl+a',
   'launch-claude':       '1',
   'launch-codex':        '2',
-  'launch-gemini':       '3',
+  'launch-antigravity':  '3',
   'launch-opencode':     '4',
   'launch-browser':      'b',
   'launch-youtube':      'y',
@@ -146,7 +148,6 @@ export const KEYBIND_META = {
   'toggle-help':         { label: 'Toggle Help',           group: 'Navigation' },
   'toggle-explorer':     { label: 'Toggle Explorer',       group: 'Navigation' },
   'toggle-focus-mode':   { label: 'Toggle Focus Mode',     group: 'Navigation' },
-  'toggle-minimap':      { label: 'Toggle Minimap',        group: 'View' },
   'open-settings':       { label: 'Open Settings',          group: 'Settings' },
   'open-keybinds':       { label: 'Open Keybinds',         group: 'Settings' },
   'launch-assistant':    { label: 'Assistant',             group: 'Launch App', icon: 'assistant' },
@@ -154,7 +155,7 @@ export const KEYBIND_META = {
   'toggle-assistant-panel': { label: 'Toggle Assistant Sidepanel', group: 'Launch App', icon: 'assistant' },
   'launch-claude':       { label: 'Claude Code',           group: 'Launch App', icon: 'claude' },
   'launch-codex':        { label: 'Codex CLI',             group: 'Launch App', icon: 'codex' },
-  'launch-gemini':       { label: 'Gemini CLI',            group: 'Launch App', icon: 'gemini' },
+  'launch-antigravity':  { label: 'Antigravity CLI',       group: 'Launch App', icon: 'antigravity' },
   'launch-opencode':     { label: 'OpenCode',              group: 'Launch App', icon: 'opencode' },
   'launch-browser':      { label: 'Browser',               group: 'Launch App', icon: 'browser' },
   'launch-youtube':      { label: 'YouTube',               group: 'Launch App', icon: 'youtube' },

package/neural-interface/public/shared/context-menu-areas.js

@@ -0,0 +1,34 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — The app's context menu: the areas registry
+// What a part of the app adds to the app's right-click menu for an element
+// in it (a memory, the memory map, the focus-mode whiteboard). No imports,
+// so a module as low as the whiteboard can register its area without
+// pulling in the menu's actions; ui-context-menu.js reads it at every open.
+// ═══════════════════════════════════════════
+
+const _areas = [];
+
+/**
+ * Add what a part of the app contributes to the menu. `match(element)` returns the area the element is in
+ * (`{ kind: 'memory' | 'map' | 'focus', …, act? }`, see context-menu-model.js) or null. The first area that
+ * matches wins, in the order they were registered. Returns a function that removes it again.
+ * @param {{ id?: string, match: (el: Element) => object | null }} area
+ */
+export function registerContextMenuArea(area) {
+  _areas.push(area);
+  return () => { const i = _areas.indexOf(area); if (i >= 0) _areas.splice(i, 1); };
+}
+
+/** The area an element is in, or null. An area whose `match` throws is skipped (and named in the console). */
+export function areaAt(el) {
+  if (!el) return null;
+  for (const area of _areas) {
+    try {
+      const found = area.match(el);
+      if (found) return found;
+    } catch (err) {
+      console.warn(`[context-menu] area ${area.id || '?'} failed:`, err);
+    }
+  }
+  return null;
+}

package/neural-interface/public/shared/context-menu-logic.js

@@ -0,0 +1,243 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Context menu: what decides
+// No DOM and no imports: the component (context-menu.js) and the app's
+// global registration (ui-context-menu.js) draw what these functions say,
+// and node --test checks them (tests/context-menu-logic.test.mjs).
+// ═══════════════════════════════════════════
+
+/**
+ * @typedef {object} MenuItem
+ * @property {string} [id]
+ * @property {string} [label]
+ * @property {string} [icon]      trusted SVG markup (the app's own icons, never page text)
+ * @property {string} [shortcut]  the key as menus show it ('' when the action has none)
+ * @property {boolean} [disabled]
+ * @property {boolean} [checked]  a toggle: drawn with a check, role menuitemcheckbox
+ * @property {boolean} [hidden]   left out of the menu
+ * @property {MenuItem[]} [submenu]
+ * @property {() => unknown} [run]
+ * @property {boolean} [separator]
+ */
+
+export const VIEWPORT_MARGIN = 8;
+export const SUBMENU_GAP = 2;
+// What a submenu's first row sits under: the menu's padding plus the row's margin.
+export const SUBMENU_LEAD = 6;
+
+/**
+ * Items as the menu draws them: hidden ones and ones without a label left out, a submenu with nothing in it left
+ * out, no separator at either end or next to another.
+ * @param {(MenuItem | null | undefined)[]} items
+ * @returns {MenuItem[]}
+ */
+export function normalizeItems(items) {
+  const out = [];
+  for (const item of items || []) {
+    if (!item || item.hidden) continue;
+    if (item.separator) {
+      if (out.length && !out[out.length - 1].separator) out.push({ separator: true });
+      continue;
+    }
+    if (!item.label) continue;
+    if (item.submenu) {
+      const submenu = normalizeItems(item.submenu);
+      if (!submenu.length) continue;
+      out.push({ ...item, submenu });
+      continue;
+    }
+    out.push(item);
+  }
+  while (out.length && out[out.length - 1].separator) out.pop();
+  return out;
+}
+
+/**
+ * Sections in order, one separator between two that have something in them.
+ * @param {(MenuItem[] | null | undefined)[]} sections
+ * @returns {MenuItem[]}
+ */
+export function joinSections(sections) {
+  const out = [];
+  for (const section of sections || []) {
+    const items = normalizeItems(section);
+    if (!items.length) continue;
+    if (out.length) out.push({ separator: true });
+    out.push(...items);
+  }
+  return out;
+}
+
+/** How many rows a menu has at its top level (separators do not count). */
+export function countRows(items) {
+  return (items || []).filter((item) => item && !item.separator).length;
+}
+
+/**
+ * Where a menu of `width` × `height` goes for a press at (x, y): down and to the right of it, flipped up or left
+ * when that side has no room, and kept inside the window either way. `bounds` ({ left, top, right, bottom }) is the
+ * area it is kept in instead of the window: the app frame (app-frame.js) for a press inside it.
+ * @returns {{ left: number, top: number }}
+ */
+export function placeMenu({ x, y, width, height, viewportWidth, viewportHeight, margin = VIEWPORT_MARGIN, bounds = null }) {
+  const b = bounds || { left: 0, top: 0, right: viewportWidth, bottom: viewportHeight };
+  const fit = (at, size, lo, hi) => {
+    const first = lo + margin;                  // the first place it may start
+    const furthest = hi - margin - size;        // the last place it may start and still end inside the margin
+    if (furthest < first) return first;         // larger than the area: from the margin (it scrolls)
+    if (at + size <= hi - margin) return Math.max(first, at);
+    if (at - size >= first) return Math.min(at - size, furthest);
+    return furthest;
+  };
+  return {
+    left: Math.round(fit(x, width, b.left, b.right)),
+    top: Math.round(fit(y, height, b.top, b.bottom)),
+  };
+}
+
+/**
+ * Where a submenu goes: beside the menu it opens from, its first row level with the row that opened it; on the left
+ * when the window (or `bounds`, as for placeMenu) has no room on the right, and kept inside it.
+ * @param {{ left: number, right: number }} o.menuRect the menu it opens from
+ * @param {{ top: number }} o.rowRect the row that opens it
+ * @returns {{ left: number, top: number, side: 'right' | 'left' }}
+ */
+export function placeSubmenu({ menuRect, rowRect, width, height, viewportWidth, viewportHeight,
+  margin = VIEWPORT_MARGIN, gap = SUBMENU_GAP, lead = SUBMENU_LEAD, bounds = null }) {
+  const b = bounds || { left: 0, top: 0, right: viewportWidth, bottom: viewportHeight };
+  let side = 'right';
+  let left = menuRect.right + gap;
+  if (left + width > b.right - margin) {
+    const leftSide = menuRect.left - gap - width;
+    if (leftSide >= b.left + margin) { left = leftSide; side = 'left'; }
+    else left = Math.max(b.left + margin, b.right - margin - width);
+  }
+  const top = Math.max(b.top + margin, Math.min(rowRect.top - lead, b.bottom - margin - height));
+  return { left: Math.round(left), top: Math.round(top), side };
+}
+
+/**
+ * Where a menu opened from the keyboard points: inside the focused element near its top-left corner, or at its
+ * middle when it fills most of the window (the memory map).
+ */
+export function anchorPoint(rect, viewportWidth, viewportHeight) {
+  if (!rect) return { x: Math.round(viewportWidth / 2), y: Math.round(viewportHeight / 3) };
+  if (rect.width > viewportWidth * 0.6 && rect.height > viewportHeight * 0.6) {
+    return { x: Math.round(rect.left + rect.width / 2), y: Math.round(rect.top + rect.height / 2) };
+  }
+  return { x: Math.round(rect.left + Math.min(rect.width / 2, 16)), y: Math.round(rect.top + Math.min(rect.height / 2, 16)) };
+}
+
+const selectable = (item) => !!item && !item.separator && !item.disabled;
+
+/**
+ * The next row the keyboard can land on from `from` in direction `dir` (1 down, -1 up), wrapping; -1 when none can.
+ * From -1, down is the first row and up the last.
+ */
+export function stepIndex(items, from, dir) {
+  const n = items?.length || 0;
+  if (!n) return -1;
+  let i = from;
+  for (let k = 0; k < n; k++) {
+    i = i < 0 ? (dir > 0 ? 0 : n - 1) : (i + dir + n) % n;
+    if (selectable(items[i])) return i;
+  }
+  return -1;
+}
+
+/** The first and the last row the keyboard can land on. */
+export const firstIndex = (items) => stepIndex(items, -1, 1);
+export const lastIndex = (items) => stepIndex(items, -1, -1);
+
+/**
+ * The row typed letters go to: the next one whose label starts with them, from the row after `from` (a first
+ * letter) or from `from` itself (more letters of the same word). -1 when none does.
+ */
+export function typeaheadIndex(items, from, typed) {
+  const n = items?.length || 0;
+  const want = String(typed || '').toLowerCase();
+  if (!n || !want) return -1;
+  const start = want.length > 1 ? Math.max(0, from) : from + 1;
+  for (let k = 0; k < n; k++) {
+    const i = (((start + k) % n) + n) % n;
+    if (selectable(items[i]) && String(items[i].label || '').toLowerCase().startsWith(want)) return i;
+  }
+  return -1;
+}
+
+const TEXT_INPUT_TYPES = new Set(['', 'text', 'search', 'url', 'tel', 'email', 'password', 'number',
+  'date', 'datetime-local', 'month', 'time', 'week']);
+
+/**
+ * Whether an element is a field the browser's own menu belongs to (spelling, paste): a text input, a textarea, a
+ * native select or anything editable. Checkboxes, buttons and the like are not.
+ * @param {{ tagName?: string, type?: string, isContentEditable?: boolean, closest?: Function } | null} el
+ */
+export function isEditableTarget(el) {
+  if (!el) return false;
+  if (el.isContentEditable) return true;
+  const tag = String(el.tagName || '').toUpperCase();
+  if (tag === 'TEXTAREA' || tag === 'SELECT') return true;
+  if (tag === 'INPUT') return TEXT_INPUT_TYPES.has(String(el.type || '').toLowerCase());
+  return !!el.closest?.('[contenteditable=""], [contenteditable="true"], [contenteditable="plaintext-only"]');
+}
+
+/**
+ * Why the app's menu stays out of a right-click, or null when it opens. In order: another handler took the event
+ * (it called preventDefault: an area with a menu of its own), the press is on the app's menu itself, Shift is held
+ * (the escape hatch to the browser's menu), the target is a field, or it is in an area that opted out.
+ * @param {{ defaultPrevented?: boolean, shiftKey?: boolean }} event
+ * @param {{ inOwnMenu?: boolean, editable?: boolean, optedOut?: boolean }} target
+ * @returns {null | 'handled' | 'own-menu' | 'shift' | 'editable' | 'opt-out'}
+ */
+export function nativeMenuReason(event, target = {}) {
+  if (event?.defaultPrevented) return 'handled';
+  if (target.inOwnMenu) return 'own-menu';
+  if (event?.shiftKey) return 'shift';
+  if (target.editable) return 'editable';
+  if (target.optedOut) return 'opt-out';
+  return null;
+}
+
+/** Whether a key press asks for a context menu: the ContextMenu key, or Shift+F10, with no other modifier. */
+export function isMenuKey(event) {
+  if (!event || event.ctrlKey || event.metaKey || event.altKey) return false;
+  return event.key === 'ContextMenu' || (event.key === 'F10' && !!event.shiftKey);
+}
+
+/**
+ * A link the menu can offer: http(s) only, and not one that only points into the page (`#`, `#…`) or runs script.
+ * @param {string | null} raw the href as written
+ * @param {string | null} resolved the href the browser resolved
+ * @returns {string | null} the address to open or copy
+ */
+export function usableLink(raw, resolved) {
+  const written = String(raw ?? '').trim();
+  if (!written || written.startsWith('#')) return null;
+  if (/^\s*javascript:/i.test(written)) return null;
+  return /^https?:\/\//i.test(String(resolved || '')) ? String(resolved) : null;
+}
+
+/**
+ * An image the menu can offer. A data: or blob: picture can be copied by address; only an http(s) one opens in a
+ * new tab (browsers refuse to open a data: address there).
+ * @returns {{ src: string, canOpen: boolean } | null}
+ */
+export function usableImage(src) {
+  const value = String(src || '');
+  if (/^https?:\/\//i.test(value)) return { src: value, canOpen: true };
+  if (/^(data|blob):/i.test(value)) return { src: value, canOpen: false };
+  return null;
+}
+
+/** A selection as a menu label shows it: one line, at most `max` characters, an ellipsis when cut. */
+export function quoteSelection(text, max = 24) {
+  const flat = String(text || '').replace(/\s+/g, ' ').trim();
+  return flat.length > max ? `${flat.slice(0, max - 1).trimEnd()}…` : flat;
+}
+
+/** The selected text an action takes: trimmed, and capped so a whole page selected is not sent anywhere at once. */
+export const SELECTION_MAX = 4000;
+export function selectionPayload(text, max = SELECTION_MAX) {
+  const value = String(text || '').trim();
+  return value.length > max ? value.slice(0, max) : value;
+}