foldkit-primitives 0.15.4 → 0.16.0

package/dist/state/{index.mjs → virtual.js}

@@ -1,300 +1,7 @@
-import { i as unlessSame, r as sameIds } from "../internal-C4gHodLc.mjs";
 import { Effect, Queue, Schema, Stream } from "effect";
-import * as Mount from "foldkit/mount";
 import { defineMessageUnion } from "foldkit/message";
 import { Bundle } from "foldkit-bundle";
-// src/state/history.ts
-const HistoryModel = (value) => Schema.Struct({
-	past: Schema.Array(value),
-	present: 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
-};
-/**
-* 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);
-	const Message = defineMessageUnion({
-		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: start(args.initial) }),
-		update: (model, message) => Message.match(message, {
-			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 });
-};
-// 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 Locale = Bundle.make("Locale", {
-	Model: LocaleModel,
-	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 }) => locale === model.locale ? { model } : { model: {
-		...model,
-		locale
-	} } })
-});
-// src/state/pagination.ts
-const PaginationModel = Schema.Struct({
-	page: Schema.Number,
-	perPage: Schema.Number,
-	total: Schema.NullOr(Schema.Number)
-});
-const PaginationMessage = defineMessageUnion({
-	GoToPage: { page: Schema.Number },
-	NextPage: {},
-	PrevPage: {},
-	SetPerPage: { perPage: Schema.Number },
-	SetTotal: { total: Schema.NullOr(Schema.Number) }
-});
-const clampPage = (page, perPage, total) => {
-	if (!Number.isInteger(page)) return 1;
-	if (page < 1) return 1;
-	if (total === null) return page;
-	return Math.min(page, Math.max(1, Math.ceil(total / perPage)));
-};
-/** The number of pages, or null while the total is unknown. */
-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,
-	args: Schema.Struct({
-		perPage: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())),
-		total: Schema.optional(Schema.NullOr(Schema.Number.pipe(Schema.check(Schema.isFinite()))))
-	}),
-	init: (args) => ({ model: {
-		page: 1,
-		perPage: args.perPage,
-		total: args.total ?? null
-	} }),
-	update: (model, message) => PaginationMessage.match(message, {
-		GoToPage: ({ page }) => ({ model: unlessSame(model, {
-			...model,
-			page: clampPage(page, model.perPage, model.total)
-		}) }),
-		NextPage: () => ({ model: unlessSame(model, {
-			...model,
-			page: clampPage(model.page + 1, model.perPage, model.total)
-		}) }),
-		PrevPage: () => ({ model: unlessSame(model, {
-			...model,
-			page: clampPage(model.page - 1, model.perPage, model.total)
-		}) }),
-		SetPerPage: ({ perPage }) => perPage > 0 ? { model: unlessSame(model, {
-			...model,
-			perPage,
-			page: clampPage(model.page, perPage, model.total)
-		}) } : { model },
-		SetTotal: ({ total }) => total === null || total >= 0 ? { model: unlessSame(model, {
-			...model,
-			total,
-			page: clampPage(model.page, model.perPage, total)
-		}) } : { model }
-	})
-});
-// src/state/range.ts
-/**
-* A numeric range as an array: `range(1, 4)` is `[1, 2, 3]`, inclusive of
-* the start and exclusive of the end, like `Array.from` length math. The
-* pagination companion: `range(1, (pageCount(model) ?? 0) + 1)` is the page
-* list. A zero or non-finite step would loop forever, so it throws, naming
-* the caller — like History's capacity check.
-*/
-const range = (start, end, step = 1) => {
-	if (!Number.isFinite(step) || step === 0) throw new Error(`range: step must be a non-zero finite number, got ${step}`);
-	const values = [];
-	if (step > 0) for (let value = start; value < end; value += step) values.push(value);
-	else for (let value = start; value > end; value += step) values.push(value);
-	return values;
-};
-// src/state/selection.ts
-const SelectionSetModel = Schema.Struct({ selected: Schema.Array(Schema.String) });
-const SelectionSetMessage = defineMessageUnion({
-	Select: { id: Schema.String },
-	Deselect: { id: Schema.String },
-	Toggle: { id: Schema.String },
-	ReplaceAll: { ids: Schema.Array(Schema.String) },
-	Clear: {}
-});
-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,
-	init: () => ({ model: { selected: [] } }),
-	update: (model, message) => SelectionSetMessage.match(message, {
-		Select: ({ id }) => isSelected(model, id) ? { model } : { model: { selected: [...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 }) => {
-			const selected = [...new Set(ids)];
-			return sameIds(selected, model.selected) ? { model } : { model: { selected } };
-		},
-		Clear: () => model.selected.length === 0 ? { model } : { model: { selected: [] } }
-	})
-});
+import * as Mount from "foldkit/mount";
 // src/state/virtual.ts
 const saneHeight = (height, estimatedHeight) => Number.isFinite(height) && height >= 0 ? height : estimatedHeight;
 const heightAt = (index, heights, keys, layout) => {
@@ -451,11 +158,10 @@ const Virtual = Bundle.make("Virtual", {
 		initialHeights: Schema.optional(Schema.Record(Schema.String, Schema.Number))
 	}),
 	init: (args) => {
-		const heights = {};
-		for (const [key, height] of Object.entries(args.initialHeights ?? {})) {
+		const heights = Object.fromEntries(Object.entries(args.initialHeights ?? {}).flatMap(([key, height]) => {
 			const sane = saneMeasured(height);
-			if (sane !== null) heights[key] = sane;
-		}
+			return sane === null ? [] : [[key, sane]];
+		}));
 		return { model: {
 			scrollTop: args.initialScrollTop ?? 0,
 			heights,
@@ -499,13 +205,11 @@ 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;
-			else dropped = true;
-			return dropped ? { model: {
+			const entries = Object.entries(model.heights);
+			const held = entries.filter(([key]) => kept.has(key));
+			return held.length < entries.length ? { model: {
 				...model,
-				heights
+				heights: Object.fromEntries(held)
 			} } : { model };
 		},
 		Settled: ({ generation }) => generation === model.generation ? { model: {
@@ -608,6 +312,6 @@ const masonry = (keys, heights, options) => {
 		totalHeight: placements.length === 0 ? 0 : Math.max(...columnHeights) - options.gap
 	};
 };
-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 };
+export { MeasureRow, RowMeasured, Viewport, ViewportScrolled, Virtual, VirtualMessage, VirtualModel, distanceToEnd, isAtEnd, masonry, offsetFor, stickyHeader, totalHeight, visibleRange, windowFor };
 
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=virtual.js.map

package/dist/state/virtual.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual.js","names":[],"sources":["../../src/state/virtual.ts"],"sourcesContent":["import { Effect, Queue, Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Mount from 'foldkit/mount'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\n\n/** The rows to draw: a half-open range of indexes. */\nexport interface VirtualWindow {\n  /** First visible row index, inclusive. */\n  readonly start: number\n  /** End row index, exclusive. */\n  readonly end: number\n}\n\n/** Layout constants: per-row estimate, inter-row gap, and end padding. */\nexport interface VirtualLayout {\n  readonly estimatedHeight: number\n  readonly gap: number\n  readonly paddingStart: number\n  readonly paddingEnd: number\n}\n\nconst saneHeight = (height: number, estimatedHeight: number): number =>\n  Number.isFinite(height) && height >= 0 ? height : estimatedHeight\n\nconst heightAt = (\n  index: number,\n  heights: Readonly<Record<string, number>>,\n  keys: ReadonlyArray<string>,\n  layout: VirtualLayout,\n): number => {\n  const key = keys[index]\n  if (key === undefined) return layout.estimatedHeight\n  return saneHeight(heights[key] ?? layout.estimatedHeight, layout.estimatedHeight)\n}\n\ninterface Offsets {\n  readonly heights: Readonly<Record<string, number>>\n  readonly layout: VirtualLayout\n  /** `tops[i]` is row i's top edge; `tops[count]` is past the last row's gap. */\n  readonly tops: Float64Array\n}\n\n// One entry per keys array, replaced when the heights or the layout change: a\n// view that keeps its keys array between renders pays O(n) once per change of\n// heights, not once per call. Keys and heights are compared by identity, so an\n// array or record changed in place reads stale offsets; the Model never is.\nconst offsetsCache = new WeakMap<ReadonlyArray<string>, Offsets>()\n\nconst sameLayout = (a: VirtualLayout, b: VirtualLayout): boolean =>\n  a.estimatedHeight === b.estimatedHeight &&\n  a.gap === b.gap &&\n  a.paddingStart === b.paddingStart &&\n  a.paddingEnd === b.paddingEnd\n\nconst topsFor = (\n  keys: ReadonlyArray<string>,\n  heights: Readonly<Record<string, number>>,\n  layout: VirtualLayout,\n): Float64Array => {\n  const cached = offsetsCache.get(keys)\n  if (cached !== undefined && cached.heights === heights && sameLayout(cached.layout, layout)) {\n    return cached.tops\n  }\n  const tops = new Float64Array(keys.length + 1)\n  tops[0] = layout.paddingStart\n  for (let index = 0; index < keys.length; index++) {\n    tops[index + 1] = tops[index]! + heightAt(index, heights, keys, layout) + layout.gap\n  }\n  offsetsCache.set(keys, { heights, layout: { ...layout }, tops })\n  return tops\n}\n\n/** The first index in `[from, to)` whose value passes `test`, or `to`; `test` must be monotonic. */\nconst firstIndex = (from: number, to: number, test: (index: number) => boolean): number => {\n  let low = from\n  let high = to\n  while (low < high) {\n    const middle = (low + high) >>> 1\n    if (test(middle)) high = middle\n    else low = middle + 1\n  }\n  return low\n}\n\n/** Total scrollable height: padding, measured rows, estimates, and gaps. */\nexport const totalHeight = (\n  keys: ReadonlyArray<string>,\n  heights: Readonly<Record<string, number>>,\n  layout: VirtualLayout,\n): number => {\n  const last = keys.length - 1\n  if (last === -1) return layout.paddingStart + layout.paddingEnd\n  // The last row's bottom edge, not `tops[count]` less a gap: subtracting a\n  // fractional gap back out need not land where the row ends.\n  return (\n    topsFor(keys, heights, layout)[last]! +\n    heightAt(last, heights, keys, layout) +\n    layout.paddingEnd\n  )\n}\n\n/** Pixel offset of a row's top edge: padding plus the prefix before it. */\nexport const offsetFor = (\n  index: number,\n  keys: ReadonlyArray<string>,\n  heights: Readonly<Record<string, number>>,\n  layout: VirtualLayout,\n): number => topsFor(keys, heights, layout)[Math.max(0, Math.min(index, keys.length))]!\n\n/**\n * Which rows to render for a scroll position: the rows intersecting\n * `[scrollTop, scrollTop + viewportHeight)`, widened by `overscan` on both\n * sides and clamped to `[0, count]`. Gaps and padding are dead space — no\n * row — so boxes are tested, not cumulative coverage. An overscan of zero\n * renders exactly the visible rows.\n */\nexport const visibleRange = (\n  keys: ReadonlyArray<string>,\n  heights: Readonly<Record<string, number>>,\n  layout: VirtualLayout,\n  scrollTop: number,\n  viewportHeight: number,\n  overscan: number,\n): VirtualWindow => {\n  const count = keys.length\n  if (count === 0 || viewportHeight <= 0) return { start: 0, end: 0 }\n  const tops = topsFor(keys, heights, layout)\n  const top = Math.max(0, scrollTop)\n  const bottom = top + viewportHeight\n  // Row bottoms and tops only grow with the index, so both edges are searches.\n  const start = firstIndex(\n    0,\n    count,\n    index => tops[index]! + heightAt(index, heights, keys, layout) > top,\n  )\n  const end = firstIndex(start, count, index => tops[index]! >= bottom)\n  return {\n    start: Math.max(0, start - Math.max(0, overscan)),\n    end: Math.min(count, end + Math.max(0, overscan)),\n  }\n}\n\nexport const VirtualModel = Schema.Struct({\n  scrollTop: Schema.Number,\n  heights: Schema.Record(Schema.String, Schema.Number),\n  scrolling: Schema.Boolean,\n  generation: Schema.Number,\n  estimatedHeight: Schema.Number,\n  overscan: Schema.Number,\n  gap: Schema.Number,\n  paddingStart: Schema.Number,\n  paddingEnd: Schema.Number,\n})\nexport type VirtualModel = typeof VirtualModel.Type\n\nexport const VirtualMessage = defineMessageUnion({\n  Scrolled: { top: Schema.Number },\n  Measured: { key: Schema.String, height: Schema.Number },\n  /** Drops heights for keys no longer listed: the bundle never sees the key\n    order, so the application tells it what left. */\n  Prune: { keys: Schema.Array(Schema.String) },\n  /** Fires when scrolling has been silent for `settleMs`: only the latest\n    generation counts, so a fling's intermediate timers emit nothing. */\n  Settled: { generation: Schema.Number },\n})\nexport type VirtualMessage = typeof VirtualMessage.Type\n\nconst layoutOf = (model: VirtualModel): VirtualLayout => ({\n  estimatedHeight: model.estimatedHeight,\n  gap: model.gap,\n  paddingStart: model.paddingStart,\n  paddingEnd: model.paddingEnd,\n})\n\n/**\n * The rows to render plus the spacer height, from the Model, the key order,\n * and the viewport height. Layout and overscan come from the Model, so the\n * call cannot disagree with the placement. Keys stay the application's:\n * render each row keyed, and per-row placements keep identity.\n */\nexport const windowFor = (\n  model: VirtualModel,\n  keys: ReadonlyArray<string>,\n  viewportHeight: number,\n): VirtualWindow & { readonly totalHeight: number } => {\n  const layout = layoutOf(model)\n  const window = visibleRange(\n    keys,\n    model.heights,\n    layout,\n    model.scrollTop,\n    viewportHeight,\n    model.overscan,\n  )\n  return { ...window, totalHeight: totalHeight(keys, model.heights, layout) }\n}\n\n/**\n * Pixels from the viewport's bottom edge to the content's end: negative\n * past it, zero exactly there. Prefetch thresholds want this number (\"load\n * when within 500px\"), not just the boolean below.\n */\nexport const distanceToEnd = (\n  model: VirtualModel,\n  keys: ReadonlyArray<string>,\n  viewportHeight: number,\n): number => {\n  const total = totalHeight(keys, model.heights, layoutOf(model))\n  return total - (model.scrollTop + viewportHeight)\n}\n\n/**\n * Whether the viewport rests at (or past) the end, within `threshold`\n * pixels: the infinite-scroll check. An empty list counts as ended — there\n * is nothing to scroll, so more should load. Thresholds below zero clamp\n * to zero.\n */\nexport const isAtEnd = (\n  model: VirtualModel,\n  keys: ReadonlyArray<string>,\n  viewportHeight: number,\n  threshold = 0,\n): boolean => {\n  const total = totalHeight(keys, model.heights, layoutOf(model))\n  if (total <= 0) return true\n  return total - (model.scrollTop + viewportHeight) <= Math.max(0, threshold)\n}\n\nconst saneTop = (top: number): number | null => (Number.isFinite(top) ? Math.max(0, top) : null)\n\nconst saneMeasured = (height: number): number | null =>\n  Number.isFinite(height) && height >= 0 ? height : null\n\n/**\n * Windowing math for virtualized lists as pure functions: which rows to\n * render, how tall the scrollable area is, and where each row starts. Row\n * heights come from measured values with a per-row estimate fallback, so\n * unmeasured rows still occupy space and measuring later only corrects.\n * Keys are strings; heights are non-negative, and non-finite measurements\n * fall back to the estimate instead of poisoning the sums.\n *\n * The `Virtual` bundle below owns the scroll position and the measured\n * heights; `Viewport` reports container scrolls and `MeasureRow` reports\n * row heights, both as Mounts on the elements they observe. The application\n * renders `windowFor(...)` rows with its own views (keyed, so `each`\n * placements keep identity) inside a spacer of `totalHeight(...)`.\n */\nexport const Virtual = Bundle.make('Virtual', {\n  Model: VirtualModel,\n  Message: VirtualMessage,\n  args: Schema.Struct({\n    estimatedHeight: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThan(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n    overscan: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),\n    gap: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThanOrEqualTo(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n    paddingStart: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThanOrEqualTo(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n    paddingEnd: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThanOrEqualTo(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n    settleMs: Schema.optional(\n      Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())),\n    ),\n    initialScrollTop: Schema.optional(\n      Schema.Number.pipe(\n        Schema.check(Schema.isGreaterThanOrEqualTo(0)),\n        Schema.check(Schema.isFinite()),\n      ),\n    ),\n    initialHeights: Schema.optional(Schema.Record(Schema.String, Schema.Number)),\n  }),\n  init: args => {\n    // Restored measurements pass through the same sanitation as live ones,\n    // so a poisoned cache cannot wedge the sums. Built from entries, since\n    // assigning a row keyed `__proto__` sets the prototype.\n    const heights: Record<string, number> = Object.fromEntries(\n      Object.entries(args.initialHeights ?? {}).flatMap(([key, height]) => {\n        const sane = saneMeasured(height)\n        return sane === null ? [] : [[key, sane] as const]\n      }),\n    )\n    return {\n      model: {\n        scrollTop: args.initialScrollTop ?? 0,\n        heights,\n        scrolling: false,\n        generation: 0,\n        estimatedHeight: args.estimatedHeight,\n        overscan: args.overscan,\n        gap: args.gap,\n        paddingStart: args.paddingStart,\n        paddingEnd: args.paddingEnd,\n      },\n    }\n  },\n  update: (model, message, args) =>\n    VirtualMessage.match<Update.ReturnWithOutMessage<VirtualModel, VirtualMessage, never>>(\n      message,\n      {\n        Scrolled: ({ top }) => {\n          const sane = saneTop(top)\n          // The Viewport reports the position it mounts at, and a horizontal\n          // scroll reports an unchanged top. The raw top is compared, so an\n          // overscroll past zero still counts as scrolling.\n          if (sane === null || top === model.scrollTop) return { model }\n          const generation = model.generation + 1\n          return {\n            model: { ...model, scrollTop: sane, scrolling: true, generation },\n            commands: [\n              {\n                name: 'Virtual.settle',\n                args: { generation },\n                effect: Effect.as(\n                  Effect.sleep(args.settleMs ?? 150),\n                  VirtualMessage.Settled({ generation }),\n                ),\n              },\n            ],\n          }\n        },\n        Measured: ({ key, height }) => {\n          const sane = saneMeasured(height)\n          // A remounted row, or a width-only resize, reports the height held.\n          return sane === null || (Object.hasOwn(model.heights, key) && model.heights[key] === sane)\n            ? { model }\n            : { model: { ...model, heights: { ...model.heights, [key]: sane } } }\n        },\n        Prune: ({ keys }) => {\n          const kept = new Set(keys)\n          const entries = Object.entries(model.heights)\n          const held = entries.filter(([key]) => kept.has(key))\n          return held.length < entries.length\n            ? { model: { ...model, heights: Object.fromEntries(held) } }\n            : { model }\n        },\n        // A superseded silence timer carries an old generation: ignore it.\n        Settled: ({ generation }) =>\n          generation === model.generation ? { model: { ...model, scrolling: false } } : { model },\n      },\n    ),\n})\n\nexport const ViewportScrolled = Schema.TaggedStruct('ViewportScrolled', { top: Schema.Number })\nexport type ViewportScrolled = typeof ViewportScrolled.Type\n\n/**\n * The scroll container's position, reported on its own scrolls starting\n * with the current one. Attach to the scrolling element — viewport scrolls\n * arrive through the window-level scroll entry instead.\n */\nexport const Viewport = Mount.defineStream('Viewport', {\n  messages: [ViewportScrolled],\n  execute: ({ element }) => {\n    // The mount needs only a scroll position, not a full Element.\n    const read = (): ViewportScrolled => {\n      const scroller = element as unknown as { readonly scrollTop: number }\n      return ViewportScrolled.make({ top: scroller.scrollTop })\n    }\n    return Stream.concat(\n      Stream.make(read()),\n      Stream.fromEventListener(element, 'scroll').pipe(Stream.map(read)),\n    )\n  },\n})\n\nexport const RowMeasured = Schema.TaggedStruct('RowMeasured', {\n  key: Schema.String,\n  height: Schema.Number,\n})\nexport type RowMeasured = typeof RowMeasured.Type\n\ntype RowObserverCtor = new (callback: ResizeObserverCallback) => ResizeObserver\n\n/**\n * One row's height, reported on every resize starting with the current\n * one. The key is the application's row identity, echoed back so the\n * parent files the height without tracking which Mount sent what.\n */\nexport const MeasureRow = Mount.defineStream('MeasureRow', {\n  messages: [RowMeasured],\n  args: { key: Schema.String },\n  execute: ({ element, key }) =>\n    Stream.callback<typeof RowMeasured.Type>(queue =>\n      Effect.gen(function* () {\n        const Observed = (globalThis as { ResizeObserver?: RowObserverCtor }).ResizeObserver\n        if (Observed === undefined) return\n        yield* Effect.acquireRelease(\n          Effect.sync(() => {\n            const observer = new Observed(entries => {\n              const rect = entries[0]?.contentRect\n              if (rect !== undefined) {\n                Queue.offerUnsafe(queue, RowMeasured.make({ key, height: rect.height }))\n              }\n            })\n            observer.observe(element)\n            return observer\n          }),\n          observer => Effect.sync(() => observer.disconnect()),\n        )\n      }),\n    ),\n})\n\n/**\n * Which section header sticks for a window: the last section starting at\n * or before the first rendered row, or null above the first section. Order\n * independent — the scan takes the maximum, so unsorted input still\n * answers. CSS `position: sticky` does the sticking; this answers *what*\n * sticks, for styling and callbacks.\n */\nexport const stickyHeader = (\n  sections: ReadonlyArray<{ readonly key: string; readonly index: number }>,\n  startIndex: number,\n): string | null => {\n  let current: string | null = null\n  let currentIndex = -1\n  for (const section of sections) {\n    if (section.index <= startIndex && section.index > currentIndex) {\n      current = section.key\n      currentIndex = section.index\n    }\n  }\n  return current\n}\n\n/** Where `masonry` puts one item: its column and its box, in pixels. */\nexport interface MasonryPlacement {\n  readonly key: string\n  readonly column: number\n  readonly x: number\n  readonly y: number\n  readonly width: number\n  readonly height: number\n}\n\n/**\n * Masonry layout as a pure function: fixed column count and width, each\n * item packed into the currently shortest column. Unmeasured items use the\n * estimate; poisoned heights fall back the same way. This is layout only,\n * not windowing — every placed item renders, so it fits hundreds of images,\n * not hundred-thousands. Needing a windowed grid is a different algorithm.\n */\nexport const masonry = (\n  keys: ReadonlyArray<string>,\n  heights: Readonly<Record<string, number>>,\n  options: {\n    readonly columns: number\n    readonly columnWidth: number\n    readonly gap: number\n    readonly estimatedHeight: number\n  },\n): { readonly placements: ReadonlyArray<MasonryPlacement>; readonly totalHeight: number } => {\n  if (!Number.isInteger(options.columns) || options.columns < 1) {\n    throw new Error(`masonry: columns must be a positive integer, got ${options.columns}`)\n  }\n  if (!(options.columnWidth > 0) || !Number.isFinite(options.columnWidth)) {\n    throw new Error(\n      `masonry: columnWidth must be a positive finite number, got ${options.columnWidth}`,\n    )\n  }\n  if (options.gap < 0 || !Number.isFinite(options.gap)) {\n    throw new Error(`masonry: gap must be a non-negative finite number, got ${options.gap}`)\n  }\n  if (options.estimatedHeight < 0 || !Number.isFinite(options.estimatedHeight)) {\n    throw new Error(\n      `masonry: estimatedHeight must be a non-negative finite number, got ${options.estimatedHeight}`,\n    )\n  }\n  const columnHeights: Array<number> = new Array(options.columns).fill(0)\n  const placements: Array<MasonryPlacement> = []\n  for (const key of keys) {\n    const raw = heights[key] ?? options.estimatedHeight\n    const height = Number.isFinite(raw) && raw >= 0 ? raw : options.estimatedHeight\n    let column = 0\n    for (let c = 1; c < columnHeights.length; c++) {\n      if (columnHeights[c]! < columnHeights[column]!) column = c\n    }\n    placements.push({\n      key,\n      column,\n      x: column * (options.columnWidth + options.gap),\n      y: columnHeights[column]!,\n      width: options.columnWidth,\n      height,\n    })\n    columnHeights[column] = columnHeights[column]! + height + options.gap\n  }\n  return {\n    placements,\n    totalHeight: placements.length === 0 ? 0 : Math.max(...columnHeights) - options.gap,\n  }\n}\n"],"mappings":"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"}

package/dist/time/debounce.d.ts

@@ -0,0 +1,43 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+/**
+ * Debounced input as a bundle factory: `Changed` restarts a timer, and the
+ * latest value settles as an OutMessage the placement must handle with
+ * `onOut`. Each `Changed` bumps a generation carried by the `Settled` fact
+ * it schedules, so a superseded timer's fact emits nothing — the same guard
+ * as Presence's exit timeout. Generic over the value Schema, like History.
+ * The clock is Effect's, so tests drive it with TestClock.
+ */
+export declare const debounce: <const Name extends string, Value>(config: {
+  readonly name: Name;
+  readonly value: Schema.Codec<Value, unknown>;
+}) => Bundle.Bundle<Name, {
+  readonly delayMs: number;
+}, {
+  readonly latest: Value | null;
+  readonly generation: number;
+}, {
+  readonly _tag: "Changed";
+  readonly value: Value;
+} | {
+  readonly _tag: "Settled";
+  readonly value: Value;
+  readonly generation: number;
+}, {
+  readonly _tag: "Debounced";
+  readonly value: Value;
+}, never, never, void, {}, {}> & {
+  Message: import("foldkit/message").MessageUnion<{
+    readonly Changed: {
+      value: Schema.Codec<Value, unknown, never, never>;
+    };
+    readonly Settled: {
+      value: Schema.Codec<Value, unknown, never, never>;
+      generation: Schema.Number;
+    };
+  }>;
+  Debounced: Schema.TaggedStruct<"Debounced", {
+    readonly value: Schema.Codec<Value, unknown, never, never>;
+  }>;
+};
+//# sourceMappingURL=debounce.d.ts.map

package/dist/time/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","names":[],"sources":["../../src/time/debounce.ts"],"mappings":";;;;;;;;;;qBAaa,iBAAkB,qBAAqB,OAAK;WAC9C,MAAM;WACN,OAAO,OAAO,MAAM;MAC9B,OAAA,OAAA;;;;;;;;;;;;;;;;;;MAQc,OAAK,OAAA,MAAA;;;MACL,OAAK,OAAA,MAAA;MAAgB,YAAU,OAAA"}

package/dist/time/debounce.js

@@ -0,0 +1,65 @@
+import { Effect, Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+// src/time/debounce.ts
+/**
+* Debounced input as a bundle factory: `Changed` restarts a timer, and the
+* latest value settles as an OutMessage the placement must handle with
+* `onOut`. Each `Changed` bumps a generation carried by the `Settled` fact
+* it schedules, so a superseded timer's fact emits nothing — the same guard
+* as Presence's exit timeout. Generic over the value Schema, like History.
+* The clock is Effect's, so tests drive it with TestClock.
+*/
+const debounce = (config) => {
+	const Model = Schema.Struct({
+		latest: Schema.NullOr(config.value),
+		generation: Schema.Number
+	});
+	const Message = defineMessageUnion({
+		Changed: { value: config.value },
+		Settled: {
+			value: config.value,
+			generation: Schema.Number
+		}
+	});
+	const Debounced = Schema.TaggedStruct("Debounced", { value: config.value });
+	const bundle = Bundle.make(config.name, {
+		Model,
+		Message,
+		args: Schema.Struct({ delayMs: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())) }),
+		init: () => ({ model: {
+			latest: null,
+			generation: 0
+		} }),
+		update: (model, message, args) => Message.match(message, {
+			Changed: ({ value }) => {
+				const generation = model.generation + 1;
+				return {
+					model: {
+						latest: value,
+						generation
+					},
+					commands: [{
+						name: `${config.name}.settle`,
+						args: { generation },
+						effect: Effect.as(Effect.sleep(args.delayMs), Message.Settled({
+							value,
+							generation
+						}))
+					}]
+				};
+			},
+			Settled: ({ generation, value }) => generation === model.generation ? {
+				model,
+				outMessage: Debounced.make({ value })
+			} : { model }
+		})
+	});
+	return Object.assign(bundle, {
+		Message,
+		Debounced
+	});
+};
+export { debounce };
+
+//# sourceMappingURL=debounce.js.map

package/dist/time/debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.js","names":[],"sources":["../../src/time/debounce.ts"],"sourcesContent":["import { Effect, Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\n\n/**\n * Debounced input as a bundle factory: `Changed` restarts a timer, and the\n * latest value settles as an OutMessage the placement must handle with\n * `onOut`. Each `Changed` bumps a generation carried by the `Settled` fact\n * it schedules, so a superseded timer's fact emits nothing — the same guard\n * as Presence's exit timeout. Generic over the value Schema, like History.\n * The clock is Effect's, so tests drive it with TestClock.\n */\nexport const debounce = <const Name extends string, Value>(config: {\n  readonly name: Name\n  readonly value: Schema.Codec<Value, unknown>\n}) => {\n  const Model = Schema.Struct({\n    latest: Schema.NullOr(config.value),\n    generation: Schema.Number,\n  })\n  type Model = typeof Model.Type\n\n  const Message = defineMessageUnion({\n    Changed: { value: config.value },\n    Settled: { value: config.value, generation: Schema.Number },\n  })\n  type Message = typeof Message.Type\n\n  const Debounced = Schema.TaggedStruct('Debounced', { value: config.value })\n  type Debounced = typeof Debounced.Type\n\n  const bundle = Bundle.make(config.name, {\n    Model,\n    Message,\n    args: Schema.Struct({\n      delayMs: Schema.Number.pipe(\n        Schema.check(Schema.isGreaterThan(0)),\n        Schema.check(Schema.isFinite()),\n      ),\n    }),\n    init: () => ({ model: { latest: null, generation: 0 } }),\n    update: (model, message, args) =>\n      Message.match<Update.ReturnWithOutMessage<Model, Message, Debounced>>(message, {\n        Changed: ({ value }) => {\n          const generation = model.generation + 1\n          return {\n            model: { latest: value, generation },\n            commands: [\n              {\n                name: `${config.name}.settle`,\n                args: { generation },\n                effect: Effect.as(\n                  Effect.sleep(args.delayMs),\n                  Message.Settled({ value, generation }),\n                ),\n              },\n            ],\n          }\n        },\n        // A superseded timer's fact arrives with an old generation: no\n        // OutMessage, so the placement never sees it.\n        Settled: ({ generation, value }) =>\n          generation === model.generation\n            ? { model, outMessage: Debounced.make({ value }) }\n            : { model },\n      }),\n  })\n\n  return Object.assign(bundle, { Message, Debounced })\n}\n"],"mappings":";;;;;;;;;;;;AAaA,MAAa,YAA8C,WAGrD;CACJ,MAAM,QAAQ,OAAO,OAAO;EAC1B,QAAQ,OAAO,OAAO,OAAO,KAAK;EAClC,YAAY,OAAO;CACrB,CAAC;CAGD,MAAM,UAAU,mBAAmB;EACjC,SAAS,EAAE,OAAO,OAAO,MAAM;EAC/B,SAAS;GAAE,OAAO,OAAO;GAAO,YAAY,OAAO;EAAO;CAC5D,CAAC;CAGD,MAAM,YAAY,OAAO,aAAa,aAAa,EAAE,OAAO,OAAO,MAAM,CAAC;CAG1E,MAAM,SAAS,OAAO,KAAK,OAAO,MAAM;EACtC;EACA;EACA,MAAM,OAAO,OAAO,EAClB,SAAS,OAAO,OAAO,KACrB,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,GACpC,OAAO,MAAM,OAAO,SAAS,CAAC,CAChC,EACF,CAAC;EACD,aAAa,EAAE,OAAO;GAAE,QAAQ;GAAM,YAAY;EAAE,EAAE;EACtD,SAAS,OAAO,SAAS,SACvB,QAAQ,MAA8D,SAAS;GAC7E,UAAU,EAAE,YAAY;IACtB,MAAM,aAAa,MAAM,aAAa;IACtC,OAAO;KACL,OAAO;MAAE,QAAQ;MAAO;KAAW;KACnC,UAAU,CACR;MACE,MAAM,GAAG,OAAO,KAAK;MACrB,MAAM,EAAE,WAAW;MACnB,QAAQ,OAAO,GACb,OAAO,MAAM,KAAK,OAAO,GACzB,QAAQ,QAAQ;OAAE;OAAO;MAAW,CAAC,CACvC;KACF,CACF;IACF;GACF;GAGA,UAAU,EAAE,YAAY,YACtB,eAAe,MAAM,aACjB;IAAE;IAAO,YAAY,UAAU,KAAK,EAAE,MAAM,CAAC;GAAE,IAC/C,EAAE,MAAM;EAChB,CAAC;CACL,CAAC;CAED,OAAO,OAAO,OAAO,QAAQ;EAAE;EAAS;CAAU,CAAC;AACrD"}

package/dist/time/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./debounce.js";
+export * from "./interval.js";
+export * from "./relative.js";
+export * from "./throttle.js";
+export * from "./ticks.js";
+export * from "./timer.js";

package/dist/time/index.js

@@ -0,0 +1,7 @@
+export * from "./debounce.js";
+export * from "./interval.js";
+export * from "./relative.js";
+export * from "./throttle.js";
+export * from "./ticks.js";
+export * from "./timer.js";
+export {};

package/dist/time/interval.d.ts

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const IntervalModel: Schema.Struct<{
+  readonly running: Schema.Boolean;
+  readonly lastAt: Schema.NullOr<Schema.Number>;
+}>;
+export type IntervalModel = typeof IntervalModel.Type;
+export declare const IntervalMessage: import("foldkit/message").MessageUnion<{
+  readonly Started: {};
+  readonly Stopped: {};
+  readonly Ticked: {
+    at: Schema.Number;
+  };
+}>;
+export type IntervalMessage = typeof IntervalMessage.Type;
+/**
+ * A wall-clock interval as a bundle: the last tick time in the Model,
+ * advanced by a tick stream while running. Sibling of Timer (which counts
+ * ticks); this one records *when* they happened, so views can render clocks
+ * and elapsed times. The clock is Effect's, so tests drive it with TestClock.
+ * For a clock whose running or interval the parent's Model decides, use the
+ * `ticks` entry instead.
+ */
+export declare const Interval: Bundle.Bundle<"Interval", {
+  readonly intervalMs: number;
+}, {
+  readonly running: boolean;
+  readonly lastAt: number | null;
+}, {
+  readonly _tag: "Started";
+} | {
+  readonly _tag: "Stopped";
+} | {
+  readonly _tag: "Ticked";
+  readonly at: number;
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=interval.d.ts.map

package/dist/time/interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.d.ts","names":[],"sources":["../../src/time/interval.ts"],"mappings":";;qBAMa,eAAa,OAAA;;;;YAId,uBAAuB,cAAc;qBAEpC,2CAAe;;;;IAGhB,IAAE,OAAA;;;YAEF,yBAAyB,gBAAgB;;;;;;;;;qBAUxC,UAAQ,OAAA"}

package/dist/time/interval.js

@@ -0,0 +1,52 @@
+import { Option, Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+import { ticks } from "./ticks.js";
+// src/time/interval.ts
+const IntervalModel = Schema.Struct({
+	running: Schema.Boolean,
+	lastAt: Schema.NullOr(Schema.Number)
+});
+const IntervalMessage = defineMessageUnion({
+	Started: {},
+	Stopped: {},
+	Ticked: { at: Schema.Number }
+});
+/**
+* A wall-clock interval as a bundle: the last tick time in the Model,
+* advanced by a tick stream while running. Sibling of Timer (which counts
+* ticks); this one records *when* they happened, so views can render clocks
+* and elapsed times. The clock is Effect's, so tests drive it with TestClock.
+* For a clock whose running or interval the parent's Model decides, use the
+* `ticks` entry instead.
+*/
+const Interval = Bundle.make("Interval", {
+	Model: IntervalModel,
+	Message: IntervalMessage,
+	args: Schema.Struct({ intervalMs: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())) }),
+	init: () => ({ model: {
+		running: false,
+		lastAt: null
+	} }),
+	update: (model, message) => IntervalMessage.match(message, {
+		Started: () => model.running ? { model } : { model: {
+			...model,
+			running: true
+		} },
+		Stopped: () => model.running ? { model: {
+			...model,
+			running: false
+		} } : { model },
+		Ticked: ({ at }) => ({ model: {
+			...model,
+			lastAt: at
+		} })
+	}),
+	subscriptions: ({ intervalMs }) => ({ ticks: ticks({
+		intervalMs: (model) => model.running ? Option.some(intervalMs) : Option.none(),
+		onTick: (at) => IntervalMessage.Ticked({ at })
+	}) })
+});
+export { Interval, IntervalMessage, IntervalModel };
+
+//# sourceMappingURL=interval.js.map

package/dist/time/interval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.js","names":[],"sources":["../../src/time/interval.ts"],"sourcesContent":["import { Option, Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\nimport { ticks } from './ticks.js'\n\nexport const IntervalModel = Schema.Struct({\n  running: Schema.Boolean,\n  lastAt: Schema.NullOr(Schema.Number),\n})\nexport type IntervalModel = typeof IntervalModel.Type\n\nexport const IntervalMessage = defineMessageUnion({\n  Started: {},\n  Stopped: {},\n  Ticked: { at: Schema.Number },\n})\nexport type IntervalMessage = typeof IntervalMessage.Type\n\n/**\n * A wall-clock interval as a bundle: the last tick time in the Model,\n * advanced by a tick stream while running. Sibling of Timer (which counts\n * ticks); this one records *when* they happened, so views can render clocks\n * and elapsed times. The clock is Effect's, so tests drive it with TestClock.\n * For a clock whose running or interval the parent's Model decides, use the\n * `ticks` entry instead.\n */\nexport const Interval = Bundle.make('Interval', {\n  Model: IntervalModel,\n  Message: IntervalMessage,\n  args: Schema.Struct({\n    intervalMs: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThan(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n  }),\n  init: () => ({ model: { running: false, lastAt: null } }),\n  update: (model, message) =>\n    IntervalMessage.match<Update.ReturnWithOutMessage<IntervalModel, IntervalMessage, never>>(\n      message,\n      {\n        Started: () => (model.running ? { model } : { model: { ...model, running: true } }),\n        Stopped: () => (model.running ? { model: { ...model, running: false } } : { model }),\n        Ticked: ({ at }) => ({ model: { ...model, lastAt: at } }),\n      },\n    ),\n  subscriptions: ({ intervalMs }) => ({\n    ticks: ticks<IntervalModel, IntervalMessage>({\n      intervalMs: model => (model.running ? Option.some(intervalMs) : Option.none()),\n      onTick: at => IntervalMessage.Ticked({ at }),\n    }),\n  }),\n})\n"],"mappings":";;;;;AAMA,MAAa,gBAAgB,OAAO,OAAO;CACzC,SAAS,OAAO;CAChB,QAAQ,OAAO,OAAO,OAAO,MAAM;AACrC,CAAC;AAGD,MAAa,kBAAkB,mBAAmB;CAChD,SAAS,CAAC;CACV,SAAS,CAAC;CACV,QAAQ,EAAE,IAAI,OAAO,OAAO;AAC9B,CAAC;;;;;;;;;AAWD,MAAa,WAAW,OAAO,KAAK,YAAY;CAC9C,OAAO;CACP,SAAS;CACT,MAAM,OAAO,OAAO,EAClB,YAAY,OAAO,OAAO,KACxB,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,GACpC,OAAO,MAAM,OAAO,SAAS,CAAC,CAChC,EACF,CAAC;CACD,aAAa,EAAE,OAAO;EAAE,SAAS;EAAO,QAAQ;CAAK,EAAE;CACvD,SAAS,OAAO,YACd,gBAAgB,MACd,SACA;EACE,eAAgB,MAAM,UAAU,EAAE,MAAM,IAAI,EAAE,OAAO;GAAE,GAAG;GAAO,SAAS;EAAK,EAAE;EACjF,eAAgB,MAAM,UAAU,EAAE,OAAO;GAAE,GAAG;GAAO,SAAS;EAAM,EAAE,IAAI,EAAE,MAAM;EAClF,SAAS,EAAE,UAAU,EAAE,OAAO;GAAE,GAAG;GAAO,QAAQ;EAAG,EAAE;CACzD,CACF;CACF,gBAAgB,EAAE,kBAAkB,EAClC,OAAO,MAAsC;EAC3C,aAAY,UAAU,MAAM,UAAU,OAAO,KAAK,UAAU,IAAI,OAAO,KAAK;EAC5E,SAAQ,OAAM,gBAAgB,OAAO,EAAE,GAAG,CAAC;CAC7C,CAAC,EACH;AACF,CAAC"}

package/dist/time/relative.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Relative time as a pure function: picks the unit (seconds through years)
+ * and delegates the wording to `Intl.RelativeTimeFormat`, so locales come
+ * from the platform, not a phrase table. `from` is the earlier moment;
+ * swap the arguments for future phrasing ("in 3 days").
+ */
+export declare const formatRelativeTime: (from: Date, to: Date, locale?: string) => string;
+//# sourceMappingURL=relative.d.ts.map

package/dist/time/relative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relative.d.ts","names":[],"sources":["../../src/time/relative.ts"],"mappings":";;;;;;qBAMa,qBAAkB,MAAU,MAAI,IAAM,MAAI"}