@vueye-table/core 3.0.0-alpha.4 → 3.0.0-alpha.6

package/dist/index.js

@@ -547,6 +547,16 @@ 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);
 		}
 	};
 }
@@ -721,6 +731,14 @@ function createVirtualizer(initialOptions) {
 			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.");
@@ -801,6 +819,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);
@@ -809,8 +831,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);
@@ -820,7 +841,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) {
@@ -1128,6 +1161,7 @@ function createEditValidation(host) {
 		});
 	}
 	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) {
@@ -1328,6 +1362,161 @@ function createPendingChanges() {
 	};
 }
 
+//#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 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
+	});
+}
+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
+	});
+	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];
+	});
+	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) {
@@ -1590,6 +1779,8 @@ function createTable(options) {
 	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;
@@ -1602,6 +1793,19 @@ function createTable(options) {
 	});
 	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;
@@ -1654,20 +1858,24 @@ function createTable(options) {
 			issues
 		};
 	});
+	let primedIndex;
 	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 row = createRow(original, key, index, byId, options.getRowCanExpand?.(original) ?? false);
+			byKey.set(key, row);
+			return row;
+		});
+		stableSource.set(rows, stableRows(rows));
 		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, options.getRowCanExpand?.(original) ?? false);
-				byKey.set(key, row);
-				return row;
-			}),
+			rows: indexed,
 			byKey,
 			issues
 		};
@@ -1757,13 +1965,24 @@ 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 = indexed.rows.map((row) => {
+		const rows = mapList(indexed.rows, (row) => {
 			const isExpanded = row.canExpand && (expanded === true || (keys?.has(row.key) ?? false));
 			return isExpanded || selected.has(row.key) ? Object.freeze({
 				...row,
@@ -1773,10 +1992,13 @@ function createTable(options) {
 		});
 		return {
 			rows,
-			byKey: new Map(rows.map((row) => [row.key, row]))
+			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) => rows.map((row) => byKey.get(row.key)));
+	const expandedOrder = memo((rows, byKey) => mapList(rows, (row) => byKey.get(row.key)));
 	function stateIssues(byId) {
 		const issues = [];
 		if (expandedIssue) issues.push(expandedIssue);
@@ -1809,6 +2031,8 @@ function createTable(options) {
 		const ordered = orderColumns(columns, state.columnOrder, state.hiddenColumns);
 		const issues = [
 			...optionIssues,
+			...ingestionIssues,
+			...streamIssues,
 			...columnIssues,
 			...indexed.issues,
 			...stateIssues(byId),
@@ -1910,24 +2134,35 @@ function createTable(options) {
 				return result;
 			};
 			const shared = rows === processedRows;
-			processedRows = processedRows.map(project);
+			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({
+			loadState,
+			loadedRowCount: indexed.rows.length,
+			expectedRowCount,
 			state,
 			columns: ordered.visible,
 			allColumns: ordered.all,
 			rows,
-			renderItems: Object.freeze(rows.flatMap((row, rowIndex) => {
+			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),
@@ -2688,12 +2923,341 @@ function createTable(options) {
 			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,
@@ -2725,6 +3289,11 @@ function createTable(options) {
 		setData(next) {
 			if (next === data) return;
 			validation.cancel();
+			streaming.cancel();
+			loadState = "idle";
+			streamIssues = [];
+			ingestionIssues = [];
+			expectedRowCount = sourceExpected;
 			pendingChanges.entries.clear();
 			abortLoads(true);
 			lazyChildren.clear();
@@ -2959,6 +3528,7 @@ function createTable(options) {
 		},
 		destroy() {
 			destroyed = true;
+			streaming.cancel();
 			validation.cancel();
 			abortLoads(true);
 			listeners.clear();