@ai-matrx/design-system 0.86.357 → 0.86.359

package/dist/data-table/data-row-window.js

@@ -1,7 +1,7 @@
 "use client";
 import {
   DataRowWindow
-} from "../chunk-XZGYKKCE.js";
+} from "../chunk-OUQT72UL.js";
 import "../chunk-YC5GAO35.js";
 import "../chunk-VLLUUOYJ.js";
 import "../chunk-TH6DDCWF.js";
@@ -10,30 +10,31 @@ import "../chunk-LEPD6TV7.js";
 import "../chunk-IMQ3RX35.js";
 import "../chunk-U24MOJWK.js";
 import "../chunk-NDTDBBMM.js";
-import "../chunk-WUD23YTG.js";
+import "../chunk-P56Y43RL.js";
 import "../chunk-UEQK6PFD.js";
 import "../chunk-PTYKILZE.js";
-import "../chunk-FRJ4PPA2.js";
+import "../chunk-CZGZV35G.js";
 import "../chunk-KPZX2M2C.js";
 import "../chunk-GLZJ7WZK.js";
 import "../chunk-B3LDW3IQ.js";
 import "../chunk-FXT7PZAF.js";
-import "../chunk-MTE6N7XU.js";
+import "../chunk-NFJ63LIH.js";
 import "../chunk-WFBPCMPF.js";
 import "../chunk-KGW373MK.js";
 import "../chunk-7ZCD4AZS.js";
 import "../chunk-OPF265PU.js";
 import "../chunk-QFP4BUKZ.js";
-import "../chunk-U46XUQI7.js";
-import "../chunk-6XNYYROM.js";
+import "../chunk-KSCSH7AO.js";
+import "../chunk-WVEDW5VO.js";
 import "../chunk-BD77DHUO.js";
 import "../chunk-BKCJUFD3.js";
 import "../chunk-PIQJULQB.js";
 import "../chunk-MOZRIHJF.js";
-import "../chunk-X6ZRHJQP.js";
+import "../chunk-T57DLONB.js";
 import "../chunk-BNXNIN2S.js";
+import "../chunk-HS6GMHKZ.js";
 import "../chunk-ORXB4A5E.js";
-import "../chunk-POJ3RR3K.js";
+import "../chunk-B5D3VIMC.js";
 import "../chunk-4JAYMFQO.js";
 import "../chunk-WFITMVDB.js";
 import "../chunk-WAT2XW7L.js";

package/dist/data-table/drill-chart.js

@@ -14,10 +14,10 @@ import {
 import {
   ErrorBox
 } from "../chunk-5Z5GTXKL.js";
-import "../chunk-HS6GMHKZ.js";
 import {
   Skeleton
 } from "../chunk-DRSBLHOF.js";
+import "../chunk-HS6GMHKZ.js";
 import "../chunk-IMOOQQOO.js";
 import {
   cn

package/dist/data-table/host.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/data-table/host.tsx","../../src/table-host/host.tsx","../../src/table-host/row-drawing.ts"],"sourcesContent":["\"use client\";\n\n// The host contract lives in ../table-host so sections that only DRAW a table's row (item, peek) never\n// load the data-table directory. This file keeps the public `@ai-matrx/design-system/data-table/host` path.\nexport * from \"../table-host/host\";\n","\"use client\";\nimport { createContext, useContext, type Context, type ComponentType, type ReactNode, type MouseEventHandler } from \"react\";\nimport type { CopyControlProps } from \"../data-table/copy-types\";\nimport type { MatrxColumnDef, MatrxDataTableDensity, MatrxDataTableLook, MatrxDataTableRecordControls, TableSavedViewsProps } from \"../data-table/types\";\nimport type {\n  MatrxTableMenuIconName,\n  MatrxTableMenuItem,\n  MatrxTableMenuPayload,\n  MatrxTableMenuSectionsResolver,\n  MatrxTableMenuTarget,\n} from \"../data-table/menu-targets\";\n\nexport type {\n  MatrxTableMenuIconName,\n  MatrxTableMenuItem,\n  MatrxTableMenuSection,\n  MatrxTableMenuSectionsResolver,\n} from \"../data-table/menu-targets\";\n\nexport type {\n  AgentPayloadInput,\n  AiCustomSource,\n  AiVariant,\n  ContentTransferReference,\n  CopyControlProps,\n  CopyEnvelopeMeta,\n  CopyExportConfig,\n  TableCopyController,\n} from \"../data-table/copy-types\";\n\nexport interface TableLinkProps { href: string; children: ReactNode; className?: string; onClick?: MouseEventHandler<HTMLAnchorElement>; }\n/**\n * Host-owned toolbar affordance. The table package keeps operation state and\n * labels; an application can supply its canonical icon-button primitive\n * without making the shared package depend on an application UI package.\n */\nexport interface TableToolbarActionProps { ariaLabel: string; tooltip?: string | undefined; disabled?: boolean | undefined; busy?: boolean | undefined; /** Indicates a selected mutually-exclusive action such as the current page. */ active?: boolean | undefined; onClick: () => void; children: ReactNode; }\nexport interface TableSidePanelProps { title: string; titleNode?: ReactNode; description?: ReactNode; onClose: () => void; /** Increments on every open request, including a repeat open of the row already shown — a host whose panel can sit in the background (a tab) brings it forward when this changes. */ openRequest?: number; defaultWidth?: number; headerActions?: ReactNode; children: ReactNode; }\nexport interface TableWindowPanelProps { id: string; title: string; onClose: () => void; width?: number; height?: number; minWidth?: number; minHeight?: number; actionsRight?: ReactNode; bodyClassName?: string; sidebarDefaultSize?: number; sidebarMinSize?: number; sidebar?: ReactNode; children: ReactNode; /** The table look the window opens from (lane mac-blockers): `\"mac\"` asks the host window for the Mac header. Absent: the default look. */ look?: MatrxDataTableLook; }\nexport interface TableEntityRefProps { token: string; id: string; href?: string; children: ReactNode; className?: string; /** Opening it starts a new tab. */ openInNewTab?: boolean; /** Its open / peek buttons stay shown, not only on hover. */ alwaysShowActions?: boolean; }\nexport interface TablePeekProps { kind: string; id: string; href?: string; onClose: () => void; }\nexport interface TableDoors {\n  href?: string;\n  peekKind?: string;\n  canPeek?: boolean;\n  /**\n   * THE RECORD'S OWN MENU (lane DRILL-PARITY-LAST): what its kind offers wherever a table names it —\n   * a person's admin destinations, an organization's pages — as neutral items the table draws in a\n   * row's menu and on a right-click. Absent = the record has only its open and preview doors.\n   */\n  menu?: MatrxTableMenuItem[];\n}\n/**\n * The host's door onto the table's right-click levels.\n *\n * A canonical table registers ONE resolver per instance. The host's own menu\n * reads which of the four levels was clicked (`readMenuTarget`) and asks for\n * that level's descriptor — the package never interprets what comes back, and\n * the host never reaches into the table for the row or the range.\n */\nexport interface TableRowContextRegistry { register(tableId: string, resolve: (target: MatrxTableMenuTarget) => unknown): () => void; }\nexport interface TableContextMenuBoundaryProps {\n  label: string;\n  children: ReactNode;\n  /**\n   * The consumer's own sections, asked per right-click. Present only when the\n   * table's consumer declared `contextMenu.sections`; the host reads the level\n   * off the clicked element (`readMenuTarget`), calls this, and draws what comes\n   * back in its own menu. Absent, the boundary behaves exactly as before.\n   */\n  sections?: MatrxTableMenuSectionsResolver | undefined;\n  /** The table asked for the host's designed menu (`MatrxDataTableContextMenuConfig.designedMenu`). */\n  designedMenu?: boolean | undefined;\n}\n/**\n * The host's view of a failed read with NO rows to show (RC-B12 round 13):\n * its error display (with the host's actions — matrx-frontend's Alchemy Menu)\n * and a retry. Without a host port the table draws a package `ErrorBox`.\n */\nexport interface TableReadFailureProps { error: unknown; what: string; onRetry?: (() => void) | undefined; }\n/**\n * The host's notice above rows kept from an earlier read when the latest read\n * failed: the rows may be out of date. Without a host port the table draws a\n * package `ErrorBox` in warning colors.\n */\nexport interface TableStaleNoticeProps { error: unknown; what: string; onRetry?: (() => void) | undefined; }\n/** The host's glyph for a menu icon name. A host without one draws labels only. */\nexport interface TableMenuIconProps { name: MatrxTableMenuIconName; className?: string | undefined; }\n/** The host's custom-field columns for a registry token over the given organizations (lane 7 W5). */\nexport interface TableCustomFieldColumns<T> { columns: MatrxColumnDef<T>[]; }\nexport interface MatrxDataTableHost { /** A HOOK, bound once by the host: the custom-field columns of `token` (null = none) for `organizationIds`. */ useCustomFieldColumns?: <T>(token: string | null, organizationIds: readonly string[]) => TableCustomFieldColumns<T> | null; JsonViewer?: ComponentType<{ data: object | string }>; Link?: ComponentType<TableLinkProps>; CopyControls?: ComponentType<CopyControlProps>; ToolbarAction?: ComponentType<TableToolbarActionProps>; SidePanelSurface?: ComponentType<TableSidePanelProps>; WindowPanel?: ComponentType<TableWindowPanelProps>; EntityRef?: ComponentType<TableEntityRefProps>; resolveEntityDoors?: (token: string, id: string, href?: string | null) => TableDoors | null; ResourcePeek?: ComponentType<TablePeekProps>; SavedViews?: ComponentType<TableSavedViewsProps>; rowContextRegistry?: TableRowContextRegistry; createDefaultMenuContext?: (payload: MatrxTableMenuPayload) => unknown; ContextMenuBoundary?: ComponentType<TableContextMenuBoundaryProps>; MenuIcon?: ComponentType<TableMenuIconProps>; /** A failed read with no rows (RC-B12 r13). */ ReadFailure?: ComponentType<TableReadFailureProps>; /** A failed refresh over kept rows (RC-B12 r13). */ StaleNotice?: ComponentType<TableStaleNoticeProps>; /** Host default; a table's explicit density takes precedence. */ defaultDensity?: MatrxDataTableDensity; /** Host default look (`default` | `mac`); a table's explicit `look` takes precedence. One switch turns every table under the host, and every mode built on it, to the Mac look. */ defaultLook?: MatrxDataTableLook; notify?: { success(message: string): void; error(message: string): void }; /** Client-side navigation (the app router), for `rowClick=\"page\"`. Absent: a full page load. */ navigate?: (href: string) => void; }\n// Public entrypoints are independently bundled in ESM and CJS. The context\n// identity must survive those bundle boundaries; values stay provider-scoped.\nconst HOST_SLOT = Symbol.for(\"ai-matrx.design-system.table-host-context\");\nconst hostRegistry = globalThis as typeof globalThis & { [HOST_SLOT]?: Context<MatrxDataTableHost> };\nconst HostContext = hostRegistry[HOST_SLOT] ??= createContext<MatrxDataTableHost>({});\nexport function MatrxDataTableProvider({ value, children }: { value: MatrxDataTableHost; children: ReactNode }) { return <HostContext.Provider value={value}>{children}</HostContext.Provider>; }\nexport function useMatrxDataTableHost(): MatrxDataTableHost { return useContext(HostContext); }\n\nexport interface MatrxTableRowAlchemy {\n  copy: CopyControlProps;\n  controls?: MatrxDataTableRecordControls;\n  placement: \"inline\" | \"menu\";\n  ready: boolean;\n  activate(): void;\n  /** Mount Alchemy's canonical palette in the host row menu. */\n  mountMenu(target: HTMLElement | null, onClose?: () => void, restoreFocus?: () => void): void;\n  prepare(restoreFocus?: () => void): Promise<void>;\n}\n\nconst ROW_ALCHEMY_SLOT = Symbol.for(\"ai-matrx.design-system.table-row-alchemy-context\");\nconst rowAlchemyRegistry = globalThis as typeof globalThis & { [ROW_ALCHEMY_SLOT]?: Context<MatrxTableRowAlchemy | null> };\nconst RowAlchemyContext = rowAlchemyRegistry[ROW_ALCHEMY_SLOT] ??= createContext<MatrxTableRowAlchemy | null>(null);\n\nexport function MatrxTableRowAlchemyScope({ value, children }: { value: MatrxTableRowAlchemy; children: ReactNode }) { return <RowAlchemyContext.Provider value={value}>{children}</RowAlchemyContext.Provider>; }\n\nexport function useMatrxTableRowAlchemy(): MatrxTableRowAlchemy | null { return useContext(RowAlchemyContext); }\n\nconst ROW_CONTROLS_SLOT = Symbol.for(\"ai-matrx.design-system.table-row-controls-context\");\nconst rowControlsRegistry = globalThis as typeof globalThis & { [ROW_CONTROLS_SLOT]?: Context<MatrxDataTableRecordControls | null> };\nconst RowControlsContext = rowControlsRegistry[ROW_CONTROLS_SLOT] ??= createContext<MatrxDataTableRecordControls | null>(null);\nexport function MatrxTableRowControlsScope({ value, children }: { value: MatrxDataTableRecordControls; children: ReactNode }) { return <RowControlsContext.Provider value={value}>{children}</RowControlsContext.Provider>; }\nexport function useMatrxTableRowControls(): MatrxDataTableRecordControls | null { return useContext(RowControlsContext); }\n\n/** Light door for components a row draws (a row menu): declare a lazy data prop without loading the table. */\nexport { declareLazyDataProps } from \"./row-drawing\";\n","/**\n * A ROW IS REDRAWN WHEN WHAT IT SHOWS CHANGED — NEVER BECAUSE A FUNCTION WAS BORN AGAIN\n * (lane TABLE-RERENDER, 2026-10-03).\n *\n * Hosts write `cell`, `customActions`, `getRowId`, `rowClassName` and their handlers inline, so every\n * host render hands the table new functions. Identity cannot say whether a new function draws\n * anything new, so the table used to redraw every row: /artifacts (560 rows) spent ~2.6 s redrawing\n * 1,120 rows to open one artifact. Asking every host to stabilise its callbacks fixed one screen of\n * ~85 at a time.\n *\n * The table now ASKS the row instead. When only the host's functions changed, a row builds its\n * elements (cheap — no component runs) and compares them with what it drew last:\n *   · equal → it returns the SAME element object it committed, and React does not descend into it;\n *   · different → it draws, and only that row pays.\n * Handlers inside a row that was not redrawn still call the host's LATEST function: every event\n * handler (`on[A-Z]…`) and every function the table marks `lazyCallback` is handed to the DOM as a\n * stable trampoline whose target is refreshed on each comparison (the latest-ref pattern, applied\n * to every handler a row holds instead of to a list the table has to keep in sync).\n *\n * Any other function in the tree (a render prop, a formatter a child calls while it renders, a\n * component type) is compared by identity, so a new one redraws the row — exactly as before. That\n * keeps the rule honest: a row is never left showing what an old closure drew. The one exception is\n * a prop its component DECLARED a lazy data getter (`declareLazyDataProps`): it is compared by what\n * it returns.\n */\nimport { cloneElement, isValidElement, type ReactElement, type ReactNode } from \"react\";\n\nconst LAZY = Symbol.for(\"@ai-matrx/design-system/data-table/lazy-callback\");\nconst MAX_DEPTH = 32;\nconst HANDLER_KEY = /^on[A-Z]/;\n\ntype AnyFunction = (...args: never[]) => unknown;\n\n/**\n * Marks a function the table hands into a row as one that runs LATER (on a click, a copy, a menu\n * choice) and never while a child renders — so a row may keep a trampoline to it instead of\n * redrawing when only its identity changed.\n */\nexport function lazyCallback<F extends AnyFunction>(fn: F): F {\n  (fn as F & { [LAZY]?: true })[LAZY] = true;\n  return fn;\n}\n\nfunction isLazy(fn: unknown): boolean {\n  return (fn as { [LAZY]?: true })[LAZY] === true;\n}\n\nconst LAZY_DATA_PROPS = Symbol.for(\"@ai-matrx/design-system/data-table/lazy-data-props\");\n\n/**\n * Declares the props of `component` that take a GETTER of data the component reads only later —\n * a row menu's `config={() => menu}`, resolved when the menu opens. Without it a getter is just an\n * unknown function, compared by identity, and a host that builds it inline (every row menu does)\n * redraws every row on every render of its own: /crm redrew all 25 rows on each checkbox tick.\n *\n * A declared prop is compared by what the getter RETURNS (its handlers by trampoline, everything\n * else exactly as a drawing is): the same data → the row keeps its drawing and the component is\n * handed a stable trampoline to the host's LATEST getter, so it opens with fresh items; different\n * data (a checkbox in an open menu flipped) → that row alone redraws. Declare once, on the\n * component — never per call site.\n *\n * The contract: a declared getter is PURE and CHEAP — the row calls the previous and the new one on\n * every host render to compare them. A getter that fetches, dispatches or builds something heavy\n * must not be declared.\n */\nexport function declareLazyDataProps<C extends object>(component: C, keys: readonly string[]): C {\n  (component as C & { [LAZY_DATA_PROPS]?: ReadonlySet<string> })[LAZY_DATA_PROPS] = new Set(keys);\n  return component;\n}\n\nfunction lazyDataKeys(type: unknown): ReadonlySet<string> | undefined {\n  if ((typeof type !== \"function\" && typeof type !== \"object\") || type === null) return undefined;\n  return (type as { [LAZY_DATA_PROPS]?: ReadonlySet<string> })[LAZY_DATA_PROPS];\n}\n\nconst UNRESOLVED = Symbol(\"unresolved\");\n\n/** A declared getter's data — or `UNRESOLVED` when calling it threw (the row then simply redraws). */\nfunction resolveLazyData(value: unknown): unknown {\n  if (typeof value !== \"function\") return value;\n  try {\n    return (value as () => unknown)();\n  } catch {\n    return UNRESOLVED;\n  }\n}\n\nfunction trampolinable(key: string, fn: unknown): boolean {\n  return isLazy(fn) || HANDLER_KEY.test(key);\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== \"object\") return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\ninterface Slot {\n  fn: (...args: unknown[]) => unknown;\n  readonly stable: (...args: unknown[]) => unknown;\n}\n\nfunction makeSlot(fn: (...args: unknown[]) => unknown): Slot {\n  const slot: Slot = {\n    fn,\n    // A Proxy rather than a bare wrapper: a handler that carries its own members (a debounced\n    // function's `cancel`) keeps them, read from the latest function.\n    stable: new Proxy((() => undefined) as (...args: unknown[]) => unknown, {\n      apply: (_target, thisArg, args: unknown[]) => Reflect.apply(slot.fn, thisArg, args),\n      get: (_target, key) => Reflect.get(slot.fn, key),\n    }),\n  };\n  return slot;\n}\n\ntype Updates = Array<[path: string, fn: (...args: unknown[]) => unknown]>;\n\nfunction sameEntries(\n  a: Record<string, unknown>,\n  b: Record<string, unknown>,\n  path: string,\n  depth: number,\n  updates: Updates,\n  lazyKeys?: ReadonlySet<string>,\n): boolean {\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) return false;\n  for (const key of keys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    // A ref is never a handler: a new callback ref must be attached by React.\n    if (key === \"ref\") {\n      if (!Object.is(a[key], b[key])) return false;\n      continue;\n    }\n    if (lazyKeys?.has(key) && (typeof a[key] === \"function\" || typeof b[key] === \"function\")) {\n      if (Object.is(a[key], b[key])) continue;\n      // A getter that became a plain value (or the reverse) is a new drawing: the committed element\n      // still holds a trampoline to the OLD getter, which nothing would re-point.\n      if (typeof a[key] !== typeof b[key]) return false;\n      const before = resolveLazyData(a[key]);\n      const after = resolveLazyData(b[key]);\n      if (before === UNRESOLVED || after === UNRESOLVED) return false;\n      // Handlers inside the data are reached through the getter's own trampoline, so the ones this\n      // comparison collects are dropped: the component calls the LATEST getter and gets them fresh.\n      if (!sameDrawing(before, after, key, `${path}/${key}()`, depth + 1, [])) return false;\n      if (typeof b[key] === \"function\") updates.push([`${path}/${key}`, b[key] as (...args: unknown[]) => unknown]);\n      continue;\n    }\n    if (!sameDrawing(a[key], b[key], key, `${path}/${key}`, depth + 1, updates)) return false;\n  }\n  return true;\n}\n\n/**\n * Whether `next` draws exactly what `previous` drew. Handlers that differ only by identity are\n * collected into `updates` (by path) so the caller can point the committed trampolines at them.\n */\nfunction sameDrawing(previous: unknown, next: unknown, key: string, path: string, depth: number, updates: Updates): boolean {\n  if (Object.is(previous, next)) return true;\n  if (typeof previous === \"function\" && typeof next === \"function\") {\n    if (trampolinable(key, previous) && trampolinable(key, next)) {\n      updates.push([path, next as (...args: unknown[]) => unknown]);\n      return true;\n    }\n    return false;\n  }\n  if (depth > MAX_DEPTH) return false;\n  if (isValidElement(previous) && isValidElement(next)) {\n    if (previous.type !== next.type || previous.key !== next.key) return false;\n    return sameEntries(\n      previous.props as Record<string, unknown>,\n      next.props as Record<string, unknown>,\n      path,\n      depth,\n      updates,\n      lazyDataKeys(previous.type),\n    );\n  }\n  if (Array.isArray(previous) && Array.isArray(next)) {\n    if (previous.length !== next.length) return false;\n    for (let i = 0; i < previous.length; i += 1) {\n      if (!sameDrawing(previous[i], next[i], key, `${path}/${i}`, depth + 1, updates)) return false;\n    }\n    return true;\n  }\n  if (isPlainObject(previous) && isPlainObject(next)) return sameEntries(previous, next, path, depth, updates);\n  return false;\n}\n\n/** `value` with every trampolinable function replaced by its stable trampoline. */\nfunction stabilize(value: unknown, key: string, path: string, depth: number, slots: Map<string, Slot>, reuse: Map<string, Slot> | undefined, lazyData = false): unknown {\n  if (typeof value === \"function\") {\n    if (!lazyData && !trampolinable(key, value)) return value;\n    const fn = value as (...args: unknown[]) => unknown;\n    const kept = reuse?.get(path);\n    const slot = kept ?? makeSlot(fn);\n    slot.fn = fn;\n    slots.set(path, slot);\n    return slot.stable;\n  }\n  if (depth > MAX_DEPTH) return value;\n  if (isValidElement(value)) {\n    const props = value.props as Record<string, unknown>;\n    const lazyKeys = lazyDataKeys(value.type);\n    let changed: Record<string, unknown> | null = null;\n    for (const propKey of Object.keys(props)) {\n      if (propKey === \"ref\") continue;\n      const before = props[propKey];\n      const after = stabilize(before, propKey, `${path}/${propKey}`, depth + 1, slots, reuse, lazyKeys?.has(propKey) ?? false);\n      if (after !== before) (changed ??= {})[propKey] = after;\n    }\n    if (!changed) return value;\n    const clone = cloneElement(value as ReactElement, changed);\n    // React (dev) marks JSX's static children as key-checked on the ELEMENT; a clone starts\n    // unmarked, and a clone inside a static children array would then warn about a missing key.\n    const before = (value as { _store?: { validated?: unknown } })._store;\n    const after = (clone as { _store?: { validated?: unknown } })._store;\n    if (before && after && \"validated\" in before) {\n      try { after.validated = before.validated; } catch { /* frozen in some builds: only a dev warning is at stake */ }\n    }\n    return clone;\n  }\n  if (Array.isArray(value)) {\n    let out: unknown[] | null = null;\n    for (let i = 0; i < value.length; i += 1) {\n      const after = stabilize(value[i], key, `${path}/${i}`, depth + 1, slots, reuse);\n      if (after !== value[i]) (out ??= value.slice())[i] = after;\n    }\n    return out ?? value;\n  }\n  if (isPlainObject(value)) {\n    let out: Record<string, unknown> | null = null;\n    for (const entryKey of Object.keys(value)) {\n      const before = value[entryKey];\n      const after = stabilize(before, entryKey, `${path}/${entryKey}`, depth + 1, slots, reuse);\n      if (after !== before) (out ??= { ...value })[entryKey] = after;\n    }\n    return out ?? value;\n  }\n  return value;\n}\n\ninterface RowDrawing {\n  /** What the host and the table built last time — compared, never rendered. */\n  raw: unknown;\n  /** What React was handed: `raw` with trampolines. Returned unchanged while the drawing holds. */\n  out: ReactNode;\n  slots: Map<string, Slot>;\n}\n\n/** One table's drawings, by row id. */\nexport class RowDrawings {\n  private readonly rows = new Map<string, RowDrawing>();\n\n  /**\n   * The element to hand React for this row. The SAME object as last time when `raw` draws what the\n   * last one drew (its handlers are re-pointed); a new one otherwise.\n   */\n  draw(rowId: string, raw: ReactNode, fresh = false): ReactNode {\n    const previous = this.rows.get(rowId);\n    // `fresh`: the row's own facts moved — what it shows may differ even when its elements match.\n    if (previous && !fresh) {\n      const updates: Updates = [];\n      if (sameDrawing(previous.raw, raw, \"\", \"\", 0, updates) && updates.every(([path]) => previous.slots.has(path))) {\n        for (const [path, fn] of updates) previous.slots.get(path)!.fn = fn;\n        previous.raw = raw;\n        return previous.out;\n      }\n    }\n    const slots = new Map<string, Slot>();\n    const out = stabilize(raw, \"\", \"\", 0, slots, previous?.slots) as ReactNode;\n    this.rows.set(rowId, { raw, out, slots });\n    return out;\n  }\n\n  /** Forget rows that are no longer in the table (bounded by what was ever drawn). */\n  prune(liveIds: ReadonlySet<string>): void {\n    for (const id of this.rows.keys()) if (!liveIds.has(id)) this.rows.delete(id);\n  }\n\n  get size(): number {\n    return this.rows.size;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCA,IAAAA,gBAAoH;;;ACwBpH,mBAAgF;AAsBhF,IAAM,kBAAkB,uBAAO,IAAI,oDAAoD;AAkBhF,SAAS,qBAAuC,WAAc,MAA4B;AAC/F,EAAC,UAA8D,eAAe,IAAI,IAAI,IAAI,IAAI;AAC9F,SAAO;AACT;;;AD4ByH;AAHzH,IAAM,YAAY,uBAAO,IAAI,2CAA2C;AACxE,IAAM,eAAe;AACrB,IAAM,cAAc,aAAa,SAAS,UAAM,6BAAkC,CAAC,CAAC;AAC7E,SAAS,uBAAuB,EAAE,OAAO,SAAS,GAAuD;AAAE,SAAO,4CAAC,YAAY,UAAZ,EAAqB,OAAe,UAAS;AAAyB;AACzL,SAAS,wBAA4C;AAAE,aAAO,0BAAW,WAAW;AAAG;AAa9F,IAAM,mBAAmB,uBAAO,IAAI,kDAAkD;AACtF,IAAM,qBAAqB;AAC3B,IAAM,oBAAoB,mBAAmB,gBAAgB,UAAM,6BAA2C,IAAI;AAE3G,SAAS,0BAA0B,EAAE,OAAO,SAAS,GAAyD;AAAE,SAAO,4CAAC,kBAAkB,UAAlB,EAA2B,OAAe,UAAS;AAA+B;AAE1M,SAAS,0BAAuD;AAAE,aAAO,0BAAW,iBAAiB;AAAG;AAE/G,IAAM,oBAAoB,uBAAO,IAAI,mDAAmD;AACxF,IAAM,sBAAsB;AAC5B,IAAM,qBAAqB,oBAAoB,iBAAiB,UAAM,6BAAmD,IAAI;AACtH,SAAS,2BAA2B,EAAE,OAAO,SAAS,GAAiE;AAAE,SAAO,4CAAC,mBAAmB,UAAnB,EAA4B,OAAe,UAAS;AAAgC;AACrN,SAAS,2BAAgE;AAAE,aAAO,0BAAW,kBAAkB;AAAG;","names":["import_react"]}
+{"version":3,"sources":["../../src/data-table/host.tsx","../../src/table-host/host.tsx","../../src/table-host/row-drawing.ts"],"sourcesContent":["\"use client\";\n\n// The host contract lives in ../table-host so sections that only DRAW a table's row (item, peek) never\n// load the data-table directory. This file keeps the public `@ai-matrx/design-system/data-table/host` path.\nexport * from \"../table-host/host\";\n","\"use client\";\nimport { createContext, useContext, type Context, type ComponentType, type ReactNode, type MouseEventHandler } from \"react\";\nimport type { CopyControlProps } from \"../data-table/copy-types\";\nimport type { MatrxColumnDef, MatrxDataTableDensity, MatrxDataTableLook, MatrxDataTableRecordControls, TableSavedViewsProps } from \"../data-table/types\";\nimport type {\n  MatrxTableMenuIconName,\n  MatrxTableMenuItem,\n  MatrxTableMenuPayload,\n  MatrxTableMenuSectionsResolver,\n  MatrxTableMenuTarget,\n} from \"../data-table/menu-targets\";\n\nexport type {\n  MatrxTableMenuIconName,\n  MatrxTableMenuItem,\n  MatrxTableMenuSection,\n  MatrxTableMenuSectionsResolver,\n} from \"../data-table/menu-targets\";\n\nexport type {\n  AgentPayloadInput,\n  AiCustomSource,\n  AiVariant,\n  ContentTransferReference,\n  CopyControlProps,\n  CopyEnvelopeMeta,\n  CopyExportConfig,\n  TableCopyController,\n} from \"../data-table/copy-types\";\n\nexport interface TableLinkProps { href: string; children: ReactNode; className?: string; onClick?: MouseEventHandler<HTMLAnchorElement>; }\n/**\n * Host-owned toolbar affordance. The table package keeps operation state and\n * labels; an application can supply its canonical icon-button primitive\n * without making the shared package depend on an application UI package.\n */\nexport interface TableToolbarActionProps { ariaLabel: string; tooltip?: string | undefined; disabled?: boolean | undefined; busy?: boolean | undefined; /** Indicates a selected mutually-exclusive action such as the current page. */ active?: boolean | undefined; onClick: () => void; children: ReactNode; }\nexport interface TableSidePanelProps { title: string; titleNode?: ReactNode; description?: ReactNode; onClose: () => void; /** Increments on every open request, including a repeat open of the row already shown — a host whose panel can sit in the background (a tab) brings it forward when this changes. */ openRequest?: number; defaultWidth?: number; headerActions?: ReactNode; children: ReactNode; }\nexport interface TableWindowPanelProps { id: string; title: string; onClose: () => void; width?: number; height?: number; minWidth?: number; minHeight?: number; actionsRight?: ReactNode; bodyClassName?: string; sidebarDefaultSize?: number; sidebarMinSize?: number; sidebar?: ReactNode; children: ReactNode; /** The table look the window opens from (lane mac-blockers): `\"mac\"` asks the host window for the Mac header. Absent: the default look. */ look?: MatrxDataTableLook; }\nexport interface TableEntityRefProps { token: string; id: string; href?: string; children: ReactNode; className?: string; /** Opening it starts a new tab. */ openInNewTab?: boolean; /** Its open / peek buttons stay shown, not only on hover. */ alwaysShowActions?: boolean; }\nexport interface TablePeekProps { kind: string; id: string; href?: string; onClose: () => void; }\nexport interface TableDoors {\n  href?: string;\n  peekKind?: string;\n  canPeek?: boolean;\n  /**\n   * THE RECORD'S OWN MENU (lane DRILL-PARITY-LAST): what its kind offers wherever a table names it —\n   * a person's admin destinations, an organization's pages — as neutral items the table draws in a\n   * row's menu and on a right-click. Absent = the record has only its open and preview doors.\n   */\n  menu?: MatrxTableMenuItem[];\n}\n/**\n * The host's door onto the table's right-click levels.\n *\n * A canonical table registers ONE resolver per instance. The host's own menu\n * reads which of the four levels was clicked (`readMenuTarget`) and asks for\n * that level's descriptor — the package never interprets what comes back, and\n * the host never reaches into the table for the row or the range.\n */\nexport interface TableRowContextRegistry { register(tableId: string, resolve: (target: MatrxTableMenuTarget) => unknown): () => void; }\nexport interface TableContextMenuBoundaryProps {\n  label: string;\n  children: ReactNode;\n  /**\n   * The consumer's own sections, asked per right-click. Present only when the\n   * table's consumer declared `contextMenu.sections`; the host reads the level\n   * off the clicked element (`readMenuTarget`), calls this, and draws what comes\n   * back in its own menu. Absent, the boundary behaves exactly as before.\n   */\n  sections?: MatrxTableMenuSectionsResolver | undefined;\n  /** The table asked for the host's designed menu (`MatrxDataTableContextMenuConfig.designedMenu`). */\n  designedMenu?: boolean | undefined;\n}\n/**\n * The host's view of a failed read with NO rows to show (RC-B12 round 13):\n * its error display (with the host's actions — matrx-frontend's Alchemy Menu)\n * and a retry. Without a host port the table draws a package `ErrorBox`.\n */\nexport interface TableReadFailureProps { error: unknown; what: string; onRetry?: (() => void) | undefined; }\n/**\n * The host's notice above rows kept from an earlier read when the latest read\n * failed: the rows may be out of date. Without a host port the table draws a\n * package `ErrorBox` in warning colors.\n */\nexport interface TableStaleNoticeProps { error: unknown; what: string; onRetry?: (() => void) | undefined; }\n/** The host's glyph for a menu icon name. A host without one draws labels only. */\nexport interface TableMenuIconProps { name: MatrxTableMenuIconName; className?: string | undefined; }\n/** The host's custom-field columns for a registry token over the given organizations (lane 7 W5). */\nexport interface TableCustomFieldColumns<T> { columns: MatrxColumnDef<T>[]; }\nexport interface MatrxDataTableHost { /** A HOOK, bound once by the host: the custom-field columns of `token` (null = none) for `organizationIds`. */ useCustomFieldColumns?: <T>(token: string | null, organizationIds: readonly string[]) => TableCustomFieldColumns<T> | null; JsonViewer?: ComponentType<{ data: object | string }>; Link?: ComponentType<TableLinkProps>; CopyControls?: ComponentType<CopyControlProps>; ToolbarAction?: ComponentType<TableToolbarActionProps>; SidePanelSurface?: ComponentType<TableSidePanelProps>; WindowPanel?: ComponentType<TableWindowPanelProps>; EntityRef?: ComponentType<TableEntityRefProps>; resolveEntityDoors?: (token: string, id: string, href?: string | null) => TableDoors | null; ResourcePeek?: ComponentType<TablePeekProps>; SavedViews?: ComponentType<TableSavedViewsProps>; rowContextRegistry?: TableRowContextRegistry; createDefaultMenuContext?: (payload: MatrxTableMenuPayload) => unknown; ContextMenuBoundary?: ComponentType<TableContextMenuBoundaryProps>; MenuIcon?: ComponentType<TableMenuIconProps>; /** A failed read with no rows (RC-B12 r13). */ ReadFailure?: ComponentType<TableReadFailureProps>; /** A failed refresh over kept rows (RC-B12 r13). */ StaleNotice?: ComponentType<TableStaleNoticeProps>; /** Host default; a table's explicit density takes precedence. */ defaultDensity?: MatrxDataTableDensity; /** Host default look (`default` | `mac`); a table's explicit `look` takes precedence. One switch turns every table under the host, and every mode built on it, to the Mac look. */ defaultLook?: MatrxDataTableLook; notify?: { success(message: string, options?: { description?: string }): void; error(message: string, options?: { description?: string }): void }; /** Client-side navigation (the app router), for `rowClick=\"page\"`. Absent: a full page load. */ navigate?: (href: string) => void; }\n// Public entrypoints are independently bundled in ESM and CJS. The context\n// identity must survive those bundle boundaries; values stay provider-scoped.\nconst HOST_SLOT = Symbol.for(\"ai-matrx.design-system.table-host-context\");\nconst hostRegistry = globalThis as typeof globalThis & { [HOST_SLOT]?: Context<MatrxDataTableHost> };\nconst HostContext = hostRegistry[HOST_SLOT] ??= createContext<MatrxDataTableHost>({});\nexport function MatrxDataTableProvider({ value, children }: { value: MatrxDataTableHost; children: ReactNode }) { return <HostContext.Provider value={value}>{children}</HostContext.Provider>; }\nexport function useMatrxDataTableHost(): MatrxDataTableHost { return useContext(HostContext); }\n\nexport interface MatrxTableRowAlchemy {\n  copy: CopyControlProps;\n  controls?: MatrxDataTableRecordControls;\n  placement: \"inline\" | \"menu\";\n  ready: boolean;\n  activate(): void;\n  /** Mount Alchemy's canonical palette in the host row menu. */\n  mountMenu(target: HTMLElement | null, onClose?: () => void, restoreFocus?: () => void): void;\n  prepare(restoreFocus?: () => void): Promise<void>;\n}\n\nconst ROW_ALCHEMY_SLOT = Symbol.for(\"ai-matrx.design-system.table-row-alchemy-context\");\nconst rowAlchemyRegistry = globalThis as typeof globalThis & { [ROW_ALCHEMY_SLOT]?: Context<MatrxTableRowAlchemy | null> };\nconst RowAlchemyContext = rowAlchemyRegistry[ROW_ALCHEMY_SLOT] ??= createContext<MatrxTableRowAlchemy | null>(null);\n\nexport function MatrxTableRowAlchemyScope({ value, children }: { value: MatrxTableRowAlchemy; children: ReactNode }) { return <RowAlchemyContext.Provider value={value}>{children}</RowAlchemyContext.Provider>; }\n\nexport function useMatrxTableRowAlchemy(): MatrxTableRowAlchemy | null { return useContext(RowAlchemyContext); }\n\nconst ROW_CONTROLS_SLOT = Symbol.for(\"ai-matrx.design-system.table-row-controls-context\");\nconst rowControlsRegistry = globalThis as typeof globalThis & { [ROW_CONTROLS_SLOT]?: Context<MatrxDataTableRecordControls | null> };\nconst RowControlsContext = rowControlsRegistry[ROW_CONTROLS_SLOT] ??= createContext<MatrxDataTableRecordControls | null>(null);\nexport function MatrxTableRowControlsScope({ value, children }: { value: MatrxDataTableRecordControls; children: ReactNode }) { return <RowControlsContext.Provider value={value}>{children}</RowControlsContext.Provider>; }\nexport function useMatrxTableRowControls(): MatrxDataTableRecordControls | null { return useContext(RowControlsContext); }\n\n/** Light door for components a row draws (a row menu): declare a lazy data prop without loading the table. */\nexport { declareLazyDataProps } from \"./row-drawing\";\n","/**\n * A ROW IS REDRAWN WHEN WHAT IT SHOWS CHANGED — NEVER BECAUSE A FUNCTION WAS BORN AGAIN\n * (lane TABLE-RERENDER, 2026-10-03).\n *\n * Hosts write `cell`, `customActions`, `getRowId`, `rowClassName` and their handlers inline, so every\n * host render hands the table new functions. Identity cannot say whether a new function draws\n * anything new, so the table used to redraw every row: /artifacts (560 rows) spent ~2.6 s redrawing\n * 1,120 rows to open one artifact. Asking every host to stabilise its callbacks fixed one screen of\n * ~85 at a time.\n *\n * The table now ASKS the row instead. When only the host's functions changed, a row builds its\n * elements (cheap — no component runs) and compares them with what it drew last:\n *   · equal → it returns the SAME element object it committed, and React does not descend into it;\n *   · different → it draws, and only that row pays.\n * Handlers inside a row that was not redrawn still call the host's LATEST function: every event\n * handler (`on[A-Z]…`) and every function the table marks `lazyCallback` is handed to the DOM as a\n * stable trampoline whose target is refreshed on each comparison (the latest-ref pattern, applied\n * to every handler a row holds instead of to a list the table has to keep in sync).\n *\n * Any other function in the tree (a render prop, a formatter a child calls while it renders, a\n * component type) is compared by identity, so a new one redraws the row — exactly as before. That\n * keeps the rule honest: a row is never left showing what an old closure drew. The one exception is\n * a prop its component DECLARED a lazy data getter (`declareLazyDataProps`): it is compared by what\n * it returns.\n */\nimport { cloneElement, isValidElement, type ReactElement, type ReactNode } from \"react\";\n\nconst LAZY = Symbol.for(\"@ai-matrx/design-system/data-table/lazy-callback\");\nconst MAX_DEPTH = 32;\nconst HANDLER_KEY = /^on[A-Z]/;\n\ntype AnyFunction = (...args: never[]) => unknown;\n\n/**\n * Marks a function the table hands into a row as one that runs LATER (on a click, a copy, a menu\n * choice) and never while a child renders — so a row may keep a trampoline to it instead of\n * redrawing when only its identity changed.\n */\nexport function lazyCallback<F extends AnyFunction>(fn: F): F {\n  (fn as F & { [LAZY]?: true })[LAZY] = true;\n  return fn;\n}\n\nfunction isLazy(fn: unknown): boolean {\n  return (fn as { [LAZY]?: true })[LAZY] === true;\n}\n\nconst LAZY_DATA_PROPS = Symbol.for(\"@ai-matrx/design-system/data-table/lazy-data-props\");\n\n/**\n * Declares the props of `component` that take a GETTER of data the component reads only later —\n * a row menu's `config={() => menu}`, resolved when the menu opens. Without it a getter is just an\n * unknown function, compared by identity, and a host that builds it inline (every row menu does)\n * redraws every row on every render of its own: /crm redrew all 25 rows on each checkbox tick.\n *\n * A declared prop is compared by what the getter RETURNS (its handlers by trampoline, everything\n * else exactly as a drawing is): the same data → the row keeps its drawing and the component is\n * handed a stable trampoline to the host's LATEST getter, so it opens with fresh items; different\n * data (a checkbox in an open menu flipped) → that row alone redraws. Declare once, on the\n * component — never per call site.\n *\n * The contract: a declared getter is PURE and CHEAP — the row calls the previous and the new one on\n * every host render to compare them. A getter that fetches, dispatches or builds something heavy\n * must not be declared.\n */\nexport function declareLazyDataProps<C extends object>(component: C, keys: readonly string[]): C {\n  (component as C & { [LAZY_DATA_PROPS]?: ReadonlySet<string> })[LAZY_DATA_PROPS] = new Set(keys);\n  return component;\n}\n\nfunction lazyDataKeys(type: unknown): ReadonlySet<string> | undefined {\n  if ((typeof type !== \"function\" && typeof type !== \"object\") || type === null) return undefined;\n  return (type as { [LAZY_DATA_PROPS]?: ReadonlySet<string> })[LAZY_DATA_PROPS];\n}\n\nconst UNRESOLVED = Symbol(\"unresolved\");\n\n/** A declared getter's data — or `UNRESOLVED` when calling it threw (the row then simply redraws). */\nfunction resolveLazyData(value: unknown): unknown {\n  if (typeof value !== \"function\") return value;\n  try {\n    return (value as () => unknown)();\n  } catch {\n    return UNRESOLVED;\n  }\n}\n\nfunction trampolinable(key: string, fn: unknown): boolean {\n  return isLazy(fn) || HANDLER_KEY.test(key);\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== \"object\") return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\ninterface Slot {\n  fn: (...args: unknown[]) => unknown;\n  readonly stable: (...args: unknown[]) => unknown;\n}\n\nfunction makeSlot(fn: (...args: unknown[]) => unknown): Slot {\n  const slot: Slot = {\n    fn,\n    // A Proxy rather than a bare wrapper: a handler that carries its own members (a debounced\n    // function's `cancel`) keeps them, read from the latest function.\n    stable: new Proxy((() => undefined) as (...args: unknown[]) => unknown, {\n      apply: (_target, thisArg, args: unknown[]) => Reflect.apply(slot.fn, thisArg, args),\n      get: (_target, key) => Reflect.get(slot.fn, key),\n    }),\n  };\n  return slot;\n}\n\ntype Updates = Array<[path: string, fn: (...args: unknown[]) => unknown]>;\n\nfunction sameEntries(\n  a: Record<string, unknown>,\n  b: Record<string, unknown>,\n  path: string,\n  depth: number,\n  updates: Updates,\n  lazyKeys?: ReadonlySet<string>,\n): boolean {\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) return false;\n  for (const key of keys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    // A ref is never a handler: a new callback ref must be attached by React.\n    if (key === \"ref\") {\n      if (!Object.is(a[key], b[key])) return false;\n      continue;\n    }\n    if (lazyKeys?.has(key) && (typeof a[key] === \"function\" || typeof b[key] === \"function\")) {\n      if (Object.is(a[key], b[key])) continue;\n      // A getter that became a plain value (or the reverse) is a new drawing: the committed element\n      // still holds a trampoline to the OLD getter, which nothing would re-point.\n      if (typeof a[key] !== typeof b[key]) return false;\n      const before = resolveLazyData(a[key]);\n      const after = resolveLazyData(b[key]);\n      if (before === UNRESOLVED || after === UNRESOLVED) return false;\n      // Handlers inside the data are reached through the getter's own trampoline, so the ones this\n      // comparison collects are dropped: the component calls the LATEST getter and gets them fresh.\n      if (!sameDrawing(before, after, key, `${path}/${key}()`, depth + 1, [])) return false;\n      if (typeof b[key] === \"function\") updates.push([`${path}/${key}`, b[key] as (...args: unknown[]) => unknown]);\n      continue;\n    }\n    if (!sameDrawing(a[key], b[key], key, `${path}/${key}`, depth + 1, updates)) return false;\n  }\n  return true;\n}\n\n/**\n * Whether `next` draws exactly what `previous` drew. Handlers that differ only by identity are\n * collected into `updates` (by path) so the caller can point the committed trampolines at them.\n */\nfunction sameDrawing(previous: unknown, next: unknown, key: string, path: string, depth: number, updates: Updates): boolean {\n  if (Object.is(previous, next)) return true;\n  if (typeof previous === \"function\" && typeof next === \"function\") {\n    if (trampolinable(key, previous) && trampolinable(key, next)) {\n      updates.push([path, next as (...args: unknown[]) => unknown]);\n      return true;\n    }\n    return false;\n  }\n  if (depth > MAX_DEPTH) return false;\n  if (isValidElement(previous) && isValidElement(next)) {\n    if (previous.type !== next.type || previous.key !== next.key) return false;\n    return sameEntries(\n      previous.props as Record<string, unknown>,\n      next.props as Record<string, unknown>,\n      path,\n      depth,\n      updates,\n      lazyDataKeys(previous.type),\n    );\n  }\n  if (Array.isArray(previous) && Array.isArray(next)) {\n    if (previous.length !== next.length) return false;\n    for (let i = 0; i < previous.length; i += 1) {\n      if (!sameDrawing(previous[i], next[i], key, `${path}/${i}`, depth + 1, updates)) return false;\n    }\n    return true;\n  }\n  if (isPlainObject(previous) && isPlainObject(next)) return sameEntries(previous, next, path, depth, updates);\n  return false;\n}\n\n/** `value` with every trampolinable function replaced by its stable trampoline. */\nfunction stabilize(value: unknown, key: string, path: string, depth: number, slots: Map<string, Slot>, reuse: Map<string, Slot> | undefined, lazyData = false): unknown {\n  if (typeof value === \"function\") {\n    if (!lazyData && !trampolinable(key, value)) return value;\n    const fn = value as (...args: unknown[]) => unknown;\n    const kept = reuse?.get(path);\n    const slot = kept ?? makeSlot(fn);\n    slot.fn = fn;\n    slots.set(path, slot);\n    return slot.stable;\n  }\n  if (depth > MAX_DEPTH) return value;\n  if (isValidElement(value)) {\n    const props = value.props as Record<string, unknown>;\n    const lazyKeys = lazyDataKeys(value.type);\n    let changed: Record<string, unknown> | null = null;\n    for (const propKey of Object.keys(props)) {\n      if (propKey === \"ref\") continue;\n      const before = props[propKey];\n      const after = stabilize(before, propKey, `${path}/${propKey}`, depth + 1, slots, reuse, lazyKeys?.has(propKey) ?? false);\n      if (after !== before) (changed ??= {})[propKey] = after;\n    }\n    if (!changed) return value;\n    const clone = cloneElement(value as ReactElement, changed);\n    // React (dev) marks JSX's static children as key-checked on the ELEMENT; a clone starts\n    // unmarked, and a clone inside a static children array would then warn about a missing key.\n    const before = (value as { _store?: { validated?: unknown } })._store;\n    const after = (clone as { _store?: { validated?: unknown } })._store;\n    if (before && after && \"validated\" in before) {\n      try { after.validated = before.validated; } catch { /* frozen in some builds: only a dev warning is at stake */ }\n    }\n    return clone;\n  }\n  if (Array.isArray(value)) {\n    let out: unknown[] | null = null;\n    for (let i = 0; i < value.length; i += 1) {\n      const after = stabilize(value[i], key, `${path}/${i}`, depth + 1, slots, reuse);\n      if (after !== value[i]) (out ??= value.slice())[i] = after;\n    }\n    return out ?? value;\n  }\n  if (isPlainObject(value)) {\n    let out: Record<string, unknown> | null = null;\n    for (const entryKey of Object.keys(value)) {\n      const before = value[entryKey];\n      const after = stabilize(before, entryKey, `${path}/${entryKey}`, depth + 1, slots, reuse);\n      if (after !== before) (out ??= { ...value })[entryKey] = after;\n    }\n    return out ?? value;\n  }\n  return value;\n}\n\ninterface RowDrawing {\n  /** What the host and the table built last time — compared, never rendered. */\n  raw: unknown;\n  /** What React was handed: `raw` with trampolines. Returned unchanged while the drawing holds. */\n  out: ReactNode;\n  slots: Map<string, Slot>;\n}\n\n/** One table's drawings, by row id. */\nexport class RowDrawings {\n  private readonly rows = new Map<string, RowDrawing>();\n\n  /**\n   * The element to hand React for this row. The SAME object as last time when `raw` draws what the\n   * last one drew (its handlers are re-pointed); a new one otherwise.\n   */\n  draw(rowId: string, raw: ReactNode, fresh = false): ReactNode {\n    const previous = this.rows.get(rowId);\n    // `fresh`: the row's own facts moved — what it shows may differ even when its elements match.\n    if (previous && !fresh) {\n      const updates: Updates = [];\n      if (sameDrawing(previous.raw, raw, \"\", \"\", 0, updates) && updates.every(([path]) => previous.slots.has(path))) {\n        for (const [path, fn] of updates) previous.slots.get(path)!.fn = fn;\n        previous.raw = raw;\n        return previous.out;\n      }\n    }\n    const slots = new Map<string, Slot>();\n    const out = stabilize(raw, \"\", \"\", 0, slots, previous?.slots) as ReactNode;\n    this.rows.set(rowId, { raw, out, slots });\n    return out;\n  }\n\n  /** Forget rows that are no longer in the table (bounded by what was ever drawn). */\n  prune(liveIds: ReadonlySet<string>): void {\n    for (const id of this.rows.keys()) if (!liveIds.has(id)) this.rows.delete(id);\n  }\n\n  get size(): number {\n    return this.rows.size;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCA,IAAAA,gBAAoH;;;ACwBpH,mBAAgF;AAsBhF,IAAM,kBAAkB,uBAAO,IAAI,oDAAoD;AAkBhF,SAAS,qBAAuC,WAAc,MAA4B;AAC/F,EAAC,UAA8D,eAAe,IAAI,IAAI,IAAI,IAAI;AAC9F,SAAO;AACT;;;AD4ByH;AAHzH,IAAM,YAAY,uBAAO,IAAI,2CAA2C;AACxE,IAAM,eAAe;AACrB,IAAM,cAAc,aAAa,SAAS,UAAM,6BAAkC,CAAC,CAAC;AAC7E,SAAS,uBAAuB,EAAE,OAAO,SAAS,GAAuD;AAAE,SAAO,4CAAC,YAAY,UAAZ,EAAqB,OAAe,UAAS;AAAyB;AACzL,SAAS,wBAA4C;AAAE,aAAO,0BAAW,WAAW;AAAG;AAa9F,IAAM,mBAAmB,uBAAO,IAAI,kDAAkD;AACtF,IAAM,qBAAqB;AAC3B,IAAM,oBAAoB,mBAAmB,gBAAgB,UAAM,6BAA2C,IAAI;AAE3G,SAAS,0BAA0B,EAAE,OAAO,SAAS,GAAyD;AAAE,SAAO,4CAAC,kBAAkB,UAAlB,EAA2B,OAAe,UAAS;AAA+B;AAE1M,SAAS,0BAAuD;AAAE,aAAO,0BAAW,iBAAiB;AAAG;AAE/G,IAAM,oBAAoB,uBAAO,IAAI,mDAAmD;AACxF,IAAM,sBAAsB;AAC5B,IAAM,qBAAqB,oBAAoB,iBAAiB,UAAM,6BAAmD,IAAI;AACtH,SAAS,2BAA2B,EAAE,OAAO,SAAS,GAAiE;AAAE,SAAO,4CAAC,mBAAmB,UAAnB,EAA4B,OAAe,UAAS;AAAgC;AACrN,SAAS,2BAAgE;AAAE,aAAO,0BAAW,kBAAkB;AAAG;","names":["import_react"]}

package/dist/data-table/host.d.cts

@@ -1257,8 +1257,12 @@ interface MatrxDataTableHost {
     defaultDensity?: MatrxDataTableDensity; /** Host default look (`default` | `mac`); a table's explicit `look` takes precedence. One switch turns every table under the host, and every mode built on it, to the Mac look. */
     defaultLook?: MatrxDataTableLook;
     notify?: {
-        success(message: string): void;
-        error(message: string): void;
+        success(message: string, options?: {
+            description?: string;
+        }): void;
+        error(message: string, options?: {
+            description?: string;
+        }): void;
     }; /** Client-side navigation (the app router), for `rowClick="page"`. Absent: a full page load. */
     navigate?: (href: string) => void;
 }

package/dist/data-table/host.d.ts

@@ -1257,8 +1257,12 @@ interface MatrxDataTableHost {
     defaultDensity?: MatrxDataTableDensity; /** Host default look (`default` | `mac`); a table's explicit `look` takes precedence. One switch turns every table under the host, and every mode built on it, to the Mac look. */
     defaultLook?: MatrxDataTableLook;
     notify?: {
-        success(message: string): void;
-        error(message: string): void;
+        success(message: string, options?: {
+            description?: string;
+        }): void;
+        error(message: string, options?: {
+            description?: string;
+        }): void;
     }; /** Client-side navigation (the app router), for `rowClick="page"`. Absent: a full page load. */
     navigate?: (href: string) => void;
 }

package/dist/data-table/host.js

@@ -8,7 +8,7 @@ import {
   useMatrxDataTableHost,
   useMatrxTableRowAlchemy,
   useMatrxTableRowControls
-} from "../chunk-POJ3RR3K.js";
+} from "../chunk-B5D3VIMC.js";
 export {
   MatrxDataTableProvider,
   MatrxTableRowAlchemyScope,

package/dist/data-table/index.cjs

@@ -1120,7 +1120,7 @@ var DropdownMenuSubTrigger = React6.forwardRef(({ className, inset, children, ..
 DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive.SubTrigger.displayName;
 var DropdownMenuSubContent = React6.forwardRef(({ className, container, surface = "default", sideOffset = 2, alignOffset = -4, collisionPadding, onFocusOutside, children, ...props }, ref) => {
   const portalContainer = usePortalContainer(container);
-  const [bottomClearance] = React6.useState(readBottomClearance);
+  const [bottomClearance] = React6.useState(sharedBottomClearance);
   const padding = menuCollisionPadding(collisionPadding ?? 8, 0, bottomClearance);
   const nested = useNestedSubmenuPlacement(ref, padding);
   const keep = useSubmenuSurvivesParentPanelFocus(nested.ref, onFocusOutside);
@@ -1142,18 +1142,27 @@ var DropdownMenuSubContent = React6.forwardRef(({ className, container, surface
   ) });
 });
 DropdownMenuSubContent.displayName = DropdownMenuPrimitive.SubContent.displayName;
-function readTopClearance() {
-  return readClearance("var(--matrx-floating-top-clearance, var(--shell-header-h, 0px))");
-}
-function readBottomClearance() {
-  return readClearance("var(--matrx-floating-clearance, 0px)");
-}
 function menuCollisionPadding(caller, top, bottom, fallback = 0) {
   const side = (key) => typeof caller === "number" ? caller : caller?.[key] ?? fallback;
   return { top: Math.max(side("top"), top), right: side("right"), bottom: Math.max(side("bottom"), bottom), left: side("left") };
 }
-function readClearance(height) {
+var CLEARANCE_REUSE_MS = 500;
+var clearanceCache = /* @__PURE__ */ new Map();
+var clock = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+function readClearance(height, shared = false) {
   if (typeof document === "undefined") return 0;
+  const now = clock();
+  const held = shared ? clearanceCache.get(height) : void 0;
+  if (held && now - held.at < CLEARANCE_REUSE_MS) return held.px;
+  const px2 = measureClearance(height);
+  clearanceCache.set(height, { px: px2, at: now });
+  return px2;
+}
+var TOP_CLEARANCE = "var(--matrx-floating-top-clearance, var(--shell-header-h, 0px))";
+var BOTTOM_CLEARANCE = "var(--matrx-floating-clearance, 0px)";
+var sharedTopClearance = () => readClearance(TOP_CLEARANCE, true);
+var sharedBottomClearance = () => readClearance(BOTTOM_CLEARANCE, true);
+function measureClearance(height) {
   const probe2 = document.createElement("div");
   probe2.style.cssText = `position:fixed;top:0;left:0;width:0;visibility:hidden;pointer-events:none;height:${height}`;
   document.body.appendChild(probe2);
@@ -1163,8 +1172,8 @@ function readClearance(height) {
 }
 var DropdownMenuContent = React6.forwardRef(({ className, sideOffset = 4, container, surface = "default", children, onCloseAutoFocus, collisionPadding, ...props }, ref) => {
   const portalContainer = usePortalContainer(container);
-  const [topClearance] = React6.useState(readTopClearance);
-  const [bottomClearance] = React6.useState(readBottomClearance);
+  const [topClearance] = React6.useState(sharedTopClearance);
+  const [bottomClearance] = React6.useState(sharedBottomClearance);
   const edges = useMenuScrollEdges(ref);
   return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DropdownMenuPrimitive.Portal, { container: portalContainer, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
     DropdownMenuPrimitive.Content,
@@ -6442,13 +6451,14 @@ function useTableNotice() {
   const [message, setMessage] = (0, import_react17.useState)(null);
   const notify = (0, import_react17.useMemo)(
     () => ({
-      success(text) {
-        if (host.notify) host.notify.success(text);
-        else setMessage({ text, error: false });
+      // A card is a short title and an optional line (NOTICE_TEXT_BUDGET); the inline fallback joins them.
+      success(text, options) {
+        if (host.notify) host.notify.success(text, options);
+        else setMessage({ text: options?.description ? `${text}. ${options.description}` : text, error: false });
       },
-      error(text) {
-        if (host.notify) host.notify.error(text);
-        else setMessage({ text, error: true });
+      error(text, options) {
+        if (host.notify) host.notify.error(text, options);
+        else setMessage({ text: options?.description ? `${text}. ${options.description}` : text, error: true });
       }
     }),
     [host]
@@ -11888,9 +11898,9 @@ function drillWindowMoment(value) {
 function momentWords(end) {
   const [y, m, d] = end.slice(0, 10).split("-").map(Number);
   const month = new Date(Date.UTC(y, m - 1, d)).toLocaleString("en-US", { month: "short", timeZone: "UTC" });
-  const clock = end.length > 10 ? end.slice(11, 16) : null;
+  const clock2 = end.length > 10 ? end.slice(11, 16) : null;
   const zone = end.endsWith("Z") ? "UTC" : end.length > 16 ? `UTC${end.slice(-6)}`.replace("UTC+00:00", "UTC") : "";
-  return { day: `${month} ${d}, ${y}`, clock, zone };
+  return { day: `${month} ${d}, ${y}`, clock: clock2, zone };
 }
 function drillWindowLabel(window2) {
   if (!window2) return "All time";
@@ -14090,9 +14100,9 @@ function drillConfigFromColumns(columns, rows = [], options = {}) {
         { key: `max_${id}`, label: `${label} (max)`, additive: false, op: "max", of: id, ...fmt }
       );
     } else if (kind === "time") {
-      const clock = sample.some((v) => v instanceof Date || typeof v === "string" && v.length > 10 && !/T00:00(:00(\.0+)?)?(Z|[+-]00:?00)?$/.test(v));
-      if (!clock) calendarDates.add(id);
-      dimensions.push({ key: id, label, kind: "time", grains: clock ? MATRX_DRILL_GRAINS : MATRX_DRILL_DEFAULT_GRAINS });
+      const clock2 = sample.some((v) => v instanceof Date || typeof v === "string" && v.length > 10 && !/T00:00(:00(\.0+)?)?(Z|[+-]00:?00)?$/.test(v));
+      if (!clock2) calendarDates.add(id);
+      dimensions.push({ key: id, label, kind: "time", grains: clock2 ? MATRX_DRILL_GRAINS : MATRX_DRILL_DEFAULT_GRAINS });
     } else if (kind === "boolean") {
       dimensions.push({ key: id, label, kind: "boolean", cardinality: "low" });
     } else if (kind === "text") {
@@ -18306,7 +18316,7 @@ function RecordId({
     e.preventDefault();
     void (0, import_clipboard2.copyText)(value).then((ok) => {
       if (!ok) {
-        notify?.error(`Couldn't copy ${copyLabel}`);
+        notify?.error("Not copied", { description: copyLabel });
         return;
       }
       setCopied(true);
@@ -18322,12 +18332,10 @@ function RecordId({
     try {
       const result = await onOpen(value);
       if (result === "forbidden") {
-        notify?.error("You don't have access to open this record");
+        notify?.error("No access", { description: "This account can't open this record" });
       }
     } catch (err) {
-      notify?.error(
-        `Couldn't open: ${err instanceof Error ? err.message : String(err)}`
-      );
+      notify?.error("Not opened", { description: peopleErrorSentence(err, null, { card: true }) });
     } finally {
       setOpening(false);
     }
@@ -23147,9 +23155,7 @@ function MatrxDataTableCore(coreProps) {
         });
         toast.success("Change saved");
       }).catch((error) => {
-        toast.error(
-          `Couldn't save: ${error instanceof Error ? error.message : String(error)}`
-        );
+        toast.error("Not saved", { description: peopleErrorSentence(error, null, { card: true }) });
       }).finally(() => finishSaving(scope));
     }
   };
@@ -23295,9 +23301,7 @@ function MatrxDataTableCore(coreProps) {
     if (!hierarchy) return;
     void Promise.resolve(hierarchy.onMove(row, move)).catch(
       (error) => {
-        toast.error(
-          `Couldn't move row: ${error instanceof Error ? error.message : String(error)}`
-        );
+        toast.error("Row not moved", { description: peopleErrorSentence(error, null, { card: true }) });
       }
     );
   };
@@ -23425,9 +23429,7 @@ function MatrxDataTableCore(coreProps) {
       });
       toast.success("Changes saved");
     } catch (e) {
-      toast.error(
-        `Couldn't save: ${e instanceof Error ? e.message : String(e)}`
-      );
+      toast.error("Not saved", { description: peopleErrorSentence(e, null, { card: true }) });
     } finally {
       savingScopesRef.current.delete(scope);
       finishSaving(scope);
@@ -25004,7 +25006,7 @@ function MatrxDataTableCore(coreProps) {
                                           void Promise.resolve().then(() => toolbar.refresh?.onRefresh()).catch((cause) => {
                                             const message = cause instanceof Error ? cause.message : String(cause);
                                             setToolbarActionError(`Refresh failed: ${message}`);
-                                            toast.error(`Refresh failed: ${message}`);
+                                            toast.error("Not refreshed", { description: peopleErrorSentence(cause, message, { card: true }) });
                                           }).finally(() => {
                                             toolbarActionPendingRef.current.refresh = false;
                                             setToolbarActionPending((current) => ({ ...current, refresh: false }));
@@ -25029,7 +25031,7 @@ function MatrxDataTableCore(coreProps) {
                                           void Promise.resolve().then(() => toolbar.add?.onAdd()).catch((cause) => {
                                             const message = cause instanceof Error ? cause.message : String(cause);
                                             setToolbarActionError(`Add failed: ${message}`);
-                                            toast.error(`Add failed: ${message}`);
+                                            toast.error("Not added", { description: peopleErrorSentence(cause, message, { card: true }) });
                                           }).finally(() => {
                                             toolbarActionPendingRef.current.add = false;
                                             setToolbarActionPending((current) => ({ ...current, add: false }));