@vueye-table/core 3.0.0-alpha.1 → 3.0.0-alpha.11

package/dist/index.js

@@ -8,13 +8,34 @@ function humanize(id) {
 	return sentence.charAt(0).toUpperCase() + sentence.slice(1);
 }
 
+//#endregion
+//#region src/issues.ts
+function issue(code, message, details = {}) {
+	return Object.freeze({
+		code,
+		message,
+		...details
+	});
+}
+
 //#endregion
 //#region src/path.ts
+/**
+* Dotted property paths.
+*
+* A column addresses nested data with a path such as `"address.city"`. The types below give every
+* such path its value type, and the functions read and write through a path without mutating.
+*/
 function isRecord$1(value) {
 	return typeof value === "object" && value !== null;
 }
+/** Whether every path segment can be read or written without addressing a prototype. */
+function isSafePath(path) {
+	return path.split(".").every((segment) => segment !== "__proto__" && segment !== "constructor" && segment !== "prototype");
+}
 /** Read the value at a dotted path, or `undefined` when a step is missing. */
 function getPath(source, path) {
+	if (!isSafePath(path)) return;
 	let current = source;
 	for (const segment of path.split(".")) {
 		if (!isRecord$1(current)) return;
@@ -24,13 +45,18 @@ function getPath(source, path) {
 }
 /**
 * Return a copy of `source` with `value` at `path`. Only the objects along the path are copied;
-* everything else is shared. Missing steps are created as plain objects.
+* everything else is shared. Missing steps are created as plain objects. Unsafe paths return
+* `source` unchanged and report an `unsafe_path` issue through `onIssue`, when supplied.
 */
-function setPath(source, path, value) {
+function setPath(source, path, value, onIssue) {
+	if (!isSafePath(path)) {
+		onIssue?.(issue("unsafe_path", `The path "${path}" addresses a prototype and cannot be written.`, { column: path }));
+		return source;
+	}
 	const [head, ...rest] = path.split(".");
 	const base = isRecord$1(source) ? { ...source } : {};
 	if (head === void 0) return source;
-	base[head] = rest.length === 0 ? value : setPath(base[head], rest.join("."), value);
+	base[head] = rest.length === 0 ? value : setPath(Object.hasOwn(base, head) ? base[head] : void 0, rest.join("."), value);
 	return base;
 }
 
@@ -197,14 +223,15 @@ function parseAs(input, type) {
 function resolveColumn(definition) {
 	const def = definition;
 	const { accessor } = def;
-	const getValue = accessor ?? ((row) => getPath(row, def.id));
+	const safe = isSafePath(def.id);
+	const getValue = safe ? accessor ?? ((row) => getPath(row, def.id)) : () => void 0;
 	const format = def.format ?? ((value) => formatValue(value));
 	const compare = def.compare ?? compareValues;
 	const customFilter = def.filter;
 	const customParse = def.parse;
 	const editable = def.editable ?? false;
 	const customSetValue = def.setValue;
-	const canWrite = accessor === void 0 || customSetValue !== void 0;
+	const canWrite = safe && (accessor === void 0 || customSetValue !== void 0);
 	return Object.freeze({
 		id: def.id,
 		header: def.header ?? humanize(def.id),
@@ -241,6 +268,7 @@ function resolveColumn(definition) {
 			return parseAs(input, def.type ?? typeOf(getValue(row)) ?? typeOf(sample) ?? "text");
 		},
 		setValue(row, value) {
+			if (!safe) return;
 			if (customSetValue) return customSetValue(row, value);
 			return accessor === void 0 ? setPath(row, def.id, value) : void 0;
 		}
@@ -258,6 +286,10 @@ function resolveColumn(definition) {
 function quote(field, delimiter) {
 	return field.includes(delimiter) || field.includes("\"") || field.includes("\n") || field.includes("\r") ? `"${field.replaceAll("\"", "\"\"")}"` : field;
 }
+/** Escape formula-like display text; a finite number formatted as a number stays numeric. */
+function escapeFormula(text, value) {
+	return !(typeof value === "number" && Number.isFinite(value) && /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/u.test(text)) && /^[=+\-@\t\r\n＝＋－＠]/u.test(text) ? "'" + text : text;
+}
 /** Write a matrix of text as delimited lines joined with `\n`. */
 function toDelimited(matrix, delimiter = "	") {
 	return matrix.map((line) => line.map((field) => quote(field, delimiter)).join(delimiter)).join("\n");
@@ -267,39 +299,92 @@ function toDelimited(matrix, delimiter = "	") {
 * and embedded line breaks, and ignores one trailing line break.
 */
 function parseDelimited(text, delimiter = "	") {
+	return readDelimited(text, {
+		maxRows: Infinity,
+		maxColumns: Infinity,
+		maxCells: Infinity,
+		maxLength: Infinity
+	}, delimiter).rows;
+}
+/** Read complete fields within a grid and work budget, without materializing discarded fields. */
+function readDelimited(text, limits, delimiter = "	") {
 	const rows = [];
+	if (limits.maxRows === 0 || limits.maxColumns === 0) return {
+		rows,
+		truncated: text.length > 0
+	};
 	let row = [];
 	let field = "";
 	let quoted = false;
+	let started = false;
 	let index = 0;
+	let column = 0;
+	let cells = 0;
+	let truncated = false;
+	const end = Math.min(text.length, limits.maxLength);
 	const endField = () => {
-		row.push(field);
+		if (column < limits.maxColumns) row.push(field);
+		else truncated = true;
+		column += 1;
+		cells += 1;
 		field = "";
+		started = false;
 	};
-	const endRow = () => {
-		endField();
-		rows.push(row);
-		row = [];
+	const append = (char) => {
+		if (column < limits.maxColumns) field += char;
 	};
-	while (index < text.length) {
+	while (index < end) {
 		const char = text.charAt(index);
 		if (quoted) {
 			if (char === "\"") {
-				if (text.charAt(index + 1) === "\"") {
-					field += "\"";
+				if (index + 1 < end && text.charAt(index + 1) === "\"") {
+					append("\"");
 					index += 1;
 				} else quoted = false;
-			} else field += char;
-		} else if (char === "\"" && field === "") quoted = true;
-		else if (char === delimiter) endField();
-		else if (char === "\n" || char === "\r") {
-			if (char === "\r" && text.charAt(index + 1) === "\n") index += 1;
-			endRow();
-		} else field += char;
+			} else append(char);
+		} else if (char === "\"" && !started) quoted = true;
+		else if (char === delimiter) {
+			endField();
+			index += 1;
+			if (cells >= limits.maxCells || rows.length + 1 >= limits.maxRows && column >= limits.maxColumns) {
+				rows.push(row);
+				return {
+					rows,
+					truncated: true
+				};
+			}
+			continue;
+		} else if (char === "\n" || char === "\r") {
+			if (char === "\r" && index + 1 < end && text.charAt(index + 1) === "\n") index += 1;
+			endField();
+			rows.push(row);
+			row = [];
+			column = 0;
+			index += 1;
+			if (cells >= limits.maxCells || rows.length >= limits.maxRows) return {
+				rows,
+				truncated: truncated || index < text.length
+			};
+			continue;
+		} else append(char);
+		started = true;
 		index += 1;
 	}
-	if (field !== "" || row.length > 0) endRow();
-	return rows;
+	if (end < text.length) {
+		if (row.length > 0) rows.push(row);
+		return {
+			rows,
+			truncated: true
+		};
+	}
+	if (started || column > 0) {
+		endField();
+		rows.push(row);
+	}
+	return {
+		rows,
+		truncated
+	};
 }
 
 //#endregion
@@ -380,15 +465,23 @@ const ARROWS = {
 	ArrowLeft: "left",
 	ArrowRight: "right"
 };
-/**
-* Map a key press to a grid command, spreadsheet style: arrows move (Shift extends, Ctrl or Cmd
-* jumps to the edge), Tab moves across, Home and End reach the row's ends, Enter or F2 edit,
-* a printable character starts editing with that character, Delete and Backspace clear, Escape
-* collapses the selection, and Ctrl or Cmd with A, Z, Y select all, undo, and redo.
-*/
-function gridCommand(event) {
+function gridCommand(event, tree) {
 	const mod = event.ctrlKey === true || event.metaKey === true;
 	const shift = event.shiftKey === true;
+	if (tree && !mod && !event.altKey) {
+		if (event.key === "*") return {
+			type: "tree",
+			action: "siblings"
+		};
+		if (!shift && event.key === "ArrowRight" && tree.canExpand) return {
+			type: "tree",
+			action: tree.expanded ? "child" : "expand"
+		};
+		if (!shift && event.key === "ArrowLeft") return {
+			type: "tree",
+			action: tree.canExpand && tree.expanded ? "collapse" : "parent"
+		};
+	}
 	const direction = ARROWS[event.key];
 	if (direction) return {
 		type: "move",
@@ -462,6 +555,214 @@ function createUndoStack(limit = 100) {
 		clear() {
 			past.length = 0;
 			future.length = 0;
+		},
+		transform(map) {
+			const update = (entries) => entries.flatMap((entry) => {
+				const value = map(entry);
+				return value === void 0 ? [] : [value];
+			});
+			const nextPast = update(past);
+			const nextFuture = update(future);
+			past.splice(0, past.length, ...nextPast);
+			future.splice(0, future.length, ...nextFuture);
+		}
+	};
+}
+
+//#endregion
+//#region src/virtualizer.ts
+const FALLBACK_SIZE = 40;
+/** Layout arithmetic for either axis. All viewport values and measurements come from the caller. */
+function createVirtualizer(initialOptions) {
+	let options = initialOptions;
+	let count = 0;
+	let overscan = 5;
+	let fixedSize;
+	let keys = [];
+	let byKey = /* @__PURE__ */ new Map();
+	let sizes = [];
+	let prefix = [0];
+	let offset = 0;
+	let viewportSize = 0;
+	let cached;
+	const measured = /* @__PURE__ */ new Map();
+	const problems = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	function recover(code, message) {
+		if (!problems.has(code)) {
+			const problem = issue(code, message);
+			problems.set(code, problem);
+			options.onIssue?.(problem);
+			cached = void 0;
+		}
+	}
+	function validSize(value) {
+		if (Number.isFinite(value) && value > 0) return value;
+		recover("invalid_virtual_size", `Item size ${String(value)} is not positive and finite; 40 is used.`);
+		return FALLBACK_SIZE;
+	}
+	function configure(next) {
+		options = next;
+		problems.clear();
+		count = Number.isSafeInteger(next.count) && next.count >= 0 ? next.count : 0;
+		if (count !== next.count) recover("invalid_virtual_option", "Virtual item count must be a non-negative safe integer; 0 is used.");
+		const requestedOverscan = next.overscan ?? 5;
+		overscan = Number.isSafeInteger(requestedOverscan) && requestedOverscan >= 0 ? requestedOverscan : 5;
+		if (overscan !== requestedOverscan) recover("invalid_virtual_option", "Overscan must be a non-negative safe integer; 5 is used.");
+		const estimate = typeof next.estimateSize === "number" ? validSize(next.estimateSize) : void 0;
+		const nextKeys = [];
+		const nextSizes = [];
+		const nextByKey = /* @__PURE__ */ new Map();
+		let firstChanged = count;
+		let uniform = estimate !== void 0;
+		for (let index = 0; index < count; index += 1) {
+			let key = next.getKey ? next.getKey(index) : index;
+			if (!(typeof key === "string" || typeof key === "number" && Number.isFinite(key))) {
+				recover("invalid_virtual_option", `Item ${index} has an invalid key; its index is used.`);
+				key = index;
+			}
+			if (nextByKey.has(key)) {
+				recover("duplicate_virtual_key", `Item ${index} repeats a key; a distinct fallback key is used.`);
+				key = JSON.stringify(["virtual", index]);
+				while (nextByKey.has(key)) key += ":";
+			}
+			const size = measured.get(key) ?? estimate ?? validSize(next.estimateSize(index));
+			uniform &&= size === estimate;
+			if (keys[index] !== key || sizes[index] !== size) firstChanged = Math.min(firstChanged, index);
+			nextKeys.push(key);
+			nextSizes.push(size);
+			nextByKey.set(key, index);
+		}
+		if (fixedSize !== void 0 || uniform) prefix = [0];
+		else prefix.length = Math.min(prefix.length, firstChanged + 1);
+		keys = nextKeys;
+		sizes = nextSizes;
+		byKey = nextByKey;
+		fixedSize = uniform ? estimate : void 0;
+		cached = void 0;
+	}
+	function startOf(index) {
+		if (fixedSize !== void 0) return index * fixedSize;
+		while (prefix.length <= index) {
+			const at = prefix.length - 1;
+			prefix.push(prefix[at] + sizes[at]);
+		}
+		return prefix[index];
+	}
+	function totalSize() {
+		return startOf(count);
+	}
+	function indexAt(position) {
+		if (fixedSize !== void 0) return Math.min(count - 1, Math.floor(position / fixedSize));
+		let low = 0;
+		let high = count - 1;
+		while (low < high) {
+			const middle = Math.floor((low + high) / 2);
+			if (startOf(middle + 1) <= position) low = middle + 1;
+			else high = middle;
+		}
+		return low;
+	}
+	function getWindow() {
+		if (cached) return cached;
+		const total = totalSize();
+		const clampedOffset = Math.min(offset, Math.max(0, total - viewportSize));
+		let first = 0;
+		let last = -1;
+		if (count > 0 && viewportSize > 0) {
+			first = Math.max(0, indexAt(clampedOffset) - overscan);
+			const edge = Math.min(total, clampedOffset + viewportSize);
+			let visibleEnd = indexAt(edge);
+			if (startOf(visibleEnd) >= edge) visibleEnd -= 1;
+			last = Math.min(count - 1, visibleEnd + overscan);
+		}
+		const items = [];
+		for (let index = first; index <= last; index += 1) items.push(Object.freeze({
+			index,
+			key: keys[index],
+			start: startOf(index),
+			size: sizes[index]
+		}));
+		const paddingStart = items.length > 0 ? startOf(first) : 0;
+		const paddingEnd = items.length > 0 ? Math.max(0, total - startOf(last + 1)) : total;
+		cached = Object.freeze({
+			items: Object.freeze(items),
+			totalSize: total,
+			paddingStart,
+			paddingEnd,
+			startIndex: first,
+			endIndex: last,
+			offset: clampedOffset,
+			viewportSize,
+			issues: Object.freeze([...problems.values()])
+		});
+		return cached;
+	}
+	function notify() {
+		cached = void 0;
+		if (listeners.size > 0) {
+			const view = getWindow();
+			for (const listener of listeners) listener(view);
+		}
+	}
+	configure(initialOptions);
+	return {
+		setOptions(next) {
+			configure(next);
+			notify();
+		},
+		setViewport(nextOffset, nextSize) {
+			const issueCount = problems.size;
+			const safeOffset = Number.isFinite(nextOffset) && nextOffset >= 0 ? nextOffset : 0;
+			const safeSize = Number.isFinite(nextSize) && nextSize >= 0 ? nextSize : 0;
+			if (safeOffset !== nextOffset || safeSize !== nextSize) recover("invalid_virtual_viewport", "Viewport offset and size must be non-negative and finite; invalid values use 0.");
+			if (offset === safeOffset && viewportSize === safeSize && problems.size === issueCount) return;
+			offset = safeOffset;
+			viewportSize = safeSize;
+			notify();
+		},
+		measure(key, size) {
+			const index = byKey.get(key);
+			if (index === void 0) return;
+			if (!Number.isFinite(size) || size <= 0) {
+				recover("invalid_virtual_size", "Measured size must be positive and finite; the previous size is retained.");
+				notify();
+				return;
+			}
+			measured.set(key, size);
+			if (sizes[index] === size) return;
+			if (fixedSize !== void 0) {
+				fixedSize = void 0;
+				prefix = [0];
+			} else prefix.length = Math.min(prefix.length, index + 1);
+			sizes[index] = size;
+			notify();
+		},
+		getWindow,
+		getItem(index) {
+			return Number.isSafeInteger(index) && index >= 0 && index < count ? Object.freeze({
+				index,
+				key: keys[index],
+				start: startOf(index),
+				size: sizes[index]
+			}) : void 0;
+		},
+		getOffsetForIndex(index, align = "auto") {
+			if (count === 0) return 0;
+			if (!Number.isFinite(index) || !Number.isInteger(index)) recover("invalid_virtual_option", "Scroll index must be a finite integer; it is clamped to a valid item.");
+			const target = Math.min(count - 1, Math.max(0, Number.isFinite(index) ? Math.trunc(index) : 0));
+			const start = startOf(target);
+			const end = start + sizes[target];
+			const current = getWindow().offset;
+			let result = start;
+			if (align === "center") result = start - (viewportSize - sizes[target]) / 2;
+			else if (align === "end") result = end - viewportSize;
+			else if (align === "auto") result = start < current ? start : end > current + viewportSize ? end - viewportSize : current;
+			return Math.min(Math.max(0, totalSize() - viewportSize), Math.max(0, result));
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
 		}
 	};
 }
@@ -526,6 +827,10 @@ function filterRows(rows, columns, search, filters) {
 }
 /** Sort rows by each rule in turn. The sort is stable: ties keep their incoming order. */
 function sortRows(rows, columns, sorting) {
+	if (!sorting.some((rule) => columns.some((column) => column.id === rule.column))) return rows;
+	return rows.toSorted(compareRows(columns, sorting));
+}
+function compareRows(columns, sorting) {
 	const byId = new Map(columns.map((column) => [column.id, column]));
 	const rules = sorting.flatMap((rule) => {
 		const column = byId.get(rule.column);
@@ -534,8 +839,7 @@ function sortRows(rows, columns, sorting) {
 			sign: rule.direction === "desc" ? -1 : 1
 		}] : [];
 	});
-	if (rules.length === 0) return rows;
-	return rows.toSorted((left, right) => {
+	return (left, right) => {
 		for (const { column, sign } of rules) {
 			const leftValue = left.getValue(column.id);
 			const rightValue = right.getValue(column.id);
@@ -545,7 +849,19 @@ function sortRows(rows, columns, sorting) {
 			if (order !== 0) return order;
 		}
 		return 0;
-	});
+	};
+}
+/** Stable merge: an existing row wins a tie against an incoming row. */
+function mergeRows(previous, incoming, columns, sorting) {
+	const compare = compareRows(columns, sorting);
+	const added = sortRows(incoming, columns, sorting);
+	const result = [];
+	let left = 0;
+	let right = 0;
+	while (left < previous.length && right < added.length) result.push(compare(previous[left], added[right]) <= 0 ? previous[left++] : added[right++]);
+	while (left < previous.length) result.push(previous[left++]);
+	while (right < added.length) result.push(added[right++]);
+	return result;
 }
 /** The number of pages for a row count. An empty table still has one page. */
 function countPages(rowCount, pageSize) {
@@ -593,10 +909,54 @@ function paginationItems(page, pageCount, siblings = 1) {
 	return items;
 }
 
+//#endregion
+//#region src/row.ts
+/** Disjoint namespaces and typed keys avoid collisions between 1, "1", and detail-like ids. */
+function getRowItemKey(key, kind = "row") {
+	return JSON.stringify([
+		kind,
+		typeof key,
+		key
+	]);
+}
+function createRow(original, key, index, columns, canExpand = false) {
+	const values = /* @__PURE__ */ new Map();
+	const displays = /* @__PURE__ */ new Map();
+	const getValue = (columnId) => {
+		if (values.has(columnId)) return values.get(columnId);
+		const value = columns.get(columnId)?.getValue(original);
+		values.set(columnId, value);
+		return value;
+	};
+	return Object.freeze({
+		key,
+		index,
+		original,
+		canExpand,
+		isExpanded: false,
+		depth: 0,
+		parentKey: void 0,
+		childCount: 0,
+		childStatus: "loaded",
+		selection: "none",
+		isDirty: false,
+		cellIssues: void 0,
+		getValue,
+		getDisplay(columnId) {
+			const cached = displays.get(columnId);
+			if (cached !== void 0) return cached;
+			const column = columns.get(columnId);
+			const display = column ? column.format(getValue(columnId), original) : "";
+			displays.set(columnId, display);
+			return display;
+		}
+	});
+}
+
 //#endregion
 //#region src/state.ts
 const DEFAULT_PAGE_SIZE = 10;
-function createInitialState(patch = {}) {
+function createInitialState(patch = {}, onIssue) {
 	return freezeState({
 		sorting: patch.sorting ?? [],
 		search: patch.search ?? "",
@@ -606,145 +966,1051 @@ function createInitialState(patch = {}) {
 			pageSize: 10
 		},
 		selection: patch.selection ?? [],
+		expanded: normalizeExpanded(patch.expanded === void 0 ? [] : patch.expanded, onIssue),
 		hiddenColumns: patch.hiddenColumns ?? [],
 		columnOrder: patch.columnOrder ?? []
 	});
 }
-function mergeState(state, patch) {
+function mergeState(state, patch, onIssue) {
 	let changed = false;
 	const next = { ...state };
-	for (const [key, value] of Object.entries(patch)) {
+	for (const [key, input] of Object.entries(patch)) {
+		const value = key === "expanded" && input !== void 0 ? normalizeExpanded(input, onIssue) : input;
 		if (value === void 0 || Object.is(next[key], value)) continue;
 		if (key === "pagination" && samePagination(next[key], value)) continue;
+		if (key === "expanded" && sameExpanded(state.expanded, value)) continue;
 		next[key] = value;
 		changed = true;
 	}
-	return changed ? freezeState(next) : state;
+	return changed ? freezeState(next, state) : state;
+}
+function normalizeExpanded(value, onIssue) {
+	if (value === true) return true;
+	if (Array.isArray(value) && value.every((key) => typeof key === "string" || typeof key === "number" && Number.isFinite(key))) return [...new Set(value)];
+	onIssue?.(issue("invalid_expanded", "Expanded state must be true or an array of string/finite number keys; an empty array is used."));
+	return [];
+}
+function sameExpanded(left, right) {
+	return left === right || left !== true && right !== true && left.length === right.length && left.every((key, index) => key === right[index]);
 }
 function samePagination(left, right) {
 	return left.page === right.page && left.pageSize === right.pageSize;
 }
-function freezeState(state) {
+function freezeState(state, previous) {
 	return Object.freeze({
-		sorting: Object.freeze(state.sorting.map((rule) => Object.freeze({ ...rule }))),
+		sorting: state.sorting === previous?.sorting ? previous.sorting : Object.freeze(state.sorting.map((rule) => Object.freeze({ ...rule }))),
 		search: state.search,
-		filters: Object.freeze({ ...state.filters }),
-		pagination: Object.freeze({ ...state.pagination }),
-		selection: Object.freeze([...state.selection]),
-		hiddenColumns: Object.freeze([...state.hiddenColumns]),
-		columnOrder: Object.freeze([...state.columnOrder])
+		filters: state.filters === previous?.filters ? previous.filters : Object.freeze({ ...state.filters }),
+		pagination: state.pagination === previous?.pagination ? previous.pagination : Object.freeze({ ...state.pagination }),
+		selection: state.selection === previous?.selection ? previous.selection : Object.freeze([...state.selection]),
+		expanded: state.expanded === previous?.expanded ? previous.expanded : state.expanded === true ? true : Object.freeze([...state.expanded]),
+		hiddenColumns: state.hiddenColumns === previous?.hiddenColumns ? previous.hiddenColumns : Object.freeze([...state.hiddenColumns]),
+		columnOrder: state.columnOrder === previous?.columnOrder ? previous.columnOrder : Object.freeze([...state.columnOrder])
 	});
 }
 
 //#endregion
-//#region src/issues.ts
-function issue(code, message, details = {}) {
-	return Object.freeze({
-		code,
-		message,
-		...details
+//#region src/validation.ts
+function isPromise(value) {
+	return typeof value === "object" && value !== null && "then" in value;
+}
+/** Validators receive values; their messages remain plain text. */
+function runValidation(validate, rowKey, column) {
+	const fail = (message, validationCode) => issue("validation_failed", message, {
+		rowKey,
+		column,
+		validationCode
 	});
+	const read = (result) => {
+		if (result === true) return void 0;
+		if (typeof result === "string") return fail(result);
+		if (result && typeof result.message === "string") return fail(result.message, result.code);
+		return fail("The validator returned an invalid result.");
+	};
+	const thrown = (error) => fail(error instanceof Error ? error.message : String(error));
+	try {
+		const result = validate();
+		return isPromise(result) ? Promise.resolve(result).then(read, thrown) : read(result);
+	} catch (error) {
+		return thrown(error);
+	}
+}
+function editorFailure(spec, value) {
+	if (!spec) return void 0;
+	if (spec.maxLength !== void 0 && (!Number.isSafeInteger(spec.maxLength) || spec.maxLength < 0)) return "Editor maxLength must be a non-negative safe integer.";
+	if (spec.min !== void 0 && !Number.isFinite(spec.min) || spec.max !== void 0 && !Number.isFinite(spec.max) || spec.min !== void 0 && spec.max !== void 0 && spec.min > spec.max) return "Editor bounds must be finite and ordered.";
+	if (spec.options && !spec.options.some((option) => Object.is(option, value))) return "Choose one of the allowed values.";
+	if (spec.maxLength !== void 0 && typeof value === "string" && value.length > spec.maxLength) return `Use at most ${spec.maxLength} characters.`;
+	if (spec.min !== void 0 || spec.max !== void 0) {
+		const number = value instanceof Date ? value.getTime() : value;
+		if (typeof number !== "number" || !Number.isFinite(number)) return "Enter a finite numeric value.";
+		if (spec.min !== void 0 && number < spec.min) return `Use a value of at least ${spec.min}.`;
+		if (spec.max !== void 0 && number > spec.max) return `Use a value of at most ${spec.max}.`;
+	}
+	if (spec.pattern !== void 0) try {
+		if (typeof value !== "string" || !new RegExp(spec.pattern, "u").test(value)) return "The value does not match the required pattern.";
+	} catch {
+		return "The editor pattern is invalid.";
+	}
 }
 
 //#endregion
-//#region src/row.ts
-function createRow(original, key, index, columns) {
-	const values = /* @__PURE__ */ new Map();
-	const displays = /* @__PURE__ */ new Map();
-	const getValue = (columnId) => {
-		if (values.has(columnId)) return values.get(columnId);
-		const value = columns.get(columnId)?.getValue(original);
-		values.set(columnId, value);
-		return value;
+//#region src/edit-validation.ts
+function readonlyMap(source) {
+	const copy = new Map(source);
+	const result = {
+		size: copy.size,
+		get: (key) => copy.get(key),
+		has: (key) => copy.has(key),
+		entries: () => copy.entries(),
+		keys: () => copy.keys(),
+		values: () => copy.values(),
+		[Symbol.iterator]: () => copy[Symbol.iterator](),
+		forEach(callback, thisArg) {
+			copy.forEach((value, key) => callback.call(thisArg, value, key, result));
+		}
 	};
-	return Object.freeze({
-		key,
-		index,
-		original,
-		getValue,
-		getDisplay(columnId) {
-			const cached = displays.get(columnId);
-			if (cached !== void 0) return cached;
-			const column = columns.get(columnId);
-			const display = column ? column.format(getValue(columnId), original) : "";
-			displays.set(columnId, display);
-			return display;
+	return Object.freeze(result);
+}
+/** All promises in one edit settle together. Tokens fence every cell against stale results. */
+function createEditValidation(host) {
+	const tokens = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const problems = /* @__PURE__ */ new Map();
+	const current = (candidate) => tokens.get(candidate.edit.rowKey)?.get(candidate.edit.column) === candidate.token;
+	const fresh = (candidate) => !candidate.guard || host.snapshot().getRow(candidate.edit.rowKey)?.original === candidate.guard.row;
+	const tokenFor = (rowKey, column) => {
+		const row = tokens.get(rowKey) ?? /* @__PURE__ */ new Map();
+		const token = {};
+		row.set(column, token);
+		tokens.set(rowKey, row);
+		pending.get(rowKey)?.delete(column);
+		problems.get(rowKey)?.delete(column);
+		return token;
+	};
+	const setIssues = (issues) => {
+		for (const problem of issues) {
+			if (problem.rowKey === void 0 || problem.column === void 0) continue;
+			const row = problems.get(problem.rowKey) ?? /* @__PURE__ */ new Map();
+			row.set(problem.column, problem);
+			problems.set(problem.rowKey, row);
 		}
-	});
+	};
+	function rowValidation(candidates, failures) {
+		if (!host.validateRow) return [...candidates];
+		const rows = /* @__PURE__ */ new Map();
+		for (const candidate of candidates) {
+			const group = rows.get(candidate.edit.rowKey) ?? [];
+			group.push(candidate);
+			rows.set(candidate.edit.rowKey, group);
+		}
+		const results = [];
+		for (const [key, group] of rows) {
+			const previous = group[0].original;
+			let next = previous;
+			try {
+				for (const candidate of group) next = candidate.column.setValue(next, candidate.edit.value) ?? next;
+			} catch (error) {
+				for (const candidate of group) failures.push(issue("validation_failed", String(error), {
+					rowKey: key,
+					column: candidate.edit.column
+				}));
+				continue;
+			}
+			const validation = runValidation(() => host.validateRow(next, previous), key);
+			const accept = (problem) => {
+				if (!problem) return group;
+				for (const candidate of group) if (current(candidate)) failures.push(Object.freeze({
+					...problem,
+					column: candidate.edit.column
+				}));
+				return [];
+			};
+			results.push(isPromise(validation) ? validation.then(accept) : accept(validation));
+		}
+		return results.some(isPromise) ? Promise.all(results.map((result) => Promise.resolve(result))).then((groups) => groups.flat()) : results.flat();
+	}
+	function settle(accepted, all, failures, asynchronous) {
+		return host.batch(() => {
+			const live = accepted.filter((candidate) => current(candidate) && fresh(candidate));
+			const liveKeys = new Set(live);
+			const active = all.filter(current);
+			for (const candidate of active) {
+				const key = candidate.edit.rowKey;
+				pending.get(key)?.delete(candidate.edit.column);
+				if (pending.get(key)?.size === 0) pending.delete(key);
+			}
+			const visibleFailures = failures;
+			setIssues(visibleFailures);
+			let result;
+			if (asynchronous && host.optimistic) {
+				const rollback = active.filter((candidate) => !liveKeys.has(candidate)).map((candidate) => ({
+					...candidate.edit,
+					value: candidate.previous
+				}));
+				result = host.apply(rollback, false, visibleFailures);
+				const changes = live.map((candidate) => Object.freeze({
+					rowKey: candidate.edit.rowKey,
+					column: candidate.edit.column,
+					previous: candidate.previous,
+					value: candidate.edit.value,
+					row: host.snapshot().getRow(candidate.edit.rowKey).original
+				}));
+				if (changes.length) host.record(changes);
+				result = Object.freeze({
+					...result,
+					changes: Object.freeze(changes),
+					status: changes.length ? visibleFailures.length ? "partial" : "applied" : visibleFailures.length ? "rejected" : "unchanged"
+				});
+			} else result = host.apply(live.map((candidate) => candidate.edit), true, visibleFailures);
+			setIssues(result.issues);
+			if (!result.changes.length && (all.length || result.issues.length) || asynchronous && host.optimistic) host.notify();
+			if (asynchronous && !result.issues.length && active.length) host.onIssues([]);
+			return result;
+		});
+	}
+	return {
+		hasPending: (key) => (pending.get(key)?.size ?? 0) > 0,
+		cells: () => Object.freeze([...pending.values()].flatMap((row) => [...row.values()])),
+		problems: () => new Map([...problems].filter(([, row]) => row.size).map(([key, row]) => [key, readonlyMap(row)])),
+		cancel(keys) {
+			if (!keys) {
+				tokens.clear();
+				pending.clear();
+				problems.clear();
+			} else for (const key of keys) {
+				tokens.delete(key);
+				pending.delete(key);
+				problems.delete(key);
+			}
+		},
+		edit(edits, recovered = [], options) {
+			const metadataChanged = edits.some((edit) => pending.get(edit.rowKey)?.has(edit.column) || problems.get(edit.rowKey)?.has(edit.column) || host.validateRow && pending.get(edit.rowKey)?.size);
+			const snapshot = host.snapshot();
+			const failures = [...recovered];
+			const candidates = [];
+			const guards = new Map([...options?.expectedRows ?? []].map(([key, row]) => [key, { row }]));
+			const drafts = /* @__PURE__ */ new Map();
+			const samples = /* @__PURE__ */ new Map();
+			if (host.validateRow) for (const key of new Set(edits.map((edit) => edit.rowKey))) {
+				tokens.delete(key);
+				pending.delete(key);
+			}
+			for (const edit of edits) {
+				const token = tokenFor(edit.rowKey, edit.column);
+				const row = snapshot.getRow(edit.rowKey);
+				const column = snapshot.getColumn(edit.column);
+				const fail = (code, message) => {
+					failures.push(issue(code, message, {
+						rowKey: edit.rowKey,
+						column: edit.column
+					}));
+				};
+				if (!isSafePath(edit.column)) {
+					fail("unsafe_path", "This path addresses a prototype and cannot be written.");
+					continue;
+				}
+				if (!row) {
+					fail("unknown_row", `No row has the key "${String(edit.rowKey)}".`);
+					continue;
+				}
+				const guard = guards.get(row.key);
+				if (guard && row.original !== guard.row) {
+					fail("stale_draft", "The row changed after this draft was opened.");
+					continue;
+				}
+				if (!column) {
+					fail("unknown_column", `No column has the id "${edit.column}".`);
+					continue;
+				}
+				const original = drafts.get(row.key) ?? row.original;
+				try {
+					if (!column.isEditable(original)) {
+						fail("read_only_cell", `The "${column.id}" cell is read-only.`);
+						continue;
+					}
+					let value;
+					if ("input" in edit) {
+						if (!samples.has(column.id)) samples.set(column.id, snapshot.processedRows.find((candidate) => candidate.getValue(column.id) !== null && candidate.getValue(column.id) !== void 0)?.getValue(column.id));
+						const parsed = column.parse(edit.input, original, samples.get(column.id));
+						if (!parsed.ok) {
+							fail("invalid_value", parsed.message);
+							continue;
+						}
+						value = parsed.value;
+					} else value = edit.value;
+					const previous = column.getValue(original);
+					if (Object.is(previous, value)) continue;
+					const constraint = editorFailure(column.definition.editor, value);
+					if (constraint) {
+						fail("validation_failed", constraint);
+						continue;
+					}
+					const next = column.setValue(original, value);
+					if (next === void 0) {
+						fail("read_only_cell", "The column has no way to write a value.");
+						continue;
+					}
+					const writeProblem = host.writeIssue(row, next);
+					if (writeProblem) {
+						failures.push(Object.freeze({
+							...writeProblem,
+							column: column.id
+						}));
+						continue;
+					}
+					const validate = column.definition.validate;
+					const validation = validate ? runValidation(() => validate(value, row.original), row.key, column.id) : void 0;
+					if (validation && !isPromise(validation)) {
+						failures.push(validation);
+						continue;
+					}
+					drafts.set(row.key, next);
+					candidates.push({
+						edit: {
+							rowKey: row.key,
+							column: column.id,
+							value
+						},
+						previous: column.getValue(row.original),
+						original: row.original,
+						column,
+						validation,
+						token,
+						guard
+					});
+				} catch (error) {
+					fail("invalid_value", error instanceof Error ? error.message : String(error));
+				}
+			}
+			const asynchronous = candidates.some((candidate) => isPromise(candidate.validation));
+			const validateRows = (accepted) => rowValidation(accepted.filter((candidate) => current(candidate) && fresh(candidate)), failures);
+			const outcome = asynchronous ? Promise.all(candidates.map(async (candidate) => {
+				const problem = await candidate.validation;
+				if (problem) {
+					if (current(candidate)) failures.push(problem);
+					return;
+				}
+				return candidate;
+			})).then((accepted) => validateRows(accepted.filter((candidate) => candidate !== void 0))) : validateRows(candidates);
+			if (!isPromise(outcome)) {
+				const result = settle(outcome, candidates, failures, false);
+				if (metadataChanged && !candidates.length && !failures.length) host.notify();
+				return result;
+			}
+			for (const candidate of candidates) {
+				const row = pending.get(candidate.edit.rowKey) ?? /* @__PURE__ */ new Map();
+				row.set(candidate.edit.column, Object.freeze({ ...candidate.edit }));
+				pending.set(candidate.edit.rowKey, row);
+			}
+			setIssues(failures);
+			const optimistic = host.optimistic ? host.apply(candidates.map((candidate) => candidate.edit), false, failures) : void 0;
+			if (optimistic) for (const [key, guard] of guards) {
+				const row = host.snapshot().getRow(key);
+				if (row) guard.row = row.original;
+			}
+			if (!optimistic?.changes.length) host.notify();
+			if (!host.optimistic && failures.length) host.onIssues(failures);
+			const completion = outcome.then((accepted) => {
+				const staleCandidates = candidates.filter((candidate) => !current(candidate) || !fresh(candidate)).map((candidate) => ({
+					candidate,
+					problem: issue("stale_draft", "This edit was superseded or its row is no longer current.", {
+						rowKey: candidate.edit.rowKey,
+						column: candidate.edit.column
+					})
+				}));
+				const stale = staleCandidates.map(({ problem }) => problem);
+				const issues = [...failures, ...stale];
+				if (candidates.some(current)) {
+					const superseded = staleCandidates.filter(({ candidate }) => !current(candidate)).map(({ problem }) => problem);
+					const result = settle(accepted, candidates, [...failures, ...staleCandidates.filter(({ candidate }) => current(candidate)).map(({ problem }) => problem)], true);
+					if (!stale.length) return result;
+					return Object.freeze({
+						...result,
+						issues: Object.freeze([...result.issues, ...superseded]),
+						status: result.changes.length ? "partial" : "rejected"
+					});
+				}
+				return Object.freeze({
+					status: "rejected",
+					changes: Object.freeze([]),
+					rowChanges: Object.freeze([]),
+					issues: Object.freeze(issues),
+					pendingCells: Object.freeze([])
+				});
+			});
+			return Object.freeze({
+				status: "pending",
+				changes: optimistic?.changes ?? Object.freeze([]),
+				rowChanges: Object.freeze([]),
+				issues: Object.freeze([...failures]),
+				pendingCells: Object.freeze(candidates.map((candidate) => Object.freeze({ ...candidate.edit }))),
+				completion
+			});
+		}
+	};
 }
 
 //#endregion
-//#region src/table.ts
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-function memo(compute) {
-	let last;
-	return (...deps) => {
-		if (last && last.deps.length === deps.length && last.deps.every((d, i) => Object.is(d, deps[i]))) return last.result;
-		const result = compute(...deps);
-		last = {
-			deps,
-			result
-		};
-		return result;
+//#region src/pending-changes.ts
+/** A saved baseline only for touched rows; viewing changes never scans source data. */
+function createPendingChanges() {
+	const entries = /* @__PURE__ */ new Map();
+	return {
+		entries,
+		snapshot() {
+			const inserted = [];
+			const removed = [];
+			const updated = [];
+			for (const [rowKey, entry] of entries) if (entry.previous === void 0 && entry.row !== void 0) inserted.push(Object.freeze({
+				kind: "inserted",
+				rowKey,
+				row: entry.row,
+				position: entry.position
+			}));
+			else if (entry.row === void 0 && entry.previous !== void 0) removed.push(Object.freeze({
+				kind: "removed",
+				rowKey,
+				row: entry.previous,
+				position: entry.position
+			}));
+			else if (entry.row !== void 0 && entry.previous !== void 0) updated.push(Object.freeze({
+				rowKey,
+				row: entry.row,
+				previous: entry.previous,
+				changes: Object.freeze([...entry.cells.values()])
+			}));
+			return Object.freeze({
+				inserted: Object.freeze(inserted),
+				updated: Object.freeze(updated),
+				removed: Object.freeze(removed)
+			});
+		},
+		record(key, previous, row, position, changes) {
+			const entry = entries.get(key) ?? {
+				previous,
+				row,
+				position: Object.freeze({ ...position }),
+				cells: /* @__PURE__ */ new Map()
+			};
+			entry.row = row;
+			for (const change of changes) {
+				const original = entry.cells.has(change.column) ? entry.cells.get(change.column).previous : change.previous;
+				if (Object.is(original, change.value)) entry.cells.delete(change.column);
+				else entry.cells.set(change.column, Object.freeze({
+					...change,
+					previous: original
+				}));
+			}
+			if (entry.previous === void 0 && row === void 0 || entry.previous !== void 0 && row !== void 0 && entry.cells.size === 0) entries.delete(key);
+			else entries.set(key, entry);
+		}
 	};
 }
-function isInputEdit(edit) {
-	return "input" in edit;
+
+//#endregion
+//#region src/row-list.ts
+/** Read-only array views keep append publication independent of existing list length. */
+function indexOf(property) {
+	if (typeof property !== "string" || !/^(0|[1-9]\d*)$/u.test(property)) return void 0;
+	return Number(property);
 }
-function coverage(selected, total) {
-	if (selected === 0 || total === 0) return "none";
-	return selected === total ? "all" : "some";
+function rowList(length, read) {
+	return new Proxy([], {
+		get(target, property, receiver) {
+			if (property === "length") return length;
+			const index = indexOf(property);
+			return index === void 0 ? Reflect.get(target, property, receiver) : index < length ? read(index) : void 0;
+		},
+		has(target, property) {
+			const index = indexOf(property);
+			return index === void 0 ? Reflect.has(target, property) : index < length;
+		},
+		ownKeys: () => [...Array.from({ length }, (_, index) => String(index)), "length"],
+		getOwnPropertyDescriptor(target, property) {
+			if (property === "length") return {
+				...Reflect.getOwnPropertyDescriptor(target, property),
+				value: length
+			};
+			const index = indexOf(property);
+			return index === void 0 ? Reflect.getOwnPropertyDescriptor(target, property) : index < length ? {
+				configurable: true,
+				enumerable: true,
+				writable: false,
+				value: read(index)
+			} : void 0;
+		},
+		set: () => false,
+		deleteProperty: () => false,
+		defineProperty: () => false,
+		preventExtensions: () => false,
+		setPrototypeOf: () => false
+	});
 }
-/** Create a data table. */
-function createTable(options) {
-	const selectionMode = options.selectionMode ?? "multiple";
-	const selectScope = options.selectScope ?? "all";
-	const manual = options.manual ?? false;
-	const undoStack = createUndoStack(options.historyLimit);
-	const listeners = /* @__PURE__ */ new Set();
-	let data = options.data;
-	let definitions = options.columns;
-	let rowCount = options.rowCount;
-	const initialState = createInitialState({
-		...options.initialState,
-		hiddenColumns: options.initialState?.hiddenColumns ?? options.columns.filter((column) => column.hidden === true).map((column) => column.id)
+const stores = /* @__PURE__ */ new WeakMap();
+function appendList(previous, incoming) {
+	if (!incoming.length) return previous;
+	let store = stores.get(previous);
+	const last = store?.chunks.at(-1);
+	if (!store || last && last.start + last.rows.length !== previous.length) store = { chunks: [{
+		start: 0,
+		rows: previous
+	}] };
+	store.chunks.push({
+		start: previous.length,
+		rows: incoming
 	});
-	let state = initialState;
-	let snapshot;
-	const readKey = (row, index) => {
-		const { rowKey } = options;
-		if (typeof rowKey === "function") return rowKey(row, index);
-		const value = getPath(row, rowKey ?? "id");
-		if (typeof value === "string" || typeof value === "number") return value;
-		return rowKey === void 0 || !isRecord(row) ? index : String(value);
-	};
-	const resolveColumns = memo((defs) => {
-		const columns = defs.map((definition) => resolveColumn(definition));
-		return {
-			columns,
-			byId: new Map(columns.map((column) => [column.id, column]))
-		};
+	const chunks = store.chunks;
+	const result = rowList(previous.length + incoming.length, (index) => {
+		let low = 0;
+		let high = chunks.length - 1;
+		while (low < high) {
+			const mid = Math.ceil((low + high) / 2);
+			if (chunks[mid].start <= index) low = mid;
+			else high = mid - 1;
+		}
+		const chunk = chunks[low];
+		return chunk.rows[index - chunk.start];
 	});
-	const indexRows = memo((rows, byId) => {
-		const byKey = /* @__PURE__ */ new Map();
-		const issues = [];
-		return {
-			rows: rows.map((original, index) => {
-				let key = readKey(original, index);
-				if (byKey.has(key)) {
-					issues.push(issue("duplicate_row_key", `Row ${index} repeats the key "${String(key)}"; it is keyed "${String(key)}#${index}" instead.`, { rowKey: key }));
-					key = `${String(key)}#${index}`;
-				}
-				const row = createRow(original, key, index, byId);
-				byKey.set(key, row);
-				return row;
-			}),
+	stores.set(result, store);
+	return result;
+}
+function mapList(rows, map) {
+	const cache = /* @__PURE__ */ new Map();
+	return rowList(rows.length, (index) => {
+		if (!cache.has(index)) cache.set(index, map(rows[index], index));
+		return cache.get(index);
+	});
+}
+
+//#endregion
+//#region src/stream.ts
+function createStream(host) {
+	let active;
+	return {
+		cancel() {
+			active?.cancel();
+			active = void 0;
+		},
+		async run(source, options = {}) {
+			active?.cancel();
+			const problems = [];
+			const requested = options.batchSize ?? 1e3;
+			const batchSize = Number.isSafeInteger(requested) && requested > 0 ? requested : 1e3;
+			if (batchSize !== requested) problems.push(issue("invalid_stream_option", "batchSize must be a positive safe integer; 1,000 is used."));
+			const requestedCount = options.expectedRowCount;
+			const expected = requestedCount === void 0 || Number.isSafeInteger(requestedCount) && requestedCount >= 0 ? requestedCount : void 0;
+			if (expected !== requestedCount) problems.push(issue("invalid_stream_option", "expectedRowCount must be a non-negative safe integer; it is unknown instead."));
+			let cancelled = false;
+			let wake = () => void 0;
+			const cancellation = new Promise((resolve) => {
+				wake = () => resolve(void 0);
+			});
+			const cancel = () => {
+				cancelled = true;
+				wake();
+			};
+			const run = { cancel };
+			active = run;
+			const signal = options.signal;
+			signal?.addEventListener?.("abort", cancel, { once: true });
+			if (signal?.aborted) run.cancel();
+			let receivedRowCount = 0;
+			let status = "done";
+			let iterator;
+			host.update(cancelled ? "aborted" : "loading", expected, problems, true);
+			try {
+				if (!cancelled) iterator = source[Symbol.asyncIterator]();
+				while (true) {
+					if (cancelled || !iterator) break;
+					const next = await Promise.race([iterator.next(), cancellation]);
+					if (!next || cancelled || signal?.aborted) {
+						run.cancel();
+						break;
+					}
+					if (next.done) break;
+					const rows = Array.isArray(next.value) ? next.value : [next.value];
+					for (let start = 0; start < rows.length; start += batchSize) {
+						await Promise.resolve();
+						if (cancelled || signal?.aborted) {
+							run.cancel();
+							break;
+						}
+						host.update("streaming", expected, problems, false);
+						const result = host.ingest(rows.slice(start, start + batchSize), options.mode ?? "append");
+						receivedRowCount += result.appended + result.replaced;
+						problems.push(...result.issues);
+					}
+				}
+			} catch (error) {
+				status = "error";
+				problems.push(issue("stream_error", error instanceof Error ? error.message : String(error)));
+			} finally {
+				signal?.removeEventListener?.("abort", cancel);
+				if (cancelled) status = "aborted";
+				if (active === run) {
+					active = void 0;
+					host.update(status, expected, problems, true);
+				}
+				if (status !== "done" && iterator?.return) Promise.resolve().then(() => iterator.return()).catch(() => void 0);
+			}
+			return Object.freeze({
+				status,
+				receivedRowCount,
+				issues: Object.freeze([...problems])
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/tree.ts
+function buildTree(data, columns, readKey, options, lazy) {
+	const nodes = [];
+	const byKey = /* @__PURE__ */ new Map();
+	const issues = [];
+	const nested = options.getChildren !== void 0;
+	let maxDepth = options.maxDepth ?? 1e3;
+	if (!Number.isSafeInteger(maxDepth) || maxDepth < 1) {
+		issues.push(issue("invalid_tree_option", "maxDepth must be a positive safe integer; 1,000 is used."));
+		maxDepth = 1e3;
+	}
+	if (nested && options.getParentKey) issues.push(issue("invalid_tree_option", "Both tree inputs were supplied; getChildren takes precedence."));
+	const seen = /* @__PURE__ */ new Set();
+	const stack = data.map((original, sourceIndex) => ({
+		original,
+		sourceIndex,
+		parent: void 0,
+		lazy: false
+	})).reverse();
+	while (stack.length) {
+		const entry = stack.pop();
+		const index = nodes.length;
+		let key = readKey(entry.original, index);
+		let parent = entry.parent;
+		const reference = entry.original !== null && (typeof entry.original === "object" || typeof entry.original === "function");
+		const repeated = nested && reference && seen.has(entry.original);
+		if (repeated) {
+			issues.push(issue("tree_cycle", "A repeated nested value recovers as a root without traversing it again.", { rowKey: key }));
+			parent = void 0;
+		}
+		if (reference) seen.add(entry.original);
+		if (byKey.has(key)) {
+			issues.push(issue(entry.lazy ? "tree_duplicate_key" : "duplicate_row_key", entry.lazy ? "A loaded child repeats an existing key and is rejected." : "A repeated row key is replaced with a unique key.", { rowKey: key }));
+			if (entry.lazy) continue;
+			const prefix = `${String(key)}#${index}`;
+			key = prefix;
+			let suffix = 0;
+			while (byKey.has(key)) key = `${prefix}#${++suffix}`;
+		}
+		if (parent && parent.depth + 1 > maxDepth) {
+			issues.push(issue("tree_depth_exceeded", "The maximum tree depth was exceeded; this row recovers as a root.", { rowKey: key }));
+			parent = void 0;
+		}
+		const children = repeated ? void 0 : lazy.get(key) ?? options.getChildren?.(entry.original);
+		const node = {
+			row: createRow(entry.original, key, index, columns),
+			parent,
+			children: [],
+			depth: parent ? parent.depth + 1 : 0,
+			sourceIndex: entry.sourceIndex,
+			lazy: entry.lazy,
+			writable: parent?.writable ?? entry.parent === void 0,
+			unloaded: children === void 0 && (options.hasChildren?.(entry.original) ?? false)
+		};
+		nodes.push(node);
+		byKey.set(key, node);
+		if (parent) parent.children.push(node);
+		if (children) for (let i = children.length - 1; i >= 0; i--) stack.push({
+			original: children[i],
+			sourceIndex: i,
+			parent: node,
+			lazy: entry.lazy || lazy.has(key)
+		});
+	}
+	if (!nested && options.getParentKey) {
+		for (const node of nodes) {
+			if (node.lazy) continue;
+			const key = options.getParentKey(node.row.original);
+			if (key === void 0 || key === null) continue;
+			const parent = byKey.get(key);
+			if (!parent) issues.push(issue("tree_orphan", "The parent is missing; this row recovers as a root.", { rowKey: node.row.key }));
+			else node.parent = parent;
+		}
+		const done = /* @__PURE__ */ new Set();
+		for (const node of nodes) {
+			const path = [];
+			const visiting = /* @__PURE__ */ new Set();
+			let cursor = node;
+			while (cursor && !done.has(cursor)) {
+				if (visiting.has(cursor)) {
+					issues.push(issue("tree_cycle", "A cyclic parent reference is detached to a root.", { rowKey: cursor.row.key }));
+					cursor.parent = void 0;
+					break;
+				}
+				visiting.add(cursor);
+				path.push(cursor);
+				cursor = cursor.parent;
+			}
+			for (let i = path.length - 1; i >= 0; i--) {
+				const current = path[i];
+				done.add(current);
+			}
+		}
+		for (const node of nodes) node.children = [];
+		for (const node of nodes) if (node.parent) node.parent.children.push(node);
+		const pending = nodes.filter((node) => !node.parent);
+		while (pending.length) {
+			const node = pending.pop();
+			node.depth = node.parent ? node.parent.depth + 1 : 0;
+			if (node.depth > maxDepth) {
+				node.parent = void 0;
+				node.depth = 0;
+				issues.push(issue("tree_depth_exceeded", "The maximum tree depth was exceeded; this row recovers as a root.", { rowKey: node.row.key }));
+			}
+			for (const child of node.children) pending.push(child);
+		}
+		for (const node of nodes) node.children = node.children.filter((child) => child.parent === node);
+	}
+	return {
+		nodes,
+		rows: nodes.map((node) => node.row),
+		roots: nodes.filter((node) => !node.parent),
+		byKey,
+		issues
+	};
+}
+function processTree(model, columns, state, mode, manual) {
+	const raw = model.nodes.map((node) => node.row);
+	const matched = manual ? raw : filterRows(raw, columns, state.search, state.filters);
+	const active = matched !== raw;
+	const included = new Set(matched.map((row) => row.key));
+	const autoExpanded = /* @__PURE__ */ new Set();
+	if (active && mode !== "strict") {
+		if (mode === "descendants") {
+			const stack = matched.map((row) => model.byKey.get(row.key));
+			const visited = /* @__PURE__ */ new Set();
+			while (stack.length) {
+				const node = stack.pop();
+				if (visited.has(node.row.key)) continue;
+				visited.add(node.row.key);
+				included.add(node.row.key);
+				if (node.children.length) autoExpanded.add(node.row.key);
+				for (const child of node.children) stack.push(child);
+			}
+		}
+		for (const row of matched) {
+			let parent = model.byKey.get(row.key).parent;
+			while (parent && !autoExpanded.has(parent.row.key)) {
+				included.add(parent.row.key);
+				autoExpanded.add(parent.row.key);
+				parent = parent.parent;
+			}
+		}
+	}
+	if (active && mode === "strict") return {
+		model,
+		roots: ordered(model.nodes.filter((node) => included.has(node.row.key) && node.children.length === 0 && !node.unloaded)),
+		children: /* @__PURE__ */ new Map(),
+		autoExpanded
+	};
+	const children = /* @__PURE__ */ new Map();
+	for (const node of model.nodes) if (node.children.length) children.set(node, ordered(node.children.filter((child) => included.has(child.row.key))));
+	return {
+		model,
+		roots: ordered(model.roots.filter((node) => included.has(node.row.key))),
+		children,
+		autoExpanded
+	};
+	function ordered(nodes) {
+		if (manual || !state.sorting.length || nodes.length < 2) return nodes;
+		return sortRows(nodes.map((node) => node.row), columns, state.sorting).map((row) => model.byKey.get(row.key));
+	}
+}
+/** Expansion changes reuse filtering and sibling order, splicing only a changed subtree. */
+function createTreeFlattener() {
+	let previous;
+	let previousExpanded = [];
+	let visible = [];
+	let previousAncestors;
+	return (tree, expanded, ancestors) => {
+		if (tree === previous && expanded === previousExpanded && ancestors === previousAncestors) return visible;
+		const keys = expanded === true ? void 0 : new Set(expanded);
+		const open = (node) => expanded === true || (keys?.has(node.row.key) ?? false) || ancestors.has(node.row.key) || tree.autoExpanded.has(node.row.key);
+		const walk = (roots) => {
+			const output = [];
+			const stack = [...roots].reverse();
+			while (stack.length) {
+				const node = stack.pop();
+				output.push(node);
+				if (open(node)) {
+					const children = tree.children.get(node) ?? [];
+					for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+				}
+			}
+			return output;
+		};
+		let changed;
+		if (previous === tree && ancestors === previousAncestors && expanded !== true && previousExpanded !== true) {
+			const before = new Set(previousExpanded);
+			const after = new Set(expanded);
+			changed = [...previousExpanded.filter((key) => !after.has(key)), ...expanded.filter((key) => !before.has(key))];
+		}
+		if (changed?.length === 1 && !tree.autoExpanded.has(changed[0])) {
+			const index = visible.findIndex((node) => node.row.key === changed[0]);
+			if (index >= 0) {
+				const node = visible[index];
+				let end = index + 1;
+				while (end < visible.length && visible[end].depth > node.depth) end++;
+				const inserted = walk(open(node) ? tree.children.get(node) ?? [] : []);
+				visible = visible.slice(0, index + 1).concat(inserted, visible.slice(end));
+			}
+		} else visible = walk(tree.roots);
+		previous = tree;
+		previousExpanded = expanded;
+		previousAncestors = ancestors;
+		return visible;
+	};
+}
+
+//#endregion
+//#region src/table.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function memo(compute) {
+	let last;
+	return (...deps) => {
+		if (last && last.deps.length === deps.length && last.deps.every((d, i) => Object.is(d, deps[i]))) return last.result;
+		const result = compute(...deps);
+		last = {
+			deps,
+			result
+		};
+		return result;
+	};
+}
+function isInputEdit(edit) {
+	return "input" in edit;
+}
+function coverage(selected, total) {
+	if (selected === 0 || total === 0) return "none";
+	return selected === total ? "all" : "some";
+}
+function pasteLimit(value, fallback, name, issues) {
+	if (value === void 0) return fallback;
+	if (Number.isSafeInteger(value) && value > 0) return value;
+	issues.push(issue("invalid_paste_limit", `Paste ${name} ${String(value)} is not a positive safe integer; ${fallback} is used.`));
+	return fallback;
+}
+/** Create a data table. */
+function createTable(options) {
+	const paginate = options.paginate ?? true;
+	const expandMode = options.expandMode ?? "multiple";
+	const selectionMode = options.selectionMode ?? "multiple";
+	const selectScope = options.selectScope ?? "all";
+	const manual = options.manual ?? false;
+	let treeFilter = options.treeFilter ?? "ancestors";
+	const treeEnabled = Boolean(options.getChildren || options.getParentKey || options.hasChildren || options.loadChildren);
+	const rootPagination = treeEnabled && (manual || (options.paginateBy ?? "root") === "root");
+	const projectedRows = /* @__PURE__ */ new WeakMap();
+	function shareRow(base, next) {
+		const previous = projectedRows.get(base);
+		if (previous && Object.keys(next).every((key) => previous[key] === next[key])) return previous;
+		projectedRows.set(base, next);
+		return next;
+	}
+	let lazyVersion = 0;
+	const lazyChildren = /* @__PURE__ */ new Map();
+	const childStatuses = /* @__PURE__ */ new Map();
+	const loadIssues = /* @__PURE__ */ new Map();
+	const loadValidationIssues = /* @__PURE__ */ new Map();
+	const pendingLoads = /* @__PURE__ */ new Map();
+	let destroyed = false;
+	const undoStack = createUndoStack(options.historyLimit);
+	const pendingChanges = createPendingChanges();
+	const listeners = /* @__PURE__ */ new Set();
+	const optionIssues = [];
+	const maxPasteCells = pasteLimit(options.pasteLimit?.maxCells, 1e5, "maxCells", optionIssues);
+	const maxPasteLength = pasteLimit(options.pasteLimit?.maxLength, 5e6, "maxLength", optionIssues);
+	const sourceExpected = options.expectedRowCount === void 0 || Number.isSafeInteger(options.expectedRowCount) && options.expectedRowCount >= 0 ? options.expectedRowCount : void 0;
+	if (sourceExpected !== options.expectedRowCount) optionIssues.push(issue("invalid_stream_option", "expectedRowCount must be a non-negative safe integer; it is unknown instead."));
+	let data = options.data;
+	let definitions = options.columns;
+	let rowCount = options.rowCount;
+	let expandedIssue;
+	let initialState = createInitialState({
+		...options.initialState,
+		hiddenColumns: options.initialState?.hiddenColumns ?? options.columns.filter((column) => column.hidden === true).map((column) => column.id)
+	}, (problem) => {
+		expandedIssue = problem;
+	});
+	let state = initialState;
+	let snapshot;
+	let loadState = "idle";
+	let expectedRowCount = sourceExpected;
+	let ingestionIssues = [];
+	let streamIssues = [];
+	const streaming = createStream({
+		ingest: (rows, mode) => ingestData(rows, mode),
+		update(next, expected, problems, publish) {
+			loadState = next;
+			expectedRowCount = expected;
+			streamIssues = [...problems];
+			if (publish) notify();
+		}
+	});
+	let transaction = false;
+	let deferValidationNotify = false;
+	let validationNotifyRequested = false;
+	const validation = createEditValidation({
+		snapshot: getSnapshot,
+		apply: applyChanges,
+		notify,
+		writeIssue(row, next) {
+			const node = treeEnabled ? treeStage(data, resolveColumns(definitions).byId, lazyVersion).byKey.get(row.key) : void 0;
+			if (node && (!node.writable || node.parent && options.getChildren && !options.setChildren)) return issue("read_only_cell", "This nested row has no immutable writable source path.", { rowKey: row.key });
+			if (readKey(next, row.index) !== readKey(row.original, row.index)) return issue("invalid_row_operation", "Editing a row key is not supported; remove and insert the row instead.", { rowKey: row.key });
+		},
+		batch(run) {
+			deferValidationNotify = true;
+			validationNotifyRequested = false;
+			try {
+				return run();
+			} finally {
+				deferValidationNotify = false;
+				if (validationNotifyRequested) notify();
+			}
+		},
+		record: (changes) => undoStack.record({
+			kind: "cells",
+			changes
+		}),
+		onIssues: (issues) => options.onEditIssues?.(issues),
+		optimistic: options.asyncValidation === "optimistic",
+		validateRow: options.validateRow
+	});
+	const readKey = (row, index) => {
+		const { rowKey } = options;
+		if (typeof rowKey === "function") return rowKey(row, index);
+		const value = getPath(row, rowKey ?? "id");
+		if (typeof value === "string" || typeof value === "number") return value;
+		return rowKey === void 0 || !isRecord(row) ? index : String(value);
+	};
+	const resolveColumns = memo((defs) => {
+		const issues = [];
+		const columns = defs.flatMap((definition) => {
+			if (!isSafePath(definition.id)) {
+				issues.push(issue("unsafe_path", `The column "${definition.id}" addresses a prototype and is ignored.`, { column: definition.id }));
+				return [];
+			}
+			return [resolveColumn(definition)];
+		});
+		return {
+			columns,
+			byId: new Map(columns.map((column) => [column.id, column])),
+			issues
+		};
+	});
+	let primedIndex;
+	let reusableRows;
+	const indexRows = memo((rows, byId) => {
+		if (primedIndex?.data === rows && primedIndex.columns === byId) return primedIndex.result;
+		const byKey = /* @__PURE__ */ new Map();
+		const issues = [];
+		const indexed = rows.map((original, index) => {
+			let key = readKey(original, index);
+			if (byKey.has(key)) {
+				issues.push(issue("duplicate_row_key", `Row ${index} repeats the key "${String(key)}"; it is keyed "${String(key)}#${index}" instead.`, { rowKey: key }));
+				key = `${String(key)}#${index}`;
+			}
+			const previous = reusableRows?.columns === byId ? reusableRows.rows.get(key) : void 0;
+			const row = previous?.original === original && previous.index === index ? previous : createRow(original, key, index, byId, options.getRowCanExpand?.(original) ?? false);
+			byKey.set(key, row);
+			return row;
+		});
+		stableSource.set(rows, stableRows(rows));
+		reusableRows = {
+			columns: byId,
+			rows: byKey
+		};
+		return {
+			rows: indexed,
 			byKey,
 			issues
 		};
 	});
+	const treeStage = memo((rows, byId, _version) => buildTree(rows, byId, readKey, options, lazyChildren));
+	const treeIndex = memo((model) => ({
+		rows: model.rows,
+		byKey: new Map(model.rows.map((row) => [row.key, row])),
+		issues: model.issues
+	}));
+	const treePositions = memo((model) => {
+		const result = /* @__PURE__ */ new Map();
+		const index = (siblings, parent) => {
+			siblings.forEach((node, position) => result.set(node.row.key, Object.freeze({
+				parent,
+				before: siblings[position + 1]?.row.key
+			})));
+		};
+		index(model.roots);
+		for (const node of model.nodes) index(node.children, node.row.key);
+		return result;
+	});
+	const processedTreeStage = memo((model, columns, search, filters, sorting, mode) => processTree(model, columns, {
+		...state,
+		search,
+		filters,
+		sorting
+	}, mode, manual));
+	const flattenTree = createTreeFlattener();
+	const emptyAncestors = /* @__PURE__ */ new Set();
+	const singleTreePath = memo((model, expanded) => {
+		const ancestors = /* @__PURE__ */ new Set();
+		if (expanded !== true) for (const key of expanded) {
+			let parent = model.byKey.get(key)?.parent;
+			while (parent && !ancestors.has(parent.row.key)) {
+				ancestors.add(parent.row.key);
+				parent = parent.parent;
+			}
+		}
+		return ancestors;
+	});
+	const treeSelection = memo((model, selection) => {
+		const selected = new Set(selection);
+		const counts = /* @__PURE__ */ new Map();
+		const stack = model.roots.map((node) => ({
+			node,
+			exit: false
+		}));
+		while (stack.length) {
+			const { node, exit } = stack.pop();
+			if (!exit) {
+				stack.push({
+					node,
+					exit: true
+				});
+				for (const child of node.children) stack.push({
+					node: child,
+					exit: false
+				});
+			} else {
+				let count = selected.has(node.row.key) ? 1 : 0;
+				let total = 1;
+				for (const child of node.children) {
+					const value = counts.get(child);
+					count += value.selected;
+					total += value.total;
+				}
+				counts.set(node, {
+					selected: count,
+					total
+				});
+			}
+		}
+		return counts;
+	});
 	const orderColumns = memo((columns, columnOrder, hiddenColumns) => {
 		const position = new Map(columnOrder.map((id, index) => [id, index]));
 		const ordered = columns.map((column, index) => ({
@@ -759,11 +2025,43 @@ function createTable(options) {
 			visible: ordered.filter((column) => !hidden.has(column.id))
 		};
 	});
-	const filterStage = memo(filterRows);
-	const sortStage = memo(sortRows);
+	let primedFilter;
+	let primedSort;
+	const filterStage = memo((rows, columns, search, filters) => primedFilter?.rows === rows && primedFilter.columns === columns && primedFilter.search === search && primedFilter.filters === filters ? primedFilter.result : filterRows(rows, columns, search, filters));
+	const sortStage = memo((rows, columns, sorting) => primedSort?.rows === rows && primedSort.columns === columns && primedSort.sorting === sorting ? primedSort.result : sortRows(rows, columns, sorting));
+	const rowMembership = /* @__PURE__ */ new WeakMap();
+	function membership(rows) {
+		let keys = rowMembership.get(rows);
+		if (!keys) {
+			keys = new Set(rows.map((row) => row.key));
+			rowMembership.set(rows, keys);
+		}
+		return keys;
+	}
 	const selectedSet = memo((selection) => new Set(selection));
+	const expansionStage = memo((indexed, expanded, selection) => {
+		const keys = expanded === true ? void 0 : new Set(expanded);
+		const selected = new Set(selection);
+		const rows = mapList(indexed.rows, (row) => {
+			const isExpanded = row.canExpand && (expanded === true || (keys?.has(row.key) ?? false));
+			return isExpanded || selected.has(row.key) ? shareRow(row, Object.freeze({
+				...row,
+				isExpanded,
+				selection: selected.has(row.key) ? "all" : "none"
+			})) : row;
+		});
+		return {
+			rows,
+			byKey: { get(key) {
+				const row = indexed.byKey.get(key);
+				return row && row.index < rows.length ? rows[row.index] : void 0;
+			} }
+		};
+	});
+	const expandedOrder = memo((rows, byKey) => mapList(rows, (row) => byKey.get(row.key)));
 	function stateIssues(byId) {
 		const issues = [];
+		if (expandedIssue) issues.push(expandedIssue);
 		const referenced = /* @__PURE__ */ new Set([
 			...state.sorting.map((rule) => rule.column),
 			...Object.keys(state.filters),
@@ -772,30 +2070,105 @@ function createTable(options) {
 		]);
 		for (const id of referenced) if (!byId.has(id)) issues.push(issue("unknown_column", `The state refers to a column "${id}" that is not defined.`, { column: id }));
 		const { pageSize } = state.pagination;
-		if (!Number.isInteger(pageSize) || pageSize < 1) issues.push(issue("invalid_page_size", `Page size ${String(pageSize)} is not a positive whole number; ${10} is used.`));
+		if (paginate && (!Number.isInteger(pageSize) || pageSize < 1)) issues.push(issue("invalid_page_size", `Page size ${String(pageSize)} is not a positive whole number; ${10} is used.`));
 		return issues;
 	}
 	function computeSnapshot() {
-		const { columns, byId } = resolveColumns(definitions);
-		const indexed = indexRows(data, byId);
+		const cellProblems = validation.problems();
+		const dirty = new Set(pendingChanges.entries.keys());
+		const metadata = (row) => dirty.has(row.key) || cellProblems.has(row.key) ? shareRow(row, Object.freeze({
+			...row,
+			isDirty: dirty.has(row.key),
+			cellIssues: cellProblems.get(row.key)
+		})) : row;
+		const { columns, byId, issues: columnIssues } = resolveColumns(definitions);
+		const model = treeEnabled ? treeStage(data, byId, lazyVersion) : void 0;
+		const indexed = model ? {
+			rows: model.rows,
+			issues: model.issues
+		} : indexRows(data, byId);
+		const expanded = model ? void 0 : expansionStage(indexed, state.expanded, state.selection);
 		const ordered = orderColumns(columns, state.columnOrder, state.hiddenColumns);
-		const issues = [...indexed.issues, ...stateIssues(byId)];
+		const issues = [
+			...optionIssues,
+			...ingestionIssues,
+			...streamIssues,
+			...columnIssues,
+			...indexed.issues,
+			...stateIssues(byId),
+			...loadIssues.values(),
+			...Array.from(loadValidationIssues.values()).flat(),
+			...Array.from(cellProblems.values()).flatMap((row) => [...row.values()])
+		];
 		const requestedSize = state.pagination.pageSize;
-		const pageSize = Number.isInteger(requestedSize) && requestedSize >= 1 ? requestedSize : 10;
+		let pageSize = Number.isInteger(requestedSize) && requestedSize >= 1 ? requestedSize : 10;
 		let processedRows;
 		let rows;
 		let filteredCount;
 		let page;
 		let pageCount;
-		if (manual) {
-			processedRows = indexed.rows;
-			rows = indexed.rows;
+		let treeRow;
+		let totalCount = indexed.rows.length;
+		if (model) {
+			const processed = processedTreeStage(model, columns, state.search, state.filters, state.sorting, treeFilter);
+			const ancestors = expandMode === "single" ? singleTreePath(model, state.expanded) : emptyAncestors;
+			const visible = flattenTree(processed, state.expanded, ancestors);
+			const expandedState = state.expanded;
+			const keys = state.expanded === true ? void 0 : new Set(state.expanded);
+			const selected = treeSelection(model, state.selection);
+			const projected = /* @__PURE__ */ new Map();
+			const statuses = new Map(childStatuses);
+			treeRow = (key) => {
+				const cached = projected.get(key);
+				if (cached) return cached;
+				const node = model.byKey.get(key);
+				if (!node) return void 0;
+				const status = statuses.get(key) ?? (node.children.length || !node.unloaded ? "loaded" : "idle");
+				const count = selected.get(node);
+				const canExpand = node.children.length > 0 || status !== "loaded" || (options.getRowCanExpand?.(node.row.original) ?? false);
+				const result = shareRow(node.row, Object.freeze({
+					...node.row,
+					isDirty: dirty.has(key),
+					cellIssues: cellProblems.get(key),
+					depth: node.depth,
+					parentKey: node.parent?.row.key,
+					childCount: status === "loaded" ? node.children.length : void 0,
+					childStatus: status,
+					canExpand,
+					isExpanded: canExpand && (expandedState === true || (keys?.has(key) ?? false) || ancestors.has(key) || processed.autoExpanded.has(key)),
+					selection: coverage(count.selected, count.total)
+				}));
+				projected.set(key, result);
+				return result;
+			};
+			processedRows = visible.map((node) => treeRow(node.row.key));
+			filteredCount = manual ? rowCount ?? model.roots.length : rootPagination ? processed.roots.length : visible.length;
+			totalCount = rootPagination ? model.roots.length : model.nodes.length;
+			pageCount = countPages(filteredCount, pageSize);
+			page = clampPage(state.pagination.page, pageCount);
+			if (manual) rows = processedRows;
+			else if (rootPagination) {
+				const roots = new Set(processed.roots.slice((page - 1) * pageSize, page * pageSize));
+				const allRoots = new Set(processed.roots);
+				let root;
+				rows = processedRows.filter((_row, index) => {
+					const node = visible[index];
+					if (allRoots.has(node)) root = node;
+					return root !== void 0 && roots.has(root);
+				});
+			} else rows = paginateRows(processedRows, {
+				page,
+				pageSize
+			});
+		} else if (manual) {
+			processedRows = expanded.rows;
+			rows = expanded.rows;
 			filteredCount = rowCount ?? indexed.rows.length;
 			pageCount = countPages(filteredCount, pageSize);
 			page = clampPage(state.pagination.page, pageCount);
 		} else {
 			const filtered = filterStage(indexed.rows, columns, state.search, state.filters);
-			processedRows = sortStage(filtered, columns, state.sorting);
+			processedRows = expandedOrder(sortStage(filtered, columns, state.sorting), expanded.byKey);
 			filteredCount = processedRows.length;
 			pageCount = countPages(filteredCount, pageSize);
 			page = clampPage(state.pagination.page, pageCount);
@@ -804,42 +2177,90 @@ function createTable(options) {
 				pageSize
 			});
 		}
+		if (!paginate) {
+			rows = processedRows;
+			page = 1;
+			pageCount = 1;
+			pageSize = Math.max(1, rows.length);
+		}
+		const flatProjected = /* @__PURE__ */ new Map();
+		if (!model) {
+			const project = (row) => {
+				let result = flatProjected.get(row.key);
+				if (!result) {
+					result = metadata(row);
+					flatProjected.set(row.key, result);
+				}
+				return result;
+			};
+			const shared = rows === processedRows;
+			processedRows = mapList(processedRows, project);
+			rows = shared ? processedRows : rows.map(project);
+		}
 		const selected = selectedSet(state.selection);
-		const pageSelected = rows.filter((row) => selected.has(row.key)).length;
+		const allData = model ? model.byKey : indexed.byKey;
+		const allProcessedKeys = model ? void 0 : manual ? void 0 : membership(filterStage(indexed.rows, columns, state.search, state.filters));
+		const selectedInProcessed = state.selection.filter((key) => allData.has(key) && (!allProcessedKeys || allProcessedKeys.has(key))).length;
+		const pageSelected = rows === processedRows ? selectedInProcessed : rows.filter((row) => selected.has(row.key)).length;
 		const scopeRows = selectScope === "page" || manual ? rows : processedRows;
-		const scopeSelected = scopeRows === rows ? pageSelected : scopeRows.filter((row) => selected.has(row.key)).length;
+		const scopeSelected = scopeRows === rows ? pageSelected : model ? scopeRows.filter((row) => selected.has(row.key)).length : selectedInProcessed;
 		const pageStart = rows.length === 0 ? 0 : (page - 1) * pageSize + 1;
 		const sortIndex = new Map(state.sorting.map((rule, priority) => [rule.column, {
 			direction: rule.direction,
 			priority
 		}]));
 		return Object.freeze({
+			tree: treeEnabled,
+			loadState,
+			loadedRowCount: indexed.rows.length,
+			expectedRowCount,
 			state,
 			columns: ordered.visible,
 			allColumns: ordered.all,
 			rows,
+			renderItems: !model && state.expanded !== true && state.expanded.length === 0 ? mapList(rows, (row, rowIndex) => Object.freeze({
+				kind: "row",
+				key: getRowItemKey(row.key),
+				row,
+				rowIndex
+			})) : Object.freeze(rows.flatMap((row, rowIndex) => {
+				const item = Object.freeze({
+					kind: "row",
+					key: getRowItemKey(row.key),
+					row,
+					rowIndex
+				});
+				return row.isExpanded && (!model || (options.getRowCanExpand?.(row.original) ?? false)) ? [item, Object.freeze({
+					kind: "detail",
+					key: getRowItemKey(row.key, "detail"),
+					row,
+					rowIndex
+				})] : [item];
+			})),
+			paginate,
 			processedRows,
 			page,
 			pageSize,
 			pageCount,
 			rowCount: filteredCount,
-			totalRowCount: manual ? filteredCount : indexed.rows.length,
+			totalRowCount: manual ? filteredCount : totalCount,
 			pageStart,
-			pageEnd: rows.length === 0 ? 0 : pageStart + rows.length - 1,
+			pageEnd: rows.length === 0 ? 0 : rootPagination ? Math.min(filteredCount, page * pageSize) : pageStart + rows.length - 1,
 			pageItems: paginationItems(page, pageCount),
 			canPreviousPage: page > 1,
 			canNextPage: page < pageCount,
 			selectionMode,
-			selectedCount: state.selection.length,
+			selectedCount: model ? state.selection.filter((key) => model.byKey.has(key)).length : state.selection.length,
 			pageSelection: coverage(pageSelected, rows.length),
 			allSelection: coverage(scopeSelected, scopeRows.length),
 			canUndo: undoStack.canUndo,
 			canRedo: undoStack.canRedo,
 			issues: Object.freeze(issues),
+			pendingCells: validation.cells(),
 			isSelected: (key) => selected.has(key),
 			getSort: (columnId) => sortIndex.get(columnId),
 			getColumn: (columnId) => byId.get(columnId),
-			getRow: (key) => indexed.byKey.get(key)
+			getRow: (key) => treeRow ? treeRow(key) : flatProjected.get(key) ?? (expanded.byKey.get(key) ? metadata(expanded.byKey.get(key)) : void 0)
 		});
 	}
 	function getSnapshot() {
@@ -848,18 +2269,140 @@ function createTable(options) {
 	}
 	function notify() {
 		snapshot = void 0;
+		if (deferValidationNotify) {
+			validationNotifyRequested = true;
+			return;
+		}
+		if (transaction) return;
 		if (listeners.size === 0) return;
 		const next = getSnapshot();
 		for (const listener of listeners) listener(next);
 	}
+	function abortLoads(all = false) {
+		for (const [key, controller] of pendingLoads) {
+			const row = all ? void 0 : getSnapshot().getRow(key);
+			const visible = !all && getSnapshot().processedRows.some((candidate) => candidate.key === key);
+			if (all || !row?.isExpanded || !visible) {
+				pendingLoads.delete(key);
+				childStatuses.delete(key);
+				controller.abort();
+				snapshot = void 0;
+			}
+		}
+	}
+	function requestChildren(row) {
+		if (!options.loadChildren || destroyed || pendingLoads.has(row.key) || lazyChildren.has(row.key) || row.childStatus === "loaded") return;
+		const key = row.key;
+		if (!options.createChildLoadController) {
+			childStatuses.set(key, "error");
+			loadIssues.set(key, issue("invalid_tree_option", "Lazy children require createChildLoadController from the caller's runtime.", { rowKey: key }));
+			notify();
+			return;
+		}
+		let controller;
+		try {
+			controller = options.createChildLoadController();
+		} catch (error) {
+			loadIssues.set(key, issue("tree_load_error", String(error), { rowKey: key }));
+			childStatuses.set(key, "error");
+			notify();
+			return;
+		}
+		pendingLoads.set(key, controller);
+		childStatuses.set(key, "loading");
+		loadIssues.delete(key);
+		loadValidationIssues.delete(key);
+		notify();
+		Promise.resolve().then(() => controller.signal.aborted ? [] : options.loadChildren(row, controller.signal)).then((children) => {
+			if (controller.signal.aborted || pendingLoads.get(key) !== controller || destroyed) return void 0;
+			const { byId } = resolveColumns(definitions);
+			const existing = treeStage(data, byId, lazyVersion);
+			const candidate = buildTree(children, byId, readKey, {
+				...options,
+				getParentKey: void 0
+			}, /* @__PURE__ */ new Map());
+			pendingLoads.delete(key);
+			loadValidationIssues.set(key, candidate.issues.filter((problem) => problem.code === "tree_cycle" || problem.code === "tree_depth_exceeded"));
+			if (candidate.nodes.filter((node) => existing.byKey.has(node.row.key)).length || candidate.issues.some((problem) => problem.code === "duplicate_row_key")) {
+				childStatuses.set(key, "error");
+				loadIssues.set(key, issue("tree_duplicate_key", "Loaded children collide with existing keys; the batch is rejected.", { rowKey: key }));
+			} else {
+				lazyChildren.set(key, children);
+				childStatuses.set(key, "loaded");
+				lazyVersion++;
+				if (state.selection.includes(key) && selectionMode === "multiple") {
+					const nextModel = treeStage(data, byId, lazyVersion);
+					applySelection([...state.selection, ...selectionKeys([key], nextModel)]);
+				}
+			}
+			notify();
+			startVisibleLoads();
+		}).catch((error) => {
+			if (controller.signal.aborted || pendingLoads.get(key) !== controller || destroyed) return;
+			pendingLoads.delete(key);
+			childStatuses.set(key, "error");
+			loadIssues.set(key, issue("tree_load_error", `Children could not be loaded: ${String(error)}`, { rowKey: key }));
+			notify();
+		});
+	}
+	function startVisibleLoads() {
+		if (!treeEnabled || !options.loadChildren || destroyed) return;
+		const current = getSnapshot();
+		for (const row of current.rows) if (row.isExpanded && row.childStatus === "idle") requestChildren(row);
+	}
+	function selectionKeys(keys, model) {
+		if (!treeEnabled || selectionMode !== "multiple") return [...keys];
+		model ??= treeStage(data, resolveColumns(definitions).byId, lazyVersion);
+		const result = new Set(keys);
+		const stack = keys.flatMap((key) => {
+			const node = model.byKey.get(key);
+			return node ? [node] : [];
+		});
+		const visited = /* @__PURE__ */ new Set();
+		while (stack.length) {
+			const node = stack.pop();
+			if (visited.has(node.row.key)) continue;
+			visited.add(node.row.key);
+			result.add(node.row.key);
+			for (const child of node.children) stack.push(child);
+		}
+		return [...result];
+	}
 	/** Apply a change made by a table operation. */
 	function commit(patch) {
 		const previous = state;
-		const next = mergeState(state, patch);
-		if (next === previous) return;
+		const previousIssue = expandedIssue;
+		const next = mergePatch(patch);
+		if (next === previous && previousIssue === expandedIssue) return;
 		state = next;
-		options.onStateChange?.(state, previous);
+		snapshot = void 0;
+		abortLoads();
+		if (next !== previous) options.onStateChange?.(state, previous);
 		notify();
+		startVisibleLoads();
+	}
+	function canonicalExpanded(expanded, candidate = state) {
+		if (expandMode === "multiple") return expanded;
+		if (expanded !== true) return expanded.slice(-1);
+		const { columns, byId } = resolveColumns(definitions);
+		if (treeEnabled) {
+			const model = treeStage(data, byId, lazyVersion);
+			const first = processedTreeStage(model, columns, candidate.search, candidate.filters, candidate.sorting, treeFilter).roots.find((node) => node.children.length > 0 || (options.hasChildren?.(node.row.original) ?? false) || (options.getRowCanExpand?.(node.row.original) ?? false));
+			return first ? [first.row.key] : [];
+		}
+		const indexed = indexRows(data, byId);
+		const first = (manual ? indexed.rows : sortStage(filterStage(indexed.rows, columns, candidate.search, candidate.filters), columns, candidate.sorting)).find((row) => row.canExpand);
+		return first ? [first.key] : [];
+	}
+	function mergePatch(patch) {
+		if (patch.expanded !== void 0) expandedIssue = void 0;
+		const next = mergeState(state, patch, (problem) => {
+			expandedIssue = problem;
+		});
+		return expandMode === "single" && patch.expanded !== void 0 ? mergeState(state, {
+			...patch,
+			expanded: canonicalExpanded(next.expanded, next)
+		}) : next;
 	}
 	const firstPage = () => ({
 		page: 1,
@@ -890,10 +2433,14 @@ function createTable(options) {
 		if (selection.length === current.length && selection.every((key, i) => key === current[i])) return;
 		commit({ selection });
 	}
-	function applyChanges(edits, record) {
+	function applyChanges(edits, record, recoveredIssues = []) {
 		const current = getSnapshot();
 		const working = [...data];
-		const issues = [];
+		const model = treeEnabled ? treeStage(data, resolveColumns(definitions).byId, lazyVersion) : void 0;
+		const replacements = /* @__PURE__ */ new Map();
+		const cache = new Map(lazyChildren);
+		const originalOf = (node) => replacements.get(node) ?? node.row.original;
+		const issues = [...recoveredIssues];
 		const changes = [];
 		const samples = /* @__PURE__ */ new Map();
 		const sampleOf = (columnId) => {
@@ -916,6 +2463,13 @@ function createTable(options) {
 				}));
 				continue;
 			}
+			if (!isSafePath(edit.column)) {
+				issues.push(issue("unsafe_path", `The path "${edit.column}" addresses a prototype and cannot be written.`, {
+					rowKey: edit.rowKey,
+					column: edit.column
+				}));
+				continue;
+			}
 			if (!column) {
 				issues.push(issue("unknown_column", `No column has the id "${edit.column}".`, {
 					rowKey: edit.rowKey,
@@ -923,7 +2477,22 @@ function createTable(options) {
 				}));
 				continue;
 			}
-			const original = working[row.index];
+			const node = model?.byKey.get(row.key);
+			const original = node ? originalOf(node) : working[row.index];
+			if (node && !node.writable) {
+				issues.push(issue("read_only_cell", "A recovered nested root has no unambiguous source path for editing.", {
+					rowKey: row.key,
+					column: column.id
+				}));
+				continue;
+			}
+			if (node?.parent && options.getChildren && !options.setChildren) {
+				issues.push(issue("read_only_cell", "Editing a nested child requires an immutable setChildren callback.", {
+					rowKey: row.key,
+					column: column.id
+				}));
+				continue;
+			}
 			if (record && !column.isEditable(original)) {
 				issues.push(issue("read_only_cell", `The "${column.id}" cell of row "${String(row.key)}" is read-only.`, {
 					rowKey: row.key,
@@ -945,7 +2514,16 @@ function createTable(options) {
 			} else value = edit.value;
 			const previous = column.getValue(original);
 			if (Object.is(previous, value)) continue;
-			const updated = column.setValue(original, value);
+			let updated;
+			try {
+				updated = column.setValue(original, value);
+			} catch (error) {
+				issues.push(issue("invalid_value", error instanceof Error ? error.message : String(error), {
+					rowKey: row.key,
+					column: column.id
+				}));
+				continue;
+			}
 			if (updated === void 0) {
 				issues.push(issue("read_only_cell", `The "${column.id}" column has no way to write a value.`, {
 					rowKey: row.key,
@@ -953,7 +2531,38 @@ function createTable(options) {
 				}));
 				continue;
 			}
-			working[row.index] = updated;
+			if (readKey(updated, row.index) !== readKey(original, row.index)) {
+				issues.push(issue("invalid_row_operation", "Editing a row key is not supported; remove and insert the row instead.", {
+					rowKey: row.key,
+					column: column.id
+				}));
+				continue;
+			}
+			if (!node) working[row.index] = updated;
+			else {
+				const planned = /* @__PURE__ */ new Map([[node, updated]]);
+				const plannedCache = /* @__PURE__ */ new Map();
+				let cursor = node;
+				try {
+					while (cursor.parent) {
+						const parent = cursor.parent;
+						const children = parent.children.map((child) => planned.get(child) ?? originalOf(child));
+						if (cursor.lazy) plannedCache.set(parent.row.key, children);
+						if (options.setChildren) planned.set(parent, options.setChildren(originalOf(parent), children));
+						cursor = parent;
+					}
+				} catch (error) {
+					issues.push(issue("invalid_value", error instanceof Error ? error.message : String(error), {
+						rowKey: row.key,
+						column: column.id
+					}));
+					continue;
+				}
+				for (const [item, plannedRow] of planned) replacements.set(item, plannedRow);
+				for (const [key, children] of plannedCache) cache.set(key, children);
+				if (!options.getChildren && !node.lazy) working[node.sourceIndex] = updated;
+				if (options.getChildren || options.setChildren) working[cursor.sourceIndex] = originalOf(cursor);
+			}
 			changes.push({
 				rowKey: row.key,
 				column: column.id,
@@ -967,16 +2576,389 @@ function createTable(options) {
 		else {
 			status = issues.length > 0 ? "partial" : "applied";
 			data = working;
-			if (record) undoStack.record(changes);
-			options.onDataChange?.(data, changes);
+			if (model) {
+				lazyChildren.clear();
+				for (const [key, children] of cache) lazyChildren.set(key, children);
+				lazyVersion++;
+			}
+			if (record) {
+				if (!transaction) undoStack.record({
+					kind: "cells",
+					changes
+				});
+			}
+			const groups = /* @__PURE__ */ new Map();
+			for (const change of changes) {
+				const group = groups.get(change.rowKey) ?? [];
+				group.push(change);
+				groups.set(change.rowKey, group);
+			}
+			for (const [key, group] of groups) pendingChanges.record(key, current.getRow(key).original, group.at(-1).row, positionOf(key), group);
+			if (!transaction) options.onDataChange?.(data, changes);
 			notify();
 		}
-		if (issues.length > 0) options.onEditIssues?.(issues);
+		if (issues.length > 0 && !transaction) options.onEditIssues?.(issues);
 		return Object.freeze({
 			status,
 			changes: Object.freeze(changes),
-			issues: Object.freeze(issues)
+			issues: Object.freeze(issues),
+			rowChanges: Object.freeze([]),
+			pendingCells: Object.freeze([])
+		});
+	}
+	function sourceRows() {
+		const { byId } = resolveColumns(definitions);
+		const model = treeEnabled ? treeStage(data, byId, lazyVersion) : void 0;
+		return model ? treeIndex(model) : indexRows(data, byId);
+	}
+	function positionOf(key) {
+		const { byId } = resolveColumns(definitions);
+		if (treeEnabled) {
+			const model = treeStage(data, byId, lazyVersion);
+			return treePositions(model).get(key) ?? Object.freeze({});
+		}
+		const indexed = indexRows(data, byId);
+		const row = indexed.byKey.get(key);
+		return Object.freeze({ before: row ? indexed.rows[row.index + 1]?.key : void 0 });
+	}
+	function scene() {
+		return {
+			data,
+			lazy: new Map(lazyChildren)
+		};
+	}
+	function resultForRows(changes, issues, cells = []) {
+		return Object.freeze({
+			status: changes.length || cells.length ? issues.length ? "partial" : "applied" : issues.length ? "rejected" : "unchanged",
+			changes: Object.freeze([...cells]),
+			rowChanges: Object.freeze([...changes]),
+			pendingCells: Object.freeze([]),
+			issues: Object.freeze([...issues])
+		});
+	}
+	function rowProblem(message, rowKey) {
+		return issue("invalid_row_operation", message, { rowKey });
+	}
+	function stableRows(rows) {
+		return options.rowKey !== void 0 || rows.every((row) => {
+			const key = getPath(row, "id");
+			return typeof key === "string" || typeof key === "number";
+		});
+	}
+	function cellDifferences(previous, row, key) {
+		return resolveColumns(definitions).columns.flatMap((column) => {
+			const before = column.getValue(previous);
+			const value = column.getValue(row);
+			return Object.is(before, value) ? [] : [{
+				rowKey: key,
+				column: column.id,
+				previous: before,
+				value,
+				row
+			}];
+		});
+	}
+	function recordRows(previous, keys, positions, baselines = /* @__PURE__ */ new Map()) {
+		const next = sourceRows();
+		const rowChanges = [];
+		for (const key of keys) {
+			const before = previous.byKey.get(key)?.original;
+			const row = next.byKey.get(key)?.original;
+			const position = positions.get(key) ?? positionOf(key);
+			const cells = before !== void 0 && row !== void 0 ? cellDifferences(before, row, key) : [];
+			const baseline = baselines.get(key);
+			const pending = pendingChanges.entries.get(key);
+			if (row === void 0 && baseline !== void 0 && pending?.previous !== void 0) pending.previous = baseline;
+			pendingChanges.record(key, row === void 0 ? baseline ?? before : before, row, position, cells);
+			if (before === void 0 && row !== void 0) rowChanges.push(Object.freeze({
+				kind: "inserted",
+				rowKey: key,
+				row,
+				position: positionOf(key)
+			}));
+			else if (row === void 0 && before !== void 0) rowChanges.push(Object.freeze({
+				kind: "removed",
+				rowKey: key,
+				row: before,
+				position
+			}));
+		}
+		return rowChanges;
+	}
+	function publishRows(before, previous, keys, positions, issues, baselines = /* @__PURE__ */ new Map()) {
+		const rowChanges = recordRows(previous, keys, positions, baselines);
+		if (!transaction) {
+			undoStack.record({
+				kind: "rows",
+				before,
+				after: scene(),
+				keys
+			});
+			options.onDataChange?.(data, []);
+			if (issues.length) options.onEditIssues?.(issues);
+		}
+		notify();
+		return resultForRows(rowChanges, issues);
+	}
+	function restoreScene(entry, direction) {
+		const previous = sourceRows();
+		const baselines = removalBaselines();
+		const positions = new Map(entry.keys.map((key) => [key, positionOf(key)]));
+		const target = direction === "undo" ? entry.before : entry.after;
+		data = target.data;
+		const changed = /* @__PURE__ */ new Set([...entry.before.lazy.keys(), ...entry.after.lazy.keys()]);
+		for (const key of changed) {
+			if (entry.before.lazy.get(key) === entry.after.lazy.get(key)) continue;
+			const rows = target.lazy.get(key);
+			if (rows) lazyChildren.set(key, rows);
+			else lazyChildren.delete(key);
+		}
+		lazyVersion++;
+		recordRows(previous, entry.keys, positions, baselines);
+		options.onDataChange?.(data, []);
+		notify();
+	}
+	function removalBaselines() {
+		const baselines = /* @__PURE__ */ new Map();
+		if (!options.getChildren || !options.setChildren) return baselines;
+		const model = treeStage(data, resolveColumns(definitions).byId, lazyVersion);
+		for (const node of model.nodes.toReversed()) {
+			const entry = pendingChanges.entries.get(node.row.key);
+			if (entry && entry.previous === void 0) continue;
+			let baseline = entry?.previous ?? node.row.original;
+			const children = node.children.filter((child) => !pendingChanges.entries.has(child.row.key) || pendingChanges.entries.get(child.row.key).previous !== void 0).map((child) => baselines.get(child.row.key) ?? child.row.original);
+			const originalChildren = options.getChildren(baseline) ?? [];
+			if (children.length !== originalChildren.length || children.some((child, index) => child !== originalChildren[index])) baseline = options.setChildren(baseline, children);
+			baselines.set(node.row.key, baseline);
+		}
+		return baselines;
+	}
+	function rewriteNested(model, removed, overrides, cache) {
+		const replacements = /* @__PURE__ */ new Map();
+		for (const node of model.nodes.toReversed()) {
+			if (removed.has(node.row.key)) continue;
+			const children = overrides.get(node.row.key) ?? node.children.filter((child) => !removed.has(child.row.key)).map((child) => replacements.get(child) ?? child.row.original);
+			if (!(overrides.has(node.row.key) || children.length !== node.children.length || children.some((child, index) => child !== node.children[index]?.row.original))) continue;
+			if (!options.setChildren) throw new Error("Changing nested children requires setChildren.");
+			replacements.set(node, options.setChildren(node.row.original, children));
+			if (cache.has(node.row.key)) cache.set(node.row.key, children);
+		}
+		const roots = new Map(model.roots.filter((node) => node.writable).map((node) => [node.sourceIndex, node]));
+		return data.flatMap((row, index) => {
+			const node = roots.get(index);
+			return node && removed.has(node.row.key) ? [] : [node ? replacements.get(node) ?? row : row];
+		});
+	}
+	function insertRows(rows, at = {}) {
+		const before = scene();
+		const previous = sourceRows();
+		const problems = [];
+		const reject = (problem) => {
+			if (!transaction) options.onEditIssues?.([problem]);
+			return resultForRows([], [problem]);
+		};
+		let incoming;
+		try {
+			incoming = rows ?? (options.createRow ? [options.createRow()] : []);
+		} catch (error) {
+			return reject(rowProblem(error instanceof Error ? error.message : String(error)));
+		}
+		if (rows === void 0 && !options.createRow) return reject(rowProblem("insertRows() requires rows or a createRow callback."));
+		if (!incoming.length) return resultForRows([], []);
+		if (!stableRows(data) || !stableRows(incoming)) return reject(rowProblem("Row operations require stable row keys; supply rowKey or an id on every row."));
+		const { byId } = resolveColumns(definitions);
+		const model = treeEnabled ? treeStage(data, byId, lazyVersion) : void 0;
+		const parent = at.parent === void 0 ? void 0 : model?.byKey.get(at.parent);
+		const sibling = at.before === void 0 ? void 0 : previous.byKey.get(at.before);
+		if (at.parent !== void 0 && !parent) return reject(issue("unknown_row", "The insertion parent does not exist.", { rowKey: at.parent }));
+		if (at.before !== void 0 && !sibling) return reject(issue("unknown_row", "The insertion sibling does not exist.", { rowKey: at.before }));
+		if (sibling && (model?.byKey.get(sibling.key)?.parent?.row.key ?? sibling.parentKey) !== at.parent) return reject(rowProblem("The before row must belong to the requested parent.", sibling.key));
+		if (parent && !parent.writable) return reject(rowProblem("A recovered parent has no writable source path.", parent.row.key));
+		if (parent && getSnapshot().getRow(parent.row.key)?.childStatus !== "loaded") return reject(rowProblem("Load the parent's children before inserting rows.", parent.row.key));
+		const cache = new Map(lazyChildren);
+		let next;
+		try {
+			if (options.getChildren && parent && model) {
+				const children = parent.children.map((child) => child.row.original);
+				const index = at.before === void 0 ? children.length : parent.children.findIndex((child) => child.row.key === at.before);
+				children.splice(index, 0, ...incoming);
+				next = rewriteNested(model, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map([[parent.row.key, children]]), cache);
+			} else if (parent && cache.has(parent.row.key)) {
+				incoming = incoming.map((row) => options.setParentKey ? options.setParentKey(row, parent.row.key) : row);
+				const children = [...cache.get(parent.row.key)];
+				const index = at.before === void 0 ? children.length : parent.children.findIndex((child) => child.row.key === at.before);
+				children.splice(index, 0, ...incoming);
+				cache.set(parent.row.key, children);
+				next = [...data];
+			} else {
+				if (parent && options.getParentKey) {
+					incoming = incoming.map((row) => options.setParentKey ? options.setParentKey(row, parent.row.key) : row);
+					if (incoming.some((row) => options.getParentKey(row) !== parent.row.key)) return reject(rowProblem("Supply setParentKey or rows already addressed to the requested parent."));
+				}
+				const working = [...data];
+				working.splice(sibling?.index ?? working.length, 0, ...incoming);
+				next = working;
+			}
+			const candidate = treeEnabled ? buildTree(next, byId, readKey, options, cache) : indexRows(next, byId);
+			if (!stableRows(candidate.rows.map((row) => row.original))) return reject(rowProblem("Every inserted descendant must have a stable key."));
+			const baseline = /* @__PURE__ */ new Map();
+			for (const problem of previous.issues) {
+				const key = `${problem.code}:${String(problem.rowKey)}`;
+				baseline.set(key, (baseline.get(key) ?? 0) + 1);
+			}
+			problems.push(...candidate.issues.filter((problem) => {
+				const key = `${problem.code}:${String(problem.rowKey)}`;
+				const remaining = baseline.get(key) ?? 0;
+				if (!remaining) return true;
+				baseline.set(key, remaining - 1);
+				return false;
+			}));
+			if (problems.length) {
+				if (!transaction) options.onEditIssues?.(problems);
+				return resultForRows([], problems);
+			}
+			const keys = candidate.rows.filter((row) => !previous.byKey.has(row.key)).map((row) => row.key);
+			if (!keys.length) return reject(rowProblem("No unique rows can be inserted."));
+			data = next;
+			lazyChildren.clear();
+			for (const [key, value] of cache) lazyChildren.set(key, value);
+			lazyVersion++;
+			return publishRows(before, previous, keys, /* @__PURE__ */ new Map(), []);
+		} catch (error) {
+			return reject(rowProblem(error instanceof Error ? error.message : String(error)));
+		}
+	}
+	function removeRows(keys) {
+		const before = scene();
+		const previous = sourceRows();
+		const problems = [];
+		const removed = /* @__PURE__ */ new Set();
+		const { byId } = resolveColumns(definitions);
+		const model = treeEnabled ? treeStage(data, byId, lazyVersion) : void 0;
+		if (!stableRows(data)) {
+			const problem = rowProblem("Row operations require stable row keys.");
+			if (!transaction) options.onEditIssues?.([problem]);
+			return resultForRows([], [problem]);
+		}
+		for (const key of keys) {
+			if (!previous.byKey.has(key)) {
+				problems.push(issue("unknown_row", "The row to remove does not exist.", { rowKey: key }));
+				continue;
+			}
+			const node = model?.byKey.get(key);
+			if (node && !node.writable) {
+				problems.push(rowProblem("A recovered row has no writable source path.", key));
+				continue;
+			}
+			const stack = node ? [node] : [];
+			removed.add(key);
+			while (stack.length) {
+				const item = stack.pop();
+				removed.add(item.row.key);
+				for (const child of item.children) stack.push(child);
+			}
+		}
+		if (!removed.size) {
+			if (problems.length && !transaction) options.onEditIssues?.(problems);
+			return resultForRows([], problems);
+		}
+		const positions = new Map([...removed].map((key) => [key, positionOf(key)]));
+		const cache = new Map(lazyChildren);
+		try {
+			const baselines = removalBaselines();
+			const next = options.getChildren && model ? rewriteNested(model, removed, /* @__PURE__ */ new Map(), cache) : data.filter((row, index) => !removed.has(readKey(row, index)));
+			for (const [key, children] of cache) if (removed.has(key)) cache.delete(key);
+			else cache.set(key, children.filter((row, index) => !removed.has(readKey(row, index))));
+			data = next;
+			lazyChildren.clear();
+			for (const [key, value] of cache) lazyChildren.set(key, value);
+			lazyVersion++;
+			validation.cancel([...removed]);
+			abortLoads();
+			return publishRows(before, previous, [...removed], positions, problems, baselines);
+		} catch (error) {
+			problems.push(rowProblem(error instanceof Error ? error.message : String(error)));
+			if (!transaction) options.onEditIssues?.(problems);
+			return resultForRows([], problems);
+		}
+	}
+	function revert(keys) {
+		const selected = new Set(keys ?? pendingChanges.entries.keys());
+		const entries = [...pendingChanges.entries].filter(([key]) => selected.has(key)).map(([key, entry]) => [key, {
+			...entry,
+			cells: new Map(entry.cells)
+		}]);
+		if (!entries.length) return resultForRows([], []);
+		const before = scene();
+		const previous = sourceRows();
+		const positions = new Map([...selected].map((key) => [key, positionOf(key)]));
+		const problems = [];
+		const cells = [];
+		transaction = true;
+		try {
+			problems.push(...removeRows(entries.filter(([, entry]) => entry.previous === void 0).map(([key]) => key)).issues);
+			const missing = entries.filter(([, entry]) => entry.previous !== void 0 && entry.row === void 0);
+			for (let pass = 0; missing.length && pass <= entries.length; pass++) {
+				let progress = false;
+				for (let index = missing.length - 1; index >= 0; index--) {
+					const [key, entry] = missing[index];
+					if (sourceRows().byKey.has(key)) {
+						missing.splice(index, 1);
+						progress = true;
+						continue;
+					}
+					if (entry.position.parent !== void 0 && !sourceRows().byKey.has(entry.position.parent)) continue;
+					const at = {
+						...entry.position,
+						before: entry.position.before !== void 0 && sourceRows().byKey.has(entry.position.before) ? entry.position.before : void 0
+					};
+					const result = insertRows([entry.previous], at);
+					problems.push(...result.issues);
+					missing.splice(index, 1);
+					progress = true;
+				}
+				if (!progress) break;
+			}
+			for (const [key] of missing) problems.push(rowProblem("The saved parent is missing; restore it before this child.", key));
+			const result = applyChanges(entries.flatMap(([key, entry]) => entry.previous !== void 0 && sourceRows().byKey.has(key) ? [...entry.cells.values()].map((change) => ({
+				rowKey: key,
+				column: change.column,
+				value: change.previous
+			})) : []), false);
+			cells.push(...result.changes);
+			problems.push(...result.issues);
+			for (const [key] of entries) if (!problems.some((problem) => problem.rowKey === key)) pendingChanges.entries.delete(key);
+			validation.cancel([...selected]);
+		} finally {
+			transaction = false;
+		}
+		const after = scene();
+		if (before.data !== after.data || cells.length) undoStack.record({
+			kind: "rows",
+			before,
+			after,
+			keys: [...selected]
 		});
+		const next = sourceRows();
+		const rowChanges = [...selected].flatMap((key) => {
+			const old = previous.byKey.get(key);
+			const row = next.byKey.get(key);
+			return !old && row ? [{
+				kind: "inserted",
+				rowKey: key,
+				row: row.original,
+				position: positionOf(key)
+			}] : old && !row ? [{
+				kind: "removed",
+				rowKey: key,
+				row: old.original,
+				position: positions.get(key)
+			}] : [];
+		});
+		if (before.data !== after.data) options.onDataChange?.(data, cells);
+		if (problems.length) options.onEditIssues?.(problems);
+		notify();
+		return resultForRows(rowChanges, problems, cells);
 	}
 	function rangeEdits(origin, matrix) {
 		const { rows, columns } = getSnapshot();
@@ -996,13 +2978,356 @@ function createTable(options) {
 		return edits;
 	}
 	function replay(changes, direction) {
-		applyChanges(changes.map((change) => ({
+		applyChanges((direction === "undo" ? changes.toReversed() : changes).map((change) => ({
 			rowKey: change.rowKey,
 			column: change.column,
 			value: direction === "undo" ? change.previous : change.value
 		})), false);
 	}
+	function ingestionResult(appended, replaced, removed, problems) {
+		return Object.freeze({
+			status: appended + replaced + removed ? problems.length ? "partial" : "applied" : problems.length ? "rejected" : "unchanged",
+			appended,
+			replaced,
+			removed,
+			issues: Object.freeze([...problems])
+		});
+	}
+	const stableSource = /* @__PURE__ */ new WeakMap();
+	function ingestionKeys(rows) {
+		let valid = stableSource.get(rows);
+		if (valid === void 0) {
+			valid = stableRows(rows);
+			stableSource.set(rows, valid);
+		}
+		return valid;
+	}
+	function isProtectedSource(key) {
+		return pendingChanges.entries.has(key) || validation.hasPending(key);
+	}
+	function affectedBranch(model, key) {
+		const result = [key];
+		const node = model?.byKey.get(key);
+		if (!node) return result;
+		let parent = node.parent;
+		while (parent) {
+			result.push(parent.row.key);
+			parent = parent.parent;
+		}
+		const stack = [...node.children];
+		while (stack.length) {
+			const child = stack.pop();
+			result.push(child.row.key);
+			for (const descendant of child.children) stack.push(descendant);
+		}
+		return result;
+	}
+	function transformScene(source, updates, removed) {
+		const seen = /* @__PURE__ */ new Set();
+		const replace = (rows) => rows.flatMap((row, index) => {
+			const key = readKey(row, index);
+			seen.add(key);
+			return removed.has(key) ? [] : [updates.get(key) ?? row];
+		});
+		const cache = /* @__PURE__ */ new Map();
+		for (const [key, children] of source.lazy) if (!removed.has(key)) cache.set(key, replace(children));
+		let next;
+		if (!options.getChildren) next = replace(source.data);
+		else {
+			const model = buildTree(source.data, resolveColumns(definitions).byId, readKey, options, source.lazy);
+			const replacements = /* @__PURE__ */ new Map();
+			for (const node of model.nodes.toReversed()) {
+				const key = node.row.key;
+				seen.add(key);
+				if (removed.has(key)) continue;
+				let row = updates.get(key) ?? node.row.original;
+				const supplied = updates.has(key) ? options.getChildren(row) : void 0;
+				if (supplied !== void 0) cache.delete(key);
+				const children = supplied ?? node.children.filter((child) => !removed.has(child.row.key)).map((child) => replacements.get(child) ?? child.row.original);
+				const old = options.getChildren(row) ?? node.children.map((child) => child.row.original);
+				if (supplied === void 0 && (updates.has(key) && node.children.length > 0 && !cache.has(key) || children.length !== old.length || children.some((child, index) => child !== old[index]))) {
+					if (!options.setChildren) throw new Error("Updating nested source children requires setChildren.");
+					row = options.setChildren(row, children);
+					if (cache.has(key)) cache.set(key, children);
+				}
+				replacements.set(node, row);
+			}
+			const roots = new Map(model.roots.filter((node) => node.writable).map((node) => [node.sourceIndex, node]));
+			next = source.data.flatMap((row, index) => {
+				const node = roots.get(index);
+				return node && removed.has(node.row.key) ? [] : [node ? replacements.get(node) ?? row : row];
+			});
+		}
+		const additions = [...updates].filter(([key]) => !seen.has(key) && !removed.has(key)).map(([, row]) => row);
+		return {
+			data: appendList(next, additions),
+			lazy: cache
+		};
+	}
+	function rebaseBatches(transform, removed) {
+		undoStack.transform((entry) => {
+			if (entry.kind === "cells") {
+				if (!removed.size) return entry;
+				const changes = entry.changes.filter((change) => !removed.has(change.rowKey));
+				return changes.length ? {
+					...entry,
+					changes
+				} : void 0;
+			}
+			const keys = entry.keys.filter((key) => !removed.has(key));
+			return keys.length ? {
+				...entry,
+				keys,
+				before: transform(entry.before),
+				after: transform(entry.after)
+			} : void 0;
+		});
+	}
+	function newTreeIssues(previous, next) {
+		const counts = /* @__PURE__ */ new Map();
+		for (const problem of previous) {
+			const key = JSON.stringify([problem.code, problem.rowKey]);
+			counts.set(key, (counts.get(key) ?? 0) + 1);
+		}
+		return next.filter((problem) => {
+			const key = JSON.stringify([problem.code, problem.rowKey]);
+			const remaining = counts.get(key) ?? 0;
+			if (!remaining) return true;
+			counts.set(key, remaining - 1);
+			return false;
+		});
+	}
+	function ingestData(incoming, mode) {
+		const problems = [];
+		const reject = (problem) => {
+			ingestionIssues = [problem];
+			notify();
+			return ingestionResult(0, 0, 0, ingestionIssues);
+		};
+		if (destroyed) return reject(issue("invalid_ingestion", "A disposed table cannot receive source data."));
+		if (!incoming.length) return ingestionResult(0, 0, 0, []);
+		try {
+			if (!ingestionKeys(data) || !stableRows(incoming)) return reject(issue("invalid_ingestion", "Source ingestion requires stable rowKey values or ids on every row."));
+		} catch (error) {
+			return reject(issue("invalid_ingestion", error instanceof Error ? error.message : String(error)));
+		}
+		const previous = sourceRows();
+		const { byId, columns } = resolveColumns(definitions);
+		const model = treeEnabled ? treeStage(data, byId, lazyVersion) : void 0;
+		const seenBatch = /* @__PURE__ */ new Set();
+		const updates = /* @__PURE__ */ new Map();
+		for (const row of incoming) try {
+			const key = readKey(row, previous.rows.length + updates.size);
+			if (typeof key !== "string" && (typeof key !== "number" || !Number.isFinite(key))) {
+				problems.push(issue("invalid_ingestion", "An incoming row key must be a string or finite number."));
+				continue;
+			}
+			const existing = previous.byKey.get(key);
+			if (seenBatch.has(key) || mode === "append" && existing) {
+				problems.push(issue("duplicate_row_key", "An incoming source row repeats an existing key and is refused.", { rowKey: key }));
+				continue;
+			}
+			seenBatch.add(key);
+			const parent = options.getParentKey?.(row);
+			const affected = affectedBranch(model, key);
+			if (parent !== void 0 && parent !== null) affected.push(...affectedBranch(model, parent));
+			if (affected.some(isProtectedSource)) {
+				problems.push(issue("ingestion_conflict", "Incoming source data would overwrite a local change or pending validation; retry after save or revert.", { rowKey: key }));
+				continue;
+			}
+			const node = model?.byKey.get(key);
+			if (node && (!node.writable || node.lazy && options.getParentKey && options.getParentKey(row) !== node.parent?.row.key)) {
+				problems.push(issue("invalid_ingestion", "This recovered or lazy tree row has no writable source position.", { rowKey: key }));
+				continue;
+			}
+			if (existing?.original !== row) updates.set(key, row);
+		} catch (error) {
+			problems.push(issue("invalid_ingestion", error instanceof Error ? error.message : String(error)));
+		}
+		if (!updates.size) {
+			ingestionIssues = problems;
+			notify();
+			return ingestionResult(0, 0, 0, problems);
+		}
+		const replaced = [...updates.keys()].filter((key) => previous.byKey.has(key)).length;
+		const appended = updates.size - replaced;
+		const previousState = state;
+		try {
+			if (!model && !replaced) {
+				const added = Object.freeze([...updates.values()]);
+				const indexed = added.map((row, offset) => createRow(row, readKey(row, previous.rows.length + offset), previous.rows.length + offset, byId, options.getRowCanExpand?.(row) ?? false));
+				const filtered = manual ? previous.rows : filterStage(previous.rows, columns, state.search, state.filters);
+				const addedFiltered = manual ? indexed : filterRows(indexed, columns, state.search, state.filters);
+				const allRows = appendList(previous.rows, indexed);
+				const allFiltered = appendList(filtered, addedFiltered);
+				const keys = membership(filtered);
+				for (const row of addedFiltered) keys.add(row.key);
+				rowMembership.set(allFiltered, keys);
+				const sorted = manual || !state.sorting.some((rule) => columns.some((column) => column.id === rule.column)) ? allFiltered : mergeRows(sortStage(filtered, columns, state.sorting), addedFiltered, columns, state.sorting);
+				const next = appendList(data, added);
+				rebaseBatches((source) => ({
+					...source,
+					data: appendList(source.data, added)
+				}), /* @__PURE__ */ new Set());
+				for (const row of indexed) previous.byKey.set(row.key, row);
+				primedIndex = {
+					data: next,
+					columns: byId,
+					result: {
+						rows: allRows,
+						byKey: previous.byKey,
+						issues: previous.issues
+					}
+				};
+				primedFilter = {
+					rows: allRows,
+					columns,
+					search: state.search,
+					filters: state.filters,
+					result: allFiltered
+				};
+				primedSort = {
+					rows: allFiltered,
+					columns,
+					sorting: state.sorting,
+					result: sorted
+				};
+				stableSource.set(next, true);
+				data = next;
+			} else {
+				const next = transformScene(scene(), updates, /* @__PURE__ */ new Set());
+				const candidate = treeEnabled ? buildTree(next.data, byId, readKey, options, next.lazy) : indexRows(next.data, byId);
+				const fresh = newTreeIssues(previous.issues, candidate.issues);
+				if (fresh.length || !stableRows(candidate.rows.map((row) => row.original))) {
+					problems.push(...fresh, ...!stableRows(candidate.rows.map((row) => row.original)) ? [issue("invalid_ingestion", "Every incoming descendant needs a stable key.")] : []);
+					ingestionIssues = problems;
+					notify();
+					return ingestionResult(0, 0, 0, problems);
+				}
+				const nextKeys = new Set(candidate.rows.map((row) => row.key));
+				const removedKeys = new Set(previous.rows.filter((row) => !nextKeys.has(row.key)).map((row) => row.key));
+				rebaseBatches((source) => transformScene(source, updates, removedKeys), removedKeys);
+				data = next.data;
+				lazyChildren.clear();
+				for (const [key, rows] of next.lazy) lazyChildren.set(key, rows);
+				lazyVersion++;
+				for (const key of [...updates.keys(), ...removedKeys]) {
+					pendingLoads.get(key)?.abort();
+					pendingLoads.delete(key);
+					childStatuses.delete(key);
+					loadIssues.delete(key);
+					loadValidationIssues.delete(key);
+				}
+				validation.cancel([...removedKeys]);
+				const selection = state.selection.filter((key) => !removedKeys.has(key));
+				state = mergeState(state, {
+					selection: selection.length === state.selection.length ? state.selection : selection,
+					expanded: state.expanded === true ? true : state.expanded.filter((key) => !removedKeys.has(key))
+				});
+			}
+			validation.cancel([...updates.keys()]);
+			ingestionIssues = problems;
+		} catch (error) {
+			return reject(issue("invalid_ingestion", error instanceof Error ? error.message : String(error)));
+		}
+		if (state !== previousState) options.onStateChange?.(state, previousState);
+		options.onDataChange?.(data, []);
+		notify();
+		startVisibleLoads();
+		return ingestionResult(appended, replaced, 0, problems);
+	}
+	function removeData(keys) {
+		const previousState = state;
+		const problems = [];
+		const removed = /* @__PURE__ */ new Set();
+		const previous = sourceRows();
+		const model = treeEnabled ? treeStage(data, resolveColumns(definitions).byId, lazyVersion) : void 0;
+		if (destroyed || !ingestionKeys(data)) problems.push(issue("invalid_ingestion", "Source removal requires a live table and stable row keys."));
+		else for (const key of new Set(keys)) {
+			if (!previous.byKey.has(key)) {
+				problems.push(issue("unknown_row", "The source row to remove does not exist.", { rowKey: key }));
+				continue;
+			}
+			if (affectedBranch(model, key).some(isProtectedSource)) {
+				problems.push(issue("ingestion_conflict", "Source removal would discard local changes or pending validation.", { rowKey: key }));
+				continue;
+			}
+			const node = model?.byKey.get(key);
+			if (node && !node.writable) {
+				problems.push(issue("invalid_ingestion", "A recovered tree row has no writable source position.", { rowKey: key }));
+				continue;
+			}
+			removed.add(key);
+			const stack = node ? [...node.children] : [];
+			while (stack.length) {
+				const child = stack.pop();
+				removed.add(child.row.key);
+				for (const descendant of child.children) stack.push(descendant);
+			}
+		}
+		try {
+			if (removed.size) {
+				const next = transformScene(scene(), /* @__PURE__ */ new Map(), removed);
+				rebaseBatches((source) => transformScene(source, /* @__PURE__ */ new Map(), removed), removed);
+				data = next.data;
+				lazyChildren.clear();
+				for (const [key, rows] of next.lazy) lazyChildren.set(key, rows);
+				lazyVersion++;
+				validation.cancel([...removed]);
+				for (const key of removed) {
+					pendingLoads.get(key)?.abort();
+					pendingLoads.delete(key);
+					childStatuses.delete(key);
+					loadIssues.delete(key);
+					loadValidationIssues.delete(key);
+				}
+				const selection = state.selection.filter((key) => !removed.has(key));
+				state = mergeState(state, {
+					selection: selection.length === state.selection.length ? state.selection : selection,
+					expanded: state.expanded === true ? true : state.expanded.filter((key) => !removed.has(key))
+				});
+			}
+			ingestionIssues = problems;
+		} catch (error) {
+			ingestionIssues = [issue("invalid_ingestion", error instanceof Error ? error.message : String(error))];
+			notify();
+			return ingestionResult(0, 0, 0, ingestionIssues);
+		}
+		if (state !== previousState) options.onStateChange?.(state, previousState);
+		if (removed.size) options.onDataChange?.(data, []);
+		notify();
+		startVisibleLoads();
+		return ingestionResult(0, 0, removed.size, problems);
+	}
+	if (expandMode === "single") {
+		initialState = mergeState(initialState, { expanded: canonicalExpanded(initialState.expanded) });
+		state = initialState;
+		snapshot = void 0;
+	}
 	const table = {
+		appendData: (rows) => ingestData(rows, "append"),
+		upsertData: (rows) => ingestData(rows, "upsert"),
+		removeData,
+		stream(source, streamOptions) {
+			if (destroyed) return Promise.resolve(Object.freeze({
+				status: "aborted",
+				receivedRowCount: 0,
+				issues: Object.freeze([issue("invalid_ingestion", "A disposed table cannot start a source.")])
+			}));
+			return streaming.run(source, {
+				expectedRowCount: sourceExpected,
+				...streamOptions
+			});
+		},
+		insertRows,
+		removeRows,
+		revert,
+		getPendingChanges: () => pendingChanges.snapshot(),
+		markSaved(keys) {
+			if (!keys) pendingChanges.entries.clear();
+			else for (const key of keys) pendingChanges.entries.delete(key);
+			notify();
+		},
 		getSnapshot,
 		getState: () => state,
 		subscribe(listener) {
@@ -1012,21 +3337,40 @@ function createTable(options) {
 			};
 		},
 		setState(patch) {
-			const next = mergeState(state, patch);
-			if (next !== state) {
+			const previousIssue = expandedIssue;
+			const next = mergePatch(patch);
+			if (next !== state || previousIssue !== expandedIssue) {
 				state = next;
+				snapshot = void 0;
+				abortLoads();
 				notify();
+				startVisibleLoads();
 			}
 		},
 		setData(next) {
 			if (next === data) return;
+			validation.cancel();
+			streaming.cancel();
+			loadState = "idle";
+			streamIssues = [];
+			ingestionIssues = [];
+			expectedRowCount = sourceExpected;
+			pendingChanges.entries.clear();
+			abortLoads(true);
+			lazyChildren.clear();
+			childStatuses.clear();
+			loadIssues.clear();
+			loadValidationIssues.clear();
+			lazyVersion++;
 			data = next;
 			undoStack.clear();
 			notify();
+			startVisibleLoads();
 		},
 		setColumns(next) {
 			if (next === definitions) return;
 			definitions = next;
+			validation.cancel();
 			notify();
 		},
 		setRowCount(next) {
@@ -1034,6 +3378,12 @@ function createTable(options) {
 			rowCount = next;
 			notify();
 		},
+		setTreeFilter(next) {
+			const mode = next ?? "ancestors";
+			if (mode === treeFilter) return;
+			treeFilter = mode;
+			notify();
+		},
 		toggleSort(columnId, { multi = false } = {}) {
 			const current = state.sorting.find((rule) => rule.column === columnId)?.direction;
 			setSort(columnId, current === void 0 ? "asc" : current === "asc" ? "desc" : void 0, multi);
@@ -1069,6 +3419,7 @@ function createTable(options) {
 			});
 		},
 		goToPage(page) {
+			if (!paginate) return;
 			const { pageCount, page: currentPage } = getSnapshot();
 			const next = clampPage(page, pageCount);
 			if (next !== currentPage || next !== state.pagination.page) commit({ pagination: {
@@ -1083,6 +3434,7 @@ function createTable(options) {
 			table.goToPage(getSnapshot().page - 1);
 		},
 		setPageSize(pageSize) {
+			if (!paginate) return;
 			if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize === state.pagination.pageSize) return;
 			const { pageStart } = getSnapshot();
 			commit({ pagination: {
@@ -1091,14 +3443,14 @@ function createTable(options) {
 			} });
 		},
 		select(keys) {
-			applySelection([...state.selection, ...keys]);
+			applySelection([...state.selection, ...selectionKeys(keys)]);
 		},
 		deselect(keys) {
-			const removed = new Set(keys);
+			const removed = new Set(selectionKeys(keys));
 			applySelection(state.selection.filter((key) => !removed.has(key)));
 		},
 		toggleRow(key, selected) {
-			const isSelected = state.selection.includes(key);
+			const isSelected = treeEnabled ? getSnapshot().getRow(key)?.selection === "all" : state.selection.includes(key);
 			const next = selected ?? !isSelected;
 			if (next === isSelected) return;
 			if (next) table.select([key]);
@@ -1121,6 +3473,27 @@ function createTable(options) {
 				return row ? [row] : [];
 			});
 		},
+		toggleExpanded(key, expanded) {
+			const row = getSnapshot().getRow(key);
+			if (!row?.canExpand) return;
+			const open = expanded ?? !row.isExpanded;
+			if (open === row.isExpanded) {
+				if (open && row.childStatus === "error") requestChildren(row);
+				return;
+			}
+			if (expandMode === "single") commit({ expanded: open ? [key] : [] });
+			else if (state.expanded === true) {
+				const { byId } = resolveColumns(definitions);
+				commit({ expanded: (treeEnabled ? treeStage(data, byId, lazyVersion).rows.map((candidate) => getSnapshot().getRow(candidate.key)) : indexRows(data, byId).rows).filter((candidate) => candidate.canExpand && candidate.key !== key).map((candidate) => candidate.key) });
+			} else commit({ expanded: open ? [...state.expanded, key] : state.expanded.filter((candidate) => candidate !== key) });
+			if (open) requestChildren(getSnapshot().getRow(key));
+		},
+		expandAll() {
+			commit({ expanded: true });
+		},
+		collapseAll() {
+			commit({ expanded: [] });
+		},
 		toggleColumn(columnId, visible) {
 			if (!getSnapshot().getColumn(columnId)) return;
 			const hidden = state.hiddenColumns.includes(columnId);
@@ -1138,22 +3511,26 @@ function createTable(options) {
 			order.splice(target, 0, columnId);
 			commit({ columnOrder: order });
 		},
-		edit(edits) {
-			return applyChanges(Array.isArray(edits) ? edits : [edits], true);
+		edit(edits, editOptions) {
+			return validation.edit(Array.isArray(edits) ? edits : [edits], [], editOptions);
 		},
 		undo() {
-			const changes = undoStack.undo();
-			if (!changes) return false;
-			replay(changes, "undo");
+			const entry = undoStack.undo();
+			if (!entry) return false;
+			validation.cancel();
+			if (entry.kind === "cells") replay(entry.changes, "undo");
+			else restoreScene(entry, "undo");
 			return true;
 		},
 		redo() {
-			const changes = undoStack.redo();
-			if (!changes) return false;
-			replay(changes, "redo");
+			const entry = undoStack.redo();
+			if (!entry) return false;
+			validation.cancel();
+			if (entry.kind === "cells") replay(entry.changes, "redo");
+			else restoreScene(entry, "redo");
 			return true;
 		},
-		copy(range) {
+		copy(range, { escapeFormulas = false } = {}) {
 			const { rows, columns } = getSnapshot();
 			const matrix = [];
 			rows.forEach((row, rowIndex) => {
@@ -1162,46 +3539,72 @@ function createTable(options) {
 					if (rangeContains(range, {
 						row: rowIndex,
 						column: columnIndex
-					})) line.push(row.getDisplay(column.id));
+					})) {
+						const display = row.getDisplay(column.id);
+						line.push(escapeFormulas ? escapeFormula(display, row.getValue(column.id)) : display);
+					}
 				});
 				if (line.length > 0) matrix.push(line);
 			});
 			return toDelimited(matrix);
 		},
 		paste(origin, text) {
-			return applyChanges(rangeEdits(origin, parseDelimited(text)), true);
+			if (!Number.isInteger(origin.row) || !Number.isInteger(origin.column) || origin.row < 0 || origin.column < 0) return validation.edit([], [issue("invalid_value", "The paste origin must use non-negative whole row and column indices.")]);
+			const { rows, columns } = getSnapshot();
+			const parsed = readDelimited(text, {
+				maxRows: Math.max(0, rows.length - origin.row),
+				maxColumns: Math.max(0, columns.length - origin.column),
+				maxCells: maxPasteCells,
+				maxLength: maxPasteLength
+			});
+			const issues = parsed.truncated ? [issue("paste_truncated", "The paste exceeds the visible grid or parsing limits; only complete cells within those limits are applied.")] : [];
+			return validation.edit(rangeEdits(origin, parsed.rows), issues);
 		},
 		clear(range) {
 			const matrix = Array.from({ length: range.bottom - range.top + 1 }, () => Array.from({ length: range.right - range.left + 1 }, () => ""));
 			const current = getSnapshot();
-			return applyChanges(rangeEdits({
+			const edits = rangeEdits({
 				row: range.top,
 				column: range.left
 			}, matrix).filter((edit) => {
 				const row = current.getRow(edit.rowKey);
 				return row !== void 0 && current.getColumn(edit.column)?.isEditable(row.original) === true;
-			}), true);
+			});
+			return validation.edit(edits);
 		},
-		exportRows({ format = "csv", columns: ids, pageOnly = false, headers = true } = {}) {
+		exportRows({ format = "csv", columns: ids, pageOnly = false, headers = true, escapeFormulas = true, depth = false, indent = "" } = {}) {
 			const current = getSnapshot();
 			const columns = ids ? ids.flatMap((id) => {
 				const column = current.getColumn(id);
 				return column ? [column] : [];
 			}) : current.columns;
-			const matrix = (pageOnly ? current.rows : current.processedRows).map((row) => columns.map((column) => row.getDisplay(column.id)));
-			if (headers) matrix.unshift(columns.map((column) => column.header));
+			const rows = pageOnly ? current.rows : current.processedRows;
+			const matrix = rows.map((row) => columns.map((column, index) => {
+				const display = (index === 0 ? indent.repeat(row.depth) : "") + row.getDisplay(column.id);
+				return escapeFormulas ? escapeFormula(display, row.getValue(column.id)) : display;
+			}));
+			if (depth) matrix.forEach((line, index) => line.unshift(String(rows[index].depth)));
+			if (headers) {
+				matrix.unshift(columns.map((column) => escapeFormulas ? escapeFormula(column.header) : column.header));
+				if (depth) matrix[0].unshift("Depth");
+			}
 			return toDelimited(matrix, format === "csv" ? "," : "	");
 		},
 		reset() {
 			commit(initialState);
 		},
 		destroy() {
+			destroyed = true;
+			streaming.cancel();
+			validation.cancel();
+			abortLoads(true);
 			listeners.clear();
 		}
 	};
+	startVisibleLoads();
 	return table;
 }
 
 //#endregion
-export { DEFAULT_PAGE_SIZE, clampPage, clampPosition, columnLabel, compareValues, countPages, createTable, createUndoStack, defineColumns, filterRows, formatValue, fromA1, getPath, gridCommand, humanize, inferColumns, matchesFilter, moveSelection, paginateRows, paginationItems, parseAs, parseDelimited, rangeContains, resolveColumn, selectCell, selectionRange, setPath, sortRows, toA1, toDelimited, typeOf };
+export { DEFAULT_PAGE_SIZE, clampPage, clampPosition, columnLabel, compareValues, countPages, createTable, createUndoStack, createVirtualizer, defineColumns, filterRows, formatValue, fromA1, getPath, getRowItemKey, gridCommand, humanize, inferColumns, matchesFilter, moveSelection, paginateRows, paginationItems, parseAs, parseDelimited, rangeContains, resolveColumn, selectCell, selectionRange, setPath, sortRows, toA1, toDelimited, typeOf };
 //# sourceMappingURL=index.js.map