foldkit-remote 0.8.0 → 0.9.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { Context, Deferred, Duration, Effect, Layer, Option, Request, RequestResolver, Result, Schema, SchemaGetter, Stream } from "effect";
+import { Context, Deferred, Duration, Effect, Layer, Option, Request, RequestResolver, Result, Schema, SchemaAST, SchemaGetter, Stream } from "effect";
 import * as Domain from "foldkit-entity";
-import { Entity as Entity$1, Expr, Query as Query$1, SelectionTypeId, evaluate } from "foldkit-entity";
+import { Entity as Entity$1, Expr, Query as Query$1, SchemaShape, SelectionTypeId, evaluate } from "foldkit-entity";
 import { mapMessage } from "foldkit/command";
 import { defineMessageUnion } from "foldkit/message";
 import * as Subscription from "foldkit/subscription";
@@ -110,7 +110,31 @@ const requirementsOf = (projection) => RemoteRequirements.get(projection.metadat
 /** The query connections a Projection carries. */
 const connectionsOf = (projection) => RemoteConnections.get(projection.metadata);
 //#endregion
+//#region src/data.ts
+/**
+* Whether two values the server sent are the same data: equal primitives, or
+* arrays and plain objects whose entries are. Anything else is compared by
+* identity.
+*/
+const sameData = (left, right) => {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+	if (Array.isArray(left)) return Array.isArray(right) && left.length === right.length && left.every((item, index) => sameData(item, right[index]));
+	if (!isPlain(left) || !isPlain(right)) return false;
+	const keys = Object.keys(left);
+	return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && sameData(left[key], right[key]));
+};
+const isPlain = (value) => {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+//#endregion
 //#region src/relation.ts
+/**
+* Relation values on the wire and in the store: a ref key (`"Entity:id"`), a
+* nullable ref key, an array of ref keys, or a page of ref keys. The planner
+* follows them into the store; the server follows them into the next read.
+*/
 /** Marks the codec `Entity.ref`/`Entity.refPage` produce, so a Selection can tell the field's shape. */
 const RelationAnnotation = "foldkitRemoteRelation";
 /** The target entity's name on the same codec, so a nested selection of another entity is refused. */
@@ -176,8 +200,8 @@ const shapeOf = (ast, nullable) => {
 		nullable,
 		entity: String(ast.annotations?.[RelationEntityAnnotation])
 	};
-	if (ast._tag === "Arrays") {
-		const item = ast.rest?.[0];
+	if (SchemaAST.isArrays(ast)) {
+		const item = ast.rest[0];
 		const inner = item === void 0 ? void 0 : shapeOf(item, false);
 		return inner?.kind === "one" ? {
 			kind: "many",
@@ -185,10 +209,9 @@ const shapeOf = (ast, nullable) => {
 			entity: inner.entity
 		} : void 0;
 	}
-	if (ast._tag === "Union") {
-		const members = ast.types ?? [];
-		const optional = members.some((member) => member._tag === "Null" || member._tag === "Undefined");
-		for (const member of members) {
+	if (SchemaAST.isUnion(ast)) {
+		const optional = ast.types.some(SchemaShape.isNullish);
+		for (const member of ast.types) {
 			const shape = shapeOf(member, optional);
 			if (shape !== void 0) return shape;
 		}
@@ -201,8 +224,8 @@ const shapeOf = (ast, nullable) => {
 *
 * Presence is tracked **separately** from values, so `undefined`/`null`/absent/
 * stale/not-found are distinct states and a missing field is never inferred from
-* `value === undefined`. Nothing here performs I/O; every operation returns a
-* new store.
+* `value === undefined`. Nothing here performs I/O or mutates its input; an
+* operation that changes nothing returns the store it was given.
 */
 /** The separator keeps an untrusted id from colliding with a prototype key. */
 const entityKey = (entity, id) => `${entity}:${id}`;
@@ -237,7 +260,7 @@ const written = (previous, values, now, windows) => {
 		}
 	}
 	return {
-		values: {
+		values: Object.keys(values).every((field) => Object.hasOwn(previous.values, field) && sameData(previous.values[field], values[field])) ? previous.values : {
 			...previous.values,
 			...values
 		},
@@ -257,7 +280,7 @@ const written = (previous, values, now, windows) => {
 const writeEntities = (store, writes, now = 0) => {
 	if (writes.length === 0) return store;
 	const next = { ...store };
-	for (const write of writes) next[write.key] = written(next[write.key] ?? emptyEntry, write.values, now, write.windows);
+	for (const write of writes) next[write.key] = written(next[write.key] ?? emptyEntry, write.values, write.updatedAt ?? now, write.windows);
 	return next;
 };
 /** `writeEntities` for one entity. */
@@ -322,7 +345,7 @@ const isFieldUnavailable = (store, key, field) => {
 	return value !== void 0 && !value.tombstone && value.unavailable.has(field);
 };
 /** Records that the entity is known to be absent, so it is not refetched. */
-const tombstone = (store, key) => replace(store, key, {
+const tombstone = (store, key) => isTombstone(store, key) ? store : replace(store, key, {
 	values: {},
 	present: /* @__PURE__ */ new Set(),
 	stale: /* @__PURE__ */ new Set(),
@@ -445,8 +468,11 @@ const mutationStatus = (state, requestId) => {
 * with the same `requestId` (a retry, or a live event describing the same change)
 * does not re-apply the entities, but still clears `pending`.
 */
-const reconcileMutation = (store, state, requestId, entities, deleted = []) => {
-	const next = state.applied.has(requestId) ? store : deleted.reduce((current, gone) => tombstone(current, entityKey(gone.entity, gone.id)), entities.reduce((current, entity) => writeEntity(current, entityKey(entity.entity, entity.id), entity.values), store));
+const reconcileMutation = (store, state, requestId, answer) => {
+	const next = state.applied.has(requestId) ? store : (answer.deleted ?? []).reduce((current, gone) => tombstone(current, entityKey(gone.entity, gone.id)), writeEntities(store, answer.entities.map((entity) => ({
+		key: entityKey(entity.entity, entity.id),
+		values: entity.values
+	})), answer.now));
 	const applied = remember(state.applied, requestId);
 	const pending = new Set(state.pending);
 	pending.delete(requestId);
@@ -806,7 +832,13 @@ const WireBoundary = Schema.Union([
 const QueryRequest = Schema.Struct({
 	query: Schema.String,
 	input: Schema.Unknown,
-	window: WindowSchema
+	window: WindowSchema,
+	/**
+	* What to read of each item, as the relation slice a read asks the server
+	* for. Absent for a query run without one: the response carries only edges,
+	* and the client's read entry fetches fields in a second round trip.
+	*/
+	select: Schema.optional(RelationRequest)
 });
 const QueryEdge = Schema.Struct({
 	entity: Schema.String,
@@ -816,7 +848,14 @@ const QueryEdge = Schema.Struct({
 const QueryResult = Schema.Struct({
 	edges: Schema.Array(QueryEdge),
 	start: WireBoundary,
-	end: WireBoundary
+	end: WireBoundary,
+	/**
+	* The selected fields of the page's items, in the same shape a read batch
+	* returns. Absent from a server that predates payload planning: the client
+	* reads it as empty and fetches fields as before.
+	*/
+	entities: Schema.optional(Schema.Array(NormalizedEntity)),
+	settled: Schema.optional(Schema.Array(SettledFields))
 });
 const QueryRpc = Rpc.make("FoldkitRemoteQuery", {
 	payload: QueryRequest,
@@ -884,7 +923,8 @@ const coalesceQueries = (query, options = {}) => Effect.gen(function* () {
 		key: stableStringify([
 			request.query,
 			request.input,
-			request.window
+			request.window,
+			request.select ?? null
 		]),
 		request
 	}), resolver);
@@ -1694,12 +1734,13 @@ const ConnectionChange = {
 const beginOptimistic = (optimistic, requestId, operations) => {
 	const patches = operations.filter((operation) => !isConnectionChange(operation));
 	const changes = operations.filter(isConnectionChange);
+	if (patches.length === 0 && changes.length === 0) return optimistic;
 	return {
 		layers: patches.length === 0 ? optimistic.layers : [...optimistic.layers, {
 			id: requestId,
 			patches
 		}],
-		overlays: [...optimistic.overlays, ...toOverlays(requestId, changes)]
+		overlays: changes.length === 0 ? optimistic.overlays : [...optimistic.overlays, ...toOverlays(requestId, changes)]
 	};
 };
 /**
@@ -1708,8 +1749,9 @@ const beginOptimistic = (optimistic, requestId, operations) => {
 * its place among other pending inserts.
 */
 const confirm = (optimistic, requestId, id, changes) => {
-	const confirmed = toOverlays(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,
@@ -1728,37 +1770,62 @@ const addLayer = (optimistic, layer) => ({
 	...optimistic,
 	layers: [...optimistic.layers, layer]
 });
-const removeLayer = (optimistic, id) => ({
-	...optimistic,
-	layers: optimistic.layers.filter((layer) => layer.id !== id)
-});
+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) => ({
-	...optimistic,
-	overlays: optimistic.overlays.filter((overlay) => overlay.id !== id)
-});
-/** Base store with every layer applied in order. Later layers win. */
-const visibleStore = (base, optimistic) => optimistic.layers.reduce((store, layer) => layer.patches.reduce((current, patch) => writeEntity(current, entityKey(patch.entity, patch.id), patch.values), store), base);
+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.
+*/
+const visibleStore = (base, optimistic) => writeEntities(base, optimistic.layers.flatMap((layer) => layer.patches.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
+	};
+})));
 /**
 * 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) => ({
-	...optimistic,
-	overlays: optimistic.overlays.flatMap((overlay) => {
+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);
 /**
@@ -1766,12 +1833,12 @@ const release = (optimistic, requestId) => removeOverlay(removeLayer(optimistic,
 * 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, entities, connections = [], deleted = []) => {
-	const reconciled = reconcileMutation(base, state, requestId, entities, deleted);
+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) : confirm(removeLayer(optimistic, requestId), requestId, `confirmed:${requestId}`, connections)
+		optimistic: state.applied.has(requestId) ? release(optimistic, requestId) : confirm(removeLayer(optimistic, requestId), requestId, `confirmed:${requestId}`, answer.connections ?? [])
 	};
 };
 /** A failed request's layer and overlays are dropped; the base was never mutated. */
@@ -1846,11 +1913,6 @@ const recordBoundary = (state, connection, position) => {
 		}
 	};
 };
-/**
-* A subscriber is woken only if the event changed a field it selects. A
-* change to an unselected field is skipped entirely.
-*/
-const shouldWake = (changed, selected) => changed.some((field) => selected.includes(field));
 const applyEntityEvent = (state, store, event, now = 0) => {
 	const outcome = classifyLive(state, event.cursor);
 	if (outcome !== "applied") return {
@@ -1868,9 +1930,13 @@ const applyEntityEvent = (state, store, event, now = 0) => {
 };
 const removeEdgeOverlays = (optimistic, connection, key) => ({
 	...optimistic,
-	overlays: optimistic.overlays.map((overlay) => overlay.connection !== connection || overlay.position === "remove" ? overlay : {
-		...overlay,
-		edges: overlay.edges.filter((edge) => edge.key !== key)
+	overlays: optimistic.overlays.map((overlay) => {
+		if (overlay.connection !== connection || overlay.position === "remove") return overlay;
+		const edges = overlay.edges.filter((edge) => edge.key !== key);
+		return edges.length === overlay.edges.length ? overlay : {
+			...overlay,
+			edges
+		};
 	})
 });
 const applyConnectionEvent = (state, optimistic, event, policy = {}) => {
@@ -1960,10 +2026,13 @@ const followRelation = (value, relation) => targetsOf(value, relation).map((ref)
 /**
 * The earliest moment a value `requirements` read, following the relations the
 * store holds as `plan` does, goes stale under `freshness`, with the
-* requirements of the entities that go stale then. Nothing when no value is
-* both present and still fresh: what is already expired or stale is planned,
-* not awaited, which is what keeps a timer from firing on what it already
-* fired on.
+* requirements of the entities that go stale then. A field the server settled
+* without a value ages with its entity too, since `plan` asks for it again once
+* the entity expires. Nothing when no such field is still fresh: what is
+* already expired or stale is planned, not awaited, which is what keeps a
+* timer from firing on what it already fired on. It is the next moment the
+* plan can change with the clock alone, which the read entry relies on to
+* reuse its plan until then.
 */
 const deadlineOf = (store, requirements, freshness) => {
 	let at;
@@ -1972,9 +2041,9 @@ const deadlineOf = (store, requirements, freshness) => {
 		const key = entityKey(group.entity, group.id);
 		const entry = store[key];
 		if (entry === void 0 || entry.tombstone) return;
-		if (group.fields.some((field) => entry.present.has(field) && !entry.stale.has(field))) {
+		if (group.fields.some((field) => entry.present.has(field) && !entry.stale.has(field) || entry.unavailable.has(field))) {
 			const expires = entry.updatedAt + freshness.freshness;
-			if (expires > freshness.now) {
+			if (expires >= freshness.now && Number.isFinite(expires)) {
 				if (at === void 0 || expires < at) {
 					at = expires;
 					due = [group];
@@ -2076,17 +2145,25 @@ const reachable = (store, roots, connections, optimistic, pending) => {
 const gc = (state, roots) => {
 	const pending = state.mutations.pending;
 	const kept = reachable(state.entities, roots, state.connections, state.optimistic, pending);
-	const entities = Object.fromEntries(Object.entries(state.entities).filter(([key]) => kept.has(key)));
+	const entities = keptOf(state.entities, (key) => kept.has(key));
 	const keptConnections = /* @__PURE__ */ new Set([...roots.connections.map((root) => root.identity), ...state.optimistic.overlays.filter((overlay) => pending.has(overlay.id)).map((overlay) => overlay.connection)]);
+	const connections = keptOf(state.connections, (identity) => keptConnections.has(identity));
+	const overlays = state.optimistic.overlays.filter((overlay) => pending.has(overlay.id) || keptConnections.has(overlay.connection));
 	return {
 		entities,
-		connections: Object.fromEntries(Object.entries(state.connections).filter(([identity]) => keptConnections.has(identity))),
-		optimistic: {
+		connections,
+		optimistic: overlays.length === state.optimistic.overlays.length ? state.optimistic : {
 			layers: state.optimistic.layers,
-			overlays: state.optimistic.overlays.filter((overlay) => pending.has(overlay.id) || keptConnections.has(overlay.connection))
+			overlays
 		}
 	};
 };
+/** The entries whose key is kept; `record` itself when that is all of them. */
+const keptOf = (record, keep) => {
+	const entries = Object.entries(record);
+	const kept = entries.filter(([key]) => keep(key));
+	return kept.length === entries.length ? record : Object.fromEntries(kept);
+};
 //#endregion
 //#region src/persistence.ts
 /**
@@ -2231,7 +2308,7 @@ const hydrate = (raw, options = {}) => {
 * an entry the current store already has (it is at least as fresh as a
 * snapshot taken earlier). Either way, keys only the current store has stay.
 */
-const mergeStores = (current, snapshot, policy) => policy === "replace" ? {
+const mergeStores = (current, snapshot, policy) => Object.keys(snapshot).length === 0 ? current : policy === "replace" ? {
 	...current,
 	...snapshot
 } : {
@@ -2392,7 +2469,9 @@ const RemoteData = {
 				error: data.error,
 				previous: f(data.previous)
 			};
-			default: return data;
+			case "Initial":
+			case "Loading":
+			case "NotFound": return data;
 		}
 	}
 };
@@ -2440,6 +2519,7 @@ const forgetRemote = (model) => {
 const initialRemoteModel = {
 	entities: emptyStore,
 	connections: {},
+	grown: {},
 	optimistic: emptyOptimistic,
 	live: {},
 	mutations: emptyMutationState,
@@ -2453,6 +2533,7 @@ const runtimeSchema = Schema.Unknown;
 const remoteModelSchema = () => Schema.Struct({
 	entities: runtimeSchema,
 	connections: Schema.Record(Schema.String, runtimeSchema),
+	grown: Schema.Record(Schema.String, Schema.Number),
 	optimistic: runtimeSchema,
 	live: Schema.Record(Schema.String, runtimeSchema),
 	mutations: runtimeSchema,
@@ -2509,7 +2590,8 @@ const remoteMessageCases = {
 		deleted: Schema.optional(Schema.Array(Schema.Struct({
 			entity: Schema.String,
 			id: Schema.String
-		})))
+		}))),
+		now: Schema.Number
 	},
 	MutationFailed: {
 		requestId: Schema.String,
@@ -2520,6 +2602,10 @@ const remoteMessageCases = {
 		optimistic: Schema.Array(Schema.Unknown)
 	},
 	OverlayLifted: { id: Schema.String },
+	WindowGrown: {
+		window: Schema.String,
+		size: Schema.Number
+	},
 	LiveReceived: {
 		stream: Schema.String,
 		event: Schema.Unknown,
@@ -2530,7 +2616,11 @@ const remoteMessageCases = {
 	ConnectionMerged: {
 		connection: Schema.String,
 		page: Schema.Unknown,
-		refreshes: Schema.optional(Schema.Boolean)
+		refreshes: Schema.optional(Schema.Boolean),
+		select: Schema.optional(RelationRequest),
+		entities: Schema.optional(Schema.Array(NormalizedEntity)),
+		settled: Schema.optional(Schema.Array(SettledFields)),
+		now: Schema.optional(Schema.Number)
 	},
 	ConnectionInvalidated: { connection: Schema.String },
 	ConnectionRefreshed: { connection: Schema.String },
@@ -2550,6 +2640,18 @@ const remoteMessageSchema = Schema.Union(Object.entries(remoteMessageCases).map(
 })));
 /** An overlay's layer, named apart from every request's: a request id is the application's to choose too. */
 const overlayLayer = (id) => `overlay:${id}`;
+/** The key a grown window is kept under: its connection and the window first asked for. */
+const windowGrowthKey = (identity, window) => `${identity}\u0000${window}`;
+/**
+* Whether only overlays show this entity: the server has told the store
+* nothing of it and no request's layer writes it, so nothing will fetch what an
+* overlay leaves out.
+*/
+const onlyOverlaid = (model, entity, id) => {
+	if (Object.hasOwn(model.entities, entityKey(entity, id))) return false;
+	const writers = model.optimistic.layers.filter((layer) => layer.patches.some((patch) => patch.entity === entity && patch.id === id));
+	return writers.length > 0 && writers.every((layer) => layer.id.startsWith("overlay:"));
+};
 const marksOf = (requests) => requests.map((request) => [entityKey(request.entity, request.id), request.fields]);
 /**
 * One mark per requested field, `entity\0id\0field`. A read is identified by
@@ -2565,13 +2667,13 @@ const fieldMarks = function* (requests) {
 const withLoading = (loading, requests) => {
 	const next = new Set(loading);
 	for (const mark of fieldMarks(requests)) next.add(mark);
-	return next;
+	return next.size === loading.size ? loading : next;
 };
 const withoutLoading = (loading, requests) => {
 	if (loading.size === 0) return loading;
 	const next = new Set(loading);
 	for (const mark of fieldMarks(requests)) next.delete(mark);
-	return next;
+	return next.size === loading.size ? loading : next;
 };
 /**
 * A connection's mark. The leading separator keeps it out of the field marks'
@@ -2600,6 +2702,14 @@ const prunedLoading = (loading, roots, reached) => {
 	return kept.length === loading.size ? loading : new Set(kept);
 };
 /**
+* The windows grown on connections retention keeps; a dropped one starts over.
+* The same record when every one is kept.
+*/
+const keptWindows = (grown, connections) => {
+	const kept = Object.entries(grown).filter(([key]) => Object.hasOwn(connections, key.slice(0, key.lastIndexOf("\0"))));
+	return kept.length === Object.keys(grown).length ? grown : Object.fromEntries(kept);
+};
+/**
 * Drops the refresh marks of entities and connections that were collected.
 * Nothing observes a collected entity — the retention roots are the active
 * Surfaces — so no read entry's generation can fall back when its mark goes.
@@ -2686,15 +2796,20 @@ const isLoading = (model, entity, id, fields) => {
 	return fields.some((field) => model.loading.has(fieldMark(entity, id, field)));
 };
 const setConnectionStale = (connections, connection, stale) => {
-	const current = connections[connection] ?? emptyConnection;
+	const current = connections[connection];
+	if (current?.stale === stale) return connections;
 	return {
 		...connections,
 		[connection]: {
-			...current,
+			...current ?? emptyConnection,
 			stale
 		}
 	};
 };
+const withLiveState = (live, stream, state) => live[stream] === state ? live : {
+	...live,
+	[stream]: state
+};
 const markGap = (model, stream) => model.gaps.has(stream) ? model : {
 	...model,
 	gaps: /* @__PURE__ */ new Set([...model.gaps, stream])
@@ -2706,9 +2821,23 @@ const clearGap = (model, stream) => model.gaps.has(stream) ? {
 /**
 * The pure reducer all four producers share. A live event that arrives ahead of
 * its cursor is a gap: it is not applied, and the stream is recorded so the host
-* can resubscribe rather than silently miss facts.
+* can resubscribe rather than silently miss facts. When every field a Message
+* touches keeps its identity, `model` itself is returned, so the application's
+* root keeps its identity and Foldkit does not render. The common no-ops do (a
+* duplicate live event, a repeated `ReadStarted`); a repeated failure, or a
+* `preserve-existing` restore of entities already held, still makes an equal
+* copy.
 */
 const updateRemote = (model, message) => {
+	const next = reduceRemote(model, message);
+	return next === model || !sameFields(model, next) ? next : model;
+};
+/** Whether every field of `next` is the one `model` holds. */
+const sameFields = (model, next) => {
+	const keys = Object.keys(next);
+	return keys.length === Object.keys(model).length && keys.every((key) => Object.is(model[key], next[key]));
+};
+const reduceRemote = (model, message) => {
 	switch (message._tag) {
 		case "ReadReceived": return {
 			...model,
@@ -2731,6 +2860,7 @@ const updateRemote = (model, message) => {
 			return {
 				...model,
 				...retained,
+				grown: keptWindows(model.grown, retained.connections),
 				refresh: prunedRefresh(model.refresh, retained),
 				failures: prunedFailures(model.failures, message.roots, reached),
 				loading: prunedLoading(model.loading, message.roots, reached)
@@ -2750,7 +2880,7 @@ const updateRemote = (model, message) => {
 				...model,
 				entities: RemotePersistence.mergeStores(model.entities, message.entities, message.merge),
 				failures: withoutFieldFailures(model.failures, written),
-				connections: message.merge === "replace" ? {
+				connections: restored.length === 0 ? model.connections : message.merge === "replace" ? {
 					...model.connections,
 					...Object.fromEntries(restored)
 				} : {
@@ -2764,7 +2894,7 @@ const updateRemote = (model, message) => {
 			const marks = marksOf(message.requests);
 			const entities = setUnavailable(setStale(asked, marks, true), marks, false);
 			const failures = withoutFieldFailures(model.failures, reachedMarks(model.entities, message.requests));
-			return entities === model.entities && failures === model.failures ? model : {
+			return {
 				...model,
 				entities,
 				failures
@@ -2789,7 +2919,7 @@ const updateRemote = (model, message) => {
 			optimistic: beginOptimistic(model.optimistic, message.requestId, message.optimistic ?? [])
 		};
 		case "MutationSucceeded": {
-			const settled = settleSuccess(model.entities, model.optimistic, model.mutations, message.requestId, message.entities, message.connections ?? [], message.deleted ?? []);
+			const settled = settleSuccess(model.entities, model.optimistic, model.mutations, message.requestId, message);
 			return {
 				...model,
 				entities: settled.store,
@@ -2802,6 +2932,13 @@ const updateRemote = (model, message) => {
 			...model,
 			optimistic: beginOptimistic(settleFailure(model.optimistic, overlayLayer(message.id)), overlayLayer(message.id), message.optimistic)
 		};
+		case "WindowGrown": return {
+			...model,
+			grown: {
+				...model.grown,
+				[message.window]: message.size
+			}
+		};
 		case "OverlayLifted": {
 			const optimistic = settleFailure(model.optimistic, overlayLayer(message.id));
 			return optimistic.layers.length === model.optimistic.layers.length && optimistic.overlays.length === model.optimistic.overlays.length ? model : {
@@ -2827,10 +2964,7 @@ const updateRemote = (model, message) => {
 				return clearGap({
 					...model,
 					entities: applied.store,
-					live: {
-						...model.live,
-						[message.stream]: applied.state
-					},
+					live: withLiveState(model.live, message.stream, applied.state),
 					failures: withoutFieldFailures(model.failures, settled)
 				}, message.stream);
 			}
@@ -2839,10 +2973,7 @@ const updateRemote = (model, message) => {
 			const next = clearGap({
 				...model,
 				optimistic: applied.optimistic,
-				live: {
-					...model.live,
-					[message.stream]: applied.state
-				}
+				live: withLiveState(model.live, message.stream, applied.state)
 			}, message.stream);
 			return applied.invalidated === void 0 ? next : updateRemote(next, {
 				_tag: "ConnectionInvalidated",
@@ -2852,12 +2983,23 @@ const updateRemote = (model, message) => {
 		case "GapCleared": return clearGap(model, message.stream);
 		case "ConnectionMerged": {
 			const current = model.connections[message.connection] ?? emptyConnection;
-			const failures = withoutConnectionFailure(model.failures, message.connection);
 			const loading = withoutQueryLoading(model.loading, message.connection);
 			const replaces = message.refreshes === true && current.stale;
 			const merged = merge(replaces ? emptyConnection : current, message.page);
+			const payload = message.select === void 0 ? [] : message.entities ?? [];
+			const settled = message.select === void 0 ? [] : message.settled ?? [];
+			const requests = message.select === void 0 || payload.length === 0 && settled.length === 0 ? [] : message.page.edges.filter((edge) => edge.ref.entity === message.select.entity).map((edge) => ({
+				...message.select,
+				id: edge.ref.id
+			}));
+			const entities = requests.length === 0 ? model.entities : writeRead(model.entities, requests, {
+				entities: [...payload],
+				settled: [...settled]
+			}, message.now ?? 0);
+			const failures = withoutFieldFailures(withoutConnectionFailure(model.failures, message.connection), [...fieldMarks(requests), ...patchedMarks(payload)]);
 			return {
 				...model,
+				entities,
 				connections: {
 					...model.connections,
 					[message.connection]: message.refreshes === true ? {
@@ -2870,13 +3012,11 @@ const updateRemote = (model, message) => {
 				loading
 			};
 		}
-		case "ConnectionInvalidated":
-			if (model.connections[message.connection]?.stale === true && !(message.connection in model.failures.connections)) return model;
-			return {
-				...model,
-				connections: setConnectionStale(model.connections, message.connection, true),
-				failures: withoutConnectionFailure(model.failures, message.connection)
-			};
+		case "ConnectionInvalidated": return {
+			...model,
+			connections: setConnectionStale(model.connections, message.connection, true),
+			failures: withoutConnectionFailure(model.failures, message.connection)
+		};
 		case "QueryFailed": return {
 			...model,
 			failures: {
@@ -3381,6 +3521,67 @@ const resumePart = (domain, options = {}) => ({
 */
 const descriptorOf = (entity) => Entity$1.is(entity) ? Entity.from(entity) : entity;
 const selectionOf = (selection) => SelectionTypeId in selection ? Selection.from(selection) : selection;
+const readContract = (source, shape, window) => {
+	const ref = {
+		...source,
+		window: pickWindow(window)
+	};
+	const relation = relationOf(shape);
+	return {
+		ref,
+		relation,
+		requirement: {
+			identity: ref.identity,
+			window: ref.window,
+			select: relation,
+			ref
+		}
+	};
+};
+const metaOf = (remote, asked) => {
+	const visible = visibleStoreOf(remote.entities, remote.optimistic);
+	let updatedAt;
+	let stale = false;
+	let loading = false;
+	const seen = /* @__PURE__ */ new Set();
+	const touch = (entity, id, requirement) => {
+		const key = entityKey(entity, id);
+		const memo = `${key}\u0000${stableStringify(requirement)}`;
+		if (seen.has(memo)) return;
+		seen.add(memo);
+		const entry = visible[key];
+		if (entry !== void 0 && !entry.tombstone) for (const field of requirement.fields) {
+			if (!entry.present.has(field)) continue;
+			if (Number.isFinite(entry.updatedAt)) updatedAt = updatedAt === void 0 ? entry.updatedAt : Math.max(updatedAt, entry.updatedAt);
+			if (entry.stale.has(field)) stale = true;
+		}
+		if (isLoadingThrough(remote, entity, id, requirement)) loading = true;
+		for (const [field, relation] of Object.entries(requirement.relations ?? {})) {
+			const value = readField(visible, key, field);
+			if (value._tag === "None" || value.value === null || value.value === void 0) continue;
+			for (const ref of targetsOf(value.value, relation)) touch(ref.entity, ref.id, relation);
+		}
+	};
+	for (const requirement of asked.requirements) touch(requirement.entity, requirement.id, requirement);
+	for (const connection of asked.connections) {
+		const known = remote.connections[connection.identity];
+		if (known === void 0) {
+			if (isQueryLoading(remote, connection.identity)) loading = true;
+			continue;
+		}
+		if (known.stale) stale = true;
+		if (isQueryLoading(remote, connection.identity)) loading = true;
+		for (const edge of visibleItems(known, connection.identity, remote.optimistic.overlays, remote.entities)) {
+			if (edge.ref.entity !== connection.select.entity) continue;
+			touch(edge.ref.entity, edge.ref.id, connection.select);
+		}
+	}
+	return {
+		updatedAt,
+		stale,
+		loading
+	};
+};
 /**
 * The store a read or plan sees: the base with every pending optimistic layer
 * applied, so a request's patches show until it settles and a temporary id is
@@ -3408,10 +3609,10 @@ const confirmed = (bound, projection) => ({
 });
 const visibleStores = /* @__PURE__ */ new WeakMap();
 const visibleStoreOf = (entities, optimistic) => {
-	let byStore = visibleStores.get(optimistic);
+	let byStore = visibleStores.get(optimistic.layers);
 	if (byStore === void 0) {
 		byStore = /* @__PURE__ */ new WeakMap();
-		visibleStores.set(optimistic, byStore);
+		visibleStores.set(optimistic.layers, byStore);
 	}
 	let visible = byStore.get(entities);
 	if (visible === void 0) {
@@ -3436,25 +3637,71 @@ const unavailableFailure = (store, key, relation) => {
 		}
 	};
 };
-const readResults = /* @__PURE__ */ new WeakMap();
-const memoRead = (snapshot, by, key, compute) => {
-	let byScope = readResults.get(snapshot);
-	if (byScope === void 0) {
-		byScope = /* @__PURE__ */ new WeakMap();
-		readResults.set(snapshot, byScope);
+/**
+* A row's decoded value, kept while the data it was assembled from is the same,
+* so a refetch or live patch that brought equal data hands a view the object it
+* already rendered. Keyed on the row's own values object, which the store keeps
+* across equal writes; a relation's targets are covered by comparing what was
+* assembled.
+*/
+const decodedRows = /* @__PURE__ */ new WeakMap();
+const decodeRow = (schema, source, values) => {
+	let bySchema = decodedRows.get(schema);
+	if (bySchema === void 0) {
+		bySchema = {
+			decode: Schema.decodeUnknownResult(schema),
+			rows: /* @__PURE__ */ new WeakMap()
+		};
+		decodedRows.set(schema, bySchema);
 	}
-	let results = byScope.get(by);
-	if (results === void 0) {
-		results = /* @__PURE__ */ new Map();
-		byScope.set(by, results);
+	const cached = bySchema.rows.get(source);
+	if (cached !== void 0 && sameData(cached.values, values)) return cached.decoded;
+	const decoded = bySchema.decode(values);
+	bySchema.rows.set(source, {
+		values,
+		decoded
+	});
+	return decoded;
+};
+const readResults = {
+	inner: /* @__PURE__ */ new WeakMap(),
+	results: /* @__PURE__ */ new Map()
+};
+const memoRead = (scopes, key, compute) => {
+	let scope = readResults;
+	for (const by of scopes) {
+		let inner = scope.inner.get(by);
+		if (inner === void 0) {
+			inner = {
+				inner: /* @__PURE__ */ new WeakMap(),
+				results: /* @__PURE__ */ new Map()
+			};
+			scope.inner.set(by, inner);
+		}
+		scope = inner;
 	}
-	if (results.has(key)) return results.get(key);
+	if (scope.results.has(key)) return scope.results.get(key);
 	const value = compute();
-	results.set(key, value);
+	scope.results.set(key, value);
 	return value;
 };
+/**
+* The default clock. It reads `Date.now` when called rather than holding the
+* function, so fake timers installed after the domain was made move it.
+*/
+const wallClock = () => Date.now();
 /** The default `toMessage`: the application reduces `RemoteMessage` itself. */
 const identityMessage = (message) => message;
+/**
+* `Data.satisfy` reached its bound with Surfaces still reading, such as a
+* chain whose every read reveals one more. It names them, so a page that
+* would have rendered them loading fails instead. (A read the server leaves
+* unanswered settles as missing and ends the loop.)
+*/
+var RemoteUnsatisfied = class extends Schema.TaggedError()("RemoteUnsatisfied", {
+	surfaces: Schema.Array(Schema.String),
+	passes: Schema.Number
+}) {};
 /** A stable key for a live subscription's requirement set. */
 const liveStreamKey = (requirements) => requirements.map((requirement) => `${entityKey(requirement.entity, requirement.id)}:${[...requirement.fields].sort().join(",")}`).sort().join("|");
 /** Declares a Remote domain: its entities, queries, and mutations, plus the submodel. */
@@ -3498,10 +3745,15 @@ const nothingAsked = {
 	requirements: [],
 	connections: []
 };
-const askedOf = (projection) => projection === void 0 ? nothingAsked : {
+const askedOf = (projection) => ({
 	requirements: requirementsOf(projection),
 	connections: connectionsOf(projection)
-};
+});
+/** What an active Surface asks for: nothing while it is inactive. */
+const askedWhile = (projection) => Option.match(projection, {
+	onNone: () => nothingAsked,
+	onSome: askedOf
+});
 /**
 * Whether `outer` asks for everything `inner` does of one entity: each field,
 * each relation's own slice of its target, and each page window alike.
@@ -3532,17 +3784,78 @@ const covers = (outer, inner) => {
 * failure is what its read shows, and retrying is `Remote.refresh`'s to ask
 * for. The rows it already holds are still planned, since they are on screen.
 */
+/**
+* One requirement per connection and direction: of the sized windows reading
+* a connection from its start (or end), the widest, which covers the rest.
+* Windows with a cursor are pages of their own and stay as they are.
+*/
+const widest = (remote, connections) => {
+	const kept = /* @__PURE__ */ new Map();
+	const rest = [];
+	for (const connection of connections) {
+		const size = windowSize(remote, connection);
+		if (size === void 0) {
+			rest.push(connection);
+			continue;
+		}
+		const key = `${connection.identity}${String.fromCharCode(0)}${connection.window.first === void 0 ? "last" : "first"}`;
+		const current = kept.get(key);
+		if (current === void 0) kept.set(key, connection);
+		else if (size > (windowSize(remote, current) ?? 0)) kept.set(key, {
+			...connection,
+			select: Requirement.mergeRelation(current.select, connection.select)
+		});
+		else kept.set(key, {
+			...current,
+			select: Requirement.mergeRelation(current.select, connection.select)
+		});
+	}
+	return [...kept.values(), ...rest];
+};
+const withWindow = (connection, window) => ({
+	...connection,
+	window,
+	ref: {
+		...connection.ref,
+		window
+	}
+});
+/**
+* The page a connection lacks for a window of `size` from its start (or end):
+* the rows after its first segment's end cursor (or before its last's start).
+* Undefined when it holds enough, reaches the end, or does not know where it
+* starts.
+*/
+const missingRows = (known, window, size) => {
+	const forward = window.first !== void 0;
+	const segment = forward ? known.segments[0] : known.segments[known.segments.length - 1];
+	if (segment === void 0) return void 0;
+	const [from, to] = forward ? [segment.start, segment.end] : [segment.end, segment.start];
+	if (from._tag !== "Terminal" || to._tag !== "Cursor" || segment.edges.length >= size) return void 0;
+	const lacking = size - segment.edges.length;
+	return forward ? {
+		first: lacking,
+		after: to.cursor
+	} : {
+		last: lacking,
+		before: to.cursor
+	};
+};
 const planAsked = (remote, asked, options) => {
 	const queries = [];
 	const items = [];
 	const connections = Requirement.mergeConnections(asked.connections);
-	for (const connection of connections) {
+	for (const connection of widest(remote, connections)) {
 		const known = remote.connections[connection.identity];
-		if (!(options.force !== true && connection.identity in remote.failures.connections) && (known === void 0 || known.stale || options.force === true)) {
-			queries.push(connection);
+		const failed = options.force !== true && connection.identity in remote.failures.connections;
+		const size = windowSize(remote, connection);
+		if (!failed && (known === void 0 || known.stale || options.force === true)) {
+			queries.push(size === void 0 ? connection : withWindow(connection, connection.window.first === void 0 ? { last: size } : { first: size }));
 			continue;
 		}
 		if (known === void 0) continue;
+		const tail = failed || size === void 0 ? void 0 : missingRows(known, connection.window, size);
+		if (tail !== void 0) queries.push(withWindow(connection, tail));
 		const edges = visibleItems(known, connection.identity, remote.optimistic.overlays, remote.entities);
 		items.push(...itemsOf(edges.map((edge) => edge.ref), connection.select));
 	}
@@ -3598,7 +3911,8 @@ const queryRequestOf = (query) => {
 		try: () => ({
 			query: query.identity.slice(0, separator),
 			input: JSON.parse(query.identity.slice(separator + 1)),
-			window: query.window
+			window: query.window,
+			...query.select === void 0 ? {} : { select: query.select }
 		}),
 		catch: () => new RemoteQueryError({ message: `connection "${query.identity}" carries no encoded input` })
 	});
@@ -3627,7 +3941,7 @@ const overrun = (window, edges) => {
 		got: edges.length
 	} : void 0;
 };
-const pageMessage = (connection, result, refreshes = false, window = {}) => {
+const pageMessage = (connection, result, refreshes = false, window = {}, select, now) => {
 	const over = overrun(window, result.edges);
 	if (over !== void 0) return {
 		_tag: "QueryFailed",
@@ -3637,6 +3951,7 @@ const pageMessage = (connection, result, refreshes = false, window = {}) => {
 			message: `the server returned ${over.got} edges for a window of ${over.asked}`
 		}
 	};
+	const hasPayload = select !== void 0 && (result.entities !== void 0 && result.entities.length > 0 || result.settled !== void 0 && result.settled.length > 0);
 	return {
 		_tag: "ConnectionMerged",
 		connection,
@@ -3651,7 +3966,13 @@ const pageMessage = (connection, result, refreshes = false, window = {}) => {
 			start: result.start,
 			end: result.end
 		},
-		...refreshes ? { refreshes } : {}
+		...refreshes ? { refreshes } : {},
+		...select === void 0 || !hasPayload ? {} : { select },
+		...hasPayload ? {
+			entities: [...result.entities ?? []],
+			settled: [...result.settled ?? []],
+			now: now ?? 0
+		} : {}
 	};
 };
 /**
@@ -3694,14 +4015,14 @@ const readMessage = (requirements, now) => Effect.gen(function* () {
 	};
 });
 /** Runs a query and reports the page that refreshes its connection, or the failure. Never fails. */
-const queryMessage = (query) => Effect.gen(function* () {
+const queryMessage = (query, now = wallClock) => Effect.gen(function* () {
 	const client = yield* RemoteClient;
 	const result = yield* Effect.result(queryRequestOf(query).pipe(Effect.flatMap((request) => client.query(request))));
 	return Result.isFailure(result) ? {
 		_tag: "QueryFailed",
 		connection: query.identity,
 		error: remoteError(result.failure)
-	} : pageMessage(query.identity, result.success, true, query.window);
+	} : pageMessage(query.identity, result.success, true, query.window, query.select, now());
 });
 /** A query the read entry runs, as its dependencies carry it: plain data Foldkit compares. */
 const PlannedQuery = Schema.Struct({
@@ -3719,9 +4040,10 @@ const PlannedQuery = Schema.Struct({
 * to the restart; a page and its refresh are one `ConnectionMerged`.
 */
 const observeEntry = (bound, askedOf, toMessage, options) => {
-	const { policy = RemotePolicy.cacheFirst, now = Date.now } = options;
+	const { policy = RemotePolicy.cacheFirst, now = wallClock } = options;
 	const read = (requirements) => Effect.map(readMessage(requirements, now), toMessage);
-	const run = (query) => Effect.map(queryMessage(query), toMessage);
+	const run = (query) => Effect.map(queryMessage(query, now), toMessage);
+	const planned = /* @__PURE__ */ new WeakMap();
 	return {
 		dependenciesSchema: Schema.Struct({
 			requirements: Schema.Array(ReadRequest),
@@ -3734,17 +4056,32 @@ const observeEntry = (bound, askedOf, toMessage, options) => {
 		}),
 		modelToDependencies: (model) => {
 			const remote = bound.store.get(model);
-			const planned = planAsked(remote, askedOf(model), RemotePolicy.toPlan(policy, now()));
-			return {
-				refresh: refreshedAt(remote.refresh, planned.requirements, planned.queries.map((query) => query.identity)),
-				requirements: planned.requirements,
-				queries: planned.queries.map(({ identity, window, select }) => ({
+			const asked = askedOf(model);
+			const askedKey = stableStringify(asked);
+			const at = now();
+			let byAsked = planned.get(remote);
+			const known = byAsked?.get(askedKey);
+			if (known !== void 0 && at < known.until) return known.dependencies;
+			const plan = planAsked(remote, asked, RemotePolicy.toPlan(policy, at));
+			const dependencies = {
+				refresh: refreshedAt(remote.refresh, plan.requirements, plan.queries.map((query) => query.identity)),
+				requirements: plan.requirements,
+				queries: plan.queries.map(({ identity, window, select }) => ({
 					identity,
 					window,
 					select
 				})),
-				expires: planned.expires
+				expires: plan.expires
 			};
+			if (byAsked === void 0) {
+				byAsked = /* @__PURE__ */ new Map();
+				planned.set(remote, byAsked);
+			}
+			byAsked.set(askedKey, {
+				until: plan.expires?.at ?? Infinity,
+				dependencies
+			});
+			return dependencies;
 		},
 		dependenciesToStream: ({ requirements, queries, refresh, expires }) => Stream.concat(Stream.fromIterable([...requirements.length === 0 ? [] : [toMessage({
 			_tag: "ReadStarted",
@@ -3762,11 +4099,12 @@ const observeEntry = (bound, askedOf, toMessage, options) => {
 		})))))
 	};
 };
+const resumeCursor = Schema.Number.pipe(Schema.overrideToEquivalence(() => () => true));
 /** The live entry: subscribes to `requirementsOf(model)` from the Model's resume cursor. */
 const liveEntry = (bound, requirementsOf, toMessage, options) => ({
 	dependenciesSchema: Schema.Struct({
 		requirements: Schema.Array(ReadRequest),
-		cursor: Schema.Number,
+		cursor: resumeCursor,
 		floor: Schema.Number
 	}),
 	modelToDependencies: (model) => {
@@ -3788,7 +4126,7 @@ const liveEntry = (bound, requirementsOf, toMessage, options) => ({
 		_tag: "LiveReceived",
 		stream: liveStreamKey(requirements),
 		event,
-		now: (options.now ?? Date.now)()
+		now: (options.now ?? wallClock)()
 	})), Stream.catchIf((_error) => true, (error) => Stream.succeed(toMessage({
 		_tag: "ReadFailed",
 		requests: requirements,
@@ -3796,8 +4134,8 @@ const liveEntry = (bound, requirementsOf, toMessage, options) => ({
 		stream: liveStreamKey(requirements)
 	}))))
 });
-/** The projection an active Surface has for this Model, if it is active. */
-const projectionOf = (entry, model) => "projectionOf" in entry ? entry.projectionOf(model) : entry.projection();
+/** The projection an active Surface has for this Model; none while it is inactive. */
+const projectionOf = (entry, model) => "projectionOf" in entry ? entry.projectionOf(model) : Option.some(entry.projection());
 /**
 * `projectionOf` computed once per Model: the read, live, and retain entries
 * all derive their dependencies from the same projection on the same Model
@@ -3809,7 +4147,8 @@ const memoizedProjectionOf = (entry) => {
 	return (model) => {
 		const key = model;
 		if (typeof key !== "object" || key === null) return projectionOf(entry, model);
-		if (cache.has(key)) return cache.get(key);
+		const known = cache.get(key);
+		if (known !== void 0) return known;
 		const projection = projectionOf(entry, model);
 		cache.set(key, projection);
 		return projection;
@@ -3860,7 +4199,6 @@ const Remote = {
 	fold: (domain, toParentMessage) => {
 		const fold = (model, message) => ({ model: domain.reduce(model, message) });
 		return Object.assign(fold, {
-			fetch: (ref) => mapMessage(domain.fetch(ref), toParentMessage),
 			mutate: (...args) => {
 				const started = domain.mutate(...args);
 				return {
@@ -3925,6 +4263,7 @@ const Remote = {
 		const selection = selectionOf(given);
 		assertRegistered(bound, "Entity", bound.definition.registry.entities, selection.entity);
 		const relation = relationOf(selection);
+		const relationKey = stableStringify(relation);
 		return (id) => ({
 			Model: remoteDataSchema(selection.schema),
 			dependencies: [],
@@ -3935,11 +4274,11 @@ const Remote = {
 			read: (root) => {
 				const store = storeOf(bound, root);
 				const key = entityKey(selection.entity, id);
-				const present = memoRead(store, store, `${key}\u0000${stableStringify(relation)}`, () => {
+				const present = memoRead([store], `${key}\u0000${relationKey}`, () => {
 					if (isTombstone(store, key)) return { _tag: "NotFound" };
 					const assembled = assemble(store, key, relation);
 					if (assembled === void 0) return unavailableFailure(store, key, relation);
-					const decoded = Schema.decodeUnknownResult(selection.schema)(assembled.values);
+					const decoded = decodeRow(selection.schema, store[key].values, assembled.values);
 					return Result.isFailure(decoded) ? {
 						_tag: "Failed",
 						error: {
@@ -3962,14 +4301,36 @@ const Remote = {
 					previous: present.value
 				} : present;
 				if (isLoadingThrough(remote, selection.entity, id, relation)) return { _tag: "Loading" };
-				return failure === void 0 ? { _tag: "Initial" } : {
+				if (failure !== void 0) return {
 					_tag: "Failed",
 					error: failure
 				};
+				if (onlyOverlaid(remote, selection.entity, id)) {
+					const lacking = missingFields(store, key, relation.fields);
+					return {
+						_tag: "Failed",
+						error: {
+							_tag: "Overlaid",
+							message: `${selection.entity} ${id} is shown only by an overlay, which does not hold ${lacking.length === 0 ? "what its relations select" : lacking.join(", ")}; the server has not seen it, so nothing will fetch them.`
+						}
+					};
+				}
+				return { _tag: "Initial" };
 			}
 		});
 	},
 	/**
+	* When what a projection shows was last received, and whether it is stale
+	* or loading. Pure, so a view can show "updated 5s ago" without I/O.
+	*
+	* `updatedAt` is the newest server write among what is shown, as the
+	* store dates it; `undefined` when nothing shown was received (nothing
+	* loaded, or only an optimistic preview). `stale` is any shown field or
+	* connection marked stale; `loading` is any of them in flight. Optimistic
+	* previews do not date: showing only one reads `updatedAt: undefined`.
+	*/
+	meta: (bound, model, projection) => metaOf(bound.store.get(model), askedOf(projection)),
+	/**
 	* The pure plan for a projection against a Model: the requirements its
 	* remote store does not satisfy, under `options` (freshness, force). A
 	* Surface's projection is `surface.projection(params)`.
@@ -4000,7 +4361,7 @@ const Remote = {
 	*/
 	prefetch: Effect.fn("Remote.prefetch")(function* (bound, model, projection, options = {}) {
 		const store = storeOf(bound, model);
-		const { policy = RemotePolicy.cacheFirst, now = Date.now } = options;
+		const { policy = RemotePolicy.cacheFirst, now = wallClock } = options;
 		const at = now();
 		const missing = plan(store, requirementsOf(projection), RemotePolicy.toPlan(policy, at));
 		if (missing.length === 0) return store;
@@ -4119,18 +4480,21 @@ const Remote = {
 	/**
 	* Runs a `Query` through `RemoteClient`, encoding its input from the ref.
 	* Pair the result with `Remote.queryMessage` to merge the page into the Model.
+	* With `select`, the server also returns the selected fields of the page's
+	* items, so one response populates both the connection and the store.
 	*/
-	query: Effect.fn("Remote.query")(function* (ref) {
+	query: Effect.fn("Remote.query")(function* (ref, select) {
 		const client = yield* RemoteClient;
 		const input = yield* Schema.encodeUnknownEffect(ref.Input)(ref.input).pipe(Effect.catchTag("SchemaError", (error) => Effect.fail(new RemoteQueryError({ message: error.message }))));
 		return yield* client.query({
 			query: ref.query,
 			input,
-			window: ref.window
+			window: ref.window,
+			...select === void 0 ? {} : { select }
 		});
 	}),
 	/** The `RemoteMessage` that merges a query page into its connection. */
-	queryMessage: (ref, result) => pageMessage(ref.identity, result, false, ref.window),
+	queryMessage: (ref, result, select, now) => pageMessage(ref.identity, result, false, ref.window, select, now),
 	/**
 	* The edges a connection shows: its server-known region with pending and
 	* confirmed overlays placed around it, minus removed edges and edges whose
@@ -4169,7 +4533,8 @@ const Remote = {
 			requestId,
 			entities: outcome.entities,
 			connections: outcome.connections,
-			deleted: outcome.deleted
+			deleted: outcome.deleted,
+			now: (options.now ?? wallClock)()
 		});
 		return {
 			output: outcome.output,
@@ -4196,9 +4561,20 @@ const Remote = {
 	live: (bound, surface, params, toMessage = identityMessage, options = {}) => liveEntry(bound, () => requirementsOf(surface.projection(params)), toMessage, options)
 };
 const brandEntries = (entries) => Subscription.make()(() => entries);
+/** Why a read failed, in words: Remote's own failures say what to do, and a server's error says itself. */
+const failedReadWords = (error) => {
+	switch (error._tag) {
+		case "DecodeError": return `What the server sent does not decode against the Selection: ${error.message}`;
+		case "Unavailable": return `${error.message} Select without it, or Data.refresh asks again.`;
+		case "Overlaid": return `${error.message} Overlay every field the Selection reads, or select fewer.`;
+		default: return `Its request failed: ${error.message}. Nothing retries a failed read on its own; Data.refresh asks again.`;
+	}
+};
 /** The bound domain: the descriptor, the binding, and the operations over them. */
 const bindDomain = (definition, store) => {
 	const bound = bindRemote(definition, store);
+	const readers = /* @__PURE__ */ new Map();
+	const keptConnections = /* @__PURE__ */ new Set();
 	/**
 	* What to do with a row a live event says was inserted into a connection.
 	*
@@ -4239,7 +4615,12 @@ const bindDomain = (definition, store) => {
 			...live,
 			policy: livePolicyFor(model, live.event)
 		};
-		return store.set(model, updateRemote(store.get(model), resolved));
+		const remote = store.get(model);
+		const next = updateRemote(remote, resolved);
+		return next === remote ? model : store.set(model, next);
+	};
+	const assertOwned = (entry) => {
+		if (bound.contract.owner !== void 0 && entry.owner !== bound.contract.owner) throw new Error(`Remote: Surface "${entry.name}" belongs to another application than domain "${bound.contract.name}"`);
 	};
 	const domain = {
 		...definition,
@@ -4255,23 +4636,30 @@ const bindDomain = (definition, store) => {
 				})))
 			};
 		},
+		active: (name, projectionOf) => {
+			const { owner } = bound.contract;
+			if (owner === void 0) throw new Error(`Remote: "${name}" reads domain "${bound.contract.name}", whose Model field is a raw optic that names no application; make the domain from an application's field (App.model.remote) to give it reads`);
+			return {
+				name,
+				owner,
+				messages: [],
+				projectionOf
+			};
+		},
 		subscriptions: (active, options = {}) => {
 			const entries = {};
-			const projections = [];
+			for (const entry of Object.values(active)) assertOwned(entry);
 			for (const [key, entry] of Object.entries(active)) {
-				if (bound.contract.owner !== void 0 && entry.owner !== bound.contract.owner) throw new Error(`Remote: Surface "${entry.name}" belongs to another application than domain "${bound.contract.name}"`);
-				const projectionAt = memoizedProjectionOf(entry);
-				projections.push(projectionAt);
-				const asked = (model) => askedOf(projectionAt(model));
+				const projectionAt = readers.get(entry) ?? memoizedProjectionOf(entry);
+				readers.set(entry, projectionAt);
+				const asked = (model) => askedWhile(projectionAt(model));
 				entries[`${key}.read`] = observeEntry(bound, asked, identityMessage, options);
 				entries[`${key}.live`] = liveEntry(bound, (model) => asked(model).requirements.filter((requirement) => requirement.live === true), identityMessage, options);
 			}
+			for (const identity of options.connections ?? []) keptConnections.add(connectionIdentity(identity));
 			entries.retain = {
 				dependenciesSchema: retentionRootsSchema,
-				modelToDependencies: (model) => rootsOf(projections.flatMap((projectionAt) => {
-					const projection = projectionAt(model);
-					return projection === void 0 ? [] : [projection];
-				}), options),
+				modelToDependencies: (model) => rootsOf([...readers.values()].flatMap((projectionAt) => Option.toArray(projectionAt(model))), { connections: [...keptConnections] }),
 				dependenciesToStream: (current) => Stream.fromEffect(Effect.succeed({
 					_tag: "RetentionChanged",
 					roots: current
@@ -4281,16 +4669,17 @@ const bindDomain = (definition, store) => {
 			return entries;
 		},
 		plan: (model, projection, options) => Remote.plan(bound, model, projection, options),
+		meta: (model, projection) => Remote.meta(bound, model, projection),
 		storeOf: (model) => storeOf(bound, model),
 		confirmed: (projection) => confirmed(bound, projection),
 		prefetch: (model, projection, options = {}) => Effect.gen(function* () {
-			const { policy = RemotePolicy.cacheFirst, now = Date.now } = options;
+			const { policy = RemotePolicy.cacheFirst, now = wallClock } = options;
 			const client = yield* RemoteClient;
 			const planOptions = RemotePolicy.toPlan(policy, now());
 			let current = model;
 			for (const query of planAsked(store.get(current), askedOf(projection), planOptions).queries) {
 				const page = yield* queryRequestOf(query).pipe(Effect.flatMap((request) => client.query(request)));
-				current = reduce(current, pageMessage(query.identity, page, true, query.window));
+				current = reduce(current, pageMessage(query.identity, page, true, query.window, query.select, now()));
 			}
 			const requirements = planAsked(store.get(current), askedOf(projection), planOptions).requirements;
 			if (requirements.length === 0) return current;
@@ -4306,6 +4695,30 @@ const bindDomain = (definition, store) => {
 				now: at
 			});
 		}),
+		satisfy: (model, active, options = {}) => Effect.gen(function* () {
+			const { passes = 8, now = wallClock } = options;
+			const entries = Object.values(active);
+			entries.forEach(assertOwned);
+			const planOptions = RemotePolicy.toPlan(RemotePolicy.cacheFirst, now());
+			const plans = (current, entry) => {
+				const planned = planAsked(store.get(current), askedWhile(projectionOf(entry, current)), planOptions);
+				return planned.queries.length > 0 || planned.requirements.length > 0;
+			};
+			let current = model;
+			for (let pass = 0; pass < passes; pass++) {
+				if (!entries.some((entry) => plans(current, entry))) return current;
+				for (const entry of entries) {
+					const projection = projectionOf(entry, current);
+					if (Option.isSome(projection)) current = yield* domain.prefetch(current, projection.value, { now });
+				}
+			}
+			const reading = entries.filter((entry) => plans(current, entry));
+			if (reading.length === 0) return current;
+			return yield* new RemoteUnsatisfied({
+				surfaces: reading.map((entry) => entry.name),
+				passes
+			});
+		}),
 		query: (query, input, options) => {
 			assertRegistered(bound, "Query", definition.registry.queries, query.name);
 			const { select: given, ...window } = options;
@@ -4314,15 +4727,13 @@ const bindDomain = (definition, store) => {
 			const listed = query.Result.entity;
 			if (listed === void 0) throw new Error(`Remote: query "${query.name}" is not a connection over an entity, so it has no page to select`);
 			if (select.entity !== listed) throw new Error(`Remote: the selection is of "${select.entity}", but query "${query.name}" lists "${listed}"`);
-			const ref = {
-				...query.ref(input),
-				window: pickWindow(window)
-			};
-			const relation = relationOf(select);
+			const { ref, relation, requirement } = readContract(query.ref(input), select, window);
 			const relationKey = stableStringify(relation);
+			const sizeOf = (remote) => windowSize(remote, ref);
+			const shown = (remote, connection) => cutToWindow(visibleItems(connection, ref.identity, remote.optimistic.overlays, remote.entities), ref.window, sizeOf(remote));
 			const failedItem = (remote, connection) => {
 				if (Object.keys(remote.failures.fields).length === 0) return void 0;
-				for (const edge of visibleItems(connection, ref.identity, remote.optimistic.overlays, remote.entities)) {
+				for (const edge of shown(remote, connection).edges) {
 					if (edge.ref.entity !== relation.entity) continue;
 					const error = failureOf(remote, edge.ref.entity, edge.ref.id, relation);
 					if (error !== void 0) return {
@@ -4333,22 +4744,26 @@ const bindDomain = (definition, store) => {
 			};
 			const loadingItem = (remote, connection) => {
 				if (remote.loading.size === 0) return void 0;
-				for (const edge of visibleItems(connection, ref.identity, remote.optimistic.overlays, remote.entities)) {
+				for (const edge of shown(remote, connection).edges) {
 					if (edge.ref.entity !== relation.entity) continue;
 					if (isLoadingThrough(remote, edge.ref.entity, edge.ref.id, relation)) return { _tag: "Loading" };
 				}
 			};
 			const readPage = (remote, connection) => {
 				const visible = visibleStoreOf(remote.entities, remote.optimistic);
-				return memoRead(visible, connection, `${ref.identity}\u0000${relationKey}`, () => {
+				return memoRead([
+					visible,
+					connection,
+					remote.optimistic.overlays
+				], `${ref.identity}\u0000${relationKey}\u0000${String(sizeOf(remote))}`, () => {
 					const items = [];
 					let refreshing = connection.stale;
-					const edges = visibleItems(connection, ref.identity, remote.optimistic.overlays, remote.entities);
+					const { edges, cutBefore, cutAfter } = shown(remote, connection);
 					for (const edge of edges) {
 						const key = entityKey(edge.ref.entity, edge.ref.id);
 						const assembled = assemble(visible, key, relation);
 						if (assembled === void 0) return unavailableFailure(visible, key, relation);
-						const decoded = Schema.decodeUnknownResult(select.schema)(assembled.values);
+						const decoded = decodeRow(select.schema, visible[key].values, assembled.values);
 						if (Result.isFailure(decoded)) return {
 							_tag: "Failed",
 							error: {
@@ -4361,8 +4776,8 @@ const bindDomain = (definition, store) => {
 					}
 					const page = {
 						items,
-						hasNext: hasNext(connection),
-						hasPrevious: hasPrevious(connection)
+						hasNext: cutAfter || hasNext(connection),
+						hasPrevious: cutBefore || hasPrevious(connection)
 					};
 					return refreshing ? {
 						_tag: "Refreshing",
@@ -4373,12 +4788,6 @@ const bindDomain = (definition, store) => {
 					};
 				});
 			};
-			const requirement = {
-				identity: ref.identity,
-				window: ref.window,
-				select: relation,
-				ref
-			};
 			return {
 				Model: remoteDataSchema(pageSchema(select.schema)),
 				dependencies: [],
@@ -4414,7 +4823,9 @@ const bindDomain = (definition, store) => {
 							previous: read.value
 						};
 						case "Failed": return read;
-						default: return {
+						case "Initial":
+						case "Loading":
+						case "NotFound": return {
 							_tag: "Failed",
 							error: failure
 						};
@@ -4422,32 +4833,23 @@ const bindDomain = (definition, store) => {
 				}
 			};
 		},
-		next: (model, projection) => {
-			const segments = store.get(model).connections[projection.ref.identity]?.segments ?? [];
-			const end = segments[segments.length - 1]?.end;
-			return end?._tag === "Cursor" ? {
-				...projection.ref,
-				window: {
-					...pageSize(projection.ref.window, "first"),
-					after: end.cursor
-				}
-			} : void 0;
-		},
-		previous: (model, projection) => {
-			const start = store.get(model).connections[projection.ref.identity]?.segments[0]?.start;
-			return start?._tag === "Cursor" ? {
-				...projection.ref,
-				window: {
-					...pageSize(projection.ref.window, "last"),
-					before: start.cursor
-				}
-			} : void 0;
+		more: (model, projection) => {
+			const remote = store.get(model);
+			const { ref } = projection;
+			const size = windowSize(remote, ref);
+			const page = ref.window.first ?? ref.window.last;
+			if (size === void 0 || page === void 0 || page === 0) return Option.none();
+			const read = projection.read(model);
+			return (read._tag === "Ready" || read._tag === "Refreshing") && (ref.window.first === void 0 ? read.value.hasPrevious : read.value.hasNext) ? Option.some(bound.store.set(model, updateRemote(remote, {
+				_tag: "WindowGrown",
+				window: windowGrowthKey(ref.identity, stableStringify(ref.window)),
+				size: size + page
+			}))) : Option.none();
 		},
 		explain: (model, projection, options) => {
 			const { ref } = projection;
 			const reading = Object.values(options?.surfaces ?? {}).filter((active) => {
-				const active_ = active.projectionOf(model);
-				return active_ !== void 0 && connectionsOf(active_).some((connection) => connection.identity === ref.identity);
+				return Option.exists(active.projectionOf(model), (shown) => connectionsOf(shown).some((connection) => connection.identity === ref.identity));
 			});
 			const body = definition.registry.queries.get(ref.query)?.body;
 			const [connection] = RemoteConnections.get(projection.metadata);
@@ -4476,8 +4878,7 @@ const bindDomain = (definition, store) => {
 			const state = projection.read(model);
 			const asked = askedOf(projection);
 			const reading = options?.surfaces === void 0 ? void 0 : Object.values(options.surfaces).filter((active) => {
-				const shown = active.projectionOf(model);
-				return shown !== void 0 && covers(askedOf(shown), asked);
+				return Option.exists(active.projectionOf(model), (shown) => covers(askedOf(shown), asked));
 			}).map((active) => active.name);
 			const withSurfaces = reading === void 0 ? {} : { surfaces: reading };
 			switch (state._tag) {
@@ -4503,7 +4904,7 @@ const bindDomain = (definition, store) => {
 				};
 				case "Failed": return {
 					state: state._tag,
-					message: state.error._tag === "DecodeError" ? `What the server sent does not decode against the Selection: ${state.error.message}` : state.error._tag === "Unavailable" ? `${state.error.message} Select without it, or Data.refresh asks again.` : `Its request failed: ${state.error.message}. Nothing retries a failed read on its own; Data.refresh asks again.`,
+					message: failedReadWords(state.error),
 					...withSurfaces
 				};
 				case "Initial":
@@ -4543,7 +4944,7 @@ const bindDomain = (definition, store) => {
 					assembledAll = false;
 					continue;
 				}
-				const decoded = Schema.decodeUnknownResult(over.selection.schema)(assembled.values);
+				const decoded = decodeRow(over.selection.schema, visible[key].values, assembled.values);
 				if (Result.isFailure(decoded)) {
 					assembledAll = false;
 					continue;
@@ -4557,33 +4958,14 @@ const bindDomain = (definition, store) => {
 		},
 		refresh: (model, target) => Remote.refresh(bound, model, target),
 		forget: (model) => Remote.forget(bound, model),
-		overlay: (model, id, optimistic) => bound.store.set(model, updateRemote(bound.store.get(model), {
+		overlay: (model, id, optimistic) => reduce(model, {
 			_tag: "OverlayShown",
 			id,
 			optimistic
-		})),
-		lift: (model, id) => {
-			const remote = bound.store.get(model);
-			const lifted = updateRemote(remote, {
-				_tag: "OverlayLifted",
-				id
-			});
-			return lifted === remote ? model : bound.store.set(model, lifted);
-		},
-		fetch: (ref) => ({
-			name: `Remote.query(${ref.query})`,
-			args: {
-				connection: ref.identity,
-				window: ref.window
-			},
-			effect: Remote.query(ref).pipe(Effect.match({
-				onFailure: (error) => ({
-					_tag: "QueryFailed",
-					connection: ref.identity,
-					error: remoteError(error)
-				}),
-				onSuccess: (page) => pageMessage(ref.identity, page, false, ref.window)
-			}))
+		}),
+		lift: (model, id) => reduce(model, {
+			_tag: "OverlayLifted",
+			id
 		}),
 		mutate: (model, mutation, input, options = {}) => {
 			assertRegistered(bound, "Mutation", definition.registry.mutations, mutation.name);
@@ -4617,7 +4999,8 @@ const bindDomain = (definition, store) => {
 							requestId,
 							entities: outcome.entities,
 							connections: outcome.connections,
-							deleted: outcome.deleted
+							deleted: outcome.deleted,
+							now: (options.now ?? wallClock)()
 						})
 					}))
 				}
@@ -4637,18 +5020,41 @@ const bindDomain = (definition, store) => {
 	return domain;
 };
 /** The window keys of a `QueryOptions`, and only those, without the undefined ones. */
+/**
+* How many rows a read of `ref` shows: its window's `first` or `last`, as
+* `Data.more` has grown it. `undefined` for a window with a cursor or no size,
+* which shows whatever the connection holds.
+*/
+const windowSize = (remote, ref) => {
+	const { first, last, after, before } = ref.window;
+	if (after !== void 0 || before !== void 0) return void 0;
+	const size = first ?? last;
+	return size === void 0 ? void 0 : remote.grown[windowGrowthKey(ref.identity, stableStringify(ref.window))] ?? size;
+};
+/** The edges a window of `size` shows, from the start (`first`) or the end (`last`), and which end it cut. */
+const cutToWindow = (edges, window, size) => {
+	if (size === void 0 || edges.length <= size) return {
+		edges,
+		cutBefore: false,
+		cutAfter: false
+	};
+	return window.first === void 0 ? {
+		edges: edges.slice(edges.length - size),
+		cutBefore: true,
+		cutAfter: false
+	} : {
+		edges: edges.slice(0, size),
+		cutBefore: false,
+		cutAfter: true
+	};
+};
 const pickWindow = (window) => ({
 	...window.first === void 0 ? {} : { first: window.first },
 	...window.last === void 0 ? {} : { last: window.last },
 	...window.after === void 0 ? {} : { after: window.after },
 	...window.before === void 0 ? {} : { before: window.before }
 });
-/** The page size of a window, carried onto the next or previous page's window under `key`. */
-const pageSize = (window, key) => {
-	const size = window.first ?? window.last;
-	return size === void 0 ? {} : { [key]: size };
-};
 //#endregion
-export { ConnectionChange, ConnectionChangeSchema, Entity, IDENTITY_SEPARATOR, Live, LiveChange, LiveEdge, LiveRequirement, MAX_FIELDS_PER_REQUEST, MAX_RELATION_DEPTH, Mutate, Mutation, MutationRequest, MutationResult, NormalizedEntity, PageSize, Query, QueryEdge, QueryRequest, QueryResult, QueryRpc, RELATION_ALIAS, REMOTE_CACHE_VERSION, REMOTE_PROTOCOL_VERSION, Read, ReadBatch, ReadBatchResult, ReadRequest, RelationAnnotation, RelationEntityAnnotation, RelationRequest, Remote, RemoteClient, RemoteConnections, RemoteData, RemoteLiveError, RemoteMutationError, RemotePersistence, RemotePolicy, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteRequirements, RemoteRpc, Requirement, Selection, SettledFields, WindowSchema, WireBoundary, addLayer, addOverlay, aliasedField, applyConnectionEvent, applyEntityEvent, assemble, beginMutation, beginOptimistic, belongsEncoded, classifyLive, clearStale, coalesceQueries, coalesceReads, coalescedLayer, connectionChangeOf, connectionIdentity, connectionsOf, cursor, deadlineOf, edge, emptyConnection, emptyLiveState, emptyMutationState, emptyOptimistic, emptyRefresh, emptyStore, entityKey, entry, failMutation, failureOf, forgetRemote, gc, hasField, hasNext, hasPrevious, initialRemoteModel, inspectEntity, inspectRemote, isFieldFailed, isFieldStale, isFieldUnavailable, isGapped, isLoading, isLoadingThrough, isQueryLoading, isRefPage, isRemoteMessage, isTombstone, items, liveEventOf, liveHasNext, liveHasPrevious, markStale, matching, merge, missingFields, mutateRemote, mutationStatus, noFailures, pageSchema, plan, pruneOverlays, reachable, readField, reconcileMutation, refParts, refreshIsInFlight, refreshedAt, refsIn, relationAlias, relationOf, relationShape, remoteDataSchema, remoteError, remoteErrorSchema, remoteMessageCases, remoteMessageSchema, remoteModelSchema, remove, removeLayer, removeOverlay, requirementKey, requirementsOf, retentionRootsSchema, schemaOf, segment, setStale, setUnavailable, settleFailure, settleSuccess, shouldWake, stableStringify, targetsOf, terminal, tombstone, unavailableOf, unknown, updateRemote, visibleItems, visibleStore, windowKey, withRefreshRequested, writeEntities, writeEntity, writeRead };
+export { ConnectionChange, ConnectionChangeSchema, Entity, IDENTITY_SEPARATOR, Live, LiveChange, LiveEdge, LiveRequirement, MAX_FIELDS_PER_REQUEST, MAX_RELATION_DEPTH, Mutate, Mutation, MutationRequest, MutationResult, NormalizedEntity, PageSize, Query, QueryEdge, QueryRequest, QueryResult, QueryRpc, RELATION_ALIAS, REMOTE_CACHE_VERSION, REMOTE_PROTOCOL_VERSION, Read, ReadBatch, ReadBatchResult, ReadRequest, RelationAnnotation, RelationEntityAnnotation, RelationRequest, Remote, RemoteClient, RemoteConnections, RemoteData, RemoteLiveError, RemoteMutationError, RemotePersistence, RemotePolicy, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteRequirements, RemoteRpc, RemoteUnsatisfied, Requirement, Selection, SettledFields, WindowSchema, WireBoundary, addLayer, addOverlay, aliasedField, applyConnectionEvent, applyEntityEvent, assemble, beginMutation, beginOptimistic, belongsEncoded, classifyLive, clearStale, coalesceQueries, coalesceReads, coalescedLayer, connectionChangeOf, connectionIdentity, connectionsOf, cursor, deadlineOf, edge, emptyConnection, emptyLiveState, emptyMutationState, emptyOptimistic, emptyRefresh, emptyStore, entityKey, entry, failMutation, failureOf, forgetRemote, gc, hasField, hasNext, hasPrevious, initialRemoteModel, inspectEntity, inspectRemote, isFieldFailed, isFieldStale, isFieldUnavailable, isGapped, isLoading, isLoadingThrough, isQueryLoading, isRefPage, isRemoteMessage, isTombstone, items, liveEventOf, liveHasNext, liveHasPrevious, markStale, matching, merge, missingFields, mutateRemote, mutationStatus, noFailures, onlyOverlaid, pageSchema, plan, pruneOverlays, reachable, readField, reconcileMutation, refParts, refreshIsInFlight, refreshedAt, refsIn, relationAlias, relationOf, relationShape, remoteDataSchema, remoteError, remoteErrorSchema, remoteMessageCases, remoteMessageSchema, remoteModelSchema, remove, removeLayer, removeOverlay, requirementKey, requirementsOf, retentionRootsSchema, schemaOf, segment, setStale, setUnavailable, settleFailure, settleSuccess, stableStringify, targetsOf, terminal, tombstone, unavailableOf, unknown, updateRemote, visibleItems, visibleStore, windowGrowthKey, windowKey, withRefreshRequested, writeEntities, writeEntity, writeRead };
 
 //# sourceMappingURL=index.mjs.map