@mono-lit/helper 0.0.6 → 0.0.7

package/dist/{mono-button.shadow-CIBGisyo.js → mono-button.shadow-DqZMpcqY.js}

@@ -1,4 +1,4 @@
-import { _ as buildSizeStyle, a as __decorate, f as customElement, i as withShadowUtilityStyles, l as defineHybridPropAliases, r as toShadowCss, s as booleanStringConverter, t as flushSsrHydration } from "./hydration-flush-9AJE8FRl.js";
+import { _ as buildSizeStyle, a as __decorate, f as customElement, i as withShadowUtilityStyles, l as defineHybridPropAliases, r as toShadowCss, s as booleanStringConverter, t as flushSsrHydration } from "./hydration-flush-BaE9gN3C.js";
 import { t as dispatchMonoEvent } from "./mono-event-BPku9HpS.js";
 import { a as rateLimitHasChanged, i as rateLimitConverter, n as normalizeDebounce, r as normalizeThrottle, t as createRateLimiter } from "./rate-limit-e9Jlpl5l.js";
 import { LitElement, html, isServer, nothing, unsafeCSS } from "lit";

package/dist/{mono-data-chart-ChkelNT7.js → mono-data-chart-BAH9Zb3p.js}

@@ -1,8 +1,8 @@
 import { n as isPath, t as getFieldValue } from "./field-path-BabiMrrA.js";
-import { r as readAllRows } from "./data-source-read-FxqzQkk2.js";
+import { r as readAllRows } from "./data-source-read-Cp_h7NIf.js";
 import { n as andPredicates, r as compileFilterPredicate, t as andFilters } from "./filter-eval-ChDSaAUH.js";
 import { n as describeError, o as isCanceled } from "./normalize-error-D93O4q8g.js";
-import { a as resolveDataSourceOptions, d as createApplyGate, f as isRolledUp, h as monoArraySource, i as normalizeSortList, n as extraLoadOptions, o as toList, p as loadApply, r as mergeDataSourceOptions, u as summaryFilterOf } from "./data-source-options-QjuI73g8.js";
+import { a as resolveDataSourceOptions, d as createApplyGate, f as isRolledUp, h as monoArraySource, i as normalizeSortList, n as extraLoadOptions, o as toList, p as loadApply, r as mergeDataSourceOptions, u as summaryFilterOf } from "./data-source-options-lDR-g9Eb.js";
 import { t as arrayToODataString } from "./filter-odata-Bi27XUpQ.js";
 import { t as createNotifier } from "./notifier-BIrqUzRh.js";
 

package/dist/{mono-data-dropdown-DxpUUk2y.js → mono-data-dropdown-BsY5IuIo.js}

@@ -1,4 +1,4 @@
-import { t as monoDataGrid } from "./mono-data-grid-8jmeIXUU.js";
+import { t as monoDataGrid } from "./mono-data-grid-kV4jYu2g.js";
 import { t as createNotifier } from "./notifier-BIrqUzRh.js";
 
 //#region src/components/dropdown-table/mono-data-dropdown.ts
@@ -251,8 +251,22 @@ function monoDataDropdown(source = null, opts = {}) {
 	function setOpen(next) {
 		if (ctrl.open === next) return;
 		ctrl.open = next;
+		if (!next) pruneCache();
 		notify();
 	}
+	/**
+	* Drop cached rows no current key needs, once the cache has outgrown the selection.
+	*
+	* The cache exists to label chips whose row is not on the loaded page; it only ever grew —
+	* every key ever selected, and after a select-all every drained row — and was cleared only on
+	* `bind()`. Pruned on close, with slack, so toggling a few rows never thrashes it.
+	*/
+	function pruneCache() {
+		const keys = currentKeys();
+		if (cache.size <= keys.length * 2 + 200) return;
+		const keep = new Set(keys.map((k) => keyStr(normKey(k))));
+		for (const k of cache.keys()) if (!keep.has(k)) cache.delete(k);
+	}
 	function hasStore() {
 		const s = grid.dataSource;
 		return typeof s?.store === "function" && !!s.store();
@@ -265,6 +279,26 @@ function monoDataDropdown(source = null, opts = {}) {
 		for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
 		return out;
 	}
+	/**
+	* `run` over every part, at most `limit` requests in flight — the result order kept.
+	*
+	* A thousand preset keys are twenty `in` chunks (or ~67 OR-chain chunks in the fallback), and
+	* `Promise.all` over them fired every request at once: a burst a backend may throttle or reject,
+	* and that queues behind the browser's per-host connection cap anyway.
+	*/
+	async function mapLimited(parts, limit, run) {
+		const out = new Array(parts.length);
+		let next = 0;
+		const worker = async () => {
+			while (next < parts.length) {
+				const i = next++;
+				out[i] = await run(parts[i]);
+			}
+		};
+		await Promise.all(Array.from({ length: Math.min(limit, parts.length) }, worker));
+		return out;
+	}
+	const RESOLVE_CONCURRENCY = 4;
 	const selectFields = () => typeof displayExpr === "string" && displayExpr ? [keyExpr, displayExpr] : void 0;
 	async function resolveSelected() {
 		const missing = currentKeys().filter((k) => !cache.has(keyStr(normKey(k))));
@@ -274,14 +308,14 @@ function monoDataDropdown(source = null, opts = {}) {
 			const store = s.store();
 			let rows = [];
 			try {
-				rows = (await Promise.all(chunk(missing, 50).map((part) => store.load({
+				rows = (await mapLimited(chunk(missing, 50), RESOLVE_CONCURRENCY, (part) => store.load({
 					filter: [
 						keyExpr,
 						"in",
 						part
 					],
 					select: selectFields()
-				})))).flatMap(storeRows);
+				}))).flatMap(storeRows);
 			} catch {
 				const orFilter = (arr) => arr.map((v) => [
 					keyExpr,
@@ -292,10 +326,10 @@ function monoDataDropdown(source = null, opts = {}) {
 					"or",
 					b
 				] : b, null);
-				rows = (await Promise.all(chunk(missing, 15).map((part) => store.load({
+				rows = (await mapLimited(chunk(missing, 15), RESOLVE_CONCURRENCY, (part) => store.load({
 					filter: orFilter(part),
 					select: selectFields()
-				})))).flatMap(storeRows);
+				}))).flatMap(storeRows);
 			}
 			for (const row of rows) cacheRow(row?.[keyExpr], row);
 		} else if (typeof s?.data === "function") {
@@ -308,7 +342,39 @@ function monoDataDropdown(source = null, opts = {}) {
 		}
 		notify();
 	}
-	const offGrid = grid.subscribe(() => notify());
+	/**
+	* Forward a grid notify only when something THIS controller's readers use has moved.
+	*
+	* Forwarding every one re-rendered the whole `<mono-dropdown-table>` (chips, `selectedItems()`),
+	* repositioned its open panel (a forced layout) and re-reflected the selection onto every row —
+	* for notifies that change none of it, chiefly each virtual-scroll window shift. What the field
+	* reads from the grid: the selection (`check().version` / `pending`), the load state
+	* (`loading` / `hasLoaded` / `error` — the skeleton release), and the rows for chip labels and
+	* key typing — the page array itself, or under virtual scroll (whose `items` is only the window)
+	* the loaded count. Rows a window shift brings in are re-reflected by the panel's own
+	* MutationObserver, not by this notify.
+	*/
+	let forwarded = [];
+	const gridSignature = () => {
+		const c = grid.check();
+		return [
+			c.version,
+			c.pending,
+			grid.loading,
+			grid.hasLoaded,
+			grid.error,
+			grid.scrollMode === "virtual" ? grid.loadedCount : grid.items,
+			grid.totalCount,
+			grid.hasMore,
+			grid.pageIndex
+		];
+	};
+	const offGrid = grid.subscribe(() => {
+		const sig = gridSignature();
+		if (sig.length === forwarded.length && sig.every((v, i) => Object.is(v, forwarded[i]))) return;
+		forwarded = sig;
+		notify();
+	});
 	const ctrl = {
 		grid,
 		/** Alias of {@link grid} — the inner `controlMonoTable`. Preferred in new

package/dist/{mono-data-grid-KDpu4d4_.js → mono-data-grid-CZFjpnOD.js}

@@ -1,8 +1,8 @@
 import { t as createNotifier } from "./notifier-BIrqUzRh.js";
 import { a as parseFieldPath, c as toODataClause, l as toODataSelector, n as isPath, o as projectFields, r as mergePatch, s as setFieldValue, t as getFieldValue } from "./field-path-BabiMrrA.js";
 import { C as resolveSearchEntries, D as compileFilterPredicate, E as andPredicates, O as joinFilters, S as plainSearchColumns, T as andFilters, f as mergeSearchFields, g as customRemoteClause, h as customPredicate, n as describeError, o as isCanceled, u as DEFAULT_SEARCH_FIELDS, v as hasCustomSearch, w as searchEntryFor, y as hasWildcardSearch } from "./normalize-error-BmLbgANw.js";
-import { a as buildGroups, c as isGroupNode, i as searchFilterOf, o as collectGroupPaths, r as readAllRows, s as flattenLeaves } from "./data-source-read-i6CYSUEl.js";
-import { a as resolveDataSourceOptions, c as composeSummaryApply, d as createApplyGate, f as isRolledUp, h as monoArraySource, i as normalizeSortList, l as summaryAliases, m as storeRows, n as extraLoadOptions, o as toList, p as loadApply, s as buildSummaryApply, t as dataSourceOptionsKey, u as summaryFilterOf } from "./data-source-options-Cz9fVLK8.js";
+import { a as buildGroups, c as isGroupNode, i as searchFilterOf, o as collectGroupPaths, r as readAllRows, s as flattenLeaves } from "./data-source-read-DTJ_Mnez.js";
+import { a as resolveDataSourceOptions, c as composeSummaryApply, d as createApplyGate, f as isRolledUp, h as monoArraySource, i as normalizeSortList, l as summaryAliases, m as storeRows, n as extraLoadOptions, o as toList, p as loadApply, s as buildSummaryApply, t as dataSourceOptionsKey, u as summaryFilterOf } from "./data-source-options-CS0w0wlO.js";
 import { n as unwrapReactive } from "./reactive-Dtd-esHO.js";
 import { t as arrayToODataString } from "./filter-odata-Bi27XUpQ.js";
 import { t as monoFilterBuilder } from "./filter-builder-B6Y2mmbM.js";
@@ -1004,6 +1004,16 @@ function monoDataGrid(ds = null, opts = {}) {
 	const checkedRows = /* @__PURE__ */ new Map();
 	let checkConfig = {};
 	let checkPending = false;
+	/**
+	* Bumped on every selection notify (a rejected toggle included — its subscribers repaint the
+	* revert), so a listener can tell a selection change from the grid's other notifies without
+	* diffing the store. See `MonoCheckHandle.version`.
+	*/
+	let checkVersion = 0;
+	function checkChanged() {
+		checkVersion += 1;
+		notify();
+	}
 	/** `keyValue` as a list (empty = project nothing, i.e. keep the whole row). */
 	function checkKeys() {
 		const k = checkConfig.keyValue;
@@ -1126,26 +1136,26 @@ function monoDataGrid(ds = null, opts = {}) {
 				if (next) checkedRows.set(key, item);
 				else checkedRows.delete(key);
 			}
-			notify();
+			checkChanged();
 		},
 		selectPage() {
 			addChecked(ctrl.items);
-			notify();
+			checkChanged();
 		},
 		replace(rows) {
 			checkedRows.clear();
 			addChecked(rows, false);
-			notify();
+			checkChanged();
 		},
 		async selectAll() {
 			if (checkPending) return;
 			if (drainIsReusable()) {
 				addChecked(drainedRows);
-				notify();
+				checkChanged();
 				return;
 			}
 			checkPending = true;
-			notify();
+			checkChanged();
 			try {
 				const select = checkSelect();
 				const rows = await readAllRows(bound, {
@@ -1161,7 +1171,7 @@ function monoDataGrid(ds = null, opts = {}) {
 				throw err;
 			} finally {
 				checkPending = false;
-				notify();
+				checkChanged();
 			}
 		},
 		clear() {
@@ -1169,14 +1179,14 @@ function monoDataGrid(ds = null, opts = {}) {
 			const min = checkLimits().min ?? 0;
 			if (min > 0) {
 				if (checkedRows.size <= min) {
-					notify();
+					checkChanged();
 					return;
 				}
 				const keep = [...checkedRows.entries()].slice(0, min);
 				checkedRows.clear();
 				for (const [key, row] of keep) checkedRows.set(key, row);
 			} else checkedRows.clear();
-			notify();
+			checkChanged();
 		},
 		limits: checkLimits,
 		get atMax() {
@@ -1187,6 +1197,9 @@ function monoDataGrid(ds = null, opts = {}) {
 			const min = checkLimits().min;
 			return min !== void 0 && checkedRows.size <= min;
 		},
+		get version() {
+			return checkVersion;
+		},
 		get pending() {
 			return checkPending;
 		},
@@ -1278,8 +1291,53 @@ function monoDataGrid(ds = null, opts = {}) {
 	function columns() {
 		return columnsHandle;
 	}
+	/**
+	* Row → index and row key → index over `ctrl.items`, built lazily per items ARRAY.
+	*
+	* `rowKey()` / `indexOfRowKey()` were linear scans, and they are per-row calls: every
+	* `<mono-table-checkbox>` asks `check.isChecked(row)` on every notify, so a tick on a grid
+	* holding N rows (infinity scroll and page-size "all" hold the whole set) cost O(N²).
+	*
+	* A HIT is always verified against the live array, and a MISS falls back to the scan
+	* (rebuilding when the scan finds the row) — so an in-place mutation of `ctrl.items`, or a
+	* key that moved, costs one rebuild and is never answered wrong.
+	*/
+	let indexFor = null;
+	let indexByRow = /* @__PURE__ */ new Map();
+	let keyIndexFor = null;
+	let indexByKey = /* @__PURE__ */ new Map();
+	function rebuildRowIndex(items) {
+		indexFor = items;
+		indexByRow = /* @__PURE__ */ new Map();
+		items.forEach((row, i) => {
+			if (!indexByRow.has(row)) indexByRow.set(row, i);
+		});
+	}
+	function indexOfRow(raw) {
+		const items = ctrl.items;
+		if (indexFor !== items) rebuildRowIndex(items);
+		const hit = indexByRow.get(raw);
+		if (hit !== void 0 && items[hit] === raw) return hit;
+		const i = items.indexOf(raw);
+		if (i >= 0) rebuildRowIndex(items);
+		return i;
+	}
+	function rebuildKeyIndex(items) {
+		keyIndexFor = items;
+		indexByKey = /* @__PURE__ */ new Map();
+		items.forEach((row, i) => {
+			const k = rowKeyOf(row, i);
+			if (!indexByKey.has(k)) indexByKey.set(k, i);
+		});
+	}
 	function indexOfRowKey(rowKey) {
-		return ctrl.items.findIndex((row, i) => rowKeyOf(row, i) === rowKey);
+		const items = ctrl.items;
+		if (keyIndexFor !== items) rebuildKeyIndex(items);
+		const hit = indexByKey.get(rowKey);
+		if (hit !== void 0 && hit < items.length && rowKeyOf(items[hit], hit) === rowKey) return hit;
+		const i = items.findIndex((row, j) => rowKeyOf(row, j) === rowKey);
+		if (i >= 0) rebuildKeyIndex(items);
+		return i;
 	}
 	function rowByKey(rowKey) {
 		const i = indexOfRowKey(rowKey);
@@ -1394,7 +1452,12 @@ function monoDataGrid(ds = null, opts = {}) {
 		return !!row && row._Type === EDITABLE_MARK;
 	}
 	function isEditingCell(rowKeyStr, field) {
-		if (!registeredColumns().some((c) => c.field === field && !!c.editable)) return false;
+		let editableCol = false;
+		for (const el of columnEls) if (el.field === field && el.editable) {
+			editableCol = true;
+			break;
+		}
+		if (!editableCol) return false;
 		return ctrl.editingKey === rowKeyStr || isEditableRow(rowByKey(rowKeyStr));
 	}
 	function commitCell(rowKey, field, value) {
@@ -2166,7 +2229,7 @@ function monoDataGrid(ds = null, opts = {}) {
 	*/
 	function rowKey(row) {
 		const raw = unwrapReactive(row);
-		const i = ctrl.items.indexOf(raw);
+		const i = indexOfRow(raw);
 		if (i >= 0) return rowKeyOf(raw, i);
 		const direct = rowKeyOf(raw, NaN);
 		if (direct !== "NaN") return direct;
@@ -2213,26 +2276,50 @@ function monoDataGrid(ds = null, opts = {}) {
 		if (cols.length && out && typeof out === "object") for (const c of cols) out[c.field] = c.map(row?.[c.field], row, index);
 		return out;
 	}
-	/** Recompute `ctrl.mapped` from `ctrl.items`. Cheap no-op without a map. */
+	/** What `ctrl.mapped` was last built from — see `syncMapped`. */
+	let mappedFrom = [];
+	/**
+	* Recompute `ctrl.mapped` from `ctrl.items`. Cheap no-op without a map.
+	*
+	* Skipped when nothing it reads has moved: the same `items` array (same length), the same
+	* row set (`rowSetVersion`) and the same map config. It runs on EVERY notifier flush, so a
+	* checkbox tick or a loading flip re-mapped every row — every accumulated row under infinity
+	* scroll or page-size "all" — and handed out new `mapped` identities each time.
+	*
+	* Never skipped while a row can be edited IN PLACE (an inline edit, a `showForm` row, form
+	* ops): those write straight into the row objects, which no identity check can see.
+	*/
 	function syncMapped() {
 		if (!hasMap()) {
 			ctrl.mapped = ctrl.items;
+			mappedFrom = [];
 			return;
 		}
+		const from = [
+			ctrl.items,
+			ctrl.items.length,
+			rowSetVersion,
+			elementProps.th,
+			opts.map
+		];
+		if (!(formHandle != null || formOps.length > 0 || ctrl.editingKey != null) && from.length === mappedFrom.length && from.every((v, i) => Object.is(v, mappedFrom[i]))) return;
 		const cols = mapColumns();
 		ctrl.mapped = ctrl.items.map((row, i) => mapRow(row, i, cols));
+		mappedFrom = from;
 	}
 	/** Flatten `ctrl.items` into the ready-to-render, keyed `displayRows` list. */
 	function buildDisplayRows() {
 		const out = [];
 		const cols = mapColumns();
 		if (!isGrouped()) {
+			syncMapped();
+			const mapped = ctrl.mapped;
 			ctrl.items.forEach((row, i) => out.push({
 				key: `r:${rowKeyOf(row, i)}`,
 				kind: "row",
 				level: 0,
 				row,
-				mapped: mapRow(row, i, cols)
+				mapped: mapped[i]
 			}));
 			return out;
 		}
@@ -2275,9 +2362,29 @@ function monoDataGrid(ds = null, opts = {}) {
 	}
 	/** Build the full group tree from every matched row the source holds. */
 	function fullGroups() {
-		const raw = bound ? [...bound.items?.() ?? []] : [];
-		return buildGroups(flattenLeaves(raw), groupFields, collapsed);
+		const src = bound ? bound.items?.() ?? [] : [];
+		const from = [
+			src,
+			src.length,
+			groupFields.join("\0"),
+			rowSetVersion
+		];
+		if (!(!(formHandle != null || formOps.length > 0 || ctrl.editingKey != null) && from.length === groupTreeFrom.length && from.every((v, i) => Object.is(v, groupTreeFrom[i])))) {
+			groupTree = buildGroups(flattenLeaves([...src]), groupFields, collapsed);
+			groupTreeFrom = from;
+			return groupTree;
+		}
+		const stamp = (nodes) => {
+			for (const node of nodes) {
+				node.collapsed = collapsed.has(node.path);
+				if (node.items.length && isGroupNode(node.items[0])) stamp(node.items);
+			}
+		};
+		stamp(groupTree);
+		return groupTree;
 	}
+	let groupTreeFrom = [];
+	let groupTree = [];
 	/** Index every group node by path (full, unsliced) for `groupPageInfo`. */
 	function indexPaths(nodes) {
 		for (const node of nodes) {
@@ -3908,7 +4015,7 @@ function monoDataGrid(ds = null, opts = {}) {
 		});
 	}
 	async function exportReport(options) {
-		const { exportTable } = await import("./export-DgomqI_3.js");
+		const { exportTable } = await import("./export-D27RJa1w.js");
 		return exportTable(options);
 	}
 	function subscribe(cb) {

package/dist/{mono-data-grid-8jmeIXUU.js → mono-data-grid-kV4jYu2g.js}

@@ -1,8 +1,8 @@
 import { a as parseFieldPath, c as toODataClause, l as toODataSelector, n as isPath, o as projectFields, r as mergePatch, s as setFieldValue, t as getFieldValue } from "./field-path-BabiMrrA.js";
-import { a as buildGroups, c as isGroupNode, i as searchFilterOf, o as collectGroupPaths, r as readAllRows, s as flattenLeaves } from "./data-source-read-FxqzQkk2.js";
+import { a as buildGroups, c as isGroupNode, i as searchFilterOf, o as collectGroupPaths, r as readAllRows, s as flattenLeaves } from "./data-source-read-Cp_h7NIf.js";
 import { i as joinFilters, n as andPredicates, r as compileFilterPredicate, t as andFilters } from "./filter-eval-ChDSaAUH.js";
 import { A as resolveSearchEntries, C as customRemoteClause, E as hasWildcardSearch, S as customPredicate, T as hasCustomSearch, h as mergeSearchFields, j as searchEntryFor, k as plainSearchColumns, n as describeError, o as isCanceled, u as DEFAULT_SEARCH_FIELDS } from "./normalize-error-D93O4q8g.js";
-import { a as resolveDataSourceOptions, c as composeSummaryApply, d as createApplyGate, f as isRolledUp, h as monoArraySource, i as normalizeSortList, l as summaryAliases, m as storeRows, n as extraLoadOptions, o as toList, p as loadApply, s as buildSummaryApply, t as dataSourceOptionsKey, u as summaryFilterOf } from "./data-source-options-QjuI73g8.js";
+import { a as resolveDataSourceOptions, c as composeSummaryApply, d as createApplyGate, f as isRolledUp, h as monoArraySource, i as normalizeSortList, l as summaryAliases, m as storeRows, n as extraLoadOptions, o as toList, p as loadApply, s as buildSummaryApply, t as dataSourceOptionsKey, u as summaryFilterOf } from "./data-source-options-lDR-g9Eb.js";
 import { n as unwrapReactive } from "./reactive-Dtd-esHO.js";
 import { t as arrayToODataString } from "./filter-odata-Bi27XUpQ.js";
 import { t as createNotifier } from "./notifier-BIrqUzRh.js";
@@ -1005,6 +1005,16 @@ function monoDataGrid(ds = null, opts = {}) {
 	const checkedRows = /* @__PURE__ */ new Map();
 	let checkConfig = {};
 	let checkPending = false;
+	/**
+	* Bumped on every selection notify (a rejected toggle included — its subscribers repaint the
+	* revert), so a listener can tell a selection change from the grid's other notifies without
+	* diffing the store. See `MonoCheckHandle.version`.
+	*/
+	let checkVersion = 0;
+	function checkChanged() {
+		checkVersion += 1;
+		notify();
+	}
 	/** `keyValue` as a list (empty = project nothing, i.e. keep the whole row). */
 	function checkKeys() {
 		const k = checkConfig.keyValue;
@@ -1127,26 +1137,26 @@ function monoDataGrid(ds = null, opts = {}) {
 				if (next) checkedRows.set(key, item);
 				else checkedRows.delete(key);
 			}
-			notify();
+			checkChanged();
 		},
 		selectPage() {
 			addChecked(ctrl.items);
-			notify();
+			checkChanged();
 		},
 		replace(rows) {
 			checkedRows.clear();
 			addChecked(rows, false);
-			notify();
+			checkChanged();
 		},
 		async selectAll() {
 			if (checkPending) return;
 			if (drainIsReusable()) {
 				addChecked(drainedRows);
-				notify();
+				checkChanged();
 				return;
 			}
 			checkPending = true;
-			notify();
+			checkChanged();
 			try {
 				const select = checkSelect();
 				const rows = await readAllRows(bound, {
@@ -1162,7 +1172,7 @@ function monoDataGrid(ds = null, opts = {}) {
 				throw err;
 			} finally {
 				checkPending = false;
-				notify();
+				checkChanged();
 			}
 		},
 		clear() {
@@ -1170,14 +1180,14 @@ function monoDataGrid(ds = null, opts = {}) {
 			const min = checkLimits().min ?? 0;
 			if (min > 0) {
 				if (checkedRows.size <= min) {
-					notify();
+					checkChanged();
 					return;
 				}
 				const keep = [...checkedRows.entries()].slice(0, min);
 				checkedRows.clear();
 				for (const [key, row] of keep) checkedRows.set(key, row);
 			} else checkedRows.clear();
-			notify();
+			checkChanged();
 		},
 		limits: checkLimits,
 		get atMax() {
@@ -1188,6 +1198,9 @@ function monoDataGrid(ds = null, opts = {}) {
 			const min = checkLimits().min;
 			return min !== void 0 && checkedRows.size <= min;
 		},
+		get version() {
+			return checkVersion;
+		},
 		get pending() {
 			return checkPending;
 		},
@@ -1279,8 +1292,53 @@ function monoDataGrid(ds = null, opts = {}) {
 	function columns() {
 		return columnsHandle;
 	}
+	/**
+	* Row → index and row key → index over `ctrl.items`, built lazily per items ARRAY.
+	*
+	* `rowKey()` / `indexOfRowKey()` were linear scans, and they are per-row calls: every
+	* `<mono-table-checkbox>` asks `check.isChecked(row)` on every notify, so a tick on a grid
+	* holding N rows (infinity scroll and page-size "all" hold the whole set) cost O(N²).
+	*
+	* A HIT is always verified against the live array, and a MISS falls back to the scan
+	* (rebuilding when the scan finds the row) — so an in-place mutation of `ctrl.items`, or a
+	* key that moved, costs one rebuild and is never answered wrong.
+	*/
+	let indexFor = null;
+	let indexByRow = /* @__PURE__ */ new Map();
+	let keyIndexFor = null;
+	let indexByKey = /* @__PURE__ */ new Map();
+	function rebuildRowIndex(items) {
+		indexFor = items;
+		indexByRow = /* @__PURE__ */ new Map();
+		items.forEach((row, i) => {
+			if (!indexByRow.has(row)) indexByRow.set(row, i);
+		});
+	}
+	function indexOfRow(raw) {
+		const items = ctrl.items;
+		if (indexFor !== items) rebuildRowIndex(items);
+		const hit = indexByRow.get(raw);
+		if (hit !== void 0 && items[hit] === raw) return hit;
+		const i = items.indexOf(raw);
+		if (i >= 0) rebuildRowIndex(items);
+		return i;
+	}
+	function rebuildKeyIndex(items) {
+		keyIndexFor = items;
+		indexByKey = /* @__PURE__ */ new Map();
+		items.forEach((row, i) => {
+			const k = rowKeyOf(row, i);
+			if (!indexByKey.has(k)) indexByKey.set(k, i);
+		});
+	}
 	function indexOfRowKey(rowKey) {
-		return ctrl.items.findIndex((row, i) => rowKeyOf(row, i) === rowKey);
+		const items = ctrl.items;
+		if (keyIndexFor !== items) rebuildKeyIndex(items);
+		const hit = indexByKey.get(rowKey);
+		if (hit !== void 0 && hit < items.length && rowKeyOf(items[hit], hit) === rowKey) return hit;
+		const i = items.findIndex((row, j) => rowKeyOf(row, j) === rowKey);
+		if (i >= 0) rebuildKeyIndex(items);
+		return i;
 	}
 	function rowByKey(rowKey) {
 		const i = indexOfRowKey(rowKey);
@@ -1395,7 +1453,12 @@ function monoDataGrid(ds = null, opts = {}) {
 		return !!row && row._Type === EDITABLE_MARK;
 	}
 	function isEditingCell(rowKeyStr, field) {
-		if (!registeredColumns().some((c) => c.field === field && !!c.editable)) return false;
+		let editableCol = false;
+		for (const el of columnEls) if (el.field === field && el.editable) {
+			editableCol = true;
+			break;
+		}
+		if (!editableCol) return false;
 		return ctrl.editingKey === rowKeyStr || isEditableRow(rowByKey(rowKeyStr));
 	}
 	function commitCell(rowKey, field, value) {
@@ -2167,7 +2230,7 @@ function monoDataGrid(ds = null, opts = {}) {
 	*/
 	function rowKey(row) {
 		const raw = unwrapReactive(row);
-		const i = ctrl.items.indexOf(raw);
+		const i = indexOfRow(raw);
 		if (i >= 0) return rowKeyOf(raw, i);
 		const direct = rowKeyOf(raw, NaN);
 		if (direct !== "NaN") return direct;
@@ -2214,26 +2277,50 @@ function monoDataGrid(ds = null, opts = {}) {
 		if (cols.length && out && typeof out === "object") for (const c of cols) out[c.field] = c.map(row?.[c.field], row, index);
 		return out;
 	}
-	/** Recompute `ctrl.mapped` from `ctrl.items`. Cheap no-op without a map. */
+	/** What `ctrl.mapped` was last built from — see `syncMapped`. */
+	let mappedFrom = [];
+	/**
+	* Recompute `ctrl.mapped` from `ctrl.items`. Cheap no-op without a map.
+	*
+	* Skipped when nothing it reads has moved: the same `items` array (same length), the same
+	* row set (`rowSetVersion`) and the same map config. It runs on EVERY notifier flush, so a
+	* checkbox tick or a loading flip re-mapped every row — every accumulated row under infinity
+	* scroll or page-size "all" — and handed out new `mapped` identities each time.
+	*
+	* Never skipped while a row can be edited IN PLACE (an inline edit, a `showForm` row, form
+	* ops): those write straight into the row objects, which no identity check can see.
+	*/
 	function syncMapped() {
 		if (!hasMap()) {
 			ctrl.mapped = ctrl.items;
+			mappedFrom = [];
 			return;
 		}
+		const from = [
+			ctrl.items,
+			ctrl.items.length,
+			rowSetVersion,
+			elementProps.th,
+			opts.map
+		];
+		if (!(formHandle != null || formOps.length > 0 || ctrl.editingKey != null) && from.length === mappedFrom.length && from.every((v, i) => Object.is(v, mappedFrom[i]))) return;
 		const cols = mapColumns();
 		ctrl.mapped = ctrl.items.map((row, i) => mapRow(row, i, cols));
+		mappedFrom = from;
 	}
 	/** Flatten `ctrl.items` into the ready-to-render, keyed `displayRows` list. */
 	function buildDisplayRows() {
 		const out = [];
 		const cols = mapColumns();
 		if (!isGrouped()) {
+			syncMapped();
+			const mapped = ctrl.mapped;
 			ctrl.items.forEach((row, i) => out.push({
 				key: `r:${rowKeyOf(row, i)}`,
 				kind: "row",
 				level: 0,
 				row,
-				mapped: mapRow(row, i, cols)
+				mapped: mapped[i]
 			}));
 			return out;
 		}
@@ -2276,9 +2363,29 @@ function monoDataGrid(ds = null, opts = {}) {
 	}
 	/** Build the full group tree from every matched row the source holds. */
 	function fullGroups() {
-		const raw = bound ? [...bound.items?.() ?? []] : [];
-		return buildGroups(flattenLeaves(raw), groupFields, collapsed);
+		const src = bound ? bound.items?.() ?? [] : [];
+		const from = [
+			src,
+			src.length,
+			groupFields.join("\0"),
+			rowSetVersion
+		];
+		if (!(!(formHandle != null || formOps.length > 0 || ctrl.editingKey != null) && from.length === groupTreeFrom.length && from.every((v, i) => Object.is(v, groupTreeFrom[i])))) {
+			groupTree = buildGroups(flattenLeaves([...src]), groupFields, collapsed);
+			groupTreeFrom = from;
+			return groupTree;
+		}
+		const stamp = (nodes) => {
+			for (const node of nodes) {
+				node.collapsed = collapsed.has(node.path);
+				if (node.items.length && isGroupNode(node.items[0])) stamp(node.items);
+			}
+		};
+		stamp(groupTree);
+		return groupTree;
 	}
+	let groupTreeFrom = [];
+	let groupTree = [];
 	/** Index every group node by path (full, unsliced) for `groupPageInfo`. */
 	function indexPaths(nodes) {
 		for (const node of nodes) {

package/dist/{mono-element-Bc9wElPy.js → mono-element-CKcT0rwv.js}

@@ -1,4 +1,4 @@
-import { S as registerPendingProperty, h as monoApplyPhantomOptions, m as isMonoSsrApp, t as applyMonoUIDefaults, v as monoPendingActive, w as watchSkeletonActivation, x as monoSkeletonInternals } from "./mono-ui-KOBJcnXk.js";
+import { S as registerPendingProperty, h as monoApplyPhantomOptions, m as isMonoSsrApp, t as applyMonoUIDefaults, v as monoPendingActive, w as watchSkeletonActivation, x as monoSkeletonInternals } from "./mono-ui-kvLVIf1V.js";
 import { html } from "lit";
 
 //#region src/composables/mono-pending.ts