foldkit-remote 0.7.0 → 0.9.0

package/dist/index.mjs

@@ -1,6 +1,8 @@
-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";
 import { Metadata } from "foldkit-surface";
 import { Rpc, RpcGroup } from "effect/unstable/rpc";
@@ -108,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. */
@@ -174,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",
@@ -183,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;
 		}
@@ -199,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}`;
@@ -208,6 +233,7 @@ const emptyEntry = {
 	values: {},
 	present: /* @__PURE__ */ new Set(),
 	stale: /* @__PURE__ */ new Set(),
+	unavailable: /* @__PURE__ */ new Set(),
 	tombstone: false,
 	updatedAt: 0,
 	windows: {}
@@ -220,10 +246,12 @@ const replace = (store, key, entry) => ({
 const written = (previous, values, now, windows) => {
 	const present = new Set(previous.present);
 	const stale = new Set(previous.stale);
+	const unavailable = new Set(previous.unavailable);
 	const nextWindows = { ...previous.windows };
 	for (const field of Object.keys(values)) {
 		present.add(field);
 		stale.delete(field);
+		unavailable.delete(field);
 		const requested = windows?.[field];
 		if (requested !== void 0 && requested !== "") nextWindows[field] = requested;
 		else delete nextWindows[field];
@@ -232,12 +260,13 @@ 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
 		},
 		present,
 		stale,
+		unavailable,
 		tombstone: false,
 		updatedAt: now,
 		windows: nextWindows
@@ -251,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. */
@@ -287,11 +316,40 @@ const setStale = (store, marks, stale) => {
 const markStale = (store, key, fields) => setStale(store, [[key, fields]], true);
 /** Ends a refresh that did not land: the fields are present again as they were. */
 const clearStale = (store, key, fields) => setStale(store, [[key, fields]], false);
+/**
+* Records fields the server settled without a value. A present field is left
+* as it is: the answer that settled it was not about the value it holds.
+* `false` forgets the marks, which is how a refresh asks again.
+*/
+const setUnavailable = (store, marks, unavailable) => {
+	let next;
+	for (const [key, fields] of marks) {
+		const previous = (next ?? store)[key] ?? emptyEntry;
+		if (previous.tombstone) continue;
+		const marked = new Set(previous.unavailable);
+		for (const field of fields) if (unavailable) {
+			if (!previous.present.has(field)) marked.add(field);
+		} else marked.delete(field);
+		if (marked.size === previous.unavailable.size) continue;
+		next ??= { ...store };
+		next[key] = {
+			...previous,
+			unavailable: marked
+		};
+	}
+	return next ?? store;
+};
+/** Whether the server settled this field without a value, and nothing has written it since. */
+const isFieldUnavailable = (store, key, field) => {
+	const value = store[key];
+	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(),
+	unavailable: /* @__PURE__ */ new Set(),
 	tombstone: true,
 	updatedAt: 0,
 	windows: {}
@@ -329,7 +387,8 @@ const readField = (store, key, field) => {
 };
 /**
 * The fields the planner must fetch. A tombstone makes every field known
-* (absent), so it returns an empty list and the entity is not refetched. A
+* (absent), so it returns an empty list and the entity is not refetched, and a
+* field the server settled without a value is known the same way. A
 * requested window that differs from the one a field was fetched with also
 * marks it missing, but only when the stored window is known (never `""`), so a
 * writer that does not record windows cannot cause a refetch loop.
@@ -338,7 +397,9 @@ const missingFields = (store, key, fields, windows) => {
 	const value = store[key];
 	if (value !== void 0 && value.tombstone) return [];
 	return [...fields].filter((field) => {
-		if (value === void 0 || !value.present.has(field) || value.stale.has(field)) return true;
+		if (value === void 0) return true;
+		if (!value.present.has(field)) return !value.unavailable.has(field);
+		if (value.stale.has(field)) return true;
 		const requested = windows?.[field];
 		const stored = value.windows[field];
 		return requested !== void 0 && stored !== void 0 && stored !== "" && stored !== requested;
@@ -407,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);
@@ -588,7 +652,7 @@ const Query = {
 * server refuses a mismatch with `RemoteProtocolError`, so a shape change never
 * drifts silently: bump it whenever `ReadRequest` or `LiveRequirement` change.
 */
-const REMOTE_PROTOCOL_VERSION = 3;
+const REMOTE_PROTOCOL_VERSION = 4;
 var RemoteReadError = class extends Schema.TaggedError()("RemoteReadError", { message: Schema.String }) {};
 var RemoteMutationError = class extends Schema.TaggedError()("RemoteMutationError", { message: Schema.String }) {};
 var RemoteLiveError = class extends Schema.TaggedError()("RemoteLiveError", { message: Schema.String }) {};
@@ -649,7 +713,20 @@ const NormalizedEntity = Schema.Struct({
 	id: Schema.String,
 	values: Schema.Record(Schema.String, Schema.Unknown)
 });
-const ReadBatchResult = Schema.Struct({ entities: Schema.Array(NormalizedEntity) });
+/**
+* Fields a read asked for that the server answered without, and will not
+* answer with: the client stops asking. It says nothing about why, so a rule
+* that withholds a field is not itself on the wire.
+*/
+const SettledFields = Schema.Struct({
+	entity: Schema.String,
+	id: Schema.String,
+	fields: Schema.Array(Schema.String)
+});
+const ReadBatchResult = Schema.Struct({
+	entities: Schema.Array(NormalizedEntity),
+	settled: Schema.Array(SettledFields)
+});
 const MutationRequest = Schema.Struct({
 	/** Stable across transport retries so a mutation is not applied twice. */
 	requestId: Schema.String,
@@ -755,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,
@@ -765,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,
@@ -833,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);
@@ -867,7 +958,7 @@ const coalesceReads = (read, options = {}) => Effect.gen(function* () {
 			for (const entry of entries) if (own.has(entry.request.key)) owned.set(entry.request.key, entry.request.requirement);
 			yield* Effect.forEach(readsOf(owned), ({ keys, requests }) => Effect.gen(function* () {
 				const exit = yield* Effect.exit(read({
-					version: 3,
+					version: 4,
 					requests
 				}));
 				for (const key of keys) {
@@ -883,10 +974,19 @@ const coalesceReads = (read, options = {}) => Effect.gen(function* () {
 	});
 	let resolver = RequestResolver.make(runAll);
 	if (options.window !== void 0) resolver = RequestResolver.setDelay(resolver, Duration.fromInputUnsafe(options.window));
-	return (batch) => batch.requests.length === 0 ? Effect.succeed({ entities: [] }) : Effect.forEach(batch.requests, (requirement) => Effect.request(new ReadRequirement({
+	return (batch) => batch.requests.length === 0 ? Effect.succeed({
+		entities: [],
+		settled: []
+	}) : Effect.forEach(batch.requests, (requirement) => Effect.request(new ReadRequirement({
 		key: requirementKey(requirement),
 		requirement
-	}), resolver), { concurrency: "unbounded" }).pipe(Effect.map((results) => ({ entities: [...new Set(results)].flatMap((result) => result.entities) })));
+	}), resolver), { concurrency: "unbounded" }).pipe(Effect.map((results) => {
+		const distinct = [...new Set(results)];
+		return {
+			entities: distinct.flatMap((result) => result.entities),
+			settled: distinct.flatMap((result) => result.settled)
+		};
+	}));
 });
 //#endregion
 //#region src/client.ts
@@ -1302,6 +1402,24 @@ const assemble = (store, key, requirement) => {
 		refreshing
 	};
 };
+/**
+* The first field `requirement` reads, at any depth, that the server settled
+* without a value, as `Entity:id.field`. A read that consults it says why it
+* cannot assemble rather than waiting on a field nothing will fetch.
+*/
+const unavailableOf = (store, key, requirement) => {
+	for (const field of requirement.fields) {
+		if (isFieldUnavailable(store, key, field)) return `${key}.${field}`;
+		const relation = requirement.relations?.[field];
+		if (relation === void 0) continue;
+		const value = readField(store, key, field);
+		if (Option.isNone(value) || value.value === null || value.value === void 0) continue;
+		for (const ref of targetsOf(value.value, relation)) {
+			const found = unavailableOf(store, entityKey(ref.entity, ref.id), relation);
+			if (found !== void 0) return found;
+		}
+	}
+};
 const assembleTarget = (store, ref, relation) => {
 	const key = entityKey(ref.entity, ref.id);
 	return isTombstone(store, key) ? "absent" : assemble(store, key, relation);
@@ -1545,6 +1663,7 @@ const inspectEntry = (key, entry) => ({
 	key,
 	present: [...entry.present],
 	stale: [...entry.stale],
+	unavailable: [...entry.unavailable],
 	tombstone: entry.tombstone,
 	updatedAt: entry.updatedAt,
 	windows: { ...entry.windows }
@@ -1615,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)]
 	};
 };
 /**
@@ -1629,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,
@@ -1649,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);
 /**
@@ -1687,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. */
@@ -1767,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 {
@@ -1789,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 = {}) => {
@@ -1878,6 +2023,44 @@ const followRelation = (value, relation) => targetsOf(value, relation).map((ref)
 	...relation,
 	id: ref.id
 }));
+/**
+* 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. 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;
+	let due = [];
+	const walk = (group) => {
+		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) || entry.unavailable.has(field))) {
+			const expires = entry.updatedAt + freshness.freshness;
+			if (expires >= freshness.now && Number.isFinite(expires)) {
+				if (at === void 0 || expires < at) {
+					at = expires;
+					due = [group];
+				} else if (expires === at) due.push(group);
+			}
+		}
+		for (const [field, relation] of Object.entries(group.relations ?? {})) {
+			const value = readField(store, key, field);
+			if (value._tag === "Some") for (const next of followRelation(value.value, relation)) walk(next);
+		}
+	};
+	for (const group of Requirement.merge(requirements)) walk(group);
+	return at === void 0 ? void 0 : {
+		at,
+		due: Requirement.merge(due)
+	};
+};
 const plan = (store, requirements, options = {}) => {
 	const { freshness, force = false } = options;
 	const planned = [];
@@ -1962,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
 /**
@@ -1989,7 +2180,7 @@ const gc = (state, roots) => {
 * application's choice.
 */
 /** Bump when the serialized shape changes; a mismatch discards the cache. */
-const REMOTE_CACHE_VERSION = 4;
+const REMOTE_CACHE_VERSION = 5;
 /**
 * A snapshot of a Model, keeping the entity cache and only the connections
 * named.
@@ -2012,13 +2203,14 @@ const sorted = (values) => [...values].sort();
 * whatever order they were built in.
 */
 const serializeStore = (snapshot, scope) => ({
-	version: 4,
+	version: 5,
 	scope: scope ?? null,
 	connections: snapshot.connections,
 	entities: Object.fromEntries(Object.entries(snapshot.entities).map(([key, entry]) => [key, {
 		values: entry.values,
 		present: sorted(entry.present),
 		stale: sorted(entry.stale),
+		unavailable: sorted(entry.unavailable),
 		tombstone: entry.tombstone,
 		updatedAt: entry.updatedAt,
 		windows: entry.windows
@@ -2033,6 +2225,7 @@ const parseEntry = (value) => {
 	if (entry.values === null || typeof entry.values !== "object" || Array.isArray(entry.values)) throw new Error("entry.values is not a record");
 	if (!isStringArray(entry.present)) throw new Error("entry.present is not a string array");
 	if (!isStringArray(entry.stale)) throw new Error("entry.stale is not a string array");
+	if (!isStringArray(entry.unavailable)) throw new Error("entry.unavailable is not a string array");
 	if (typeof entry.tombstone !== "boolean") throw new Error("entry.tombstone is not a boolean");
 	if (typeof entry.updatedAt !== "number") throw new Error("entry.updatedAt is not a number");
 	if (!isStringRecord(entry.windows)) throw new Error("entry.windows is not a string record");
@@ -2040,6 +2233,7 @@ const parseEntry = (value) => {
 		values: entry.values,
 		present: new Set(entry.present),
 		stale: new Set(entry.stale),
+		unavailable: new Set(entry.unavailable),
 		tombstone: entry.tombstone,
 		updatedAt: entry.updatedAt,
 		windows: entry.windows
@@ -2098,7 +2292,7 @@ const hydrate = (raw, options = {}) => {
 	}
 	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
 	const candidate = parsed;
-	if (candidate.version !== 4) return void 0;
+	if (candidate.version !== 5) return void 0;
 	if ((candidate.scope ?? null) !== (options.scope ?? null)) return void 0;
 	if (candidate.entities === null || typeof candidate.entities !== "object") return void 0;
 	if (Array.isArray(candidate.entities)) return void 0;
@@ -2114,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
 } : {
@@ -2275,7 +2469,9 @@ const RemoteData = {
 				error: data.error,
 				previous: f(data.previous)
 			};
-			default: return data;
+			case "Initial":
+			case "Loading":
+			case "NotFound": return data;
 		}
 	}
 };
@@ -2293,11 +2489,37 @@ const noFailures = {
 const emptyRefresh = {
 	generation: 0,
 	requested: /* @__PURE__ */ new Map(),
-	started: /* @__PURE__ */ new Map()
+	started: /* @__PURE__ */ new Map(),
+	floor: 0
+};
+/**
+* The Model with everything the server told it forgotten: values, tombstones,
+* unavailable fields, connections, live cursors, failures, and what is in
+* flight. For a change of principal, whose facts these were. The mutation
+* sequence is kept, so request ids stay unique, and a mutation in flight is
+* treated as applied: its answer, when it comes, writes nothing here.
+*/
+const forgetRemote = (model) => {
+	const generation = model.refresh.generation + 1;
+	return {
+		...initialRemoteModel,
+		refresh: {
+			generation,
+			requested: /* @__PURE__ */ new Map(),
+			started: /* @__PURE__ */ new Map(),
+			floor: generation
+		},
+		mutations: {
+			...emptyMutationState,
+			sequence: model.mutations.sequence,
+			applied: /* @__PURE__ */ new Set([...model.mutations.applied, ...model.mutations.pending])
+		}
+	};
 };
 const initialRemoteModel = {
 	entities: emptyStore,
 	connections: {},
+	grown: {},
 	optimistic: emptyOptimistic,
 	live: {},
 	mutations: emptyMutationState,
@@ -2311,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,
@@ -2367,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,
@@ -2378,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,
@@ -2388,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 },
@@ -2408,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
@@ -2423,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'
@@ -2458,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.
@@ -2487,7 +2739,7 @@ const prunedRefresh = (refresh, retained) => {
 * anything else is.
 */
 const refreshedAt = (refresh, requests, connections = []) => {
-	let at = 0;
+	let at = refresh.floor;
 	for (const mark of fieldMarks(requests)) at = Math.max(at, refresh.requested.get(mark) ?? 0);
 	for (const identity of connections) at = Math.max(at, refresh.requested.get(connectionMark(identity)) ?? 0);
 	return at;
@@ -2544,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])
@@ -2564,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,
@@ -2589,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)
@@ -2608,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)
 				} : {
@@ -2619,9 +2891,10 @@ const updateRemote = (model, message) => {
 		}
 		case "RefreshStarted": {
 			const asked = message.requests.reduce((store, request) => isTombstone(store, entityKey(request.entity, request.id)) ? remove(store, entityKey(request.entity, request.id)) : store, model.entities);
-			const entities = setStale(asked, marksOf(message.requests), true);
+			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
@@ -2646,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,
@@ -2659,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 : {
@@ -2684,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);
 			}
@@ -2696,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",
@@ -2709,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 ? {
@@ -2727,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: {
@@ -2974,12 +3257,13 @@ const writeRead = (store, requests, result, now = 0) => {
 			windows: entry?.windows
 		});
 	}
+	const settled = new Set(result.settled.map((entry) => entityKey(entry.entity, entry.id)));
 	let answered = store;
 	for (const request of requests) {
 		const key = entityKey(request.entity, request.id);
-		if (!returned.has(key)) answered = tombstone(answered, key);
+		if (!returned.has(key) && !settled.has(key)) answered = tombstone(answered, key);
 	}
-	return writeEntities(answered, writes, now);
+	return setUnavailable(writeEntities(answered, writes, now), result.settled.map((entry) => [entityKey(entry.entity, entry.id), entry.fields]), true);
 };
 //#endregion
 //#region src/policy.ts
@@ -3012,6 +3296,221 @@ const RemotePolicy = {
 	refreshes: (policy) => policy._tag !== "CacheFirst"
 };
 //#endregion
+//#region src/resume.ts
+/**
+* What of Remote's state crosses from a server render to the browser.
+*
+* A page rendered a moment ago sends exactly what its active Surfaces read:
+* for each requirement the fields it names, following relations through the
+* refs the store holds, and each connection whole, with its boundaries, so
+* "load more" knows where the server stopped. A live subscription's cursor
+* crosses with the entities it covers, so a subscription started in the
+* browser resumes where the server's left off.
+*
+* This is not a `Snapshot`, which is built for a cache that survived a reload
+* and deliberately keeps no cursors. Nothing else of `RemoteModel` crosses:
+* loading marks, failures, the mutation ledger, optimistic layers, gaps and
+* retention start from their initial values in the browser.
+*/
+const CapturedEntry = Schema.Struct({
+	values: Schema.Record(Schema.String, Schema.Unknown),
+	present: Schema.Array(Schema.String),
+	stale: Schema.Array(Schema.String),
+	unavailable: Schema.Array(Schema.String),
+	windows: Schema.Record(Schema.String, Schema.String),
+	tombstone: Schema.Boolean,
+	updatedAt: Schema.Number
+});
+const CapturedBoundary = Schema.Union([
+	Schema.TaggedStruct("Terminal", {}),
+	Schema.TaggedStruct("Cursor", { cursor: Schema.String }),
+	Schema.TaggedStruct("Unknown", {})
+]);
+const CapturedConnection = Schema.Struct({
+	segments: Schema.Array(Schema.Struct({
+		edges: Schema.Array(Schema.Struct({
+			key: Schema.String,
+			ref: Schema.Struct({
+				entity: Schema.String,
+				id: Schema.String
+			})
+		})),
+		start: CapturedBoundary,
+		end: CapturedBoundary
+	})),
+	stale: Schema.Boolean
+});
+const CapturedLive = Schema.Struct({
+	cursor: Schema.Number,
+	boundary: Schema.Record(Schema.String, Schema.Struct({
+		before: Schema.Number,
+		after: Schema.Number
+	}))
+});
+/**
+* Marks a Subscription entry Remote built as one that may start late under
+* `foldkit-ssr`'s deferred boot (its decision 10): a read with resumed data
+* plans nothing, a live subscription resumes from the cursor the envelope
+* carries, and retention running late collects late. Non-enumerable, so the
+* runtime's iteration of an entry never sees it.
+*/
+const DEFERRABLE = Symbol.for("foldkit-remote/deferrable");
+/** Marks every entry of a record Remote built, lifted or not. */
+const markAll = (entries) => {
+	for (const entry of Object.values(entries)) Object.defineProperty(entry, DEFERRABLE, {
+		value: true,
+		enumerable: false
+	});
+	return entries;
+};
+/** The captured part of a Remote store, as JSON. */
+const RemoteCapture = Schema.Struct({
+	entities: Schema.Record(Schema.String, CapturedEntry),
+	connections: Schema.Record(Schema.String, CapturedConnection),
+	live: Schema.Record(Schema.String, CapturedLive)
+});
+/** What some projections read, from their metadata. */
+const askedOf$1 = (projections) => ({
+	requirements: projections.flatMap((projection) => RemoteRequirements.get(projection.metadata)),
+	connections: projections.flatMap((projection) => RemoteConnections.get(projection.metadata))
+});
+/** Whether every `entity:id:fields` part of a live stream key was captured with those fields. */
+const liveCovered = (stream, entries) => stream.split("|").every((part) => {
+	const split = part.lastIndexOf(":");
+	const entry = entries.get(part.slice(0, split));
+	const fields = part.slice(split + 1).split(",").filter((field) => field !== "");
+	return entry !== void 0 && fields.every((field) => entry.present.has(field));
+});
+/**
+* Captures what some projections read from a store: the fields each
+* requirement names, through its relations; each connection whole, and the
+* fields its selection reads of each item; and each live cursor whose
+* entities were all captured with the fields it follows.
+*/
+const captureRemote = (remote, projections) => {
+	const store = remote.entities;
+	const entries = /* @__PURE__ */ new Map();
+	const walked = /* @__PURE__ */ new Map();
+	const walk = (entity, id, requirement) => {
+		const key = entityKey(entity, id);
+		const seen = walked.get(key) ?? /* @__PURE__ */ new Set();
+		if (seen.has(requirement)) return;
+		seen.add(requirement);
+		walked.set(key, seen);
+		const stored = store[key];
+		if (stored === void 0) return;
+		const entry = entries.get(key) ?? {
+			values: {},
+			present: /* @__PURE__ */ new Set(),
+			stale: /* @__PURE__ */ new Set(),
+			unavailable: /* @__PURE__ */ new Set(),
+			windows: {},
+			tombstone: stored.tombstone,
+			updatedAt: stored.updatedAt
+		};
+		entries.set(key, entry);
+		for (const field of requirement.fields) {
+			if (stored.unavailable.has(field)) entry.unavailable.add(field);
+			if (!stored.present.has(field)) continue;
+			entry.values[field] = stored.values[field];
+			entry.present.add(field);
+			if (stored.stale.has(field)) entry.stale.add(field);
+			const window = stored.windows[field];
+			if (window !== void 0) entry.windows[field] = window;
+			const nested = requirement.relations?.[field];
+			if (nested === void 0) continue;
+			const value = readField(store, key, field);
+			if (value._tag === "None") continue;
+			for (const ref of targetsOf(value.value, nested)) walk(ref.entity, ref.id, nested);
+		}
+	};
+	const asked = askedOf$1(projections);
+	for (const requirement of asked.requirements) walk(requirement.entity, requirement.id, requirement);
+	const connections = {};
+	for (const { identity, select } of asked.connections) {
+		const connection = remote.connections[identity];
+		if (connection === void 0) continue;
+		connections[identity] = connection;
+		for (const segment of connection.segments) for (const edge of segment.edges) walk(edge.ref.entity, edge.ref.id, select);
+	}
+	const live = {};
+	for (const [stream, state] of Object.entries(remote.live)) if (liveCovered(stream, entries)) live[stream] = state;
+	return {
+		entities: Object.fromEntries([...entries].map(([key, entry]) => [key, {
+			values: entry.values,
+			present: [...entry.present],
+			stale: [...entry.stale],
+			unavailable: [...entry.unavailable],
+			windows: entry.windows,
+			tombstone: entry.tombstone,
+			updatedAt: entry.updatedAt
+		}])),
+		connections: Object.fromEntries(Object.entries(connections).map(([identity, connection]) => [identity, {
+			segments: connection.segments.map((segment) => ({
+				edges: segment.edges.map((edge) => ({
+					key: edge.key,
+					ref: edge.ref
+				})),
+				start: segment.start,
+				end: segment.end
+			})),
+			stale: connection.stale
+		}])),
+		live
+	};
+};
+/**
+* Sets a capture onto a store: its entities, connections and live cursors
+* replace any held under the same keys, and nothing else of the store changes.
+*/
+const restoreRemote = (remote, capture) => ({
+	...remote,
+	entities: {
+		...remote.entities,
+		...Object.fromEntries(Object.entries(capture.entities).map(([key, entry]) => [key, {
+			values: entry.values,
+			present: new Set(entry.present),
+			stale: new Set(entry.stale),
+			unavailable: new Set(entry.unavailable),
+			windows: entry.windows,
+			tombstone: entry.tombstone,
+			updatedAt: entry.updatedAt
+		}]))
+	},
+	connections: {
+		...remote.connections,
+		...Object.fromEntries(Object.entries(capture.connections).map(([identity, connection]) => [identity, {
+			segments: connection.segments.map((segment) => ({
+				edges: segment.edges,
+				start: segment.start,
+				end: segment.end
+			})),
+			stale: connection.stale
+		}]))
+	},
+	live: {
+		...remote.live,
+		...capture.live
+	}
+});
+const encodeCapture = Schema.encodeSync(RemoteCapture);
+const decodeCapture = Schema.decodeUnknownResult(RemoteCapture);
+/**
+* The resume part for a Remote domain, for `SSR.plan`'s `parts`: it sends
+* what the plan's active Surfaces read from this domain's store, and nothing
+* else of it. `id` tells two domains in one application apart.
+*/
+const resumePart = (domain, options = {}) => ({
+	id: options.id ?? "remote",
+	covers: [RemoteRequirements.name, RemoteConnections.name],
+	deferrable: (_key, entry) => typeof entry === "object" && entry !== null && DEFERRABLE in entry,
+	capture: (model, projections) => encodeCapture(captureRemote(domain.store.get(model), projections)),
+	restore: (model, value) => Result.match(decodeCapture(value), {
+		onFailure: (error) => Result.fail(`Remote's state does not decode: ${error.message}`),
+		onSuccess: (capture) => Result.succeed(domain.store.set(model, restoreRemote(domain.store.get(model), capture)))
+	})
+});
+//#endregion
 //#region src/index.ts
 /**
 * `foldkit-remote` — normalized application-facing server state.
@@ -3022,6 +3521,67 @@ const RemotePolicy = {
 */
 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
@@ -3049,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) {
@@ -3061,25 +3621,87 @@ const visibleStoreOf = (entities, optimistic) => {
 	}
 	return visible;
 };
-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);
+/**
+* `Failed` naming a field the server settled without a value, when one is
+* among what `relation` reads of the entity; otherwise nothing, and the store
+* merely lacks the value. The reason stays with the server, so a view shows
+* the field it cannot have, not why.
+*/
+const unavailableFailure = (store, key, relation) => {
+	const field = unavailableOf(store, key, relation);
+	return field === void 0 ? void 0 : {
+		_tag: "Failed",
+		error: {
+			_tag: "Unavailable",
+			message: `The server answered without ${field}, and will not answer with it: the field is not available to this client.`
+		}
+	};
+};
+/**
+* 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. */
@@ -3123,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.
@@ -3157,24 +3784,88 @@ 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));
 	}
-	const planned = plan(visibleStoreOf(remote.entities, remote.optimistic), [...asked.requirements, ...items], options);
+	const visible = visibleStoreOf(remote.entities, remote.optimistic);
+	const read = [...asked.requirements, ...items];
+	const planned = plan(visible, read, options);
 	return {
 		requirements: options.force === true ? planned : withoutFailedFields(remote, planned),
-		queries
+		queries,
+		expires: options.freshness === void 0 ? null : deadlineOf(visible, read, options.freshness) ?? null
 	};
 };
 /**
@@ -3220,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` })
 	});
@@ -3249,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",
@@ -3259,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,
@@ -3273,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
+		} : {}
 	};
 };
 /**
@@ -3301,7 +4000,7 @@ const readMessage = (requirements, now) => Effect.gen(function* () {
 	const client = yield* RemoteClient;
 	const at = now();
 	const result = yield* Effect.result(client.read({
-		version: 3,
+		version: 4,
 		requests: requirements
 	}));
 	return Result.isFailure(result) ? {
@@ -3316,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({
@@ -3341,29 +4040,50 @@ 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),
 			queries: Schema.Array(PlannedQuery),
-			refresh: Schema.Number
+			refresh: Schema.Number,
+			expires: Schema.NullOr(Schema.Struct({
+				at: Schema.Number,
+				due: Schema.Array(ReadRequest)
+			}))
 		}),
 		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: 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 }) => Stream.concat(Stream.fromIterable([...requirements.length === 0 ? [] : [toMessage({
+		dependenciesToStream: ({ requirements, queries, refresh, expires }) => Stream.concat(Stream.fromIterable([...requirements.length === 0 ? [] : [toMessage({
 			_tag: "ReadStarted",
 			requests: requirements,
 			refresh
@@ -3373,21 +4093,28 @@ const observeEntry = (bound, askedOf, toMessage, options) => {
 		})] : []], ...queries.length === 0 ? [] : [toMessage({
 			_tag: "QueryStarted",
 			connections: queries.map((query) => query.identity)
-		})]]), Stream.mergeAll([...requirements.length === 0 ? [] : [Stream.fromEffect(read(requirements))], ...queries.map((query) => Stream.fromEffect(run(query)))], { concurrency: "unbounded" }))
+		})]]), Stream.merge(Stream.mergeAll([...requirements.length === 0 ? [] : [Stream.fromEffect(read(requirements))], ...queries.map((query) => Stream.fromEffect(run(query)))], { concurrency: "unbounded" }), expires === null ? Stream.empty : Stream.fromEffect(Effect.as(Effect.sleep(Math.max(0, expires.at - now())), toMessage({
+			_tag: "RefreshStarted",
+			requests: expires.due
+		})))))
 	};
 };
+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) => {
 		const requirements = requirementsOf(model);
 		const stream = liveStreamKey(requirements);
+		const remote = bound.store.get(model);
 		return {
 			requirements,
-			cursor: bound.store.get(model).live[stream]?.cursor ?? 0
+			cursor: remote.live[stream]?.cursor ?? 0,
+			floor: remote.refresh.floor
 		};
 	},
 	dependenciesToStream: ({ requirements, cursor }) => requirements.length === 0 ? Stream.empty : Stream.unwrap(Effect.gen(function* () {
@@ -3399,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,
@@ -3407,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
@@ -3420,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;
@@ -3440,6 +4168,51 @@ const Remote = {
 	/** Whether a Message is one of Remote's, by tag. */
 	reduces: isRemoteMessage,
 	/**
+	* Remote's Messages as one Schema, for a wrapper variant in the
+	* application's union: `GotRemoteMessage: { message: Remote.Message }`. With
+	* a wrapper, `update` matches the application's union exhaustively and
+	* `Remote.fold` reduces what arrives inside it.
+	*/
+	Message: defineMessageUnion(remoteMessageCases),
+	/**
+	* A bound domain under one wrapper variant of the application's union, the
+	* same shape Foldkit gives a Submodel: `toParentMessage` wraps Remote's
+	* Messages, the fold reduces them, and its `fetch`, `mutate`, and
+	* `subscriptions` yield the wrapper. Spreading `Remote.messages` and
+	* narrowing with `Remote.reduces` remains the shorter path for an
+	* application whose `update` only reduces.
+	*
+	* @example
+	* ```ts
+	* const Message = defineMessageUnion({ GotRemoteMessage: { message: Remote.Message } })
+	* const foldData = Remote.fold(Data, message => Message.GotRemoteMessage({ message }))
+	*
+	* const update = (model: Model, message: Message): Return =>
+	*   Message.match(message, {
+	*     GotRemoteMessage: ({ message }) => foldData(model, message),
+	*   })
+	* const subscriptions = Subscription.make<Model, Message, RemoteClient>()(() =>
+	*   foldData.subscriptions({ page: Surface.at(ProjectPage, …) }),
+	* )
+	* ```
+	*/
+	fold: (domain, toParentMessage) => {
+		const fold = (model, message) => ({ model: domain.reduce(model, message) });
+		return Object.assign(fold, {
+			mutate: (...args) => {
+				const started = domain.mutate(...args);
+				return {
+					...started,
+					command: mapMessage(started.command, toParentMessage)
+				};
+			},
+			subscriptions: (active, options) => markAll(Subscription.lift(brandEntries(domain.subscriptions(active, options)))({
+				toChildModel: (model) => model,
+				toParentMessage
+			}))
+		});
+	},
+	/**
 	* A patch of one entity's values, for a mutation's `optimistic` list or an
 	* overlay. Takes a `foldkit-entity` Entity or a Remote descriptor alike, so
 	* the domain you declared once is the one you patch:
@@ -3473,6 +4246,13 @@ const Remote = {
 	*/
 	at: bindRemote,
 	/**
+	* The resume part for this domain, for `foldkit-ssr`'s `SSR.plan({ parts })`:
+	* a server render sends what the plan's active Surfaces read from the store,
+	* each connection with its boundaries and each live cursor with it, and
+	* nothing else. `id` tells two domains in one application apart.
+	*/
+	resume: resumePart,
+	/**
 	* A Projection node that reads a `RemoteData` value out of the store. The id
 	* is supplied by the caller, usually from a Surface's params. The assembled
 	* value is decoded against the Selection, so malformed server data surfaces
@@ -3483,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: [],
@@ -3493,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 void 0;
-					const decoded = Schema.decodeUnknownResult(selection.schema)(assembled.values);
+					if (assembled === void 0) return unavailableFailure(store, key, relation);
+					const decoded = decodeRow(selection.schema, store[key].values, assembled.values);
 					return Result.isFailure(decoded) ? {
 						_tag: "Failed",
 						error: {
@@ -3520,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)`.
@@ -3558,13 +4361,13 @@ 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;
 		yield* Effect.annotateCurrentSpan("requirementCount", missing.length);
 		const result = yield* (yield* RemoteClient).read({
-			version: 3,
+			version: 4,
 			requests: missing
 		});
 		return writeRead(store, missing, result, at);
@@ -3617,6 +4420,17 @@ const Remote = {
 		});
 	},
 	/**
+	* Forgets everything the server told this Model: values, tombstones,
+	* unavailable fields, connections, live cursors, failures. What is known is
+	* known for a principal, and this is the one boundary for a login, a logout
+	* or a switch of organization: called from `update`, it performs no I/O, and
+	* every active Surface's read and live entries restart, so the screen asks
+	* again as whoever the client now is. A read or stream begun before is
+	* interrupted rather than landing after. A mutation in flight is treated as
+	* applied: its answer writes nothing here.
+	*/
+	forget: (bound, model) => bound.store.set(model, forgetRemote(bound.store.get(model))),
+	/**
 	* Writes a read result into the store, recording each field's applied window.
 	* `requests` are the planned requirements the result answers.
 	*/
@@ -3633,7 +4447,7 @@ const Remote = {
 			query: (request) => client.FoldkitRemoteQuery(request).pipe(Effect.provideContext(context)),
 			mutate: (request) => client.FoldkitRemoteMutate(request).pipe(Effect.provideContext(context)),
 			live: ({ requirements, after }) => client.FoldkitRemoteLive({
-				version: 3,
+				version: 4,
 				requirements,
 				after
 			}).pipe(Stream.map(liveEventOf), Stream.provideContext(context))
@@ -3666,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
@@ -3716,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,
@@ -3743,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.
 	*
@@ -3786,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,
@@ -3802,47 +4636,56 @@ 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
 				}).pipe(Effect.delay(options.grace ?? 0)))
 			};
+			markAll(entries);
 			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;
 			const at = now();
 			const result = yield* client.read({
-				version: 3,
+				version: 4,
 				requests: requirements
 			});
 			return reduce(current, {
@@ -3852,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;
@@ -3860,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 {
@@ -3879,21 +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 assembled = assemble(visible, entityKey(edge.ref.entity, edge.ref.id), relation);
-						if (assembled === void 0) return void 0;
-						const decoded = Schema.decodeUnknownResult(select.schema)(assembled.values);
+						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 = decodeRow(select.schema, visible[key].values, assembled.values);
 						if (Result.isFailure(decoded)) return {
 							_tag: "Failed",
 							error: {
@@ -3906,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",
@@ -3918,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: [],
@@ -3959,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
 						};
@@ -3967,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);
@@ -4021,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) {
@@ -4048,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}` : `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":
@@ -4088,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;
@@ -4101,33 +4957,15 @@ const bindDomain = (definition, store) => {
 			};
 		},
 		refresh: (model, target) => Remote.refresh(bound, model, target),
-		overlay: (model, id, optimistic) => bound.store.set(model, updateRemote(bound.store.get(model), {
+		forget: (model) => Remote.forget(bound, 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);
@@ -4161,7 +4999,8 @@ const bindDomain = (definition, store) => {
 							requestId,
 							entities: outcome.entities,
 							connections: outcome.connections,
-							deleted: outcome.deleted
+							deleted: outcome.deleted,
+							now: (options.now ?? wallClock)()
 						})
 					}))
 				}
@@ -4181,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, WindowSchema, WireBoundary, addLayer, addOverlay, aliasedField, applyConnectionEvent, applyEntityEvent, assemble, beginMutation, beginOptimistic, belongsEncoded, classifyLive, clearStale, coalesceQueries, coalesceReads, coalescedLayer, connectionChangeOf, connectionIdentity, connectionsOf, cursor, edge, emptyConnection, emptyLiveState, emptyMutationState, emptyOptimistic, emptyRefresh, emptyStore, entityKey, entry, failMutation, failureOf, gc, hasField, hasNext, hasPrevious, initialRemoteModel, inspectEntity, inspectRemote, isFieldFailed, isFieldStale, 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, settleFailure, settleSuccess, shouldWake, stableStringify, targetsOf, terminal, tombstone, 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