foldkit-remote 0.6.0 → 0.8.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 * as Domain from "foldkit-entity";
 import { Entity as Entity$1, Expr, Query as Query$1, 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";
@@ -208,6 +210,7 @@ const emptyEntry = {
 	values: {},
 	present: /* @__PURE__ */ new Set(),
 	stale: /* @__PURE__ */ new Set(),
+	unavailable: /* @__PURE__ */ new Set(),
 	tombstone: false,
 	updatedAt: 0,
 	windows: {}
@@ -220,10 +223,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];
@@ -238,6 +243,7 @@ const written = (previous, values, now, windows) => {
 		},
 		present,
 		stale,
+		unavailable,
 		tombstone: false,
 		updatedAt: now,
 		windows: nextWindows
@@ -287,11 +293,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, {
 	values: {},
 	present: /* @__PURE__ */ new Set(),
 	stale: /* @__PURE__ */ new Set(),
+	unavailable: /* @__PURE__ */ new Set(),
 	tombstone: true,
 	updatedAt: 0,
 	windows: {}
@@ -329,7 +364,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 +374,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;
@@ -588,7 +626,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 +687,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,
@@ -867,7 +918,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 +934,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 +1362,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);
@@ -1344,12 +1422,6 @@ const assembleRelation = (store, value, relation) => {
 * Entities: the descriptor an application declares, refs, ref pages, and
 * patches, with the codecs that carry refs on the wire.
 */
-/**
-* Relations are **references**, never inline target schemas: a ref cannot
-* reconstruct a full entity, and dereferencing is a store concern. Because the
-* target schema is not inlined, recursive relations cannot arise through the
-* schema graph.
-*/
 const refCodec = (entity) => Schema.Struct({
 	entity: Schema.String,
 	id: Schema.String
@@ -1551,6 +1623,7 @@ const inspectEntry = (key, entry) => ({
 	key,
 	present: [...entry.present],
 	stale: [...entry.stale],
+	unavailable: [...entry.unavailable],
 	tombstone: entry.tombstone,
 	updatedAt: entry.updatedAt,
 	windows: { ...entry.windows }
@@ -1884,6 +1957,41 @@ 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. Nothing when no value is
+* both present and still fresh: what is already expired or stale is planned,
+* not awaited, which is what keeps a timer from firing on what it already
+* fired on.
+*/
+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))) {
+			const expires = entry.updatedAt + freshness.freshness;
+			if (expires > freshness.now) {
+				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 = [];
@@ -1995,7 +2103,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.
@@ -2018,13 +2126,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
@@ -2039,6 +2148,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");
@@ -2046,6 +2156,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
@@ -2104,7 +2215,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;
@@ -2299,7 +2410,32 @@ 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,
@@ -2457,9 +2593,10 @@ const withoutQueryLoading = (loading, identity) => {
 * leaves its mark behind, and a connection released with that mark would read
 * `Loading` forever the next time something asked for it before sending.
 */
-const prunedQueryLoading = (loading, roots) => {
+const prunedLoading = (loading, roots, reached) => {
+	if (loading.size === 0) return loading;
 	const named = new Set(roots.connections.map((root) => connectionMark(root.identity)));
-	const kept = [...loading].filter((mark) => !mark.startsWith(connectionPrefix) || named.has(mark));
+	const kept = [...loading].filter((mark) => mark.startsWith(connectionPrefix) ? named.has(mark) : reached().has(markEntity(mark)));
 	return kept.length === loading.size ? loading : new Set(kept);
 };
 /**
@@ -2492,7 +2629,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;
@@ -2589,12 +2726,14 @@ const updateRemote = (model, message) => {
 			};
 		case "RetentionChanged": {
 			const retained = gc(model, message.roots);
+			let reachedKeys;
+			const reached = () => reachedKeys ??= reachable(model.entities, message.roots, model.connections, model.optimistic, model.mutations.pending);
 			return {
 				...model,
 				...retained,
 				refresh: prunedRefresh(model.refresh, retained),
-				failures: prunedFailures(model, message.roots),
-				loading: prunedQueryLoading(model.loading, message.roots)
+				failures: prunedFailures(model.failures, message.roots, reached),
+				loading: prunedLoading(model.loading, message.roots, reached)
 			};
 		}
 		case "Hydrated": {
@@ -2606,9 +2745,11 @@ const updateRemote = (model, message) => {
 				})),
 				stale: true
 			}]);
+			const written = Object.entries(message.entities).flatMap(([key, entry]) => message.merge === "replace" || !(key in model.entities) ? [...entry.present].map((field) => `${key}\u0000${field}`) : []);
 			return {
 				...model,
 				entities: RemotePersistence.mergeStores(model.entities, message.entities, message.merge),
+				failures: withoutFieldFailures(model.failures, written),
 				connections: message.merge === "replace" ? {
 					...model.connections,
 					...Object.fromEntries(restored)
@@ -2620,8 +2761,9 @@ 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 failures = withoutFieldFailures(model.failures, fieldMarks(message.requests));
+			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 : {
 				...model,
 				entities,
@@ -2737,7 +2879,6 @@ const updateRemote = (model, message) => {
 			};
 		case "QueryFailed": return {
 			...model,
-			connections: message.connection in model.connections ? setConnectionStale(model.connections, message.connection, false) : model.connections,
 			failures: {
 				...model.failures,
 				connections: {
@@ -2793,6 +2934,35 @@ const patchedMarks = function* (patches) {
 	for (const patch of patches) for (const field of Object.keys(patch.values)) yield fieldMark(patch.entity, patch.id, field);
 };
 /**
+* Every field a read's requests reach: their own, and through each relation
+* the store already holds, the fields they ask of its targets. A request with
+* a relation riding on it names no target id; the store does, and a failure
+* recorded on a target is reached only this way.
+*/
+const reachedMarks = (store, requests) => {
+	const marks = [];
+	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);
+		for (const field of requirement.fields) {
+			marks.push(fieldMark(entity, id, field));
+			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);
+		}
+	};
+	for (const request of requests) walk(request.entity, request.id, request);
+	return marks;
+};
+/** The entity key a field mark belongs to. */
+const markEntity = (mark) => mark.slice(0, mark.indexOf("\0"));
+/**
 * The failures of what the roots still reach. A released connection's or
 * entity's failure goes with it, so asking for it again later asks the server
 * again rather than repeating an error that may no longer hold.
@@ -2802,12 +2972,10 @@ const patchedMarks = function* (patches) {
 * which is exactly a value whose first read failed: it is still on screen,
 * behind the parent that refers to it.
 */
-const prunedFailures = (model, roots) => {
-	const { failures } = model;
+const prunedFailures = (failures, roots, reached) => {
 	const named = new Set(roots.connections.map((root) => root.identity));
 	const connections = Object.entries(failures.connections).filter(([identity]) => named.has(identity));
-	const kept = Object.keys(failures.fields).length === 0 ? /* @__PURE__ */ new Set() : reachable(model.entities, roots, model.connections, model.optimistic, model.mutations.pending);
-	const fields = Object.entries(failures.fields).filter(([mark]) => kept.has(mark.slice(0, mark.indexOf("\0"))));
+	const fields = Object.keys(failures.fields).length === 0 ? [] : Object.entries(failures.fields).filter(([mark]) => reached().has(markEntity(mark)));
 	return connections.length === Object.keys(failures.connections).length && fields.length === Object.keys(failures.fields).length ? failures : {
 		connections: Object.fromEntries(connections),
 		fields: Object.fromEntries(fields)
@@ -2816,6 +2984,32 @@ const prunedFailures = (model, roots) => {
 /** Whether this field's last read failed and nothing has settled it since. */
 const isFieldFailed = (model, entity, id, field) => fieldMark(entity, id, field) in model.failures.fields;
 /**
+* Whether a read is fetching any field `relation` reads of an entity, its own
+* or, through each relation the store holds, its targets'. A value whose owner
+* is being fetched is loading, not `Initial`: nothing is missing a fetch.
+*/
+const isLoadingThrough = (model, entity, id, relation) => {
+	if (model.loading.size === 0) return false;
+	const walked = /* @__PURE__ */ new Map();
+	const walk = (target, targetId, requirement) => {
+		const key = entityKey(target, targetId);
+		const seen = walked.get(key) ?? /* @__PURE__ */ new Set();
+		if (seen.has(requirement)) return false;
+		seen.add(requirement);
+		walked.set(key, seen);
+		for (const field of requirement.fields) {
+			if (model.loading.has(fieldMark(target, targetId, field))) return true;
+			const nested = requirement.relations?.[field];
+			if (nested === void 0) continue;
+			const value = readField(model.entities, key, field);
+			if (value._tag === "None") continue;
+			for (const ref of targetsOf(value.value, nested)) if (walk(ref.entity, ref.id, nested)) return true;
+		}
+		return false;
+	};
+	return walk(entity, id, relation);
+};
+/**
 * The first failure among the fields `relation` reads of an entity, following
 * each relation the store holds into its targets, as `assemble` does. A read
 * that consults it shows `Failed` for a related entity's failure too, rather
@@ -2923,12 +3117,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
@@ -2961,6 +3156,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.
@@ -3010,6 +3420,22 @@ const visibleStoreOf = (entities, optimistic) => {
 	}
 	return visible;
 };
+/**
+* `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.`
+		}
+	};
+};
 const readResults = /* @__PURE__ */ new WeakMap();
 const memoRead = (snapshot, by, key, compute) => {
 	let byScope = readResults.get(snapshot);
@@ -3077,6 +3503,26 @@ const askedOf = (projection) => projection === void 0 ? nothingAsked : {
 	connections: connectionsOf(projection)
 };
 /**
+* 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.
+*/
+const sliceCovers = (outer, inner) => outer.entity === inner.entity && inner.fields.every((field) => outer.fields.includes(field)) && Object.entries(inner.relations ?? {}).every(([field, relation]) => {
+	const wider = outer.relations?.[field];
+	return wider !== void 0 && sliceCovers(wider, relation);
+}) && Object.entries(inner.windows ?? {}).every(([field, window]) => outer.windows?.[field] !== void 0 && stableStringify(outer.windows[field]) === stableStringify(window));
+/**
+* Whether what `outer` asks includes everything `inner` asks: each list with
+* the slice it selects of its rows, and each entity with the slice it reads,
+* relations included. A Surface that shows a read is one whose projection
+* asks for all of it; one that reads part of it cannot be why it is fetched.
+* A Surface that asks for one entity in several pieces is already one
+* requirement here: projection metadata unions them per entity and id.
+*/
+const covers = (outer, inner) => {
+	const { connections, requirements } = outer;
+	return inner.connections.every((connection) => connections.some((wider) => wider.identity === connection.identity && (connection.select === void 0 || wider.select !== void 0 && sliceCovers(wider.select, connection.select)))) && inner.requirements.every((requirement) => requirements.some((wider) => wider.id === requirement.id && sliceCovers(wider, requirement)));
+};
+/**
 * Plans what a projection asks against the Model. A connection the Model holds
 * fresh contributes its visible items' selected fields to the entity plan; one
 * it does not hold, or holds stale, is a query to run (its items are planned
@@ -3100,10 +3546,13 @@ const planAsked = (remote, asked, options) => {
 		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
 	};
 };
 /**
@@ -3230,7 +3679,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) ? {
@@ -3277,7 +3726,11 @@ const observeEntry = (bound, askedOf, toMessage, options) => {
 		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);
@@ -3289,10 +3742,11 @@ const observeEntry = (bound, askedOf, toMessage, options) => {
 					identity,
 					window,
 					select
-				}))
+				})),
+				expires: planned.expires
 			};
 		},
-		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
@@ -3302,21 +3756,27 @@ 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
+		})))))
 	};
 };
 /** 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: Schema.Number,
+		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* () {
@@ -3369,6 +3829,67 @@ 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, {
+			fetch: (ref) => mapMessage(domain.fetch(ref), toParentMessage),
+			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:
+	* `Remote.patch(Project, 'p1', { name: 'Apollo II' })`. Values are the
+	* fields' wire shape, as the server writes them; a relation is its ref key
+	* (`'User:u1'`).
+	*/
+	patch: (entity, id, values) => descriptorOf(entity).patch(id, values),
+	/**
+	* A reference to one entity, for `ConnectionChange` and anything else that
+	* names a row: `Remote.ref(Project, 'p3')`. Either kind of entity, as with
+	* `Remote.patch`.
+	*/
+	ref: (entity, id) => descriptorOf(entity).ref(id),
+	/**
 	* Declares a Remote domain and binds it to its place in the application Model
 	* in one step; the result carries the application-facing operations. The
 	* descriptor alone is `Remote.define`, the binding alone `Remote.at`.
@@ -3387,6 +3908,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
@@ -3410,7 +3938,7 @@ const Remote = {
 				const present = memoRead(store, store, `${key}\u0000${stableStringify(relation)}`, () => {
 					if (isTombstone(store, key)) return { _tag: "NotFound" };
 					const assembled = assemble(store, key, relation);
-					if (assembled === void 0) return void 0;
+					if (assembled === void 0) return unavailableFailure(store, key, relation);
 					const decoded = Schema.decodeUnknownResult(selection.schema)(assembled.values);
 					return Result.isFailure(decoded) ? {
 						_tag: "Failed",
@@ -3433,7 +3961,7 @@ const Remote = {
 					error: failure,
 					previous: present.value
 				} : present;
-				if (isLoading(remote, selection.entity, id, relation.fields)) return { _tag: "Loading" };
+				if (isLoadingThrough(remote, selection.entity, id, relation)) return { _tag: "Loading" };
 				return failure === void 0 ? { _tag: "Initial" } : {
 					_tag: "Failed",
 					error: failure
@@ -3478,7 +4006,7 @@ const Remote = {
 		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);
@@ -3531,6 +4059,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.
 	*/
@@ -3547,7 +4086,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))
@@ -3738,6 +4277,7 @@ const bindDomain = (definition, store) => {
 					roots: current
 				}).pipe(Effect.delay(options.grace ?? 0)))
 			};
+			markAll(entries);
 			return entries;
 		},
 		plan: (model, projection, options) => Remote.plan(bound, model, projection, options),
@@ -3756,7 +4296,7 @@ const bindDomain = (definition, store) => {
 			if (requirements.length === 0) return current;
 			const at = now();
 			const result = yield* client.read({
-				version: 3,
+				version: 4,
 				requests: requirements
 			});
 			return reduce(current, {
@@ -3795,7 +4335,7 @@ const bindDomain = (definition, store) => {
 				if (remote.loading.size === 0) return void 0;
 				for (const edge of visibleItems(connection, ref.identity, remote.optimistic.overlays, remote.entities)) {
 					if (edge.ref.entity !== relation.entity) continue;
-					if (isLoading(remote, edge.ref.entity, edge.ref.id, relation.fields)) return { _tag: "Loading" };
+					if (isLoadingThrough(remote, edge.ref.entity, edge.ref.id, relation)) return { _tag: "Loading" };
 				}
 			};
 			const readPage = (remote, connection) => {
@@ -3805,8 +4345,9 @@ const bindDomain = (definition, store) => {
 					let refreshing = connection.stale;
 					const edges = visibleItems(connection, ref.identity, remote.optimistic.overlays, remote.entities);
 					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 key = entityKey(edge.ref.entity, edge.ref.id);
+						const assembled = assemble(visible, key, relation);
+						if (assembled === void 0) return unavailableFailure(visible, key, relation);
 						const decoded = Schema.decodeUnknownResult(select.schema)(assembled.values);
 						if (Result.isFailure(decoded)) return {
 							_tag: "Failed",
@@ -3931,6 +4472,59 @@ const bindDomain = (definition, store) => {
 				}
 			};
 		},
+		why: (model, projection, options) => {
+			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);
+			}).map((active) => active.name);
+			const withSurfaces = reading === void 0 ? {} : { surfaces: reading };
+			switch (state._tag) {
+				case "Ready": return {
+					state: state._tag,
+					message: "Everything it selects is here.",
+					...withSurfaces
+				};
+				case "Refreshing": return {
+					state: state._tag,
+					message: "It is shown while a newer value is fetched.",
+					...withSurfaces
+				};
+				case "Loading": return {
+					state: state._tag,
+					message: "A request for it is in flight.",
+					...withSurfaces
+				};
+				case "NotFound": return {
+					state: state._tag,
+					message: "The server answered without it: it does not exist, or this principal may not see it.",
+					...withSurfaces
+				};
+				case "Failed": return {
+					state: state._tag,
+					message: state.error._tag === "DecodeError" ? `What the server sent does not decode against the Selection: ${state.error.message}` : state.error._tag === "Unavailable" ? `${state.error.message} Select without it, or Data.refresh asks again.` : `Its request failed: ${state.error.message}. Nothing retries a failed read on its own; Data.refresh asks again.`,
+					...withSurfaces
+				};
+				case "Initial":
+					if (reading === void 0) return {
+						state: state._tag,
+						reason: "Unknown",
+						message: "Nothing is fetching it. Pass the active record you give Data.subscriptions as `surfaces` to tell whether an active Surface reads it."
+					};
+					return reading.length === 0 ? {
+						state: state._tag,
+						reason: "NotObserved",
+						message: "No active Surface reads it, so nothing fetches it. Include it in a Surface that is active for this Model, in the record given to Data.subscriptions.",
+						surfaces: reading
+					} : {
+						state: state._tag,
+						reason: "NotFetching",
+						message: `${reading.join(", ")} ${reading.length === 1 ? "reads it and is" : "read it and are"} active, yet nothing is fetching it. Remote's Subscriptions are most likely not installed: give the runtime Data.subscriptions (or Data.wiring) and a RemoteClient.`,
+						surfaces: reading
+					};
+			}
+		},
 		filtered: (model, over, by, input) => {
 			assertRegistered(bound, "Query", definition.registry.queries, by.name);
 			const filters = by.body?.entity.name;
@@ -3962,6 +4556,7 @@ const bindDomain = (definition, store) => {
 			};
 		},
 		refresh: (model, target) => Remote.refresh(bound, model, target),
+		forget: (model) => Remote.forget(bound, model),
 		overlay: (model, id, optimistic) => bound.store.set(model, updateRemote(bound.store.get(model), {
 			_tag: "OverlayShown",
 			id,
@@ -4054,6 +4649,6 @@ const pageSize = (window, key) => {
 	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, 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, Requirement, Selection, SettledFields, WindowSchema, WireBoundary, addLayer, addOverlay, aliasedField, applyConnectionEvent, applyEntityEvent, assemble, beginMutation, beginOptimistic, belongsEncoded, classifyLive, clearStale, coalesceQueries, coalesceReads, coalescedLayer, connectionChangeOf, connectionIdentity, connectionsOf, cursor, deadlineOf, edge, emptyConnection, emptyLiveState, emptyMutationState, emptyOptimistic, emptyRefresh, emptyStore, entityKey, entry, failMutation, failureOf, forgetRemote, gc, hasField, hasNext, hasPrevious, initialRemoteModel, inspectEntity, inspectRemote, isFieldFailed, isFieldStale, isFieldUnavailable, isGapped, isLoading, isLoadingThrough, isQueryLoading, isRefPage, isRemoteMessage, isTombstone, items, liveEventOf, liveHasNext, liveHasPrevious, markStale, matching, merge, missingFields, mutateRemote, mutationStatus, noFailures, pageSchema, plan, pruneOverlays, reachable, readField, reconcileMutation, refParts, refreshIsInFlight, refreshedAt, refsIn, relationAlias, relationOf, relationShape, remoteDataSchema, remoteError, remoteErrorSchema, remoteMessageCases, remoteMessageSchema, remoteModelSchema, remove, removeLayer, removeOverlay, requirementKey, requirementsOf, retentionRootsSchema, schemaOf, segment, setStale, setUnavailable, settleFailure, settleSuccess, shouldWake, stableStringify, targetsOf, terminal, tombstone, unavailableOf, unknown, updateRemote, visibleItems, visibleStore, windowKey, withRefreshRequested, writeEntities, writeEntity, writeRead };
 
 //# sourceMappingURL=index.mjs.map