@iris-ui-kit/vue 0.2.36 → 0.2.38

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var vue = require('vue');
+var grid = require('@iris-ui-kit/core/grid');
 var core = require('@iris-ui-kit/core');
 var theme = require('@iris-ui-kit/theme');
 var skins = require('@iris-ui-kit/skins');
@@ -20,6 +21,378 @@ function useStoreSelector(store2, selector, equals) {
   vue.onScopeDispose(store2.subscribeWith(selector, (v) => slice.value = v, equals));
   return slice;
 }
+function defaultValue(row, column) {
+  return row[column.dataIndex ?? column.key];
+}
+function defaultSetValue(row, column, value) {
+  return { ...row, [column.dataIndex ?? column.key]: value };
+}
+function useGridClipboard(core, options) {
+  const latest = vue.shallowRef(options);
+  if (!core.hasFeature("clipboard")) {
+    core.use(
+      grid.createGridClipboardFeature({
+        getRows: () => latest.value.getRows?.() ?? core.invoke("getRows"),
+        getColumns: () => latest.value.getColumns(),
+        rowKeyField: latest.value.rowKeyField,
+        overflowRows: (context) => latest.value.overflowRows?.(context),
+        resolveValue: (row, column) => {
+          const resolve4 = latest.value.resolveValue;
+          return resolve4 ? resolve4(row, column) : defaultValue(row, column);
+        },
+        parseValue: (text, row, column) => {
+          const parse = latest.value.parseValue;
+          return parse ? parse(text, row, column) : text;
+        },
+        setValue: (row, column, value) => latest.value.setValue?.(row, column, value) ?? defaultSetValue(row, column, value),
+        isCellEditable: (row, column, rowIndex, columnIndex) => latest.value.isCellEditable?.(row, column, rowIndex, columnIndex) ?? true,
+        reconcileRows: (sourceRows, previousRows, rows) => latest.value.reconcileRows?.(sourceRows, previousRows, rows) ?? rows,
+        commitOptions: () => {
+          const configured = latest.value.commitOptions;
+          return typeof configured === "function" ? configured() : configured ?? {};
+        },
+        onCopy: (change) => latest.value.onCopy?.(change),
+        onPaste: (change) => latest.value.onPaste?.(change)
+      })
+    );
+  }
+  const model = core.invoke("getClipboardModel");
+  return {
+    core,
+    model,
+    serialize: (format, copyWithFormat) => model.serialize(
+      format ?? latest.value.copyFormat ?? "tsv",
+      copyWithFormat ?? latest.value.copyWithFormat ?? false
+    ),
+    paste: (text, range) => model.paste(text, range)
+  };
+}
+function useGridFeature(core, name, method, create) {
+  if (!core.hasFeature(name)) core.use(create());
+  return core.invoke(method);
+}
+function useGridEditing(core, options) {
+  const latest = vue.shallowRef(options);
+  const model = useGridFeature(
+    core,
+    "editing",
+    "getEditingModel",
+    () => grid.createGridEditingFeature({
+      getRowKey: (row, index) => latest.value.getRowKey(row, index),
+      getRowIndex: (rowKey, row, rootRows) => latest.value.getRowIndex?.(rowKey, row, rootRows),
+      getRules: (columnKey) => latest.value.getRules?.(columnKey),
+      getValue: (row, columnKey) => latest.value.getValue?.(row, columnKey) ?? row[columnKey],
+      setValue: (row, columnKey, value) => latest.value.setValue?.(row, columnKey, value) ?? { ...row, [columnKey]: value },
+      coerce: (draft, row, columnKey) => latest.value.coerce?.(draft, row, columnKey) ?? draft,
+      validate: (value, row, columnKey) => latest.value.validate?.(value, row, columnKey) ?? null,
+      isEditable: (row, columnKey) => latest.value.isEditable?.(row, columnKey) ?? true,
+      missingRowMessage: options.missingRowMessage,
+      commitOptions: () => {
+        const configured = latest.value.commitOptions;
+        return typeof configured === "function" ? configured() : configured ?? {};
+      },
+      onStateChange: (state2) => latest.value.onStateChange?.(state2),
+      onValidation: (validation) => latest.value.onValidation?.(validation),
+      onCommit: (commit) => latest.value.onCommit?.(commit)
+    })
+  );
+  const state = useStore(model.store);
+  return {
+    core,
+    model,
+    state,
+    startCellEdit: (rowKey, columnKey, initialDraft) => model.start(rowKey, columnKey, initialDraft),
+    setCellDraft: (value) => model.setDraft(value),
+    cancelCellEdit: () => model.cancelEdit(),
+    commitCellEdit: (value) => model.commitEdit(value),
+    isCellEditing: (rowKey, columnKey) => model.isEditing(rowKey, columnKey)
+  };
+}
+function useGridRange(core, options = {}) {
+  const latest = vue.shallowRef(options);
+  if (!core.hasFeature("range")) {
+    core.use(
+      grid.createGridRangeFeature({
+        onChange: (change) => latest.value.onChange?.(change)
+      })
+    );
+  }
+  const model = core.invoke("getRangeModel");
+  const state = useStore(model);
+  const range = vue.computed(() => {
+    const { anchor, active } = state.value;
+    if (!anchor || !active) return null;
+    return {
+      start: {
+        row: Math.min(anchor.row, active.row),
+        col: Math.min(anchor.col, active.col)
+      },
+      end: {
+        row: Math.max(anchor.row, active.row),
+        col: Math.max(anchor.col, active.col)
+      }
+    };
+  });
+  return { model, state, range };
+}
+
+// src/grid/index.ts
+function useGridCore(options = {}) {
+  const core = grid.createGridCore(options);
+  vue.onMounted(() => core.ready());
+  vue.onBeforeUnmount(() => core.destroy());
+  return core;
+}
+function useGridFeature2(core, name, method, create) {
+  if (!core.hasFeature(name)) core.use(create());
+  return core.invoke(method);
+}
+function useGridSelection(core, options = {}) {
+  const latest = vue.shallowRef(options);
+  const model = useGridFeature2(
+    core,
+    "selection",
+    "getSelectionModel",
+    () => grid.createGridSelectionFeature({
+      mode: options.mode,
+      defaultSelected: options.value ?? options.defaultValue,
+      getKeys: () => latest.value.getKeys?.() ?? [],
+      onChange: (keys) => latest.value.onChange?.(keys)
+    })
+  );
+  const state = useStore(model.store);
+  const controlled = vue.computed(() => options.value !== void 0);
+  vue.watch(
+    () => options.value,
+    (value) => {
+      if (value !== void 0) model.sync(value);
+    },
+    { immediate: true }
+  );
+  return {
+    model,
+    controlled,
+    selection: vue.computed(() => controlled.value ? options.value ?? [] : state.value)
+  };
+}
+function useGridExpansion(core, options = {}) {
+  const latest = vue.shallowRef(options);
+  const model = useGridFeature2(
+    core,
+    "expansion",
+    "getExpansionModel",
+    () => grid.createGridExpansionFeature({
+      mode: options.mode,
+      defaultExpanded: options.defaultValue,
+      getKeys: () => latest.value.getKeys?.() ?? [],
+      onChange: (keys) => latest.value.onChange?.(keys)
+    })
+  );
+  return { model, expandedKeys: useStore(model.store) };
+}
+function useGridRows(core, initialRows, options = {}) {
+  const latest = vue.shallowRef(options);
+  const model = useGridFeature2(
+    core,
+    "rows",
+    "getRowsModel",
+    () => grid.createGridRowsFeature({
+      defaultRows: initialRows,
+      cloneDefaultRows: options.cloneDefaultRows,
+      rowKeyField: options.rowKeyField,
+      getRowKey: (row, index) => latest.value.getRowKey?.(row, index),
+      getChildren: options.getChildren,
+      setChildren: options.setChildren,
+      onBeforeRowsChange: (tx) => latest.value.onBeforeRowsChange?.(tx),
+      onRowsChange: (tx) => latest.value.onRowsChange?.(tx)
+    })
+  );
+  return { model, rows: useStore(model.store) };
+}
+function useGridColumns(core, options = {}) {
+  const latest = vue.shallowRef(options);
+  const model = useGridFeature2(
+    core,
+    "columns",
+    "getColumnsModel",
+    () => grid.createGridColumnsFeature({
+      defaultVisibility: options.visibility ?? options.defaultVisibility,
+      defaultOrder: options.order ?? options.defaultOrder,
+      defaultWidths: options.widths ?? options.defaultWidths,
+      defaultPinned: options.pinned ?? options.defaultPinned,
+      onVisibilityChange: (v) => latest.value.onVisibilityChange?.(v),
+      onOrderChange: (v) => latest.value.onOrderChange?.(v),
+      onWidthsChange: (v) => latest.value.onWidthsChange?.(v),
+      onPinnedChange: (k, v) => latest.value.onPinnedChange?.(k, v)
+    })
+  );
+  const state = useStore(model.store);
+  vue.watch(
+    () => options.visibility,
+    (v) => v !== void 0 && model.syncVisibility(v)
+  );
+  vue.watch(
+    () => options.order,
+    (v) => v !== void 0 && model.syncOrder(v)
+  );
+  vue.watch(
+    () => options.widths,
+    (v) => v !== void 0 && model.syncWidths(v)
+  );
+  vue.watch(
+    () => options.pinned,
+    (v) => v !== void 0 && model.syncPinned(v)
+  );
+  return {
+    model,
+    state,
+    setVisibility: (v) => model.setVisibility(v),
+    toggleVisibility: (k) => model.toggleVisibility(k),
+    setOrder: (v) => model.setOrder(v),
+    clearOrder: () => model.setOrder(void 0),
+    setWidth: (k, v) => model.setWidth(k, v),
+    setWidths: (v) => model.setWidths(v),
+    resetWidths: () => model.setWidths({}),
+    setPinned: (k, v) => model.setPinned(k, v)
+  };
+}
+function useGridPagination(core, options = {}) {
+  const latest = vue.shallowRef(options);
+  const model = useGridFeature2(
+    core,
+    "pagination",
+    "getPaginationModel",
+    () => grid.createGridPaginationFeature({
+      defaultPage: options.page ?? options.defaultPage,
+      defaultPageSize: options.pageSize ?? options.defaultPageSize,
+      defaultTotal: options.total ?? options.defaultTotal,
+      onChange: (change) => latest.value.onChange?.(change)
+    })
+  );
+  const pagination = useStore(model.store);
+  vue.watch(
+    () => [options.page, options.pageSize, options.total],
+    ([page, pageSize, total]) => model.sync({ page, pageSize, total }),
+    { immediate: true }
+  );
+  return {
+    model,
+    pagination,
+    setPage: (v) => model.setPage(v),
+    setPageSize: (v) => model.setPageSize(v),
+    setPagination: (page, size) => model.set(page, size)
+  };
+}
+function useGridSorting(core, options = {}) {
+  const latest = vue.shallowRef(options);
+  const model = useGridFeature2(
+    core,
+    "sorting",
+    "getSortingModel",
+    () => grid.createGridSortingFeature({
+      mode: options.mode,
+      defaultSort: options.sort ?? options.defaultSort,
+      defaultMultiSort: options.multiSortState ?? options.defaultMultiSort,
+      onSortChange: (v) => latest.value.onSortChange?.(v),
+      onMultiSortChange: (v) => latest.value.onMultiSortChange?.(v)
+    })
+  );
+  const state = useStore(model.store);
+  vue.watch(
+    () => options.sort,
+    (v) => v !== void 0 && model.syncSort(v)
+  );
+  vue.watch(
+    () => options.multiSortState,
+    (v) => v !== void 0 && model.syncMultiSort(v)
+  );
+  return {
+    model,
+    sort: vue.computed(() => options.sort !== void 0 ? options.sort : state.value.sort),
+    multiSort: vue.computed(
+      () => options.multiSortState !== void 0 ? options.multiSortState : state.value.multiSort
+    ),
+    cycleSort: (key) => model.cycleSort(key),
+    setSort: (v) => model.setSort(v),
+    cycleMultiSort: (key) => model.cycleMultiSort(key),
+    setMultiSort: (v) => model.setMultiSort(v)
+  };
+}
+function useGridFiltering(core, options = {}) {
+  const latest = vue.shallowRef(options);
+  const model = useGridFeature2(
+    core,
+    "filtering",
+    "getFilteringModel",
+    () => grid.createGridFilteringFeature({
+      defaultFilters: options.filters ?? options.defaultFilters,
+      defaultFilterValues: options.filterValues ?? options.defaultFilterValues,
+      onFiltersChange: (v) => latest.value.onFiltersChange?.(v),
+      onFilterValuesChange: (v) => latest.value.onFilterValuesChange?.(v)
+    })
+  );
+  const state = useStore(model.store);
+  vue.watch(
+    () => options.filters,
+    (v) => v !== void 0 && model.syncFilters(v)
+  );
+  vue.watch(
+    () => options.filterValues,
+    (v) => v !== void 0 && model.syncFilterValues(v)
+  );
+  return {
+    model,
+    filters: vue.computed(() => options.filters ?? state.value.filters),
+    filterValues: vue.computed(() => options.filterValues ?? state.value.filterValues)
+  };
+}
+function useGridVirtual(core, options) {
+  const model = useGridFeature2(
+    core,
+    "virtual",
+    "getVirtualModel",
+    () => grid.createGridVirtualFeature({
+      count: options.items.length,
+      estimateSize: (index) => {
+        const estimate = options.estimateSize;
+        return typeof estimate === "function" ? estimate(index) : estimate;
+      },
+      viewportSize: options.viewportSize,
+      scrollOffset: options.scrollOffset,
+      buffer: options.buffer,
+      fixedSize: typeof options.estimateSize === "number" ? options.estimateSize : null,
+      getItemKey: (index) => {
+        const item = options.items[index];
+        return item !== void 0 && options.getItemKey ? options.getItemKey(item, index) : index;
+      },
+      onRangeChange: options.onRangeChange
+    })
+  );
+  vue.watch(
+    () => options.items,
+    (items) => model.setCount(items.length)
+  );
+  vue.watch(
+    () => options.buffer,
+    (buffer) => model.setBuffer(buffer ?? 0)
+  );
+  vue.watch(
+    () => options.estimateSize,
+    (estimate) => {
+      model.setFixedSize(typeof estimate === "number" ? estimate : null);
+      model.remeasure();
+    }
+  );
+  vue.watch(
+    () => options.viewportSize,
+    (size) => size !== void 0 && model.setViewportSize(size)
+  );
+  vue.watch(
+    () => options.scrollOffset,
+    (offset) => offset !== void 0 && model.setScroll(offset)
+  );
+  return { model, state: useStore(model.store) };
+}
 function useReconnectingSource(connect, handlers, options) {
   const status = vue.ref("idle");
   const handlersRef = { current: handlers };
@@ -621,20 +994,39 @@ function read() {
   if (typeof window === "undefined" || typeof window.matchMedia !== "function") return false;
   return window.matchMedia(QUERY).matches;
 }
-function usePrefersReducedMotion() {
-  const reduced = vue.ref(read());
+function usePrefersReducedMotion(enabled) {
+  const reduced = vue.ref(enabled?.value === false ? false : read());
   let mq = null;
+  let mounted = false;
   const onChange = () => {
     if (mq) reduced.value = mq.matches;
   };
-  vue.onMounted(() => {
-    if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+  const start = () => {
+    if (!mounted || enabled?.value === false || mq !== null || typeof window === "undefined" || typeof window.matchMedia !== "function")
+      return;
     mq = window.matchMedia(QUERY);
     reduced.value = mq.matches;
     mq.addEventListener?.("change", onChange);
+  };
+  const stop = () => {
+    mq?.removeEventListener?.("change", onChange);
+    mq = null;
+    reduced.value = false;
+  };
+  vue.onMounted(() => {
+    mounted = true;
+    start();
   });
+  if (enabled) {
+    vue.watch(enabled, (active) => {
+      if (!mounted) return;
+      if (active) start();
+      else stop();
+    });
+  }
   vue.onBeforeUnmount(() => {
-    mq?.removeEventListener?.("change", onChange);
+    mounted = false;
+    stop();
   });
   return reduced;
 }
@@ -2879,7 +3271,7 @@ var IrisAdminTabs = vue.defineComponent({
             width: "16px",
             height: "16px",
             border: "none",
-            borderRadius: "4px",
+            borderRadius: "var(--iris-radius-sm, 4px)",
             background: "transparent",
             color: "inherit",
             cursor: "pointer",
@@ -7665,7 +8057,7 @@ function badgeStyle(variant, tone, size) {
     fontWeight: "500",
     lineHeight: "1",
     whiteSpace: "nowrap",
-    fontSize: size === "sm" ? "var(--iris-font-size-xs, 12px)" : "12px",
+    fontSize: "var(--iris-font-size-xs, 12px)",
     padding: size === "sm" ? "2px 6px" : "3px 8px"
   };
   switch (variant) {
@@ -7965,7 +8357,7 @@ var CSS5 = `
   border-radius: 50%;
 }
 [data-iris-skeleton-shape="text"] {
-  border-radius: 4px;
+  border-radius: var(--iris-radius-sm, 4px);
 }
 @media (prefers-reduced-motion: reduce) {
   [data-iris-skeleton][data-iris-skeleton-animated="true"] {
@@ -8022,8 +8414,8 @@ var IrisSkeleton = vue.defineComponent({
     vue.onMounted(installSkeletonStyles);
     const style = vue.computed(() => {
       const w = props.width !== void 0 ? toCss(props.width) : defaultWidth(props.shape);
-      const h137 = props.height !== void 0 ? toCss(props.height) : defaultHeight(props.shape, props.width);
-      return { width: w, height: h137 };
+      const h139 = props.height !== void 0 ? toCss(props.height) : defaultHeight(props.shape, props.width);
+      return { width: w, height: h139 };
     });
     return () => vue.h("div", {
       ...attrs,
@@ -8762,7 +9154,7 @@ var IrisCard = vue.defineComponent({
         flexDirection: "column",
         background: "var(--iris-background)",
         color: "var(--iris-foreground)",
-        borderRadius: "var(--iris-radius-md, 8px)",
+        borderRadius: "var(--iris-radius-md, 6px)",
         overflow: "hidden",
         transition: props.hover ? "transform 160ms ease, box-shadow 160ms ease" : "none"
       };
@@ -9868,7 +10260,7 @@ var IrisKbd = vue.defineComponent({
       background: "var(--iris-surface)",
       color: "var(--iris-foreground)",
       border: "1px solid var(--iris-border)",
-      borderRadius: "4px",
+      borderRadius: "var(--iris-radius-sm, 4px)",
       boxShadow: "0 1px 0 var(--iris-border)",
       lineHeight: "1",
       fontWeight: "500"
@@ -10604,6 +10996,13 @@ var tableProps = {
   tableTabs: { type: Array, default: void 0 },
   /** Show a draggable boundary for the leading left-pinned columns. */
   pinnedDrag: { type: Boolean, default: false },
+  /** Controlled per-column pin state; explicit null overrides a static column pin. */
+  pinnedColumns: {
+    type: Object,
+    default: void 0
+  },
+  /** Enable the built-in column-header pin menu; default off. */
+  columnPinMenu: { type: Boolean, default: false },
   /** Called for each column whose pin side changes. */
   onColumnPinnedChange: {
     type: Function,
@@ -10617,6 +11016,14 @@ var tableProps = {
   /** Below 480px, greedily hide the lowest-priority top-level columns until
    * the natural width fits; pinned columns survive. */
   responsive: { type: Boolean, default: false },
+  /**
+   * External row sets for `table!field` formula references. The first row of
+   * the named set is read; replace the object when referenced rows change.
+   */
+  formulaTables: {
+    type: Object,
+    default: void 0
+  },
   /** Extra bare row sets appended as named CSV segments by the imperative handle. */
   exportNames: {
     type: Array,
@@ -10635,6 +11042,8 @@ var tableProps = {
   error: { type: Boolean, default: false },
   /** Print-friendly mode: marks the root so toolbar/form chrome is hidden by print CSS. */
   printable: { type: Boolean, default: false },
+  /** Show a token-styled back-to-top button for the table's effective scroller. */
+  scrollToTop: { type: Boolean, default: false },
   /** Show a confirmation preview before the toolbar CSV import callback. */
   importPreview: { type: Boolean, default: false },
   onRetry: { type: Function, default: void 0 },
@@ -10643,6 +11052,16 @@ var tableProps = {
   cellRange: { type: Boolean, default: false },
   /** Range clipboard copy; copyWithFormat uses column formatter output. */
   clipConfig: { type: Object, default: void 0 },
+  /** Batch CK (iris 独有 — vxe has no inline search highlight): a
+   * case-insensitive literal-substring search over each text cell's display
+   * chain (mask → formatter ?? raw); every occurrence renders as an inline
+   * `<mark data-iris-search-hit>` with the surface-selected token. Display-only:
+   * no bar, no match state, no write-back. `render`/`html`/`link`/`autoLink`/
+   * sparkline cells are untouched. Additive; default off (fail-closed).
+   */
+  searchHighlight: { type: String, default: "" },
+  /** Enable built-in row-list undo/redo history; default off. */
+  undo: { type: Boolean, default: false },
   renderDetail: {
     type: Function,
     default: void 0
@@ -10694,6 +11113,13 @@ var tableProps = {
     type: Object,
     default: void 0
   },
+  /** Controlled top-level presentation order; omitted keys retain source order. */
+  columnOrder: {
+    type: Array,
+    default: void 0
+  },
+  /** Animate controlled column show/hide transitions; disabled by default. */
+  columnFade: { type: Boolean, default: false },
   filters: {
     type: Object,
     default: void 0
@@ -10702,6 +11128,8 @@ var tableProps = {
     type: Object,
     default: void 0
   },
+  /** Show recently confirmed non-empty filter sets in the filter panel; default off. */
+  recentFilters: { type: Boolean, default: false },
   onFilterValuesChange: {
     type: Function,
     default: void 0
@@ -10743,12 +11171,12 @@ var RESIZE_STEP = 16;
 function isEditableColumn(column) {
   return !!column.editable && !column.formula;
 }
-function getCellValue(row, column) {
-  if (column.formula) return core.memoizedFormulaValue(column.formula, row);
+function getCellValue(row, column, formulaTables) {
+  if (column.formula) return core.memoizedFormulaValue(column.formula, row, formulaTables);
   const key = column.dataIndex ?? column.key;
   return row[key];
 }
-function withComputedFormulaCells(rows, columns) {
+function withComputedFormulaCells(rows, columns, formulaTables) {
   const formulaCols = columns.filter((c) => c.formula);
   if (formulaCols.length === 0) return rows;
   return rows.map((row) => {
@@ -10756,7 +11184,11 @@ function withComputedFormulaCells(rows, columns) {
     for (const col of formulaCols) {
       const key = col.dataIndex ?? col.key;
       const next = shadow ?? { ...row };
-      next[key] = core.memoizedFormulaValue(col.formula, row);
+      next[key] = core.memoizedFormulaValue(
+        col.formula,
+        row,
+        formulaTables
+      );
       shadow = next;
     }
     return shadow;
@@ -10787,7 +11219,7 @@ function resolveInitialWidth(col) {
   }
   return DEFAULT_COL_WIDTH;
 }
-function computeVisibleColSet(enabled, columns, scrollLeft, viewportWidth, widths) {
+function computeVisibleColSet(enabled, columns, scrollLeft, viewportWidth, widths, pinOf) {
   if (!enabled) return null;
   const range = core.computeVirtualRange({
     itemCount: columns.length,
@@ -10799,7 +11231,7 @@ function computeVisibleColSet(enabled, columns, scrollLeft, viewportWidth, width
   const visible = /* @__PURE__ */ new Set();
   for (let index = range.startIndex; index <= range.endIndex; index += 1) visible.add(index);
   columns.forEach((column, index) => {
-    if (column.pinned) visible.add(index);
+    if (pinOf(column) !== null) visible.add(index);
   });
   return visible;
 }
@@ -10808,18 +11240,21 @@ function cellId(rowIdent, columnKey) {
 }
 
 // src/primitives/table/useTableSort.ts
-function buildSorter(col) {
+function buildSorter(col, formulaTables) {
   if (col.sorter) return col.sorter;
-  return (a, b) => core.compareValues(getCellValue(a, col), getCellValue(b, col));
+  return (a, b) => core.compareValues(getCellValue(a, col, formulaTables), getCellValue(b, col, formulaTables));
 }
-function buildMultiSortComparator(leafColumns, state) {
+function buildMultiSortComparator(leafColumns, state, formulaTables) {
   if (state.length === 0) return null;
   const colMap = new Map(leafColumns.map((c) => [c.key, c]));
   const chain = [];
   for (const s of state) {
     const col = colMap.get(s.key);
     if (!col) continue;
-    chain.push({ dir: s.direction === "asc" ? 1 : -1, sorter: buildSorter(col) });
+    chain.push({
+      dir: s.direction === "asc" ? 1 : -1,
+      sorter: buildSorter(col, formulaTables)
+    });
   }
   if (chain.length === 0) return null;
   return (a, b) => {
@@ -10830,93 +11265,6 @@ function buildMultiSortComparator(leafColumns, state) {
     return 0;
   };
 }
-function useTableSort(data, options) {
-  const sortProp = vue.computed(() => options.sort === void 0 ? void 0 : vue.toValue(options.sort));
-  const internalSortValue = vue.ref(options.defaultSort ?? null);
-  const sortState = vue.computed({
-    get: () => sortProp.value === void 0 ? internalSortValue.value : sortProp.value ?? null,
-    set: (val) => {
-      if (sortProp.value === void 0) internalSortValue.value = val;
-      options.onSortChange?.(val);
-    }
-  });
-  const multiEnabled = vue.computed(() => vue.toValue(options.multiSort) === true);
-  const multiSortProp = vue.computed(
-    () => options.multiSortState === void 0 ? void 0 : vue.toValue(options.multiSortState)
-  );
-  const internalMultiSort = vue.ref(options.defaultMultiSort ?? []);
-  const multiSortState = vue.computed({
-    get: () => multiSortProp.value === void 0 ? internalMultiSort.value : multiSortProp.value,
-    set: (val) => {
-      if (multiSortProp.value === void 0) internalMultiSort.value = val;
-      options.onMultiSortChange?.(val);
-    }
-  });
-  const sortComparator = vue.computed(() => {
-    const s = sortState.value;
-    if (!s) return null;
-    const col = vue.toValue(options.leafColumns).find((c) => c.key === s.key);
-    if (!col) return null;
-    const dir = s.direction === "asc" ? 1 : -1;
-    return (a, b) => buildSorter(col)(a, b) * dir;
-  });
-  const multiSortComparator = vue.computed(
-    () => buildMultiSortComparator(vue.toValue(options.leafColumns), multiSortState.value)
-  );
-  const sortedData = vue.computed(() => {
-    const comparator = multiEnabled.value ? multiSortComparator.value : sortComparator.value;
-    if (!comparator) return data.value;
-    return [...data.value].sort(comparator);
-  });
-  function setSort(next) {
-    if (sortProp.value === void 0) internalSortValue.value = next;
-    options.onSortChange?.(next);
-  }
-  function cycleSort(col) {
-    if (!col.sortable) return;
-    const s = sortState.value;
-    if (!s || s.key !== col.key) {
-      setSort({ key: col.key, direction: "asc" });
-      return;
-    }
-    if (s.direction === "asc") {
-      setSort({ key: col.key, direction: "desc" });
-      return;
-    }
-    setSort(null);
-  }
-  function setMultiSort(next) {
-    if (multiSortProp.value === void 0) internalMultiSort.value = next;
-    options.onMultiSortChange?.(next);
-  }
-  function cycleMultiSort(col) {
-    if (!col.sortable) return;
-    const idx = multiSortState.value.findIndex((s) => s.key === col.key);
-    if (idx < 0) {
-      setMultiSort([...multiSortState.value, { key: col.key, direction: "asc" }]);
-      return;
-    }
-    const next = [...multiSortState.value];
-    if (next[idx].direction === "asc") {
-      next[idx] = { key: col.key, direction: "desc" };
-      setMultiSort(next);
-      return;
-    }
-    next.splice(idx, 1);
-    setMultiSort(next);
-  }
-  return {
-    sortState,
-    cycleSort,
-    setSort,
-    sortComparator,
-    sortedData,
-    multiSortState,
-    cycleMultiSort,
-    setMultiSort,
-    multiSortComparator
-  };
-}
 function mergeFilterValues(filters, filterValues) {
   const next = { ...filters };
   for (const [key, values] of Object.entries(filterValues)) {
@@ -11033,6 +11381,37 @@ async function downloadCsv(filename, csv) {
     mimeType: "text/csv;charset=utf-8;"
   });
 }
+var undoButtonStyle = {
+  border: "none",
+  background: "transparent",
+  cursor: "pointer",
+  color: "var(--iris-muted)",
+  fontSize: "var(--iris-font-size-md, 14px)"
+};
+var undoButton = (dataAttr, labelKey, active, onActivate, t) => vue.h(
+  "button",
+  {
+    type: "button",
+    [dataAttr]: "",
+    onClick: onActivate,
+    disabled: !active,
+    "aria-label": t(labelKey),
+    title: t(labelKey),
+    style: { ...undoButtonStyle, cursor: active ? "pointer" : "default" }
+  },
+  dataAttr === "data-iris-table-undo" ? "\u21B6" : "\u21B7"
+);
+function renderUndoToolbar(ctx) {
+  if (!ctx.enabled) return [];
+  const canUndo = ctx.controller.canUndo.value;
+  const canRedo = ctx.controller.canRedo.value;
+  return [
+    undoButton("data-iris-table-undo", "table.undo", canUndo, ctx.controller.undo, ctx.t),
+    undoButton("data-iris-table-redo", "table.redo", canRedo, ctx.controller.redo, ctx.t)
+  ];
+}
+
+// src/primitives/table/table-sections.ts
 function renderFormSection(ctx) {
   const fc = ctx.formConfig;
   if (!fc) return null;
@@ -11123,13 +11502,14 @@ var toolbarBtnStyle = {
 };
 function renderToolbarSection(ctx) {
   const tb = ctx.toolbar;
-  if (!tb && !ctx.densityToggle && !ctx.auditLog) return null;
+  if (!tb && !ctx.densityToggle && !ctx.auditLog && !ctx.undo.enabled) return null;
   const toolChildren = [];
   if (tb?.title) {
     toolChildren.push(
       vue.h("span", { style: { fontWeight: 600, color: "var(--iris-foreground)" } }, tb.title)
     );
   }
+  toolChildren.push(...renderUndoToolbar(ctx.undo));
   toolChildren.push(vue.h("div", { style: { flex: "1" } }));
   if (tb?.onRefresh) {
     toolChildren.push(
@@ -11405,6 +11785,15 @@ function renderContextMenuSection(ctx) {
   );
   return vue.h(vue.Teleport, { to: "body" }, [node]);
 }
+function recentFilterLabel(entry, columns) {
+  const col = columns.find((column) => column.key === entry.key);
+  if (!col) return entry.values.join(", ");
+  const labels = entry.values.map((value) => {
+    const option = col.filterOptions?.find((item) => item.value === value);
+    return option ? option.label : value;
+  });
+  return `${col.title ?? entry.key}: ${labels.join(", ")}`;
+}
 function renderFilterPanelSection(ctx) {
   const st = ctx.state.value;
   if (!st || !st.open) return null;
@@ -11437,6 +11826,49 @@ function renderFilterPanelSection(ctx) {
       }
     },
     [
+      ...ctx.recent.length > 0 ? [
+        vue.h(
+          "div",
+          {
+            "data-iris-filter-recent-title": "",
+            style: {
+              color: "var(--iris-muted)",
+              fontSize: "var(--iris-font-size-xs, 11px)",
+              marginTop: "var(--iris-space-xxs, 4px)"
+            }
+          },
+          ctx.t("table.recentFilters")
+        ),
+        ...ctx.recent.map(
+          (entry, index) => vue.h(
+            "button",
+            {
+              key: `${entry.key}:${index}`,
+              type: "button",
+              "data-iris-filter-recent": index,
+              onClick: () => ctx.onApplyRecent(entry),
+              style: {
+                border: "none",
+                background: "transparent",
+                color: "var(--iris-foreground)",
+                cursor: "pointer",
+                font: "inherit",
+                fontSize: "var(--iris-font-size-sm, 13px)",
+                padding: "var(--iris-space-xxs, 4px) var(--iris-space-xs, 8px)",
+                borderRadius: "var(--iris-radius-sm, 4px)",
+                textAlign: "start"
+              }
+            },
+            recentFilterLabel(entry, ctx.columns)
+          )
+        ),
+        vue.h("div", {
+          style: {
+            borderTop: "1px solid var(--iris-border)",
+            margin: "var(--iris-space-xxs, 4px) 0"
+          }
+        })
+      ] : [],
       ...options.map(
         (opt) => vue.h(
           "div",
@@ -11920,6 +12352,7 @@ function renderTableSummaryRow(ctx) {
     if (ctx.visibleColSet && !ctx.visibleColSet.has(columnIndex)) continue;
     const align = column.align ?? "left";
     const operation = column.summary;
+    const fadeStyle = ctx.columnFadeStyle(column);
     const value = operation ? core.aggregate(ctx.bodyData, (row) => ctx.getCellValue(row, column), operation) : null;
     const content = operation != null && value != null ? column.renderSummary ? column.renderSummary(value, ctx.bodyData) : String(value) : "";
     summaryCells.push(
@@ -11930,7 +12363,10 @@ function renderTableSummaryRow(ctx) {
           role: "cell",
           "data-iris-table-cell": column.key,
           "data-iris-table-summary-cell": operation ? "" : void 0,
-          "data-iris-table-pinned": column.pinned,
+          "data-iris-table-pinned": ctx.pinOf(column),
+          "data-iris-column-fade": ctx.columnFadeAttr(column),
+          "aria-hidden": fadeStyle ? "true" : void 0,
+          inert: fadeStyle ? "" : void 0,
           style: {
             display: "flex",
             alignItems: "center",
@@ -11941,6 +12377,7 @@ function renderTableSummaryRow(ctx) {
             overflow: "hidden",
             textOverflow: "ellipsis",
             ...ctx.visibleColSet ? { gridColumnStart: String(ctx.colTrack(columnIndex)) } : {},
+            ...fadeStyle ?? {},
             ...ctx.pinnedStyle(column.key)
           }
         },
@@ -11964,6 +12401,187 @@ function renderTableSummaryRow(ctx) {
     summaryCells
   );
 }
+var FADE_DURATION_MS = 200;
+function createTableColumnFade(options) {
+  const fadeOverlay = vue.shallowRef({});
+  const previousVisibility = vue.ref({ ...options.visibility() });
+  let fadeFlipRaf = null;
+  let fadeCommitTimer = null;
+  let fadeFocusCandidate = null;
+  let disposed = false;
+  const topLevelColumn = (key) => options.columns.value.find((column) => column.key === key);
+  const fadeFlip = (current) => {
+    let changed = false;
+    const next = {};
+    for (const [key, entry] of Object.entries(current)) {
+      if (entry.phase === "pending") {
+        next[key] = { dir: entry.dir, phase: "run" };
+        changed = true;
+      } else {
+        next[key] = entry;
+      }
+    }
+    return changed ? next : void 0;
+  };
+  const fadeCommit = (current) => {
+    let changed = false;
+    const next = {};
+    const visibility = options.visibility();
+    for (const [key, entry] of Object.entries(current)) {
+      const visible = visibility[key] !== false;
+      const done = entry.dir === "out" ? !visible : visible;
+      if (done) changed = true;
+      else next[key] = entry;
+    }
+    return changed ? next : void 0;
+  };
+  const cancelFadeSchedule = () => {
+    fadeFocusCandidate = null;
+    if (fadeFlipRaf !== null) {
+      if (typeof globalThis.cancelAnimationFrame === "function") {
+        globalThis.cancelAnimationFrame(fadeFlipRaf);
+      }
+      fadeFlipRaf = null;
+    }
+    if (fadeCommitTimer !== null) {
+      clearTimeout(fadeCommitTimer);
+      fadeCommitTimer = null;
+    }
+  };
+  const recoverFocus = (candidate) => {
+    if (disposed || typeof document === "undefined" || typeof HTMLElement === "undefined" || !(candidate instanceof HTMLElement))
+      return;
+    const hidden = candidate.closest("[data-iris-column-fade][inert]");
+    if (!hidden) return;
+    const root = hidden.closest("[data-iris-table]");
+    const rowIndex = hidden.dataset.gridRow;
+    if (root && rowIndex !== void 0) {
+      const currentColumn = Number(hidden.dataset.gridCol);
+      const alternatives = Array.from(
+        root.querySelectorAll("[data-grid-row][data-grid-col]")
+      ).filter((cell) => cell.dataset.gridRow === rowIndex && !cell.hasAttribute("inert")).sort(
+        (a, b) => Math.abs(Number(a.dataset.gridCol) - currentColumn) - Math.abs(Number(b.dataset.gridCol) - currentColumn)
+      );
+      if (alternatives[0]) {
+        alternatives[0].focus();
+        return;
+      }
+    }
+    if (document.activeElement === candidate || hidden.contains(document.activeElement)) {
+      candidate.blur();
+    }
+  };
+  vue.watch(
+    [options.visibility, options.enabled, options.reducedMotion],
+    ([visibility, fadeEnabled, motion]) => {
+      const next = visibility;
+      const previous = previousVisibility.value;
+      previousVisibility.value = { ...next };
+      if (!fadeEnabled || motion) {
+        cancelFadeSchedule();
+        fadeOverlay.value = {};
+        return;
+      }
+      const overlay = { ...fadeOverlay.value };
+      const activeElement = typeof document !== "undefined" ? document.activeElement : null;
+      const changedKeys = /* @__PURE__ */ new Set();
+      for (const key of /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(next)])) {
+        if (!topLevelColumn(key)) continue;
+        const wasVisible = previous[key] !== false;
+        const isVisible = next[key] !== false;
+        if (wasVisible === isVisible) continue;
+        overlay[key] = { dir: isVisible ? "in" : "out", phase: "pending" };
+        changedKeys.add(key);
+      }
+      if (changedKeys.size === 0) return;
+      fadeOverlay.value = overlay;
+      fadeFocusCandidate = activeElement;
+      if (typeof window === "undefined" || typeof window.requestAnimationFrame !== "function") {
+        cancelFadeSchedule();
+        fadeOverlay.value = {};
+        return;
+      }
+      if (fadeFlipRaf === null) {
+        fadeFlipRaf = window.requestAnimationFrame(() => {
+          if (disposed) return;
+          fadeFlipRaf = null;
+          fadeFlipRaf = window.requestAnimationFrame(() => {
+            if (disposed) return;
+            fadeFlipRaf = null;
+            const candidate = fadeFocusCandidate;
+            fadeOverlay.value = fadeFlip(fadeOverlay.value) ?? fadeOverlay.value;
+            void vue.nextTick(() => recoverFocus(candidate));
+          });
+        });
+      }
+      if (fadeCommitTimer !== null) clearTimeout(fadeCommitTimer);
+      fadeCommitTimer = setTimeout(() => {
+        if (disposed) return;
+        fadeCommitTimer = null;
+        fadeOverlay.value = fadeCommit(fadeOverlay.value) ?? fadeOverlay.value;
+      }, FADE_DURATION_MS);
+    }
+  );
+  vue.onBeforeUnmount(() => {
+    disposed = true;
+    cancelFadeSchedule();
+  });
+  const effectiveVisibility = vue.computed(() => {
+    if (Object.keys(fadeOverlay.value).length === 0) return options.visibility();
+    const merged = { ...options.visibility() };
+    for (const key of Object.keys(fadeOverlay.value)) merged[key] = true;
+    return merged;
+  });
+  const displayColumns = vue.computed(() => {
+    const visibility = effectiveVisibility.value;
+    if (Object.keys(visibility).length === 0) return options.columns.value;
+    return options.columns.value.filter((column) => visibility[column.key] !== false);
+  });
+  const fadeByLeaf = vue.computed(() => {
+    if (Object.keys(fadeOverlay.value).length === 0) return {};
+    const out = {};
+    for (const [key, entry] of Object.entries(fadeOverlay.value)) {
+      const top = topLevelColumn(key);
+      if (!top) continue;
+      const leaves = top.children && top.children.length > 0 ? core.flattenLeafColumns([top]) : [top];
+      for (const leaf of leaves) out[leaf.key] = entry;
+    }
+    return out;
+  });
+  const columnFadeAttr = (column) => (fadeOverlay.value[column.key] ?? fadeByLeaf.value[column.key])?.dir;
+  const columnFadeStyle = (column) => {
+    const entry = fadeOverlay.value[column.key] ?? fadeByLeaf.value[column.key];
+    if (!entry) return null;
+    const hidden = entry.dir === "out" ? entry.phase === "run" : entry.phase === "pending";
+    return hidden ? { opacity: "0" } : null;
+  };
+  const columnFadeAttrs = (column) => {
+    const hidden = columnFadeStyle(column) !== null;
+    return {
+      "data-iris-column-fade": columnFadeAttr(column),
+      "aria-hidden": hidden ? "true" : void 0,
+      inert: hidden ? "" : void 0
+    };
+  };
+  const columnFadeActive = vue.computed(
+    () => options.enabled() === true && Object.keys(fadeByLeaf.value).length > 0
+  );
+  const isCollapsed = (key) => {
+    const entry = fadeByLeaf.value[key];
+    return Boolean(
+      entry && (entry.dir === "out" && entry.phase === "run" || entry.dir === "in" && entry.phase === "pending")
+    );
+  };
+  return {
+    displayColumns,
+    fadeByLeaf,
+    columnFadeAttr,
+    columnFadeStyle,
+    columnFadeAttrs,
+    columnFadeActive,
+    isCollapsed
+  };
+}
 function renderTableStateRow(ctx) {
   if (ctx.error) {
     return vue.h("div", { role: "row", "data-iris-table-row": "error", style: ctx.stateRowStyle }, [
@@ -12073,24 +12691,25 @@ function createTableKeyboard(options) {
     const range = activeCellRange();
     const clip = options.clipConfig();
     if (!range || clip?.copy === false) return;
-    const rows = withComputedFormulaCells(options.rows(), options.columns());
-    void core.writeClipboardText(
-      core.serializeTableRange(
-        rows,
-        options.columns(),
-        range,
-        clip?.copyFormat,
-        clip?.copyWithFormat === true
-      )
-    );
+    const text = options.serializeRange(clip?.copyFormat, clip?.copyWithFormat === true);
+    if (text !== null) void core.writeClipboardText(text);
   };
   const handleClipboardKey = (event) => {
     const clip = options.clipConfig();
     if (!options.cellRange() || !clip || event.defaultPrevented) return;
-    if (event.key.toLowerCase() !== "c" || !event.ctrlKey && !event.metaKey) return;
-    if (clip.copy === false || !activeCellRange()) return;
-    event.preventDefault();
-    copyActiveRange();
+    if (!event.ctrlKey && !event.metaKey) return;
+    const key = event.key.toLowerCase();
+    const range = activeCellRange();
+    if (!range) return;
+    if (key === "c") {
+      if (clip.copy === false) return;
+      event.preventDefault();
+      copyActiveRange();
+    } else if (key === "v") {
+      if (clip.paste === false) return;
+      event.preventDefault();
+      options.pasteRange(range);
+    }
   };
   return {
     handleRootKeyDown: (event) => {
@@ -12103,11 +12722,11 @@ function createTableKeyboard(options) {
     copyActiveRange
   };
 }
-function computeResponsiveTableColumns(columns, containerWidth, leadingWidth, widthOf) {
+function computeResponsiveTableColumns(columns, containerWidth, leadingWidth, widthOf, pinOf) {
   if (containerWidth <= 0 || containerWidth >= core.RESPONSIVE_NARROW_WIDTH) {
     return { columns, overflow: false };
   }
-  const isPinned = (column) => column.children && column.children.length > 0 ? column.children.some(isPinned) : column.pinned !== void 0;
+  const isPinned = (column) => column.children && column.children.length > 0 ? column.children.some(isPinned) : pinOf(column) !== null;
   const fitted = core.computeResponsiveColumns(columns, Math.max(1, containerWidth - leadingWidth), {
     widthOf: (column) => widthOf(column),
     isPinned: (column) => isPinned(column),
@@ -12122,6 +12741,7 @@ function computeResponsiveTableColumns(columns, containerWidth, leadingWidth, wi
 
 // src/primitives/table/table-styles.ts
 var TABLE_STYLE_ID = "iris-table-row-styles";
+var TABLE_FADE_STYLE_ID = "iris-table-column-fade-styles-vue";
 var TABLE_STYLES = `
 [data-iris-table] [role="row"]:hover {
   --iris-cell-bg: var(--iris-surface-hover);
@@ -12143,15 +12763,52 @@ var TABLE_STYLES = `
   background: color-mix(in srgb, var(--iris-primary) 18%, var(--iris-background));
 }
 `;
-function ensureTableStyles() {
-  if (typeof document === "undefined" || document.getElementById(TABLE_STYLE_ID)) return;
-  const style = document.createElement("style");
-  style.id = TABLE_STYLE_ID;
-  style.textContent = TABLE_STYLES;
-  document.head.appendChild(style);
+var TABLE_FADE_STYLES = `
+[data-iris-column-fade-active] [data-iris-column-fade] {
+  transition: opacity var(--iris-duration-md, 200ms) ease;
+}
+[data-iris-column-fade-active] [role="row"],
+[data-iris-column-fade-active][role="row"] {
+  transition: grid-template-columns var(--iris-duration-md, 200ms) ease;
+}
+@media (prefers-reduced-motion: reduce) {
+  [data-iris-column-fade-active] [data-iris-column-fade],
+  [data-iris-column-fade-active][data-iris-column-fade],
+  [data-iris-column-fade-active] [role="row"],
+  [data-iris-column-fade-active][role="row"] {
+    transition: none !important;
+  }
+}
+`;
+function ensureTableStyles(includeFade = false) {
+  if (typeof document === "undefined") return;
+  if (!document.getElementById(TABLE_STYLE_ID)) {
+    const style = document.createElement("style");
+    style.id = TABLE_STYLE_ID;
+    style.textContent = TABLE_STYLES;
+    document.head.appendChild(style);
+  }
+  if (!includeFade) return;
+  if (!document.getElementById(TABLE_FADE_STYLE_ID)) {
+    const style = document.createElement("style");
+    style.id = TABLE_FADE_STYLE_ID;
+    style.textContent = TABLE_FADE_STYLES;
+    document.head.appendChild(style);
+  }
 }
 
 // src/primitives/table/table-columns.ts
+function applyTableColumnOrder(columns, order) {
+  if (!order || order.length === 0) return columns;
+  const orderIndex = /* @__PURE__ */ new Map();
+  order.forEach((key, index) => {
+    if (!orderIndex.has(key)) orderIndex.set(key, index);
+  });
+  const ordered = columns.filter((column) => orderIndex.has(column.key));
+  const rest = columns.filter((column) => !orderIndex.has(column.key));
+  ordered.sort((left, right) => orderIndex.get(left.key) - orderIndex.get(right.key));
+  return [...ordered, ...rest];
+}
 function applyDetectedTableTypes(columns, detectedTypes) {
   const apply = (column) => {
     const kind = detectedTypes[column.key];
@@ -12249,16 +12906,24 @@ function createTableRowTarget(root) {
   };
   return { find, scrollTo, goTo, dispose };
 }
-function createTablePinnedDrag(options) {
+function leftPinnedCount(columns, pinOf, cap) {
+  let count = 0;
+  for (let index = 0; index < cap; index += 1) {
+    if (pinOf(columns[index]) === "left") count = index + 1;
+    else break;
+  }
+  return count;
+}
+function createTablePinnedDrag(options) {
   const firstRightPinnedIndex = vue.computed(() => {
-    const index = options.columns().findIndex((column) => column.pinned === "right");
+    const index = options.columns().findIndex((column) => options.pinOf(column) === "right");
     return index < 0 ? options.columns().length : index;
   });
   const pinnedBoundaryColumn = vue.computed(() => {
     if (!options.enabled()) return null;
     for (let index = firstRightPinnedIndex.value - 1; index >= 0; index -= 1) {
       const column = options.columns()[index];
-      if (column?.pinned === "left") return column;
+      if (column && options.pinOf(column) === "left") return column;
     }
     return null;
   });
@@ -12277,7 +12942,7 @@ function createTablePinnedDrag(options) {
   const resolvePinnedCount = (dx) => {
     const columns = options.columns();
     const cap = firstRightPinnedIndex.value;
-    const current = core.leftPinnedCount(columns, cap);
+    const current = leftPinnedCount(columns, options.pinOf, cap);
     let currentWidth = 0;
     for (let index = 0; index < current; index += 1) {
       const column = columns[index];
@@ -12295,14 +12960,14 @@ function createTablePinnedDrag(options) {
     const columns = options.columns();
     const cap = firstRightPinnedIndex.value;
     const clamped = Math.max(0, Math.min(cap, count));
-    const current = core.leftPinnedCount(columns, cap);
+    const current = leftPinnedCount(columns, options.pinOf, cap);
     if (clamped === current) return;
     for (let index = 0; index < cap; index += 1) {
       const column = columns[index];
       if (!column) continue;
       const target = index < clamped ? "left" : null;
-      if (column.pinned === target) continue;
-      options.onColumnPinnedChange?.(column.key, target);
+      if (options.pinOf(column) === target) continue;
+      options.setPinned(column.key, target);
     }
     options.onPinnedCountChange?.(clamped);
   };
@@ -12382,6 +13047,218 @@ function createTablePinnedDrag(options) {
     );
   };
 }
+function isInsideTableRoot(root, target) {
+  return target !== null && typeof target === "object" && "nodeType" in target && root() !== null && root().contains(target);
+}
+function isTextControl(target) {
+  if (!target || typeof target !== "object") return false;
+  const element = target;
+  return element.tagName === "INPUT" || element.tagName === "TEXTAREA" || element.tagName === "SELECT" || element.dataset?.irisTableEditor !== void 0;
+}
+function registerScopedKeydownListener(gate, handler) {
+  let listening = false;
+  let stopGateWatch = null;
+  const syncListener = () => {
+    if (typeof window === "undefined") return;
+    if (gate() && !listening) {
+      window.addEventListener("keydown", handler);
+      listening = true;
+    } else if (!gate() && listening) {
+      window.removeEventListener("keydown", handler);
+      listening = false;
+    }
+  };
+  vue.onMounted(() => {
+    syncListener();
+    stopGateWatch = vue.watch(gate, syncListener);
+  });
+  vue.onBeforeUnmount(() => {
+    stopGateWatch?.();
+    stopGateWatch = null;
+    if (listening && typeof window !== "undefined") {
+      window.removeEventListener("keydown", handler);
+      listening = false;
+    }
+  });
+}
+
+// src/primitives/table/table-undo.ts
+function createCommittedList(source) {
+  let current = source();
+  return {
+    list: () => {
+      const latest = source();
+      if (latest !== current) current = latest;
+      return current;
+    },
+    sync: (next) => {
+      current = next;
+    }
+  };
+}
+function replaceTableCell(rows, key, columnKey, value, rowKeyOf) {
+  const index = rows.findIndex((candidate, i) => rowKeyOf(candidate, i) === key);
+  if (index < 0) return rows;
+  const next = rows.slice();
+  next[index] = { ...next[index], [columnKey]: value };
+  return next;
+}
+function sameRowList(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function rebaselineOnExternalChange(ctx, stack, bump) {
+  let lastExternalRows = ctx.sourceRows();
+  vue.watch(ctx.sourceRows, (next) => {
+    if (next === lastExternalRows) return;
+    lastExternalRows = next;
+    if (ctx.enabled() && !stack.canUndo() && !stack.canRedo()) {
+      stack.clear();
+      stack.push([...next ?? []]);
+      bump();
+    }
+  });
+}
+function replayStep(ctx, commit, setRestoring) {
+  return (rows, type) => {
+    if (rows === void 0) return;
+    const before = ctx.selection.current();
+    if (ctx.selection.enabled() && before.length > 0) {
+      const keys = /* @__PURE__ */ new Set();
+      rows.forEach((row, index) => keys.add(ctx.selection.keyOf(row, index)));
+      const vanished = before.filter((key) => !keys.has(key));
+      if (vanished.length > 0) {
+        ctx.selection.rebase();
+        ctx.selection.set(before.filter((key) => !vanished.includes(key)));
+      }
+    }
+    setRestoring(true);
+    try {
+      commit(rows, type);
+    } finally {
+      setRestoring(false);
+    }
+  };
+}
+function undoKeydownBindings(ctx, onUndo, onRedo) {
+  const bindings = core.normalizeKeymap();
+  return (event) => {
+    if (!ctx.enabled() || event.defaultPrevented) return;
+    if (!isInsideTableRoot(ctx.root, event.target)) return;
+    if (isTextControl(event.target) || ctx.isEditing()) return;
+    if (core.matchTableKey(event, bindings.undo)) {
+      event.preventDefault();
+      onUndo();
+    } else if (core.matchTableKey(event, bindings.redo)) {
+      event.preventDefault();
+      onRedo();
+    }
+  };
+}
+function createTableUndoRuntime(ctx) {
+  const stack = core.createUndoStack({
+    maxHistory: 100,
+    initial: [...ctx.initialRows() ?? []],
+    equals: sameRowList
+  });
+  const tick = vue.ref(0);
+  let restoring = false;
+  const bump = () => {
+    tick.value += 1;
+  };
+  const record = (rows) => {
+    if (!ctx.enabled() || restoring) return;
+    stack.push([...rows ?? []]);
+    bump();
+  };
+  const commit = (rows, type = "edit") => {
+    record(rows);
+    ctx.recordAudit(rows, type);
+    ctx.setRows(rows);
+    ctx.onDataChange(rows);
+  };
+  return {
+    stack,
+    bump,
+    readTick: () => void tick.value,
+    record,
+    commit,
+    setRestoring: (value) => restoring = value
+  };
+}
+function createUndoRedoActions(stack, bump, replay) {
+  const undo = () => {
+    const rows = stack.undo();
+    if (rows !== void 0) {
+      bump();
+      replay(rows, "undo");
+    }
+  };
+  const redo = () => {
+    const rows = stack.redo();
+    if (rows !== void 0) {
+      bump();
+      replay(rows, "redo");
+    }
+  };
+  return { undo, redo };
+}
+function createTableUndoController(enabled, initialRows, sourceRows, setRows, recordAudit, onDataChange, root, isEditing, selection) {
+  const ctx = {
+    enabled,
+    initialRows,
+    sourceRows,
+    setRows,
+    recordAudit,
+    onDataChange,
+    root,
+    isEditing,
+    selection
+  };
+  const runtime = createTableUndoRuntime(ctx);
+  const { stack, bump, record, commit } = runtime;
+  const canUndo = vue.computed(() => {
+    runtime.readTick();
+    return stack.canUndo();
+  });
+  const canRedo = vue.computed(() => {
+    runtime.readTick();
+    return stack.canRedo();
+  });
+  rebaselineOnExternalChange(ctx, stack, bump);
+  const replay = replayStep(ctx, commit, runtime.setRestoring);
+  const { undo, redo } = createUndoRedoActions(stack, bump, replay);
+  const handleKeydown = undoKeydownBindings(ctx, undo, redo);
+  registerScopedKeydownListener(() => ctx.enabled(), handleKeydown);
+  return { stack, canUndo, canRedo, record, commit, undo, redo, handleKeydown };
+}
+var SEARCH_HIT_STYLE = {
+  background: "var(--iris-surface-selected, rgba(99,102,241,0.12))",
+  color: "inherit",
+  borderRadius: "var(--iris-radius-sm, 4px)",
+  padding: "0 var(--iris-space-xxs, 4px)"
+};
+function applySearchHighlight(node, query) {
+  if (!query || typeof node !== "string") return node;
+  const text = String(node);
+  const segments = core.splitSearchHits(text, query);
+  if (!segments) return node;
+  return segments.map(
+    (segment, index) => index % 2 === 1 ? vue.h(
+      "mark",
+      {
+        key: index,
+        "data-iris-search-hit": "",
+        style: SEARCH_HIT_STYLE
+      },
+      segment
+    ) : segment
+  );
+}
 function useTableImport(isPreviewEnabled, getOnImport) {
   const importFileInput = vue.ref(null);
   const importPreviewRows = vue.ref(null);
@@ -12511,7 +13388,7 @@ function renderCellEditContent(ctx, row, col, index, editCellId) {
     "aria-invalid": error ? "true" : void 0,
     "aria-describedby": error ? `${editCellId}-error` : void 0,
     onInput: (e) => {
-      ctx.editingDraft.value = e.target.value;
+      ctx.setEditingDraft(e.target.value);
     },
     onKeydown: (e) => {
       if (e.key === "Enter") {
@@ -12619,6 +13496,7 @@ function renderGroupedHeader(ctx, matrix) {
       const isLeaf = !col.children || col.children.length === 0;
       const sortable = isLeaf && col.sortable;
       const align = col.align ?? "left";
+      const fadeStyle = ctx.columnFadeStyle(col);
       const headerSlot = ctx.slots[`header.${col.key}`];
       const title = headerSlot?.({ column: col }) ?? col.title;
       cells.push(
@@ -12629,8 +13507,13 @@ function renderGroupedHeader(ctx, matrix) {
             role: "columnheader",
             "data-iris-table-header": col.key,
             "data-iris-table-header-group": isLeaf ? void 0 : "",
+            "data-iris-table-pinned": isLeaf && (ctx.pinnedColumnsControlled || ctx.columnPinMenu) ? ctx.pinOf(col) : void 0,
+            "data-iris-column-fade": ctx.columnFadeAttr(col),
+            "aria-hidden": fadeStyle ? "true" : void 0,
+            inert: fadeStyle ? "" : void 0,
             "aria-colspan": cell.colSpan,
             onClick: sortable ? () => ctx.onHeaderClick(col) : void 0,
+            ...isLeaf && ctx.onHeaderContextMenu ? { onContextmenu: (event) => ctx.onHeaderContextMenu(event, col) } : {},
             "aria-sort": sortable ? ctx.ariaSortFor(col) : void 0,
             style: {
               gridColumn: `${lead + cell.colStart} / span ${cell.colSpan}`,
@@ -12648,7 +13531,9 @@ function renderGroupedHeader(ctx, matrix) {
               color: "var(--iris-foreground)",
               whiteSpace: "nowrap",
               overflow: "hidden",
-              textOverflow: "ellipsis"
+              textOverflow: "ellipsis",
+              ...fadeStyle ?? {},
+              ...isLeaf && (ctx.pinnedColumnsControlled || ctx.columnPinMenu) && ctx.pinOf(col) !== null ? { ...ctx.pinnedStyle(col.key), background: "var(--iris-surface)" } : {}
             }
           },
           [
@@ -12896,6 +13781,47 @@ function renderTableTabs(tabs, activeTab, onApply) {
 }
 
 // src/primitives/table/Table.ts
+var SCROLL_TOP_VISIBLE_PX = 200;
+var PIN_LEFT_MENU_KEY = "__iris-pin-left";
+var UNPIN_MENU_KEY = "__iris-unpin";
+var BACK_TOP_ANCHOR_STYLE = {
+  position: "sticky",
+  insetBlockEnd: "0px",
+  height: "0px",
+  pointerEvents: "none",
+  zIndex: "3"
+};
+var BACK_TOP_BUTTON_STYLE = {
+  position: "absolute",
+  insetBlockEnd: "24px",
+  insetInlineEnd: "24px",
+  width: "40px",
+  height: "40px",
+  borderRadius: "50%",
+  border: "1px solid var(--iris-border)",
+  background: "var(--iris-surface, var(--iris-background))",
+  color: "var(--iris-foreground)",
+  cursor: "pointer",
+  boxShadow: "var(--iris-shadow-md)",
+  display: "inline-flex",
+  alignItems: "center",
+  justifyContent: "center",
+  fontSize: "var(--iris-font-size-xl, 18px)",
+  pointerEvents: "auto"
+};
+async function readClipboardText() {
+  if (typeof navigator === "undefined") return null;
+  const nav = navigator;
+  if (!nav.clipboard?.readText) return null;
+  try {
+    return await nav.clipboard.readText();
+  } catch {
+    return null;
+  }
+}
+function prefersReducedMotion() {
+  return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
 var IrisTable = vue.defineComponent({
   name: "IrisTable",
   inheritAttrs: false,
@@ -12908,13 +13834,22 @@ var IrisTable = vue.defineComponent({
     "update:columnWidths": (_value) => true,
     /** Controlled columnVisibility channel (parent owns the map). */
     "update:columnVisibility": (_value) => true,
+    /** Controlled top-level column-order proposal channel. */
+    "update:columnOrder": (_value) => true,
     rowClick: (_row, _index) => true,
     rowDblclick: (_row, _index) => true,
     cellEdit: (_payload) => true,
     expandedRowsChange: (_keys) => true
   },
   setup(props, { slots, attrs, emit, expose }) {
-    ensureTableStyles();
+    ensureTableStyles(props.columnFade);
+    vue.watch(
+      () => props.columnFade,
+      (enabled) => {
+        if (enabled) ensureTableStyles(true);
+      }
+    );
+    const getCellValue2 = (row, column) => getCellValue(row, column, props.formulaTables);
     const { t } = useI18n();
     const densityState = vue.ref("comfortable");
     const effectiveDensity = vue.computed(() => {
@@ -12928,17 +13863,102 @@ var IrisTable = vue.defineComponent({
       () => props.importPreview,
       () => props.toolbar?.onImport
     );
-    const responsiveWidth = vue.ref(0);
-    const internalWidths = vue.ref({});
-    const effectiveWidths = vue.computed(() => {
-      if (props.columnWidths) return props.columnWidths;
-      return internalWidths.value;
+    const gridCore = useGridCore();
+    const columnsFeature = useGridColumns(gridCore, {
+      pinned: props.pinnedColumns,
+      onVisibilityChange: (next) => emit("update:columnVisibility", next),
+      onOrderChange: (next) => emit("update:columnOrder", next),
+      onWidthsChange: (next) => emit("update:columnWidths", next),
+      onPinnedChange: (key, side) => props.onColumnPinnedChange?.(key, side)
     });
-    const sourceDisplayColumns = vue.computed(() => {
-      const vis = props.columnVisibility;
-      if (!vis) return props.columns;
-      return props.columns.filter((c) => vis[c.key] !== false);
+    const pinnedPropControlled = vue.ref(props.pinnedColumns !== void 0);
+    const pinOf = (column) => {
+      const pinned = props.pinnedColumns;
+      if (pinned !== void 0) {
+        if (Object.prototype.hasOwnProperty.call(pinned, column.key)) {
+          return pinned[column.key] ?? null;
+        }
+        return column.pinned ?? null;
+      }
+      const internal = columnsFeature.state.value.pinned;
+      if (Object.prototype.hasOwnProperty.call(internal, column.key)) {
+        return internal[column.key] ?? null;
+      }
+      return column.pinned ?? null;
+    };
+    vue.watch(
+      () => props.pinnedColumns,
+      (next) => {
+        if (next !== void 0) {
+          pinnedPropControlled.value = true;
+          columnsFeature.model.syncPinned(next);
+        } else {
+          if (pinnedPropControlled.value) columnsFeature.model.syncPinned({});
+          pinnedPropControlled.value = false;
+        }
+      },
+      { immediate: true, flush: "sync" }
+    );
+    const orderPropControlled = vue.ref(props.columnOrder !== void 0);
+    vue.watch(
+      () => props.columnOrder,
+      (next) => {
+        if (next !== void 0) {
+          orderPropControlled.value = true;
+          columnsFeature.model.syncOrder(next);
+        } else {
+          if (orderPropControlled.value) columnsFeature.model.syncOrder([]);
+          orderPropControlled.value = false;
+        }
+      },
+      { immediate: true, flush: "sync" }
+    );
+    const effectiveColumnOrder = vue.computed(
+      () => orderPropControlled.value ? props.columnOrder ?? [] : columnsFeature.state.value.order
+    );
+    const uncontrolledWidths = vue.ref({});
+    const widthPropControlled = vue.ref(props.columnWidths !== void 0);
+    vue.watch(
+      () => props.columnVisibility,
+      (next) => columnsFeature.model.syncVisibility(next ?? {}),
+      { immediate: true }
+    );
+    vue.watch(
+      () => props.columnWidths,
+      (next) => {
+        if (next !== void 0) {
+          columnsFeature.model.syncWidths(next);
+        } else if (widthPropControlled.value) {
+          columnsFeature.model.syncWidths(uncontrolledWidths.value);
+        }
+        widthPropControlled.value = next !== void 0;
+      },
+      { immediate: true }
+    );
+    const responsiveWidth = vue.ref(0);
+    const effectiveWidths = vue.computed(
+      () => props.columnWidths !== void 0 ? props.columnWidths : columnsFeature.state.value.widths
+    );
+    const effectiveVisibility = vue.computed(
+      () => columnsFeature.state.value.visibility
+    );
+    const columnFadeEnabled = vue.computed(() => props.columnFade);
+    const reducedMotion = usePrefersReducedMotion(columnFadeEnabled);
+    const columnFade = createTableColumnFade({
+      visibility: () => effectiveVisibility.value,
+      enabled: () => columnFadeEnabled.value,
+      reducedMotion,
+      columns: vue.computed(() => props.columns)
     });
+    const {
+      displayColumns: sourceDisplayColumns,
+      columnFadeAttr,
+      columnFadeStyle,
+      columnFadeAttrs,
+      columnFadeActive,
+      fadeByLeaf,
+      isCollapsed: isColumnFadeCollapsed
+    } = columnFade;
     const detectedTypes = vue.ref({});
     const detectTypesDone = vue.ref(false);
     const detectedDisplayColumns = vue.computed(() => {
@@ -12954,13 +13974,17 @@ var IrisTable = vue.defineComponent({
       const width = effectiveWidths.value[column.key] ?? resolveInitialWidth(column);
       return Number.isFinite(width) && width >= 0 ? width : resolveInitialWidth(column);
     };
+    const orderedDisplayColumns = vue.computed(
+      () => applyTableColumnOrder(detectedDisplayColumns.value, effectiveColumnOrder.value)
+    );
     const responsiveResult = vue.computed(
       () => props.responsive ? computeResponsiveTableColumns(
-        detectedDisplayColumns.value,
+        orderedDisplayColumns.value,
         responsiveWidth.value,
         responsiveLeadingWidth.value,
-        responsiveWidthOf
-      ) : { columns: detectedDisplayColumns.value, overflow: false }
+        responsiveWidthOf,
+        pinOf
+      ) : { columns: orderedDisplayColumns.value, overflow: false }
     );
     const responsiveDisplayColumns = vue.computed(
       () => responsiveResult.value.columns
@@ -13013,6 +14037,7 @@ var IrisTable = vue.defineComponent({
     const tableData = vue.computed(
       () => proxyCtrl.proxy.value ? proxyCtrl.liveData.value : localRowsOverride.value ?? props.data ?? []
     );
+    const committedList = createCommittedList(() => tableData.value);
     vue.watch(
       [() => props.autoDetectTypes, tableData, () => props.columns],
       () => {
@@ -13022,38 +14047,76 @@ var IrisTable = vue.defineComponent({
         for (const column of core.flattenLeafColumns(props.columns)) {
           if (column.formula) continue;
           next[column.key] = core.detectColumnType(
-            tableData.value.map((row) => getCellValue(row, column))
+            tableData.value.map((row) => getCellValue2(row, column))
           );
         }
         detectedTypes.value = next;
       },
       { immediate: true }
     );
-    const {
-      sortState: internalSort,
-      cycleSort,
-      setSort,
-      sortComparator,
-      sortedData: sortedRows,
-      multiSortState,
-      cycleMultiSort
-    } = useTableSort(tableData, {
-      leafColumns,
-      sort: vue.computed(() => props.sort),
+    let recordUndoRows = null;
+    let suppressUndoRecord = false;
+    const readRowChildren = (row) => {
+      if (props.lazyLoad !== void 0) {
+        const children = row.children;
+        if (Array.isArray(children)) return children;
+      }
+      return props.getSubRows?.(row);
+    };
+    const writeLazyChildren = props.lazyLoad === void 0 ? void 0 : (row, children) => ({
+      ...row,
+      children
+    });
+    const sorting = useGridSorting(gridCore, {
+      mode: props.multiSort ? "multiple" : "single",
       defaultSort: props.defaultSort,
+      defaultMultiSort: props.defaultMultiSort,
       onSortChange: (next) => {
         emit("update:sort", next);
         if (remoteSort.value) proxyCtrl.setParams({ sort: next });
       },
-      multiSort: () => props.multiSort,
-      multiSortState: () => props.multiSortState,
-      defaultMultiSort: props.defaultMultiSort,
       onMultiSortChange: (next) => {
         emit("update:multiSortState", next);
         emit("multiSortChange", next);
         if (remoteSort.value) proxyCtrl.setParams({ sorts: next });
       }
     });
+    vue.watch(
+      () => props.sort,
+      (next) => next !== void 0 && sorting.model.syncSort(next ?? null),
+      { immediate: true }
+    );
+    vue.watch(
+      () => props.multiSortState,
+      (next) => next !== void 0 && sorting.model.syncMultiSort(next ?? []),
+      { immediate: true }
+    );
+    const internalSort = vue.computed(
+      () => props.sort !== void 0 ? props.sort ?? null : sorting.sort.value
+    );
+    const multiSortState = vue.computed(
+      () => props.multiSortState !== void 0 ? props.multiSortState : sorting.multiSort.value
+    );
+    const setSort = (next) => sorting.model.setSort(next);
+    const cycleSort = (column) => {
+      if (column.sortable) sorting.model.cycleSort(column.key);
+    };
+    const cycleMultiSort = (column) => {
+      if (column.sortable) sorting.model.cycleMultiSort(column.key);
+    };
+    const sortComparator = vue.computed(
+      () => buildMultiSortComparator(
+        leafColumns.value,
+        internalSort.value ? [internalSort.value] : [],
+        props.formulaTables
+      )
+    );
+    const multiSortComparator = vue.computed(() => buildMultiSortComparator(leafColumns.value, multiSortState.value, props.formulaTables));
+    const sortedRows = vue.computed(() => {
+      if (remoteSort.value) return tableData.value;
+      const compare = props.multiSort ? multiSortComparator.value : sortComparator.value;
+      return compare ? [...tableData.value].sort(compare) : tableData.value;
+    });
     const tableViews = createTableViewsController({
       config: () => props.views,
       sort: internalSort,
@@ -13061,6 +14124,34 @@ var IrisTable = vue.defineComponent({
       onActiveViewChange: (key) => props.onActiveViewChange?.(key)
     });
     const sortedData = vue.computed(() => remoteSort.value ? tableData.value : sortedRows.value);
+    const filtering = useGridFiltering(gridCore, {
+      defaultFilters: props.filters,
+      defaultFilterValues: props.filterValues,
+      onFilterValuesChange: (next) => props.onFilterValuesChange?.(next)
+    });
+    vue.watch(
+      () => props.filters,
+      (next) => next !== void 0 && filtering.model.syncFilters(next),
+      { immediate: true }
+    );
+    vue.watch(
+      () => props.filterValues,
+      (next) => next !== void 0 && filtering.model.syncFilterValues(next),
+      { immediate: true }
+    );
+    const effectiveFilters = vue.computed(
+      () => props.filters !== void 0 ? props.filters : filtering.filters.value
+    );
+    const effectiveFilterValues = vue.computed(
+      () => props.filterValues !== void 0 ? props.filterValues : filtering.filterValues.value
+    );
+    const recent = core.createRecentFilters();
+    const recentEntries = vue.shallowRef(recent.list());
+    vue.onScopeDispose(
+      recent.subscribe(() => {
+        recentEntries.value = recent.list();
+      })
+    );
     vue.watch([internalSort, () => props.multiSort, remoteSort, () => proxyCtrl.proxy.value], () => {
       if (!proxyCtrl.proxy.value || !remoteSort.value || props.multiSort) return;
       proxyCtrl.setParams({ sort: internalSort.value });
@@ -13086,7 +14177,7 @@ var IrisTable = vue.defineComponent({
       if (formDraft.value[key] === value) return;
       formDraft.value = { ...formDraft.value, [key]: value };
     };
-    const mergedProxyFilters = (form) => mergeFilterValues(core.mergeFormFilters(props.filters ?? {}, form), props.filterValues ?? {});
+    const mergedProxyFilters = (form) => mergeFilterValues(core.mergeFormFilters(effectiveFilters.value, form), effectiveFilterValues.value);
     const handleFormSubmit = () => {
       const values = core.buildFormValues(props.formConfig?.fields, formDraft.value);
       props.formConfig?.onSearch?.(values);
@@ -13108,7 +14199,7 @@ var IrisTable = vue.defineComponent({
       }
     };
     vue.watch(
-      [formApplied, () => props.filters, () => props.filterValues],
+      [formApplied, effectiveFilters, effectiveFilterValues],
       () => {
         if (proxyCtrl.proxy.value && remoteFilter.value) {
           proxyCtrl.setParams({
@@ -13118,22 +14209,39 @@ var IrisTable = vue.defineComponent({
       },
       { immediate: true }
     );
+    const gridRows = useGridRows(gridCore, tableData.value, {
+      getRowKey: (row, index) => rowId(row, index),
+      getChildren: props.getSubRows !== void 0 || props.lazyLoad !== void 0 ? readRowChildren : void 0,
+      setChildren: writeLazyChildren,
+      onRowsChange: (transaction) => {
+        const next = [...transaction.rows];
+        committedList.sync(next);
+        if (proxyCtrl.proxy.value) proxyCtrl.liveData.value = next;
+        else localRowsOverride.value = next;
+        if (!suppressUndoRecord) recordUndoRows?.(next);
+      }
+    });
+    vue.watch(tableData, (rows) => {
+      committedList.sync(rows);
+      gridRows.model.sync(rows);
+    });
     const selControlled = vue.computed(() => props.selection !== void 0);
-    const selectionModel = core.createSelectionModel({
-      defaultSelected: props.selection ?? props.defaultSelection ?? [],
+    const { model: selectionModel, selection: selectedKeys } = useGridSelection(gridCore, {
+      mode: "multiple",
+      value: props.selection,
+      defaultValue: props.defaultSelection,
       onChange: (keys) => emit("update:selection", keys)
     });
-    const selectedKeys = vue.shallowRef(selectionModel.get());
-    vue.onBeforeUnmount(
-      selectionModel.store.subscribe((keys) => {
-        selectedKeys.value = keys;
-      })
-    );
     vue.watch(
       () => props.selection,
-      (sel) => {
-        if (sel !== void 0) selectionModel.sync(sel);
-      }
+      (selection) => {
+        if (selection === void 0) return;
+        const current = selectionModel.get();
+        if (current.length !== selection.length || current.some((key, index) => !Object.is(key, selection[index]))) {
+          selectionModel.sync(selection);
+        }
+      },
+      { immediate: true }
     );
     const displaySelection = vue.computed(
       () => selControlled.value ? props.selection : selectedKeys.value
@@ -13142,17 +14250,11 @@ var IrisTable = vue.defineComponent({
       if (selControlled.value) selectionModel.sync(props.selection);
     };
     const hasDetail = vue.computed(() => props.renderDetail !== void 0);
-    const expansion = core.createExpansion({
+    const { model: expansion, expandedKeys } = useGridExpansion(gridCore, {
       mode: "multiple",
-      defaultExpanded: (props.defaultExpandedRowKeys ?? []).map(String),
+      defaultValue: (props.defaultExpandedRowKeys ?? []).map(String),
       onChange: (keys) => emit("expandedRowsChange", keys)
     });
-    const expandedKeys = vue.shallowRef(expansion.get());
-    vue.onBeforeUnmount(
-      expansion.store.subscribe((keys) => {
-        expandedKeys.value = keys;
-      })
-    );
     const isRowExpandable = (row, idx) => hasDetail.value && (props.rowExpandable ? props.rowExpandable(row, idx) : true);
     const rowId = (row, index) => {
       const v = row[props.rowKey];
@@ -13171,21 +14273,17 @@ var IrisTable = vue.defineComponent({
       auditRowsRef.value = next;
     };
     const treeMode = vue.computed(() => props.getSubRows !== void 0 || props.lazyLoad !== void 0);
-    const lazyChildren = vue.ref(/* @__PURE__ */ new Map());
     const lazyLoading = vue.ref(/* @__PURE__ */ new Set());
     let lazyEpoch = 0;
     vue.watch(
       () => proxyCtrl.proxy.value ? proxyCtrl.state.value.data : props.data,
       () => {
-        lazyChildren.value = /* @__PURE__ */ new Map();
         lazyLoading.value = /* @__PURE__ */ new Set();
         lazyEpoch += 1;
       }
     );
-    const lazyChildrenOf = (row) => {
-      const key = String(row[props.rowKey]);
-      return lazyChildren.value.get(key) ?? props.getSubRows?.(row);
-    };
+    const lazyChildrenOf = readRowChildren;
+    const hasLazyChildren = (row) => props.lazyLoad !== void 0 && Array.isArray(row.children);
     const flatTree = vue.computed(
       () => treeMode.value ? core.flattenTree(sortedData.value, {
         getKey: (r) => String(r[props.rowKey]),
@@ -13198,9 +14296,9 @@ var IrisTable = vue.defineComponent({
     );
     const filteredData = vue.computed(() => {
       if (remoteFilter.value) return sortedData.value;
-      const merged = proxyCtrl.proxy.value ? props.filters ?? {} : core.mergeFormFilters(props.filters ?? {}, formApplied.value);
+      const merged = proxyCtrl.proxy.value ? effectiveFilters.value : core.mergeFormFilters(effectiveFilters.value, formApplied.value);
       const active = Object.entries(merged).filter(([, v]) => v != null && v !== "");
-      const checkedEntries = Object.entries(props.filterValues ?? {}).filter(
+      const checkedEntries = Object.entries(effectiveFilterValues.value).filter(
         ([, values]) => values.length > 0
       );
       if (active.length === 0 && checkedEntries.length === 0) return sortedData.value;
@@ -13208,12 +14306,12 @@ var IrisTable = vue.defineComponent({
         const textOk = active.every(([key, value]) => {
           const col = displayColumns.value.find((c) => c.key === key);
           if (!col) return true;
-          return String(getCellValue(row, col) ?? "").toLowerCase().includes(value.toLowerCase());
+          return String(getCellValue2(row, col) ?? "").toLowerCase().includes(value.toLowerCase());
         });
         const setsOk = checkedEntries.every(([key, values]) => {
           const col = displayColumns.value.find((c) => c.key === key);
           if (!col) return true;
-          return values.includes(String(getCellValue(row, col) ?? ""));
+          return values.includes(String(getCellValue2(row, col) ?? ""));
         });
         return textOk && setsOk;
       });
@@ -13221,28 +14319,48 @@ var IrisTable = vue.defineComponent({
     const bodyData = vue.computed(
       () => flatTree.value ? flatTree.value.map((t2) => t2.row) : filteredData.value
     );
+    const reconcileClipboardRows = (sourceRows, previousRows, rows) => {
+      const visibleKeys = /* @__PURE__ */ new Map();
+      bodyData.value.forEach((row, index) => {
+        visibleKeys.set(row, rowId(row, index));
+      });
+      const keyOf = (row, index, source) => {
+        const visibleKey = visibleKeys.get(row);
+        if (visibleKey !== void 0) return visibleKey;
+        const sourceIndex = source?.indexOf(row) ?? -1;
+        return rowId(row, sourceIndex >= 0 ? sourceIndex : index);
+      };
+      const patches = /* @__PURE__ */ new Map();
+      rows.forEach((row, index) => {
+        if (Object.is(row, previousRows[index])) return;
+        const previous = previousRows[index];
+        if (!previous) return;
+        const sourceIndex = sourceRows.indexOf(previous);
+        patches.set(keyOf(previous, sourceIndex >= 0 ? sourceIndex : index, sourceRows), row);
+      });
+      if (props.getSubRows !== void 0 || props.lazyLoad !== void 0) {
+        return core.reconcileTreeRows(sourceRows, patches, {
+          getRowKey: (row, index) => keyOf(row, index),
+          getChildren: readRowChildren,
+          setChildren: writeLazyChildren
+        });
+      }
+      return sourceRows.map((row, index) => patches.get(keyOf(row, index, sourceRows)) ?? row);
+    };
     const cascadingTreeSelection = vue.computed(
       () => props.treeSelectionCascade && props.selectable === "multi" && treeMode.value
     );
     const treeSelectionNodes = vue.computed(() => {
-      const getChildren = props.getSubRows;
+      const getChildren = props.getSubRows !== void 0 || props.lazyLoad !== void 0 ? readRowChildren : void 0;
       if (!cascadingTreeSelection.value || !getChildren) return [];
-      const nodes = [];
-      const seen = /* @__PURE__ */ new Set();
       let rowIndex = 0;
-      const walk = (rows, parentKey) => {
-        for (const row of rows) {
-          const key = rowId(row, rowIndex);
-          rowIndex += 1;
-          if (seen.has(key)) continue;
-          seen.add(key);
-          nodes.push({ key, parentKey });
-          const children = getChildren(row);
-          if (children && children.length > 0) walk(children, key);
-        }
-      };
-      walk(sortedData.value);
-      return nodes;
+      return core.flattenTreeSelectionNodes(sortedData.value, {
+        // Keep the legacy fallback key's global pre-order ordinal. The core
+        // helper owns recursion and duplicate/cycle protection; this closure
+        // only supplies the table's existing row-id policy.
+        getKey: (row) => rowId(row, rowIndex++),
+        getChildren
+      });
     });
     const compactTreeSelectionSeed = (keys) => {
       const selected = new Set(keys);
@@ -13313,51 +14431,8 @@ var IrisTable = vue.defineComponent({
       }
       selectionModel.set([...allRowIds.value]);
     };
-    const editingCellId = vue.ref(null);
-    const editingColumnKey = vue.ref(null);
-    const editingDraft = vue.ref("");
-    const editError = vue.ref(null);
     const editorInputRef = vue.ref(null);
-    const beginEdit = (row, column, rowIdent) => {
-      if (!isEditableColumn(column)) return;
-      editingCellId.value = cellId(rowIdent, column.key);
-      editingColumnKey.value = column.key;
-      const current = getCellValue(row, column);
-      editingDraft.value = current == null ? "" : String(current);
-      editError.value = null;
-      void vue.nextTick(() => editorInputRef.value?.focus());
-    };
-    const commitEdit = (row, column, rowIndex) => {
-      if (editingCellId.value === null) return;
-      const oldValue = getCellValue(row, column);
-      const draft = editingDraft.value;
-      const newValue = column.editor === "number" ? draft === "" || Number.isNaN(Number(draft)) ? oldValue : Number(draft) : draft;
-      if (column.editRules && column.editRules.length > 0) {
-        const context = { rows: tableData.value, columnKey: column.key };
-        core.validateEditRulesAsync(column.editRules, draft, row, false, context).then((r) => {
-          if (!r.valid) {
-            editError.value = r.messages[0] ?? null;
-            return;
-          }
-          finishCommit(row, column, rowIndex, oldValue, newValue);
-        });
-        return;
-      }
-      if (column.validate) {
-        const error = column.validate(newValue, row);
-        if (error) {
-          editError.value = error;
-          return;
-        }
-      }
-      finishCommit(row, column, rowIndex, oldValue, newValue);
-      editError.value = null;
-      editingCellId.value = null;
-      if (newValue !== oldValue) {
-        emit("cellEdit", { row, column, oldValue, newValue, rowIndex });
-      }
-    };
-    const writeCellValue = (row, column, rowIndex, oldValue, newValue) => {
+    const recordCellCommit = (row, column, rowIndex, oldValue, newValue) => {
       if (newValue === oldValue) return;
       if (props.auditLog) {
         audit.push({
@@ -13369,43 +14444,95 @@ var IrisTable = vue.defineComponent({
         });
       }
       emit("cellEdit", { row, column, oldValue, newValue, rowIndex });
-      if (proxyCtrl.proxy.value) {
-        const id = rowId(row, rowIndex);
-        const idx = proxyCtrl.liveData.value.findIndex((r, i) => rowId(r, i) === id);
-        if (idx >= 0) {
-          const key = column.dataIndex ?? column.key;
-          const next = { ...proxyCtrl.liveData.value[idx], [key]: newValue };
-          proxyCtrl.liveData.value = [
-            ...proxyCtrl.liveData.value.slice(0, idx),
-            next,
-            ...proxyCtrl.liveData.value.slice(idx + 1)
-          ];
+    };
+    const cellEditing = useGridEditing(gridCore, {
+      getRowKey: (row, index) => rowId(row, index),
+      getRowIndex: (rowKey) => {
+        const index = bodyData.value.findIndex(
+          (row, rowIndex) => Object.is(rowId(row, rowIndex), rowKey)
+        );
+        return index >= 0 ? index : void 0;
+      },
+      getRules: (columnKey) => leafColumns.value.find((column) => column.key === columnKey)?.editRules,
+      getValue: (row, columnKey) => {
+        const column = leafColumns.value.find((candidate) => candidate.key === columnKey);
+        return column ? getCellValue2(row, column) : row[columnKey];
+      },
+      setValue: (row, columnKey, value) => {
+        const column = leafColumns.value.find((candidate) => candidate.key === columnKey);
+        const key = column?.dataIndex ?? column?.key ?? columnKey;
+        return { ...row, [key]: value };
+      },
+      coerce: (draft, row, columnKey) => {
+        const column = leafColumns.value.find((candidate) => candidate.key === columnKey);
+        if (column?.editor !== "number") return draft;
+        const text = String(draft ?? "");
+        if (text === "" || Number.isNaN(Number(text))) {
+          return column ? getCellValue2(row, column) : draft;
         }
+        return Number(text);
+      },
+      validate: (value, row, columnKey) => {
+        const column = leafColumns.value.find((candidate) => candidate.key === columnKey);
+        return column?.validate?.(value, row) ?? null;
+      },
+      isEditable: (_row, columnKey) => {
+        const column = leafColumns.value.find((candidate) => candidate.key === columnKey);
+        return Boolean(column && isEditableColumn(column));
+      },
+      onCommit: (commit) => {
+        const column = leafColumns.value.find((candidate) => candidate.key === commit.columnKey);
+        if (column)
+          recordCellCommit(commit.row, column, commit.rowIndex, commit.oldValue, commit.value);
+      }
+    });
+    const editingState = cellEditing.state;
+    const editingCellId = vue.computed(() => {
+      const target = editingState.value.editing;
+      return target ? cellId(target.rowKey, target.columnKey) : null;
+    });
+    const editingColumnKey = vue.computed(() => editingState.value.editing?.columnKey ?? null);
+    const editingDraft = vue.computed(() => String(editingState.value.draft ?? ""));
+    const editError = vue.computed(() => editingState.value.error);
+    const setEditingDraft = (draft) => cellEditing.setCellDraft(draft);
+    const beginEdit = (row, column, rowIdent) => {
+      if (!isEditableColumn(column)) return;
+      const current = getCellValue2(row, column);
+      if (cellEditing.startCellEdit(rowIdent, column.key, current == null ? "" : String(current))) {
+        void vue.nextTick(() => editorInputRef.value?.focus());
       }
     };
-    const finishCommit = (row, column, rowIndex, oldValue, newValue) => {
-      editError.value = null;
-      editingCellId.value = null;
-      editingColumnKey.value = null;
-      writeCellValue(row, column, rowIndex, oldValue, newValue);
+    const commitEdit = (_row, _column, _rowIndex) => {
+      cellEditing.commitCellEdit();
     };
-    const cancelEdit = () => {
-      editError.value = null;
-      editingCellId.value = null;
-      editingColumnKey.value = null;
+    const cancelEdit = () => cellEditing.cancelCellEdit();
+    const writeCellValue = (row, column, rowIndex, oldValue, newValue) => {
+      if (newValue === oldValue) return;
+      recordCellCommit(row, column, rowIndex, oldValue, newValue);
+      const current = committedList.list();
+      const key = column.dataIndex ?? column.key;
+      const next = replaceTableCell(current, rowId(row, rowIndex), key, newValue, rowId);
+      if (next !== current) {
+        undoController.record(next);
+        setTableRows(next);
+      }
     };
     const rowMode = vue.computed(() => props.editConfig?.mode === "row");
     const rowSessions = vue.ref(/* @__PURE__ */ new Map());
     const rowEditing = vue.ref(null);
     const rowEditorRefs = /* @__PURE__ */ new Map();
-    const currentRowFor = (k) => bodyData.value.find((r, i) => rowId(r, i) === k);
+    const currentRowFor = (k) => (
+      // Static tree children are indexed by the shared Core rows model. Keep
+      // the visible-body fallback for proxy/lazy rows owned by this adapter.
+      committedList.list().find((r, i) => rowId(r, i) === k) ?? gridRows.model.find(k) ?? bodyData.value.find((r, i) => rowId(r, i) === k)
+    );
     const beginRowEdit = (row, rowIndex, focusColKey) => {
       const k = rowId(row, rowIndex);
       const editableCols = leafColumns.value.filter(isEditableColumn);
       if (editableCols.length === 0) return;
       const sessions = /* @__PURE__ */ new Map();
       for (const col of editableCols) {
-        const current = getCellValue(row, col);
+        const current = getCellValue2(row, col);
         sessions.set(cellId(k, col.key), {
           draft: current == null ? "" : String(current),
           error: null
@@ -13421,7 +14548,7 @@ var IrisTable = vue.defineComponent({
       if (!session) return;
       const row = currentRowFor(k);
       if (!row) return;
-      const oldValue = getCellValue(row, column);
+      const oldValue = getCellValue2(row, column);
       const draft = session.draft;
       const newValue = column.editor === "number" ? draft === "" || Number.isNaN(Number(draft)) ? oldValue : Number(draft) : draft;
       if (column.editRules && column.editRules.length > 0) {
@@ -13473,7 +14600,7 @@ var IrisTable = vue.defineComponent({
       if (rowEditing.value?.k === k) {
         const id = cellId(k, col.key);
         if (isEditableColumn(col) && !rowSessions.value.has(id)) {
-          const current = getCellValue(row, col);
+          const current = getCellValue2(row, col);
           rowSessions.value.set(id, {
             draft: current == null ? "" : String(current),
             error: null
@@ -13488,6 +14615,7 @@ var IrisTable = vue.defineComponent({
       rowEditorRefs,
       editorInputRef,
       editingDraft,
+      setEditingDraft,
       editError,
       commitEdit,
       cancelEdit,
@@ -13495,7 +14623,7 @@ var IrisTable = vue.defineComponent({
       cancelRowEdit,
       editPreview: props.editPreview,
       previewValue: (row, col, draft) => {
-        const raw = col.editor === "number" ? draft === "" || Number.isNaN(Number(draft)) ? getCellValue(row, col) : Number(draft) : draft;
+        const raw = col.editor === "number" ? draft === "" || Number.isNaN(Number(draft)) ? getCellValue2(row, col) : Number(draft) : draft;
         return col.formatter?.(core.applyTableMask(raw, col), row) ?? "";
       }
     };
@@ -13512,7 +14640,7 @@ var IrisTable = vue.defineComponent({
           paddingLeft: `${treeMeta.depth * 16}px`
         }
       },
-      treeMeta.hasChildren || props.lazyLoad !== void 0 && !lazyChildren.value.has(treeMeta.key) ? [
+      treeMeta.hasChildren || props.lazyLoad !== void 0 && !hasLazyChildren(row) ? [
         vue.h(
           "button",
           {
@@ -13538,8 +14666,18 @@ var IrisTable = vue.defineComponent({
                 const epoch = lazyEpoch;
                 props.lazyLoad(row, (children) => {
                   if (epoch !== lazyEpoch) return;
-                  lazyChildren.value.set(treeMeta.key, children);
-                  if (children && children.length > 0) {
+                  const rawKey = row[props.rowKey];
+                  const lazyKey = typeof rawKey === "string" || typeof rawKey === "number" ? rawKey : rowId(row, Math.max(0, treeMeta.posInset - 1));
+                  suppressUndoRecord = true;
+                  let committed = false;
+                  try {
+                    committed = gridRows.model.setChildren(lazyKey, children, {
+                      reason: "lazy-load"
+                    });
+                  } finally {
+                    suppressUndoRecord = false;
+                  }
+                  if (committed && children && children.length > 0) {
                     expansion.toggle(treeMeta.key);
                   }
                   clearLoading();
@@ -13572,21 +14710,30 @@ var IrisTable = vue.defineComponent({
     vue.watch(
       () => leafColumns.value,
       (cols) => {
-        const seeded = { ...internalWidths.value };
-        let changed = false;
+        const seeded = { ...uncontrolledWidths.value };
+        let snapshotChanged = false;
         for (const col of cols) {
           if (seeded[col.key] === void 0) {
             seeded[col.key] = resolveInitialWidth(col);
-            changed = true;
+            snapshotChanged = true;
           }
         }
-        if (changed) internalWidths.value = seeded;
+        if (snapshotChanged) uncontrolledWidths.value = seeded;
+        const modelWidths = { ...columnsFeature.state.value.widths };
+        let modelChanged = false;
+        for (const col of cols) {
+          if (modelWidths[col.key] === void 0) {
+            modelWidths[col.key] = resolveInitialWidth(col);
+            modelChanged = true;
+          }
+        }
+        if (modelChanged) columnsFeature.model.syncWidths(modelWidths);
       },
       { immediate: true, deep: false }
     );
     const setColumnWidths = (next) => {
-      if (props.columnWidths === void 0) internalWidths.value = next;
-      emit("update:columnWidths", next);
+      if (props.columnWidths === void 0) uncontrolledWidths.value = next;
+      columnsFeature.setWidths(next);
     };
     const onHeaderClick = (column) => {
       if (props.multiSort) cycleMultiSort(column);
@@ -13622,7 +14769,7 @@ var IrisTable = vue.defineComponent({
     const renderFilterTrigger = (col, leaf) => renderTableFilterTrigger({
       column: col,
       leaf,
-      active: (props.filterValues?.[col.key]?.length ?? 0) > 0,
+      active: (effectiveFilterValues.value[col.key]?.length ?? 0) > 0,
       open: filterPanelState.value?.open === true && filterPanelState.value.colKey === col.key,
       label: t("table.filter"),
       onOpen: openFilterPanel
@@ -13635,18 +14782,136 @@ var IrisTable = vue.defineComponent({
       if (hasDetail.value) parts.push(`${EXPAND_COL_WIDTH}px`);
       if (props.selectable !== "none") parts.push(`${SELECTION_COL_WIDTH}px`);
       for (const col of leafColumns.value) {
+        if (isColumnFadeCollapsed(col.key)) {
+          parts.push("0px");
+          continue;
+        }
         parts.push(`${effectiveWidths.value[col.key] ?? resolveInitialWidth(col)}px`);
       }
       return parts.join(" ");
     });
-    const cellRangeCtrl = core.createCellRange();
-    const cellRangeState = vue.shallowRef(cellRangeCtrl.getState());
-    vue.onBeforeUnmount(
-      cellRangeCtrl.subscribe((s) => {
-        cellRangeState.value = s;
-      })
-    );
+    const { model: cellRangeCtrl, state: cellRangeState } = useGridRange(gridCore);
+    const { serialize: serializeGridRange, paste: pasteGridRange } = useGridClipboard(gridCore, {
+      getRows: () => bodyData.value,
+      getColumns: () => leafColumns.value,
+      rowKeyField: props.rowKey,
+      resolveValue: (row, column) => getCellValue2(row, column),
+      setValue: (row, column, value) => ({
+        ...row,
+        [column.dataIndex ?? column.key]: value
+      }),
+      isCellEditable: (_row, column) => !column.formula,
+      reconcileRows: reconcileClipboardRows,
+      onPaste: (change) => {
+        const rows = [...change.rows];
+        recordAudit(rows, "paste");
+        props.onDataChange?.(rows);
+      }
+    });
     const rootRef = vue.ref(null);
+    let tableDisposed = false;
+    vue.onScopeDispose(() => {
+      tableDisposed = true;
+    });
+    const setTableRows = (rows) => {
+      committedList.sync(rows);
+      suppressUndoRecord = true;
+      try {
+        gridRows.model.commit(rows);
+      } finally {
+        suppressUndoRecord = false;
+      }
+    };
+    const undoController = createTableUndoController(
+      () => props.undo,
+      () => props.data ?? [],
+      () => proxyCtrl.proxy.value ? proxyCtrl.state.value.data : props.data ?? [],
+      setTableRows,
+      recordAudit,
+      (rows) => props.onDataChange?.(rows),
+      () => rootRef.value,
+      () => editingCellId.value !== null || rowEditing.value !== null,
+      {
+        current: () => displaySelection.value,
+        enabled: () => props.selectable !== "none",
+        keyOf: rowId,
+        rebase: rebaseToProp,
+        set: (keys) => selectionModel.set(keys)
+      }
+    );
+    recordUndoRows = undoController.record;
+    const scrollTopShown = vue.ref(false);
+    let scrollTopListeners = [];
+    const clearScrollTopListeners = () => {
+      for (const el of scrollTopListeners) el.removeEventListener("scroll", onScrollTop);
+      scrollTopListeners = [];
+    };
+    const onScrollTop = () => {
+      const root = rootRef.value;
+      if (!root) return;
+      const viewport = root.querySelector("[data-iris-virtual-scroll]");
+      const scroller = viewport ?? root;
+      scrollTopShown.value = scroller.scrollTop >= SCROLL_TOP_VISIBLE_PX;
+    };
+    const armScrollTop = () => {
+      clearScrollTopListeners();
+      scrollTopShown.value = false;
+      if (!props.scrollToTop || !rootRef.value) return;
+      const root = rootRef.value;
+      const viewport = root.querySelector("[data-iris-virtual-scroll]");
+      root.addEventListener("scroll", onScrollTop);
+      scrollTopListeners.push(root);
+      if (viewport) {
+        viewport.addEventListener("scroll", onScrollTop);
+        scrollTopListeners.push(viewport);
+      }
+      onScrollTop();
+    };
+    vue.onMounted(armScrollTop);
+    vue.watch(
+      [
+        () => props.scrollToTop,
+        () => Boolean(props.virtualScroll),
+        bodyData,
+        tableLoading,
+        tableError
+      ],
+      armScrollTop,
+      { flush: "post" }
+    );
+    vue.onBeforeUnmount(clearScrollTopListeners);
+    const scrollToTopOfTable = () => {
+      const root = rootRef.value;
+      if (!root) return;
+      const viewport = root.querySelector("[data-iris-virtual-scroll]");
+      const scroller = viewport ?? root;
+      const behavior = prefersReducedMotion() ? "auto" : "smooth";
+      if (typeof scroller.scrollTo === "function") {
+        try {
+          scroller.scrollTo({ top: 0, behavior });
+          return;
+        } catch {
+        }
+      }
+      scroller.scrollTop = 0;
+    };
+    const buildBackTopSection = () => {
+      if (!props.scrollToTop || !scrollTopShown.value || props.printable) return null;
+      return vue.h("div", { "data-iris-back-top-anchor": "", style: BACK_TOP_ANCHOR_STYLE }, [
+        vue.h(
+          "button",
+          {
+            type: "button",
+            "data-iris-back-top-table": "",
+            "aria-label": t("backTop.label"),
+            title: t("backTop.label"),
+            onClick: scrollToTopOfTable,
+            style: BACK_TOP_BUTTON_STYLE
+          },
+          "\u2191"
+        )
+      ]);
+    };
     let responsiveObserver = null;
     const measureResponsiveWidth = () => {
       responsiveWidth.value = props.responsive && rootRef.value ? rootRef.value.clientWidth : 0;
@@ -13679,7 +14944,17 @@ var IrisTable = vue.defineComponent({
       root: () => rootRef.value,
       focused: focusedCell,
       range: cellRangeCtrl,
-      rangeState: cellRangeState
+      rangeState: cellRangeState,
+      serializeRange: serializeGridRange,
+      pasteRange: (range) => {
+        const clipAtStart = props.clipConfig;
+        if (!clipAtStart || clipAtStart.paste === false) return;
+        void readClipboardText().then((text) => {
+          const clip = props.clipConfig;
+          if (text === null || tableDisposed || !clip || clip.paste === false) return;
+          pasteGridRange(text, range);
+        });
+      }
     });
     const { handleRootKeyDown, isInRange, activeCellRange, copyActiveRange } = keyboard;
     const scrollLeft = vue.ref(0);
@@ -13701,21 +14976,28 @@ var IrisTable = vue.defineComponent({
         ro = null;
       });
     }
-    const visibleColSet = vue.computed(
-      () => computeVisibleColSet(
+    const visibleColSet = vue.computed(() => {
+      const visible = computeVisibleColSet(
         props.columnVirtualization,
         leafColumns.value,
         scrollLeft.value,
         viewportWidth.value,
-        effectiveWidths.value
-      )
-    );
+        effectiveWidths.value,
+        pinOf
+      );
+      if (!visible) return null;
+      const next = new Set(visible);
+      leafColumns.value.forEach((column, index) => {
+        if (fadeByLeaf.value[column.key]) next.add(index);
+      });
+      return next;
+    });
     const pinnedOffsets = vue.computed(() => {
       const map = {};
       const widthOf = (col) => effectiveWidths.value[col.key] ?? resolveInitialWidth(col);
       let left = (props.rowDrag ? DRAG_COL_WIDTH : 0) + (props.seq ? SEQ_COL_WIDTH : 0) + (hasDetail.value ? EXPAND_COL_WIDTH : 0) + (props.selectable !== "none" ? SELECTION_COL_WIDTH : 0);
       for (const col of leafColumns.value) {
-        if (col.pinned === "left") {
+        if (pinOf(col) === "left") {
           map[col.key] = { side: "left", offset: left };
           left += widthOf(col);
         }
@@ -13723,7 +15005,7 @@ var IrisTable = vue.defineComponent({
       let right = 0;
       for (let i = leafColumns.value.length - 1; i >= 0; i -= 1) {
         const col = leafColumns.value[i];
-        if (col?.pinned === "right") {
+        if (col && pinOf(col) === "right") {
           map[col.key] = { side: "right", offset: right };
           right += widthOf(col);
         }
@@ -13769,12 +15051,24 @@ var IrisTable = vue.defineComponent({
         }
       });
     };
+    const setColumnPinned = (key, side) => {
+      if (props.pinnedColumns !== void 0) {
+        columnsFeature.model.syncPinned(props.pinnedColumns);
+      }
+      columnsFeature.setPinned(key, side);
+    };
     const pinnedDragHandle = createTablePinnedDrag({
       enabled: () => props.pinnedDrag === true,
       columns: () => leafColumns.value,
       widthOf: (column) => effectiveWidths.value[column.key] ?? resolveInitialWidth(column),
-      onColumnPinnedChange: props.onColumnPinnedChange,
-      onPinnedCountChange: props.onPinnedCountChange
+      pinOf,
+      setPinned: (key, side) => {
+        if (pinnedPropControlled.value) {
+          columnsFeature.model.syncPinned(props.pinnedColumns ?? {});
+          columnsFeature.setPinned(key, side);
+        } else props.onColumnPinnedChange?.(key, side);
+      },
+      onPinnedCountChange: (count) => props.onPinnedCountChange?.(count)
     });
     const rowDragCtrl = core.createSortable();
     const rowDragState = vue.shallowRef(rowDragCtrl.getState());
@@ -13823,16 +15117,66 @@ var IrisTable = vue.defineComponent({
       }
       const { activeId, overId } = rowDragCtrl.end();
       if (activeId !== null && overId !== null && activeId !== overId) {
-        const rows = [...bodyData.value];
-        const from = rows.findIndex((r, i) => String(rowId(r, i)) === activeId);
-        const to = rows.findIndex((r, i) => String(rowId(r, i)) === overId);
-        if (from >= 0 && to >= 0 && from !== to) {
-          const [moved] = rows.splice(from, 1);
-          rows.splice(to, 0, moved);
-          if (proxyCtrl.proxy.value) proxyCtrl.liveData.value = rows;
-          else localRowsOverride.value = rows;
-          props.onDataChange?.(rows);
-          props.rowDrag.onReorder(rows);
+        const visibleRows = bodyData.value;
+        const fromVisible = visibleRows.findIndex(
+          (row, index) => String(rowId(row, index)) === activeId
+        );
+        const toVisible = visibleRows.findIndex(
+          (row, index) => String(rowId(row, index)) === overId
+        );
+        const fromRow = fromVisible >= 0 ? visibleRows[fromVisible] : void 0;
+        const toRow = toVisible >= 0 ? visibleRows[toVisible] : void 0;
+        const fromKey = fromRow === void 0 ? void 0 : rowId(fromRow, fromVisible);
+        const toKey = toRow === void 0 ? void 0 : rowId(toRow, toVisible);
+        const modelFrom = fromKey === void 0 ? void 0 : gridRows.model.find(fromKey);
+        const modelTo = toKey === void 0 ? void 0 : gridRows.model.find(toKey);
+        const useRowsModel = fromKey !== void 0 && toKey !== void 0 && modelFrom === fromRow && modelTo === toRow;
+        if (useRowsModel) {
+          const position = fromVisible < toVisible ? "after" : "before";
+          if (gridRows.model.reorder(fromKey, toKey, { reason: "row-drag", position })) {
+            const rows = gridRows.model.get();
+            props.onDataChange?.(rows);
+            props.rowDrag.onReorder(rows);
+            rowRectsRef.value = [];
+            return;
+          }
+        }
+        if (props.getSubRows !== void 0 || props.lazyLoad !== void 0) {
+          const visibleKeys = new Map(
+            visibleRows.map((row, index) => [row, String(rowId(row, index))])
+          );
+          if (fromVisible >= 0 && toVisible >= 0) {
+            const result = core.reorderTreeRows(
+              gridRows.model.get(),
+              activeId,
+              overId,
+              {
+                // Every drop target is visible; leave hidden descendants keyless
+                // so a synthetic sibling index cannot mask a visible target.
+                getRowKey: (row) => visibleKeys.get(row),
+                getChildren: readRowChildren,
+                setChildren: writeLazyChildren
+              },
+              fromVisible < toVisible ? "after" : "before"
+            );
+            if (result.changed) {
+              const rows = result.rows;
+              gridRows.model.commit(rows, { reason: "row-drag" });
+              props.onDataChange?.(rows);
+              props.rowDrag.onReorder(rows);
+            }
+          }
+        } else {
+          const rows = [...bodyData.value];
+          const from = rows.findIndex((r, i) => String(rowId(r, i)) === activeId);
+          const to = rows.findIndex((r, i) => String(rowId(r, i)) === overId);
+          if (from >= 0 && to >= 0 && from !== to) {
+            const [moved] = rows.splice(from, 1);
+            rows.splice(to, 0, moved);
+            gridRows.model.commit(rows, { reason: "row-drag" });
+            props.onDataChange?.(rows);
+            props.rowDrag.onReorder(rows);
+          }
         }
       }
       rowRectsRef.value = [];
@@ -13881,6 +15225,9 @@ var IrisTable = vue.defineComponent({
           const [moved] = next.splice(from, 1);
           next.splice(to, 0, moved);
           props.columnDrag.onReorder(next);
+          if (!grouped.value && orderPropControlled.value) {
+            columnsFeature.setOrder(next.map((column) => column.key));
+          }
         }
       }
       colRectsRef.value = [];
@@ -13889,8 +15236,7 @@ var IrisTable = vue.defineComponent({
     const tableExpose = {
       loadData: (rows) => {
         recordAudit(rows, "edit");
-        if (proxyCtrl.proxy.value) proxyCtrl.liveData.value = rows;
-        else localRowsOverride.value = rows;
+        gridRows.model.loadData(rows);
         props.onDataChange?.(rows);
       },
       reloadData: () => {
@@ -13905,13 +15251,13 @@ var IrisTable = vue.defineComponent({
         return { page: s.params.page, pageSize: s.params.pageSize, total: s.total };
       },
       removeRows: (keys) => {
-        const { rows, removedKeys } = core.removeRowsFromList(tableData.value, props.rowKey, keys);
-        if (removedKeys.size === 0) return;
+        const removedKeys = gridRows.model.removeMany(keys);
+        if (removedKeys.length === 0) return;
+        const rows = gridRows.model.get();
         recordAudit(rows, "remove");
-        if (proxyCtrl.proxy.value) proxyCtrl.liveData.value = rows;
-        else localRowsOverride.value = rows;
         const selected = displaySelection.value;
-        const nextSelection = selected.filter((key) => !removedKeys.has(key));
+        const removed = new Set(removedKeys);
+        const nextSelection = selected.filter((key) => !removed.has(key));
         if (nextSelection.length !== selected.length) {
           rebaseToProp();
           selectionModel.set(nextSelection);
@@ -13920,12 +15266,12 @@ var IrisTable = vue.defineComponent({
       },
       getFilteredData: () => [...bodyData.value],
       exportCurrentViewCsv: () => exportCsv(
-        withComputedFormulaCells(bodyData.value, leafColumns.value),
+        withComputedFormulaCells(bodyData.value, leafColumns.value, props.formulaTables),
         leafColumns.value
       ),
       exportMultiCsv: () => {
         const current = exportCsv(
-          withComputedFormulaCells(bodyData.value, leafColumns.value),
+          withComputedFormulaCells(bodyData.value, leafColumns.value, props.formulaTables),
           leafColumns.value
         );
         const names = props.exportNames;
@@ -14013,6 +15359,7 @@ ${refCsv}` : ""}`);
       densityToggle: props.densityToggle,
       effectiveDensity: effectiveDensity.value,
       onDensityToggle: cycleDensity,
+      undo: { enabled: props.undo, controller: undoController, t },
       // Batch EN: the built-in audit trigger rides the toolbar (react
       // parity — the toolbar gate admits auditLog on its own).
       auditLog: props.auditLog,
@@ -14027,23 +15374,80 @@ ${refCsv}` : ""}`);
     const closeContextMenu = () => {
       if (contextMenuState.value) contextMenuState.value.open = false;
     };
+    const virtualCursorAnchor = (event) => ({
+      getBoundingClientRect: () => ({
+        left: event.clientX,
+        top: event.clientY,
+        right: event.clientX,
+        bottom: event.clientY,
+        width: 0,
+        height: 0,
+        x: event.clientX,
+        y: event.clientY,
+        toJSON() {
+        }
+      })
+    });
+    const pinMenuState = vue.ref(null);
+    const pinMenuAnchorRef = vue.ref(null);
+    const pinMenuRef = vue.ref(null);
+    const closePinMenu = () => {
+      if (pinMenuState.value) pinMenuState.value.open = false;
+    };
+    vue.watch(
+      () => props.columnPinMenu,
+      (enabled) => {
+        if (!enabled) closePinMenu();
+      },
+      { flush: "sync" }
+    );
+    const pinMenuItemsFor = (column) => pinOf(column) === null ? [{ key: PIN_LEFT_MENU_KEY, label: t("table.pinLeft") }] : [{ key: UNPIN_MENU_KEY, label: t("table.unpin") }];
+    const handleHeaderContextMenu = (event, column) => {
+      if (!props.columnPinMenu) return;
+      event.preventDefault();
+      event.stopPropagation();
+      closeContextMenu();
+      pinMenuAnchorRef.value = virtualCursorAnchor(event);
+      const params = {
+        row: void 0,
+        column,
+        rowIndex: -1,
+        columnIndex: leafColumns.value.findIndex((candidate) => candidate.key === column.key)
+      };
+      pinMenuState.value = { open: true, items: pinMenuItemsFor(column), params };
+    };
+    const pinMenuConfig = {
+      // The renderer receives the snapshot items above. This required config
+      // member is intentionally empty: the pin menu has no caller items.
+      items: () => [],
+      onSelect: (key, params) => {
+        const current = pinOf(params.column);
+        if (key === PIN_LEFT_MENU_KEY && current === null) {
+          setColumnPinned(params.column.key, "left");
+        } else if (key === UNPIN_MENU_KEY && current !== null) {
+          setColumnPinned(params.column.key, null);
+        }
+      }
+    };
+    vue.watch(
+      () => {
+        const state = pinMenuState.value;
+        if (!state?.open) return null;
+        const side = pinOf(state.params.column);
+        const label = t(side === null ? "table.pinLeft" : "table.unpin");
+        return `${side ?? "none"}\0${label}`;
+      },
+      () => {
+        const state = pinMenuState.value;
+        if (state?.open) state.items = pinMenuItemsFor(state.params.column);
+      },
+      { flush: "sync" }
+    );
     const handleContextMenu = (e, row, col, idx, ci) => {
       if (!props.contextMenu) return;
       e.preventDefault();
-      contextAnchorRef.value = {
-        getBoundingClientRect: () => ({
-          left: e.clientX,
-          top: e.clientY,
-          right: e.clientX,
-          bottom: e.clientY,
-          width: 0,
-          height: 0,
-          x: e.clientX,
-          y: e.clientY,
-          toJSON() {
-          }
-        })
-      };
+      closePinMenu();
+      contextAnchorRef.value = virtualCursorAnchor(e);
       const params = {
         row,
         column: col,
@@ -14085,6 +15489,41 @@ ${refCsv}` : ""}`);
       close: closeContextMenu,
       contextMenu: props.contextMenu
     });
+    const pinMenuOpen = vue.computed(() => props.columnPinMenu && pinMenuState.value?.open === true);
+    const { floatingStyles: pinMenuStyles } = useFloating({
+      anchor: pinMenuAnchorRef,
+      floating: pinMenuRef,
+      open: pinMenuOpen,
+      placement: "bottom-start",
+      // The zero-size virtual anchor must remain at the cursor; clamping it
+      // would move the context menu away from the requested coordinates.
+      flip: false,
+      shift: false
+    });
+    useDismiss({
+      enabled: pinMenuOpen,
+      exclude: [pinMenuRef],
+      onDismiss: closePinMenu
+    });
+    vue.watch(pinMenuOpen, (open) => {
+      if (typeof document === "undefined") return;
+      if (open) document.addEventListener("scroll", closePinMenu, true);
+      else document.removeEventListener("scroll", closePinMenu, true);
+    });
+    vue.onScopeDispose(() => {
+      if (typeof document === "undefined") return;
+      document.removeEventListener("scroll", closePinMenu, true);
+    });
+    const buildPinMenuSection = () => {
+      if (!props.columnPinMenu) return null;
+      return renderContextMenuSection({
+        state: pinMenuState,
+        styles: pinMenuStyles,
+        menuRef: pinMenuRef,
+        close: closePinMenu,
+        contextMenu: pinMenuConfig
+      });
+    };
     const filterPanelState = vue.ref(null);
     const filterAnchorRef = vue.ref(null);
     const filterPanelRef = vue.ref(null);
@@ -14095,7 +15534,7 @@ ${refCsv}` : ""}`);
     const openFilterPanel = (e, colKey) => {
       e.stopPropagation();
       filterAnchorRef.value = e.currentTarget;
-      filterDraft.value = [...props.filterValues?.[colKey] ?? []];
+      filterDraft.value = [...effectiveFilterValues.value[colKey] ?? []];
       filterPanelState.value = { open: true, colKey };
     };
     const filterPanelOpen = vue.computed(() => filterPanelState.value?.open === true);
@@ -14120,12 +15559,15 @@ ${refCsv}` : ""}`);
       document.removeEventListener("scroll", closeFilterPanel, true);
     });
     const applyFilterValues = (colKey, values) => {
-      props.onFilterValuesChange?.({ ...props.filterValues ?? {}, [colKey]: values });
+      filtering.model.setFilterValues({ ...effectiveFilterValues.value, [colKey]: values });
+      if (props.recentFilters && values.length > 0) recent.record(colKey, values);
+    };
+    const applyRecentFilter = (entry) => {
+      applyFilterValues(entry.key, entry.values);
+      closeFilterPanel();
     };
     const clearFilterValues = (colKey) => {
-      const next = { ...props.filterValues ?? {} };
-      delete next[colKey];
-      props.onFilterValuesChange?.(next);
+      filtering.model.clearColumnFilterValues(colKey);
     };
     const toggleFilterDraft = (value) => {
       filterDraft.value = filterDraft.value.includes(value) ? filterDraft.value.filter((v) => v !== value) : [...filterDraft.value, value];
@@ -14136,12 +15578,14 @@ ${refCsv}` : ""}`);
       panelRef: filterPanelRef,
       filterDraft,
       columns: displayColumns.value,
-      filterValues: props.filterValues,
+      filterValues: effectiveFilterValues.value,
       t,
       close: closeFilterPanel,
       toggle: toggleFilterDraft,
       apply: applyFilterValues,
-      clear: clearFilterValues
+      clear: clearFilterValues,
+      recent: props.recentFilters ? recentEntries.value : [],
+      onApplyRecent: applyRecentFilter
     });
     return () => {
       const showSelection = props.selectable !== "none";
@@ -14270,6 +15714,13 @@ ${refCsv}` : ""}`);
           multiSortSeq,
           renderFilterTrigger,
           pinnedDragHandle,
+          pinOf,
+          pinnedColumnsControlled: props.pinnedColumns !== void 0,
+          columnPinMenu: props.columnPinMenu,
+          pinnedStyle,
+          onHeaderContextMenu: props.columnPinMenu ? handleHeaderContextMenu : void 0,
+          columnFadeAttr,
+          columnFadeStyle,
           gridTemplate
         },
         matrix
@@ -14370,7 +15821,8 @@ ${refCsv}` : ""}`);
               key: col.key,
               role: "columnheader",
               "data-iris-table-header": col.key,
-              "data-iris-table-pinned": col.pinned,
+              "data-iris-table-pinned": pinOf(col),
+              ...columnFadeAttrs(col),
               // Column drag-sort (vxe columnDragConfig parity, batch Y): the
               // header cell is the press target; grouped headers are NOT
               // supported (documented simplification — the reorder maps leaf
@@ -14379,6 +15831,7 @@ ${refCsv}` : ""}`);
               "data-iris-col-drag-over": props.columnDrag && colDragState.value.overId === col.key ? "true" : void 0,
               onPointerdown: props.columnDrag && !grouped.value ? (e) => handleColDragPointerDown(e, col.key) : void 0,
               onClick: () => onHeaderClick(col),
+              ...props.columnPinMenu ? { onContextmenu: (event) => handleHeaderContextMenu(event, col) } : {},
               style: {
                 position: "relative",
                 display: "flex",
@@ -14395,8 +15848,9 @@ ${refCsv}` : ""}`);
                 whiteSpace: "nowrap",
                 overflow: "hidden",
                 textOverflow: "ellipsis",
+                ...columnFadeStyle(col) ?? {},
                 ...visibleColSet.value ? { gridColumnStart: String(colTrack(ci)) } : {},
-                ...col.pinned ? { ...pinnedStyle(col.key), background: "var(--iris-surface)" } : {}
+                ...pinOf(col) !== null ? { ...pinnedStyle(col.key), background: "var(--iris-surface)" } : {}
               },
               "aria-sort": ariaSortFor(col)
             },
@@ -14574,7 +16028,7 @@ ${refCsv}` : ""}`);
           const cellSlot = slots[`cell.${col.key}`];
           const isRowEditing = rowMode.value && rowEditing.value !== null && rowEditing.value.k === id && rowSessions.value.has(cellId(id, col.key));
           const isEditing = isRowEditing || editingCellId.value === cellId(id, col.key);
-          const patternHint = (props.pattern || props.patternFill) && !rowMode.value && editingColumnKey.value === col.key && !isEditing && editingDraft.value !== "" && String(getCellValue(row, col) ?? "") === editingDraft.value;
+          const patternHint = (props.pattern || props.patternFill) && !rowMode.value && editingColumnKey.value === col.key && !isEditing && editingDraft.value !== "" && String(getCellValue2(row, col) ?? "") === editingDraft.value;
           let content;
           if (isEditing) {
             const editCellId = cellId(id, col.key);
@@ -14587,7 +16041,11 @@ ${refCsv}` : ""}`);
               rowSessions.value.get(editCellId)
             ) : buildCellEditContent(row, col, index, editCellId);
           } else {
-            content = cellSlot?.({ row, index, value: getCellValue(row, col) }) ?? core.tableDisplayText(row, col, getCellValue);
+            content = cellSlot?.({ row, index, value: getCellValue2(row, col) }) ?? (props.searchHighlight ? (() => {
+              const displayValue = core.applyTableMask(getCellValue2(row, col), col);
+              const renderedValue = col.formatter ? col.formatter(displayValue, row) : displayValue;
+              return applySearchHighlight(renderedValue, props.searchHighlight);
+            })() : core.tableDisplayText(row, col, getCellValue2));
           }
           const treeIndent = treeMeta && ci === 0 ? buildTreeIndent(treeMeta, row) : null;
           const cellChildren = treeIndent ? [treeIndent, ...Array.isArray(content) ? content : [content]] : content;
@@ -14598,7 +16056,8 @@ ${refCsv}` : ""}`);
                 key: col.key,
                 role: "cell",
                 "data-iris-table-cell": col.key,
-                "data-iris-table-pinned": col.pinned,
+                "data-iris-table-pinned": pinOf(col),
+                ...columnFadeAttrs(col),
                 "data-editable": isEditableColumn(col) ? "" : void 0,
                 "data-editing": isEditing ? "" : void 0,
                 "data-iris-input-hint": patternHint ? "true" : void 0,
@@ -14651,7 +16110,8 @@ ${refCsv}` : ""}`);
                   ...patternHint ? {
                     backgroundImage: "linear-gradient(var(--iris-input-hint, rgba(251, 191, 36, 0.16)), var(--iris-input-hint, rgba(251, 191, 36, 0.16)))"
                   } : {},
-                  ...pinnedStyle(col.key)
+                  ...pinnedStyle(col.key),
+                  ...columnFadeStyle(col) ?? {}
                 }
               },
               cellChildren
@@ -14681,7 +16141,7 @@ ${refCsv}` : ""}`);
               display: "grid",
               gridTemplateColumns: gridTemplate.value,
               background: selected ? "var(--iris-surface-hover)" : "transparent",
-              transition: "background-color 120ms ease",
+              transition: columnFadeActive.value ? "background-color 120ms ease, grid-template-columns var(--iris-duration-md, 200ms) ease" : "background-color 120ms ease",
               cursor: "default",
               ...style
             }
@@ -14778,8 +16238,11 @@ ${refCsv}` : ""}`);
         visibleColSet: visibleColSet.value,
         gridTemplate: gridTemplate.value,
         leadingCells: leadSummaryCells(),
+        columnFadeAttr,
+        columnFadeStyle,
         colTrack,
-        getCellValue,
+        getCellValue: getCellValue2,
+        pinOf,
         pinnedStyle
       }) : null;
       const rootNodes = [
@@ -14809,6 +16272,7 @@ ${refCsv}` : ""}`);
             // grid/table role as before (treegrid implies managed cell focus).
             role: props.keyboardNavigation ? treeMode.value ? "treegrid" : "grid" : "table",
             "data-iris-table": "",
+            "data-iris-column-fade-active": columnFadeActive.value ? "true" : void 0,
             "data-density": effectiveDensity.value,
             "data-printable": props.printable ? "true" : void 0,
             "data-virtual": props.virtualScroll ? "" : void 0,
@@ -14842,7 +16306,7 @@ ${refCsv}` : ""}`);
               ...attrs.style ?? {}
             }
           },
-          [headerRow, bodyNode, summaryRow, buildPagerSection()]
+          [headerRow, bodyNode, summaryRow, buildPagerSection(), buildBackTopSection()]
         ),
         props.responsive && responsiveOverflow.value && !props.printable ? vue.h(
           "div",
@@ -14865,6 +16329,7 @@ ${refCsv}` : ""}`);
           [vue.h("span", { "aria-hidden": "true" }, "\u21C6"), vue.h("span", t("table.scrollHint"))]
         ) : null,
         buildContextMenuSection(),
+        buildPinMenuSection(),
         buildFilterPanelSection(),
         buildAuditPanelSection()
       ].filter((n) => n !== null);
@@ -16156,16 +17621,11 @@ var IrisTree = vue.defineComponent({
       return out;
     });
     const checkNodes = vue.computed(() => {
-      const out = [];
-      const walk = (nodes, parentKey) => {
-        for (const node of nodes) {
-          out.push({ key: node.id, parentKey, disabled: node.disabled });
-          const kids = node.children ?? lazyCache.value.get(node.id);
-          if (kids && kids.length > 0) walk(kids, node.id);
-        }
-      };
-      walk(props.nodes, void 0);
-      return out;
+      return core.flattenTreeSelectionNodes(props.nodes, {
+        getKey: (node) => node.id,
+        getChildren: (node) => node.children ?? lazyCache.value.get(node.id),
+        isDisabled: (node) => node.disabled === true
+      });
     });
     let checkModel = core.createTreeSelection({
       nodes: checkNodes.value,
@@ -16573,7 +18033,7 @@ var ARROW_BTN = {
   fontSize: "var(--iris-font-size-xl, 18px)",
   lineHeight: "1"
 };
-function prefersReducedMotion() {
+function prefersReducedMotion2() {
   return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
 function flattenSlides(nodes) {
@@ -16621,7 +18081,7 @@ var IrisCarousel = vue.defineComponent({
     };
     const start = () => {
       stop();
-      if (!props.autoplay || prefersReducedMotion()) return;
+      if (!props.autoplay || prefersReducedMotion2()) return;
       timer = setInterval(() => {
         if (props.pauseOnHover && hovered.value || focusedWithin.value) return;
         const list = flattenSlides(slots.default?.() ?? []);
@@ -17395,7 +18855,7 @@ var IrisWatermark = vue.defineComponent({
     );
   }
 });
-function prefersReducedMotion2() {
+function prefersReducedMotion3() {
   return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
 var resolve = (target) => (target ? target() : window) ?? window;
@@ -17433,7 +18893,7 @@ var IrisBackTop = vue.defineComponent({
     });
     const scrollToTop = () => {
       if (!el) return;
-      const b = prefersReducedMotion2() ? "auto" : props.behavior;
+      const b = prefersReducedMotion3() ? "auto" : props.behavior;
       if (typeof el.scrollTo === "function") {
         el.scrollTo({ top: 0, behavior: b });
       } else {
@@ -18921,7 +20381,7 @@ var IrisFloatButton = vue.defineComponent({
     };
   }
 });
-function prefersReducedMotion3() {
+function prefersReducedMotion4() {
   return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
 var resolve3 = (target) => (target ? target() : window) ?? window;
@@ -18965,7 +20425,7 @@ var IrisAnchor = vue.defineComponent({
       if (!node) return;
       if (typeof node.scrollIntoView === "function") {
         node.scrollIntoView({
-          behavior: prefersReducedMotion3() ? "auto" : "smooth",
+          behavior: prefersReducedMotion4() ? "auto" : "smooth",
           block: "start"
         });
       }
@@ -20136,7 +21596,7 @@ var IrisGauge = vue.defineComponent({
     };
   }
 });
-function prefersReducedMotion4() {
+function prefersReducedMotion5() {
   return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
 var IrisMarquee = vue.defineComponent({
@@ -20155,7 +21615,7 @@ var IrisMarquee = vue.defineComponent({
     let anim = null;
     vue.onMounted(() => {
       const el = trackEl.value;
-      if (!el || typeof el.animate !== "function" || prefersReducedMotion4()) return;
+      if (!el || typeof el.animate !== "function" || prefersReducedMotion5()) return;
       const frames = props.direction === "left" ? [{ transform: "translateX(0%)" }, { transform: "translateX(-50%)" }] : [{ transform: "translateX(-50%)" }, { transform: "translateX(0%)" }];
       anim = el.animate(frames, {
         duration: Math.max(1, props.duration) * 1e3,
@@ -21436,7 +22896,7 @@ var IrisColorPicker = vue.defineComponent({
         color: "var(--iris-foreground)",
         border: "1px solid var(--iris-border)",
         borderRadius: "var(--iris-radius-sm, 4px)",
-        fontSize: "12px",
+        fontSize: "var(--iris-font-size-xs, 12px)",
         fontFamily: "inherit",
         textAlign: "center"
       };
@@ -21530,7 +22990,7 @@ var IrisColorPicker = vue.defineComponent({
                     height: "4px",
                     transform: "translateY(-50%)",
                     border: "2px solid #fff",
-                    borderRadius: "2px",
+                    borderRadius: "var(--iris-radius-sm, 4px)",
                     boxShadow: "0 0 0 1px rgba(0,0,0,.4)",
                     pointerEvents: "none"
                   }
@@ -21582,7 +23042,7 @@ var IrisColorPicker = vue.defineComponent({
                 display: "flex",
                 gap: "6px",
                 alignItems: "center",
-                fontSize: "12px"
+                fontSize: "var(--iris-font-size-xs, 12px)"
               }
             },
             [
@@ -21664,12 +23124,12 @@ function defaultFilter(query, item) {
   if (!q) return 0;
   const haystacks = [item.label, ...item.keywords ?? []].map((s) => s.toLowerCase());
   let best = null;
-  for (const h137 of haystacks) {
+  for (const h139 of haystacks) {
     let qi = 0;
     let lastIdx = -1;
     let score = 0;
-    for (let i = 0; i < h137.length && qi < q.length; i += 1) {
-      if (h137[i] === q[qi]) {
+    for (let i = 0; i < h139.length && qi < q.length; i += 1) {
+      if (h139[i] === q[qi]) {
         score += lastIdx === -1 ? i : i - lastIdx - 1;
         lastIdx = i;
         qi += 1;
@@ -23945,6 +25405,18 @@ exports.useFloating = useFloating;
 exports.useFocusTrap = useFocusTrap;
 exports.useForm = useForm;
 exports.useFormContext = useFormContext;
+exports.useGridClipboard = useGridClipboard;
+exports.useGridColumns = useGridColumns;
+exports.useGridCore = useGridCore;
+exports.useGridEditing = useGridEditing;
+exports.useGridExpansion = useGridExpansion;
+exports.useGridFiltering = useGridFiltering;
+exports.useGridPagination = useGridPagination;
+exports.useGridRange = useGridRange;
+exports.useGridRows = useGridRows;
+exports.useGridSelection = useGridSelection;
+exports.useGridSorting = useGridSorting;
+exports.useGridVirtual = useGridVirtual;
 exports.useGroupedView = useGroupedView;
 exports.useI18n = useI18n;
 exports.useMachine = useMachine;