foldkit-primitives 0.9.0 → 0.10.1

package/dist/state/index.d.mts

@@ -15,6 +15,17 @@ export type HistoryModel<Value> = {
   readonly future: ReadonlyArray<Value>;
   readonly group: string | null;
 };
+declare const start: <Value>(present: Value) => HistoryModel<Value>;
+declare const push: <Value>(model: HistoryModel<Value>, value: Value, options: {
+  readonly capacity: number;
+  readonly group?: string | null | undefined;
+}) => HistoryModel<Value>;
+declare const undo: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+declare const redo: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+declare const goTo: <Value>(model: HistoryModel<Value>, step: number) => HistoryModel<Value>;
+declare const clear: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+declare const close: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+declare const revert: <Value>(model: HistoryModel<Value>, group: string) => HistoryModel<Value>;
 /** 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. */
@@ -22,26 +33,23 @@ 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>;
+  start: typeof start;
   /** 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>;
+  push: typeof push;
   /** One step back, or the Model as it was when there is none. */
-  undo: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+  undo: typeof undo;
   /** One step forward, or the Model as it was when there is none. */
-  redo: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+  redo: typeof 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: <Value>(model: HistoryModel<Value>, step: number) => HistoryModel<Value>;
+  goTo: typeof goTo;
   /** Nothing to undo or redo, the present kept. */
-  clear: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+  clear: typeof clear;
   /** The next push starts a step of its own, whatever its group: a group ends here. */
-  close: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+  close: typeof 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
@@ -50,10 +58,23 @@ export declare const History: {
    * 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;
+  revert: typeof revert;
+  canUndo: typeof canUndo;
+  canRedo: typeof canRedo;
 };
+/**
+ * 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.
+ */
 export declare const history: <const Name extends string, Value>(config: {
   readonly name: Name;
   readonly value: Schema.Codec<Value, unknown>;
@@ -61,28 +82,28 @@ export declare const history: <const Name extends string, Value>(config: {
 }) => Bundle.Bundle<Name, {
   readonly initial: Value;
 }, HistoryModel<Value>, {
+  readonly _tag: "Clear";
+} | {
+  readonly _tag: "GoTo";
+  readonly step: number;
+} | {
   readonly _tag: "Push";
   readonly value: Value;
   readonly group?: string | undefined;
-} | {
-  readonly _tag: "Undo";
 } | {
   readonly _tag: "Redo";
 } | {
-  readonly _tag: "GoTo";
-  readonly step: number;
-} | {
-  readonly _tag: "Clear";
+  readonly _tag: "Undo";
 }, 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>;
+      value: Schema.Codec<Value, unknown, never, never>;
+      group: Schema.optional<Schema.String>;
     };
     readonly Undo: {};
     readonly Redo: {};
     readonly GoTo: {
-      readonly step: Schema.Number;
+      step: Schema.Number;
     };
     readonly Clear: {};
   }>;
@@ -95,10 +116,16 @@ export declare const LocaleModel: Schema.Struct<{
 export type LocaleModel = typeof LocaleModel.Type;
 export declare const LocaleMessage: import("foldkit/message").MessageUnion<{
   readonly SetLocale: {
-    readonly locale: Schema.String;
+    locale: Schema.String;
   };
 }>;
 export type LocaleMessage = typeof LocaleMessage.Type;
+/**
+ * Locale as a bundle: the current locale string in the Model. Starts from
+ * `navigator.language` where available, falling back to the configured
+ * default; changes arrive as Messages. No subscriptions: language changes
+ * take effect on reload.
+ */
 export declare const Locale: Bundle.Bundle<"Locale", {
   readonly default: string;
 }, {
@@ -117,15 +144,15 @@ export declare const PaginationModel: Schema.Struct<{
 export type PaginationModel = typeof PaginationModel.Type;
 export declare const PaginationMessage: import("foldkit/message").MessageUnion<{
   readonly GoToPage: {
-    readonly page: Schema.Number;
+    page: Schema.Number;
   };
   readonly NextPage: {};
   readonly PrevPage: {};
   readonly SetPerPage: {
-    readonly perPage: Schema.Number;
+    perPage: Schema.Number;
   };
   readonly SetTotal: {
-    readonly total: Schema.NullOr<Schema.Number>;
+    total: Schema.NullOr<Schema.Number>;
   };
 }>;
 export type PaginationMessage = typeof PaginationMessage.Type;
@@ -133,6 +160,11 @@ export type PaginationMessage = typeof PaginationMessage.Type;
 export declare const pageCount: (model: PaginationModel) => number | null;
 /** The offset of the first item on the page, for a slice or a query. */
 export declare const offset: (model: PaginationModel) => number;
+/**
+ * Pagination as a bundle: the page, page size, and total live in the Model,
+ * so page changes replay and every transition clamps into range. Pure logic,
+ * no streams: data loading stays the application's job.
+ */
 export declare const Pagination: Bundle.Bundle<"Pagination", {
   readonly perPage: number;
   readonly total?: number | null | undefined;
@@ -172,41 +204,47 @@ export declare const SelectionSetModel: Schema.Struct<{
 export type SelectionSetModel = typeof SelectionSetModel.Type;
 export declare const SelectionSetMessage: import("foldkit/message").MessageUnion<{
   readonly Select: {
-    readonly id: Schema.String;
+    id: Schema.String;
   };
   readonly Deselect: {
-    readonly id: Schema.String;
+    id: Schema.String;
   };
   readonly Toggle: {
-    readonly id: Schema.String;
+    id: Schema.String;
   };
   readonly ReplaceAll: {
-    readonly ids: Schema.$Array<Schema.String>;
+    ids: Schema.$Array<Schema.String>;
   };
   readonly Clear: {};
 }>;
 export type SelectionSetMessage = typeof SelectionSetMessage.Type;
 /** Whether the id is currently selected. */
 export declare const isSelected: (model: SelectionSetModel, id: string) => boolean;
+/**
+ * A selection set as a bundle: the selected ids in the Model, changed one at
+ * a time or replaced whole. Order follows first selection; toggling moves a
+ * reselected id to the end. Pure logic, no streams.
+ */
 export declare const SelectionSet: Bundle.Bundle<"SelectionSet", void, {
   readonly selected: readonly string[];
 }, {
   readonly _tag: "Clear";
 } | {
-  readonly _tag: "Select";
+  readonly _tag: "Deselect";
   readonly id: string;
 } | {
-  readonly _tag: "Deselect";
+  readonly _tag: "ReplaceAll";
+  readonly ids: readonly string[];
+} | {
+  readonly _tag: "Select";
   readonly id: string;
 } | {
   readonly _tag: "Toggle";
   readonly id: string;
-} | {
-  readonly _tag: "ReplaceAll";
-  readonly ids: readonly string[];
 }, never, never, never, void, {}, {}>;
 //#endregion
 //#region src/state/virtual.d.ts
+/** The rows to draw: a half-open range of indexes. */
 export interface VirtualWindow {
   /** First visible row index, inclusive. */
   readonly start: number;
@@ -246,21 +284,21 @@ export declare const VirtualModel: Schema.Struct<{
 export type VirtualModel = typeof VirtualModel.Type;
 export declare const VirtualMessage: import("foldkit/message").MessageUnion<{
   readonly Scrolled: {
-    readonly top: Schema.Number;
+    top: Schema.Number;
   };
   readonly Measured: {
-    readonly key: Schema.String;
-    readonly height: Schema.Number;
+    key: Schema.String;
+    height: Schema.Number;
   };
   /** Drops heights for keys no longer listed: the bundle never sees the key
       order, so the application tells it what left. */
   readonly Prune: {
-    readonly keys: Schema.$Array<Schema.String>;
+    keys: Schema.$Array<Schema.String>;
   };
   /** Fires when scrolling has been silent for `settleMs`: only the latest
       generation counts, so a fling's intermediate timers emit nothing. */
   readonly Settled: {
-    readonly generation: Schema.Number;
+    generation: Schema.Number;
   };
 }>;
 export type VirtualMessage = typeof VirtualMessage.Type;
@@ -286,6 +324,20 @@ export declare const distanceToEnd: (model: VirtualModel, keys: ReadonlyArray<st
  * to zero.
  */
 export declare const isAtEnd: (model: VirtualModel, keys: ReadonlyArray<string>, viewportHeight: number, threshold?: number) => boolean;
+/**
+ * Windowing math for virtualized lists as pure functions: which rows to
+ * render, how tall the scrollable area is, and where each row starts. Row
+ * heights come from measured values with a per-row estimate fallback, so
+ * unmeasured rows still occupy space and measuring later only corrects.
+ * Keys are strings; heights are non-negative, and non-finite measurements
+ * fall back to the estimate instead of poisoning the sums.
+ *
+ * The `Virtual` bundle below owns the scroll position and the measured
+ * heights; `Viewport` reports container scrolls and `MeasureRow` reports
+ * row heights, both as Mounts on the elements they observe. The application
+ * renders `windowFor(...)` rows with its own views (keyed, so `each`
+ * placements keep identity) inside a spacer of `totalHeight(...)`.
+ */
 export declare const Virtual: Bundle.Bundle<"Virtual", {
   readonly estimatedHeight: number;
   readonly overscan: number;
@@ -312,14 +364,14 @@ export declare const Virtual: Bundle.Bundle<"Virtual", {
   readonly key: string;
   readonly height: number;
 } | {
-  readonly _tag: "Settled";
-  readonly generation: number;
+  readonly _tag: "Prune";
+  readonly keys: readonly string[];
 } | {
   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;
@@ -362,6 +414,7 @@ export declare const stickyHeader: (sections: ReadonlyArray<{
   readonly key: string;
   readonly index: number;
 }>, startIndex: number) => string | null;
+/** Where `masonry` puts one item: its column and its box, in pixels. */
 export interface MasonryPlacement {
   readonly key: string;
   readonly column: number;
@@ -387,4 +440,5 @@ export declare const masonry: (keys: ReadonlyArray<string>, heights: Readonly<Re
   readonly totalHeight: number;
 };
 //#endregion
+export {};
 //# sourceMappingURL=index.d.mts.map

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":";;;;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"}
+{"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":"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"}

package/dist/state/index.mjs

@@ -4,19 +4,6 @@ import * as Mount from "foldkit/mount";
 import { defineMessageUnion } from "foldkit/message";
 import { Bundle } from "foldkit-bundle";
 //#region src/state/history.ts
-/**
-* 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,
@@ -134,6 +121,19 @@ const History = {
 	canUndo,
 	canRedo
 };
+/**
+* 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 history = (config) => {
 	const capacity = checkCapacity(config.name, config.capacity ?? 100);
 	const Model = HistoryModel(config.value);
@@ -166,14 +166,14 @@ const history = (config) => {
 };
 //#endregion
 //#region src/state/locale.ts
+const LocaleModel = Schema.Struct({ locale: Schema.String });
+const LocaleMessage = defineMessageUnion({ SetLocale: { locale: Schema.String } });
 /**
 * Locale as a bundle: the current locale string in the Model. Starts from
 * `navigator.language` where available, falling back to the configured
 * default; changes arrive as Messages. No subscriptions: language changes
 * take effect on reload.
 */
-const LocaleModel = Schema.Struct({ locale: Schema.String });
-const LocaleMessage = defineMessageUnion({ SetLocale: { locale: Schema.String } });
 const Locale = Bundle.make("Locale", {
 	Model: LocaleModel,
 	Message: LocaleMessage,
@@ -186,11 +186,6 @@ const Locale = Bundle.make("Locale", {
 });
 //#endregion
 //#region src/state/pagination.ts
-/**
-* Pagination as a bundle: the page, page size, and total live in the Model,
-* so page changes replay and every transition clamps into range. Pure logic,
-* no streams: data loading stays the application's job.
-*/
 const PaginationModel = Schema.Struct({
 	page: Schema.Number,
 	perPage: Schema.Number,
@@ -213,6 +208,11 @@ const clampPage = (page, perPage, total) => {
 const pageCount = (model) => model.total === null ? null : Math.max(1, Math.ceil(model.total / model.perPage));
 /** The offset of the first item on the page, for a slice or a query. */
 const offset = (model) => (model.page - 1) * model.perPage;
+/**
+* Pagination as a bundle: the page, page size, and total live in the Model,
+* so page changes replay and every transition clamps into range. Pure logic,
+* no streams: data loading stays the application's job.
+*/
 const Pagination = Bundle.make("Pagination", {
 	Model: PaginationModel,
 	Message: PaginationMessage,
@@ -268,11 +268,6 @@ const range = (start, end, step = 1) => {
 };
 //#endregion
 //#region src/state/selection.ts
-/**
-* A selection set as a bundle: the selected ids in the Model, changed one at
-* a time or replaced whole. Order follows first selection; toggling moves a
-* reselected id to the end. Pure logic, no streams.
-*/
 const SelectionSetModel = Schema.Struct({ selected: Schema.Array(Schema.String) });
 const SelectionSetMessage = defineMessageUnion({
 	Select: { id: Schema.String },
@@ -284,6 +279,11 @@ const SelectionSetMessage = defineMessageUnion({
 const without = (selected, id) => selected.filter((other) => other !== id);
 /** Whether the id is currently selected. */
 const isSelected = (model, id) => model.selected.includes(id);
+/**
+* A selection set as a bundle: the selected ids in the Model, changed one at
+* a time or replaced whole. Order follows first selection; toggling moves a
+* reselected id to the end. Pure logic, no streams.
+*/
 const SelectionSet = Bundle.make("SelectionSet", {
 	Model: SelectionSetModel,
 	Message: SelectionSetMessage,
@@ -301,20 +301,6 @@ const SelectionSet = Bundle.make("SelectionSet", {
 });
 //#endregion
 //#region src/state/virtual.ts
-/**
-* Windowing math for virtualized lists as pure functions: which rows to
-* render, how tall the scrollable area is, and where each row starts. Row
-* heights come from measured values with a per-row estimate fallback, so
-* unmeasured rows still occupy space and measuring later only corrects.
-* Keys are strings; heights are non-negative, and non-finite measurements
-* fall back to the estimate instead of poisoning the sums.
-*
-* The `Virtual` bundle below owns the scroll position and the measured
-* heights; `Viewport` reports container scrolls and `MeasureRow` reports
-* row heights, both as Mounts on the elements they observe. The application
-* renders `windowFor(...)` rows with its own views (keyed, so `each`
-* placements keep identity) inside a spacer of `totalHeight(...)`.
-*/
 const saneHeight = (height, estimatedHeight) => Number.isFinite(height) && height >= 0 ? height : estimatedHeight;
 const heightAt = (index, heights, keys, layout) => {
 	const key = keys[index];
@@ -442,6 +428,20 @@ const isAtEnd = (model, keys, viewportHeight, threshold = 0) => {
 };
 const saneTop = (top) => Number.isFinite(top) ? Math.max(0, top) : null;
 const saneMeasured = (height) => Number.isFinite(height) && height >= 0 ? height : null;
+/**
+* Windowing math for virtualized lists as pure functions: which rows to
+* render, how tall the scrollable area is, and where each row starts. Row
+* heights come from measured values with a per-row estimate fallback, so
+* unmeasured rows still occupy space and measuring later only corrects.
+* Keys are strings; heights are non-negative, and non-finite measurements
+* fall back to the estimate instead of poisoning the sums.
+*
+* The `Virtual` bundle below owns the scroll position and the measured
+* heights; `Viewport` reports container scrolls and `MeasureRow` reports
+* row heights, both as Mounts on the elements they observe. The application
+* renders `windowFor(...)` rows with its own views (keyed, so `each`
+* placements keep identity) inside a spacer of `totalHeight(...)`.
+*/
 const Virtual = Bundle.make("Virtual", {
 	Model: VirtualModel,
 	Message: VirtualMessage,