foldkit-remote 0.21.0 → 0.22.0

package/dist/optimistic-CECsfNGY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic-CECsfNGY.d.ts","names":[],"sources":["../src/mutation.ts","../src/optimistic.ts"],"mappings":"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"}

package/dist/optimistic.d.ts

@@ -0,0 +1,2 @@
+import { S as visibleStore, _ as removeOverlay, a as OptimisticOperation, b as settleSuccess, c as addOverlay, d as emptyOptimistic, f as goneIn, g as removeLayer, h as pruneOverlays, i as EntityLayer, l as beginOptimistic, m as plannedStore, n as ConnectionIdentity, o as OptimisticState, p as heldOnlyByRequests, r as ConnectionOverlay, s as addLayer, t as ConnectionChange, u as connectionIdentity, v as resolvedPatches, x as visibleItems, y as settleFailure } from "./optimistic-CECsfNGY.js";
+export { ConnectionChange, ConnectionIdentity, ConnectionOverlay, EntityLayer, OptimisticOperation, OptimisticState, addLayer, addOverlay, beginOptimistic, connectionIdentity, emptyOptimistic, goneIn, heldOnlyByRequests, plannedStore, pruneOverlays, removeLayer, removeOverlay, resolvedPatches, settleFailure, settleSuccess, visibleItems, visibleStore };

package/dist/optimistic.js

@@ -0,0 +1,336 @@
+import { put } from "./record.js";
+import { isPatch } from "./shown.js";
+import { entityKey, isTombstone, tombstone, writeEntities } from "./store.js";
+import { reconcileMutation } from "./mutation.js";
+import { edge, items } from "./connection.js";
+import { Option } from "effect";
+import { Operators, QueryEvaluateError, Write } from "foldkit-entity";
+// src/optimistic.ts
+/**
+* Optimistic layers. Pending changes are held as ordered layers over a base
+* store and as overlays over a connection; the visible value is recomputed, never
+* patched with inverses. Settling is remove-the-layer, so overlapping layers
+* rebase for free.
+*/
+const toOverlays = (id, changes) => changes.map((change) => ({
+	id,
+	connection: change.connection,
+	edges: [change.edge],
+	position: change._tag === "Insert" ? change.position : "remove"
+}));
+const connectionIdentity = (connection) => typeof connection === "string" ? connection : connection.identity;
+const change = (connection, ref, position) => position === "remove" ? {
+	_tag: "Remove",
+	connection: connectionIdentity(connection),
+	edge: edge(ref)
+} : {
+	_tag: "Insert",
+	connection: connectionIdentity(connection),
+	position,
+	edge: edge(ref)
+};
+/**
+* Constructors for connection changes: what a request shows optimistically
+* (`MutateOptions.optimistic`) and what a mutation source reports it made
+* (`MutationOutcome.connections`).
+*/
+const ConnectionChange = {
+	/** Show `ref` at the front of the connection until the request settles. */
+	prepend: (connection, ref) => change(connection, ref, "prepend"),
+	/** Show `ref` at the end of the connection until the request settles. */
+	append: (connection, ref) => change(connection, ref, "append"),
+	/** Hide `ref` from the connection until the request settles. */
+	remove: (connection, ref) => change(connection, ref, "remove")
+};
+/**
+* Applies a request's operations: its patches and deletions become one layer
+* and its connection changes become overlays, all owned by `requestId` so
+* settling removes every one of them together.
+*/
+const beginOptimistic = (optimistic, requestId, operations, viewer = Option.none()) => {
+	const patches = [];
+	const deletes = [];
+	const changes = [];
+	for (const operation of operations) if (isPatch(operation)) patches.push(operation);
+	else if (operation._tag === "Delete") deletes.push(operation);
+	else changes.push(operation);
+	if (patches.length === 0 && deletes.length === 0 && changes.length === 0) return optimistic;
+	return {
+		layers: patches.length === 0 && deletes.length === 0 ? optimistic.layers : [...optimistic.layers, {
+			id: requestId,
+			patches,
+			deletes,
+			viewer
+		}],
+		overlays: changes.length === 0 ? optimistic.overlays : [...optimistic.overlays, ...toOverlays(requestId, changes)]
+	};
+};
+/**
+* Replaces a request's overlays with the server-confirmed changes, owned by
+* `id`, in the position the request's overlays held, so a confirmed edge keeps
+* its place among other pending inserts.
+*/
+const confirm = (optimistic, requestId, id, changes) => {
+	const at = optimistic.overlays.findIndex((overlay) => overlay.id === requestId);
+	if (at === -1 && changes.length === 0) return optimistic;
+	const confirmed = toOverlays(id, changes);
+	const others = optimistic.overlays.filter((overlay) => overlay.id !== requestId);
+	return {
+		...optimistic,
+		overlays: at === -1 ? [...others, ...confirmed] : [
+			...others.slice(0, at),
+			...confirmed,
+			...others.slice(at)
+		]
+	};
+};
+const emptyOptimistic = {
+	layers: [],
+	overlays: []
+};
+const addLayer = (optimistic, layer) => ({
+	...optimistic,
+	layers: [...optimistic.layers, layer]
+});
+const removeLayer = (optimistic, id) => {
+	const layers = optimistic.layers.filter((layer) => layer.id !== id);
+	return layers.length === optimistic.layers.length ? optimistic : {
+		...optimistic,
+		layers
+	};
+};
+const addOverlay = (optimistic, overlay) => ({
+	...optimistic,
+	overlays: [...optimistic.overlays, overlay]
+});
+const removeOverlay = (optimistic, id) => {
+	const overlays = optimistic.overlays.filter((overlay) => overlay.id !== id);
+	return overlays.length === optimistic.overlays.length ? optimistic : {
+		...optimistic,
+		overlays
+	};
+};
+/**
+* Base store with every layer applied in order. Later layers win. A patch is
+* not news from the server, so it keeps the date of the value under it; an
+* entity only a request holds (a temporary id) is not the server's to age, and
+* is dated `Infinity`, so freshness never plans or times it. A row a layer
+* deletes is a tombstone over all of them. A patch over a row the server
+* holds deleted shows it, as a create of a row known absent does; a patch a
+* later request's delete settled is taken out of its layer (`settleSuccess`).
+*/
+const visibleStore = (base, optimistic, operators = Operators.kernel) => [...pendingDeletes(optimistic)].reduce(tombstone, writeEntities(base, resolvedPatches(base, optimistic, operators).map((patch) => {
+	const key = entityKey(patch.entity, patch.id);
+	const under = base[key];
+	return {
+		key,
+		values: patch.values,
+		updatedAt: under === void 0 || under.tombstone ? Infinity : under.updatedAt
+	};
+})));
+const pendingDeletes = (optimistic) => new Set(optimistic.layers.flatMap((layer) => layer.deletes.map((gone) => entityKey(gone.entity, gone.id))));
+/**
+* The store a read plans over: the visible store, except that a row the
+* server holds is planned by what the server holds of it, so a field only a
+* layer shows is still fetched. Its values stay the visible ones, so a
+* relation a layer points elsewhere is followed where it points. A row only a
+* request holds and a row a layer deletes are planned as shown; the first is
+* then left out of the read (`heldOnlyByRequests`).
+*/
+const plannedStore = (base, visible, optimistic) => {
+	let next;
+	for (const layer of optimistic.layers) for (const patch of layer.patches) {
+		const key = entityKey(patch.entity, patch.id);
+		const under = base[key];
+		const shown = visible[key];
+		if (under === void 0 || under.tombstone || shown === void 0 || shown.tombstone) continue;
+		next ??= { ...visible };
+		next[key] = {
+			...under,
+			values: shown.values
+		};
+	}
+	return next ?? visible;
+};
+/**
+* The rows only a pending request holds: a layer shows each over a row the
+* server holds nothing of (never read, or read as absent). A read of one is
+* not sent. The server has nothing for it until the request lands, so it would
+* answer "absent", which leaves the plan as it was. Once the answer lands
+* the plan would also be unchanged, so the read entry would never restart and
+* a field the answer omits (a guard's `may`) would never be fetched. Left out
+* now, the row's missing fields enter the plan when its answer lands, and that
+* change starts the read.
+*/
+const heldOnlyByRequests = (base, optimistic) => {
+	const held = /* @__PURE__ */ new Set();
+	for (const layer of optimistic.layers) for (const patch of layer.patches) {
+		const key = entityKey(patch.entity, patch.id);
+		const under = base[key];
+		if (under === void 0 || under.tombstone) held.add(key);
+	}
+	return held;
+};
+/**
+* Whether a list hides a row: the store holds it deleted, or a pending layer
+* deletes it. Read from the server's store, not the visible one, where a
+* pending patch over a deleted row clears its tombstone.
+*/
+const goneIn = (store, optimistic) => {
+	const deleted = pendingDeletes(optimistic);
+	return (key) => deleted.has(key) || isTombstone(store, key);
+};
+/**
+* Every pending patch in order, each amount added and each computed field
+* worked out over the row under it (the store's, with earlier layers over
+* it) by `Write.apply`, with the client's table (the kernel's when not
+* given). A prediction, so only over
+* what the client holds: a field it has not read, an amount over anything
+* but a number, or a computation by an operator its table lacks keeps what
+* it shows until the server answers.
+*/
+const resolvedPatches = (base, optimistic, operators = Operators.kernel) => {
+	const shown = /* @__PURE__ */ new Map();
+	const unsure = /* @__PURE__ */ new Map();
+	return optimistic.layers.flatMap((layer) => layer.patches.map(({ adds, computes, ...patch }) => {
+		const key = entityKey(patch.entity, patch.id);
+		const earlier = shown.get(key) ?? {};
+		const unknown = new Set([...unsure.get(key) ?? []].filter((field) => !Object.hasOwn(patch.values, field)));
+		const values = { ...patch.values };
+		const row = Object.fromEntries(Object.entries({
+			...base[key]?.values,
+			...earlier
+		}).filter(([field]) => !unknown.has(field)));
+		const moved = {
+			values: {},
+			increments: adds ?? {},
+			assignments: computes ?? {}
+		};
+		const predicted = predicting(() => Write.apply(row, moved, { operators }));
+		for (const field of [...Object.keys(moved.increments), ...Object.keys(moved.assignments)]) if (predicted !== void 0 && !predicted.unknown.includes(field)) {
+			put(values, field, predicted.row[field]);
+			unknown.delete(field);
+		} else unknown.add(field);
+		shown.set(key, {
+			...earlier,
+			...values
+		});
+		unsure.set(key, unknown);
+		return {
+			...patch,
+			values
+		};
+	}));
+};
+/** A prediction, or none where an operator refuses the row it is given: the server will answer. */
+const predicting = (predict) => {
+	try {
+		return predict();
+	} catch (error) {
+		if (error instanceof QueryEvaluateError) return void 0;
+		throw error;
+	}
+};
+/**
+* A fresh page is newer than any settled overlay it covers: an edge the page
+* carries no longer needs an insert overlay, and a `remove` overlay hiding it
+* is stale (the server says it is back). A pending request's overlays are
+* left alone; they settle with the request.
+*/
+const pruneOverlays = (optimistic, connection, covered, pending) => {
+	let changed = false;
+	const overlays = optimistic.overlays.flatMap((overlay) => {
+		if (overlay.connection !== connection || pending.has(overlay.id)) return [overlay];
+		const edges = overlay.edges.filter((edge) => !covered.has(edge.key));
+		if (edges.length > 0 && edges.length === overlay.edges.length) return [overlay];
+		changed = true;
+		return edges.length === 0 ? [] : [{
+			...overlay,
+			edges
+		}];
+	});
+	return changed ? {
+		...optimistic,
+		overlays
+	} : optimistic;
+};
+/** Everything a request owns: its layer and its overlays. */
+const release = (optimistic, requestId) => removeOverlay(removeLayer(optimistic, requestId), requestId);
+/**
+* Applies a result idempotently and releases the request's layer and overlays:
+* a later layer re-wins on rebase. Confirmed connection changes are recorded
+* once per request, as overlays the request no longer owns.
+*/
+const settleSuccess = (base, optimistic, state, requestId, answer) => {
+	const reconciled = reconcileMutation(base, state, requestId, answer);
+	return {
+		store: reconciled.store,
+		state: reconciled.state,
+		optimistic: state.applied.has(requestId) ? release(optimistic, requestId) : superseded(confirm(removeLayer(optimistic, requestId), requestId, `confirmed:${requestId}`, answer.connections ?? []), state, requestId, (answer.deleted ?? []).map((gone) => entityKey(gone.entity, gone.id)).filter((key) => isTombstone(reconciled.store, key)))
+	};
+};
+/**
+* The layers without the patches of rows `requestId`'s answer deleted, in each
+* request started before it: the server ran those first, so the delete is
+* the row's last word, and their answers will not bring it back. Shown, such
+* a patch would make the deleted row a stub that reads `Initial`.
+*/
+const superseded = (optimistic, state, requestId, deleted) => {
+	const at = state.order.get(requestId);
+	if (at === void 0 || deleted.length === 0) return optimistic;
+	const gone = new Set(deleted);
+	let changed = false;
+	const layers = optimistic.layers.map((layer) => {
+		const started = state.order.get(layer.id);
+		if (started === void 0 || started > at) return layer;
+		const patches = layer.patches.filter((patch) => !gone.has(entityKey(patch.entity, patch.id)));
+		if (patches.length === layer.patches.length) return layer;
+		changed = true;
+		return {
+			...layer,
+			patches
+		};
+	});
+	return changed ? {
+		...optimistic,
+		layers
+	} : optimistic;
+};
+/** A failed request's layer and overlays are dropped; the base was never mutated. */
+const settleFailure = (optimistic, requestId) => release(optimistic, requestId);
+/**
+* Visible edges for one connection: applicable overlays are placed outside the
+* server-known segments and de-duplicated by edge identity (across overlays too),
+* so a pending insert never corrupts server-known ordering; a `remove` overlay
+* hides its edges wherever they are, and so does `gone` (`goneIn`) of the
+* edge's target. A later prepend lands before an earlier one, a later append
+* after, so pending inserts read in the order they were made. Boundaries still
+* come from the connection's segments.
+*/
+const visibleItems = (connection, connectionId, overlays, gone = () => false) => {
+	const applicable = overlays.filter((overlay) => overlay.connection === connectionId);
+	const hidden = /* @__PURE__ */ new Set();
+	for (const overlay of applicable) for (const edge of overlay.edges) if (overlay.position === "remove") hidden.add(edge.key);
+	else hidden.delete(edge.key);
+	const hides = (edge) => hidden.has(edge.key) || gone(entityKey(edge.ref.entity, edge.ref.id));
+	const known = items(connection).filter((edge) => !hides(edge));
+	const seen = new Set(known.map((edge) => edge.key));
+	const take = (position) => {
+		const edges = [];
+		const ordered = applicable.filter((value) => value.position === position);
+		for (const overlay of position === "prepend" ? [...ordered].reverse() : ordered) for (const edge of overlay.edges) {
+			if (seen.has(edge.key) || hides(edge)) continue;
+			seen.add(edge.key);
+			edges.push(edge);
+		}
+		return edges;
+	};
+	return [
+		...take("prepend"),
+		...known,
+		...take("append")
+	];
+};
+export { ConnectionChange, addLayer, addOverlay, beginOptimistic, connectionIdentity, emptyOptimistic, goneIn, heldOnlyByRequests, plannedStore, pruneOverlays, removeLayer, removeOverlay, resolvedPatches, settleFailure, settleSuccess, visibleItems, visibleStore };
+
+//# sourceMappingURL=optimistic.js.map

package/dist/optimistic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic.js","names":[],"sources":["../src/optimistic.ts"],"sourcesContent":["/**\n * Optimistic layers. Pending changes are held as ordered layers over a base\n * store and as overlays over a connection; the visible value is recomputed, never\n * patched with inverses. Settling is remove-the-layer, so overlapping layers\n * rebase for free.\n */\nimport { Option } from 'effect'\nimport {\n  Operators,\n  QueryEvaluateError,\n  Write,\n  type EntityRef,\n  type MemoryOperators,\n} from 'foldkit-entity'\nimport { type Connection, type Edge, edge, items } from './connection.js'\nimport {\n  reconcileMutation,\n  type MutationAnswer,\n  type MutationState,\n  type NormalizedPatch,\n  type PendingDelete,\n  type PendingPatch,\n} from './mutation.js'\nimport { put } from './record.js'\nimport { isPatch } from './shown.js'\nimport {\n  entityKey,\n  isTombstone,\n  tombstone,\n  writeEntities,\n  type EntityEntry,\n  type EntityKey,\n  type EntityStore,\n} from './store.js'\n\nexport interface EntityLayer {\n  readonly id: string\n  readonly patches: ReadonlyArray<PendingPatch>\n  /** Rows it deletes. A delete wins over every layer's patch of its row, as in an answer. */\n  readonly deletes: ReadonlyArray<PendingDelete>\n  /**\n   * Who the operation was predicted for (`Remote.make`'s viewer when it\n   * started): what a list body's `Expr.viewer` reads when the client places\n   * the rows this layer changes. None for a preview with no operation.\n   */\n  readonly viewer: Option.Option<EntityRef>\n}\n\n/**\n * Edges placed outside a connection's server-known region (`prepend`,\n * `append`) or hidden from it (`remove`), owned by the request or live event\n * that produced them.\n */\nexport interface ConnectionOverlay {\n  readonly id: string\n  readonly connection: string\n  readonly edges: ReadonlyArray<Edge>\n  readonly position: 'prepend' | 'append' | 'remove'\n}\n\n/** A connection change a request makes optimistically or a mutation result confirms. */\nexport type ConnectionChange =\n  | {\n      readonly _tag: 'Insert'\n      readonly connection: string\n      readonly position: 'prepend' | 'append'\n      readonly edge: Edge\n    }\n  | { readonly _tag: 'Remove'; readonly connection: string; readonly edge: Edge }\n\n/** What a request changes before the server answers: entity patches, deletions and connection changes. */\nexport type OptimisticOperation = PendingPatch | PendingDelete | ConnectionChange\n\nconst toOverlays = (id: string, changes: ReadonlyArray<ConnectionChange>): ConnectionOverlay[] =>\n  changes.map(change => ({\n    id,\n    connection: change.connection,\n    edges: [change.edge],\n    position: change._tag === 'Insert' ? change.position : 'remove',\n  }))\n\n/** A connection, by identity string or by anything that carries one (a `QueryRef`). */\nexport type ConnectionIdentity = string | { readonly identity: string }\n\nexport const connectionIdentity = (connection: ConnectionIdentity): string =>\n  typeof connection === 'string' ? connection : connection.identity\n\nconst change = (\n  connection: ConnectionIdentity,\n  ref: { readonly entity: string; readonly id: string },\n  position: 'prepend' | 'append' | 'remove',\n): ConnectionChange =>\n  position === 'remove'\n    ? { _tag: 'Remove', connection: connectionIdentity(connection), edge: edge(ref) }\n    : { _tag: 'Insert', connection: connectionIdentity(connection), position, edge: edge(ref) }\n\n/**\n * Constructors for connection changes: what a request shows optimistically\n * (`MutateOptions.optimistic`) and what a mutation source reports it made\n * (`MutationOutcome.connections`).\n */\nexport const ConnectionChange = {\n  /** Show `ref` at the front of the connection until the request settles. */\n  prepend: (\n    connection: ConnectionIdentity,\n    ref: { readonly entity: string; readonly id: string },\n  ): ConnectionChange => change(connection, ref, 'prepend'),\n\n  /** Show `ref` at the end of the connection until the request settles. */\n  append: (\n    connection: ConnectionIdentity,\n    ref: { readonly entity: string; readonly id: string },\n  ): ConnectionChange => change(connection, ref, 'append'),\n\n  /** Hide `ref` from the connection until the request settles. */\n  remove: (\n    connection: ConnectionIdentity,\n    ref: { readonly entity: string; readonly id: string },\n  ): ConnectionChange => change(connection, ref, 'remove'),\n}\n\n/**\n * Applies a request's operations: its patches and deletions become one layer\n * and its connection changes become overlays, all owned by `requestId` so\n * settling removes every one of them together.\n */\nexport const beginOptimistic = (\n  optimistic: OptimisticState,\n  requestId: string,\n  operations: ReadonlyArray<OptimisticOperation>,\n  viewer: Option.Option<EntityRef> = Option.none(),\n): OptimisticState => {\n  const patches: PendingPatch[] = []\n  const deletes: PendingDelete[] = []\n  const changes: ConnectionChange[] = []\n  for (const operation of operations) {\n    if (isPatch(operation)) patches.push(operation)\n    else if (operation._tag === 'Delete') deletes.push(operation)\n    else changes.push(operation)\n  }\n  if (patches.length === 0 && deletes.length === 0 && changes.length === 0) return optimistic\n  return {\n    layers:\n      patches.length === 0 && deletes.length === 0\n        ? optimistic.layers\n        : [...optimistic.layers, { id: requestId, patches, deletes, viewer }],\n    overlays:\n      changes.length === 0\n        ? optimistic.overlays\n        : [...optimistic.overlays, ...toOverlays(requestId, changes)],\n  }\n}\n\n/**\n * Replaces a request's overlays with the server-confirmed changes, owned by\n * `id`, in the position the request's overlays held, so a confirmed edge keeps\n * its place among other pending inserts.\n */\nconst confirm = (\n  optimistic: OptimisticState,\n  requestId: string,\n  id: string,\n  changes: ReadonlyArray<ConnectionChange>,\n): OptimisticState => {\n  const at = optimistic.overlays.findIndex(overlay => overlay.id === requestId)\n  if (at === -1 && changes.length === 0) return optimistic\n  const confirmed = toOverlays(id, changes)\n  const others = optimistic.overlays.filter(overlay => overlay.id !== requestId)\n  return {\n    ...optimistic,\n    overlays:\n      at === -1\n        ? [...others, ...confirmed]\n        : [...others.slice(0, at), ...confirmed, ...others.slice(at)],\n  }\n}\n\n/** Pending entity layers and connection overlays over the base store. */\nexport interface OptimisticState {\n  readonly layers: ReadonlyArray<EntityLayer>\n  readonly overlays: ReadonlyArray<ConnectionOverlay>\n}\n\nexport const emptyOptimistic: OptimisticState = { layers: [], overlays: [] }\n\nexport const addLayer = (optimistic: OptimisticState, layer: EntityLayer): OptimisticState => ({\n  ...optimistic,\n  layers: [...optimistic.layers, layer],\n})\n\nexport const removeLayer = (optimistic: OptimisticState, id: string): OptimisticState => {\n  const layers = optimistic.layers.filter(layer => layer.id !== id)\n  return layers.length === optimistic.layers.length ? optimistic : { ...optimistic, layers }\n}\n\nexport const addOverlay = (\n  optimistic: OptimisticState,\n  overlay: ConnectionOverlay,\n): OptimisticState => ({\n  ...optimistic,\n  overlays: [...optimistic.overlays, overlay],\n})\n\nexport const removeOverlay = (optimistic: OptimisticState, id: string): OptimisticState => {\n  const overlays = optimistic.overlays.filter(overlay => overlay.id !== id)\n  return overlays.length === optimistic.overlays.length ? optimistic : { ...optimistic, overlays }\n}\n\n/**\n * Base store with every layer applied in order. Later layers win. A patch is\n * not news from the server, so it keeps the date of the value under it; an\n * entity only a request holds (a temporary id) is not the server's to age, and\n * is dated `Infinity`, so freshness never plans or times it. A row a layer\n * deletes is a tombstone over all of them. A patch over a row the server\n * holds deleted shows it, as a create of a row known absent does; a patch a\n * later request's delete settled is taken out of its layer (`settleSuccess`).\n */\nexport const visibleStore = (\n  base: EntityStore,\n  optimistic: OptimisticState,\n  operators: MemoryOperators = Operators.kernel,\n): EntityStore =>\n  [...pendingDeletes(optimistic)].reduce(\n    tombstone,\n    writeEntities(\n      base,\n      resolvedPatches(base, optimistic, operators).map(patch => {\n        const key = entityKey(patch.entity, patch.id)\n        const under = base[key]\n        return {\n          key,\n          values: patch.values,\n          updatedAt: under === undefined || under.tombstone ? Infinity : under.updatedAt,\n        }\n      }),\n    ),\n  )\n\nconst pendingDeletes = (optimistic: OptimisticState): ReadonlySet<EntityKey> =>\n  new Set(\n    optimistic.layers.flatMap(layer => layer.deletes.map(gone => entityKey(gone.entity, gone.id))),\n  )\n\n/**\n * The store a read plans over: the visible store, except that a row the\n * server holds is planned by what the server holds of it, so a field only a\n * layer shows is still fetched. Its values stay the visible ones, so a\n * relation a layer points elsewhere is followed where it points. A row only a\n * request holds and a row a layer deletes are planned as shown; the first is\n * then left out of the read (`heldOnlyByRequests`).\n */\nexport const plannedStore = (\n  base: EntityStore,\n  visible: EntityStore,\n  optimistic: OptimisticState,\n): EntityStore => {\n  let next: Record<EntityKey, EntityEntry> | undefined\n  for (const layer of optimistic.layers)\n    for (const patch of layer.patches) {\n      const key = entityKey(patch.entity, patch.id)\n      const under = base[key]\n      const shown = visible[key]\n      if (under === undefined || under.tombstone || shown === undefined || shown.tombstone) continue\n      next ??= { ...visible }\n      next[key] = { ...under, values: shown.values }\n    }\n  return next ?? visible\n}\n\n/**\n * The rows only a pending request holds: a layer shows each over a row the\n * server holds nothing of (never read, or read as absent). A read of one is\n * not sent. The server has nothing for it until the request lands, so it would\n * answer \"absent\", which leaves the plan as it was. Once the answer lands\n * the plan would also be unchanged, so the read entry would never restart and\n * a field the answer omits (a guard's `may`) would never be fetched. Left out\n * now, the row's missing fields enter the plan when its answer lands, and that\n * change starts the read.\n */\nexport const heldOnlyByRequests = (\n  base: EntityStore,\n  optimistic: OptimisticState,\n): ReadonlySet<EntityKey> => {\n  const held = new Set<EntityKey>()\n  for (const layer of optimistic.layers)\n    for (const patch of layer.patches) {\n      const key = entityKey(patch.entity, patch.id)\n      const under = base[key]\n      if (under === undefined || under.tombstone) held.add(key)\n    }\n  return held\n}\n\n/**\n * Whether a list hides a row: the store holds it deleted, or a pending layer\n * deletes it. Read from the server's store, not the visible one, where a\n * pending patch over a deleted row clears its tombstone.\n */\nexport const goneIn = (\n  store: EntityStore,\n  optimistic: OptimisticState,\n): ((key: EntityKey) => boolean) => {\n  const deleted = pendingDeletes(optimistic)\n  return key => deleted.has(key) || isTombstone(store, key)\n}\n\n/**\n * Every pending patch in order, each amount added and each computed field\n * worked out over the row under it (the store's, with earlier layers over\n * it) by `Write.apply`, with the client's table (the kernel's when not\n * given). A prediction, so only over\n * what the client holds: a field it has not read, an amount over anything\n * but a number, or a computation by an operator its table lacks keeps what\n * it shows until the server answers.\n */\nexport const resolvedPatches = (\n  base: EntityStore,\n  optimistic: OptimisticState,\n  operators: MemoryOperators = Operators.kernel,\n): ReadonlyArray<NormalizedPatch> => {\n  const shown = new Map<EntityKey, Record<string, unknown>>()\n  // Fields an earlier layer could not work out: what the store holds for one is\n  // not what the row before a later layer holds, so nothing reading it is predicted.\n  const unsure = new Map<EntityKey, ReadonlySet<string>>()\n  return optimistic.layers.flatMap(layer =>\n    layer.patches.map(({ adds, computes, ...patch }) => {\n      const key = entityKey(patch.entity, patch.id)\n      const earlier = shown.get(key) ?? {}\n      const unknown = new Set(\n        [...(unsure.get(key) ?? [])].filter(field => !Object.hasOwn(patch.values, field)),\n      )\n      const values: Record<string, unknown> = { ...patch.values }\n      // A tombstone holds no values; what the store holds, with what earlier layers show over it.\n      const row = Object.fromEntries(\n        Object.entries({ ...base[key]?.values, ...earlier }).filter(\n          ([field]) => !unknown.has(field),\n        ),\n      )\n      const moved = { values: {}, increments: adds ?? {}, assignments: computes ?? {} }\n      const predicted = predicting(() => Write.apply(row, moved, { operators }))\n      for (const field of [...Object.keys(moved.increments), ...Object.keys(moved.assignments)]) {\n        if (predicted !== undefined && !predicted.unknown.includes(field)) {\n          put(values, field, predicted.row[field])\n          unknown.delete(field)\n        } else {\n          unknown.add(field)\n        }\n      }\n      shown.set(key, { ...earlier, ...values })\n      unsure.set(key, unknown)\n      return { ...patch, values }\n    }),\n  )\n}\n\n/** A prediction, or none where an operator refuses the row it is given: the server will answer. */\nconst predicting = <A>(predict: () => A): A | undefined => {\n  try {\n    return predict()\n  } catch (error) {\n    if (error instanceof QueryEvaluateError) return undefined\n    throw error\n  }\n}\n\n/**\n * A fresh page is newer than any settled overlay it covers: an edge the page\n * carries no longer needs an insert overlay, and a `remove` overlay hiding it\n * is stale (the server says it is back). A pending request's overlays are\n * left alone; they settle with the request.\n */\nexport const pruneOverlays = (\n  optimistic: OptimisticState,\n  connection: string,\n  covered: ReadonlySet<string>,\n  pending: ReadonlySet<string>,\n): OptimisticState => {\n  let changed = false\n  const overlays = optimistic.overlays.flatMap(overlay => {\n    if (overlay.connection !== connection || pending.has(overlay.id)) return [overlay]\n    const edges = overlay.edges.filter(edge => !covered.has(edge.key))\n    // An overlay a live remove emptied goes too: it shows nothing.\n    if (edges.length > 0 && edges.length === overlay.edges.length) return [overlay]\n    changed = true\n    return edges.length === 0 ? [] : [{ ...overlay, edges }]\n  })\n  return changed ? { ...optimistic, overlays } : optimistic\n}\n\n/** Everything a request owns: its layer and its overlays. */\nconst release = (optimistic: OptimisticState, requestId: string): OptimisticState =>\n  removeOverlay(removeLayer(optimistic, requestId), requestId)\n\n/**\n * Applies a result idempotently and releases the request's layer and overlays:\n * a later layer re-wins on rebase. Confirmed connection changes are recorded\n * once per request, as overlays the request no longer owns.\n */\nexport const settleSuccess = (\n  base: EntityStore,\n  optimistic: OptimisticState,\n  state: MutationState,\n  requestId: string,\n  answer: MutationAnswer & {\n    /** Connection changes the server confirmed; they replace the request's own. */\n    readonly connections?: ReadonlyArray<ConnectionChange> | undefined\n  },\n): {\n  readonly store: EntityStore\n  readonly state: MutationState\n  readonly optimistic: OptimisticState\n} => {\n  const reconciled = reconcileMutation(base, state, requestId, answer)\n  return {\n    store: reconciled.store,\n    state: reconciled.state,\n    optimistic: state.applied.has(requestId)\n      ? release(optimistic, requestId)\n      : superseded(\n          confirm(\n            removeLayer(optimistic, requestId),\n            requestId,\n            `confirmed:${requestId}`,\n            answer.connections ?? [],\n          ),\n          state,\n          requestId,\n          (answer.deleted ?? [])\n            .map(gone => entityKey(gone.entity, gone.id))\n            .filter(key => isTombstone(reconciled.store, key)),\n        ),\n  }\n}\n\n/**\n * The layers without the patches of rows `requestId`'s answer deleted, in each\n * request started before it: the server ran those first, so the delete is\n * the row's last word, and their answers will not bring it back. Shown, such\n * a patch would make the deleted row a stub that reads `Initial`.\n */\nconst superseded = (\n  optimistic: OptimisticState,\n  state: MutationState,\n  requestId: string,\n  deleted: ReadonlyArray<EntityKey>,\n): OptimisticState => {\n  const at = state.order.get(requestId)\n  if (at === undefined || deleted.length === 0) return optimistic\n  const gone = new Set(deleted)\n  let changed = false\n  const layers = optimistic.layers.map(layer => {\n    const started = state.order.get(layer.id)\n    if (started === undefined || started > at) return layer\n    const patches = layer.patches.filter(patch => !gone.has(entityKey(patch.entity, patch.id)))\n    if (patches.length === layer.patches.length) return layer\n    changed = true\n    return { ...layer, patches }\n  })\n  return changed ? { ...optimistic, layers } : optimistic\n}\n\n/** A failed request's layer and overlays are dropped; the base was never mutated. */\nexport const settleFailure = (optimistic: OptimisticState, requestId: string): OptimisticState =>\n  release(optimistic, requestId)\n\n/**\n * Visible edges for one connection: applicable overlays are placed outside the\n * server-known segments and de-duplicated by edge identity (across overlays too),\n * so a pending insert never corrupts server-known ordering; a `remove` overlay\n * hides its edges wherever they are, and so does `gone` (`goneIn`) of the\n * edge's target. A later prepend lands before an earlier one, a later append\n * after, so pending inserts read in the order they were made. Boundaries still\n * come from the connection's segments.\n */\nexport const visibleItems = (\n  connection: Connection,\n  connectionId: string,\n  overlays: ReadonlyArray<ConnectionOverlay>,\n  gone: (key: EntityKey) => boolean = () => false,\n): ReadonlyArray<Edge> => {\n  const applicable = overlays.filter(overlay => overlay.connection === connectionId)\n  // Overlays are ordered evidence: the last word on an edge wins, so a remove\n  // hides it only until a later insert brings it back.\n  const hidden = new Set<string>()\n  for (const overlay of applicable) {\n    for (const edge of overlay.edges) {\n      if (overlay.position === 'remove') hidden.add(edge.key)\n      else hidden.delete(edge.key)\n    }\n  }\n  const hides = (edge: Edge): boolean =>\n    hidden.has(edge.key) || gone(entityKey(edge.ref.entity, edge.ref.id))\n  const known = items(connection).filter(edge => !hides(edge))\n  const seen = new Set(known.map(edge => edge.key))\n\n  const take = (position: 'prepend' | 'append'): ReadonlyArray<Edge> => {\n    const edges: Edge[] = []\n    const ordered = applicable.filter(value => value.position === position)\n    for (const overlay of position === 'prepend' ? [...ordered].reverse() : ordered) {\n      for (const edge of overlay.edges) {\n        if (seen.has(edge.key) || hides(edge)) continue\n        seen.add(edge.key)\n        edges.push(edge)\n      }\n    }\n    return edges\n  }\n\n  return [...take('prepend'), ...known, ...take('append')]\n}\n"],"mappings":"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"}

package/dist/outbox-DNuc4kZp.d.ts

@@ -0,0 +1,259 @@
+import { i as RemoteError } from "./remoteData-mK1suYi1.js";
+import { a as OptimisticOperation } from "./optimistic-CECsfNGY.js";
+import { n as RelationRequirement } from "./requirement-D57S2LpH.js";
+import { Context, Data, Duration, Effect, Option, Schema } from "effect";
+import { KeyValueStore } from "effect/persistence";
+/** Where a queued write stands, as the store keeps it. */
+type QueuedState = {
+  readonly _tag: 'Waiting';
+} | {
+  readonly _tag: 'Failed';
+  readonly error: RemoteError;
+};
+/**
+ * A durable write as the store keeps it: what a later page needs to show it
+ * and send it as itself. Its input is encoded by the Mutation's `Input`, so a
+ * page reads it back with the Mutation it has then.
+ */
+declare const StoredWrite: Schema.Struct<{
+  /** Its operation id, which is also its request id. */
+  readonly operation: Schema.String;
+  readonly mutation: Schema.String;
+  readonly input: Schema.Unknown;
+  readonly keys: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly now: Schema.optionalKey<Schema.Number>;
+  /** The layer it shows until it settles. */
+  readonly optimistic: Schema.$Array<Schema.Codec<OptimisticOperation, OptimisticOperation, never, never>>;
+  /** Who its layer was predicted for. */
+  readonly viewer: Schema.optionalKey<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+  }>>;
+  /** What the reader was shown when they acted, for the answer to carry. */
+  readonly shown: Schema.$Array<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+  /** Moves on each change of `state`; of two copies, the higher wins. */
+  readonly revision: Schema.Number;
+  readonly state: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Waiting">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Failed">;
+    readonly error: Schema.Struct<{
+      readonly _tag: Schema.String;
+      readonly message: Schema.String;
+      readonly refusal: Schema.optional<Schema.Unknown>;
+      readonly reason: Schema.optional<Schema.String>;
+    }>;
+  }>]>;
+}>;
+type StoredWrite = typeof StoredWrite.Type;
+/** A key's queue as stored, each entry as it was written, read or not. */
+interface StoredOutbox {
+  readonly entries: ReadonlyArray<unknown>;
+  readonly done: ReadonlyArray<string>;
+}
+declare const emptyStoredOutbox: StoredOutbox;
+/** `done` with `settled` after it, the newest `DONE_WINDOW`, each once. */
+declare const withDone: (done: ReadonlyArray<string>, settled: ReadonlyArray<string>) => ReadonlyArray<string>;
+/**
+ * Two copies of a queue as one: entries of both by operation, none that
+ * either settled, the higher revision of each, in the store's order and then
+ * mine. A join, so tabs that save at once lose nothing the next save does
+ * not put back.
+ */
+declare const mergeStored: (store: StoredOutbox, mine: StoredOutbox) => StoredOutbox;
+/** The record under `key` for `scope`: none when absent, of another scope or version, or not JSON. */
+declare const readStored: (key: string, scope: string) => Effect.Effect<StoredOutbox, KeyValueStore.KeyValueStoreError, KeyValueStore.KeyValueStore>;
+/**
+ * Whether the record under `key` holds writes waiting for another scope than
+ * `scope`: a key that is not one per principal. Writing over it would lose
+ * them, so it is not written.
+ */
+declare const othersWaiting: (key: string, scope: string) => Effect.Effect<boolean, KeyValueStore.KeyValueStoreError, KeyValueStore.KeyValueStore>;
+declare const storedText: (outbox: StoredOutbox, scope: string) => string;
+/** A queue's text, as `storedText` wrote it, read back. */
+declare const storedFromText: (text: string) => StoredOutbox;
+/**
+ * Whether the store says `operation` is settled: done, or refused. A store
+ * that lacks it says nothing (it could not be written), and it is sent.
+ */
+declare const settledIn: (outbox: StoredOutbox, operation: string) => boolean;
+/** A queued write in the Model. */
+type Queued = Data.TaggedEnum<{
+  /** One this version can send: shown, in the ledger, and sent in its turn. */
+  Readable: {
+    readonly write: StoredWrite;
+    /** Whether the store is known to hold this revision: only then is it sent. */
+    readonly stored: boolean;
+    /** Sends in a row that nothing answered, this page. */
+    readonly attempt: number;
+    /** Why the last of them failed. */
+    readonly delayed: Option.Option<RemoteError>;
+  };
+  /** One this version cannot read (a Mutation it lacks, an input that no longer decodes): kept, never sent. */
+  Unreadable: {
+    readonly operation: string;
+    readonly revision: number;
+    /** The entry as it was stored, written back as it is. */
+    readonly raw: unknown;
+    readonly reason: string;
+    readonly stored: boolean;
+  };
+}>;
+declare const Queued: Data.TaggedEnum.Constructor<{
+  readonly _tag: "Readable";
+  readonly write: StoredWrite;
+  readonly stored: boolean;
+  readonly attempt: number;
+  readonly delayed: Option.Option<RemoteError>;
+} | {
+  readonly _tag: "Unreadable";
+  readonly operation: string;
+  readonly revision: number;
+  readonly raw: unknown;
+  readonly reason: string;
+  readonly stored: boolean;
+}>;
+/** The durable writes this page holds, and the store they are copied to. */
+interface OutboxState {
+  /** Names this page load's operations; minted by the outbox's restore. */
+  readonly session: Option.Option<string>;
+  /** The store key the queue was read from; it is saved there and nowhere else. */
+  readonly key: Option.Option<string>;
+  /**
+   * Whose queue it is, as it was read: a page whose scope moves on sends none
+   * of it, and reads the new scope's instead.
+   */
+  readonly scope: Option.Option<string>;
+  /** Every tab's queued writes, in the order they are sent. */
+  readonly queue: ReadonlyArray<Queued>;
+  /** Operations settled lately, here or in another tab. */
+  readonly done: ReadonlyArray<string>;
+}
+declare const emptyOutbox: OutboxState;
+declare const operationOf: (value: {
+  readonly _tag: "Readable";
+  readonly write: StoredWrite;
+  readonly stored: boolean;
+  readonly attempt: number;
+  readonly delayed: Option.Option<RemoteError>;
+} | {
+  readonly _tag: "Unreadable";
+  readonly operation: string;
+  readonly revision: number;
+  readonly raw: unknown;
+  readonly reason: string;
+  readonly stored: boolean;
+}) => string;
+declare const revisionOf: (value: {
+  readonly _tag: "Readable";
+  readonly write: StoredWrite;
+  readonly stored: boolean;
+  readonly attempt: number;
+  readonly delayed: Option.Option<RemoteError>;
+} | {
+  readonly _tag: "Unreadable";
+  readonly operation: string;
+  readonly revision: number;
+  readonly raw: unknown;
+  readonly reason: string;
+  readonly stored: boolean;
+}) => number;
+/** The queue as the store keeps it. */
+declare const storedOf: (outbox: OutboxState) => StoredOutbox;
+/** Whether every queued write is in the store as the Model holds it. */
+declare const allStored: (outbox: OutboxState) => boolean;
+/** The write sent next: the oldest one waiting that the store holds. */
+declare const headOf: (outbox: OutboxState) => Option.Option<StoredWrite>;
+/**
+ * A stored entry as a page reads it: a write it can send, with its input
+ * decoded, or one it cannot, with why.
+ */
+type ReadEntry = {
+  readonly _tag: 'Readable';
+  readonly write: StoredWrite;
+  readonly input: unknown;
+} | {
+  readonly _tag: 'Unreadable';
+  readonly operation: string;
+  readonly revision: number;
+  readonly raw: unknown;
+  readonly reason: string;
+};
+/** A stored queue as a page reads it, entry by entry: one bad entry never fails the rest. */
+declare const readEntries: (outbox: StoredOutbox, inputOf: (mutation: string) => Option.Option<(input: unknown) => Option.Option<{
+  readonly decoded: unknown;
+}>>) => ReadonlyArray<ReadEntry>;
+/** One item of `Data.outboxStatus`. */
+interface OutboxItem {
+  readonly requestId: string;
+  /** The Mutation it names; none where the stored entry names none this version can read. */
+  readonly mutation: Option.Option<string>;
+  readonly state: OutboxItemState;
+}
+type OutboxItemState = Data.TaggedEnum<{
+  /** Not answered yet: `attempt` sends nothing answered so far, `error` the last one's. */
+  Waiting: {
+    readonly attempt: number;
+    readonly error: Option.Option<RemoteError>;
+  };
+  /** The server answered no: `Data.retry` or `Data.dismiss` it. */
+  Failed: {
+    readonly error: RemoteError;
+  };
+  /** Stored by a version of the app this one cannot read: `Data.dismiss` it. */
+  Unreadable: {
+    readonly reason: string;
+  };
+}>;
+declare const OutboxItemState: Data.TaggedEnum.Constructor<{
+  readonly _tag: "Failed";
+  readonly error: RemoteError;
+} | {
+  readonly _tag: "Unreadable";
+  readonly reason: string;
+} | {
+  readonly _tag: "Waiting";
+  readonly attempt: number;
+  readonly error: Option.Option<RemoteError>;
+}>;
+/** What the outbox holds, for a view: "3 changes waiting". */
+interface OutboxStatus {
+  readonly waiting: number;
+  readonly failed: number;
+  /** Every durable write not yet settled, in the order they are sent. */
+  readonly items: ReadonlyArray<OutboxItem>;
+}
+declare const outboxStatus: (outbox: OutboxState) => OutboxStatus;
+/**
+ * Where the outbox takes its Web Locks: the browser's, where it has them. A
+ * trace, which is one tab, takes none.
+ */
+declare const OutboxLocks: Context.Reference<Option.Option<LockManager>>;
+/**
+ * Holds the Web Lock `name` while `effect` runs, where there are Web Locks;
+ * elsewhere runs it as it is (one tab, or a server).
+ */
+declare const withLock: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/** The `BroadcastChannel` the tabs on one key speak on; none where there is none. */
+declare const channelFor: (key: string) => Option.Option<BroadcastChannel>;
+/** The lock the tabs on one key send under: one sends, the others wait. */
+declare const sendLock: (key: string) => string;
+/** The lock a write to the store is made under, so two tabs never write it at once. */
+declare const storeLock: (key: string) => string;
+/** How long the outbox waits before sending again after `attempt` sends nothing answered. */
+interface RetryOptions {
+  /** The first wait; 1 second unless given. */
+  readonly base?: Duration.Input | undefined;
+  /** The longest; 30 seconds unless given. */
+  readonly max?: Duration.Input | undefined;
+}
+/** `base` doubled per attempt, up to `max`, ±20% so tabs that failed together do not retry together. */
+declare const backoff: (attempt: number, options?: RetryOptions) => Effect.Effect<Duration.Duration>;
+/**
+ * Waits until the browser says it is online again, where it can say so;
+ * never elsewhere. A wait for a retry races it, so a write goes as soon as
+ * the network is back.
+ */
+declare const onlineAgain: Effect.Effect<void>;
+export { storedOf as A, readEntries as C, settledIn as D, sendLock as E, withDone as M, withLock as N, storeLock as O, outboxStatus as S, revisionOf as T, headOf as _, OutboxStatus as a, operationOf as b, ReadEntry as c, StoredWrite as d, allStored as f, emptyStoredOutbox as g, emptyOutbox as h, OutboxState as i, storedText as j, storedFromText as k, RetryOptions as l, channelFor as m, OutboxItemState as n, Queued as o, backoff as p, OutboxLocks as r, QueuedState as s, OutboxItem as t, StoredOutbox as u, mergeStored as v, readStored as w, othersWaiting as x, onlineAgain as y };
+//# sourceMappingURL=outbox-DNuc4kZp.d.ts.map