foldkit-remote 0.20.0 → 0.22.0

package/dist/model.js

@@ -0,0 +1,1308 @@
+import { PredictionPart, liveRefused, outboxUnreadable, outboxUnsaved, predictionMismatch, withDiagnostics } from "./diagnostics.js";
+import { put } from "./record.js";
+import { isRefPage, targetsOf } from "./relation.js";
+import { askAgain, emptyStore, entityKey, entry, isTombstone, readField, remove, setStale, setUnavailable, tombstone, writeEntities } from "./store.js";
+import { beginMutation, emptyMutationState, failMutation, forgetFailure, settledLater } from "./mutation.js";
+import { AnswerRead, NormalizedEntity, ReadBatchResult, ReadRequest, RelationRequest, SettledFields } from "./wire.js";
+import { emptyConnection, merge, unknown } from "./connection.js";
+import { remoteErrorSchema } from "./remoteData.js";
+import { beginOptimistic, emptyOptimistic, pruneOverlays, settleFailure, settleSuccess } from "./optimistic.js";
+import { applyConnectionEvent, applyEntityEvent, emptyLiveState } from "./live.js";
+import { Queued, emptyOutbox, operationOf, revisionOf, withDone } from "./outbox.js";
+import { windowKey } from "./plan.js";
+import { gc, reachable, recentRoots } from "./retain.js";
+import { RemotePersistence } from "./persistence.js";
+import { Option, Schema } from "effect";
+// src/model.ts
+/**
+* The Remote submodel: the store, connections, mutations, live state, and
+* optimistic layers an application keeps in its Model, the Messages that
+* change it, and the pure reducer over them.
+*/
+const noFailures = {
+	connections: {},
+	fields: {}
+};
+const emptyRefresh = {
+	generation: 0,
+	requested: /* @__PURE__ */ new Map(),
+	started: /* @__PURE__ */ new Map(),
+	floor: 0
+};
+/**
+* The Model with everything the server told it forgotten: values, tombstones,
+* unavailable fields, connections, live cursors, failures, and what is in
+* flight. For a change of principal, whose facts these were. The mutation
+* sequence is kept, so request ids stay unique, and a mutation in flight is
+* treated as applied: its answer, when it comes, writes nothing here.
+*
+* `restoredFrom` is kept too: the emptied store is now what that key holds,
+* so `Data.persistence` saves it over the old snapshot and never restores the
+* key again. Restoring would bring back exactly what was forgotten.
+*/
+const forgetRemote = (model) => {
+	const generation = model.refresh.generation + 1;
+	return {
+		...initialRemoteModel,
+		restoredFrom: model.restoredFrom,
+		refresh: {
+			generation,
+			requested: /* @__PURE__ */ new Map(),
+			started: /* @__PURE__ */ new Map(),
+			floor: generation
+		},
+		mutations: {
+			...emptyMutationState,
+			sequence: model.mutations.sequence,
+			applied: /* @__PURE__ */ new Set([...model.mutations.applied, ...model.mutations.pending])
+		},
+		outbox: {
+			...emptyOutbox,
+			session: model.outbox.session
+		}
+	};
+};
+const initialRemoteModel = {
+	entities: emptyStore,
+	connections: {},
+	grown: {},
+	optimistic: emptyOptimistic,
+	live: {},
+	mutations: emptyMutationState,
+	outbox: emptyOutbox,
+	gaps: /* @__PURE__ */ new Set(),
+	streams: {},
+	loading: /* @__PURE__ */ new Set(),
+	refresh: emptyRefresh,
+	failures: noFailures,
+	restoredFrom: Option.none(),
+	placed: {},
+	diagnostics: [],
+	recent: {
+		requirements: [],
+		connections: []
+	}
+};
+/** The entity store and the mutation ledger are runtime values, not wire shapes. */
+const runtimeSchema = Schema.Unknown;
+const remoteModelSchema = () => Schema.Struct({
+	entities: runtimeSchema,
+	connections: Schema.Record(Schema.String, runtimeSchema),
+	grown: Schema.Record(Schema.String, Schema.Number),
+	optimistic: runtimeSchema,
+	live: Schema.Record(Schema.String, runtimeSchema),
+	mutations: runtimeSchema,
+	outbox: runtimeSchema,
+	gaps: runtimeSchema,
+	streams: Schema.Record(Schema.String, runtimeSchema),
+	loading: runtimeSchema,
+	refresh: runtimeSchema,
+	failures: Schema.Struct({
+		connections: Schema.Record(Schema.String, remoteErrorSchema),
+		fields: Schema.Record(Schema.String, remoteErrorSchema)
+	}),
+	restoredFrom: runtimeSchema,
+	placed: runtimeSchema,
+	diagnostics: runtimeSchema,
+	recent: runtimeSchema
+});
+const retentionRootsSchema = Schema.Struct({
+	requirements: Schema.Array(ReadRequest),
+	connections: Schema.Array(Schema.Struct({
+		identity: Schema.String,
+		select: Schema.optional(RelationRequest)
+	}))
+});
+/**
+* The Messages' fields by tag, without `_tag`: what `defineMessageUnion` takes,
+* so an application spreads them into its own union (`Remote.messages`).
+*/
+const remoteMessageCases = {
+	ReadReceived: {
+		requests: Schema.Array(ReadRequest),
+		result: ReadBatchResult,
+		now: Schema.Number
+	},
+	ReadFailed: {
+		requests: Schema.Array(ReadRequest),
+		error: remoteErrorSchema,
+		stream: Schema.optional(Schema.String)
+	},
+	RefreshStarted: { requests: Schema.Array(ReadRequest) },
+	ReadStarted: {
+		requests: Schema.Array(ReadRequest),
+		refresh: Schema.optional(Schema.Number)
+	},
+	QueryStarted: { connections: Schema.Array(Schema.String) },
+	RetentionChanged: { roots: retentionRootsSchema },
+	Hydrated: {
+		connections: Schema.optional(Schema.Unknown),
+		from: Schema.optional(Schema.String),
+		entities: runtimeSchema,
+		merge: Schema.Union([Schema.Literal("replace"), Schema.Literal("preserve-existing")])
+	},
+	MutationStarted: {
+		requestId: Schema.String,
+		optimistic: Schema.optional(Schema.Array(Schema.Unknown)),
+		viewer: Schema.optional(Schema.Struct({
+			entity: Schema.String,
+			id: Schema.String
+		})),
+		write: Schema.optional(Schema.Struct({
+			mutation: Schema.String,
+			input: Schema.Unknown,
+			keys: Schema.optional(Schema.Array(Schema.String)),
+			now: Schema.optional(Schema.Number),
+			durable: Schema.optional(Schema.Struct({
+				input: Schema.Unknown,
+				shown: Schema.Array(RelationRequest)
+			}))
+		}))
+	},
+	MutationQueued: { requestId: Schema.String },
+	OutboxRead: {
+		key: Schema.String,
+		scope: Schema.String,
+		session: Schema.optional(Schema.String),
+		entries: Schema.Array(Schema.Unknown),
+		done: Schema.Array(Schema.String),
+		unsaved: Schema.optional(Schema.String)
+	},
+	OutboxDelayed: {
+		requestId: Schema.String,
+		attempt: Schema.Number,
+		error: remoteErrorSchema
+	},
+	MutationSucceeded: {
+		requestId: Schema.String,
+		entities: Schema.Array(NormalizedEntity),
+		connections: Schema.optional(Schema.Array(Schema.Unknown)),
+		deleted: Schema.optional(Schema.Array(Schema.Struct({
+			entity: Schema.String,
+			id: Schema.String
+		}))),
+		read: Schema.optional(AnswerRead),
+		now: Schema.Number
+	},
+	MutationFailed: {
+		requestId: Schema.String,
+		error: remoteErrorSchema,
+		operation: Schema.String
+	},
+	OverlayShown: {
+		id: Schema.String,
+		optimistic: Schema.Array(Schema.Unknown)
+	},
+	OverlayLifted: { id: Schema.String },
+	WindowGrown: {
+		window: Schema.String,
+		size: Schema.Number
+	},
+	LiveReceived: {
+		stream: Schema.String,
+		event: Schema.Unknown,
+		policy: Schema.optional(Schema.Unknown),
+		now: Schema.Number
+	},
+	GapCleared: { stream: Schema.String },
+	ConnectionMerged: {
+		connection: Schema.String,
+		page: Schema.Unknown,
+		refreshes: Schema.optional(Schema.Boolean),
+		select: Schema.optional(RelationRequest),
+		entities: Schema.optional(Schema.Array(NormalizedEntity)),
+		settled: Schema.optional(Schema.Array(SettledFields)),
+		now: Schema.optional(Schema.Number)
+	},
+	ConnectionInvalidated: { connection: Schema.String },
+	ConnectionRefreshed: { connection: Schema.String },
+	QueryFailed: {
+		connection: Schema.String,
+		error: remoteErrorSchema
+	},
+	Preloaded: { messages: Schema.Array(Schema.suspend(() => remoteMessageSchema)) },
+	CompletedReportDiagnostics: {}
+};
+/**
+* Whether a Message is one of Remote's, by tag. Narrows an application's union
+* to its Remote cases, and its complement to the application's own.
+*/
+const isRemoteMessage = (message) => Object.hasOwn(remoteMessageCases, message._tag);
+const remoteMessageSchema = Schema.Union(Object.entries(remoteMessageCases).map(([tag, fields]) => Schema.Struct({
+	_tag: Schema.Literal(tag),
+	...fields
+})));
+/** An overlay's layer, named apart from every request's: a request id is the application's to choose too. */
+const OVERLAY = "overlay:";
+const overlayLayer = (id) => `${OVERLAY}${id}`;
+/** The ids `OverlayShown` shows now, each once, in the order they are drawn. */
+const overlaysOf = (model) => [...new Set([...model.optimistic.layers, ...model.optimistic.overlays].flatMap(({ id }) => id.startsWith(OVERLAY) ? [id.slice(8)] : []))];
+/** The key a grown window is kept under: its connection and the window first asked for. */
+const windowGrowthKey = (identity, window) => `${identity}\u0000${window}`;
+/**
+* Whether only overlays show this entity: the server has told the store
+* nothing of it and no request's layer writes it, so nothing will fetch what an
+* overlay leaves out.
+*/
+const onlyOverlaid = (model, entity, id) => {
+	if (Object.hasOwn(model.entities, entityKey(entity, id))) return false;
+	const writers = model.optimistic.layers.filter((layer) => layer.patches.some((patch) => patch.entity === entity && patch.id === id));
+	return writers.length > 0 && writers.every((layer) => layer.id.startsWith("overlay:"));
+};
+const marksOf = (requests) => requests.map((request) => [entityKey(request.entity, request.id), request.fields]);
+/**
+* One mark per requested field, `entity\0id\0field`. A read is identified by
+* what it asks for, not by a request id: two reads asking for one field share
+* its mark, so the first answer clears it. Over-clearing shows `Initial` rather
+* than a spinner, which is the safer way to be wrong. The refresh generations
+* below key off the same marks, so "what a read asks for" means one thing.
+*/
+const fieldMark = (entity, id, field) => `${entityKey(entity, id)}\u0000${field}`;
+const fieldMarks = function* (requests) {
+	for (const request of requests) for (const field of request.fields) yield fieldMark(request.entity, request.id, field);
+};
+const withLoading = (loading, requests) => {
+	const next = new Set(loading);
+	for (const mark of fieldMarks(requests)) next.add(mark);
+	return next.size === loading.size ? loading : next;
+};
+const withoutLoading = (loading, requests) => {
+	if (loading.size === 0) return loading;
+	const next = new Set(loading);
+	for (const mark of fieldMarks(requests)) next.delete(mark);
+	return next.size === loading.size ? loading : next;
+};
+/**
+* A connection's mark. The leading separator keeps it out of the field marks'
+* space, whatever a connection identity happens to spell.
+*/
+const connectionPrefix = "\0connection\0";
+const connectionMark = (identity) => `${connectionPrefix}${identity}`;
+/** Whether a query for this connection is in flight. */
+const isQueryLoading = (model, identity) => model.loading.size !== 0 && model.loading.has(connectionMark(identity));
+const withoutQueryLoading = (loading, identity) => {
+	if (!loading.has(connectionMark(identity))) return loading;
+	const next = new Set(loading);
+	next.delete(connectionMark(identity));
+	return next;
+};
+/**
+* The in-flight marks of connections the roots still name. A query the entry
+* stopped waiting for — it was restarted or deactivated before an answer came —
+* leaves its mark behind, and a connection released with that mark would read
+* `Loading` forever the next time something asked for it before sending.
+*/
+const prunedLoading = (loading, roots, reached) => {
+	if (loading.size === 0) return loading;
+	const named = new Set(roots.connections.map((root) => connectionMark(root.identity)));
+	const kept = [...loading].filter((mark) => mark.startsWith(connectionPrefix) ? named.has(mark) : reached().has(markEntity(mark)));
+	return kept.length === loading.size ? loading : new Set(kept);
+};
+/**
+* The windows grown on connections retention keeps; a dropped one starts over.
+* The same record when every one is kept.
+*/
+const keptWindows = (grown, connections) => {
+	const kept = Object.entries(grown).filter(([key]) => Object.hasOwn(connections, key.slice(0, key.lastIndexOf("\0"))));
+	return kept.length === Object.keys(grown).length ? grown : Object.fromEntries(kept);
+};
+/** The placements awaiting a page of a list retention still keeps; a dropped list's page never comes. */
+const keptPlacements = (placed, connections) => {
+	const kept = Object.entries(placed).filter(([key]) => Object.hasOwn(connections, key));
+	return kept.length === Object.keys(placed).length ? placed : Object.fromEntries(kept);
+};
+/**
+* Drops the refresh marks of entities and connections that were collected.
+* Nothing observes a collected entity — the retention roots are the active
+* Surfaces — so no read entry's generation can fall back when its mark goes.
+* Without this the generations would be bounded by how many things the
+* application has ever refreshed rather than by what it currently holds, which
+* for a list refreshed on a timer is the same as not bounded at all.
+*/
+const prunedRefresh = (refresh, retained) => {
+	const live = (mark) => mark.startsWith(connectionPrefix) ? retained.connections[mark.slice(12)] !== void 0 : retained.entities[mark.slice(0, mark.indexOf("\0"))] !== void 0;
+	const keep = (marks) => {
+		const next = /* @__PURE__ */ new Map();
+		for (const [mark, generation] of marks) if (live(mark)) next.set(mark, generation);
+		return next.size === marks.size ? marks : next;
+	};
+	const requested = keep(refresh.requested);
+	const started = keep(refresh.started);
+	return requested === refresh.requested && started === refresh.started ? refresh : {
+		...refresh,
+		requested,
+		started
+	};
+};
+/**
+* The generation a read is planned under: the highest any of the fields it
+* reads or connections it runs was refreshed at. A read entry carries this as a
+* dependency, so it restarts when what it observes is refreshed and not when
+* anything else is.
+*/
+const refreshedAt = (refresh, requests, connections = []) => {
+	let at = refresh.floor;
+	for (const mark of fieldMarks(requests)) at = Math.max(at, refresh.requested.get(mark) ?? 0);
+	for (const identity of connections) at = Math.max(at, refresh.requested.get(connectionMark(identity)) ?? 0);
+	return at;
+};
+/**
+* Marks every field of `requests` and every connection in `connections`
+* refreshed at the next generation.
+*/
+const withRefreshRequested = (refresh, requests, connections = []) => {
+	const generation = refresh.generation + 1;
+	const requested = new Map(refresh.requested);
+	for (const mark of fieldMarks(requests)) requested.set(mark, generation);
+	for (const identity of connections) requested.set(connectionMark(identity), generation);
+	return {
+		...refresh,
+		generation,
+		requested
+	};
+};
+/**
+* Marks connections as needing to be asked again, and restarts a read of them
+* already in flight: a page requested before what invalidated it could land
+* after it, saying what is no longer true. `Remote.refresh` marks the same way.
+*/
+const invalidateConnections = (model, connections) => {
+	if (connections.length === 0) return model;
+	const marked = connections.reduce((current, connection) => updateRemote(current, {
+		_tag: "ConnectionInvalidated",
+		connection
+	}), model);
+	return {
+		...marked,
+		refresh: withRefreshRequested(marked.refresh, [], connections)
+	};
+};
+/**
+* Records that a read of `requests` began under `generation`. A read that
+* carries no generation began under none, and leaves the marks as they are.
+*/
+const withRefreshStarted = (refresh, requests, generation) => {
+	if (generation === void 0 || generation === 0) return refresh;
+	let started;
+	for (const mark of fieldMarks(requests)) {
+		if ((refresh.started.get(mark) ?? 0) >= generation) continue;
+		started ??= new Map(refresh.started);
+		started.set(mark, generation);
+	}
+	return started === void 0 ? refresh : {
+		...refresh,
+		started
+	};
+};
+/**
+* Whether one field's read already began under the generation that field was
+* last refreshed at. Such a read is in flight and would otherwise outlive the
+* refresh, so the refresh takes a new generation to restart it even though the
+* field is already stale.
+*/
+const refreshIsInFlight = (refresh, request, field) => {
+	const mark = fieldMark(request.entity, request.id, field);
+	return (refresh.started.get(mark) ?? 0) === (refresh.requested.get(mark) ?? 0);
+};
+/**
+* Whether a read is fetching any of `fields` for this entity. Consulted only
+* when the store lacks the value, which is what separates `Loading` from
+* `Initial`.
+*/
+const isLoading = (model, entity, id, fields) => {
+	if (model.loading.size === 0) return false;
+	return fields.some((field) => model.loading.has(fieldMark(entity, id, field)));
+};
+const setConnectionStale = (connections, connection, stale) => {
+	const current = connections[connection];
+	if (current?.stale === stale) return connections;
+	return {
+		...connections,
+		[connection]: {
+			...current ?? emptyConnection,
+			stale
+		}
+	};
+};
+/**
+* How many streams `live` and `streams` keep. Which streams the active
+* Surfaces hold is not in the Model (retention roots merge every Surface's
+* requirements, and a stream key is one entry's), so the ledger keeps those
+* most recently heard from, as `failed` keeps the latest failures. A stream
+* dropped while still open meets its next event as a gap, which restarts it
+* and refetches what it covers.
+*/
+const STREAM_WINDOW = 256;
+/** `record` with `stream` set as the most recent, the oldest dropped past the window. */
+const heard = (record, stream, value) => {
+	const { [stream]: _previous, ...rest } = record;
+	const next = {
+		...rest,
+		[stream]: value
+	};
+	const keys = Object.keys(next);
+	for (const key of keys.slice(0, Math.max(0, keys.length - STREAM_WINDOW))) delete next[key];
+	return next;
+};
+const withLiveState = (live, stream, state) => live[stream] === state ? live : heard(live, stream, state);
+const noHealth = {
+	restarts: 0,
+	failures: 0,
+	error: Option.none(),
+	refused: Option.none()
+};
+/**
+* A stream broke: it is marked a gap and its restart count moves, which
+* restarts its live entry. A stream already broken and not yet restarted
+* changes nothing, so the events a dying stream still delivers restart it once.
+*/
+const broke = (model, stream, error) => {
+	if (model.gaps.has(stream)) return model;
+	const health = model.streams[stream] ?? noHealth;
+	const streams = heard(model.streams, stream, {
+		restarts: health.restarts + 1,
+		failures: health.failures + 1,
+		error,
+		refused: Option.none()
+	});
+	const gaps = new Set([...model.gaps, stream].filter((key) => Object.hasOwn(streams, key)));
+	return {
+		...model,
+		gaps,
+		streams
+	};
+};
+/** The tag of the server's refusal of a live stream, which `RemoteError` carries open. */
+const refusedTag = "RemoteLiveRefused";
+/**
+* The server refused a stream for what it asks: it is marked refused and not a
+* gap, so its live entry does not restart it, and the refusal is recorded as
+* a diagnostic once.
+*/
+const refused = (model, stream, error) => {
+	const health = model.streams[stream] ?? noHealth;
+	if (Option.isSome(health.refused)) return model;
+	const streams = heard(model.streams, stream, {
+		...health,
+		error: Option.some(error),
+		refused: Option.some(error)
+	});
+	return {
+		...clearGap(model, stream),
+		streams,
+		diagnostics: withDiagnostics(model.diagnostics, [liveRefused({
+			stream,
+			error
+		})])
+	};
+};
+/**
+* An event applied on a stream that resubscribed: it works, so its next break
+* backs off from the start. A broken stream's last events prove nothing.
+*/
+const healthy = (model, stream) => {
+	const health = model.streams[stream];
+	const settled = health !== void 0 && health.failures === 0 && Option.isNone(health.refused);
+	return health === void 0 || settled || model.gaps.has(stream) ? model : {
+		...model,
+		streams: heard(model.streams, stream, {
+			...health,
+			failures: 0,
+			error: Option.none(),
+			refused: Option.none()
+		})
+	};
+};
+const clearGap = (model, stream) => model.gaps.has(stream) ? {
+	...model,
+	gaps: new Set([...model.gaps].filter((entry) => entry !== stream))
+} : model;
+/**
+* The pure reducer all four producers share. A live event that arrives ahead of
+* its cursor is a gap: it is not applied, and the stream is recorded so its
+* live entry restarts it rather than silently missing facts. When every field a Message
+* touches keeps its identity, `model` itself is returned, so the application's
+* root keeps its identity and Foldkit does not render. The common no-ops do (a
+* duplicate live event, a repeated `ReadStarted`); a repeated failure, or a
+* `preserve-existing` restore of entities already held, still makes an equal
+* copy.
+*/
+const updateRemote = (model, message) => {
+	const next = reduceRemote(model, message);
+	return next === model || !sameFields(model, next) ? next : model;
+};
+/** Whether every field of `next` is the one `model` holds. */
+const sameFields = (model, next) => {
+	const keys = Object.keys(next);
+	return keys.length === Object.keys(model).length && keys.every((key) => Object.is(model[key], next[key]));
+};
+/**
+* A placement compared with the server's first page of the list it placed
+* in, under `verifyPredictions`: the keys as far as both reach must agree, and
+* no row placing took out may be one the page still lists. The record goes
+* once compared; a disagreement is kept.
+*/
+const checkedPlacement = (model, connection, page, refreshes) => {
+	const placed = model.placed[connection];
+	if (placed === void 0 || !refreshes || page.start._tag !== "Terminal") return {
+		placed: model.placed,
+		diagnostics: model.diagnostics
+	};
+	const { [connection]: _, ...rest } = model.placed;
+	const reach = Math.min(placed.order.length, page.edges.length);
+	const served = page.edges.slice(0, reach).map((edge) => edge.key);
+	const asPlaced = placed.order.slice(0, reach);
+	const listed = new Set(page.edges.map((edge) => edge.key));
+	return {
+		placed: rest,
+		diagnostics: served.every((key, index) => key === asPlaced[index]) && !placed.dropped.some((key) => listed.has(key)) ? model.diagnostics : withDiagnostics(model.diagnostics, [predictionMismatch(PredictionPart.Placement({
+			connection,
+			placed: asPlaced,
+			served
+		}))])
+	};
+};
+/** The queue with `queued` in place of the entry of its operation, or after the rest. */
+const placedIn = (queue, queued) => {
+	const operation = operationOf(queued);
+	return queue.some((each) => operationOf(each) === operation) ? queue.map((each) => operationOf(each) === operation ? queued : each) : [...queue, queued];
+};
+/** A durable write queued to wait its turn: new, or a failed one retried, its revision moved on. */
+const queuedWrite = (outbox, operation, write, message) => {
+	const prior = outbox.queue.find((queued) => operationOf(queued) === operation);
+	const stored = {
+		operation,
+		mutation: write.mutation,
+		input: write.durable?.input,
+		...write.keys === void 0 ? {} : { keys: write.keys },
+		...write.now === void 0 ? {} : { now: write.now },
+		optimistic: message.optimistic ?? [],
+		...message.viewer === void 0 ? {} : { viewer: message.viewer },
+		shown: write.durable?.shown ?? [],
+		revision: prior === void 0 ? 0 : revisionOf(prior) + 1,
+		state: { _tag: "Waiting" }
+	};
+	return {
+		...outbox,
+		queue: placedIn(outbox.queue, Queued.Readable({
+			write: stored,
+			stored: false,
+			attempt: 0,
+			delayed: Option.none()
+		}))
+	};
+};
+/** The outbox with the readable write of `operation` changed by `change`; itself when it has none. */
+const withQueued = (outbox, operation, change) => {
+	const at = outbox.queue.findIndex((queued) => operationOf(queued) === operation);
+	const queued = outbox.queue[at];
+	if (queued?._tag !== "Readable") return outbox;
+	return {
+		...outbox,
+		queue: outbox.queue.map((each, index) => index === at ? change(queued) : each)
+	};
+};
+/** The outbox with `operation` settled: out of the queue, and remembered as done. */
+const withoutQueued = (outbox, operation) => outbox.queue.some((queued) => operationOf(queued) === operation) ? {
+	...outbox,
+	queue: outbox.queue.filter((queued) => operationOf(queued) !== operation),
+	done: withDone(outbox.done, [operation])
+} : outbox;
+const storedAs = (queued, stored) => queued.stored === stored ? queued : {
+	...queued,
+	stored
+};
+/** A stored entry as the queue holds it: in the store, as read. */
+const queuedOf = (entry) => entry._tag === "Readable" ? Queued.Readable({
+	write: entry.write,
+	stored: true,
+	attempt: 0,
+	delayed: Option.none()
+}) : Queued.Unreadable({
+	operation: entry.operation,
+	revision: entry.revision,
+	raw: entry.raw,
+	reason: entry.reason,
+	stored: true
+});
+const entryOperation = (entry) => entry._tag === "Readable" ? entry.write.operation : entry.operation;
+const entryRevision = (entry) => entry._tag === "Readable" ? entry.write.revision : entry.revision;
+/** Whether the queued write waits its turn: in the ledger in flight, its layer shown. */
+const isWaiting = (queued) => queued._tag === "Readable" && queued.write.state._tag === "Waiting";
+/** The ledger and layers without a queued write: nothing of it shown or listed. */
+const releasedFrom = (model, queued) => {
+	const operation = operationOf(queued);
+	if (!model.mutations.pending.has(operation)) return {
+		...model,
+		mutations: forgetFailure(model.mutations, operation)
+	};
+	const pending = new Set(model.mutations.pending);
+	pending.delete(operation);
+	const writes = new Map(model.mutations.writes);
+	writes.delete(operation);
+	const order = new Map(model.mutations.order);
+	order.delete(operation);
+	return {
+		...model,
+		mutations: {
+			...model.mutations,
+			pending,
+			writes,
+			order
+		},
+		optimistic: settleFailure(model.optimistic, operation)
+	};
+};
+/**
+* The ledger and layers with a stored entry adopted in place of what the
+* page held of it (`prior`): a write waiting is begun, its layer shown; one
+* failed is failed, its layer gone; one this version cannot read is not in
+* the ledger at all.
+*/
+const adopted = (model, prior, entry) => {
+	const released = prior === void 0 ? model : releasedFrom(model, prior);
+	if (entry._tag === "Unreadable") return released;
+	const { write } = entry;
+	const begun = {
+		...released,
+		mutations: beginMutation(released.mutations, write.operation, {
+			mutation: write.mutation,
+			input: entry.input,
+			keys: write.keys,
+			now: Option.fromUndefinedOr(write.now),
+			optimistic: write.optimistic
+		})
+	};
+	return write.state._tag === "Waiting" ? {
+		...begun,
+		optimistic: beginOptimistic(begun.optimistic, write.operation, write.optimistic, Option.fromUndefinedOr(write.viewer))
+	} : {
+		...begun,
+		mutations: failMutation(begun.mutations, write.operation, write.state.error, write.operation)
+	};
+};
+/**
+* Writes another tab settled, whose answers this page did not see: their
+* layers go, every row they showed is asked for again and every list is
+* refetched, since what the server made of them is not known here.
+*/
+const settledElsewhere = (model, settled) => {
+	const released = settled.reduce(releasedFrom, model);
+	const rows = /* @__PURE__ */ new Map();
+	for (const queued of settled) {
+		if (queued._tag !== "Readable" || queued.write.state._tag !== "Waiting") continue;
+		for (const operation of queued.write.optimistic) if ("entity" in operation) rows.set(entityKey(operation.entity, operation.id), operation);
+	}
+	if (!settled.some(isWaiting)) return released;
+	const requests = [...rows.entries()].flatMap(([key, row]) => Option.match(entry(released.entities, key), {
+		onNone: () => [],
+		onSome: (held) => held.present.size === 0 ? [] : [{
+			entity: row.entity,
+			id: row.id,
+			fields: [...held.present]
+		}]
+	}));
+	const asked = requests.length === 0 ? released : reduceRemote(released, {
+		_tag: "RefreshStarted",
+		requests
+	});
+	return invalidateConnections(asked, Object.keys(asked.connections));
+};
+/**
+* What the store holds, met by what the page holds: an entry the store has a
+* newer revision of is adopted, one it has as the page does is marked
+* stored, one it lacks is written again, and one it settled goes. A read
+* under another key replaces the page's queue (its writes stay in their own
+* store). The Model itself when nothing changed.
+*/
+const readOutbox = (model, message) => {
+	const switching = Option.isSome(model.outbox.key) && model.outbox.key.value !== message.key || Option.isSome(model.outbox.scope) && model.outbox.scope.value !== message.scope;
+	const start = switching ? {
+		...model.outbox.queue.reduce(releasedFrom, model),
+		outbox: {
+			...model.outbox,
+			queue: [],
+			done: []
+		}
+	} : model;
+	const before = start.outbox;
+	const done = withDone(before.done, message.done);
+	const gone = new Set(done);
+	const held = new Map(before.queue.map((queued) => [operationOf(queued), queued]));
+	const read = /* @__PURE__ */ new Set();
+	const queue = [];
+	const recorded = [];
+	let next = start;
+	for (const entry of message.entries) {
+		const operation = entryOperation(entry);
+		if (gone.has(operation) || read.has(operation)) continue;
+		read.add(operation);
+		const prior = held.get(operation);
+		const revision = entryRevision(entry);
+		if (prior !== void 0 && revisionOf(prior) > revision) queue.push(prior);
+		else if (prior !== void 0 && revisionOf(prior) === revision) queue.push(storedAs(prior, true));
+		else {
+			next = adopted(next, prior, entry);
+			if (entry._tag === "Unreadable" && prior === void 0) recorded.push(outboxUnreadable({
+				requestId: operation,
+				reason: entry.reason
+			}));
+			queue.push(queuedOf(entry));
+		}
+	}
+	const settled = [];
+	for (const queued of before.queue) {
+		const operation = operationOf(queued);
+		if (read.has(operation)) continue;
+		if (gone.has(operation)) settled.push(queued);
+		else queue.push(storedAs(queued, false));
+	}
+	next = settledElsewhere(next, settled);
+	const said = next.diagnostics.some((diagnostic) => diagnostic._tag === "OutboxUnsaved" && diagnostic.key === message.key);
+	if (message.unsaved !== void 0 && !said) recorded.push(outboxUnsaved({
+		key: message.key,
+		reason: message.unsaved
+	}));
+	const session = Option.orElse(before.session, () => Option.fromUndefinedOr(message.session));
+	if (!switching && next === start && recorded.length === 0 && done === before.done && Option.contains(before.key, message.key) && Option.contains(before.scope, message.scope) && Option.isSome(before.session) === Option.isSome(session) && queue.length === before.queue.length && queue.every((queued, index) => queued === before.queue[index])) return model;
+	return {
+		...next,
+		outbox: {
+			session,
+			key: Option.some(message.key),
+			scope: Option.some(message.scope),
+			queue,
+			done
+		},
+		diagnostics: withDiagnostics(next.diagnostics, recorded)
+	};
+};
+/**
+* The Remote Model with a failed or unreadable durable write settled by the
+* reader (`Data.dismiss`): out of the queue and the ledger, and done, so every
+* tab drops it. A waiting one, or one not queued, is the Model itself.
+*/
+const dismissQueued = (model, requestId) => {
+	const queued = model.outbox.queue.find((each) => operationOf(each) === requestId);
+	if (queued === void 0 || isWaiting(queued)) return model;
+	return {
+		...model,
+		mutations: forgetFailure(model.mutations, requestId),
+		outbox: withoutQueued(model.outbox, requestId)
+	};
+};
+const reduceRemote = (model, message) => {
+	switch (message._tag) {
+		case "Preloaded": return message.messages.reduce(reduceRemote, model);
+		case "CompletedReportDiagnostics": return model;
+		case "ReadReceived": return {
+			...model,
+			entities: writeRead(model.entities, message.requests, message.result, message.now),
+			loading: withoutLoading(model.loading, message.requests),
+			failures: withoutFieldFailures(model.failures, [...fieldMarks(message.requests), ...patchedMarks(message.result.entities)])
+		};
+		case "ReadFailed":
+			if (message.stream !== void 0) return message.error._tag === refusedTag ? refused(model, message.stream, message.error) : broke(model, message.stream, Option.some(message.error));
+			return {
+				...model,
+				entities: setStale(model.entities, marksOf(message.requests), false),
+				loading: withoutLoading(model.loading, message.requests),
+				failures: withFieldFailures(model.failures, message.requests, message.error)
+			};
+		case "RetentionChanged": {
+			const recent = recentRoots(model.recent, message.roots);
+			const retained = gc(model, recent);
+			const active = new Set(message.roots.connections.map((root) => root.identity));
+			const connections = recent.connections.reduce((held, { identity }) => active.has(identity) || held[identity] === void 0 ? held : setConnectionStale(held, identity, true), retained.connections);
+			let reachedKeys;
+			const reached = () => reachedKeys ??= reachable(model.entities, message.roots, model.connections, model.optimistic, model.mutations.pending);
+			return {
+				...model,
+				...retained,
+				connections,
+				recent,
+				grown: keptWindows(model.grown, retained.connections),
+				placed: keptPlacements(model.placed, retained.connections),
+				refresh: prunedRefresh(model.refresh, retained),
+				failures: prunedFailures(model.failures, message.roots, reached),
+				loading: prunedLoading(model.loading, message.roots, reached)
+			};
+		}
+		case "Hydrated": {
+			const restored = Object.entries(message.connections ?? {}).map(([identity, segments]) => [identity, {
+				segments: segments.map((edges) => ({
+					edges: [...edges],
+					start: unknown,
+					end: unknown
+				})),
+				stale: true
+			}]);
+			const written = Object.entries(message.entities).flatMap(([key, entry]) => message.merge === "replace" || !(key in model.entities) ? [...entry.present].map((field) => `${key}\u0000${field}`) : []);
+			return {
+				...model,
+				entities: RemotePersistence.mergeStores(model.entities, message.entities, message.merge),
+				failures: withoutFieldFailures(model.failures, written),
+				connections: restored.length === 0 ? model.connections : message.merge === "replace" ? {
+					...model.connections,
+					...Object.fromEntries(restored)
+				} : {
+					...Object.fromEntries(restored),
+					...model.connections
+				},
+				restoredFrom: message.from === void 0 ? model.restoredFrom : Option.some(message.from)
+			};
+		}
+		case "RefreshStarted": {
+			const marks = marksOf(message.requests);
+			const entities = setUnavailable(setStale(askAgain(model.entities, marks), marks, true), marks, false);
+			const reached = reachedMarks(model.entities, message.requests);
+			const failures = withoutFieldFailures(model.failures, reached);
+			const retried = reached.filter((mark) => mark in model.failures.fields);
+			const loading = retried.length === 0 ? model.loading : /* @__PURE__ */ new Set([...model.loading, ...retried]);
+			return {
+				...model,
+				entities,
+				failures,
+				loading
+			};
+		}
+		case "QueryStarted": {
+			const loading = new Set(model.loading);
+			for (const identity of message.connections) loading.add(connectionMark(identity));
+			return loading.size === model.loading.size ? model : {
+				...model,
+				loading
+			};
+		}
+		case "ReadStarted": return {
+			...model,
+			loading: withLoading(model.loading, message.requests),
+			refresh: withRefreshStarted(model.refresh, message.requests, message.refresh)
+		};
+		case "MutationStarted": return {
+			...model,
+			outbox: message.write?.durable === void 0 ? model.outbox : queuedWrite(model.outbox, message.requestId, message.write, message),
+			mutations: beginMutation(model.mutations, message.requestId, message.write === void 0 ? void 0 : {
+				mutation: message.write.mutation,
+				input: message.write.input,
+				keys: message.write.keys,
+				now: Option.fromUndefinedOr(message.write.now),
+				optimistic: message.optimistic ?? []
+			}),
+			optimistic: beginOptimistic(model.optimistic, message.requestId, message.optimistic ?? [], Option.fromUndefinedOr(message.viewer))
+		};
+		case "MutationSucceeded": {
+			const settled = settleSuccess(model.entities, model.optimistic, model.mutations, message.requestId, message);
+			const read = message.read === void 0 || model.mutations.applied.has(message.requestId) ? void 0 : unsettledRead(message.read, settledLater(model.mutations, message.requestId));
+			return {
+				...model,
+				entities: read === void 0 ? settled.store : writeRead(settled.store, read.requests, read.result, message.now),
+				mutations: settled.state,
+				outbox: withoutQueued(model.outbox, message.requestId),
+				optimistic: settled.optimistic,
+				failures: withoutFieldFailures(model.failures, [
+					...read === void 0 ? [] : [...fieldMarks(read.requests), ...patchedMarks(read.result.entities)],
+					...patchedMarks(message.entities),
+					...(message.deleted ?? []).flatMap((ref) => entityFailureMarks(model.failures, entityKey(ref.entity, ref.id)))
+				])
+			};
+		}
+		case "MutationQueued": return model;
+		case "OutboxDelayed": return {
+			...model,
+			outbox: withQueued(model.outbox, message.requestId, (queued) => Queued.Readable({
+				...queued,
+				attempt: message.attempt,
+				delayed: Option.some(message.error)
+			}))
+		};
+		case "OutboxRead": return readOutbox(model, message);
+		case "OverlayShown": return {
+			...model,
+			optimistic: beginOptimistic(settleFailure(model.optimistic, overlayLayer(message.id)), overlayLayer(message.id), message.optimistic)
+		};
+		case "WindowGrown": return {
+			...model,
+			grown: {
+				...model.grown,
+				[message.window]: message.size
+			}
+		};
+		case "OverlayLifted": {
+			const optimistic = settleFailure(model.optimistic, overlayLayer(message.id));
+			return optimistic.layers.length === model.optimistic.layers.length && optimistic.overlays.length === model.optimistic.overlays.length ? model : {
+				...model,
+				optimistic
+			};
+		}
+		case "MutationFailed": return {
+			...model,
+			outbox: !model.mutations.pending.has(message.requestId) ? model.outbox : withQueued(model.outbox, message.requestId, (queued) => Queued.Readable({
+				write: {
+					...queued.write,
+					revision: queued.write.revision + 1,
+					state: {
+						_tag: "Failed",
+						error: message.error
+					}
+				},
+				stored: false,
+				attempt: 0,
+				delayed: Option.none()
+			})),
+			mutations: failMutation(model.mutations, message.requestId, message.error, message.operation),
+			optimistic: settleFailure(model.optimistic, message.requestId)
+		};
+		case "LiveReceived": {
+			const state = model.live[message.stream] ?? emptyLiveState;
+			if (message.event._tag === "EntityPatched" || message.event._tag === "EntityDeleted") {
+				const event = message.event;
+				const applied = applyEntityEvent(state, model.entities, event, message.now);
+				if (applied.outcome === "gap") return broke(model, message.stream, Option.none());
+				const settled = applied.outcome !== "applied" ? [] : event._tag === "EntityPatched" ? [...patchedMarks([{
+					...event.ref,
+					values: event.values
+				}])] : entityFailureMarks(model.failures, entityKey(event.ref.entity, event.ref.id));
+				const next = {
+					...model,
+					entities: applied.store,
+					live: withLiveState(model.live, message.stream, applied.state),
+					failures: withoutFieldFailures(model.failures, settled)
+				};
+				return applied.outcome === "applied" ? healthy(next, message.stream) : next;
+			}
+			const applied = applyConnectionEvent(state, model.optimistic, message.event, message.policy);
+			if (applied.outcome === "gap") return broke(model, message.stream, Option.none());
+			const written = {
+				...model,
+				optimistic: applied.optimistic,
+				live: withLiveState(model.live, message.stream, applied.state)
+			};
+			const next = applied.outcome === "applied" ? healthy(written, message.stream) : written;
+			return applied.invalidated === void 0 ? next : invalidateConnections(next, [applied.invalidated]);
+		}
+		case "GapCleared": return clearGap(model, message.stream);
+		case "ConnectionMerged": {
+			const current = model.connections[message.connection] ?? emptyConnection;
+			const loading = withoutQueryLoading(model.loading, message.connection);
+			const replaces = message.refreshes === true && current.stale;
+			const merged = merge(replaces ? emptyConnection : current, message.page);
+			const payload = message.select === void 0 ? [] : message.entities ?? [];
+			const settled = message.select === void 0 ? [] : message.settled ?? [];
+			const requests = message.select === void 0 || payload.length === 0 && settled.length === 0 ? [] : message.page.edges.filter((edge) => edge.ref.entity === message.select.entity).map((edge) => ({
+				...message.select,
+				id: edge.ref.id
+			}));
+			const entities = requests.length === 0 ? model.entities : writeRead(model.entities, requests, {
+				entities: [...payload],
+				settled: [...settled]
+			}, message.now ?? 0);
+			const failures = withoutFieldFailures(withoutConnectionFailure(model.failures, message.connection), [...fieldMarks(requests), ...patchedMarks(payload)]);
+			return {
+				...model,
+				...checkedPlacement(model, message.connection, message.page, message.refreshes === true),
+				entities,
+				connections: {
+					...model.connections,
+					[message.connection]: message.refreshes === true ? {
+						...merged,
+						stale: false
+					} : merged
+				},
+				optimistic: pruneOverlays(model.optimistic, message.connection, new Set(message.page.edges.map((edge) => edge.key)), model.mutations.pending),
+				failures,
+				loading
+			};
+		}
+		case "ConnectionInvalidated": return {
+			...model,
+			connections: setConnectionStale(model.connections, message.connection, true),
+			failures: withoutConnectionFailure(model.failures, message.connection),
+			loading: message.connection in model.failures.connections ? /* @__PURE__ */ new Set([...model.loading, connectionMark(message.connection)]) : model.loading
+		};
+		case "QueryFailed": return {
+			...model,
+			failures: {
+				...model.failures,
+				connections: {
+					...model.failures.connections,
+					[message.connection]: message.error
+				}
+			},
+			loading: withoutQueryLoading(model.loading, message.connection)
+		};
+		case "ConnectionRefreshed": return {
+			...model,
+			connections: setConnectionStale(model.connections, message.connection, false)
+		};
+	}
+};
+/** The failures without one connection's, keeping identity when it had none. */
+const withoutConnectionFailure = (failures, connection) => {
+	if (!(connection in failures.connections)) return failures;
+	const { [connection]: _settled, ...connections } = failures.connections;
+	return {
+		...failures,
+		connections
+	};
+};
+/** The failures with every field a read asked for failed with `error`. */
+const withFieldFailures = (failures, requests, error) => {
+	const fields = { ...failures.fields };
+	for (const mark of fieldMarks(requests)) fields[mark] = error;
+	return {
+		...failures,
+		fields
+	};
+};
+/**
+* The failures without the fields `settled` names, keeping identity when none
+* of them had failed, which is nearly always: this runs on every write.
+*/
+const withoutFieldFailures = (failures, settled) => {
+	if (Object.keys(failures.fields).length === 0) return failures;
+	const marks = [...settled].filter((mark) => mark in failures.fields);
+	if (marks.length === 0) return failures;
+	const fields = { ...failures.fields };
+	for (const mark of marks) delete fields[mark];
+	return {
+		...failures,
+		fields
+	};
+};
+/** Every failed field of one entity: what deleting the entity settles. */
+const entityFailureMarks = (failures, key) => Object.keys(failures.fields).filter((mark) => mark.startsWith(`${key}\u0000`));
+/** The field marks of written values: each patch settles the fields it carries. */
+const patchedMarks = function* (patches) {
+	for (const patch of patches) for (const field of Object.keys(patch.values)) yield fieldMark(patch.entity, patch.id, field);
+};
+/**
+* Every field a read's requests reach: their own, and through each relation
+* the store already holds, the fields they ask of its targets. A request with
+* a relation riding on it names no target id; the store does, and a failure
+* recorded on a target is reached only this way.
+*/
+const reachedMarks = (store, requests) => {
+	const marks = [];
+	const walked = /* @__PURE__ */ new Map();
+	const walk = (entity, id, requirement) => {
+		const key = entityKey(entity, id);
+		const seen = walked.get(key) ?? /* @__PURE__ */ new Set();
+		if (seen.has(requirement)) return;
+		seen.add(requirement);
+		walked.set(key, seen);
+		for (const field of requirement.fields) {
+			marks.push(fieldMark(entity, id, field));
+			const nested = requirement.relations?.[field];
+			if (nested === void 0) continue;
+			const value = readField(store, key, field);
+			if (value._tag === "None") continue;
+			for (const ref of targetsOf(value.value, nested)) walk(ref.entity, ref.id, nested);
+		}
+	};
+	for (const request of requests) walk(request.entity, request.id, request);
+	return marks;
+};
+/** The entity key a field mark belongs to. */
+const markEntity = (mark) => mark.slice(0, mark.indexOf("\0"));
+/**
+* The failures of what the roots still reach. A released connection's or
+* entity's failure goes with it, so asking for it again later asks the server
+* again rather than repeating an error that may no longer hold.
+*
+* Reached is retention's own walk, taken over the Model before collection. It
+* counts a relation's target and a list's row that the store does not hold,
+* which is exactly a value whose first read failed: it is still on screen,
+* behind the parent that refers to it.
+*/
+const prunedFailures = (failures, roots, reached) => {
+	const named = new Set(roots.connections.map((root) => root.identity));
+	const connections = Object.entries(failures.connections).filter(([identity]) => named.has(identity));
+	const fields = Object.keys(failures.fields).length === 0 ? [] : Object.entries(failures.fields).filter(([mark]) => reached().has(markEntity(mark)));
+	return connections.length === Object.keys(failures.connections).length && fields.length === Object.keys(failures.fields).length ? failures : {
+		connections: Object.fromEntries(connections),
+		fields: Object.fromEntries(fields)
+	};
+};
+/** Whether this field's last read failed and nothing has settled it since. */
+const isFieldFailed = (model, entity, id, field) => fieldMark(entity, id, field) in model.failures.fields;
+/**
+* Whether a read is fetching any field `relation` reads of an entity, its own
+* or, through each relation the store holds, its targets'. A value whose owner
+* is being fetched is loading, not `Initial`: nothing is missing a fetch.
+*/
+const isLoadingThrough = (model, entity, id, relation) => {
+	if (model.loading.size === 0) return false;
+	const walked = /* @__PURE__ */ new Map();
+	const walk = (target, targetId, requirement) => {
+		const key = entityKey(target, targetId);
+		const seen = walked.get(key) ?? /* @__PURE__ */ new Set();
+		if (seen.has(requirement)) return false;
+		seen.add(requirement);
+		walked.set(key, seen);
+		for (const field of requirement.fields) {
+			if (model.loading.has(fieldMark(target, targetId, field))) return true;
+			const nested = requirement.relations?.[field];
+			if (nested === void 0) continue;
+			const value = readField(model.entities, key, field);
+			if (value._tag === "None") continue;
+			for (const ref of targetsOf(value.value, nested)) if (walk(ref.entity, ref.id, nested)) return true;
+		}
+		return false;
+	};
+	return walk(entity, id, relation);
+};
+/**
+* The first failure among the fields `relation` reads of an entity, following
+* each relation the store holds into its targets, as `assemble` does. A read
+* that consults it shows `Failed` for a related entity's failure too, rather
+* than waiting on a field nothing will fetch.
+*/
+const failureOf = (model, entity, id, relation) => {
+	const failed = model.failures.fields;
+	if (Object.keys(failed).length === 0) return void 0;
+	const walked = /* @__PURE__ */ new Map();
+	const walk = (target, targetId, requirement) => {
+		const key = entityKey(target, targetId);
+		const seen = walked.get(key) ?? /* @__PURE__ */ new Set();
+		if (seen.has(requirement)) return void 0;
+		seen.add(requirement);
+		walked.set(key, seen);
+		for (const field of requirement.fields) {
+			const error = failed[fieldMark(target, targetId, field)];
+			if (error !== void 0) return error;
+			const nested = requirement.relations?.[field];
+			if (nested === void 0) continue;
+			const value = readField(model.entities, key, field);
+			if (value._tag === "None") continue;
+			for (const ref of targetsOf(value.value, nested)) {
+				const found = walk(ref.entity, ref.id, nested);
+				if (found !== void 0) return found;
+			}
+		}
+	};
+	return walk(entity, id, relation);
+};
+/** Appends (after) or prepends (before) an incoming page onto the stored one. */
+const mergeWireRefPages = (current, next, direction) => {
+	const refs = direction === "after" ? [.../* @__PURE__ */ new Set([...current.refs, ...next.refs])] : [.../* @__PURE__ */ new Set([...next.refs, ...current.refs])];
+	return direction === "after" ? {
+		refs,
+		hasNext: next.hasNext,
+		hasPrevious: current.hasPrevious
+	} : {
+		refs,
+		hasNext: current.hasNext,
+		hasPrevious: next.hasPrevious
+	};
+};
+/**
+* A mutation answer's read without what a later request settled (#288): a
+* field it wrote, a row it deleted, and the absence of a row it wrote, which
+* the read would otherwise tombstone.
+*/
+const unsettledRead = (read, { newer, rewritten }) => {
+	const entities = read.result.entities.flatMap((entity) => {
+		if (newer(entityKey(entity.entity, entity.id))) return [];
+		const values = Object.fromEntries(Object.entries(entity.values).filter(([field]) => !newer(fieldMark(entity.entity, entity.id, field))));
+		return Object.keys(values).length === 0 ? [] : [{
+			...entity,
+			values
+		}];
+	});
+	const settled = read.result.settled.flatMap((entry) => {
+		if (newer(entityKey(entry.entity, entry.id))) return [];
+		const fields = entry.fields.filter((field) => !newer(fieldMark(entry.entity, entry.id, field)));
+		return fields.length === 0 ? [] : [{
+			...entry,
+			fields
+		}];
+	});
+	const answered = new Set([...entities, ...settled].map((entry) => entityKey(entry.entity, entry.id)));
+	return {
+		requests: read.requests.filter((request) => {
+			const key = entityKey(request.entity, request.id);
+			return answered.has(key) || !rewritten(key);
+		}),
+		result: {
+			entities,
+			settled
+		}
+	};
+};
+/**
+* Writes a read result into the store, recording each field's applied window so
+* a later request with a different window refetches. A relation page requested
+* with a cursor is merged onto the page already stored, so "load more"
+* accumulates rather than replaces. Every read path should use this rather than
+* reducing `writeEntity` by hand.
+*/
+const writeRead = (store, requests, result, now = 0) => {
+	const returned = /* @__PURE__ */ new Map();
+	for (const entity of result.entities) {
+		const key = entityKey(entity.entity, entity.id);
+		returned.set(key, {
+			...returned.get(key),
+			...entity.values
+		});
+	}
+	const byEntity = /* @__PURE__ */ new Map();
+	const record = (key, windows, relations) => {
+		let entry = byEntity.get(key);
+		if (entry === void 0) {
+			entry = {
+				windows: {},
+				merge: /* @__PURE__ */ new Map()
+			};
+			byEntity.set(key, entry);
+		}
+		for (const [field, window] of Object.entries(windows ?? {})) {
+			put(entry.windows, field, windowKey(window));
+			const direction = window.after !== void 0 ? "after" : window.before !== void 0 ? "before" : void 0;
+			if (direction !== void 0) entry.merge.set(field, direction);
+		}
+		const values = returned.get(key);
+		if (values === void 0) return;
+		for (const [field, relation] of Object.entries(relations ?? {})) for (const ref of targetsOf(values[field], relation)) record(entityKey(ref.entity, ref.id), relation.windows, relation.relations);
+	};
+	for (const request of requests) record(entityKey(request.entity, request.id), request.windows, request.relations);
+	const writes = [];
+	const pending = /* @__PURE__ */ new Map();
+	for (const entity of result.entities) {
+		const key = entityKey(entity.entity, entity.id);
+		const entry = byEntity.get(key);
+		let values = entity.values;
+		if (entry !== void 0 && entry.merge.size > 0) {
+			const previous = pending.get(key) ?? store[key]?.values;
+			if (previous !== void 0) {
+				const merged = { ...values };
+				for (const [field, direction] of entry.merge) {
+					const incoming = values[field];
+					const existing = previous[field];
+					if (isRefPage(incoming) && isRefPage(existing)) merged[field] = mergeWireRefPages(existing, incoming, direction);
+				}
+				values = merged;
+			}
+		}
+		pending.set(key, {
+			...pending.get(key),
+			...values
+		});
+		writes.push({
+			key,
+			values,
+			windows: entry?.windows
+		});
+	}
+	const settled = new Set(result.settled.map((entry) => entityKey(entry.entity, entry.id)));
+	let answered = store;
+	for (const request of requests) {
+		const key = entityKey(request.entity, request.id);
+		if (!returned.has(key) && !settled.has(key)) answered = tombstone(answered, key);
+		else if (settled.has(key) && isTombstone(answered, key)) answered = remove(answered, key);
+	}
+	return setUnavailable(writeEntities(answered, writes, now), result.settled.map((entry) => [entityKey(entry.entity, entry.id), entry.fields]), true);
+};
+export { 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 };
+
+//# sourceMappingURL=model.js.map