foldkit-remote 0.20.0 → 0.22.0

package/dist/index.js

@@ -0,0 +1,2791 @@
+import { PredictionPart, predictionMismatch, withDiagnostics } from "./diagnostics.js";
+import { RemoteConnections, RemoteRequirements, Requirement, connectionsOf, requirementsOf } from "./requirement.js";
+import { patchedFields, shownOf } from "./shown.js";
+import { sameData } from "./data.js";
+import { RELATION_ALIAS, RelationAnnotation, RelationEntityAnnotation, aliasedField, isRefPage, refParts, refsIn, relationAlias, relationShape, targetsOf } from "./relation.js";
+import { askAgain, clearStale, emptyStore, entityKey, entry, hasField, isFieldStale, isFieldUnavailable, isTombstone, markStale, missingFields, readField, remove, setStale, setUnavailable, tombstone, writeEntities, writeEntity } from "./store.js";
+import { answerGaps } from "./answerGaps.js";
+import { DerivedBy, Mutation, Refusal, beginMutation, brokenByWrite, derivedOfWrite, emptyMutationState, failMutation, forbiddenByWrite, forgetFailure, mutationStatus, optimisticOfWrite, patchOfWrite, predictionOfWrite, reconcileMutation, schemaOf, settledLater } from "./mutation.js";
+import { IDENTITY_SEPARATOR, Query, queryIdentity, stableStringify } from "./query.js";
+import { AnswerRead, ConnectionChangeSchema, Live, LiveChange, LiveEdge, LiveRequirement, MAX_FIELDS_PER_REQUEST, MAX_LIVE_QUERIES, MAX_RELATION_DEPTH, MAX_SHOWN_ENTITIES, Mutate, MutationRequest, MutationResult, NormalizedEntity, OperationId, PageSize, QueryEdge, QueryRequest, QueryResult, QueryRpc, REMOTE_PROTOCOL_VERSION, Read, ReadBatch, ReadBatchResult, ReadRequest, RelationRequest, RemoteForbidden, RemoteLiveError, RemoteLiveRefused, RemoteMutationError, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteRpc, RemoteUnauthenticated, RemoteUnreachable, SettledFields, ShownSlice, WindowSchema, WireBoundary } from "./wire.js";
+import { coalesceQueries, coalesceReads, requirementKey } from "./coalesce.js";
+import { RemoteClient, coalescedLayer, connectionChangeOf, liveEventOf, mintOperation, mutateRemote, remoteError } from "./client.js";
+import { cursor, edge, emptyConnection, hasNext, hasPrevious, isGapped, items, merge, segment, terminal, unknown } from "./connection.js";
+import { a as relationOf, i as pageSchema, n as Selection, o as unavailableOf, r as assemble, t as Entity } from "./entity-DuDxaa3n.js";
+import { RowPlace, placeIn, withEdge } from "./placement.js";
+import { belongsEncoded, matching } from "./matching.js";
+import { EntityChange, Impact, changesOf, impactOn } from "./impact.js";
+import { wireValues } from "./patchValues.js";
+import { Denied, Freshness, RemoteData, remoteDataSchema, remoteErrorSchema } from "./remoteData.js";
+import { ReadWhy, ShownBy, Why, WhyTerm, readWhy, regressed } from "./why.js";
+import { ConnectionChange, addLayer, addOverlay, beginOptimistic, connectionIdentity, emptyOptimistic, goneIn, heldOnlyByRequests, plannedStore, pruneOverlays, removeLayer, removeOverlay, resolvedPatches, settleFailure, settleSuccess, visibleItems, visibleStore } from "./optimistic.js";
+import { applyConnectionEvent, applyEntityEvent, classifyLive, emptyLiveState, liveHasNext, liveHasPrevious } from "./live.js";
+import { OutboxItemState, StoredWrite, backoff, channelFor, headOf, mergeStored, onlineAgain, operationOf, othersWaiting, outboxStatus, readEntries, readStored, sendLock, settledIn, storeLock, storedFromText, storedOf, storedText, withLock } from "./outbox.js";
+import { deadlineOf, plan, windowKey } from "./plan.js";
+import { departedLimit, gc, reachable, recentRoots } from "./retain.js";
+import { REMOTE_CACHE_VERSION, RemotePersistence } from "./persistence.js";
+import { dismissQueued, emptyRefresh, failureOf, fieldMark, forgetRemote, initialRemoteModel, invalidateConnections, isFieldFailed, isLoading, isLoadingThrough, isQueryLoading, isRemoteMessage, noFailures, onlyOverlaid, overlaysOf, refreshIsInFlight, refreshedAt, remoteMessageCases, remoteMessageSchema, remoteModelSchema, retentionRootsSchema, updateRemote, windowGrowthKey, withRefreshRequested, writeRead } from "./model.js";
+import { failedReasons, reasonsOf } from "./whyReasons.js";
+import { inspectEntity, inspectRemote } from "./inspect.js";
+import { RemotePolicy } from "./policy.js";
+import { markAll, resumePart } from "./resume.js";
+import { reduceReporting } from "./reporting.js";
+import { RemoteJsonAnswer, RemoteJsonRequest, http, json } from "./json.js";
+import { httpWithLive, liveFetch } from "./sse.js";
+import { Clock, Duration, Effect, Layer, Match, Option, Queue, Record, Result, Schema, Stream } from "effect";
+import { Diagnostics, ModelRef } from "foldkit-surface";
+import { Derivation, Entity as Entity$1, Operators, Query as Query$1, QueryEvaluateError, ReadFilter, SelectionTypeId } from "foldkit-entity";
+import { KeyValueStore } from "effect/persistence";
+import { mapMessage } from "foldkit/command";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+// src/index.ts
+/**
+* `foldkit-remote` — normalized application-facing server state.
+*
+* The pure core (entities, selections, the store, the planner, connections,
+* live classification, optimistic layers) performs no I/O. The `Remote.*`
+* helpers that read or mutate go through the `RemoteClient` Effect service.
+*/
+/** A body's dependencies as an explanation carries them: without the owner identity, which holds a symbol. */
+const explainedDependencies = (dependencies) => ({
+	fields: dependencies.fields.map(({ entity, key }) => ({
+		entity,
+		key
+	})),
+	inputs: dependencies.inputs,
+	operations: dependencies.operations,
+	operators: dependencies.operators.map(({ id, version }) => ({
+		id,
+		version
+	}))
+});
+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
+		}
+	};
+};
+/**
+* A read contract whose connection, when a client can place rows in it, also
+* reads every field its body filters and orders by: a changed row is then
+* compared with neighbours that hold those fields. What the view reads, and so
+* decodes, stays its Selection.
+*/
+const placeableReadContract = (contract, body, operators) => {
+	if (body === void 0) return contract;
+	const { requirement, ref } = contract;
+	const encoded = Schema.encodeSync(ref.Input)(ref.input);
+	if (Query$1.placement(body, encoded, { operators })._tag !== "Placeable") return contract;
+	const missing = Query$1.dependencies(body).fields.filter((field) => !requirement.select.fields.includes(field.key));
+	if (missing.length === 0) return contract;
+	return {
+		...contract,
+		requirement: {
+			...requirement,
+			select: {
+				...requirement.select,
+				fields: [...requirement.select.fields, ...missing.map((field) => field.key)]
+			}
+		}
+	};
+};
+const metaOf = (remote, asked, operators) => {
+	const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
+	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, goneIn(remote.entities, remote.optimistic))) {
+			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
+* not planned as a fetch.
+*/
+const storeOf = (bound, model) => {
+	const remote = bound.store.get(model);
+	return visibleStoreOf(remote.entities, remote.optimistic, bound.operators);
+};
+/**
+* The Model as it would be with nothing optimistic pending. Every read reaches
+* the layers through the Model it is given, so dropping them here is what makes
+* a read confirmed — no read has to know it is being read confirmed.
+*/
+const withoutOptimistic = (bound, model) => {
+	const remote = bound.store.get(model);
+	return remote.optimistic.layers.length === 0 && remote.optimistic.overlays.length === 0 ? model : bound.store.set(model, {
+		...remote,
+		optimistic: emptyOptimistic
+	});
+};
+const confirmed = (bound, projection) => ({
+	...projection,
+	read: (root) => projection.read(withoutOptimistic(bound, root))
+});
+const visibleStores = /* @__PURE__ */ new WeakMap();
+const visibleStoreOf = (entities, optimistic, operators) => {
+	let byLayers = visibleStores.get(operators);
+	if (byLayers === void 0) {
+		byLayers = /* @__PURE__ */ new WeakMap();
+		visibleStores.set(operators, byLayers);
+	}
+	let byStore = byLayers.get(optimistic.layers);
+	if (byStore === void 0) {
+		byStore = /* @__PURE__ */ new WeakMap();
+		byLayers.set(optimistic.layers, byStore);
+	}
+	let visible = byStore.get(entities);
+	if (visible === void 0) {
+		visible = visibleStore(entities, optimistic, operators);
+		byStore.set(entities, visible);
+	}
+	return visible;
+};
+const plannedStores = /* @__PURE__ */ new WeakMap();
+/** `plannedStore` of the visible store, kept by it. */
+const plannedStoreOf = (entities, optimistic, visible) => {
+	let planned = plannedStores.get(visible);
+	if (planned === void 0) {
+		planned = plannedStore(entities, visible, optimistic);
+		plannedStores.set(visible, planned);
+	}
+	return planned;
+};
+/**
+* `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);
+	}
+	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 (scope.results.has(key)) return scope.results.get(key);
+	const value = compute();
+	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 rows and lists. */
+const liveStreamKey = ({ requirements, queries }) => [...requirements.map((requirement) => `${entityKey(requirement.entity, requirement.id)}:${[...requirement.fields].sort().join(",")}`), ...queries.map((query) => stableStringify(query))].sort().join("|");
+/** Each registered Entity's `Derived.count`s and `Derived.exists`, under the pointing Entity. */
+const derivedMembersBy = (entities) => {
+	const byPointing = /* @__PURE__ */ new Map();
+	const add = (pointing, member) => {
+		const members = byPointing.get(pointing) ?? [];
+		members.push(member);
+		byPointing.set(pointing, members);
+	};
+	for (const entity of entities) {
+		if (!Entity$1.is(entity)) continue;
+		const derived = entity.derived;
+		for (const [field, member] of Object.entries(derived)) Derivation.$match(member.derives, {
+			Supplied: () => void 0,
+			Count: ({ relation }) => add(relation.owner.name, DerivedBy.Count({
+				relation: relation.key,
+				owner: entity.name,
+				field
+			})),
+			Exists: ({ relation, viewer }) => add(relation.owner.name, DerivedBy.Exists({
+				relation: relation.key,
+				viewer: viewer.key,
+				owner: entity.name,
+				field
+			}))
+		});
+	}
+	return byPointing;
+};
+/** Declares a Remote domain: its entities, queries, and mutations, plus the submodel. */
+const defineRemote = (config) => {
+	const entities = config.entities.map(descriptorOf);
+	return {
+		entities,
+		queries: config.queries ?? [],
+		mutations: config.mutations ?? [],
+		Model: remoteModelSchema(),
+		initial: initialRemoteModel,
+		Message: remoteMessageSchema,
+		update: updateRemote,
+		rpc: RemoteRpc,
+		registry: {
+			entities: new Map(entities.map((entity) => [entity.name, entity])),
+			queries: new Map((config.queries ?? []).map((query) => [query.name, query])),
+			mutations: new Map((config.mutations ?? []).map((mutation) => [mutation.name, mutation])),
+			filtered: new Map(config.entities.flatMap((entity) => Entity$1.is(entity) ? [[entity.name, ReadFilter.members(entity.metadata)]] : [])),
+			derived: derivedMembersBy(config.entities)
+		}
+	};
+};
+/** Binds a Remote domain to its store's location in the application Model. */
+const bindRemote = (definition, ref, operators) => {
+	const store = ModelRef.focus(ref);
+	return {
+		definition,
+		store,
+		operators,
+		contract: {
+			kind: "remote",
+			name: store.dependency.join(".") || "remote",
+			owner: store.owner,
+			owns: store.dependency.length === 0 ? [] : [store.dependency],
+			observes: store.dependency.length === 0 ? [] : [store.dependency],
+			messages: [],
+			metadata: []
+		}
+	};
+};
+/** The runtime half of `Registered`: a descriptor the domain never declared is an error naming both. */
+const assertRegistered = (bound, kind, registered, name) => {
+	if (!registered.has(name)) throw new Error(`Remote: ${kind} "${name}" is not registered with domain "${bound.contract.name}"`);
+};
+const askedOf = (projection) => ({
+	requirements: requirementsOf(projection),
+	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
+* once the page arrives).
+*
+* A connection whose query failed is not run again here, short of `force`: the
+* 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, operators) => {
+	const queries = [];
+	const items = [];
+	const connections = Requirement.mergeConnections(asked.connections);
+	for (const connection of widest(remote, connections)) {
+		const known = remote.connections[connection.identity];
+		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, goneIn(remote.entities, remote.optimistic));
+		items.push(...itemsOf(edges.map((edge) => edge.ref), connection.select));
+	}
+	const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
+	const read = [...asked.requirements, ...items];
+	const held = heldOnlyByRequests(remote.entities, remote.optimistic);
+	const sent = plan(plannedStoreOf(remote.entities, remote.optimistic, visible), read, options).filter((requirement) => !held.has(entityKey(requirement.entity, requirement.id)));
+	return {
+		requirements: options.force === true ? sent : withoutFailedFields(remote, sent),
+		queries,
+		expires: options.freshness === void 0 ? null : deadlineOf(visible, read, options.freshness) ?? null
+	};
+};
+/**
+* The plan without the fields whose last read failed. Like a failed query,
+* a failed field is shown rather than retried on its own, so a persistent
+* error is not asked again on every unrelated restart of the read entry. A
+* field leaving the request takes its window and its relation with it.
+*/
+const withoutFailedFields = (remote, planned) => {
+	if (Object.keys(remote.failures.fields).length === 0) return planned;
+	return planned.flatMap((requirement) => {
+		const fields = requirement.fields.filter((field) => !isFieldFailed(remote, requirement.entity, requirement.id, field));
+		if (fields.length === requirement.fields.length) return [requirement];
+		if (fields.length === 0) return [];
+		const kept = new Set(fields);
+		const only = (record) => record === void 0 ? void 0 : Object.fromEntries(Object.entries(record).filter(([field]) => kept.has(field)));
+		const windows = only(requirement.windows);
+		const relations = only(requirement.relations);
+		return [{
+			entity: requirement.entity,
+			id: requirement.id,
+			fields,
+			...windows === void 0 || Object.keys(windows).length === 0 ? {} : { windows },
+			...relations === void 0 || Object.keys(relations).length === 0 ? {} : { relations },
+			...requirement.live === void 0 ? {} : { live: requirement.live }
+		}];
+	});
+};
+/** The entity requirements a page's edges add under a selection. */
+const itemsOf = (edges, select) => edges.filter((edge) => edge.entity === select.entity).map((edge) => ({
+	...select,
+	id: edge.id
+}));
+/**
+* The wire request of a planned query; a `QueryRef` identity carries the query
+* name and the canonical encoded input. A connection requirement built by hand
+* with another identity cannot be run, and fails as a query would.
+*/
+const parsedQueryRequest = (query) => {
+	const separator = query.identity.indexOf("\0");
+	if (separator < 0) return Result.fail(new RemoteQueryError({ message: `connection "${query.identity}" is not a query's: only a QueryRef identity can be run` }));
+	try {
+		return Result.succeed({
+			query: query.identity.slice(0, separator),
+			input: JSON.parse(query.identity.slice(separator + 1)),
+			window: query.window,
+			...query.select === void 0 ? {} : { select: query.select }
+		});
+	} catch {
+		return Result.fail(new RemoteQueryError({ message: `connection "${query.identity}" carries no encoded input` }));
+	}
+};
+const queryRequestOf = (query) => Effect.suspend(() => Result.match(parsedQueryRequest(query), {
+	onFailure: Effect.fail,
+	onSuccess: Effect.succeed
+}));
+/**
+* The live rows and lists of what projections ask. A list read live is a
+* `Data.query`, whose identity is always a query's, so one that is not is
+* this package's bug, and throws.
+*/
+const liveAskOf = (asked) => ({
+	requirements: asked.requirements.filter((requirement) => requirement.live === true),
+	queries: asked.connections.flatMap((connection) => connection.live === true ? [Result.getOrThrow(parsedQueryRequest(connection))] : [])
+});
+/**
+* The `ConnectionMerged` for a query result, in the client's edge shape.
+* `refreshes` marks the page as answering the connection's refresh, so one
+* Message both merges it and clears `stale`.
+*/
+/**
+* The page a window asked for, or the number of edges that came back instead.
+*
+* A window is a request the client made and the server answered, so more edges
+* than were asked for is a protocol disagreement rather than a windfall: the
+* client cannot tell which of them the window meant, the connection's
+* boundaries stop describing what it holds, and a `first: 25` that quietly
+* becomes a thousand is a memory event with no error attached to it.
+*
+* `undefined` when the page is within its window, or when no size was asked
+* for — `after`/`before` with no `first`/`last` bounds nothing.
+*/
+const overrun = (window, edges) => {
+	const asked = window.first ?? window.last;
+	return asked !== void 0 && edges.length > asked ? {
+		asked,
+		got: edges.length
+	} : void 0;
+};
+const pageMessage = (connection, result, refreshes = false, window = {}, select, now) => {
+	const over = overrun(window, result.edges);
+	if (over !== void 0) return {
+		_tag: "QueryFailed",
+		connection,
+		error: {
+			_tag: "RemoteProtocolError",
+			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,
+		page: {
+			edges: result.edges.map((edge) => ({
+				key: edge.key,
+				ref: {
+					entity: edge.entity,
+					id: edge.id
+				}
+			})),
+			start: result.start,
+			end: result.end
+		},
+		...refreshes ? { refreshes } : {},
+		...select === void 0 || !hasPayload ? {} : { select },
+		...hasPayload ? {
+			entities: [...result.entities ?? []],
+			settled: [...result.settled ?? []],
+			now: now ?? 0
+		} : {}
+	};
+};
+/**
+* The retention roots of some projections: their requirements, their
+* connections (each with the union of what the projections select of its
+* items), and the connections listed by identity alone.
+*/
+const rootsOf = (projections, options) => {
+	const connections = /* @__PURE__ */ new Map();
+	for (const identity of (options.connections ?? []).map(connectionIdentity)) connections.set(identity, { identity });
+	for (const { identity, select } of projections.flatMap(connectionsOf)) {
+		const current = connections.get(identity)?.select;
+		connections.set(identity, {
+			identity,
+			select: current === void 0 ? select : Requirement.mergeRelation(current, select)
+		});
+	}
+	return {
+		requirements: Requirement.merge(projections.flatMap(requirementsOf)),
+		connections: [...connections.values()].sort((a, b) => a.identity < b.identity ? -1 : 1)
+	};
+};
+/** Reads requirements and reports the Message that settles them. Never fails. */
+const readMessage = (requirements, now) => Effect.gen(function* () {
+	const client = yield* RemoteClient;
+	const at = now();
+	const result = yield* Effect.result(client.read({
+		version: 5,
+		requests: requirements
+	}));
+	return Result.isFailure(result) ? {
+		_tag: "ReadFailed",
+		requests: requirements,
+		error: remoteError(result.failure)
+	} : {
+		_tag: "ReadReceived",
+		requests: requirements,
+		result: result.success,
+		now: at
+	};
+});
+/** Runs a query and reports the page that refreshes its connection, or the failure. Never fails. */
+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, query.select, now());
+});
+/** A query the read entry runs, as its dependencies carry it: plain data Foldkit compares. */
+const PlannedQuery = Schema.Struct({
+	identity: Schema.String,
+	window: WindowSchema,
+	select: RelationRequest
+});
+/**
+* The read entry: plans what `askedOf(model)` asks against the Model and runs
+* the entity read and the queries concurrently. Each Message it emits changes
+* the Model, so Foldkit recomputes the dependencies and restarts the stream
+* (`switchMap`): a merged page's items are planned by that next computation,
+* against the store as it then is, rather than read here unplanned. Nothing
+* the entry needs is spread over two Messages, since the second could be lost
+* to the restart; a page and its refresh are one `ConnectionMerged`.
+*/
+const observeEntry = (bound, askedOf, toMessage, options) => {
+	const { policy = RemotePolicy.cacheFirst, now = wallClock } = options;
+	const read = (requirements) => Effect.map(readMessage(requirements, now), 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,
+			expires: Schema.NullOr(Schema.Struct({
+				at: Schema.Number,
+				due: Schema.Array(ReadRequest)
+			}))
+		}),
+		modelToDependencies: (model) => {
+			const remote = bound.store.get(model);
+			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), bound.operators);
+			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, expires }) => Stream.concat(Stream.fromIterable([...requirements.length === 0 ? [] : [toMessage({
+			_tag: "ReadStarted",
+			requests: requirements,
+			refresh
+		}), ...RemotePolicy.refreshes(policy) ? [toMessage({
+			_tag: "RefreshStarted",
+			requests: requirements
+		})] : []], ...queries.length === 0 ? [] : [toMessage({
+			_tag: "QueryStarted",
+			connections: queries.map((query) => query.identity)
+		})]]), 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 wait before a stream's restart after `failures` breaks in a row: Sync's transport backoff. */
+const restartDelay = (options, failures) => {
+	const base = Duration.toMillis(Duration.fromInputUnsafe(options.retryBase ?? "50 millis"));
+	const max = Duration.toMillis(Duration.fromInputUnsafe(options.maxRetryDelay ?? "5 seconds"));
+	const backoff = Math.min(max, base * 2 ** Math.min(Math.max(failures, 1) - 1, 30));
+	return Duration.millis(backoff * (.8 + Math.random() * .4));
+};
+/** The live entry: subscribes to `liveOf(model)` from the Model's resume cursor. */
+const liveEntry = (bound, liveOf, toMessage, options) => ({
+	dependenciesSchema: Schema.Struct({
+		requirements: Schema.Array(ReadRequest),
+		queries: Schema.Array(QueryRequest),
+		cursor: resumeCursor,
+		floor: Schema.Number,
+		restarts: Schema.Number,
+		failures: resumeCursor
+	}),
+	modelToDependencies: (model) => {
+		const asked = liveOf(model);
+		const stream = liveStreamKey(asked);
+		const remote = bound.store.get(model);
+		const health = remote.streams[stream];
+		return {
+			requirements: asked.requirements,
+			queries: asked.queries,
+			cursor: remote.live[stream]?.cursor ?? 0,
+			floor: remote.refresh.floor,
+			restarts: health?.restarts ?? 0,
+			failures: health?.failures ?? 0
+		};
+	},
+	dependenciesToStream: ({ requirements, queries, cursor, restarts, failures }) => {
+		if (requirements.length === 0 && queries.length === 0) return Stream.empty;
+		const stream = liveStreamKey({
+			requirements,
+			queries
+		});
+		const live = Stream.unwrap(Effect.gen(function* () {
+			return (yield* RemoteClient).live({
+				requirements,
+				queries,
+				after: cursor
+			});
+		})).pipe(Stream.map((event) => toMessage({
+			_tag: "LiveReceived",
+			stream,
+			event,
+			now: (options.now ?? wallClock)()
+		})), Stream.catchIf((_error) => true, (error) => Stream.succeed(toMessage({
+			_tag: "ReadFailed",
+			requests: requirements,
+			error: remoteError(error),
+			stream
+		}))));
+		if (restarts === 0) return live;
+		return Stream.fromEffect(Effect.sleep(restartDelay(options, failures))).pipe(Stream.drain, Stream.concat(Stream.make(toMessage({
+			_tag: "RefreshStarted",
+			requests: requirements
+		}), toMessage({
+			_tag: "GapCleared",
+			stream
+		}))), Stream.concat(live));
+	}
+});
+/** The projection an active entry has for this Model; none while it is inactive. */
+const projectionOf = (entry, model) => {
+	if ("projectionOf" in entry) return entry.projectionOf(model);
+	if ("projection" in entry) return Option.some(entry.projection());
+	return Option.none();
+};
+/**
+* Every projection an entry resolves to for a Model: the lone one of a
+* `Surface.at`/`Surface.when` value or a bare Surface, or a family's parent
+* first and then each instance. The parent joins so an unloaded parent is
+* fetched before what it reveals; `Data.satisfy` reaches the instances in a
+* later pass. A caller that also passes the parent separately double-covers
+* its requirements, as overlapping Surfaces already do.
+*/
+const resolvedOf = (entry, model) => {
+	const source = entry;
+	if (typeof source.instancesOf === "function") {
+		const instances = source.instancesOf(model);
+		const from = entry.from;
+		if (from === void 0) return instances.map((instance) => ({
+			name: entry.name,
+			projection: instance.projection
+		}));
+		return [...Option.toArray(from.projectionOf(model)).map((projection) => ({
+			name: from.name,
+			projection
+		})), ...instances.map((instance) => ({
+			name: `${entry.name}[${instance.key}]`,
+			projection: instance.projection
+		}))];
+	}
+	return Option.toArray(projectionOf(entry, model)).map((projection) => ({
+		name: entry.name,
+		projection
+	}));
+};
+/** What some projections ask for together: their requirements and connections unioned. */
+const askedUnion = (projections) => ({
+	requirements: projections.flatMap(requirementsOf),
+	connections: projections.flatMap(connectionsOf)
+});
+/**
+* `resolvedOf` computed once per Model: the read, live, and retain entries
+* all derive their dependencies from the same projections on the same Model
+* change, and a Surface's `model` callback (which lifts and builds schemas)
+* need not run three times for it. Models are objects, so the memo is weak.
+*/
+const memoizedResolved = (entry) => {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (model) => {
+		const key = model;
+		if (typeof key !== "object" || key === null) return resolvedOf(entry, model);
+		const known = cache.get(key);
+		if (known !== void 0) return known;
+		const resolved = resolvedOf(entry, model);
+		cache.set(key, resolved);
+		return resolved;
+	};
+};
+/** Why the server refused a write, as `mutation` declares it: none for any other failure, or one that does not decode. */
+const refusalOf = (error, mutation) => error.refusal === void 0 ? Option.none() : Schema.decodeUnknownOption(mutation.Refusal)(error.refusal);
+/** Refuses an entry of another application: two can share a Model type, and the owner token tells them apart. */
+const assertOwnedBy = (contract, entry) => {
+	if (contract.owner === void 0) return;
+	const from = entry.from;
+	for (const surface of from === void 0 ? [entry] : [entry, from]) if (surface.owner !== contract.owner) throw new Error(`Remote: Surface "${surface.name}" belongs to another application than domain "${contract.name}"`);
+};
+/** Whether a refresh target is one list by its query and input. */
+const isQueryRef = (target) => typeof target.identity === "string";
+/** Whether a refresh target is a projection, the one kind that is not a Surface. */
+const isProjection = (target) => typeof target.read === "function";
+/** Whether a refresh target is one entry of an active record rather than the record. */
+const isActiveEntry = (target) => {
+	const members = target;
+	return typeof members.projectionOf === "function" || typeof members.instancesOf === "function" || typeof members.projection === "function";
+};
+/** Every projection a refresh target reads for this Model, each entry resolved as the read entries resolve it. */
+const targetProjections = (contract, target, model) => {
+	if (isProjection(target)) return [target];
+	const entries = isActiveEntry(target) ? [target] : Object.values(target);
+	for (const entry of entries) assertOwnedBy(contract, entry);
+	return entries.flatMap((entry) => resolvedOf(entry, model).map(({ projection }) => projection));
+};
+const Remote = {
+	/** The submodel's schema, the same for every domain; embed it in the application Model. */
+	Model: remoteModelSchema(),
+	/** The submodel's initial value. */
+	initial: initialRemoteModel,
+	/**
+	* Remote's Message cases for `defineMessageUnion`: spread them into the
+	* application's union, and reduce the ones `Remote.reduces` recognizes with
+	* `RemoteDomain.reduce`.
+	*/
+	messages: remoteMessageCases,
+	/** 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) => {
+			const reduced = reduceReporting(domain.store, domain.reduce, model, message, true);
+			return {
+				model: reduced.model,
+				commands: (reduced.commands ?? []).map((command) => mapMessage(command, toParentMessage))
+			};
+		};
+		return Object.assign(fold, {
+			mutate: (...args) => {
+				const started = domain.mutate(...args);
+				return {
+					...started,
+					command: mapMessage(started.command, toParentMessage)
+				};
+			},
+			retry: (...args) => Option.map(domain.retry(...args), (started) => ({
+				...started,
+				command: mapMessage(started.command, toParentMessage)
+			})),
+			preload: (...args) => mapMessage(domain.preload(...args), toParentMessage),
+			subscriptions: (active, options) => markAll(messagesAs(brandEntries(domain.subscriptions(active, options)), 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, except a relation, which is
+	* a ref (`owner: Remote.ref(User, 'u1')`), an array of refs, or `null` where
+	* it is optional. A ref key typed by hand, or a ref to another Entity, is
+	* refused, in the type and when the patch is made.
+	*/
+	patch: (entity, id, values) => {
+		const descriptor = descriptorOf(entity);
+		return descriptor.patch(id, wireValues(descriptor, values));
+	},
+	/**
+	* A deletion of one entity, for a mutation's `optimistic` list or an
+	* overlay: `Remote.tombstone(Post, 'p1')`. Until it settles the row reads
+	* `NotFound` and leaves every list and relation, as an answer's `deleted`
+	* does; a failure brings it back. Keeping it gone is the answer's to say.
+	*/
+	tombstone: (entity, id) => ({
+		_tag: "Delete",
+		...descriptorOf(entity).ref(id)
+	}),
+	/**
+	* 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`.
+	*/
+	make: (config) => bindDomain(defineRemote(config), config.model, {
+		verifyPredictions: config.verifyPredictions,
+		operators: config.operators,
+		viewer: config.viewer
+	}),
+	/**
+	* Declares a Remote domain without binding it: its entities, queries, and
+	* mutations, plus the submodel. For a domain reused across applications or
+	* bound in a test; `Remote.make` is the one-step form.
+	*/
+	define: defineRemote,
+	/**
+	* Binds a Remote domain to its store's location in the application Model. The
+	* registered entity names are carried on the returned value, so `Remote.select`
+	* rejects a selection for an entity this domain never declared. `operators`
+	* is the client's table, which a pending computed assignment is predicted by
+	* (`Operators.kernel` when not given), as `Remote.make`'s is.
+	*/
+	at: (definition, store, options = {}) => bindRemote(definition, store, options.operators ?? Operators.kernel),
+	/**
+	* 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
+	* as `Failed` instead of being asserted into `Value`. A present value with a
+	* stale field reads as `Refreshing`: an observer is refetching it.
+	*/
+	select: (bound, given) => {
+		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: [],
+			metadata: RemoteRequirements.of({
+				...relation,
+				id
+			}),
+			read: (root) => {
+				const store = storeOf(bound, root);
+				const key = entityKey(selection.entity, id);
+				const present = memoRead([store], `${key}\u0000${relationKey}`, () => {
+					if (isTombstone(store, key)) return { _tag: "NotFound" };
+					const assembled = assemble(store, key, relation);
+					if (assembled === void 0) return unavailableFailure(store, key, relation);
+					const decoded = decodeRow(selection.schema, store[key].values, assembled.values);
+					return Result.isFailure(decoded) ? {
+						_tag: "Failed",
+						error: {
+							_tag: "DecodeError",
+							message: decoded.failure.message
+						}
+					} : assembled.refreshing ? {
+						_tag: "Refreshing",
+						value: decoded.success
+					} : {
+						_tag: "Ready",
+						value: decoded.success
+					};
+				});
+				const remote = bound.store.get(root);
+				const failure = failureOf(remote, selection.entity, id, relation);
+				if (present !== void 0) return failure !== void 0 && (present._tag === "Ready" || present._tag === "Refreshing") ? {
+					_tag: "Failed",
+					error: failure,
+					previous: present.value
+				} : present;
+				if (isLoadingThrough(remote, selection.entity, id, relation)) return { _tag: "Loading" };
+				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), bound.operators),
+	/**
+	* 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)`.
+	*/
+	plan: (bound, model, projection, options) => planAsked(bound.store.get(model), askedOf(projection), options ?? {}, bound.operators).requirements,
+	/**
+	* The queries a projection needs run before its connections read: those the
+	* Model does not hold, or holds stale (every one under `force`).
+	*/
+	planQueries: (bound, model, projection, options) => planAsked(bound.store.get(model), askedOf(projection), options ?? {}, bound.operators).queries.flatMap((query) => query.ref === void 0 ? [] : [query.ref]),
+	/**
+	* The store reads see: the base store under the pending optimistic layers.
+	* One store is shared by every read and plan of a Model whose remote state
+	* has not changed.
+	*/
+	storeOf: (bound, model) => storeOf(bound, model),
+	/**
+	* The projection read against the server-derived store alone: the same
+	* requirements, planned the same way, with the pending optimistic layers and
+	* connection overlays left off. See the bound `Remote.confirmed`.
+	*/
+	confirmed: (bound, projection) => confirmed(bound, projection),
+	/**
+	* Executes the plan against the `RemoteClient` and returns a new store. Used
+	* for SSR route prefetch, hover prefetch, and tests. Never called during render.
+	* `policy` decides what a present field means (default cache-first); `now`
+	* is the clock it reads, so the planner itself stays pure and time-injected.
+	*/
+	prefetch: Effect.fn("Remote.prefetch")(function* (bound, model, projection, options = {}) {
+		const store = storeOf(bound, model);
+		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: 5,
+			requests: missing
+		});
+		return writeRead(store, missing, result, at);
+	}),
+	/**
+	* Marks what a read requires as due again: a projection, a Surface without
+	* params, one entry of the active record, or the whole record, each entry
+	* resolved for this Model as `subscriptions` resolves it. Called from
+	* `update`: every selected field the store holds reads `Refreshing`, and
+	* every loaded query connection is invalidated. Nothing is fetched here.
+	* The read entries `Data.subscriptions` derives refetch it, because a stale
+	* field or connection is planned again under every policy, so a refresh never
+	* sends a request beside the entry already observing the same data.
+	*
+	* A refreshed connection's page replaces its pages, so items the server removed
+	* or reordered follow it; pages loaded past the first are dropped and paged
+	* again with `next`/`previous`. The read entries restart, so a read or query
+	* sent before the refresh is not applied after it.
+	*
+	* It is also how a failed read is retried: nothing that failed is asked
+	* again on its own, so its read stays `Failed` until this asks. A failed
+	* read with nothing to show reads `Loading` from here, and `Failed` again if
+	* the retry fails. `{ failed: true }` asks again only what failed, which is
+	* what a "Try again" means: what loaded keeps its value and its pages.
+	*
+	* The projection must be observed, which it is while it is on screen. Live
+	* subscriptions are left as they are. For data nothing observes (SSR, tests),
+	* use `Remote.prefetch` with `RemotePolicy.networkOnly`. Refreshing what is
+	* already being refreshed returns the same Model.
+	*/
+	refresh: (bound, model, target, options = {}) => {
+		const remote = bound.store.get(model);
+		if (isQueryRef(target)) {
+			assertRegistered(bound, "Query", bound.definition.registry.queries, target.query);
+			return Object.hasOwn(remote.failures.connections, target.identity) || options.failed !== true && remote.connections[target.identity] !== void 0 ? bound.store.set(model, invalidateConnections(remote, [target.identity])) : model;
+		}
+		const asked = askedUnion(targetProjections(bound.contract, target, model));
+		const merged = Requirement.mergeConnections(asked.connections);
+		const items = merged.flatMap((connection) => {
+			const known = remote.connections[connection.identity];
+			return known === void 0 ? [] : itemsOf(visibleItems(known, connection.identity, remote.optimistic.overlays, goneIn(remote.entities, remote.optimistic)).map((edge) => edge.ref), connection.select);
+		});
+		const asking = [...asked.requirements, ...items];
+		const connections = options.failed === true ? merged.filter((connection) => connection.identity in remote.failures.connections) : merged;
+		const requirements = plan(visibleStoreOf(remote.entities, remote.optimistic, bound.operators), options.failed === true ? asking.filter((requirement) => failureOf(remote, requirement.entity, requirement.id, requirement) !== void 0) : asking, { force: true });
+		const invalidated = connections.filter((connection) => remote.connections[connection.identity] !== void 0 || connection.identity in remote.failures.connections).map((connection) => connection.identity);
+		const marked = [...requirements.length === 0 ? [] : [{
+			_tag: "RefreshStarted",
+			requests: requirements
+		}], ...invalidated.map((connection) => ({
+			_tag: "ConnectionInvalidated",
+			connection
+		}))].reduce(updateRemote, remote);
+		const inFlight = requirements.some((requirement) => requirement.fields.some((field) => remote.entities[entityKey(requirement.entity, requirement.id)]?.stale.has(field) === true && refreshIsInFlight(remote.refresh, requirement, field)));
+		if (marked === remote && !inFlight) return model;
+		const refresh = withRefreshRequested(marked.refresh, requirements, invalidated);
+		return bound.store.set(model, {
+			...marked,
+			refresh
+		});
+	},
+	/**
+	* 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.
+	*/
+	writeRead,
+	/**
+	* Adapts an Effect RPC client for `RemoteRpc` to `RemoteClient`, so an
+	* application provides the transport's RPC layer instead of writing the
+	* `LiveChange`-to-`LiveEvent` mapping by hand. The client `RpcClient.make`
+	* builds is accepted as it is: when its transport fails (`RpcClientError`),
+	* the call fails with its own Remote error, which the application shows and
+	* retries like any failed read, query, mutation or live stream.
+	*/
+	/**
+	* Remote's client over any way of sending one JSON request and receiving its
+	* answer, for `clientLayer`: a worker, a server in the page. `RemoteServer.answer`
+	* is the other end.
+	*/
+	json,
+	/**
+	* Remote's client over HTTP, for `clientLayer`: each call a `POST` of the JSON
+	* request to `url`. `headers` is read per request (a session token, say).
+	*/
+	http,
+	/**
+	* Remote's client over HTTP with live, for `clientLayer`: reads, queries,
+	* and mutations as `http` sends them, live requirements as one `POST`
+	* answered with a `text/event-stream` of changes.
+	* `foldkit-remote-server/fetch` is the other end.
+	*/
+	httpWithLive,
+	clientLayer: (client, options = {}) => coalescedLayer(Layer.effect(RemoteClient, Effect.gen(function* () {
+		const context = yield* Effect.context();
+		return {
+			read: (batch) => client.FoldkitRemoteRead(batch).pipe(Effect.catchTag(["RpcClientError", "Unreachable"], (error) => Effect.fail(new RemoteReadError({ message: error.message }))), Effect.provideContext(context)),
+			query: (request) => client.FoldkitRemoteQuery(request).pipe(Effect.catchTag(["RpcClientError", "Unreachable"], (error) => Effect.fail(new RemoteQueryError({ message: error.message }))), Effect.provideContext(context)),
+			mutate: (request) => client.FoldkitRemoteMutate(request).pipe(Effect.catchTag("RpcClientError", (error) => Effect.fail(new RemoteUnreachable({ message: error.message }))), Effect.provideContext(context)),
+			live: ({ requirements, queries, after }) => client.FoldkitRemoteLive({
+				version: 5,
+				requirements,
+				...queries.length === 0 ? {} : { queries },
+				after
+			}).pipe(Stream.catchTag(["RpcClientError", "Unreachable"], (error) => Stream.fail(new RemoteLiveError({ message: error.message }))), Stream.map(liveEventOf), Stream.provideContext(context))
+		};
+	})), options),
+	/**
+	* Wraps a `RemoteClient` layer so its reads coalesce: requirements issued
+	* together become one batch, and a requirement already in flight is joined.
+	* `Remote.clientLayer` applies this; use it on a hand-written client.
+	*/
+	coalesced: coalescedLayer,
+	/**
+	* A Foldkit Subscription entry that keeps the cache to what the active
+	* Surfaces reach. `projections` are the ones the application observes (the
+	* same it passes to `Remote.observe`), `connections` the query connections
+	* it shows; anything else is collected once the roots have been stable for
+	* `grace`, so a route transition that comes straight back does not thrash.
+	*/
+	retain: (projections, toMessage = identityMessage, options = {}) => {
+		const roots = rootsOf(projections, options);
+		return {
+			dependenciesSchema: retentionRootsSchema,
+			modelToDependencies: () => roots,
+			dependenciesToStream: (current) => Stream.fromEffect(Effect.succeed(toMessage({
+				_tag: "RetentionChanged",
+				roots: current
+			})).pipe(Effect.delay(options.grace ?? 0)))
+		};
+	},
+	/**
+	* 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, 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,
+			...select === void 0 ? {} : { select }
+		});
+	}),
+	/** The `RemoteMessage` that merges a query page into its connection. */
+	queryMessage: (ref, result, select, now) => pageMessage(ref.identity, result, false, ref.window, select, now),
+	/** A pure, serializable view of the whole cache. */
+	inspect: inspectRemote,
+	/** A pure, serializable view of one entity, or `undefined` if unknown. */
+	inspectEntity,
+	/**
+	* Runs a mutation through `RemoteClient`, decoding its typed Output and
+	* returning the result's normalized patches so the caller can reconcile them
+	* through `updateRemote`'s `MutationSucceeded` (or `Remote.mutateInto`).
+	*/
+	mutate: mutateRemote,
+	/**
+	* Reads the clock where the reader acts, for `Data.mutate`'s `now`: a
+	* Command that yields `toMessage(now)`, the time in milliseconds since the
+	* epoch. It reads Effect's `Clock`, so a test pins it, and `Trace.run`
+	* runs it at the trace's time. Chirp's compose box answers a submit with
+	* `Remote.now(now => Message.ClockedPost({ post, now }))`, and
+	* `ClockedPost` starts the write.
+	*/
+	now: (toMessage) => ({
+		name: "Remote.now",
+		effect: Effect.map(Clock.currentTimeMillis, toMessage)
+	}),
+	/**
+	* Runs a mutation and reconciles its patches into a `RemoteModel` in one step,
+	* returning the new model alongside the typed Output. The model-level form of
+	* `MutationStarted` → `RemoteClient.mutate` → `MutationSucceeded`; in an
+	* application the three are `update` (with `optimistic`), a Command, and the
+	* Message the Command returns, so the optimistic operations show meanwhile.
+	*/
+	mutateInto: Effect.fn("Remote.mutateInto")(function* (bound, model, mutation, input, requestId, options = {}) {
+		const started = updateRemote(bound.store.get(model), {
+			_tag: "MutationStarted",
+			requestId,
+			...options.optimistic === void 0 ? {} : { optimistic: options.optimistic }
+		});
+		const outcome = yield* mutateRemote(mutation, input, requestId, { now: options.now });
+		const settled = updateRemote(started, {
+			_tag: "MutationSucceeded",
+			requestId,
+			entities: outcome.entities,
+			connections: outcome.connections,
+			deleted: outcome.deleted,
+			now: yield* Clock.currentTimeMillis
+		});
+		return {
+			output: outcome.output,
+			model: bound.store.set(model, settled)
+		};
+	}),
+	/**
+	* A Foldkit Subscription entry that plans a Surface's missing fields from the
+	* Model and fetches them through `RemoteClient`, emitting a `RemoteMessage`
+	* per outcome. Wrap it in an application Message (`toMessage`) and reduce it
+	* with the domain's `update`. Under a refreshing `policy` the entry first
+	* emits `RefreshStarted`, so the fields being refetched read as `Refreshing`
+	* while the request is pending.
+	*/
+	observe: (bound, surface, params, toMessage = identityMessage, options = {}) => observeEntry(bound, () => askedOf(surface.projection(params)), toMessage, options),
+	/**
+	* A Foldkit Subscription entry that consumes the live stream for a Surface's
+	* requirements, emitting a `LiveReceived` per event and a `ReadFailed`
+	* carrying its `stream` when the stream breaks (including
+	* `ResumeUnavailable`). That records a gap on the stream rather than a failed
+	* read, since nothing was being read, and restarts the entry after a
+	* backoff; the restart refetches what it covers. The resume cursor is read
+	* from `RemoteModel.live`, so the application tracks no cursor of its own.
+	*/
+	live: (bound, surface, params, toMessage = identityMessage, options = {}) => liveEntry(bound, () => {
+		const projection = surface.projection(params);
+		return {
+			...liveAskOf(askedOf(projection)),
+			requirements: requirementsOf(projection)
+		};
+	}, toMessage, options)
+};
+/**
+* Each entry with its Messages as the parent's and its dependencies as they
+* were. The Model is the parent's already, and `Subscription.lift` would wrap
+* every entry's dependencies in `maybeDependencies` (since Foldkit 0.166).
+*/
+const messagesAs = (entries, toParentMessage) => Record.map(entries, (entry) => ({
+	...entry,
+	dependenciesToStream: (dependencies, read) => Stream.map(entry.dependenciesToStream(dependencies, read), toParentMessage)
+}));
+/**
+* An answer with what it read folded into its patches, one per row, so a list
+* is placed by every value the answer wrote, a derived field it read included.
+*/
+const withAnswerRead = (answer) => {
+	if (answer.read === void 0) return answer;
+	const rows = /* @__PURE__ */ new Map();
+	for (const patch of [...answer.entities, ...answer.read.result.entities]) {
+		const key = entityKey(patch.entity, patch.id);
+		const held = rows.get(key);
+		rows.set(key, held === void 0 ? patch : {
+			...held,
+			values: {
+				...held.values,
+				...patch.values
+			}
+		});
+	}
+	return {
+		...answer,
+		entities: [...rows.values()]
+	};
+};
+const brandEntries = (entries) => Subscription.make()(() => entries);
+/** The bound domain: the descriptor, the binding, and the operations over them. */
+const bindDomain = (definition, ref, options = {}) => {
+	const operators = options.operators ?? Operators.kernel;
+	const bound = bindRemote(definition, ref, operators);
+	const store = bound.store;
+	const viewerOf = options.viewer ?? (() => Option.none());
+	const contextOf = (model) => ({
+		viewer: viewerOf(model),
+		now: Option.none()
+	});
+	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.
+	*
+	* Resolved here rather than in the pure reducer because this is the only
+	* place with both the Model and the registry, and two separate things needed
+	* one or the other.
+	*
+	* **The declared policy reaches the decision.** `Query.connection(E, { live })`
+	* has always been typed, documented, carried on the descriptor and encoded in
+	* the Message schema — and nothing ever put it on a Message, so every live
+	* insert took the default whatever an application asked for. It does now.
+	*
+	* **A row the client can judge does not need a policy.** The policy exists
+	* because nothing could tell whether an inserted row belonged to the query.
+	* Where the body says it does not, `ignore` is not a guess. Where the body
+	* says it does, or the client cannot tell — a row it never fetched, or holds
+	* without a field the body reads — the declared policy is the answer, exactly
+	* as it was meant to be.
+	*
+	* Only membership is decided here. *Where* a row sorts needs text collation,
+	* which is the backend's, so the position the event carries stands.
+	*/
+	const livePolicyFor = (model, event) => {
+		if (event._tag !== "ConnectionInsert") return void 0;
+		const identity = event.connection;
+		const descriptor = definition.registry.queries.get(identity.slice(0, identity.indexOf("\0")));
+		const declared = (descriptor?.Result)?.live;
+		if (descriptor?.body === void 0) return declared;
+		const encoded = JSON.parse(identity.slice(identity.indexOf("\0") + 1));
+		return belongsEncoded(storeOf(bound, model), descriptor, encoded, entityKey(event.edge.ref.entity, event.edge.ref.id), operators, contextOf(model)) === "no" ? {
+			prepend: "ignore",
+			append: "ignore"
+		} : declared;
+	};
+	const reduce = (model, message) => {
+		const live = message._tag === "LiveReceived" ? message : void 0;
+		const resolved = live === void 0 || live.policy !== void 0 ? message : {
+			...live,
+			policy: livePolicyFor(model, live.event)
+		};
+		const remote = store.get(model);
+		const reduced = updateRemote(remote, resolved);
+		const answer = message._tag === "MutationSucceeded" ? message : void 0;
+		const next = answer === void 0 ? placedNews(reduced, newsOf(message), remote.entities, contextOf(model)) : impactOf(reduced, remote.mutations.applied.has(answer.requestId) ? answer : withAnswerRead(answer), remote.entities, contextOf(model));
+		const checked = answer === void 0 || options.verifyPredictions !== true ? next : withAnswerChecked(model, remote, next, answer);
+		return checked === remote ? model : store.set(model, checked);
+	};
+	/**
+	* `after` with each part of the request's prediction the answer disagreed
+	* with (`verifyPredictions`): a field it showed that the answer holds
+	* otherwise (`Value`), and a row it left without fields the client showed
+	* (`Gap`).
+	*/
+	const withAnswerChecked = (model, before, after, answer) => {
+		const { requestId } = answer;
+		if (before.mutations.applied.has(requestId)) return after;
+		const mutation = Option.map(Option.fromUndefinedOr(before.mutations.writes.get(requestId)), (write) => write.mutation);
+		const settled = store.set(model, after);
+		const projections = [...readers.values()].flatMap((resolvedAt) => resolvedAt(settled).map(({ projection }) => projection));
+		const found = [...valueMismatches(requestId, mutation, before, after, answer), ...answerGaps(requestId, mutation, before.optimistic, after.optimistic, visibleStoreOf(after.entities, after.optimistic, operators), planAsked(unverified(after), askedUnion(projections), {}, operators).requirements)];
+		return found.length === 0 ? after : {
+			...after,
+			diagnostics: withDiagnostics(after.diagnostics, found)
+		};
+	};
+	/**
+	* `remote` with each list placed only to be checked (`placed`) read as it
+	* would be without the check: such a list is fetched for its page, and a
+	* stale list plans no reads of its rows, so a gap in them would go unseen.
+	*/
+	const unverified = (remote) => {
+		const checked = Object.keys(remote.placed).filter((identity) => remote.connections[identity] !== void 0);
+		if (checked.length === 0) return remote;
+		const connections = { ...remote.connections };
+		for (const identity of checked) connections[identity] = {
+			...connections[identity],
+			stale: false
+		};
+		return {
+			...remote,
+			connections
+		};
+	};
+	/**
+	* Each field the request's layer showed that its answer carries another
+	* value of. A field the answer does not carry is the `Gap`'s; one a request
+	* still pending also patches shows that request's value before and after,
+	* so it is not judged.
+	*/
+	const valueMismatches = (requestId, mutation, before, after, answer) => {
+		const layer = before.optimistic.layers.find((each) => each.id === requestId);
+		if (layer === void 0) return [];
+		const shown = visibleStoreOf(before.entities, before.optimistic, operators);
+		const answered = /* @__PURE__ */ new Map();
+		for (const row of [...answer.entities, ...answer.read?.result.entities ?? []]) {
+			const key = entityKey(row.entity, row.id);
+			answered.set(key, {
+				...answered.get(key),
+				...row.values
+			});
+		}
+		const stillPatched = new Set(after.optimistic.layers.flatMap((each) => each.patches.flatMap((patch) => patchedFields(patch).map((field) => `${entityKey(patch.entity, patch.id)}.${field}`))));
+		return layer.patches.flatMap((patch) => {
+			const key = entityKey(patch.entity, patch.id);
+			const values = answered.get(key);
+			const entry = shown[key];
+			if (values === void 0 || entry === void 0 || entry.tombstone) return [];
+			return patchedFields(patch).flatMap((field) => stillPatched.has(`${key}.${field}`) || !entry.present.has(field) || !Object.hasOwn(values, field) || sameData(entry.values[field], values[field]) ? [] : [predictionMismatch(PredictionPart.Value({
+				requestId,
+				mutation,
+				entity: patch.entity,
+				id: patch.id,
+				field,
+				shown: entry.values[field],
+				answered: values[field]
+			}))]);
+		});
+	};
+	/** The registered query a connection identity names, and its encoded input. */
+	const queryOf = (identity) => {
+		const separator = identity.indexOf("\0");
+		const descriptor = definition.registry.queries.get(identity.slice(0, separator));
+		if (descriptor === void 0) return Option.none();
+		const encoded = JSON.parse(identity.slice(separator + 1));
+		const over = descriptor.body?.entity.name;
+		const filtered = (over === void 0 ? void 0 : definition.registry.filtered.get(over)) ?? [];
+		return Option.some({
+			descriptor,
+			encoded,
+			filtered
+		});
+	};
+	/**
+	* `pages` with each change to a row they hold placed, judged against
+	* `store`: a row that moved goes where the body's order puts it, and one
+	* that stopped matching leaves. A row a pending write creates joins where
+	* the body puts it, since the write holds all it is. Another row a change
+	* brings in is not added, since what the list selects of it may not be
+	* loaded, and a change the client cannot place leaves the row where it is.
+	*/
+	const placedHeld = (identity, pages, changes, store, context) => {
+		const query = queryOf(identity);
+		if (Option.isNone(query)) return pages;
+		const holds = new Set(items(pages).map((edge) => entityKey(edge.ref.entity, edge.ref.id)));
+		let placed = pages;
+		for (const change of changes) {
+			const created = EntityChange.match(change, {
+				Changed: ({ created }) => created,
+				Deleted: () => false
+			});
+			if (!holds.has(entityKey(change.entity, change.id)) && !created) continue;
+			placed = Impact.$match(impactOn({
+				...query.value,
+				connection: placed,
+				holds
+			}, store, change, operators, context), {
+				Kept: () => placed,
+				Placed: ({ connection }) => connection,
+				Invalidated: () => placed
+			});
+		}
+		return placed;
+	};
+	/**
+	* What a list body's context reads while pending layers are placed: the
+	* viewer the newest operation was predicted for. The viewer is the
+	* reader's, so every operation since the last `forget` names the same one.
+	*/
+	const layersContext = (layers) => {
+		const viewer = [...layers].reverse().find((layer) => Option.isSome(layer.viewer))?.viewer;
+		return viewer === void 0 ? void 0 : {
+			viewer,
+			now: Option.none()
+		};
+	};
+	/**
+	* A loaded list with the pending layers placed in its pages, so a row a
+	* pending edit moves, or takes out of the list, shows where its answer
+	* will be placed until the edit settles.
+	*/
+	const pendingPlaced = (remote, identity, pages) => {
+		const { layers } = remote.optimistic;
+		if (layers.length === 0) return pages;
+		return memoRead([
+			pages,
+			layers,
+			remote.entities
+		], `placed:${identity}`, () => placedHeld(identity, pages, changesOf({ entities: resolvedPatches(remote.entities, remote.optimistic, operators) }, remote.entities), visibleStoreOf(remote.entities, remote.optimistic, operators), layersContext(layers)));
+	};
+	/**
+	* The edges a loaded list shows: its pages with pending edits placed, and
+	* each row an insert overlay shows (a pending create, a confirmed or a live
+	* insert) where the body's order puts it, or left out when it sorts past
+	* what is loaded. An overlay says a row is in the list; in a list the
+	* client can place, the order says where. A row it cannot place stays at
+	* the end its overlay names.
+	*/
+	const shownEdges = (remote, identity, connection) => {
+		const pages = pendingPlaced(remote, identity, connection);
+		const shown = remote.optimistic.overlays.some((overlay) => overlay.connection === identity && overlay.position !== "remove") ? insertsPlaced(remote, identity, pages) : {
+			pages,
+			overlays: remote.optimistic.overlays
+		};
+		return visibleItems(shown.pages, identity, shown.overlays, goneIn(remote.entities, remote.optimistic));
+	};
+	const insertsPlaced = (remote, identity, pages) => {
+		const { overlays } = remote.optimistic;
+		const store = visibleStoreOf(remote.entities, remote.optimistic, operators);
+		return memoRead([
+			pages,
+			overlays,
+			store
+		], `inserted:${identity}`, () => {
+			const query = queryOf(identity);
+			const body = Option.isSome(query) ? query.value.descriptor.body : void 0;
+			if (Option.isNone(query) || body === void 0) return {
+				pages,
+				overlays
+			};
+			const inserted = /* @__PURE__ */ new Map();
+			for (const overlay of overlays) {
+				if (overlay.connection !== identity || overlay.position === "remove") continue;
+				for (const edge of overlay.edges) inserted.set(edge.key, edge);
+			}
+			const held = new Set(items(pages).map((edge) => edge.key));
+			let placed = pages;
+			const outside = [];
+			for (const edge of inserted.values()) {
+				if (held.has(edge.key)) continue;
+				const key = entityKey(edge.ref.entity, edge.ref.id);
+				RowPlace.$match(placeIn(store, placed, body, query.value.encoded, key, operators), {
+					Before: (place) => void (placed = withEdge(placed, edge, place)),
+					End: (place) => void (placed = withEdge(placed, edge, place)),
+					Outside: () => void outside.push(edge),
+					Unknown: () => void 0
+				});
+			}
+			return {
+				pages: placed,
+				overlays: outside.length === 0 ? overlays : [...overlays, {
+					id: "placed:outside",
+					connection: identity,
+					edges: outside,
+					position: "remove"
+				}]
+			};
+		});
+	};
+	/**
+	* The loaded lists with what the server said of rows they hold placed: a
+	* read or a live patch that changes a held row's ordering or filtered field
+	* moves it, or takes it out, as a mutation's answer does. A list it cannot
+	* place stands as it is, as a read is no write: its own refetch or live
+	* stream says otherwise. Only a value the client held before counts, so a
+	* row's first read judges nothing.
+	*/
+	const placedNews = (remote, news, before, context) => {
+		if (news.length === 0) return remote;
+		const held = news.map((patch) => {
+			const values = before[entityKey(patch.entity, patch.id)]?.values ?? {};
+			return {
+				...patch,
+				values: Object.fromEntries(Object.entries(patch.values).filter(([field]) => Object.hasOwn(values, field)))
+			};
+		});
+		const changes = changesOf({ entities: held }, before);
+		if (changes.length === 0) return remote;
+		const placed = {};
+		for (const [identity, pages] of Object.entries(remote.connections)) {
+			const after = placedHeld(identity, pages, changes, remote.entities, context);
+			if (after !== pages) placed[identity] = after;
+		}
+		return withPlacements(remote, placed, []);
+	};
+	/** The rows a read or a live patch says the server holds now. */
+	const newsOf = (message) => {
+		if (message._tag === "ReadReceived") return message.result.entities;
+		if (message._tag !== "LiveReceived") return [];
+		const event = message.event;
+		if (event._tag !== "EntityPatched") return [];
+		return [{
+			entity: event.ref.entity,
+			id: event.ref.id,
+			values: event.values
+		}];
+	};
+	/**
+	* The loaded connections as a write left them: each judged by its body
+	* against the store as the write left it, a change it can place placed in
+	* its pages, and one it cannot invalidated for its read entry to fetch.
+	*/
+	const impactOf = (remote, answer, before, context) => {
+		const changes = changesOf(answer, before);
+		if (changes.length === 0) return remote;
+		const named = /* @__PURE__ */ new Map();
+		for (const change of answer.connections ?? []) {
+			const keys = named.get(change.connection) ?? /* @__PURE__ */ new Set();
+			keys.add(change.edge.key);
+			named.set(change.connection, keys);
+		}
+		const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
+		const placed = {};
+		const invalidated = [];
+		for (const identity of Object.keys(remote.connections)) {
+			const answered = named.get(identity);
+			const judged = answered === void 0 ? changes : changes.filter((change) => !answered.has(entityKey(change.entity, change.id)));
+			if (judged.length === 0) continue;
+			const query = queryOf(identity);
+			if (Option.isNone(query)) continue;
+			const original = remote.connections[identity];
+			const holds = new Set(visibleItems(original, identity, remote.optimistic.overlays, goneIn(remote.entities, remote.optimistic)).map((edge) => entityKey(edge.ref.entity, edge.ref.id)));
+			let pages = original;
+			let invalid = false;
+			for (const change of judged) {
+				const held = {
+					...query.value,
+					connection: pages,
+					holds
+				};
+				const after = Impact.$match(impactOn(held, visible, change, operators, context), {
+					Kept: () => Option.some(pages),
+					Placed: ({ connection }) => Option.some(connection),
+					Invalidated: () => Option.none()
+				});
+				if (Option.isNone(after)) {
+					invalid = true;
+					break;
+				}
+				pages = after.value;
+			}
+			if (invalid) invalidated.push(identity);
+			else if (pages !== original) placed[identity] = pages;
+		}
+		return withPlacements(remote, placed, invalidated);
+	};
+	/**
+	* The lists placed and invalidated. Under `verifyPredictions`, each placed
+	* list is fetched too, and the order it was placed in kept to compare with
+	* the server's page.
+	*/
+	const withPlacements = (remote, placed, invalidated) => {
+		const identities = Object.keys(placed);
+		if (identities.length === 0) return invalidateConnections(remote, invalidated);
+		const withPlaced = {
+			...remote,
+			connections: {
+				...remote.connections,
+				...placed
+			}
+		};
+		if (options.verifyPredictions !== true) return invalidateConnections(withPlaced, invalidated);
+		const firstPage = (connection) => (connection?.segments[0]?.edges ?? []).map((edge) => edge.key);
+		const orders = Object.fromEntries(identities.map((identity) => {
+			const order = firstPage(placed[identity]);
+			const kept = new Set(order);
+			return [identity, {
+				order,
+				dropped: firstPage(remote.connections[identity]).filter((key) => !kept.has(key))
+			}];
+		}));
+		return invalidateConnections({
+			...withPlaced,
+			placed: {
+				...remote.placed,
+				...orders
+			}
+		}, [...invalidated, ...identities]);
+	};
+	const assertOwned = (entry) => assertOwnedBy(bound.contract, entry);
+	/**
+	* What the reader is shown of each entity in `model`, and what the write
+	* itself shows (`predicted`), for its answer to carry (#245, #265).
+	*/
+	const shownAt = (model, predicted) => shownOf(askedUnion([...readers.values()].flatMap((resolvedAt) => resolvedAt(model).map(({ projection }) => projection))), predicted);
+	/**
+	* A durable write's request id, which is its operation id: this page's
+	* session and the next in its sequence, unique across tabs and loads. Only
+	* a retry names one, and only one the outbox holds.
+	*/
+	const durableId = (remote, mutation, given) => {
+		if (given !== void 0) {
+			if (remote.outbox.queue.some((queued) => operationOf(queued) === given)) return given;
+			throw new Error(`[foldkit-remote] Data.mutate(${mutation}, { durable: true, requestId: "${given}" }): a durable write is named by the outbox; pass no requestId`);
+		}
+		return Option.match(remote.outbox.session, {
+			onNone: () => {
+				throw new Error(`[foldkit-remote] Data.mutate(${mutation}, { durable: true }) before the outbox's restore has run: start init from Data.outbox(…).restore(model), as the runtime's flags, so a durable write has an id no other tab or page load uses`);
+			},
+			onSome: (session) => `${session}-${remote.mutations.sequence + 1}`
+		});
+	};
+	/** The descriptor a recorded write names; only a hand-built `MutationStarted` names another. */
+	const registeredMutation = (name) => {
+		const descriptor = definition.registry.mutations.get(name);
+		if (descriptor === void 0) throw new Error(`Remote: a failed write names mutation "${name}", which domain "${bound.contract.name}" does not register`);
+		return descriptor;
+	};
+	/**
+	* `prefetch` and `satisfy`, each Message they reduce also kept in `heard`,
+	* so `preload` can hand them to the Model as it is by the time they land.
+	*/
+	const prefetchInto = (model, projection, options, heard) => {
+		const hear = (current, message) => {
+			heard.push(message);
+			return reduce(current, message);
+		};
+		return Effect.gen(function* () {
+			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, operators).queries) {
+				const page = yield* queryRequestOf(query).pipe(Effect.flatMap((request) => client.query(request)));
+				current = hear(current, pageMessage(query.identity, page, true, query.window, query.select, now()));
+			}
+			const requirements = planAsked(store.get(current), askedOf(projection), planOptions, operators).requirements;
+			if (requirements.length === 0) return current;
+			const at = now();
+			const result = yield* client.read({
+				version: 5,
+				requests: requirements
+			});
+			return hear(current, {
+				_tag: "ReadReceived",
+				requests: requirements,
+				result,
+				now: at
+			});
+		});
+	};
+	const satisfyInto = (model, active, options, heard) => 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, projections) => {
+			const planned = planAsked(store.get(current), askedUnion(projections), planOptions, operators);
+			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, resolvedOf(entry, current).map(({ projection }) => projection)))) return current;
+			for (const entry of entries) for (const { projection } of resolvedOf(entry, current)) current = yield* prefetchInto(current, projection, { now }, heard);
+		}
+		const reading = entries.flatMap((entry) => resolvedOf(entry, current).filter(({ projection }) => plans(current, [projection])));
+		if (reading.length === 0) return current;
+		return yield* new RemoteUnsatisfied({
+			surfaces: reading.map(({ name }) => name),
+			passes
+		});
+	});
+	const domain = {
+		...definition,
+		...bound,
+		get: (selection, id) => Remote.select(bound, selection)(id),
+		live: (selection, id) => {
+			const projection = Remote.select(bound, selection)(id);
+			return {
+				...projection,
+				metadata: RemoteRequirements.of(...requirementsOf(projection).map((requirement) => ({
+					...requirement,
+					live: true
+				})))
+			};
+		},
+		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 = {};
+			for (const entry of Object.values(active)) assertOwned(entry);
+			for (const [key, entry] of Object.entries(active)) {
+				const resolvedAt = readers.get(entry) ?? memoizedResolved(entry);
+				readers.set(entry, resolvedAt);
+				const asked = (model) => askedUnion(resolvedAt(model).map(({ projection }) => projection));
+				entries[`${key}.read`] = observeEntry(bound, asked, identityMessage, options);
+				entries[`${key}.live`] = liveEntry(bound, (model) => liveAskOf(asked(model)), identityMessage, options);
+			}
+			for (const identity of options.connections ?? []) keptConnections.add(connectionIdentity(identity));
+			entries.retain = {
+				dependenciesSchema: retentionRootsSchema,
+				modelToDependencies: (model) => rootsOf([...readers.values()].flatMap((resolvedAt) => resolvedAt(model).map(({ projection }) => projection)), { 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 = {}) => prefetchInto(model, projection, options, []),
+		satisfy: (model, active, options = {}) => satisfyInto(model, active, options, []),
+		preload: (model, active, options = {}) => {
+			Object.values(active).forEach(assertOwned);
+			return {
+				name: "Remote.preload",
+				args: { active: Object.keys(active).join(", ") },
+				effect: Effect.suspend(() => {
+					const heard = [];
+					return satisfyInto(model, active, options, heard).pipe(Effect.exit, Effect.map(() => ({
+						_tag: "Preloaded",
+						messages: heard
+					})));
+				})
+			};
+		},
+		query: (query, input, options) => {
+			assertRegistered(bound, "Query", definition.registry.queries, query.name);
+			const { select: given, live, ...window } = options;
+			const select = selectionOf(given);
+			for (const [side, size] of [["first", window.first], ["last", window.last]]) if (size !== void 0 && !(Number.isInteger(size) && size >= 0)) throw new Error(`Remote: query "${query.name}" asks for ${side}: ${String(size)}; a page size is a non-negative integer`);
+			if (live === true && window.first === void 0) throw new Error(`Remote: query "${query.name}" is read live without first; a list watched live is read again every tick, so it needs a size`);
+			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 contract = placeableReadContract(readContract(query.ref(input), select, window), query.body, operators);
+			const { ref, relation } = contract;
+			const requirement = live === true ? {
+				...contract.requirement,
+				live
+			} : contract.requirement;
+			const relationKey = stableStringify(relation);
+			const sizeOf = (remote) => windowSize(remote, ref);
+			const shown = (remote, connection) => cutToWindow(shownEdges(remote, ref.identity, connection), ref.window, sizeOf(remote));
+			const failedItem = (remote, connection) => {
+				if (Object.keys(remote.failures.fields).length === 0) return void 0;
+				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 {
+						_tag: "Failed",
+						error
+					};
+				}
+			};
+			const loadingItem = (remote, connection) => {
+				if (remote.loading.size === 0) return void 0;
+				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, operators);
+				return memoRead([
+					visible,
+					connection,
+					remote.optimistic.overlays
+				], `${ref.identity}\u0000${relationKey}\u0000${String(sizeOf(remote))}`, () => {
+					const rows = [];
+					let refreshing = connection.stale;
+					let missing = false;
+					const { edges, cutBefore, cutAfter } = shown(remote, connection);
+					for (const edge of edges) {
+						const key = entityKey(edge.ref.entity, edge.ref.id);
+						const assembled = assemble(visible, key, relation);
+						if (assembled === void 0) {
+							const unavailable = unavailableFailure(visible, key, relation);
+							if (unavailable !== void 0) return unavailable;
+							missing = true;
+							continue;
+						}
+						const decoded = decodeRow(select.schema, visible[key].values, assembled.values);
+						if (Result.isFailure(decoded)) return {
+							_tag: "Failed",
+							error: {
+								_tag: "DecodeError",
+								message: decoded.failure.message
+							}
+						};
+						refreshing ||= assembled.refreshing;
+						rows.push(decoded.success);
+					}
+					if (missing && rows.length === 0 && !deletedInWindow(items(connection), new Set(shownEdges(remote, ref.identity, connection).map((edge) => edge.key)), ref.window, sizeOf(remote), goneIn(remote.entities, remote.optimistic))) return;
+					const page = {
+						items: rows,
+						hasNext: cutAfter || hasNext(connection),
+						hasPrevious: cutBefore || hasPrevious(connection)
+					};
+					return refreshing || missing ? {
+						_tag: "Refreshing",
+						value: page
+					} : {
+						_tag: "Ready",
+						value: page
+					};
+				});
+			};
+			return {
+				Model: remoteDataSchema(pageSchema(select.schema)),
+				dependencies: [],
+				metadata: RemoteConnections.of(requirement),
+				ref,
+				selection: select,
+				read: (root) => {
+					const remote = store.get(root);
+					const connection = remote.connections[ref.identity];
+					const failure = remote.failures.connections[ref.identity];
+					if (connection === void 0 || connection.stale && connection.segments.length === 0) {
+						if (isQueryLoading(remote, ref.identity)) return { _tag: "Loading" };
+						return failure === void 0 ? { _tag: "Initial" } : {
+							_tag: "Failed",
+							error: failure
+						};
+					}
+					const read = readPage(remote, connection) ?? failedItem(remote, connection) ?? loadingItem(remote, connection) ?? { _tag: "Initial" };
+					if (failure === void 0) {
+						if (read._tag !== "Ready" && read._tag !== "Refreshing") return read;
+						const item = failedItem(remote, connection);
+						return item === void 0 ? read : {
+							_tag: "Failed",
+							error: item.error,
+							previous: read.value
+						};
+					}
+					switch (read._tag) {
+						case "Ready":
+						case "Refreshing": return {
+							_tag: "Failed",
+							error: failure,
+							previous: read.value
+						};
+						case "Failed": return read;
+						case "Initial":
+						case "Loading":
+						case "NotFound": return {
+							_tag: "Failed",
+							error: failure
+						};
+					}
+				}
+			};
+		},
+		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 ?? {}).flatMap((source) => {
+				const matched = resolvedOf(source, model).filter(({ projection: shown }) => connectionsOf(shown).some((connection) => connection.identity === ref.identity));
+				if (matched.length === 0) return [];
+				return [{
+					source,
+					names: matched.map(({ name }) => name)
+				}];
+			});
+			const body = definition.registry.queries.get(ref.query)?.body;
+			const [connection] = RemoteConnections.get(projection.metadata);
+			return {
+				domain: bound.contract.name,
+				query: ref.query,
+				input: Schema.encodeSync(ref.Input)(ref.input),
+				identity: ref.identity,
+				window: ref.window,
+				select: connection.select,
+				...body === void 0 ? {} : {
+					body: Query$1.show(body),
+					dependencies: explainedDependencies(Query$1.dependencies(body))
+				},
+				state: projection.read(model)._tag,
+				...options?.surfaces === void 0 ? {} : {
+					surfaces: reading.flatMap((read) => read.names),
+					activation: reading.flatMap((read) => {
+						const activation = "activation" in read.source ? read.source.activation : void 0;
+						return activation === void 0 ? [] : [{
+							surface: read.source.name,
+							...activation
+						}];
+					})
+				}
+			};
+		},
+		why: (model, projection, options) => {
+			const data = projection.read(model);
+			const asked = askedOf(projection);
+			const reading = (options?.surfaces === void 0 ? [] : Object.values(options.surfaces)).flatMap((entry) => {
+				const names = resolvedOf(entry, model).filter(({ projection: shown }) => covers(askedOf(shown), asked)).map(({ name }) => name);
+				return names.length === 0 ? [] : [{
+					entry,
+					names
+				}];
+			});
+			const surfaces = options?.surfaces === void 0 ? Option.none() : Option.some(reading.flatMap((read) => read.names));
+			const initial = data._tag !== "Initial" ? [] : [Option.match(surfaces, {
+				onNone: () => Why.NoActiveRecord(),
+				onSome: (names) => names.length === 0 ? Why.NotObserved() : Why.NotFetching({ surfaces: names })
+			})];
+			const remote = store.get(model);
+			const streams = asked.requirements.some((requirement) => requirement.live === true) || asked.connections.some((connection) => connection.live === true) ? reading.flatMap(({ entry }) => {
+				return Match.valueTags(domain.liveStatus(model, entry), {
+					Idle: () => [],
+					Live: () => [],
+					Reconnecting: ({ attempt, error }) => [Why.LiveReconnecting({
+						surface: entry.name,
+						attempt,
+						error
+					})],
+					Refused: ({ error }) => [Why.LiveRefused({
+						surface: entry.name,
+						error
+					})]
+				});
+			}) : [];
+			const reader = {
+				remote,
+				visible: visibleStoreOf(remote.entities, remote.optimistic, operators),
+				listOf: (identity) => ({
+					query: Option.match(queryOf(identity), {
+						onNone: () => identity,
+						onSome: (query) => query.descriptor.name
+					}),
+					identity
+				}),
+				bodyOf: (identity) => Option.flatMap(queryOf(identity), (query) => Option.map(Option.fromUndefinedOr(query.descriptor.body), (body) => ({
+					body,
+					encoded: query.encoded
+				}))),
+				edgesOf: ({ identity, window }) => {
+					const connection = remote.connections[identity] ?? emptyConnection;
+					const placed = shownEdges(remote, identity, connection);
+					return {
+						shown: cutToWindow(placed, window, windowSize(remote, {
+							identity,
+							window
+						})).edges,
+						placed,
+						pages: items(connection)
+					};
+				},
+				operators,
+				context: layersContext(remote.optimistic.layers)
+			};
+			return readWhy(data._tag, [
+				...initial,
+				...failedReasons(data),
+				...reasonsOf(reader, asked),
+				...streams
+			], surfaces);
+		},
+		timeline: (start, history, reads, options) => {
+			let before = start;
+			return history.flatMap((entry, index) => {
+				const from = before;
+				before = entry.model;
+				return Object.entries(reads).flatMap(([read, projection]) => {
+					const was = projection.read(from);
+					const is = projection.read(entry.model);
+					if (was._tag === is._tag) return [];
+					return [{
+						read,
+						index,
+						message: entry.message,
+						from: was._tag,
+						to: is._tag,
+						why: domain.why(entry.model, projection, options),
+						regression: regressed(was, is)
+					}];
+				});
+			});
+		},
+		filtered: (model, over, by, input) => {
+			assertRegistered(bound, "Query", definition.registry.queries, by.name);
+			const filters = by.body?.entity.name;
+			if (filters !== void 0 && filters !== over.selection.entity) throw new Error(`Remote: query "${by.name}" is over "${filters}", but the list is of "${over.selection.entity}", so it cannot filter it`);
+			const remote = store.get(model);
+			const connection = remote.connections[over.ref.identity];
+			const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
+			const among = (connection === void 0 ? [] : shownEdges(remote, over.ref.identity, connection)).map((edge) => entityKey(edge.ref.entity, edge.ref.id));
+			let judged;
+			try {
+				judged = matching(visible, by, input, {
+					among,
+					operators,
+					context: contextOf(model)
+				});
+			} catch (error) {
+				if (error instanceof QueryEvaluateError) return {
+					items: [],
+					complete: false
+				};
+				throw error;
+			}
+			const relation = relationOf(over.selection);
+			const items = [];
+			let assembledAll = true;
+			for (const key of judged.matched) {
+				const assembled = assemble(visible, key, relation);
+				if (assembled === void 0) {
+					assembledAll = false;
+					continue;
+				}
+				const decoded = decodeRow(over.selection.schema, visible[key].values, assembled.values);
+				if (Result.isFailure(decoded)) {
+					assembledAll = false;
+					continue;
+				}
+				items.push(decoded.success);
+			}
+			return {
+				items,
+				complete: judged.skipped.length === 0 && assembledAll && connection !== void 0 && !isGapped(connection) && !hasNext(connection) && !hasPrevious(connection)
+			};
+		},
+		refresh: (model, target, options) => Remote.refresh(bound, model, target, options),
+		forget: (model) => Remote.forget(bound, model),
+		overlay: (model, id, optimistic) => reduce(model, {
+			_tag: "OverlayShown",
+			id,
+			optimistic
+		}),
+		lift: (model, id) => reduce(model, {
+			_tag: "OverlayLifted",
+			id
+		}),
+		overlays: (model) => overlaysOf(store.get(model)),
+		visibleItems: (remote, connection) => {
+			const identity = connectionIdentity(connection);
+			return shownEdges(remote, identity, remote.connections[identity] ?? emptyConnection);
+		},
+		mutate: (model, mutation, input, options = {}) => {
+			assertRegistered(bound, "Mutation", definition.registry.mutations, mutation.name);
+			const remote = store.get(model);
+			const durable = options.durable === true;
+			const requestId = durable ? durableId(remote, mutation.name, options.requestId) : options.requestId ?? `${bound.contract.name}-${remote.mutations.sequence + 1}`;
+			const tempId = `${requestId}.tmp`;
+			const known = Option.fromUndefinedOr(remote.mutations.operations.get(requestId));
+			const viewer = viewerOf(model);
+			const visible = visibleStoreOf(remote.entities, remote.optimistic, bound.operators);
+			const predicted = mutation.write === void 0 ? void 0 : predictionOfWrite(mutation.write, input, options.keys, {
+				derived: definition.registry.derived,
+				store: visible,
+				viewer,
+				now: Option.fromUndefinedOr(options.now)
+			});
+			const write = mutation.write;
+			const refused = write === void 0 || options.optimistic !== void 0 ? Option.none() : Option.orElse(Option.map(forbiddenByWrite(write, input, options.keys, visible), ({ reason }) => remoteError(new RemoteForbidden({
+				message: Option.getOrElse(reason, () => "Forbidden"),
+				...Option.match(reason, {
+					onNone: () => ({}),
+					onSome: (said) => ({ reason: said })
+				})
+			}))), () => Option.map(brokenByWrite(write, input, options.keys, {
+				viewer,
+				now: Option.fromUndefinedOr(options.now)
+			}, visible, bound.operators), (held) => remoteError({
+				_tag: "RemoteMutationError",
+				message: held.message,
+				refusal: Schema.encodeUnknownSync(mutation.Refusal)({
+					_tag: "Invalid",
+					entity: Option.some(held.entity),
+					rule: Option.some(held.id),
+					message: held.message,
+					path: held.path
+				})
+			})));
+			const optimistic = Option.isSome(refused) ? void 0 : typeof options.optimistic === "function" ? options.optimistic({
+				requestId,
+				tempId
+			}) : options.optimistic ?? predicted;
+			const queued = durable && Option.isNone(refused);
+			const started = updateRemote(remote, {
+				_tag: "MutationStarted",
+				requestId,
+				...optimistic === void 0 ? {} : { optimistic },
+				...Option.isSome(viewer) ? { viewer: viewer.value } : {},
+				write: {
+					mutation: mutation.name,
+					input,
+					...options.keys === void 0 ? {} : { keys: options.keys },
+					...options.now === void 0 ? {} : { now: options.now },
+					...queued ? { durable: {
+						input: Schema.encodeUnknownSync(mutation.Input)(input),
+						shown: shownAt(model, optimistic ?? [])
+					} } : {}
+				}
+			});
+			const startedModel = store.set(model, started);
+			return {
+				model: startedModel,
+				requestId,
+				tempId,
+				command: {
+					name: `Remote.mutate(${mutation.name})`,
+					args: { requestId },
+					effect: Effect.flatMap(Effect.sync(() => Option.getOrElse(known, mintOperation)), (operation) => queued ? Effect.succeed({
+						_tag: "MutationQueued",
+						requestId
+					}) : Option.isSome(refused) ? Effect.succeed({
+						_tag: "MutationFailed",
+						requestId,
+						error: refused.value,
+						operation
+					}) : mutateRemote(mutation, input, requestId, {
+						keys: options.keys,
+						operation,
+						shown: shownAt(startedModel, optimistic ?? []),
+						now: options.now
+					}).pipe(Effect.matchEffect({
+						onFailure: (error) => Effect.succeed({
+							_tag: "MutationFailed",
+							requestId,
+							error: remoteError(error),
+							operation
+						}),
+						onSuccess: (outcome) => Effect.map(Clock.currentTimeMillis, (at) => ({
+							_tag: "MutationSucceeded",
+							requestId,
+							entities: outcome.entities,
+							connections: outcome.connections,
+							deleted: outcome.deleted,
+							...outcome.read === void 0 ? {} : { read: outcome.read },
+							now: at
+						}))
+					})))
+				}
+			};
+		},
+		mutation: (model, requestId) => mutationStatus(store.get(model).mutations, requestId),
+		refusal: (model, requestId, mutation) => {
+			const status = mutationStatus(store.get(model).mutations, requestId);
+			return status._tag === "Failed" ? refusalOf(status.error, mutation) : Option.none();
+		},
+		failedWrites: (model, mutation) => {
+			if (mutation !== void 0) assertRegistered(bound, "Mutation", definition.registry.mutations, mutation.name);
+			const { mutations } = store.get(model);
+			return [...mutations.failed].flatMap((requestId) => {
+				const write = mutations.writes.get(requestId);
+				const error = mutations.errors.get(requestId);
+				if (write === void 0 || error === void 0 || mutations.pending.has(requestId)) return [];
+				if (mutation !== void 0 && write.mutation !== mutation.name) return [];
+				const descriptor = registeredMutation(write.mutation);
+				return [{
+					requestId,
+					mutation: descriptor,
+					input: write.input,
+					error,
+					refusal: refusalOf(error, descriptor)
+				}];
+			});
+		},
+		retry: (model, requestId) => {
+			const { mutations, outbox } = store.get(model);
+			const write = mutations.writes.get(requestId);
+			if (write === void 0 || mutationStatus(mutations, requestId)._tag !== "Failed") return Option.none();
+			return Option.some(domain.mutate(model, registeredMutation(write.mutation), write.input, {
+				requestId,
+				optimistic: write.optimistic,
+				keys: write.keys,
+				now: Option.getOrUndefined(write.now),
+				durable: outbox.queue.some((queued) => operationOf(queued) === requestId)
+			}));
+		},
+		dismiss: (model, requestId) => {
+			const remote = store.get(model);
+			const dismissed = dismissQueued(remote, requestId);
+			if (dismissed !== remote) return store.set(model, dismissed);
+			if (mutationStatus(remote.mutations, requestId)._tag !== "Failed") return model;
+			return store.set(model, {
+				...remote,
+				mutations: forgetFailure(remote.mutations, requestId)
+			});
+		},
+		liveStatus: (model, active) => {
+			assertOwned(active);
+			const resolvedAt = readers.get(active) ?? memoizedResolved(active);
+			const live = liveAskOf(askedUnion(resolvedAt(model).map(({ projection }) => projection)));
+			if (live.requirements.length === 0 && live.queries.length === 0) return { _tag: "Idle" };
+			const remote = store.get(model);
+			const stream = liveStreamKey(live);
+			const health = remote.streams[stream];
+			if (health === void 0) return { _tag: "Live" };
+			return Option.match(health.refused, {
+				onSome: (error) => ({
+					_tag: "Refused",
+					error
+				}),
+				onNone: () => remote.gaps.has(stream) ? {
+					_tag: "Reconnecting",
+					attempt: health.failures,
+					error: health.error
+				} : { _tag: "Live" }
+			});
+		},
+		outboxStatus: (model) => outboxStatus(store.get(model).outbox),
+		reduce,
+		inspect: (model) => inspectRemote(store.get(model)),
+		persistence: (options) => {
+			const connections = (options.connections ?? []).map(connectionIdentity);
+			const snapshotOf = options.snapshot ?? ((remote) => RemotePersistence.snapshotOf(remote, { connections }));
+			const debounce = options.debounce ?? "250 millis";
+			let last = {
+				entities: emptyStore,
+				connections: {},
+				scope: "",
+				text: Option.none()
+			};
+			const textOf = (remote, scope) => {
+				if (last.entities !== remote.entities || last.connections !== remote.connections || last.scope !== scope) last = {
+					entities: remote.entities,
+					connections: remote.connections,
+					scope,
+					text: Option.fromUndefinedOr(RemotePersistence.dehydrate(snapshotOf(remote), {
+						scope,
+						maxBytes: options.maxBytes
+					}))
+				};
+				return last.text;
+			};
+			const hydratedFrom = (key, scope) => RemotePersistence.restore({
+				key,
+				scope,
+				maxBytes: options.maxBytes
+			}).pipe(Effect.map((snapshot) => ({
+				_tag: "Hydrated",
+				entities: snapshot.entities,
+				connections: snapshot.connections,
+				merge: "preserve-existing",
+				from: key
+			})), Effect.option);
+			const restoreEntry = {
+				dependenciesSchema: Schema.Struct({
+					key: Schema.String,
+					scope: Schema.String,
+					restored: Schema.Boolean
+				}),
+				modelToDependencies: (model) => {
+					const key = options.key(model);
+					return {
+						key,
+						scope: options.scope(model),
+						restored: Option.contains(store.get(model).restoredFrom, key)
+					};
+				},
+				dependenciesToStream: ({ key, scope, restored }) => restored ? Stream.empty : Stream.fromEffect(hydratedFrom(key, scope)).pipe(Stream.flatMap(Option.match({
+					onNone: () => Stream.empty,
+					onSome: Stream.make
+				})))
+			};
+			const save = {
+				dependenciesSchema: Schema.Struct({
+					key: Schema.String,
+					restored: Schema.Boolean,
+					text: Schema.OptionFromNullOr(Schema.String)
+				}),
+				modelToDependencies: (model) => {
+					const remote = store.get(model);
+					const key = options.key(model);
+					const restored = Option.contains(remote.restoredFrom, key);
+					return {
+						key,
+						restored,
+						text: restored ? textOf(remote, options.scope(model)) : Option.none()
+					};
+				},
+				dependenciesToStream: ({ key, restored, text }) => restored ? Stream.fromEffect(Effect.gen(function* () {
+					yield* Effect.sleep(debounce);
+					const kv = yield* KeyValueStore.KeyValueStore;
+					yield* Option.match(text, {
+						onNone: () => kv.remove(key),
+						onSome: (written) => kv.set(key, written)
+					});
+				}).pipe(Effect.ignore)).pipe(Stream.drain) : Stream.empty
+			};
+			return {
+				key: `persistence:${bound.contract.name}`,
+				handles: [],
+				subscriptions: Subscription.make()(() => ({
+					"persistence.restore": restoreEntry,
+					"persistence.save": save
+				})),
+				restore: (model) => Effect.map(hydratedFrom(options.key(model), options.scope(model)), Option.match({
+					onNone: () => model,
+					onSome: (message) => reduce(model, message)
+				}))
+			};
+		},
+		outbox: (options) => {
+			/** How this version reads a stored input of `mutation`; none for one it does not register. */
+			const inputOf = (mutation) => Option.map(Option.fromUndefinedOr(definition.registry.mutations.get(mutation)), (descriptor) => (input) => Option.map(Schema.decodeUnknownOption(descriptor.Input)(input), (decoded) => ({ decoded })));
+			const readOf = (key, scope, stored, extra = {}) => ({
+				_tag: "OutboxRead",
+				key,
+				scope,
+				entries: readEntries(stored, inputOf),
+				done: stored.done,
+				...extra
+			});
+			/** Tells the other tabs on `key` the store changed, with the answer that changed it. */
+			const announce = (key, outcome) => Effect.sync(() => Option.map(channelFor(key), (channel) => {
+				channel.postMessage({ outcome: Option.getOrUndefined(outcome) });
+				channel.close();
+			}));
+			/** The store with `change` merged in, under its lock, so two tabs never write it at once. */
+			const writeStored = (key, scope, change) => withLock(storeLock(key), Effect.gen(function* () {
+				if (yield* othersWaiting(key, scope)) return yield* Effect.fail(/* @__PURE__ */ new Error(`the store under ${key} holds another scope's waiting writes; give each principal a key of its own`));
+				const merged = mergeStored(yield* readStored(key, scope), change);
+				yield* (yield* KeyValueStore.KeyValueStore).set(key, storedText(merged, scope));
+				return merged;
+			}));
+			/** What the store holds, as a page reads it; this page's own queue, and why, where it cannot be read. */
+			const restored = (key, scope, session) => readStored(key, scope).pipe(Effect.map((stored) => readOf(key, scope, stored, Option.match(session, {
+				onNone: () => ({}),
+				onSome: (minted) => ({ session: minted })
+			}))), Effect.catch((error) => Effect.succeed(readOf(key, scope, {
+				entries: [],
+				done: []
+			}, {
+				...Option.match(session, {
+					onNone: () => ({}),
+					onSome: (minted) => ({ session: minted })
+				}),
+				unsaved: error.message
+			}))));
+			/** Whether the page's queue is the one stored under `key` for `scope`. */
+			const holding = (outbox, key, scope) => Option.contains(outbox.key, key) && Option.contains(outbox.scope, scope);
+			const minted = (has) => has ? Effect.succeed(Option.none()) : Effect.sync(() => Option.some(mintOperation()));
+			let lastText = {
+				outbox: void 0,
+				scope: "",
+				text: ""
+			};
+			const textOf = (outbox, scope) => {
+				if (lastText.outbox !== outbox || lastText.scope !== scope) lastText = {
+					outbox,
+					scope,
+					text: storedText(storedOf(outbox), scope)
+				};
+				return lastText.text;
+			};
+			const restoreEntry = {
+				dependenciesSchema: Schema.Struct({
+					key: Schema.String,
+					scope: Schema.String,
+					restored: Schema.Boolean,
+					session: Schema.Boolean
+				}),
+				modelToDependencies: (model) => {
+					const { outbox } = store.get(model);
+					const key = options.key(model);
+					const scope = options.scope(model);
+					return {
+						key,
+						scope,
+						restored: holding(outbox, key, scope),
+						session: Option.isSome(outbox.session)
+					};
+				},
+				dependenciesToStream: ({ key, scope, restored: done, session }) => done ? Stream.empty : Stream.fromEffect(Effect.flatMap(minted(session), (mint) => restored(key, scope, mint)))
+			};
+			const save = {
+				dependenciesSchema: Schema.Struct({
+					key: Schema.String,
+					scope: Schema.String,
+					text: Schema.OptionFromNullOr(Schema.String)
+				}),
+				modelToDependencies: (model) => {
+					const { outbox } = store.get(model);
+					const key = options.key(model);
+					const scope = options.scope(model);
+					return {
+						key,
+						scope,
+						text: holding(outbox, key, scope) ? Option.some(textOf(outbox, scope)) : Option.none()
+					};
+				},
+				dependenciesToStream: ({ key, scope, text }) => Option.match(text, {
+					onNone: () => Stream.empty,
+					onSome: (written) => {
+						const mine = storedFromText(written);
+						return Stream.fromEffect(writeStored(key, scope, mine).pipe(Effect.tap(() => announce(key, Option.none())), Effect.map((merged) => readOf(key, scope, merged)), Effect.catch((error) => Effect.succeed(readOf(key, scope, mine, { unsaved: error.message })))));
+					}
+				})
+			};
+			/** Sends `write`, as the one tab on `key` that sends, until the server answers it. */
+			const sent = (key, scope, write) => Stream.callback((queue) => {
+				const emit = (message) => Queue.offer(queue, message);
+				/**
+				* The outcome told this tab and the others first, so each settles
+				* with the server's answer, then written to the store before the
+				* lock goes, so the next sender reads it.
+				*/
+				const settle = (message, change) => emit(message).pipe(Effect.andThen(announce(key, Option.some(message))), Effect.andThen(writeStored(key, scope, change)), Effect.andThen(announce(key, Option.none())), Effect.ignore);
+				const operation = write.operation;
+				return withLock(sendLock(key), Effect.gen(function* () {
+					const there = yield* Effect.option(readStored(key, scope));
+					if (Option.isSome(there) && settledIn(there.value, operation)) {
+						yield* emit(readOf(key, scope, there.value));
+						return;
+					}
+					const mutation = registeredMutation(write.mutation);
+					const input = Schema.decodeUnknownSync(mutation.Input)(write.input);
+					for (let attempt = 1;; attempt++) {
+						const result = yield* Effect.result(mutateRemote(mutation, input, operation, {
+							keys: write.keys,
+							operation,
+							shown: write.shown,
+							now: write.now
+						}));
+						if (Result.isSuccess(result)) {
+							const outcome = result.success;
+							const at = yield* Clock.currentTimeMillis;
+							return yield* settle({
+								_tag: "MutationSucceeded",
+								requestId: operation,
+								entities: outcome.entities,
+								connections: outcome.connections,
+								deleted: outcome.deleted,
+								...outcome.read === void 0 ? {} : { read: outcome.read },
+								now: at
+							}, {
+								entries: [],
+								done: [operation]
+							});
+						}
+						const error = remoteError(result.failure);
+						if (result.failure._tag === "Unreachable") {
+							yield* emit({
+								_tag: "OutboxDelayed",
+								requestId: operation,
+								attempt,
+								error
+							});
+							yield* Effect.race(Effect.flatMap(backoff(attempt, options.retry), Effect.sleep), onlineAgain);
+							continue;
+						}
+						return yield* settle({
+							_tag: "MutationFailed",
+							requestId: operation,
+							error,
+							operation
+						}, {
+							entries: [{
+								...write,
+								revision: write.revision + 1,
+								state: {
+									_tag: "Failed",
+									error
+								}
+							}],
+							done: []
+						});
+					}
+				})).pipe(Effect.ensuring(Queue.end(queue)));
+			});
+			let lastHead = {
+				outbox: void 0,
+				head: Option.none()
+			};
+			const headTextOf = (outbox) => {
+				if (lastHead.outbox !== outbox) lastHead = {
+					outbox,
+					head: Option.map(headOf(outbox), (write) => JSON.stringify(write))
+				};
+				return lastHead.head;
+			};
+			const send = {
+				dependenciesSchema: Schema.Struct({
+					key: Schema.String,
+					scope: Schema.String,
+					head: Schema.OptionFromNullOr(Schema.String)
+				}),
+				modelToDependencies: (model) => {
+					const { outbox } = store.get(model);
+					const key = options.key(model);
+					const scope = options.scope(model);
+					return {
+						key,
+						scope,
+						head: holding(outbox, key, scope) ? headTextOf(outbox) : Option.none()
+					};
+				},
+				dependenciesToStream: ({ key, scope, head }) => Option.match(head, {
+					onNone: () => Stream.empty,
+					onSome: (text) => sent(key, scope, Schema.decodeUnknownSync(StoredWrite)(JSON.parse(text)))
+				})
+			};
+			/** What another tab announced: the answer it heard first, then the store as it now is. */
+			const heard = (key, scope, data) => Effect.map(restored(key, scope, Option.none()), (read) => [...Option.toArray(outcomeOf(data)), read]);
+			const watch = {
+				dependenciesSchema: Schema.Struct({
+					key: Schema.String,
+					scope: Schema.String,
+					restored: Schema.Boolean
+				}),
+				modelToDependencies: (model) => {
+					const key = options.key(model);
+					const scope = options.scope(model);
+					return {
+						key,
+						scope,
+						restored: holding(store.get(model).outbox, key, scope)
+					};
+				},
+				dependenciesToStream: ({ key, scope, restored: read }) => read ? Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => Option.map(channelFor(key), (channel) => {
+					channel.onmessage = (event) => {
+						Queue.offerUnsafe(queue, event.data);
+					};
+					return channel;
+				})), (channel) => Effect.sync(() => Option.map(channel, (open) => open.close())))).pipe(Stream.mapEffect((data) => heard(key, scope, data)), Stream.flatMap((messages) => Stream.fromIterable(messages))) : Stream.empty
+			};
+			return {
+				key: `outbox:${bound.contract.name}`,
+				handles: [],
+				subscriptions: Subscription.make()(() => ({
+					"outbox.restore": restoreEntry,
+					"outbox.save": save,
+					"outbox.send": send,
+					"outbox.watch": watch
+				})),
+				restore: (model) => Effect.map(Effect.flatMap(minted(Option.isSome(store.get(model).outbox.session)), (mint) => restored(options.key(model), options.scope(model), mint)), (message) => reduce(model, message))
+			};
+		},
+		wiring: (active, options = {}) => ({
+			key: `remote:${bound.contract.name}`,
+			shared: options.shared ?? [],
+			handles: Record.keys(remoteMessageCases),
+			route: (model, message) => isRemoteMessage(message) ? Option.some(reduceReporting(bound.store, reduce, model, message, (options.shared ?? []).some((tag) => tag === "MutationFailed"))) : Option.none(),
+			subscriptions: brandEntries(domain.subscriptions(active, options)),
+			contract: bound.contract
+		})
+	};
+	return domain;
+};
+/** The outbox's own answers, as another tab announced them: a settled write, and nothing else. */
+const announcedOutcome = Schema.Struct({ outcome: Schema.optional(remoteMessageSchema) });
+const outcomeOf = (data) => Option.filter(Option.flatMap(Schema.decodeUnknownOption(announcedOutcome)(data), ({ outcome }) => Option.fromUndefinedOr(outcome)), (outcome) => outcome._tag === "MutationSucceeded" || outcome._tag === "MutationFailed");
+/** 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
+	};
+};
+/**
+* Whether a row a window of `size` would show was deleted: one of `edges`
+* gone before the window, read from its end, fills with rows still `shown`.
+* A delete past the window is another window's (#287).
+*/
+const deletedInWindow = (edges, shown, window, size, gone) => {
+	const ordered = window.first === void 0 ? [...edges].reverse() : edges;
+	let filled = 0;
+	for (const edge of ordered) {
+		if (size !== void 0 && filled >= size) return false;
+		if (gone(entityKey(edge.ref.entity, edge.ref.id))) return true;
+		if (shown.has(edge.key)) filled++;
+	}
+	return false;
+};
+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 }
+});
+export { AnswerRead, ConnectionChange, ConnectionChangeSchema, Denied, DerivedBy, Diagnostics, Entity, Freshness, IDENTITY_SEPARATOR, Live, LiveChange, LiveEdge, LiveRequirement, MAX_FIELDS_PER_REQUEST, MAX_LIVE_QUERIES, MAX_RELATION_DEPTH, MAX_SHOWN_ENTITIES, Mutate, Mutation, MutationRequest, MutationResult, NormalizedEntity, OperationId, OutboxItemState, PageSize, PredictionPart, Query, QueryEdge, QueryRequest, QueryResult, QueryRpc, RELATION_ALIAS, REMOTE_CACHE_VERSION, REMOTE_PROTOCOL_VERSION, Read, ReadBatch, ReadBatchResult, ReadRequest, ReadWhy, Refusal, RelationAnnotation, RelationEntityAnnotation, RelationRequest, Remote, RemoteClient, RemoteConnections, RemoteData, RemoteForbidden, RemoteJsonAnswer, RemoteJsonRequest, RemoteLiveError, RemoteLiveRefused, RemoteMutationError, RemotePersistence, RemotePolicy, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteRequirements, RemoteRpc, RemoteUnauthenticated, RemoteUnreachable, RemoteUnsatisfied, Requirement, RowPlace, Selection, SettledFields, ShownBy, ShownSlice, Why, WhyTerm, WindowSchema, WireBoundary, addLayer, addOverlay, aliasedField, applyConnectionEvent, applyEntityEvent, askAgain, assemble, beginMutation, beginOptimistic, belongsEncoded, brokenByWrite, classifyLive, clearStale, coalesceQueries, coalesceReads, coalescedLayer, connectionChangeOf, connectionIdentity, connectionsOf, cursor, deadlineOf, departedLimit, derivedOfWrite, dismissQueued, edge, emptyConnection, emptyLiveState, emptyMutationState, emptyOptimistic, emptyRefresh, emptyStore, entityKey, entry, failMutation, failureOf, fieldMark, forbiddenByWrite, forgetFailure, forgetRemote, gc, goneIn, hasField, hasNext, hasPrevious, heldOnlyByRequests, httpWithLive, initialRemoteModel, inspectEntity, inspectRemote, invalidateConnections, isFieldFailed, isFieldStale, isFieldUnavailable, isGapped, isLoading, isLoadingThrough, isQueryLoading, isRefPage, isRemoteMessage, isTombstone, items, liveEventOf, liveFetch, liveHasNext, liveHasPrevious, markStale, matching, merge, mintOperation, missingFields, mutateRemote, mutationStatus, noFailures, onlyOverlaid, optimisticOfWrite, overlaysOf, pageSchema, patchOfWrite, placeIn, plan, plannedStore, predictionOfWrite, pruneOverlays, queryIdentity, reachable, readField, recentRoots, reconcileMutation, refParts, refreshIsInFlight, refreshedAt, refsIn, relationAlias, relationOf, relationShape, remoteDataSchema, remoteError, remoteErrorSchema, remoteMessageCases, remoteMessageSchema, remoteModelSchema, remove, removeLayer, removeOverlay, requirementKey, requirementsOf, resolvedPatches, retentionRootsSchema, schemaOf, segment, setStale, setUnavailable, settleFailure, settleSuccess, settledLater, stableStringify, targetsOf, terminal, tombstone, unavailableOf, unknown, updateRemote, visibleItems, visibleStore, windowGrowthKey, windowKey, withRefreshRequested, writeEntities, writeEntity, writeRead };
+
+//# sourceMappingURL=index.js.map