foldkit-primitives 0.2.1 → 0.4.0

package/dist/state/index.d.mts

@@ -6,11 +6,53 @@ export declare const HistoryModel: <Value>(value: Schema.Codec<Value, unknown>)
   readonly past: Schema.$Array<Schema.Codec<Value, unknown, never, never>>;
   readonly present: Schema.Codec<Value, unknown, never, never>;
   readonly future: Schema.$Array<Schema.Codec<Value, unknown, never, never>>;
+  /** The group of the last push, so the next push of the same group joins it; `null` for none. */
+  readonly group: Schema.NullOr<Schema.String>;
 }>;
 export type HistoryModel<Value> = {
   readonly past: ReadonlyArray<Value>;
   readonly present: Value;
   readonly future: ReadonlyArray<Value>;
+  readonly group: string | null;
+};
+/** Whether Undo would move: the past is non-empty. */
+export declare const canUndo: <Value>(model: HistoryModel<Value>) => boolean;
+/** Whether Redo would move: the future is non-empty. */
+export declare const canRedo: <Value>(model: HistoryModel<Value>) => boolean;
+/** The steps of a history as pure functions of its Model. */
+export declare const History: {
+  /** A history whose present is `value`, with nothing to undo. */
+  start: <Value>(present: Value) => HistoryModel<Value>;
+  /** Records `value` as the present; the same `group` as the last push joins its step. */
+  push: <Value>(model: HistoryModel<Value>, value: Value, options: {
+    readonly capacity: number;
+    readonly group?: string | null | undefined;
+  }) => HistoryModel<Value>;
+  /** One step back, or the Model as it was when there is none. */
+  undo: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+  /** One step forward, or the Model as it was when there is none. */
+  redo: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+  /**
+   * The value at `step` made the present, counting every kept value from the
+   * oldest (0), so the present is at `past.length`: what a click on a step's
+   * thumbnail does. The Model as it was for the present or a step not kept.
+   */
+  goTo: <Value>(model: HistoryModel<Value>, step: number) => HistoryModel<Value>;
+  /** Nothing to undo or redo, the present kept. */
+  clear: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+  /** The next push starts a step of its own, whatever its group: a group ends here. */
+  close: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+  /**
+   * The step `group` is making taken back, and not redoable: what a cancelled
+   * edit, or one that ended where it began, leaves. The Model as it was when
+   * the last push was not of `group`. What the group's first push dropped
+   * stays dropped: the redo future it cleared, and an entry capacity evicted;
+   * with a capacity of 0 nothing was kept, so the present stays and only the
+   * group ends.
+   */
+  revert: <Value>(model: HistoryModel<Value>, group: string) => HistoryModel<Value>;
+  canUndo: <Value>(model: HistoryModel<Value>) => boolean;
+  canRedo: <Value>(model: HistoryModel<Value>) => boolean;
 };
 export declare const history: <const Name extends string, Value>(config: {
   readonly name: Name;
@@ -18,33 +60,33 @@ export declare const history: <const Name extends string, Value>(config: {
   readonly capacity?: number | undefined;
 }) => Bundle.Bundle<Name, {
   readonly initial: Value;
-}, {
-  readonly past: readonly Value[];
-  readonly present: Value;
-  readonly future: readonly Value[];
-}, {
+}, HistoryModel<Value>, {
+  readonly _tag: "Clear";
+} | {
   readonly _tag: "Push";
   readonly value: Value;
+  readonly group?: string | undefined;
 } | {
   readonly _tag: "Undo";
 } | {
   readonly _tag: "Redo";
 } | {
-  readonly _tag: "Clear";
+  readonly _tag: "GoTo";
+  readonly step: number;
 }, never, never, never, void, {}, {}> & {
   Message: import("foldkit/message").MessageUnion<{
     readonly Push: {
       readonly value: Schema.Codec<Value, unknown, never, never>;
+      readonly group: Schema.optional<Schema.String>;
     };
     readonly Undo: {};
     readonly Redo: {};
+    readonly GoTo: {
+      readonly step: Schema.Number;
+    };
     readonly Clear: {};
   }>;
 };
-/** Whether Undo would move: the past is non-empty. */
-export declare const canUndo: <Value>(model: HistoryModel<Value>) => boolean;
-/** Whether Redo would move: the future is non-empty. */
-export declare const canRedo: <Value>(model: HistoryModel<Value>) => boolean;
 //#endregion
 //#region src/state/locale.d.ts
 export declare const LocaleModel: Schema.Struct<{
@@ -149,8 +191,6 @@ export declare const isSelected: (model: SelectionSetModel, id: string) => boole
 export declare const SelectionSet: Bundle.Bundle<"SelectionSet", void, {
   readonly selected: readonly string[];
 }, {
-  readonly _tag: "Clear";
-} | {
   readonly _tag: "Select";
   readonly id: string;
 } | {
@@ -162,6 +202,8 @@ export declare const SelectionSet: Bundle.Bundle<"SelectionSet", void, {
 } | {
   readonly _tag: "ReplaceAll";
   readonly ids: readonly string[];
+} | {
+  readonly _tag: "Clear";
 }, never, never, never, void, {}, {}>;
 //#endregion
 //#region src/state/virtual.d.ts
@@ -269,15 +311,15 @@ export declare const Virtual: Bundle.Bundle<"Virtual", {
   readonly _tag: "Measured";
   readonly key: string;
   readonly height: number;
-} | {
-  readonly _tag: "Settled";
-  readonly generation: number;
 } | {
   readonly _tag: "Scrolled";
   readonly top: number;
 } | {
   readonly _tag: "Prune";
   readonly keys: readonly string[];
+} | {
+  readonly _tag: "Settled";
+  readonly generation: number;
 }, never, never, never, void, {}, {}>;
 export declare const ViewportScrolled: Schema.TaggedStruct<"ViewportScrolled", {
   readonly top: Schema.Number;

package/dist/state/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/state/history.ts","../../src/state/locale.ts","../../src/state/pagination.ts","../../src/state/range.ts","../../src/state/selection.ts","../../src/state/virtual.ts"],"mappings":";;;;qBASa,eAAgB,OAAO,OAAO,OAAO,MAAM,oBAAe,OAAA;;;;;YAM3D,aAAa;WACd,MAAM,cAAc;WACpB,SAAS;WACT,QAAQ,cAAc;;qBAGpB,gBAAiB,qBAAqB,OAAO;WAC/C,MAAM;WACN,OAAO,OAAO,MAAM;WACpB;MACV,OAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+DY,UAAW,OAAO,OAAO,aAAa;;qBAGtC,UAAW,OAAO,OAAO,aAAa;;;qBCjFtC,aAAW,OAAA;;;YACZ,qBAAqB,YAAY;qBAEhC,yCAAa;;qBAAb,OAAA;;;YACD,uBAAuB,cAAc;qBAEpC,QAAM,OAAA;;;;;;;;;;qBCPN,iBAAe,OAAA;;;;;YAKhB,yBAAyB,gBAAgB;qBAExC,6CAAiB;;;;;;;;;;;;;YAOlB,2BAA2B,kBAAkB;;qBAU5C,YAAa,OAAO;;qBAIpB,SAAU,OAAO;qBAEjB,YAAU,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBChCV,QAAS,eAAe,aAAa,kBAAW;;;qBCEhD,mBAAiB,OAAA;;;YAClB,2BAA2B,kBAAkB;qBAE5C,+CAAmB;;;;;;;;;;;;;;;YAOpB,6BAA6B,oBAAoB;;qBAMhD,aAAc,OAAO,mBAAmB;qBAGxC,cAAY,OAAA;;;;;;;;;;;;;;;;;;;iBCRR;;WAEN;;WAEA;;;iBAIM;WACN;WACA;WACA;WACA;;;qBAkBE,cACX,MAAM,uBACN,SAAS,SAAS,yBAClB,QAAQ;;qBAWG,YACX,eACA,MAAM,uBACN,SAAS,SAAS,yBAClB,QAAQ;;;;;;;;qBAiBG,eACX,MAAM,uBACN,SAAS,SAAS,yBAClB,QAAQ,eACR,mBACA,wBACA,qBACC;qBA4BU,cAAY,OAAA;;;;;;;;;;;YAWb,sBAAsB,aAAa;qBAElC,0CAAc;;;;;;;;;;;;;;;;;;;YAUf,wBAAwB,eAAe;;;;;;;qBAetC,YACX,OAAO,cACP,MAAM,uBACN,2BACC;WAA2B;;;;;;;qBAkBjB,gBACX,OAAO,cACP,MAAM,uBACN;;;;;;;qBAYW,UACX,OAAO,cACP,MAAM,uBACN,wBACA;qBAYW,SAAO,OAAA;WAKU;WACP;WACL;WACS;WACF;WACD;WACQ;WACF,iBAAA,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmG1B,kBAAgB,OAAA;;;YACjB,0BAA0B,iBAAiB;;;;;;qBAO1C,UAAQ,MAAA;;;;qBAeR,aAAW,OAAA;;;;YAIZ,qBAAqB,YAAY;;;;;;qBAShC,YAAU,MAAA;;;;;;;;;;;;;;qBAgCV,eACX,UAAU;WAAyB;WAAsB;IACzD;iBAae;WACN;WACA;WACA;WACA;WACA;WACA;;;;;;;;;qBAUE,UACX,MAAM,uBACN,SAAS,SAAS,yBAClB;WACW;WACA;WACA;WACA;;WAEC,YAAY,cAAc;WAA4B"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/state/history.ts","../../src/state/locale.ts","../../src/state/pagination.ts","../../src/state/range.ts","../../src/state/selection.ts","../../src/state/virtual.ts"],"mappings":";;;;qBAiBa,eAAgB,OAAO,OAAO,OAAO,MAAM,oBAAe,OAAA;;;;;;;YAQ3D,aAAa;WACd,MAAM,cAAc;WACpB,SAAS;WACT,QAAQ,cAAc;WACtB;;;qBA2FE,UAAW,OAAO,OAAO,aAAa;;qBAGtC,UAAW,OAAO,OAAO,aAAa;;qBAGtC;;EA9FE,QAAA,OAAK,SAAW,UAAQ,aAAa;;EAetC,OAAA,OAAK,OACV,aAAa,QAAM,OACnB,OAAK;aACQ;aAA2B;QAC9C,aAAa;;EAcF,OAAA,OAAK,OAAS,aAAa,WAAS,aAAa;;EAWjD,OAAA,OAAK,OAAS,aAAa,WAAS,aAAa;;;;;;EAWjD,OAAA,OAAK,OAAS,aAAa,QAAM,iBAAiB,aAAa;;EAY9D,QAAA,OAAK,OAAS,aAAa,WAAS,aAAa;;EAKjD,QAAA,OAAK,OAAS,aAAa,WAAS,aAAa;;;;;;;;;EAGhD,SAAA,OAAK,OAAS,aAAa,QAAM,kBAAkB,aAAa;EAaxD,UAAA,OAAK,OAAS,aAAa;EAG3B,UAAA,OAAK,OAAS,aAAa;;qBAmCtC,gBAAiB,qBAAqB,OAAO;WAC/C,MAAM;WACN,OAAO,OAAO,MAAM;WACpB;MACV,OAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBCxJY,aAAW,OAAA;;;YACZ,qBAAqB,YAAY;qBAEhC,yCAAa;;qBAAb,OAAA;;;YACD,uBAAuB,cAAc;qBAEpC,QAAM,OAAA;;;;;;;;;;qBCNN,iBAAe,OAAA;;;;;YAKhB,yBAAyB,gBAAgB;qBAExC,6CAAiB;;;;;;;;;;;;;YAOlB,2BAA2B,kBAAkB;;qBAU5C,YAAa,OAAO;;qBAIpB,SAAU,OAAO;qBAEjB,YAAU,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBCjCV,QAAS,eAAe,aAAa,kBAAW;;;qBCGhD,mBAAiB,OAAA;;;YAClB,2BAA2B,kBAAkB;qBAE5C,+CAAmB;;;;;;;;;;;;;;;YAOpB,6BAA6B,oBAAoB;;qBAMhD,aAAc,OAAO,mBAAmB;qBAGxC,cAAY,OAAA;;;;;;;;;;;;;;;;;;;iBCTR;;WAEN;;WAEA;;;iBAIM;WACN;WACA;WACA;WACA;;;qBAmEE,cACX,MAAM,uBACN,SAAS,SAAS,yBAClB,QAAQ;;qBAcG,YACX,eACA,MAAM,uBACN,SAAS,SAAS,yBAClB,QAAQ;;;;;;;;qBAUG,eACX,MAAM,uBACN,SAAS,SAAS,yBAClB,QAAQ,eACR,mBACA,wBACA,qBACC;qBAmBU,cAAY,OAAA;;;;;;;;;;;YAWb,sBAAsB,aAAa;qBAElC,0CAAc;;;;;;;;;;;;;;;;;;;YAUf,wBAAwB,eAAe;;;;;;;qBAetC,YACX,OAAO,cACP,MAAM,uBACN,2BACC;WAA2B;;;;;;;qBAkBjB,gBACX,OAAO,cACP,MAAM,uBACN;;;;;;;qBAYW,UACX,OAAO,cACP,MAAM,uBACN,wBACA;qBAYW,SAAO,OAAA;WAKU;WACP;WACL;WACS;WACF;WACD;WACQ;WACF,iBAAA,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyG1B,kBAAgB,OAAA;;;YACjB,0BAA0B,iBAAiB;;;;;;qBAO1C,UAAQ,MAAA;;;;qBAeR,aAAW,OAAA;;;;YAIZ,qBAAqB,YAAY;;;;;;qBAShC,YAAU,MAAA;;;;;;;;;;;;;;qBAgCV,eACX,UAAU;WAAyB;WAAsB;IACzD;iBAae;WACN;WACA;WACA;WACA;WACA;WACA;;;;;;;;;qBAUE,UACX,MAAM,uBACN,SAAS,SAAS,yBAClB;WACW;WACA;WACA;WACA;;WAEC,YAAY,cAAc;WAA4B"}

package/dist/state/index.mjs

@@ -1,3 +1,4 @@
+import { i as unlessSame, r as sameIds } from "../internal-DP-xLKbT.mjs";
 import { Effect, Queue, Schema, Stream } from "effect";
 import * as Mount from "foldkit/mount";
 import { defineMessageUnion } from "foldkit/message";
@@ -7,67 +8,162 @@ import { Bundle } from "foldkit-bundle";
 * Undo/redo as a bundle factory: the past, present, and future of one value
 * live in the Model, so every step replays. Pushing records, even an unchanged
 * value; skipping duplicates is the application's policy, not the stack's.
+*
+* A push may name a `group`. Consecutive pushes of the same group are one step:
+* the present moves and nothing new is recorded, so typing a word undoes as a
+* whole. Grouping needs no clock; the application names what belongs together.
+*
+* The steps are also pure functions (`History.push`, `undo`, `redo`, `goTo`, `clear`),
+* for a parent that records an edit in the same transition that makes it
+* rather than dispatching a Message to a placed bundle.
 */
 const HistoryModel = (value) => Schema.Struct({
 	past: Schema.Array(value),
 	present: value,
-	future: Schema.Array(value)
+	future: Schema.Array(value),
+	/** The group of the last push, so the next push of the same group joins it; `null` for none. */
+	group: Schema.NullOr(Schema.String)
+});
+const start = (present) => ({
+	past: [],
+	present,
+	future: [],
+	group: null
 });
+/**
+* No redo steps, keeping an already empty future: a view that reads the
+* future compares it by identity, so a push per keystroke or stroke cell
+* must not hand it a new empty array each time.
+*/
+const noFuture = (model) => model.future.length === 0 ? model.future : [];
+const push = (model, value, options) => {
+	const group = options.group ?? null;
+	if (group !== null && group === model.group && model.past.length > 0) return {
+		...model,
+		present: value,
+		future: noFuture(model)
+	};
+	return {
+		past: options.capacity === 0 ? [] : [...model.past, model.present].slice(-options.capacity),
+		present: value,
+		future: noFuture(model),
+		group
+	};
+};
+const undo = (model) => {
+	const previous = model.past[model.past.length - 1];
+	if (previous === void 0) return model;
+	return {
+		past: model.past.slice(0, -1),
+		present: previous,
+		future: [model.present, ...model.future],
+		group: null
+	};
+};
+const redo = (model) => {
+	const next = model.future[0];
+	if (next === void 0) return model;
+	return {
+		past: [...model.past, model.present],
+		present: next,
+		future: model.future.slice(1),
+		group: null
+	};
+};
+const goTo = (model, step) => {
+	const steps = [
+		...model.past,
+		model.present,
+		...model.future
+	];
+	if (!Number.isInteger(step) || step < 0 || step >= steps.length || step === model.past.length) return model;
+	return {
+		past: steps.slice(0, step),
+		present: steps[step],
+		future: steps.slice(step + 1),
+		group: null
+	};
+};
+const clear = (model) => model.past.length === 0 && model.future.length === 0 && model.group === null ? model : start(model.present);
+const close = (model) => model.group === null ? model : {
+	...model,
+	group: null
+};
+const revert = (model, group) => model.group === group ? {
+	...undo(model),
+	future: [],
+	group: null
+} : model;
+const checkCapacity = (name, capacity) => {
+	if (!Number.isInteger(capacity) || capacity < 0) throw new Error(`History "${name}": capacity must be a non-negative integer`);
+	return capacity;
+};
+/** Whether Undo would move: the past is non-empty. */
+const canUndo = (model) => model.past.length > 0;
+/** Whether Redo would move: the future is non-empty. */
+const canRedo = (model) => model.future.length > 0;
+/** The steps of a history as pure functions of its Model. */
+const History = {
+	/** A history whose present is `value`, with nothing to undo. */
+	start,
+	/** Records `value` as the present; the same `group` as the last push joins its step. */
+	push,
+	/** One step back, or the Model as it was when there is none. */
+	undo,
+	/** One step forward, or the Model as it was when there is none. */
+	redo,
+	/**
+	* The value at `step` made the present, counting every kept value from the
+	* oldest (0), so the present is at `past.length`: what a click on a step's
+	* thumbnail does. The Model as it was for the present or a step not kept.
+	*/
+	goTo,
+	/** Nothing to undo or redo, the present kept. */
+	clear,
+	/** The next push starts a step of its own, whatever its group: a group ends here. */
+	close,
+	/**
+	* The step `group` is making taken back, and not redoable: what a cancelled
+	* edit, or one that ended where it began, leaves. The Model as it was when
+	* the last push was not of `group`. What the group's first push dropped
+	* stays dropped: the redo future it cleared, and an entry capacity evicted;
+	* with a capacity of 0 nothing was kept, so the present stays and only the
+	* group ends.
+	*/
+	revert,
+	canUndo,
+	canRedo
+};
 const history = (config) => {
-	const capacity = config.capacity ?? 100;
-	if (!Number.isInteger(capacity) || capacity < 0) throw new Error(`History "${config.name}": capacity must be a non-negative integer`);
+	const capacity = checkCapacity(config.name, config.capacity ?? 100);
 	const Model = HistoryModel(config.value);
 	const Message = defineMessageUnion({
-		Push: { value: config.value },
+		Push: {
+			value: config.value,
+			group: Schema.optional(Schema.String)
+		},
 		Undo: {},
 		Redo: {},
+		GoTo: { step: Schema.Number },
 		Clear: {}
 	});
 	return Object.assign(Bundle.make(config.name, {
 		Model,
 		Message,
 		args: Schema.Struct({ initial: config.value }),
-		init: (args) => ({ model: {
-			past: [],
-			present: args.initial,
-			future: []
-		} }),
+		init: (args) => ({ model: start(args.initial) }),
 		update: (model, message) => Message.match(message, {
-			Push: ({ value }) => ({ model: {
-				past: capacity === 0 ? [] : [...model.past, model.present].slice(-capacity),
-				present: value,
-				future: []
-			} }),
-			Undo: () => {
-				const previous = model.past[model.past.length - 1];
-				if (previous === void 0) return { model };
-				return { model: {
-					past: model.past.slice(0, -1),
-					present: previous,
-					future: [model.present, ...model.future]
-				} };
-			},
-			Redo: () => {
-				const next = model.future[0];
-				if (next === void 0) return { model };
-				return { model: {
-					past: [...model.past, model.present],
-					present: next,
-					future: model.future.slice(1)
-				} };
-			},
-			Clear: () => ({ model: {
-				past: [],
-				present: model.present,
-				future: []
-			} })
+			Push: ({ value, group }) => ({ model: push(model, value, {
+				capacity,
+				group
+			}) }),
+			Undo: () => ({ model: undo(model) }),
+			Redo: () => ({ model: redo(model) }),
+			GoTo: ({ step }) => ({ model: goTo(model, step) }),
+			Clear: () => ({ model: clear(model) })
 		})
 	}), { Message });
 };
-/** Whether Undo would move: the past is non-empty. */
-const canUndo = (model) => model.past.length > 0;
-/** Whether Redo would move: the future is non-empty. */
-const canRedo = (model) => model.future.length > 0;
 //#endregion
 //#region src/state/locale.ts
 /**
@@ -83,10 +179,10 @@ const Locale = Bundle.make("Locale", {
 	Message: LocaleMessage,
 	args: Schema.Struct({ default: Schema.String }),
 	init: (args) => ({ model: { locale: typeof navigator !== "undefined" && typeof navigator.language === "string" ? navigator.language : args.default } }),
-	update: (model, message) => LocaleMessage.match(message, { SetLocale: ({ locale }) => ({ model: {
+	update: (model, message) => LocaleMessage.match(message, { SetLocale: ({ locale }) => locale === model.locale ? { model } : { model: {
 		...model,
 		locale
-	} }) })
+	} } })
 });
 //#endregion
 //#region src/state/pagination.ts
@@ -130,28 +226,28 @@ const Pagination = Bundle.make("Pagination", {
 		total: args.total ?? null
 	} }),
 	update: (model, message) => PaginationMessage.match(message, {
-		GoToPage: ({ page }) => ({ model: {
+		GoToPage: ({ page }) => ({ model: unlessSame(model, {
 			...model,
 			page: clampPage(page, model.perPage, model.total)
-		} }),
-		NextPage: () => ({ model: {
+		}) }),
+		NextPage: () => ({ model: unlessSame(model, {
 			...model,
 			page: clampPage(model.page + 1, model.perPage, model.total)
-		} }),
-		PrevPage: () => ({ model: {
+		}) }),
+		PrevPage: () => ({ model: unlessSame(model, {
 			...model,
 			page: clampPage(model.page - 1, model.perPage, model.total)
-		} }),
-		SetPerPage: ({ perPage }) => perPage > 0 ? { model: {
+		}) }),
+		SetPerPage: ({ perPage }) => perPage > 0 ? { model: unlessSame(model, {
 			...model,
 			perPage,
 			page: clampPage(model.page, perPage, model.total)
-		} } : { model },
-		SetTotal: ({ total }) => total === null || total >= 0 ? { model: {
+		}) } : { model },
+		SetTotal: ({ total }) => total === null || total >= 0 ? { model: unlessSame(model, {
 			...model,
 			total,
 			page: clampPage(model.page, model.perPage, total)
-		} } : { model }
+		}) } : { model }
 	})
 });
 //#endregion
@@ -194,10 +290,13 @@ const SelectionSet = Bundle.make("SelectionSet", {
 	init: () => ({ model: { selected: [] } }),
 	update: (model, message) => SelectionSetMessage.match(message, {
 		Select: ({ id }) => isSelected(model, id) ? { model } : { model: { selected: [...model.selected, id] } },
-		Deselect: ({ id }) => ({ model: { selected: without(model.selected, id) } }),
+		Deselect: ({ id }) => isSelected(model, id) ? { model: { selected: without(model.selected, id) } } : { model },
 		Toggle: ({ id }) => isSelected(model, id) ? { model: { selected: without(model.selected, id) } } : { model: { selected: [...model.selected, id] } },
-		ReplaceAll: ({ ids }) => ({ model: { selected: [...new Set(ids)] } }),
-		Clear: () => ({ model: { selected: [] } })
+		ReplaceAll: ({ ids }) => {
+			const selected = [...new Set(ids)];
+			return sameIds(selected, model.selected) ? { model } : { model: { selected } };
+		},
+		Clear: () => model.selected.length === 0 ? { model } : { model: { selected: [] } }
 	})
 });
 //#endregion
@@ -222,22 +321,40 @@ const heightAt = (index, heights, keys, layout) => {
 	if (key === void 0) return layout.estimatedHeight;
 	return saneHeight(heights[key] ?? layout.estimatedHeight, layout.estimatedHeight);
 };
+const offsetsCache = /* @__PURE__ */ new WeakMap();
+const sameLayout = (a, b) => a.estimatedHeight === b.estimatedHeight && a.gap === b.gap && a.paddingStart === b.paddingStart && a.paddingEnd === b.paddingEnd;
+const topsFor = (keys, heights, layout) => {
+	const cached = offsetsCache.get(keys);
+	if (cached !== void 0 && cached.heights === heights && sameLayout(cached.layout, layout)) return cached.tops;
+	const tops = new Float64Array(keys.length + 1);
+	tops[0] = layout.paddingStart;
+	for (let index = 0; index < keys.length; index++) tops[index + 1] = tops[index] + heightAt(index, heights, keys, layout) + layout.gap;
+	offsetsCache.set(keys, {
+		heights,
+		layout: { ...layout },
+		tops
+	});
+	return tops;
+};
+/** The first index in `[from, to)` whose value passes `test`, or `to`; `test` must be monotonic. */
+const firstIndex = (from, to, test) => {
+	let low = from;
+	let high = to;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if (test(middle)) high = middle;
+		else low = middle + 1;
+	}
+	return low;
+};
 /** Total scrollable height: padding, measured rows, estimates, and gaps. */
 const totalHeight = (keys, heights, layout) => {
-	let total = layout.paddingStart + layout.paddingEnd;
-	for (let index = 0; index < keys.length; index++) {
-		total += heightAt(index, heights, keys, layout);
-		if (index < keys.length - 1) total += layout.gap;
-	}
-	return total;
+	const last = keys.length - 1;
+	if (last === -1) return layout.paddingStart + layout.paddingEnd;
+	return topsFor(keys, heights, layout)[last] + heightAt(last, heights, keys, layout) + layout.paddingEnd;
 };
 /** Pixel offset of a row's top edge: padding plus the prefix before it. */
-const offsetFor = (index, keys, heights, layout) => {
-	const clamped = Math.max(0, Math.min(index, keys.length));
-	let offset = layout.paddingStart;
-	for (let i = 0; i < clamped; i++) offset += heightAt(i, heights, keys, layout) + layout.gap;
-	return offset;
-};
+const offsetFor = (index, keys, heights, layout) => topsFor(keys, heights, layout)[Math.max(0, Math.min(index, keys.length))];
 /**
 * Which rows to render for a scroll position: the rows intersecting
 * `[scrollTop, scrollTop + viewportHeight)`, widened by `overscan` on both
@@ -251,23 +368,11 @@ const visibleRange = (keys, heights, layout, scrollTop, viewportHeight, overscan
 		start: 0,
 		end: 0
 	};
+	const tops = topsFor(keys, heights, layout);
 	const top = Math.max(0, scrollTop);
 	const bottom = top + viewportHeight;
-	let start = 0;
-	let offset = layout.paddingStart;
-	for (let index = 0; index < count; index++) {
-		const height = heightAt(index, heights, keys, layout);
-		if (offset + height <= top) {
-			start = index + 1;
-			offset += height + layout.gap;
-		} else break;
-	}
-	let end = start;
-	let cursor = offset;
-	while (end < count && cursor < bottom) {
-		cursor += heightAt(end, heights, keys, layout) + layout.gap;
-		end += 1;
-	}
+	const start = firstIndex(0, count, (index) => tops[index] + heightAt(index, heights, keys, layout) > top);
+	const end = firstIndex(start, count, (index) => tops[index] >= bottom);
 	return {
 		start: Math.max(0, start - Math.max(0, overscan)),
 		end: Math.min(count, end + Math.max(0, overscan))
@@ -331,8 +436,9 @@ const distanceToEnd = (model, keys, viewportHeight) => {
 * to zero.
 */
 const isAtEnd = (model, keys, viewportHeight, threshold = 0) => {
-	if (totalHeight(keys, model.heights, layoutOf(model)) <= 0) return true;
-	return distanceToEnd(model, keys, viewportHeight) <= Math.max(0, threshold);
+	const total = totalHeight(keys, model.heights, layoutOf(model));
+	if (total <= 0) return true;
+	return total - (model.scrollTop + viewportHeight) <= Math.max(0, threshold);
 };
 const saneTop = (top) => Number.isFinite(top) ? Math.max(0, top) : null;
 const saneMeasured = (height) => Number.isFinite(height) && height >= 0 ? height : null;
@@ -370,7 +476,7 @@ const Virtual = Bundle.make("Virtual", {
 	update: (model, message, args) => VirtualMessage.match(message, {
 		Scrolled: ({ top }) => {
 			const sane = saneTop(top);
-			if (sane === null) return { model };
+			if (sane === null || top === model.scrollTop) return { model };
 			const generation = model.generation + 1;
 			return {
 				model: {
@@ -388,7 +494,7 @@ const Virtual = Bundle.make("Virtual", {
 		},
 		Measured: ({ key, height }) => {
 			const sane = saneMeasured(height);
-			return sane === null ? { model } : { model: {
+			return sane === null || Object.hasOwn(model.heights, key) && model.heights[key] === sane ? { model } : { model: {
 				...model,
 				heights: {
 					...model.heights,
@@ -399,11 +505,13 @@ const Virtual = Bundle.make("Virtual", {
 		Prune: ({ keys }) => {
 			const kept = new Set(keys);
 			const heights = {};
+			let dropped = false;
 			for (const [key, height] of Object.entries(model.heights)) if (kept.has(key)) heights[key] = height;
-			return { model: {
+			else dropped = true;
+			return dropped ? { model: {
 				...model,
 				heights
-			} };
+			} } : { model };
 		},
 		Settled: ({ generation }) => generation === model.generation ? { model: {
 			...model,
@@ -506,6 +614,6 @@ const masonry = (keys, heights, options) => {
 	};
 };
 //#endregion
-export { HistoryModel, Locale, LocaleMessage, LocaleModel, MeasureRow, Pagination, PaginationMessage, PaginationModel, RowMeasured, SelectionSet, SelectionSetMessage, SelectionSetModel, Viewport, ViewportScrolled, Virtual, VirtualMessage, VirtualModel, canRedo, canUndo, distanceToEnd, history, isAtEnd, isSelected, masonry, offset, offsetFor, pageCount, range, stickyHeader, totalHeight, visibleRange, windowFor };
+export { History, HistoryModel, Locale, LocaleMessage, LocaleModel, MeasureRow, Pagination, PaginationMessage, PaginationModel, RowMeasured, SelectionSet, SelectionSetMessage, SelectionSetModel, Viewport, ViewportScrolled, Virtual, VirtualMessage, VirtualModel, canRedo, canUndo, distanceToEnd, history, isAtEnd, isSelected, masonry, offset, offsetFor, pageCount, range, stickyHeader, totalHeight, visibleRange, windowFor };
 
 //# sourceMappingURL=index.mjs.map