@iris-ui-kit/vue 0.2.36 → 0.2.38

package/dist/index.js

@@ -4,36 +4,38 @@ import { useBodyScrollLock, useFocusTrap } from './chunk-LQ2YAOYR.js';
 export { __getBodyScrollLockCount, __resetBodyScrollLock, useBodyScrollLock, useFocusTrap } from './chunk-LQ2YAOYR.js';
 export { IrisGrid } from './chunk-IN3DQ55U.js';
 import './chunk-4FQ7XF52.js';
-import { useDataState } from './chunk-S43IHHBU.js';
-export { DATA_STATE_CLASS, __resetDataStateStyles, installDataStateStyles, useDataState, usePrefersReducedMotion } from './chunk-S43IHHBU.js';
+import { useDataState, usePrefersReducedMotion } from './chunk-U635XRYU.js';
+export { DATA_STATE_CLASS, __resetDataStateStyles, installDataStateStyles, useDataState, usePrefersReducedMotion } from './chunk-U635XRYU.js';
 export { IrisProvider, PluginStoreContextKey, usePlugin, usePluginStore } from './chunk-MO7AAXA6.js';
 export { createClientFetcher, createResourceController, useResourceController } from './chunk-25NYWSXP.js';
 import { IrisCheckbox, IrisFormField, IrisInput, IrisButton } from './chunk-W64OMUBD.js';
 export { IrisAlert, IrisButton, IrisCheckbox, IrisDashboardTemplate, IrisDivider, IrisFormField, IrisInput, IrisLoginTemplate, IrisPasswordInput } from './chunk-W64OMUBD.js';
 export { IrisContainer, IrisDashboardCard, IrisDashboardGrid, IrisStack } from './chunk-3R3QDLJC.js';
 export { IrisSkinKey, SkinProvider, SkinResolutionError, applySkin, builtinSkins, createSkinCatalog, createSkinEngine, createSkinRegistry, darkSkin, lightSkin, loadSkin, localStorageSkinStorage, memorySkinStorage, renderSkinStyle, resolveSkin, skinBootScript, skinError, skinToCssEntries, useSkin, useSkinContext, validateSkin } from './chunk-UPC4GN3F.js';
-export { DropdownContextKey, IrisAdminBreadcrumb, IrisAdminLayout, IrisAdminTabs, IrisBreadcrumb, IrisBreadcrumbItem, IrisDropdown, IrisDropdownItem, IrisDropdownMenu, IrisDropdownSeparator, IrisDropdownTrigger, IrisIcon, IrisNavMenu, createAdminPreferences, createTabsNav, filterNavByAccess, findNavNode, findNavPath, firstLeaf, flattenNav, isBranch, isClosable, localStorageAdminPreferencesStorage, nodeAllowsRoles, useAdminPreferences, useAdminShell, useTabsNav, visibleNav } from './chunk-FZI5BGWH.js';
+export { DropdownContextKey, IrisAdminBreadcrumb, IrisAdminLayout, IrisAdminTabs, IrisBreadcrumb, IrisBreadcrumbItem, IrisDropdown, IrisDropdownItem, IrisDropdownMenu, IrisDropdownSeparator, IrisDropdownTrigger, IrisIcon, IrisNavMenu, createAdminPreferences, createTabsNav, filterNavByAccess, findNavNode, findNavPath, firstLeaf, flattenNav, isBranch, isClosable, localStorageAdminPreferencesStorage, nodeAllowsRoles, useAdminPreferences, useAdminShell, useTabsNav, visibleNav } from './chunk-IFRH33BT.js';
 import { useFloating, useDismiss } from './chunk-IPR5JAVF.js';
 export { useDismiss, useFloating } from './chunk-IPR5JAVF.js';
 import { useMachine } from './chunk-NNOF7KUH.js';
 export { useMachine } from './chunk-NNOF7KUH.js';
+export { IrisThemeKey, ThemeProvider, useColorScheme, useDirection, useTheme, useThemeContext } from './chunk-ZTPIXL7Q.js';
 import { findFirstElement, mergeSlotProps, composeRefs } from './chunk-F77KIPOH.js';
 export { IrisSlot, composeRefs, findFirstElement, mergeSlotProps } from './chunk-F77KIPOH.js';
 export { IrisHeaderLayout, IrisSidebarLayout } from './chunk-3V46HGRC.js';
-export { IrisThemeKey, ThemeProvider, useColorScheme, useDirection, useTheme, useThemeContext } from './chunk-ZTPIXL7Q.js';
 export { useAsyncResource, usePaginatedResource } from './chunk-SJB5DIIY.js';
 import { useDrag } from './chunk-IOMKC5OI.js';
 export { IrisClickOutside, IrisCompose, IrisHotkey, IrisLongPress, IrisMovable, IrisResizable, useDrag } from './chunk-IOMKC5OI.js';
 export { IrisSortable, SORTABLE_ITEM_ATTR } from './chunk-W3B6E5GN.js';
 export { createClientDataSource, createDataSource, createGroupedView, useDataSource, useGroupedView } from './chunk-QBFYIDY7.js';
 export { IrisErrorBoundary } from './chunk-3547J6IN.js';
+import { useI18n } from './chunk-TCAXRWT6.js';
+export { I18nInjectionKey, IrisI18nProvider, useI18n } from './chunk-TCAXRWT6.js';
 export { FormInjectionKey, IrisForm, useField, useFieldArray, useForm, useFormContext } from './chunk-IAG64CHL.js';
+import { useGridCore, useGridColumns, useGridSorting, useGridFiltering, useGridRows, useGridSelection, useGridExpansion, useGridEditing, useGridRange, useGridClipboard } from './chunk-5Q3JCKNE.js';
+export { useGridClipboard, useGridColumns, useGridCore, useGridEditing, useGridExpansion, useGridFiltering, useGridPagination, useGridRange, useGridRows, useGridSelection, useGridSorting, useGridVirtual } from './chunk-5Q3JCKNE.js';
 import { useStore } from './chunk-75GSYEJS.js';
 export { useStore, useStoreSelector } from './chunk-75GSYEJS.js';
-import { useI18n } from './chunk-TCAXRWT6.js';
-export { I18nInjectionKey, IrisI18nProvider, useI18n } from './chunk-TCAXRWT6.js';
 import { defineComponent, computed, watch, ref, useId, provide, inject, h, nextTick, Teleport, onScopeDispose, Fragment, onMounted, watchEffect, onBeforeUnmount, onBeforeMount, shallowRef, toValue, Comment, onUnmounted } from 'vue';
-import { createFloatingMachine, createHoverIntent, createVirtualizer, createKeyboardNav, getPageRange, createSelectionModel, formatClock, flattenLeafColumns, buildHeaderMatrix, detectColumnType, seedFormValues, createExpansion, createAuditLog, flattenTree, withSortedChildren, mergeFormFilters, createTreeSelection, createCellRange, createSortable, compareStates, createStore, firstEnabledIndex, createCalendarNav, clampDate, startOfMonth, isSameMonth, buildMonthMatrix, getWeekdayNames, formatMonthYear, startOfDay, endOfMonth, isSameDay, isOutOfRange, formatLocalISO, hexToRgba, rgbaToHsva, hsvaToRgba, rgbToHex, addMonths, RESPONSIVE_NARROW_WIDTH, computeResponsiveColumns, createRemoteTableSource, memoizedFormulaValue, readTableViews, computeVirtualRange, toCsvRows, removeRowsFromList, tableDisplayText, aggregate, previewColumnsFromRows, nextEnabledIndex, copyText, clamp01, rowsFromCsv, compareValues, TABLE_VIEWS_SAVE_ITEM, uniqueTableTabs, leftPinnedCount, pinnedCountFromBudget, toCsv, createAutoDismiss, validateEditRulesAsync, writeClipboardText, serializeTableRange, nextGridCell, createReconnectingSource, createResilientFetcher, createDisposableScope, downloadFile, toSpreadsheetXml, generateId, buildFormValues, applyTableMask, writeTableViews } from '@iris-ui-kit/core';
+import { createFloatingMachine, createHoverIntent, createVirtualizer, createKeyboardNav, getPageRange, createSelectionModel, formatClock, flattenLeafColumns, buildHeaderMatrix, detectColumnType, createRecentFilters, seedFormValues, createAuditLog, flattenTree, withSortedChildren, mergeFormFilters, flattenTreeSelectionNodes, createTreeSelection, createSortable, compareStates, createStore, firstEnabledIndex, createCalendarNav, clampDate, startOfMonth, isSameMonth, buildMonthMatrix, getWeekdayNames, formatMonthYear, startOfDay, endOfMonth, isSameDay, isOutOfRange, formatLocalISO, hexToRgba, rgbaToHsva, hsvaToRgba, rgbToHex, addMonths, RESPONSIVE_NARROW_WIDTH, computeResponsiveColumns, createRemoteTableSource, readTableViews, reconcileTreeRows, computeVirtualRange, toCsvRows, applyTableMask, tableDisplayText, aggregate, previewColumnsFromRows, reorderTreeRows, nextEnabledIndex, copyText, clamp01, rowsFromCsv, memoizedFormulaValue, compareValues, TABLE_VIEWS_SAVE_ITEM, uniqueTableTabs, createUndoStack, normalizeKeymap, matchTableKey, pinnedCountFromBudget, toCsv, splitSearchHits, createAutoDismiss, validateEditRulesAsync, writeClipboardText, nextGridCell, createReconnectingSource, createResilientFetcher, createDisposableScope, downloadFile, toSpreadsheetXml, generateId, buildFormValues, writeTableViews } from '@iris-ui-kit/core';
 export { addDays, addMonths, buildMonthMatrix, clamp01, clampDate, composeEventHandlers, createFloatingMachine, createMachine, createStore, endOfMonth, formatLocalISO, formatMonthYear, generateId, getPageRange, getWeekdayNames, hexToRgba, hsvToRgb, hsvaToRgba, isOutOfRange, isSameDay, isSameMonth, mergeProps, parseCsv, rgbToHex, rgbToHsv, rgbaToHsva, startOfDay, startOfMonth } from '@iris-ui-kit/core';
 import { getDirection } from '@iris-ui-kit/theme';
 export { applyTheme, createThemeStore, getCssVar, toCssVarName } from '@iris-ui-kit/theme';
@@ -3182,7 +3184,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) {
@@ -3482,7 +3484,7 @@ var CSS2 = `
   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"] {
@@ -3539,8 +3541,8 @@ var IrisSkeleton = defineComponent({
     onMounted(installSkeletonStyles);
     const style = computed(() => {
       const w = props.width !== void 0 ? toCss(props.width) : defaultWidth(props.shape);
-      const h102 = props.height !== void 0 ? toCss(props.height) : defaultHeight(props.shape, props.width);
-      return { width: w, height: h102 };
+      const h104 = props.height !== void 0 ? toCss(props.height) : defaultHeight(props.shape, props.width);
+      return { width: w, height: h104 };
     });
     return () => h("div", {
       ...attrs,
@@ -4173,7 +4175,7 @@ var IrisCard = 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"
       };
@@ -5194,7 +5196,7 @@ var IrisKbd = 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"
@@ -5930,6 +5932,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,
@@ -5943,6 +5952,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,
@@ -5961,6 +5978,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 },
@@ -5969,6 +5988,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
@@ -6020,6 +6049,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
@@ -6028,6 +6064,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
@@ -6069,12 +6107,12 @@ var RESIZE_STEP = 16;
 function isEditableColumn(column) {
   return !!column.editable && !column.formula;
 }
-function getCellValue(row, column) {
-  if (column.formula) return memoizedFormulaValue(column.formula, row);
+function getCellValue(row, column, formulaTables) {
+  if (column.formula) return 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) => {
@@ -6082,7 +6120,11 @@ function withComputedFormulaCells(rows, columns) {
     for (const col of formulaCols) {
       const key = col.dataIndex ?? col.key;
       const next = shadow ?? { ...row };
-      next[key] = memoizedFormulaValue(col.formula, row);
+      next[key] = memoizedFormulaValue(
+        col.formula,
+        row,
+        formulaTables
+      );
       shadow = next;
     }
     return shadow;
@@ -6113,7 +6155,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 = computeVirtualRange({
     itemCount: columns.length,
@@ -6125,7 +6167,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;
 }
@@ -6134,18 +6176,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) => compareValues(getCellValue(a, col), getCellValue(b, col));
+  return (a, b) => 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) => {
@@ -6156,93 +6201,6 @@ function buildMultiSortComparator(leafColumns, state) {
     return 0;
   };
 }
-function useTableSort(data, options) {
-  const sortProp = computed(() => options.sort === void 0 ? void 0 : toValue(options.sort));
-  const internalSortValue = ref(options.defaultSort ?? null);
-  const sortState = 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 = computed(() => toValue(options.multiSort) === true);
-  const multiSortProp = computed(
-    () => options.multiSortState === void 0 ? void 0 : toValue(options.multiSortState)
-  );
-  const internalMultiSort = ref(options.defaultMultiSort ?? []);
-  const multiSortState = 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 = computed(() => {
-    const s = sortState.value;
-    if (!s) return null;
-    const col = 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 = computed(
-    () => buildMultiSortComparator(toValue(options.leafColumns), multiSortState.value)
-  );
-  const sortedData = 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)) {
@@ -6359,6 +6317,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) => 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;
@@ -6449,13 +6438,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(
       h("span", { style: { fontWeight: 600, color: "var(--iris-foreground)" } }, tb.title)
     );
   }
+  toolChildren.push(...renderUndoToolbar(ctx.undo));
   toolChildren.push(h("div", { style: { flex: "1" } }));
   if (tb?.onRefresh) {
     toolChildren.push(
@@ -6731,6 +6721,15 @@ function renderContextMenuSection(ctx) {
   );
   return h(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;
@@ -6763,6 +6762,49 @@ function renderFilterPanelSection(ctx) {
       }
     },
     [
+      ...ctx.recent.length > 0 ? [
+        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) => 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)
+          )
+        ),
+        h("div", {
+          style: {
+            borderTop: "1px solid var(--iris-border)",
+            margin: "var(--iris-space-xxs, 4px) 0"
+          }
+        })
+      ] : [],
       ...options.map(
         (opt) => h(
           "div",
@@ -7246,6 +7288,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 ? 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(
@@ -7256,7 +7299,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",
@@ -7267,6 +7313,7 @@ function renderTableSummaryRow(ctx) {
             overflow: "hidden",
             textOverflow: "ellipsis",
             ...ctx.visibleColSet ? { gridColumnStart: String(ctx.colTrack(columnIndex)) } : {},
+            ...fadeStyle ?? {},
             ...ctx.pinnedStyle(column.key)
           }
         },
@@ -7290,6 +7337,187 @@ function renderTableSummaryRow(ctx) {
     summaryCells
   );
 }
+var FADE_DURATION_MS = 200;
+function createTableColumnFade(options) {
+  const fadeOverlay = shallowRef({});
+  const previousVisibility = 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();
+    }
+  };
+  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 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);
+    }
+  );
+  onBeforeUnmount(() => {
+    disposed = true;
+    cancelFadeSchedule();
+  });
+  const effectiveVisibility = 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 = 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 = 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 ? 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 = 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 h("div", { role: "row", "data-iris-table-row": "error", style: ctx.stateRowStyle }, [
@@ -7399,24 +7627,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 writeClipboardText(
-      serializeTableRange(
-        rows,
-        options.columns(),
-        range,
-        clip?.copyFormat,
-        clip?.copyWithFormat === true
-      )
-    );
+    const text = options.serializeRange(clip?.copyFormat, clip?.copyWithFormat === true);
+    if (text !== null) void 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) => {
@@ -7429,11 +7658,11 @@ function createTableKeyboard(options) {
     copyActiveRange
   };
 }
-function computeResponsiveTableColumns(columns, containerWidth, leadingWidth, widthOf) {
+function computeResponsiveTableColumns(columns, containerWidth, leadingWidth, widthOf, pinOf) {
   if (containerWidth <= 0 || containerWidth >= 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 = computeResponsiveColumns(columns, Math.max(1, containerWidth - leadingWidth), {
     widthOf: (column) => widthOf(column),
     isPinned: (column) => isPinned(column),
@@ -7448,6 +7677,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);
@@ -7469,15 +7699,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];
@@ -7575,16 +7842,24 @@ function createTableRowTarget(root) {
   };
   return { find, scrollTo, goTo, dispose };
 }
+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 = 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 = 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;
   });
@@ -7603,7 +7878,7 @@ function createTablePinnedDrag(options) {
   const resolvePinnedCount = (dx) => {
     const columns = options.columns();
     const cap = firstRightPinnedIndex.value;
-    const current = 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];
@@ -7621,14 +7896,14 @@ function createTablePinnedDrag(options) {
     const columns = options.columns();
     const cap = firstRightPinnedIndex.value;
     const clamped = Math.max(0, Math.min(cap, count));
-    const current = 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);
   };
@@ -7708,6 +7983,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;
+    }
+  };
+  onMounted(() => {
+    syncListener();
+    stopGateWatch = watch(gate, syncListener);
+  });
+  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();
+  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 = normalizeKeymap();
+  return (event) => {
+    if (!ctx.enabled() || event.defaultPrevented) return;
+    if (!isInsideTableRoot(ctx.root, event.target)) return;
+    if (isTextControl(event.target) || ctx.isEditing()) return;
+    if (matchTableKey(event, bindings.undo)) {
+      event.preventDefault();
+      onUndo();
+    } else if (matchTableKey(event, bindings.redo)) {
+      event.preventDefault();
+      onRedo();
+    }
+  };
+}
+function createTableUndoRuntime(ctx) {
+  const stack = createUndoStack({
+    maxHistory: 100,
+    initial: [...ctx.initialRows() ?? []],
+    equals: sameRowList
+  });
+  const tick = 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 = computed(() => {
+    runtime.readTick();
+    return stack.canUndo();
+  });
+  const canRedo = 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 = splitSearchHits(text, query);
+  if (!segments) return node;
+  return segments.map(
+    (segment, index) => index % 2 === 1 ? h(
+      "mark",
+      {
+        key: index,
+        "data-iris-search-hit": "",
+        style: SEARCH_HIT_STYLE
+      },
+      segment
+    ) : segment
+  );
+}
 function useTableImport(isPreviewEnabled, getOnImport) {
   const importFileInput = ref(null);
   const importPreviewRows = ref(null);
@@ -7837,7 +8324,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") {
@@ -7945,6 +8432,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(
@@ -7955,8 +8443,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}`,
@@ -7974,7 +8467,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)" } : {}
             }
           },
           [
@@ -8222,6 +8717,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 = defineComponent({
   name: "IrisTable",
   inheritAttrs: false,
@@ -8234,13 +8770,22 @@ var IrisTable = 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);
+    watch(
+      () => props.columnFade,
+      (enabled) => {
+        if (enabled) ensureTableStyles(true);
+      }
+    );
+    const getCellValue2 = (row, column) => getCellValue(row, column, props.formulaTables);
     const { t } = useI18n();
     const densityState = ref("comfortable");
     const effectiveDensity = computed(() => {
@@ -8254,17 +8799,102 @@ var IrisTable = defineComponent({
       () => props.importPreview,
       () => props.toolbar?.onImport
     );
-    const responsiveWidth = ref(0);
-    const internalWidths = ref({});
-    const effectiveWidths = 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 = computed(() => {
-      const vis = props.columnVisibility;
-      if (!vis) return props.columns;
-      return props.columns.filter((c) => vis[c.key] !== false);
+    const pinnedPropControlled = 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;
+    };
+    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 = ref(props.columnOrder !== void 0);
+    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 = computed(
+      () => orderPropControlled.value ? props.columnOrder ?? [] : columnsFeature.state.value.order
+    );
+    const uncontrolledWidths = ref({});
+    const widthPropControlled = ref(props.columnWidths !== void 0);
+    watch(
+      () => props.columnVisibility,
+      (next) => columnsFeature.model.syncVisibility(next ?? {}),
+      { immediate: true }
+    );
+    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 = ref(0);
+    const effectiveWidths = computed(
+      () => props.columnWidths !== void 0 ? props.columnWidths : columnsFeature.state.value.widths
+    );
+    const effectiveVisibility = computed(
+      () => columnsFeature.state.value.visibility
+    );
+    const columnFadeEnabled = computed(() => props.columnFade);
+    const reducedMotion = usePrefersReducedMotion(columnFadeEnabled);
+    const columnFade = createTableColumnFade({
+      visibility: () => effectiveVisibility.value,
+      enabled: () => columnFadeEnabled.value,
+      reducedMotion,
+      columns: computed(() => props.columns)
     });
+    const {
+      displayColumns: sourceDisplayColumns,
+      columnFadeAttr,
+      columnFadeStyle,
+      columnFadeAttrs,
+      columnFadeActive,
+      fadeByLeaf,
+      isCollapsed: isColumnFadeCollapsed
+    } = columnFade;
     const detectedTypes = ref({});
     const detectTypesDone = ref(false);
     const detectedDisplayColumns = computed(() => {
@@ -8280,13 +8910,17 @@ var IrisTable = defineComponent({
       const width = effectiveWidths.value[column.key] ?? resolveInitialWidth(column);
       return Number.isFinite(width) && width >= 0 ? width : resolveInitialWidth(column);
     };
+    const orderedDisplayColumns = computed(
+      () => applyTableColumnOrder(detectedDisplayColumns.value, effectiveColumnOrder.value)
+    );
     const responsiveResult = 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 = computed(
       () => responsiveResult.value.columns
@@ -8339,6 +8973,7 @@ var IrisTable = defineComponent({
     const tableData = computed(
       () => proxyCtrl.proxy.value ? proxyCtrl.liveData.value : localRowsOverride.value ?? props.data ?? []
     );
+    const committedList = createCommittedList(() => tableData.value);
     watch(
       [() => props.autoDetectTypes, tableData, () => props.columns],
       () => {
@@ -8348,38 +8983,76 @@ var IrisTable = defineComponent({
         for (const column of flattenLeafColumns(props.columns)) {
           if (column.formula) continue;
           next[column.key] = 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: 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 });
       }
     });
+    watch(
+      () => props.sort,
+      (next) => next !== void 0 && sorting.model.syncSort(next ?? null),
+      { immediate: true }
+    );
+    watch(
+      () => props.multiSortState,
+      (next) => next !== void 0 && sorting.model.syncMultiSort(next ?? []),
+      { immediate: true }
+    );
+    const internalSort = computed(
+      () => props.sort !== void 0 ? props.sort ?? null : sorting.sort.value
+    );
+    const multiSortState = 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 = computed(
+      () => buildMultiSortComparator(
+        leafColumns.value,
+        internalSort.value ? [internalSort.value] : [],
+        props.formulaTables
+      )
+    );
+    const multiSortComparator = computed(() => buildMultiSortComparator(leafColumns.value, multiSortState.value, props.formulaTables));
+    const sortedRows = 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,
@@ -8387,6 +9060,34 @@ var IrisTable = defineComponent({
       onActiveViewChange: (key) => props.onActiveViewChange?.(key)
     });
     const sortedData = computed(() => remoteSort.value ? tableData.value : sortedRows.value);
+    const filtering = useGridFiltering(gridCore, {
+      defaultFilters: props.filters,
+      defaultFilterValues: props.filterValues,
+      onFilterValuesChange: (next) => props.onFilterValuesChange?.(next)
+    });
+    watch(
+      () => props.filters,
+      (next) => next !== void 0 && filtering.model.syncFilters(next),
+      { immediate: true }
+    );
+    watch(
+      () => props.filterValues,
+      (next) => next !== void 0 && filtering.model.syncFilterValues(next),
+      { immediate: true }
+    );
+    const effectiveFilters = computed(
+      () => props.filters !== void 0 ? props.filters : filtering.filters.value
+    );
+    const effectiveFilterValues = computed(
+      () => props.filterValues !== void 0 ? props.filterValues : filtering.filterValues.value
+    );
+    const recent = createRecentFilters();
+    const recentEntries = shallowRef(recent.list());
+    onScopeDispose(
+      recent.subscribe(() => {
+        recentEntries.value = recent.list();
+      })
+    );
     watch([internalSort, () => props.multiSort, remoteSort, () => proxyCtrl.proxy.value], () => {
       if (!proxyCtrl.proxy.value || !remoteSort.value || props.multiSort) return;
       proxyCtrl.setParams({ sort: internalSort.value });
@@ -8412,7 +9113,7 @@ var IrisTable = defineComponent({
       if (formDraft.value[key] === value) return;
       formDraft.value = { ...formDraft.value, [key]: value };
     };
-    const mergedProxyFilters = (form) => mergeFilterValues(mergeFormFilters(props.filters ?? {}, form), props.filterValues ?? {});
+    const mergedProxyFilters = (form) => mergeFilterValues(mergeFormFilters(effectiveFilters.value, form), effectiveFilterValues.value);
     const handleFormSubmit = () => {
       const values = buildFormValues(props.formConfig?.fields, formDraft.value);
       props.formConfig?.onSearch?.(values);
@@ -8434,7 +9135,7 @@ var IrisTable = defineComponent({
       }
     };
     watch(
-      [formApplied, () => props.filters, () => props.filterValues],
+      [formApplied, effectiveFilters, effectiveFilterValues],
       () => {
         if (proxyCtrl.proxy.value && remoteFilter.value) {
           proxyCtrl.setParams({
@@ -8444,22 +9145,39 @@ var IrisTable = 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);
+      }
+    });
+    watch(tableData, (rows) => {
+      committedList.sync(rows);
+      gridRows.model.sync(rows);
+    });
     const selControlled = computed(() => props.selection !== void 0);
-    const selectionModel = 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 = shallowRef(selectionModel.get());
-    onBeforeUnmount(
-      selectionModel.store.subscribe((keys) => {
-        selectedKeys.value = keys;
-      })
-    );
     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 = computed(
       () => selControlled.value ? props.selection : selectedKeys.value
@@ -8468,17 +9186,11 @@ var IrisTable = defineComponent({
       if (selControlled.value) selectionModel.sync(props.selection);
     };
     const hasDetail = computed(() => props.renderDetail !== void 0);
-    const expansion = 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 = shallowRef(expansion.get());
-    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];
@@ -8497,21 +9209,17 @@ var IrisTable = defineComponent({
       auditRowsRef.value = next;
     };
     const treeMode = computed(() => props.getSubRows !== void 0 || props.lazyLoad !== void 0);
-    const lazyChildren = ref(/* @__PURE__ */ new Map());
     const lazyLoading = ref(/* @__PURE__ */ new Set());
     let lazyEpoch = 0;
     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 = computed(
       () => treeMode.value ? flattenTree(sortedData.value, {
         getKey: (r) => String(r[props.rowKey]),
@@ -8524,9 +9232,9 @@ var IrisTable = defineComponent({
     );
     const filteredData = computed(() => {
       if (remoteFilter.value) return sortedData.value;
-      const merged = proxyCtrl.proxy.value ? props.filters ?? {} : mergeFormFilters(props.filters ?? {}, formApplied.value);
+      const merged = proxyCtrl.proxy.value ? effectiveFilters.value : 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;
@@ -8534,12 +9242,12 @@ var IrisTable = 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;
       });
@@ -8547,28 +9255,48 @@ var IrisTable = defineComponent({
     const bodyData = 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 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 = computed(
       () => props.treeSelectionCascade && props.selectable === "multi" && treeMode.value
     );
     const treeSelectionNodes = 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 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);
@@ -8639,51 +9367,8 @@ var IrisTable = defineComponent({
       }
       selectionModel.set([...allRowIds.value]);
     };
-    const editingCellId = ref(null);
-    const editingColumnKey = ref(null);
-    const editingDraft = ref("");
-    const editError = ref(null);
     const editorInputRef = 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 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 };
-        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({
@@ -8695,43 +9380,95 @@ var IrisTable = 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 = computed(() => {
+      const target = editingState.value.editing;
+      return target ? cellId(target.rowKey, target.columnKey) : null;
+    });
+    const editingColumnKey = computed(() => editingState.value.editing?.columnKey ?? null);
+    const editingDraft = computed(() => String(editingState.value.draft ?? ""));
+    const editError = 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 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 = computed(() => props.editConfig?.mode === "row");
     const rowSessions = ref(/* @__PURE__ */ new Map());
     const rowEditing = 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
@@ -8747,7 +9484,7 @@ var IrisTable = 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) {
@@ -8799,7 +9536,7 @@ var IrisTable = 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
@@ -8814,6 +9551,7 @@ var IrisTable = defineComponent({
       rowEditorRefs,
       editorInputRef,
       editingDraft,
+      setEditingDraft,
       editError,
       commitEdit,
       cancelEdit,
@@ -8821,7 +9559,7 @@ var IrisTable = 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?.(applyTableMask(raw, col), row) ?? "";
       }
     };
@@ -8838,7 +9576,7 @@ var IrisTable = 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) ? [
         h(
           "button",
           {
@@ -8864,8 +9602,18 @@ var IrisTable = 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();
@@ -8898,21 +9646,30 @@ var IrisTable = defineComponent({
     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 (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 (changed) internalWidths.value = seeded;
+        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);
@@ -8948,7 +9705,7 @@ var IrisTable = 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
@@ -8961,18 +9718,136 @@ var IrisTable = 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 = createCellRange();
-    const cellRangeState = shallowRef(cellRangeCtrl.getState());
-    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 = ref(null);
+    let tableDisposed = false;
+    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 = 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();
+    };
+    onMounted(armScrollTop);
+    watch(
+      [
+        () => props.scrollToTop,
+        () => Boolean(props.virtualScroll),
+        bodyData,
+        tableLoading,
+        tableError
+      ],
+      armScrollTop,
+      { flush: "post" }
+    );
+    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 h("div", { "data-iris-back-top-anchor": "", style: BACK_TOP_ANCHOR_STYLE }, [
+        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;
@@ -9005,7 +9880,17 @@ var IrisTable = 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 = ref(0);
@@ -9027,21 +9912,28 @@ var IrisTable = defineComponent({
         ro = null;
       });
     }
-    const visibleColSet = computed(
-      () => computeVisibleColSet(
+    const visibleColSet = 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 = 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);
         }
@@ -9049,7 +9941,7 @@ var IrisTable = 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);
         }
@@ -9095,12 +9987,24 @@ var IrisTable = 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 = createSortable();
     const rowDragState = shallowRef(rowDragCtrl.getState());
@@ -9149,16 +10053,66 @@ var IrisTable = 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 = 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 = [];
@@ -9207,6 +10161,9 @@ var IrisTable = 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 = [];
@@ -9215,8 +10172,7 @@ var IrisTable = 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: () => {
@@ -9231,13 +10187,13 @@ var IrisTable = defineComponent({
         return { page: s.params.page, pageSize: s.params.pageSize, total: s.total };
       },
       removeRows: (keys) => {
-        const { rows, removedKeys } = 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);
@@ -9246,12 +10202,12 @@ var IrisTable = 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;
@@ -9339,6 +10295,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,
@@ -9353,23 +10310,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 = ref(null);
+    const pinMenuAnchorRef = ref(null);
+    const pinMenuRef = ref(null);
+    const closePinMenu = () => {
+      if (pinMenuState.value) pinMenuState.value.open = false;
+    };
+    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);
+        }
+      }
+    };
+    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,
@@ -9411,6 +10425,41 @@ ${refCsv}` : ""}`);
       close: closeContextMenu,
       contextMenu: props.contextMenu
     });
+    const pinMenuOpen = 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
+    });
+    watch(pinMenuOpen, (open) => {
+      if (typeof document === "undefined") return;
+      if (open) document.addEventListener("scroll", closePinMenu, true);
+      else document.removeEventListener("scroll", closePinMenu, true);
+    });
+    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 = ref(null);
     const filterAnchorRef = ref(null);
     const filterPanelRef = ref(null);
@@ -9421,7 +10470,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 = computed(() => filterPanelState.value?.open === true);
@@ -9446,12 +10495,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];
@@ -9462,12 +10514,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";
@@ -9596,6 +10650,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
@@ -9696,7 +10757,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
@@ -9705,6 +10767,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",
@@ -9721,8 +10784,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)
             },
@@ -9900,7 +10964,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);
@@ -9913,7 +10977,11 @@ ${refCsv}` : ""}`);
               rowSessions.value.get(editCellId)
             ) : buildCellEditContent(row, col, index, editCellId);
           } else {
-            content = cellSlot?.({ row, index, value: getCellValue(row, col) }) ?? tableDisplayText(row, col, getCellValue);
+            content = cellSlot?.({ row, index, value: getCellValue2(row, col) }) ?? (props.searchHighlight ? (() => {
+              const displayValue = applyTableMask(getCellValue2(row, col), col);
+              const renderedValue = col.formatter ? col.formatter(displayValue, row) : displayValue;
+              return applySearchHighlight(renderedValue, props.searchHighlight);
+            })() : tableDisplayText(row, col, getCellValue2));
           }
           const treeIndent = treeMeta && ci === 0 ? buildTreeIndent(treeMeta, row) : null;
           const cellChildren = treeIndent ? [treeIndent, ...Array.isArray(content) ? content : [content]] : content;
@@ -9924,7 +10992,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,
@@ -9977,7 +11046,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
@@ -10007,7 +11077,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
             }
@@ -10104,8 +11174,11 @@ ${refCsv}` : ""}`);
         visibleColSet: visibleColSet.value,
         gridTemplate: gridTemplate.value,
         leadingCells: leadSummaryCells(),
+        columnFadeAttr,
+        columnFadeStyle,
         colTrack,
-        getCellValue,
+        getCellValue: getCellValue2,
+        pinOf,
         pinnedStyle
       }) : null;
       const rootNodes = [
@@ -10135,6 +11208,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,
@@ -10168,7 +11242,7 @@ ${refCsv}` : ""}`);
               ...attrs.style ?? {}
             }
           },
-          [headerRow, bodyNode, summaryRow, buildPagerSection()]
+          [headerRow, bodyNode, summaryRow, buildPagerSection(), buildBackTopSection()]
         ),
         props.responsive && responsiveOverflow.value && !props.printable ? h(
           "div",
@@ -10191,6 +11265,7 @@ ${refCsv}` : ""}`);
           [h("span", { "aria-hidden": "true" }, "\u21C6"), h("span", t("table.scrollHint"))]
         ) : null,
         buildContextMenuSection(),
+        buildPinMenuSection(),
         buildFilterPanelSection(),
         buildAuditPanelSection()
       ].filter((n) => n !== null);
@@ -11482,16 +12557,11 @@ var IrisTree = defineComponent({
       return out;
     });
     const checkNodes = 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 flattenTreeSelectionNodes(props.nodes, {
+        getKey: (node) => node.id,
+        getChildren: (node) => node.children ?? lazyCache.value.get(node.id),
+        isDisabled: (node) => node.disabled === true
+      });
     });
     let checkModel = createTreeSelection({
       nodes: checkNodes.value,
@@ -11899,7 +12969,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) {
@@ -11947,7 +13017,7 @@ var IrisCarousel = 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?.() ?? []);
@@ -12721,7 +13791,7 @@ var IrisWatermark = 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;
@@ -12759,7 +13829,7 @@ var IrisBackTop = 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 {
@@ -14247,7 +15317,7 @@ var IrisFloatButton = 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;
@@ -14291,7 +15361,7 @@ var IrisAnchor = defineComponent({
       if (!node) return;
       if (typeof node.scrollIntoView === "function") {
         node.scrollIntoView({
-          behavior: prefersReducedMotion3() ? "auto" : "smooth",
+          behavior: prefersReducedMotion4() ? "auto" : "smooth",
           block: "start"
         });
       }
@@ -15462,7 +16532,7 @@ var IrisGauge = defineComponent({
     };
   }
 });
-function prefersReducedMotion4() {
+function prefersReducedMotion5() {
   return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
 var IrisMarquee = defineComponent({
@@ -15481,7 +16551,7 @@ var IrisMarquee = defineComponent({
     let anim = null;
     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,
@@ -16762,7 +17832,7 @@ var IrisColorPicker = 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"
       };
@@ -16856,7 +17926,7 @@ var IrisColorPicker = 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"
                   }
@@ -16908,7 +17978,7 @@ var IrisColorPicker = defineComponent({
                 display: "flex",
                 gap: "6px",
                 alignItems: "center",
-                fontSize: "12px"
+                fontSize: "var(--iris-font-size-xs, 12px)"
               }
             },
             [
@@ -16990,12 +18060,12 @@ function defaultFilter(query, item) {
   if (!q) return 0;
   const haystacks = [item.label, ...item.keywords ?? []].map((s) => s.toLowerCase());
   let best = null;
-  for (const h102 of haystacks) {
+  for (const h104 of haystacks) {
     let qi = 0;
     let lastIdx = -1;
     let score = 0;
-    for (let i = 0; i < h102.length && qi < q.length; i += 1) {
-      if (h102[i] === q[qi]) {
+    for (let i = 0; i < h104.length && qi < q.length; i += 1) {
+      if (h104[i] === q[qi]) {
         score += lastIdx === -1 ? i : i - lastIdx - 1;
         lastIdx = i;
         qi += 1;