foldkit-remote 0.21.0 → 0.22.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["DomainEntity","Relational","jsonClient","httpClient","httpWithLiveClient"],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `foldkit-remote` — normalized application-facing server state.\n *\n * The pure core (entities, selections, the store, the planner, connections,\n * live classification, optimistic layers) performs no I/O. The `Remote.*`\n * helpers that read or mutate go through the `RemoteClient` Effect service.\n */\nimport {\n  Clock,\n  Duration,\n  Effect,\n  Layer,\n  Match,\n  Option,\n  Queue,\n  Record,\n  Result,\n  Schema,\n  Stream,\n} from 'effect'\nimport { KeyValueStore } from 'effect/persistence'\nimport {\n  Derivation,\n  Entity as DomainEntity,\n  Query as Relational,\n  QueryEvaluateError,\n  Operators,\n  ReadFilter,\n  SelectionTypeId,\n  type ExprContext,\n  type MemoryOperators,\n} from 'foldkit-entity'\nimport type * as Domain from 'foldkit-entity'\nimport type { RpcClientError } from 'effect/rpc'\nimport { mapMessage, type Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\nimport type * as Update from 'foldkit/update'\nimport * as Subscription from 'foldkit/subscription'\nimport type { EntryWithoutKeepAlive } from 'foldkit/subscription'\nimport {\n  type ActiveSurface,\n  type Contract,\n  type Invalid,\n  ModelRef,\n  type Focus,\n  type Projection,\n  type Surface,\n  type SurfaceSource,\n  type Wiring,\n} from 'foldkit-surface'\nimport {\n  RemoteClient,\n  coalescedLayer,\n  liveEventOf,\n  mintOperation,\n  mutateRemote,\n  remoteError,\n  type RemoteRpcClient,\n} from './client.js'\nimport {\n  emptyConnection,\n  hasNext,\n  hasPrevious,\n  isGapped,\n  items,\n  type Connection,\n  type Edge,\n} from './connection.js'\nimport {\n  Entity,\n  type EntityDescriptor,\n  type EntityPatch,\n  type EntityRef,\n  type FieldsFrom,\n  type PatchValues,\n} from './entity.js'\nimport { wireValues } from './patchValues.js'\nimport { EntityChange, Impact, changesOf, impactOn, type HeldConnection } from './impact.js'\nimport { belongsEncoded, matching, type Judged, type Matched } from './matching.js'\nimport { readWhy, regressed, Why, type ReadStep, type ReadWhy } from './why.js'\nimport { failedReasons, reasonsOf, type WhyReader } from './whyReasons.js'\n\n/** A body's dependencies as an explanation carries them: without the owner identity, which holds a symbol. */\nconst explainedDependencies = (dependencies: Domain.Dependencies): ExplainedDependencies => ({\n  fields: dependencies.fields.map(({ entity, key }) => ({ entity, key })),\n  inputs: dependencies.inputs,\n  operations: dependencies.operations,\n  operators: dependencies.operators.map(({ id, version }) => ({ id, version })),\n})\nimport {\n  inspectEntity,\n  inspectRemote,\n  type ExplainedDependencies,\n  type QueryExplanation,\n  type RemoteInspection,\n} from './inspect.js'\nimport type { LiveCursor, LiveEvent } from './live.js'\nimport {\n  failureOf,\n  initialRemoteModel,\n  overlaysOf,\n  isFieldFailed,\n  isLoadingThrough,\n  onlyOverlaid,\n  windowGrowthKey,\n  isQueryLoading,\n  isRemoteMessage,\n  dismissQueued,\n  forgetRemote,\n  refreshIsInFlight,\n  refreshedAt,\n  remoteMessageCases,\n  remoteMessageSchema,\n  remoteModelSchema,\n  retentionRootsSchema,\n  invalidateConnections,\n  updateRemote,\n  withRefreshRequested,\n  writeRead,\n  type RemoteMessage,\n  type RemoteMessageInput,\n  type RemoteMessageTag,\n  type RemoteModel,\n} from './model.js'\nimport {\n  forgetFailure,\n  mutationStatus,\n  predictionOfWrite,\n  brokenByWrite,\n  forbiddenByWrite,\n  DerivedBy,\n  type MutationDescriptor,\n  type MutationStatus,\n  type NormalizedPatch,\n  type PendingDelete,\n} from './mutation.js'\nimport {\n  connectionIdentity,\n  emptyOptimistic,\n  goneIn,\n  heldOnlyByRequests,\n  plannedStore,\n  resolvedPatches,\n  visibleItems,\n  visibleStore,\n  type ConnectionIdentity,\n  type ConnectionOverlay,\n  type EntityLayer,\n  type OptimisticState,\n  type OptimisticOperation,\n} from './optimistic.js'\nimport { RowPlace, placeIn, withEdge } from './placement.js'\nimport { deadlineOf, plan, type Deadline, type PlanOptions } from './plan.js'\nimport { RemotePolicy } from './policy.js'\nimport { IDENTITY_SEPARATOR, stableStringify } from './query.js'\nimport type { ConnectionSpec, LivePolicy, QueryDescriptor, QueryRef, QueryWindow } from './query.js'\nimport { remoteDataSchema, type RemoteData, type RemoteError } from './remoteData.js'\nimport type { ConnectionRoot, RetentionRoots } from './retain.js'\nimport {\n  Selection,\n  assemble,\n  pageSchema,\n  relationOf,\n  unavailableOf,\n  type Page,\n} from './selection.js'\nimport { sameData } from './data.js'\nimport {\n  emptyStore,\n  entityKey,\n  isTombstone,\n  missingFields,\n  readField,\n  type EntityStore,\n} from './store.js'\nimport { RemotePersistence, type Snapshot } from './persistence.js'\nimport {\n  backoff,\n  channelFor,\n  headOf,\n  mergeStored,\n  onlineAgain,\n  operationOf,\n  outboxStatus,\n  readEntries,\n  othersWaiting,\n  readStored,\n  sendLock,\n  storedFromText,\n  storedOf,\n  storedText,\n  storeLock,\n  StoredWrite,\n  settledIn,\n  withLock,\n  type OutboxStatus,\n  type RetryOptions,\n  type StoredOutbox,\n} from './outbox.js'\nimport { targetsOf } from './relation.js'\nimport {\n  QueryRequest,\n  QueryResult,\n  ReadRequest,\n  RelationRequest,\n  REMOTE_PROTOCOL_VERSION,\n  WindowSchema,\n  RemoteLiveError,\n  RemoteForbidden,\n  RemoteLiveRefused,\n  RemoteProtocolError,\n  RemoteQueryError,\n  RemoteReadError,\n  RemoteRpc,\n  RemoteUnauthenticated,\n  RemoteUnreachable,\n} from './wire.js'\nimport type { CoalesceOptions } from './coalesce.js'\nimport {\n  Requirement,\n  RemoteConnections,\n  RemoteRequirements,\n  connectionsOf,\n  requirementsOf,\n  type ConnectionRequirement,\n  type RelationRequirement,\n} from './requirement.js'\nimport { markAll, resumePart } from './resume.js'\nimport { answerGaps } from './answerGaps.js'\nimport {\n  PredictionPart,\n  predictionMismatch,\n  withDiagnostics,\n  type PredictionMismatch,\n} from './diagnostics.js'\nimport { reduceReporting } from './reporting.js'\nimport { patchedFields, shownOf } from './shown.js'\n\nimport { http as httpClient, json as jsonClient } from './json.js'\nimport { httpWithLive as httpWithLiveClient } from './sse.js'\nexport * from './client.js'\nexport type { RemoteResumePart } from './resume.js'\nexport {\n  PredictionPart,\n  type LiveRefused,\n  type OutboxUnreadable,\n  type OutboxUnsaved,\n  type PredictionMismatch,\n  type RemoteDiagnostic,\n  type WriteUnheard,\n} from './diagnostics.js'\n// The channel Remote reports into, for a server or a test that uses Remote alone.\nexport { Diagnostics, type Diagnostic, type ReportDiagnostic } from 'foldkit-surface'\nexport * from './coalesce.js'\nexport { RemoteJsonAnswer, RemoteJsonRequest, type RemoteJsonSend } from './json.js'\nexport { httpWithLive, liveFetch, type LiveFetchOptions } from './sse.js'\nexport * from './connection.js'\nexport * from './entity.js'\nexport * from './inspect.js'\nexport * from './live.js'\nexport * from './matching.js'\nexport { placeIn, RowPlace } from './placement.js'\nexport { ReadWhy, ShownBy, Why, WhyTerm, type ReadStep } from './why.js'\nexport * from './model.js'\nexport * from './mutation.js'\nexport * from './optimistic.js'\nexport * from './persistence.js'\nexport { OutboxItemState, type OutboxItem, type OutboxStatus, type RetryOptions } from './outbox.js'\nexport * from './plan.js'\nexport * from './policy.js'\nexport * from './query.js'\nexport * from './relation.js'\nexport * from './remoteData.js'\nexport * from './requirement.js'\nexport * from './retain.js'\nexport * from './selection.js'\nexport * from './store.js'\nexport * from './wire.js'\n\n/** What a domain registers: a Remote descriptor, or a `foldkit-entity` Entity (read through `Entity.from`). */\nexport type EntityLike = EntityDescriptor<any, any> | Domain.AnyEntity\n\n/**\n * What a read selects: a Remote Selection, or a `foldkit-entity` Selection\n * (read through `Selection.from`).\n */\nexport type EntitySelection<Value, Name extends string, Id extends string = string> =\n  | Selection<Value, Name, 'entity'>\n  | Domain.Selection<Name, unknown, Schema.Constraint & { readonly Type: Value }, Id>\n\nconst descriptorOf = (entity: EntityLike): EntityDescriptor<any, any> =>\n  DomainEntity.is(entity) ? Entity.from(entity as never) : entity\n\n/** The Remote descriptor either kind of entity reads as, at the type level. */\ntype DescriptorOf<E extends EntityLike> =\n  E extends EntityDescriptor<any, any>\n    ? E\n    : E extends Domain.AnyEntity\n      ? EntityDescriptor<E['name'], FieldsFrom<E>>\n      : never\n\ntype NameOf<E extends EntityLike> =\n  DescriptorOf<E> extends EntityDescriptor<infer N, any> ? N : never\ntype FieldsOf<E extends EntityLike> =\n  DescriptorOf<E> extends EntityDescriptor<any, infer F> ? F : never\n\nconst selectionOf = <Value, Name extends string>(\n  selection: EntitySelection<Value, Name>,\n): Selection<Value, Name, 'entity'> =>\n  SelectionTypeId in selection ? (Selection.from(selection) as never) : selection\n\ntype EntityName<D> = D extends { readonly name: infer Name extends string } ? Name : never\ntype QueryName<D> = D extends QueryDescriptor<infer Name, any, any> ? Name : never\ntype MutationName<D> = D extends MutationDescriptor<infer Name, any, any> ? Name : never\n\n/**\n * Nothing when `Name` is one of the domain's registered `Names`; otherwise a\n * branded failure naming the descriptor, so `Data.get(Team.select(…))` for an\n * unregistered `Team` errors at the selection in one line.\n */\nexport type Registered<Name extends string, Names extends string, Kind extends string> = [\n  Name,\n] extends [Names]\n  ? unknown\n  : Invalid<`${Kind} \"${Name}\" is not registered with this Remote domain`>\n\n/** Nothing when a selection is of the query's entity; otherwise a branded failure naming both. */\nexport type SelectsEntity<Entity extends string, Of extends string> = [Entity] extends [Of]\n  ? unknown\n  : Invalid<`the selection is of \"${Entity}\", but the query lists \"${Of}\"`>\n\nexport interface RemoteDescriptor<\n  Entities extends readonly EntityLike[] = readonly EntityLike[],\n  Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<\n    any,\n    any,\n    any\n  >[],\n  Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly MutationDescriptor<\n    any,\n    any,\n    any\n  >[],\n> {\n  readonly entities: Entities\n  readonly queries: Queries\n  readonly mutations: Mutations\n  readonly Model: Schema.Codec<RemoteModel, unknown>\n  readonly initial: RemoteModel\n  readonly Message: Schema.Schema<RemoteMessage>\n  readonly update: (model: RemoteModel, message: RemoteMessage) => RemoteModel\n  readonly rpc: typeof RemoteRpc\n  /** Name-keyed lookups built from the declared entities, queries, and mutations. */\n  readonly registry: {\n    readonly entities: ReadonlyMap<string, EntityDescriptor<any, any>>\n    readonly queries: ReadonlyMap<string, QueryDescriptor<any, any, any>>\n    readonly mutations: ReadonlyMap<string, MutationDescriptor<any, any, any>>\n    /**\n     * Per entity name, the members its server filters rows by under a rule\n     * the client does not run (`ReadFilter`), so a change to one is fetched,\n     * not placed.\n     */\n    readonly filtered: ReadonlyMap<string, ReadonlyArray<string>>\n    /**\n     * Per entity name, the members other registered Entities derive over its\n     * relations (`Derived.count`, `Derived.exists`), which a write of it\n     * moves: what a declared write predicts.\n     */\n    readonly derived: ReadonlyMap<string, ReadonlyArray<DerivedBy>>\n  }\n}\n\ndeclare const boundRemoteNames: unique symbol\n\nexport interface BoundRemote<AppModel, Store extends RemoteModel, Names extends string = string> {\n  readonly definition: RemoteDescriptor\n  /** The focus of the store's place in the application Model. */\n  readonly store: Focus<AppModel, Store>\n  /** For `Module`: owns the store's Model path. */\n  readonly contract: Contract\n  /**\n   * How the client runs primitive operators: `Remote.make`'s table, which a\n   * pending computed assignment is predicted by wherever the store is read.\n   */\n  readonly operators: MemoryOperators\n  /** Phantom: the entity names this Remote definition registers. */\n  readonly [boundRemoteNames]?: Names\n}\n\ntype MutationInput<M> = M extends MutationDescriptor<any, infer Input, any> ? Input : never\ntype MutationRefusal<M> =\n  M extends MutationDescriptor<any, any, any, infer Refused> ? Refused : never\n\n/** How `Data.persistence` keeps the cache across a reload. */\nexport interface PersistenceOptions<AppModel> {\n  /**\n   * Where the snapshot is stored, from the Model: one key per principal, so a\n   * change of principal reads and writes another snapshot.\n   */\n  readonly key: (model: AppModel) => string\n  /** Who the snapshot is for; one taken under another scope is discarded. */\n  readonly scope: (model: AppModel) => string\n  /** The query connections whose rows survive a reload; none by default. */\n  readonly connections?: ReadonlyArray<ConnectionIdentity> | undefined\n  /** What to keep, when it is not `snapshotOf` the `connections`. */\n  readonly snapshot?: ((remote: RemoteModel) => Snapshot) | undefined\n  /** A snapshot larger than this is neither written nor read. */\n  readonly maxBytes?: number | undefined\n  /** How long the cache must be unchanged before it is written; default 250 milliseconds. */\n  readonly debounce?: Duration.Input | undefined\n}\n\n/** `Data.persistence`'s wiring, and the restore its runtime's `init` starts from. */\nexport interface PersistenceWiring<AppModel> extends Wiring<\n  AppModel,\n  RemoteMessage,\n  KeyValueStore.KeyValueStore\n> {\n  /**\n   * The Model with the snapshot stored under its `key` restored, as the wiring\n   * would restore it. Resolve it as the runtime's `flags` and start `init`\n   * from it, so the first frame draws the stored rows; the wiring then\n   * restores only when `key` changes. A store it cannot read leaves the Model\n   * as it is, and the wiring tries again.\n   */\n  readonly restore: (model: AppModel) => Effect.Effect<AppModel, never, KeyValueStore.KeyValueStore>\n}\n\n/** How `Data.outbox` keeps durable writes across a reload. */\nexport interface OutboxOptions<AppModel> {\n  /**\n   * Where the queue is stored, from the Model: one key per principal, so one\n   * person's waiting writes are never sent as another's.\n   */\n  readonly key: (model: AppModel) => string\n  /**\n   * Who the queue is for, the principal. One stored under another scope reads\n   * as empty and is never written over; a page whose scope changes sends\n   * nothing it read for the old one, and reads the new one's.\n   */\n  readonly scope: (model: AppModel) => string\n  /** The wait between sends nothing answered: 1 second doubling to 30, unless given. */\n  readonly retry?: RetryOptions | undefined\n}\n\n/** `Data.outbox`'s wiring, and the restore its runtime's `init` starts from. */\nexport interface OutboxWiring<AppModel> extends Wiring<\n  AppModel,\n  RemoteMessage,\n  KeyValueStore.KeyValueStore | RemoteClient\n> {\n  /**\n   * The Model with the stored queue under its `key` read back, as the wiring\n   * would read it, and this page's session minted. Resolve it as the runtime's\n   * `flags` and start `init` from it: a durable write needs the session, and\n   * the first frame then shows the waiting writes.\n   */\n  readonly restore: (model: AppModel) => Effect.Effect<AppModel, never, KeyValueStore.KeyValueStore>\n}\n\nexport interface DomainMutateOptions {\n  /** Overrides the generated id, for a retry, a durable bridge, or a test. Not with `durable`. */\n  readonly requestId?: string | undefined\n  /**\n   * Queues the write in `Data.outbox` rather than sending it: stored first,\n   * sent in order by one tab, sent again after a reload with the same\n   * operation id and `now`, and after a failure that nothing answered. Its\n   * Command answers `MutationQueued`; the outbox's Subscriptions send it. Needs\n   * the outbox's `restore` to have run, and an input its Mutation encodes.\n   */\n  readonly durable?: boolean | undefined\n  /**\n   * What the request changes before the server answers, released when it\n   * settles. A function receives the generated ids, so a created entity can\n   * carry `tempId` until the result names the real one.\n   */\n  readonly optimistic?:\n    | ReadonlyArray<OptimisticOperation>\n    | ((ids: {\n        readonly requestId: string\n        readonly tempId: string\n      }) => ReadonlyArray<OptimisticOperation>)\n    | undefined\n  /**\n   * When the reader acted, in milliseconds since the epoch: what a time the\n   * write sets (`Expr.now` in `Entity.sets`) is predicted as, and the same\n   * number the request sends, which the server takes within its `clockSkew`.\n   * Read it where the action is, with `Remote.now`, since `update` reads no\n   * clock. Without it the time is not predicted, and the server's clock decides.\n   */\n  readonly now?: number | undefined\n  /**\n   * For a mutation that is a `Write`: the input keys to write, when only some\n   * changed (what an author edited). The rest of the input is still sent, whole.\n   */\n  readonly keys?: ReadonlyArray<string> | undefined\n}\n\n/**\n * One entry of the active record `subscriptions`, `wiring` and `satisfy`\n * take: a Surface as the Model activates it (`Surface.at`/`Surface.when`),\n * a source of keyed instances (`Surface.each`, or any `SurfaceSource`), or a\n * Surface without params read whole. A family joins its parent's\n * requirements with its instances', so passing the family alone fetches both\n * the page and what the page reveals.\n */\nexport type ActiveEntry<AppModel> =\n  | ActiveSurface<AppModel>\n  | Surface<AppModel, any, any, void>\n  | SurfaceSource<AppModel>\n\n/** A Foldkit Subscription entry of the Remote domain, emitting its Messages through `RemoteClient`. */\nexport type RemoteEntry<AppModel, Dependencies> = EntryWithoutKeepAlive<\n  AppModel,\n  RemoteMessage,\n  Dependencies,\n  RemoteClient\n>\n\n/**\n * The entries `RemoteDomain.subscriptions` returns for an active record: a read\n * and a live entry per key (the live one idles when nothing is read live), and\n * `retain`.\n */\nexport type SubscriptionEntries<AppModel, Active, Message = RemoteMessage> = {\n  // `Object.entries` turns a numeric key into a string, so numeric keys have entries too.\n  readonly [K in keyof Active & (string | number) as `${K}.read`]: EntryWithoutKeepAlive<\n    AppModel,\n    Message,\n    ReadDependencies,\n    RemoteClient\n  >\n} & {\n  readonly [K in keyof Active & (string | number) as `${K}.live`]: EntryWithoutKeepAlive<\n    AppModel,\n    Message,\n    LiveDependencies,\n    RemoteClient\n  >\n} & {\n  readonly retain: EntryWithoutKeepAlive<AppModel, Message, RetentionRoots, never>\n}\n\n/** The dependencies of a live entry: what it subscribes to, and where a restart resumes. */\nexport interface LiveDependencies {\n  readonly requirements: ReadonlyArray<Requirement>\n  /** The lists read live, each as its read sends it. */\n  readonly queries: ReadonlyArray<Schema.Schema.Type<typeof QueryRequest>>\n  readonly cursor: LiveCursor\n  readonly floor: number\n  /** How many times the stream broke; each break restarts it. */\n  readonly restarts: number\n  /** Breaks since its last applied event, which the restart's backoff grows with. */\n  readonly failures: number\n}\n\n/**\n * Whether what an active entry reads live is arriving. `Reconnecting` is a\n * stream that broke and waits to resubscribe; until it has, changes are\n * missed, and its rows may be out of date. `Refused` is a stream the server\n * would not open for what it asks: it is not retried until that changes.\n */\nexport type LiveStatus =\n  /** It reads nothing live. */\n  | { readonly _tag: 'Idle' }\n  /** Subscribed, and not broken since. */\n  | { readonly _tag: 'Live' }\n  | {\n      readonly _tag: 'Reconnecting'\n      /** Breaks in a row, the first being 1. */\n      readonly attempt: number\n      /** Why it broke; none for a gap in its events. */\n      readonly error: Option.Option<RemoteError>\n    }\n  /** The server refused it (`RemoteLiveRefused`); it waits for what it asks to change. */\n  | { readonly _tag: 'Refused'; readonly error: RemoteError }\n\nexport interface SubscriptionsOptions extends ObserveOptions, LiveOptions, RetainOptions {}\n\n/**\n * A Remote domain's wiring for an assembly: it routes Remote's Messages into\n * `reduce`, brings its Subscriptions and contract, and requires `RemoteClient`\n * from the runtime's resources Layer. The `Shared` tags reach the\n * application's own update too, after Remote has reduced them.\n */\nexport type RemoteWiring<AppModel, Shared extends RemoteMessageTag = never> = Wiring<\n  AppModel,\n  RemoteMessage | RemoteMessageInput,\n  RemoteClient,\n  RemoteMessageTag\n> & { readonly shared: ReadonlyArray<Shared> }\n\n/** How `Data.wiring` joins an assembly: its Subscriptions' options, and what the application hears. */\nexport interface WiringOptions<\n  Shared extends RemoteMessageTag = never,\n> extends SubscriptionsOptions {\n  /**\n   * Remote's Messages the application's own `update` receives as well, after\n   * Remote has reduced them, so the Model it gets already holds what they say:\n   * `['MutationFailed']` to react to a write that failed.\n   */\n  readonly shared?: ReadonlyArray<Shared> | undefined\n}\n\n/**\n * A write that failed and is neither retried nor dismissed, typed by its\n * mutation: what `Data.failedWrites` lists.\n */\nexport interface FailedWrite<M extends MutationDescriptor<any, any, any, any>> {\n  readonly requestId: string\n  readonly mutation: M\n  /** The input it was started with, to show or give back. */\n  readonly input: MutationInput<M>\n  readonly error: RemoteError\n  /** Why the server refused it, as `mutation` declares; none for any other failure. */\n  readonly refusal: Option.Option<MutationRefusal<M>>\n}\n\n/** `FailedWrite` of each of a union of mutations. */\nexport type FailedWriteOf<M> =\n  M extends MutationDescriptor<any, any, any, any> ? FailedWrite<M> : never\n\n/** What `RemoteDomain.mutate` hands `update`: the Model with the request started, and the Command that settles it. */\nexport interface MutationStarted<AppModel> {\n  readonly model: AppModel\n  readonly requestId: string\n  readonly tempId: string\n  /** Yields `MutationSucceeded` or `MutationFailed`; never fails. */\n  readonly command: Command<RemoteMessage, never, RemoteClient>\n}\n\n/**\n * A Remote domain bound to its place in the application Model: the descriptor\n * (`Remote.define`), the binding (`Remote.at`), and the application-facing\n * operations over them. Every method compiles to the `Remote.*` function of the\n * same name, which stays exported for tooling, SSR, and tests.\n */\nexport interface RemoteDomain<\n  AppModel,\n  Store extends RemoteModel,\n  Entities extends readonly EntityLike[],\n  Queries extends readonly QueryDescriptor<any, any, any>[],\n  Mutations extends readonly MutationDescriptor<any, any, any>[],\n>\n  extends\n    BoundRemote<AppModel, Store, EntityName<Entities[number]>>,\n    RemoteDescriptor<Entities, Queries, Mutations> {\n  /** `Remote.select`: a Projection reading one entity through a selection of a registered entity. */\n  get<Value, Name extends string, Id extends string = string>(\n    selection: EntitySelection<Value, Name, Id> &\n      Registered<Name, EntityName<Entities[number]>, 'Entity'>,\n    // The id type of the Entity selected: another Entity's branded id does not fit.\n    id: NoInfer<Id>,\n  ): Projection<AppModel, RemoteData<Value>>\n  /**\n   * `get`, and the projection also subscribes to the entity's changes: its\n   * requirements are marked `live`, so `subscriptions` derives a live entry for\n   * the Surfaces that read it.\n   */\n  live<Value, Name extends string, Id extends string = string>(\n    selection: EntitySelection<Value, Name, Id> &\n      Registered<Name, EntityName<Entities[number]>, 'Entity'>,\n    // The id type of the Entity selected: another Entity's branded id does not fit.\n    id: NoInfer<Id>,\n  ): Projection<AppModel, RemoteData<Value>>\n  /**\n   * A query connection read as a `Page` of items selected of the query's\n   * entity: `Initial` until the page and every item's selected fields are\n   * present, `Refreshing` while any of them is being refetched. The window is\n   * the page first asked for; the pages `next`, `previous` and `fetch` merge\n   * onto the connection read through the same projection.\n   */\n  query<Q extends QueryDescriptor<any, any, any>, Value, Entity extends string>(\n    query: Q & Registered<Q['name'], QueryName<Queries[number]>, 'Query'>,\n    input: QueryInput<Q>,\n    options: QueryOptions<Value, Entity, QueryEntity<Q>>,\n  ): QueryProjection<AppModel, Value, Q['name'], QueryInput<Q>>\n  /**\n   * \"Load more\": the Model with the read's window grown by one page, so it\n   * shows that many more rows; the read entry fetches what the connection\n   * lacks. None when the read shows everything there is (or is not a sized\n   * window). Called from `update`.\n   */\n  more<Name extends string, Input>(\n    model: AppModel,\n    projection: QueryProjection<AppModel, any, Name, Input>,\n  ): Option.Option<AppModel>\n  /**\n   * What a query read is and what it currently is, as one serializable value —\n   * data-query-DESIGN §29.1: the domain, the definition and its input, the\n   * connection identity, the window, the Selection, the body as readable text\n   * with what it depends on, and what the read answers from this Model.\n   *\n   * Pure, so a DevTools panel showing it shows something the Model can be\n   * replayed to.\n   *\n   * Given `surfaces` — the same active record `subscriptions` takes — it also\n   * reports which of them read this connection, and why each is active where\n   * that is a readable fact (`Surface.when`) rather than a callback\n   * (`Surface.at`). A Projection cannot carry this itself: several Surfaces may\n   * read one connection, so it is not a property of the read.\n   */\n  explain<Name extends string, Input>(\n    model: AppModel,\n    projection: QueryProjection<AppModel, any, Name, Input>,\n    options?: {\n      readonly surfaces?:\n        | Readonly<Record<string, ActiveSurface<AppModel> | SurfaceSource<AppModel>>>\n        | undefined\n    },\n  ): QueryExplanation\n  /**\n   * Why a read shows what it shows. Any Remote read: `Data.get`, `Data.live`\n   * or `Data.query`, or a projection made of them.\n   *\n   * `because` is every fact the Model holds about what it reads, as typed\n   * references: a list or a row's fields missing, stale, in flight or\n   * failed; a pending write showing a value, and which `where` term put a row\n   * in a list or took it out. The reason that decides the state comes first,\n   * and `message` says it, with what restarts it. For `Initial`, given\n   * `surfaces` (the record `subscriptions` takes), it tells the two wiring\n   * mistakes apart: no active Surface reads it, or one does and Remote's\n   * Subscriptions are not running. Pure: it reads the Model and plans nothing.\n   */\n  why(\n    model: AppModel,\n    projection: Projection<AppModel, RemoteData<unknown>>,\n    options?: {\n      readonly surfaces?:\n        | Readonly<Record<string, ActiveSurface<AppModel> | SurfaceSource<AppModel>>>\n        | undefined\n    },\n  ): ReadWhy\n  /**\n   * Each change of each read's tag across a recorded history (the Messages\n   * `update` handled, each with the Model it left, as Foldkit's devtools\n   * records them), with the Message that made it and `why` at the Model it\n   * changed to. `regression` marks a read that showed a value and stopped\n   * with no reason a reader can see (#234).\n   */\n  timeline<Message>(\n    start: AppModel,\n    history: ReadonlyArray<{ readonly message: Message; readonly model: AppModel }>,\n    reads: Readonly<Record<string, Projection<AppModel, RemoteData<unknown>>>>,\n    options?: {\n      readonly surfaces?:\n        | Readonly<Record<string, ActiveSurface<AppModel> | SurfaceSource<AppModel>>>\n        | undefined\n    },\n  ): ReadonlyArray<ReadStep<Message>>\n  /**\n   * The rows of a loaded list that a body matches, decoded as the list decodes\n   * them — a filter that asks the server nothing.\n   *\n   * **It filters a list; it does not run a query.** That distinction is what\n   * keeps it honest. \"Which rows match\" would need to know that the list holds\n   * every row the body could match, which is predicate containment and is\n   * deliberately not built. \"Which rows *of this list* match\" is decidable from\n   * what is already here, and is what a search box over a loaded page actually\n   * wants.\n   *\n   * `complete` says whether the answer is about the whole list: every edge\n   * judged, and the connection terminal at both ends. An incomplete answer is\n   * not wrong — it is about less than the caller may have meant, which is why\n   * it is said rather than left for a view to assume.\n   *\n   * Creates no connection, so there is nothing new to retain and nothing new to\n   * fetch. The server stays authoritative for which rows exist.\n   */\n  filtered<Value, Name extends string, Input, Q extends QueryDescriptor<any, any, any>>(\n    model: AppModel,\n    over: QueryProjection<AppModel, Value, Name, Input>,\n    by: Q & Registered<Q['name'], QueryName<Queries[number]>, 'Query'>,\n    input: QueryInput<Q>,\n  ): Matched<Value>\n  /**\n   * Shows operations over the store with no request behind them, as a mutation's\n   * `optimistic` ones show while it is in flight: every Selection and view draws\n   * them. For a preview of a change nobody has made. They stay until `lift`;\n   * showing an id again replaces what it showed. Called from `update`. A read\n   * of an entity only overlays show, lacking a field it selects, is `Failed`\n   * (`Overlaid`): nothing will fetch that field.\n   */\n  overlay(model: AppModel, id: string, optimistic: ReadonlyArray<OptimisticOperation>): AppModel\n  /** Lifts what `overlay` showed under this id. Lifting nothing returns the same Model. */\n  lift(model: AppModel, id: string): AppModel\n  /**\n   * The ids `overlay` shows now, in the order they are drawn, a later one over\n   * an earlier: what a caller that overlays from its own state reconciles\n   * against.\n   */\n  overlays(model: AppModel): ReadonlyArray<string>\n  /**\n   * The edges a connection shows, as its reads draw them: the server's pages\n   * with pending edits placed, each inserted row where the body's order puts\n   * it (or at the end its overlay names, when it cannot be placed), minus\n   * removed edges and tombstones. Takes the `RemoteModel`, so a persistence\n   * `snapshot` can store a list as it is shown.\n   */\n  visibleItems(remote: RemoteModel, connection: ConnectionIdentity): ReadonlyArray<Edge>\n  /**\n   * `Remote.refresh`: marks what `target` reads for this Model as due, for its\n   * read entries to refetch. `target` is a projection, a Surface without\n   * params, one entry of the active record, or the record itself, whose\n   * params come from the Model as they do for `subscriptions`; or a\n   * registered query's ref, which invalidates that list whatever its window. With\n   * `{ failed: true }` only what failed is asked again: a \"Try again\".\n   */\n  refresh(\n    model: AppModel,\n    target: RefreshTarget<AppModel, QueryName<Queries[number]>>,\n    options?: RefreshOptions,\n  ): AppModel\n  /** `Remote.forget`: the Model with every server-derived fact gone, for a change of principal. */\n  forget(model: AppModel): AppModel\n  /**\n   * A read of this domain as an active Surface, for `subscriptions` and\n   * `wiring`: `projectionOf` is what it reads for a Model, none while it\n   * reads nothing. It belongs to the domain's application, and lists no\n   * Messages: it is a requirement, not a sender. A domain made from a raw\n   * optic names no application, so this throws for one.\n   */\n  active<Value>(\n    name: string,\n    projectionOf: (model: AppModel) => Option.Option<Projection<AppModel, Value>>,\n  ): ActiveSurface<AppModel, Value>\n  /**\n   * The Foldkit Subscription entries for the active record, keyed for\n   * `Subscription.make`: a read entry per record entry (`Remote.observe`), a\n   * live entry per record entry that reads through `live` (`Remote.live`), and\n   * one retain entry (`Remote.retain`). A `Surface.each` family is one record\n   * entry whose read unions its parent's requirements with its instances'.\n   * Retention is the domain's: the retain entry of every call roots the active\n   * Surfaces of every call, so reads split over calls (one per policy) do not\n   * collect each other's data. A Surface's params are a function of the Model\n   * (`Surface.at`), so what is fetched, subscribed, and retained follows the\n   * Model.\n   */\n  subscriptions<const Active extends Readonly<Record<string, ActiveEntry<AppModel>>>>(\n    active: Active,\n    options?: SubscriptionsOptions,\n  ): SubscriptionEntries<AppModel, Active>\n  /** `Remote.plan`: the requirements the store does not satisfy. */\n  plan<Value>(\n    model: AppModel,\n    projection: Projection<AppModel, Value>,\n    options?: PlanOptions,\n  ): ReadonlyArray<Requirement>\n  /** `Remote.meta`: when what a projection shows was last received, and whether it is stale or loading. */\n  meta<Value>(model: AppModel, projection: Projection<AppModel, Value>): ReadMeta\n  /** `Remote.storeOf`: the visible store, base under the pending optimistic layers. */\n  storeOf(model: AppModel): EntityStore\n  /**\n   * `Remote.confirmed`: the same projection read against the server-derived\n   * store alone, with every pending optimistic layer and connection overlay\n   * left off. What it plans is unchanged — the requirements are the\n   * projection's own — so observing it reads exactly what observing the\n   * projection reads; only what it *shows* differs.\n   *\n   * A view usually wants the projection itself, which is the visible read:\n   * the optimistic layers are there so a change shows before the server has\n   * agreed to it. This is for the reader that must not believe a change until\n   * the server has confirmed it, which in practice is an Agent capability\n   * reporting that what it was asked to do is done:\n   *\n   * ```ts\n   * Agent.when({\n   *   projection: Data.confirmed(ProjectPage.model.project),\n   *   predicate: (project, request) => project.name === request.name,\n   * })\n   * ```\n   *\n   * There is deliberately no `visible`: a projection is already the visible\n   * read, and a wrapper that only forwards would be a second name for it.\n   */\n  confirmed<P extends Projection<AppModel, any>>(projection: P): P\n  /**\n   * The plan run through `RemoteClient` and reduced into the Model: the\n   * projection's pending queries first, then the fields it lacks (the pages'\n   * items included). For SSR, route or hover prefetch, and tests.\n   */\n  prefetch<Value>(\n    model: AppModel,\n    projection: Projection<AppModel, Value>,\n    options?: ObserveOptions,\n  ): Effect.Effect<\n    AppModel,\n    RemoteReadError | RemoteProtocolError | RemoteQueryError | RemoteUnauthenticated,\n    RemoteClient\n  >\n  /**\n   * The Model with everything the active Surfaces read, for a render that\n   * fetches nothing (SSR, a prerender). Each pass prefetches every Surface\n   * that plans a read, over the Model the one before it left, so a Surface\n   * active only once another's read has arrived is read in the next pass (or\n   * the same one, when it comes later in `active`). It stops at the first\n   * pass that plans nothing, and fails with `RemoteUnsatisfied` when\n   * `options.passes` run out first. Reads are cache-first: a field already\n   * held is not asked again. A server that could not tell who is asking\n   * fails it with `RemoteUnauthenticated`, for the host to answer as it\n   * answers a lost session.\n   */\n  satisfy(\n    model: AppModel,\n    active: Readonly<Record<string, ActiveEntry<AppModel>>>,\n    options?: SatisfyOptions,\n  ): Effect.Effect<\n    AppModel,\n    | RemoteReadError\n    | RemoteProtocolError\n    | RemoteQueryError\n    | RemoteUnauthenticated\n    | RemoteUnsatisfied,\n    RemoteClient\n  >\n  /**\n   * `satisfy` from `update`, for a destination the reader has not reached:\n   * a hover over a link, or a navigation the app expects. `model` is the\n   * Model as it would be there (the route set to the target's); the Command\n   * reads what `active` would read in it and yields one `Preloaded`\n   * carrying the Messages that wrote it, which reduce into the Model as it is\n   * by then. It never fails: a read that fails is one the destination makes\n   * again, and what was read before it still arrives.\n   *\n   * What it reads is kept like any other read until the next change of what\n   * is retained, so preload close to the navigation it expects.\n   */\n  preload(\n    model: AppModel,\n    active: Readonly<Record<string, ActiveEntry<AppModel>>>,\n    options?: SatisfyOptions,\n  ): Command<RemoteMessage, never, RemoteClient>\n  /**\n   * Starts a registered mutation from `update`: applies `MutationStarted` (with\n   * the optimistic operations) to the Model and returns the Command that runs\n   * it and yields the settling Message. The request id comes from the model's\n   * mutation sequence unless `options.requestId` is given.\n   */\n  mutate<M extends MutationDescriptor<any, any, any>>(\n    model: AppModel,\n    mutation: M & Registered<M['name'], MutationName<Mutations[number]>, 'Mutation'>,\n    input: MutationInput<M>,\n    options?: DomainMutateOptions,\n  ): MutationStarted<AppModel>\n  /**\n   * What Remote knows of a mutation `mutate` started, by its request id:\n   * pending, applied, or failed with the error the server or transport gave.\n   */\n  mutation(model: AppModel, requestId: string): MutationStatus\n  /**\n   * Why the server refused a mutation, as the value its `Refusal` declares:\n   * none while it is pending or applied, when it failed for another reason,\n   * or when the refusal does not decode as `mutation`'s.\n   */\n  refusal<Refused>(\n    model: AppModel,\n    requestId: string,\n    mutation: MutationDescriptor<string, any, any, Refused>,\n  ): Option.Option<Refused>\n  /**\n   * The writes that failed and are still owed an answer, oldest first, each\n   * with its mutation, the input it was started with, and why it failed. Given\n   * a mutation, only its writes, with its input type. A write is listed until\n   * `retry` sends it again, `dismiss` forgets it, or `forget` changes the\n   * principal; nothing drops one on a timer, since that would hide a failure\n   * the reader has not seen.\n   */\n  failedWrites(model: AppModel): ReadonlyArray<FailedWriteOf<Mutations[number]>>\n  failedWrites<M extends MutationDescriptor<any, any, any, any>>(\n    model: AppModel,\n    mutation: M & Registered<M['name'], MutationName<Mutations[number]>, 'Mutation'>,\n  ): ReadonlyArray<FailedWrite<M>>\n  /**\n   * Sends a failed write again as itself: the same input, request id and\n   * operation id (so a server that applied it answers from its record), with\n   * its optimistic operations shown again. None unless `failedWrites` lists it.\n   * A durable one is queued again, and the outbox sends it.\n   */\n  retry(model: AppModel, requestId: string): Option.Option<MutationStarted<AppModel>>\n  /**\n   * Forgets a failed write, so `failedWrites` no longer lists it; a durable one,\n   * or one the outbox cannot read, goes from its store and every tab. Anything\n   * else (a write still waiting, too) returns the same Model.\n   */\n  dismiss(model: AppModel, requestId: string): AppModel\n  /**\n   * The durable writes not yet settled, every tab's, in the order the outbox\n   * sends them: how many wait, how many the server refused, and each one's\n   * state, for a \"3 changes waiting\" line.\n   */\n  outboxStatus(model: AppModel): OutboxStatus\n  /**\n   * Whether what `active` reads live is arriving: `Reconnecting` from the\n   * moment its stream breaks until it resubscribes, which its live entry does\n   * on its own, with backoff.\n   */\n  liveStatus(model: AppModel, active: ActiveEntry<AppModel>): LiveStatus\n  /** `updateRemote` on the bound slice: reduces one of Remote's Messages, as `RemoteMessage` or as the application's union constructs it. */\n  reduce(model: AppModel, message: RemoteMessage | RemoteMessageInput): AppModel\n  /**\n   * How this domain joins an assembly: it routes Remote's Messages into\n   * `reduce`, brings its Subscriptions and contract, and requires\n   * `RemoteClient` from the runtime's resources Layer. One assembly holds at\n   * most one Remote wiring: every domain claims the same tags, and routing\n   * takes the first claimant. `shared` names the Messages the application's\n   * own update hears too.\n   */\n  wiring: <\n    const Active extends Readonly<Record<string, ActiveEntry<AppModel>>>,\n    const Shared extends RemoteMessageTag = never,\n  >(\n    active: Active,\n    options?: WiringOptions<Shared>,\n  ) => RemoteWiring<AppModel, Shared>\n  /**\n   * Keeps the cache across a reload, as a wiring beside `wiring`: the stored\n   * snapshot for `key` is restored (`Hydrated`, with what the store already\n   * holds kept over it, so a page resumed from the server wins) whenever the\n   * Model is not yet restored from `key`; and the cache is written back when it\n   * changes, once its own snapshot is in. Start `init` from its `restore` so\n   * the first frame already holds the snapshot. Overlays, optimistic layers,\n   * the mutation ledger, live cursors and gaps are never stored. A change of\n   * principal should `forget` in `update`, and name another `key`.\n   */\n  persistence(options: PersistenceOptions<AppModel>): PersistenceWiring<AppModel>\n  /**\n   * Keeps durable writes (`mutate`'s `durable`) across a reload and sends\n   * them, as a wiring beside `wiring`: the queue is written to `key` before a\n   * write is sent, sent oldest first by one tab (a Web Lock), sent again after\n   * a failure that nothing answered with a backoff, and read back by every\n   * tab. Start `init` from its `restore`. A change of principal should\n   * `forget` in `update`, and name another `key`.\n   */\n  outbox(options: OutboxOptions<AppModel>): OutboxWiring<AppModel>\n  /** `Remote.inspect` of the bound slice. */\n  inspect(model: AppModel): RemoteInspection\n}\n\n/** What `Remote.fold(Data, …).mutate` starts: `Data.mutate`'s result with its Command lifted. */\nexport type FoldedMutationStarted<AppModel, ParentMessage> = Omit<\n  MutationStarted<AppModel>,\n  'command'\n> & {\n  readonly command: Command<ParentMessage, never, RemoteClient>\n}\n\n/**\n * A bound domain folded under one of the application's own Message variants,\n * from `Remote.fold`. Calling it reduces a Remote Message into the Model; the\n * members that produce Messages, `fetch`, `mutate`, and `subscriptions`,\n * yield the wrapper Message instead of `RemoteMessage`, with the lift recorded\n * so Story and Scene can resolve a fetch or a mutation by Remote's own answer.\n * Members that only read or write the Model (`get`, `refresh`, `next`,\n * `overlay`, and the rest) stay on the domain itself.\n */\nexport interface RemoteFold<\n  AppModel,\n  ParentMessage,\n  Domain extends RemoteDomain<AppModel, any, any, any, any>,\n> {\n  (\n    model: AppModel,\n    message: RemoteMessage | RemoteMessageInput,\n  ): Update.Return<AppModel, ParentMessage>\n  /** `Data.mutate`, its Command lifted. */\n  readonly mutate: (\n    ...args: Parameters<Domain['mutate']>\n  ) => FoldedMutationStarted<AppModel, ParentMessage>\n  /** `Data.retry`, its Command lifted. */\n  readonly retry: (\n    ...args: Parameters<Domain['retry']>\n  ) => Option.Option<FoldedMutationStarted<AppModel, ParentMessage>>\n  /** `Data.preload`, its Command lifted. */\n  readonly preload: (\n    ...args: Parameters<Domain['preload']>\n  ) => Command<ParentMessage, never, RemoteClient>\n  /** `Data.subscriptions`, every entry lifted to the wrapper Message. */\n  readonly subscriptions: <const Active extends Readonly<Record<string, ActiveEntry<AppModel>>>>(\n    active: Active,\n    options?: SubscriptionsOptions,\n  ) => SubscriptionEntries<AppModel, Active, ParentMessage>\n}\n\n/** The application Model a bound domain is over. */\nexport type ModelOfDomain<Domain> =\n  Domain extends RemoteDomain<infer AppModel, any, any, any, any> ? AppModel : never\n\n/** A projection's connection requirement with the `QueryRef` that runs it. */\nexport interface QueryRequirement extends ConnectionRequirement {\n  readonly ref: QueryRef<string, unknown>\n}\n\n/** A page forward (`first`, `after`) or back (`last`, `before`); mixing the two is a type error. */\nexport type QueryWindowOptions =\n  | {\n      readonly first?: number | undefined\n      readonly after?: string | undefined\n      readonly last?: undefined\n      readonly before?: undefined\n    }\n  | {\n      readonly last: number\n      readonly before?: string | undefined\n      readonly first?: undefined\n      readonly after?: undefined\n    }\n\nexport type QueryOptions<Value, Entity extends string, Of extends string = Entity> = {\n  /** What to read of each item: a selection of the query's entity (`Of`). */\n  readonly select: EntitySelection<Value, Entity> & SelectsEntity<Entity, Of>\n  /**\n   * Watch the list live while a Surface reads it: rows that join, change or\n   * leave it are streamed (by a live source that watches queries, such as\n   * `foldkit-remote-drizzle`'s `pollLive`). Needs `first`.\n   */\n  readonly live?: boolean | undefined\n} & QueryWindowOptions\n\n/** A query connection read as a `Page` of selected items; `ref` is the connection with its first window. */\nexport interface QueryProjection<AppModel, Value, Name extends string, Input> extends Projection<\n  AppModel,\n  RemoteData<Page<Value>>\n> {\n  readonly ref: QueryRef<Name, Input>\n  /** What it reads of each item, so a filter over the same list decodes identically. */\n  readonly selection: Selection<Value, string>\n}\n\n/** The input of a query descriptor. */\nexport type QueryInput<Q> = Q extends QueryDescriptor<any, infer Input, any> ? Input : never\n/** The entity a query's connection is over. */\nexport type QueryEntity<Q> =\n  Q extends QueryDescriptor<any, any, ConnectionSpec<infer Entity>> ? Entity : string\n\n/**\n * What one consumer asks of one connection, as the pieces it is actually made\n * of — data-query-DESIGN §11's read contract, with only the parts that exist\n * here:\n *\n * - **source** — the `QueryRef`: the query and its input, whose `identity`\n *   names the connection and deliberately excludes the window.\n * - **window** — how much of it this consumer wants.\n * - **shape** — the Selection, as the relation slice a read asks the server for.\n *\n * The design's other two are absent on purpose. *Expectation* (required versus\n * optional) has no consumer yet, so there is nothing to carry. *Observation* is\n * a policy of the subscription that runs the read, not of the read itself: one\n * policy covers every connection an active Surface asks for.\n *\n * This is a shaping step, not a public type. The design asked for the\n * separation, not for a new API to compose it with.\n *\n * Note what is *not* here: a read identity keyed on the shape. Two consumers\n * asking one connection and window for different Selections merge into one\n * requirement whose fields are the union, so one read serves both — see\n * `Requirement.mergeConnections`. An identity that included the Selection would\n * split them and fetch twice.\n */\ninterface ReadContract<Name extends string, Input> {\n  readonly ref: QueryRef<Name, Input>\n  readonly relation: RelationRequirement\n  readonly requirement: QueryRequirement\n}\n\nconst readContract = <Name extends string, Input, Value, Entity extends string>(\n  source: QueryRef<Name, Input>,\n  shape: Selection<Value, Entity>,\n  window: QueryWindowOptions,\n): ReadContract<Name, Input> => {\n  const ref: QueryRef<Name, Input> = { ...source, window: pickWindow(window) }\n  const relation = relationOf(shape)\n  return {\n    ref,\n    relation,\n    requirement: { identity: ref.identity, window: ref.window, select: relation, ref },\n  }\n}\n\n/**\n * A read contract whose connection, when a client can place rows in it, also\n * reads every field its body filters and orders by: a changed row is then\n * compared with neighbours that hold those fields. What the view reads, and so\n * decodes, stays its Selection.\n */\nconst placeableReadContract = <Name extends string, Input>(\n  contract: ReadContract<Name, Input>,\n  body: Domain.AnyQuery | undefined,\n  operators: MemoryOperators,\n): ReadContract<Name, Input> => {\n  if (body === undefined) return contract\n  const { requirement, ref } = contract\n  const encoded = Schema.encodeSync(ref.Input)(ref.input) as Readonly<Record<string, unknown>>\n  if (Relational.placement(body, encoded, { operators })._tag !== 'Placeable') return contract\n  const missing = Relational.dependencies(body).fields.filter(\n    field => !requirement.select.fields.includes(field.key),\n  )\n  if (missing.length === 0) return contract\n  return {\n    ...contract,\n    requirement: {\n      ...requirement,\n      select: {\n        ...requirement.select,\n        fields: [...requirement.select.fields, ...missing.map(field => field.key)],\n      },\n    },\n  }\n}\n\n/**\n * When what a projection shows was last received, and whether it is stale\n * or loading. See `Remote.meta`.\n */\nexport interface ReadMeta {\n  /** The newest server write among what is shown; none received reads `undefined`. */\n  readonly updatedAt: number | undefined\n  /** Any shown field or connection is marked stale. */\n  readonly stale: boolean\n  /** Any shown field or connection is in flight. */\n  readonly loading: boolean\n}\n\nconst metaOf = (remote: RemoteModel, asked: Asked, operators: MemoryOperators): ReadMeta => {\n  const visible = visibleStoreOf(remote.entities, remote.optimistic, operators)\n  let updatedAt: number | undefined\n  let stale = false\n  let loading = false\n  const seen = new Set<string>()\n  const touch = (entity: string, id: string, requirement: RelationRequirement): void => {\n    const key = entityKey(entity, id)\n    const memo = `${key}\\u0000${stableStringify(requirement)}`\n    if (seen.has(memo)) return\n    seen.add(memo)\n    const entry = visible[key]\n    if (entry !== undefined && !entry.tombstone) {\n      for (const field of requirement.fields) {\n        if (!entry.present.has(field)) continue\n        if (Number.isFinite(entry.updatedAt))\n          updatedAt =\n            updatedAt === undefined ? entry.updatedAt : Math.max(updatedAt, entry.updatedAt)\n        if (entry.stale.has(field)) stale = true\n      }\n    }\n    if (isLoadingThrough(remote, entity, id, requirement)) loading = true\n    for (const [field, relation] of Object.entries(requirement.relations ?? {})) {\n      const value = readField(visible, key, field)\n      if (value._tag === 'None' || value.value === null || value.value === undefined) continue\n      for (const ref of targetsOf(value.value, relation)) touch(ref.entity, ref.id, relation)\n    }\n  }\n  for (const requirement of asked.requirements)\n    touch(requirement.entity, requirement.id, requirement)\n  for (const connection of asked.connections) {\n    const known = remote.connections[connection.identity]\n    if (known === undefined) {\n      if (isQueryLoading(remote, connection.identity)) loading = true\n      continue\n    }\n    if (known.stale) stale = true\n    if (isQueryLoading(remote, connection.identity)) loading = true\n    for (const edge of visibleItems(\n      known,\n      connection.identity,\n      remote.optimistic.overlays,\n      goneIn(remote.entities, remote.optimistic),\n    )) {\n      if (edge.ref.entity !== connection.select.entity) continue\n      touch(edge.ref.entity, edge.ref.id, connection.select)\n    }\n  }\n  return { updatedAt, stale, loading }\n}\n\n/**\n * The store a read or plan sees: the base with every pending optimistic layer\n * applied, so a request's patches show until it settles and a temporary id is\n * not planned as a fetch.\n */\nconst storeOf = <AppModel, Store extends RemoteModel, Names extends string>(\n  bound: BoundRemote<AppModel, Store, Names>,\n  model: AppModel,\n): EntityStore => {\n  const remote = bound.store.get(model)\n  return visibleStoreOf(remote.entities, remote.optimistic, bound.operators)\n}\n\n/**\n * The Model as it would be with nothing optimistic pending. Every read reaches\n * the layers through the Model it is given, so dropping them here is what makes\n * a read confirmed — no read has to know it is being read confirmed.\n */\nconst withoutOptimistic = <AppModel, Store extends RemoteModel, Names extends string>(\n  bound: BoundRemote<AppModel, Store, Names>,\n  model: AppModel,\n): AppModel => {\n  const remote = bound.store.get(model)\n  return remote.optimistic.layers.length === 0 && remote.optimistic.overlays.length === 0\n    ? model\n    : bound.store.set(model, { ...remote, optimistic: emptyOptimistic } as Store)\n}\n\nconst confirmed = <AppModel, Store extends RemoteModel, P extends Projection<AppModel, any>>(\n  bound: BoundRemote<AppModel, Store>,\n  projection: P,\n): P => ({\n  ...projection,\n  read: (root: AppModel) => projection.read(withoutOptimistic(bound, root)),\n})\n\n// The visible store is recomputed only when the base store or the layers\n// change, so reads and plans across renders of one Model share it. Keyed on\n// the layers rather than the whole optimistic state, which also changes with\n// every overlay (a live insert, a page pruning one) that no layer is part of.\n// By the client's table, then the layers, then the store: a prediction depends on all three.\nconst visibleStores = new WeakMap<\n  MemoryOperators,\n  WeakMap<object, WeakMap<EntityStore, EntityStore>>\n>()\n\nconst visibleStoreOf = (\n  entities: EntityStore,\n  optimistic: OptimisticState,\n  operators: MemoryOperators,\n): EntityStore => {\n  let byLayers = visibleStores.get(operators)\n  if (byLayers === undefined) {\n    byLayers = new WeakMap()\n    visibleStores.set(operators, byLayers)\n  }\n  let byStore = byLayers.get(optimistic.layers)\n  if (byStore === undefined) {\n    byStore = new WeakMap()\n    byLayers.set(optimistic.layers, byStore)\n  }\n  let visible = byStore.get(entities)\n  if (visible === undefined) {\n    visible = visibleStore(entities, optimistic, operators)\n    byStore.set(entities, visible)\n  }\n  return visible\n}\n\n// A visible store is made from one store and one set of layers, so it keys\n// what is planned over it; the read entries ask on every Model change.\nconst plannedStores = new WeakMap<EntityStore, EntityStore>()\n\n/** `plannedStore` of the visible store, kept by it. */\nconst plannedStoreOf = (\n  entities: EntityStore,\n  optimistic: OptimisticState,\n  visible: EntityStore,\n): EntityStore => {\n  let planned = plannedStores.get(visible)\n  if (planned === undefined) {\n    planned = plannedStore(entities, visible, optimistic)\n    plannedStores.set(visible, planned)\n  }\n  return planned\n}\n\n/**\n * `Failed` naming a field the server settled without a value, when one is\n * among what `relation` reads of the entity; otherwise nothing, and the store\n * merely lacks the value. The reason stays with the server, so a view shows\n * the field it cannot have, not why.\n */\nconst unavailableFailure = (\n  store: EntityStore,\n  key: string,\n  relation: RelationRequirement,\n): { readonly _tag: 'Failed'; readonly error: RemoteError } | undefined => {\n  const field = unavailableOf(store, key, relation)\n  return field === undefined\n    ? undefined\n    : {\n        _tag: 'Failed',\n        error: {\n          _tag: 'Unavailable',\n          message: `The server answered without ${field}, and will not answer with it: the field is not available to this client.`,\n        },\n      }\n}\n\n/**\n * A row's decoded value, kept while the data it was assembled from is the same,\n * so a refetch or live patch that brought equal data hands a view the object it\n * already rendered. Keyed on the row's own values object, which the store keeps\n * across equal writes; a relation's targets are covered by comparing what was\n * assembled.\n */\nconst decodedRows = new WeakMap<\n  object,\n  {\n    readonly decode: (values: unknown) => Result.Result<unknown, Schema.SchemaError>\n    readonly rows: WeakMap<object, { readonly values: unknown; readonly decoded: unknown }>\n  }\n>()\n\nconst decodeRow = <Value>(\n  schema: Schema.Codec<Value, unknown, never, never>,\n  source: object,\n  values: unknown,\n): Result.Result<Value, Schema.SchemaError> => {\n  let bySchema = decodedRows.get(schema)\n  if (bySchema === undefined) {\n    bySchema = { decode: Schema.decodeUnknownResult(schema), rows: new WeakMap() }\n    decodedRows.set(schema, bySchema)\n  }\n  const cached = bySchema.rows.get(source)\n  if (cached !== undefined && sameData(cached.values, values)) {\n    return cached.decoded as Result.Result<Value, Schema.SchemaError>\n  }\n  const decoded = bySchema.decode(values)\n  bySchema.rows.set(source, { values, decoded })\n  return decoded as Result.Result<Value, Schema.SchemaError>\n}\n\ninterface ReadScope {\n  readonly inner: WeakMap<object, ReadScope>\n  readonly results: Map<string, unknown>\n}\n\nconst readResults: ReadScope = { inner: new WeakMap(), results: new Map() }\n\n// A read's result per snapshot of everything it reads. `Remote.storeOf` is\n// shared across every read of one Model state, so equal reads of one render\n// assemble and decode once and return one value (a view may compare by\n// identity). A query read also depends on its connection and the overlays,\n// which change independently of the store, so it keys on those too. Weak on\n// every scope, bounded by what is read.\nconst memoRead = <T>(scopes: ReadonlyArray<object>, key: string, compute: () => T): T => {\n  let scope = readResults\n  for (const by of scopes) {\n    let inner = scope.inner.get(by)\n    if (inner === undefined) {\n      inner = { inner: new WeakMap(), results: new Map() }\n      scope.inner.set(by, inner)\n    }\n    scope = inner\n  }\n  if (scope.results.has(key)) return scope.results.get(key) as T\n  const value = compute()\n  scope.results.set(key, value)\n  return value\n}\n\nexport interface MutateOptions {\n  /** What the request changes before the server answers; released when it settles. */\n  readonly optimistic?: ReadonlyArray<OptimisticOperation> | undefined\n  /**\n   * When the reader acted, in milliseconds since the epoch, as `Remote.now`\n   * read it: sent for a time the write sets, which the server takes within\n   * its `clockSkew`.\n   */\n  readonly now?: number | undefined\n}\n\n/**\n * The default clock. It reads `Date.now` when called rather than holding the\n * function, so fake timers installed after the domain was made move it.\n */\nconst wallClock = (): number => Date.now()\n\n/** The default `toMessage`: the application reduces `RemoteMessage` itself. */\nconst identityMessage = (message: RemoteMessage): RemoteMessage => message\n\nexport interface RetainOptions {\n  /** The query connections the application shows, by `QueryRef` or identity. */\n  readonly connections?: ReadonlyArray<ConnectionIdentity> | undefined\n  /** How long the roots must be stable before collecting; default none. */\n  readonly grace?: Duration.Input | undefined\n}\n\n/** How `Remote.observe` and `Remote.prefetch` treat fields the store already holds. */\nexport interface ObserveOptions {\n  /** Default `RemotePolicy.cacheFirst`. */\n  readonly policy?: RemotePolicy | undefined\n  /** The clock a refreshing policy reads; default `Date.now`, read at each use. */\n  readonly now?: (() => number) | undefined\n}\n\n/** How `Data.satisfy` reads: how many passes it may take, and the clock. */\nexport interface SatisfyOptions {\n  /** At most this many passes over the Surfaces; default 8. */\n  readonly passes?: number | undefined\n  /** The clock the reads are stamped with; default `Date.now`, read at each use. */\n  readonly now?: (() => number) | undefined\n}\n\n/**\n * `Data.satisfy` reached its bound with Surfaces still reading, such as a\n * chain whose every read reveals one more. It names them, so a page that\n * would have rendered them loading fails instead. (A read the server leaves\n * unanswered settles as missing and ends the loop.)\n */\nexport class RemoteUnsatisfied extends Schema.TaggedError<RemoteUnsatisfied>()(\n  'RemoteUnsatisfied',\n  { surfaces: Schema.Array(Schema.String), passes: Schema.Number },\n) {}\n\nexport interface LiveOptions {\n  /** The clock `LiveReceived` stamps events with; default `Date.now`, read at each use. */\n  readonly now?: (() => number) | undefined\n  /**\n   * The first restart's delay after a stream breaks, doubled for each break in\n   * a row, with ±20% jitter: Sync's transport policy. Default `50 millis`.\n   */\n  readonly retryBase?: Duration.Input | undefined\n  /** The longest a restart waits. Default `5 seconds`. */\n  readonly maxRetryDelay?: Duration.Input | undefined\n}\n\n/** A stable key for a live subscription's rows and lists. */\nconst liveStreamKey = ({ requirements, queries }: LiveAsk): string =>\n  [\n    ...requirements.map(\n      requirement =>\n        `${entityKey(requirement.entity, requirement.id)}:${[...requirement.fields].sort().join(',')}`,\n    ),\n    ...queries.map(query => stableStringify(query)),\n  ]\n    .sort()\n    .join('|')\n\n/** Each registered Entity's `Derived.count`s and `Derived.exists`, under the pointing Entity. */\nconst derivedMembersBy = (\n  entities: ReadonlyArray<EntityLike>,\n): ReadonlyMap<string, ReadonlyArray<DerivedBy>> => {\n  const byPointing = new Map<string, Array<DerivedBy>>()\n  const add = (pointing: string, member: DerivedBy): void => {\n    const members = byPointing.get(pointing) ?? []\n    members.push(member)\n    byPointing.set(pointing, members)\n  }\n  for (const entity of entities) {\n    if (!DomainEntity.is(entity)) continue\n    const derived: Readonly<\n      Record<string, Domain.EntityDerived<string, string, Schema.Constraint>>\n    > = entity.derived\n    for (const [field, member] of Object.entries(derived))\n      Derivation.$match(member.derives, {\n        Supplied: () => undefined,\n        Count: ({ relation }) =>\n          add(\n            relation.owner.name,\n            DerivedBy.Count({ relation: relation.key, owner: entity.name, field }),\n          ),\n        Exists: ({ relation, viewer }) =>\n          add(\n            relation.owner.name,\n            DerivedBy.Exists({\n              relation: relation.key,\n              viewer: viewer.key,\n              owner: entity.name,\n              field,\n            }),\n          ),\n      })\n  }\n  return byPointing\n}\n\n/** Declares a Remote domain: its entities, queries, and mutations, plus the submodel. */\nconst defineRemote = <\n  const Entities extends readonly EntityLike[],\n  const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<\n    any,\n    any,\n    any\n  >[],\n  const Mutations extends readonly MutationDescriptor<any, any, any>[] =\n    readonly MutationDescriptor<any, any, any>[],\n>(config: {\n  readonly entities: Entities\n  readonly queries?: Queries\n  readonly mutations?: Mutations\n}): RemoteDescriptor<Entities, Queries, Mutations> => {\n  const entities = config.entities.map(descriptorOf)\n  return {\n    entities: entities as unknown as Entities,\n    queries: (config.queries ?? []) as unknown as Queries,\n    mutations: (config.mutations ?? []) as unknown as Mutations,\n    Model: remoteModelSchema(),\n    initial: initialRemoteModel,\n    Message: remoteMessageSchema,\n    update: updateRemote,\n    rpc: RemoteRpc,\n    registry: {\n      entities: new Map(entities.map(entity => [entity.name, entity])),\n      queries: new Map((config.queries ?? []).map(query => [query.name, query])),\n      mutations: new Map((config.mutations ?? []).map(mutation => [mutation.name, mutation])),\n      // Read from the Entities as given: a descriptor keeps no metadata.\n      filtered: new Map(\n        config.entities.flatMap(entity =>\n          DomainEntity.is(entity) ? [[entity.name, ReadFilter.members(entity.metadata)]] : [],\n        ),\n      ),\n      derived: derivedMembersBy(config.entities),\n    },\n  }\n}\n\n/** Binds a Remote domain to its store's location in the application Model. */\nconst bindRemote = <\n  AppModel,\n  Store extends RemoteModel,\n  Entities extends readonly EntityLike[],\n  Queries extends readonly QueryDescriptor<any, any, any>[],\n  Mutations extends readonly MutationDescriptor<any, any, any>[],\n>(\n  definition: RemoteDescriptor<Entities, Queries, Mutations>,\n  ref: ModelRef<AppModel, Store>,\n  operators: MemoryOperators,\n): BoundRemote<AppModel, Store, EntityName<Entities[number]>> => {\n  const store = ModelRef.focus(ref)\n  return {\n    definition,\n    store,\n    operators,\n    contract: {\n      kind: 'remote',\n      name: store.dependency.join('.') || 'remote',\n      // A generated field reference knows its application and its path; a raw\n      // optic (`ModelRef.fromOptic`) knows neither, so it claims nothing.\n      owner: (store as { readonly owner?: object }).owner,\n      owns: store.dependency.length === 0 ? [] : [store.dependency],\n      observes: store.dependency.length === 0 ? [] : [store.dependency],\n      messages: [],\n      metadata: [],\n    },\n  }\n}\n\n/** The runtime half of `Registered`: a descriptor the domain never declared is an error naming both. */\nconst assertRegistered = (\n  bound: BoundRemote<any, any>,\n  kind: 'Entity' | 'Query' | 'Mutation',\n  registered: ReadonlyMap<string, unknown>,\n  name: string,\n): void => {\n  if (!registered.has(name)) {\n    throw new Error(\n      `Remote: ${kind} \"${name}\" is not registered with domain \"${bound.contract.name}\"`,\n    )\n  }\n}\n\n/** What a projection asks of the remote: entity requirements and query connections. */\ninterface Asked {\n  readonly requirements: ReadonlyArray<Requirement>\n  readonly connections: ReadonlyArray<ConnectionRequirement>\n}\n\nconst askedOf = (projection: Projection<any, unknown>): Asked => ({\n  requirements: requirementsOf(projection),\n  connections: connectionsOf(projection),\n})\n\n/**\n * Whether `outer` asks for everything `inner` does of one entity: each field,\n * each relation's own slice of its target, and each page window alike.\n */\nconst sliceCovers = (outer: RelationRequirement, inner: RelationRequirement): boolean =>\n  outer.entity === inner.entity &&\n  inner.fields.every(field => outer.fields.includes(field)) &&\n  Object.entries(inner.relations ?? {}).every(([field, relation]) => {\n    const wider = outer.relations?.[field]\n    return wider !== undefined && sliceCovers(wider, relation)\n  }) &&\n  Object.entries(inner.windows ?? {}).every(\n    ([field, window]) =>\n      outer.windows?.[field] !== undefined &&\n      stableStringify(outer.windows[field]) === stableStringify(window),\n  )\n\n/**\n * Whether what `outer` asks includes everything `inner` asks: each list with\n * the slice it selects of its rows, and each entity with the slice it reads,\n * relations included. A Surface that shows a read is one whose projection\n * asks for all of it; one that reads part of it cannot be why it is fetched.\n * A Surface that asks for one entity in several pieces is already one\n * requirement here: projection metadata unions them per entity and id.\n */\nconst covers = (outer: Asked, inner: Asked): boolean => {\n  const { connections, requirements } = outer\n  return (\n    inner.connections.every(connection =>\n      connections.some(\n        wider =>\n          wider.identity === connection.identity &&\n          (connection.select === undefined ||\n            (wider.select !== undefined && sliceCovers(wider.select, connection.select))),\n      ),\n    ) &&\n    inner.requirements.every(requirement =>\n      requirements.some(wider => wider.id === requirement.id && sliceCovers(wider, requirement)),\n    )\n  )\n}\n\n/** The plan for what a projection asks: the entity fields to read, and the queries to run. */\ninterface Planned {\n  readonly requirements: ReadonlyArray<Requirement>\n  readonly queries: ReadonlyArray<QueryRequirement>\n  /** Under a freshness, when what is held next goes stale; `null` when nothing held will. */\n  readonly expires: Deadline | null\n}\n\n/**\n * Plans what a projection asks against the Model. A connection the Model holds\n * fresh contributes its visible items' selected fields to the entity plan; one\n * it does not hold, or holds stale, is a query to run (its items are planned\n * once the page arrives).\n *\n * A connection whose query failed is not run again here, short of `force`: the\n * failure is what its read shows, and retrying is `Remote.refresh`'s to ask\n * for. The rows it already holds are still planned, since they are on screen.\n */\n/**\n * One requirement per connection and direction: of the sized windows reading\n * a connection from its start (or end), the widest, which covers the rest.\n * Windows with a cursor are pages of their own and stay as they are.\n */\nconst widest = (\n  remote: RemoteModel,\n  connections: ReadonlyArray<QueryRequirement>,\n): ReadonlyArray<QueryRequirement> => {\n  const kept = new Map<string, QueryRequirement>()\n  const rest: QueryRequirement[] = []\n  for (const connection of connections) {\n    const size = windowSize(remote, connection)\n    if (size === undefined) {\n      rest.push(connection)\n      continue\n    }\n    const key = `${connection.identity}${String.fromCharCode(0)}${connection.window.first === undefined ? 'last' : 'first'}`\n    const current = kept.get(key)\n    if (current === undefined) kept.set(key, connection)\n    else if (size > (windowSize(remote, current) ?? 0))\n      kept.set(key, {\n        ...connection,\n        select: Requirement.mergeRelation(current.select, connection.select),\n      })\n    else\n      kept.set(key, {\n        ...current,\n        select: Requirement.mergeRelation(current.select, connection.select),\n      })\n  }\n  return [...kept.values(), ...rest]\n}\n\nconst withWindow = (connection: QueryRequirement, window: QueryWindow): QueryRequirement => ({\n  ...connection,\n  window,\n  ref: { ...connection.ref, window },\n})\n\n/**\n * The page a connection lacks for a window of `size` from its start (or end):\n * the rows after its first segment's end cursor (or before its last's start).\n * Undefined when it holds enough, reaches the end, or does not know where it\n * starts.\n */\nconst missingRows = (\n  known: Connection,\n  window: QueryWindow,\n  size: number,\n): QueryWindow | undefined => {\n  const forward = window.first !== undefined\n  const segment = forward ? known.segments[0] : known.segments[known.segments.length - 1]\n  if (segment === undefined) return undefined\n  const [from, to] = forward ? [segment.start, segment.end] : [segment.end, segment.start]\n  if (from._tag !== 'Terminal' || to._tag !== 'Cursor' || segment.edges.length >= size)\n    return undefined\n  const lacking = size - segment.edges.length\n  return forward ? { first: lacking, after: to.cursor } : { last: lacking, before: to.cursor }\n}\n\nconst planAsked = (\n  remote: RemoteModel,\n  asked: Asked,\n  options: PlanOptions,\n  operators: MemoryOperators,\n): Planned => {\n  const queries: QueryRequirement[] = []\n  const items: Requirement[] = []\n  const connections = Requirement.mergeConnections(\n    asked.connections,\n  ) as ReadonlyArray<QueryRequirement>\n  for (const connection of widest(remote, connections)) {\n    const known = remote.connections[connection.identity]\n    const failed = options.force !== true && connection.identity in remote.failures.connections\n    const size = windowSize(remote, connection)\n    if (!failed && (known === undefined || known.stale || options.force === true)) {\n      queries.push(\n        size === undefined\n          ? connection\n          : withWindow(\n              connection,\n              connection.window.first === undefined ? { last: size } : { first: size },\n            ),\n      )\n      continue\n    }\n    if (known === undefined) continue\n    // A wider window than the connection holds asks for the rows it lacks.\n    const tail =\n      failed || size === undefined ? undefined : missingRows(known, connection.window, size)\n    if (tail !== undefined) queries.push(withWindow(connection, tail))\n    const edges = visibleItems(\n      known,\n      connection.identity,\n      remote.optimistic.overlays,\n      goneIn(remote.entities, remote.optimistic),\n    )\n    items.push(\n      ...itemsOf(\n        edges.map(edge => edge.ref),\n        connection.select,\n      ),\n    )\n  }\n  const visible = visibleStoreOf(remote.entities, remote.optimistic, operators)\n  const read = [...asked.requirements, ...items]\n  const held = heldOnlyByRequests(remote.entities, remote.optimistic)\n  const planned = plan(plannedStoreOf(remote.entities, remote.optimistic, visible), read, options)\n  const sent = planned.filter(\n    requirement => !held.has(entityKey(requirement.entity, requirement.id)),\n  )\n  return {\n    requirements: options.force === true ? sent : withoutFailedFields(remote, sent),\n    queries,\n    expires:\n      options.freshness === undefined\n        ? null\n        : (deadlineOf(visible, read, options.freshness) ?? null),\n  }\n}\n\n/**\n * The plan without the fields whose last read failed. Like a failed query,\n * a failed field is shown rather than retried on its own, so a persistent\n * error is not asked again on every unrelated restart of the read entry. A\n * field leaving the request takes its window and its relation with it.\n */\nconst withoutFailedFields = (\n  remote: RemoteModel,\n  planned: ReadonlyArray<Requirement>,\n): ReadonlyArray<Requirement> => {\n  if (Object.keys(remote.failures.fields).length === 0) return planned\n  return planned.flatMap(requirement => {\n    const fields = requirement.fields.filter(\n      field => !isFieldFailed(remote, requirement.entity, requirement.id, field),\n    )\n    if (fields.length === requirement.fields.length) return [requirement]\n    if (fields.length === 0) return []\n    const kept = new Set(fields)\n    const only = <T>(record: Readonly<Record<string, T>> | undefined) =>\n      record === undefined\n        ? undefined\n        : Object.fromEntries(Object.entries(record).filter(([field]) => kept.has(field)))\n    const windows = only(requirement.windows)\n    const relations = only(requirement.relations)\n    return [\n      {\n        entity: requirement.entity,\n        id: requirement.id,\n        fields,\n        ...(windows === undefined || Object.keys(windows).length === 0 ? {} : { windows }),\n        ...(relations === undefined || Object.keys(relations).length === 0 ? {} : { relations }),\n        ...(requirement.live === undefined ? {} : { live: requirement.live }),\n      },\n    ]\n  })\n}\n\n/** The entity requirements a page's edges add under a selection. */\nconst itemsOf = (\n  edges: ReadonlyArray<{ readonly entity: string; readonly id: string }>,\n  select: RelationRequirement,\n): ReadonlyArray<Requirement> =>\n  edges.filter(edge => edge.entity === select.entity).map(edge => ({ ...select, id: edge.id }))\n\n/**\n * The wire request of a planned query; a `QueryRef` identity carries the query\n * name and the canonical encoded input. A connection requirement built by hand\n * with another identity cannot be run, and fails as a query would.\n */\nconst parsedQueryRequest = (query: {\n  readonly identity: string\n  readonly window: QueryWindow\n  readonly select?: RelationRequirement | undefined\n}): Result.Result<Schema.Schema.Type<typeof QueryRequest>, RemoteQueryError> => {\n  const separator = query.identity.indexOf('\\u0000')\n  if (separator < 0) {\n    return Result.fail(\n      new RemoteQueryError({\n        message: `connection \"${query.identity}\" is not a query's: only a QueryRef identity can be run`,\n      }),\n    )\n  }\n  try {\n    return Result.succeed({\n      query: query.identity.slice(0, separator),\n      input: JSON.parse(query.identity.slice(separator + 1)) as unknown,\n      window: query.window,\n      ...(query.select === undefined ? {} : { select: query.select }),\n    })\n  } catch {\n    return Result.fail(\n      new RemoteQueryError({ message: `connection \"${query.identity}\" carries no encoded input` }),\n    )\n  }\n}\n\nconst queryRequestOf = (\n  query: Parameters<typeof parsedQueryRequest>[0],\n): Effect.Effect<Schema.Schema.Type<typeof QueryRequest>, RemoteQueryError> =>\n  Effect.suspend(() =>\n    Result.match(parsedQueryRequest(query), { onFailure: Effect.fail, onSuccess: Effect.succeed }),\n  )\n\n/** What a live stream subscribes to: rows, and lists as their reads send them. */\ninterface LiveAsk {\n  readonly requirements: ReadonlyArray<Requirement>\n  readonly queries: ReadonlyArray<Schema.Schema.Type<typeof QueryRequest>>\n}\n\n/**\n * The live rows and lists of what projections ask. A list read live is a\n * `Data.query`, whose identity is always a query's, so one that is not is\n * this package's bug, and throws.\n */\nconst liveAskOf = (asked: Asked): LiveAsk => ({\n  requirements: asked.requirements.filter(requirement => requirement.live === true),\n  queries: asked.connections.flatMap(connection =>\n    connection.live === true ? [Result.getOrThrow(parsedQueryRequest(connection))] : [],\n  ),\n})\n\n/**\n * The `ConnectionMerged` for a query result, in the client's edge shape.\n * `refreshes` marks the page as answering the connection's refresh, so one\n * Message both merges it and clears `stale`.\n */\n/**\n * The page a window asked for, or the number of edges that came back instead.\n *\n * A window is a request the client made and the server answered, so more edges\n * than were asked for is a protocol disagreement rather than a windfall: the\n * client cannot tell which of them the window meant, the connection's\n * boundaries stop describing what it holds, and a `first: 25` that quietly\n * becomes a thousand is a memory event with no error attached to it.\n *\n * `undefined` when the page is within its window, or when no size was asked\n * for — `after`/`before` with no `first`/`last` bounds nothing.\n */\nconst overrun = (\n  window: QueryWindow,\n  edges: ReadonlyArray<unknown>,\n): { readonly asked: number; readonly got: number } | undefined => {\n  const asked = window.first ?? window.last\n  return asked !== undefined && edges.length > asked ? { asked, got: edges.length } : undefined\n}\n\nconst pageMessage = (\n  connection: string,\n  result: Schema.Schema.Type<typeof QueryResult>,\n  refreshes = false,\n  window: QueryWindow = {},\n  select?: RelationRequirement | undefined,\n  now?: number | undefined,\n): RemoteMessage => {\n  // Failed the way any query fails, with a named protocol error, rather than\n  // the page being silently accepted or an exception escaping a subscription.\n  const over = overrun(window, result.edges)\n  if (over !== undefined) {\n    return {\n      _tag: 'QueryFailed',\n      connection,\n      error: {\n        _tag: 'RemoteProtocolError',\n        message: `the server returned ${over.got} edges for a window of ${over.asked}`,\n      },\n    }\n  }\n  const hasPayload =\n    select !== undefined &&\n    ((result.entities !== undefined && result.entities.length > 0) ||\n      (result.settled !== undefined && result.settled.length > 0))\n  return {\n    _tag: 'ConnectionMerged',\n    connection,\n    page: {\n      edges: result.edges.map(edge => ({\n        key: edge.key,\n        ref: { entity: edge.entity, id: edge.id },\n      })),\n      start: result.start,\n      end: result.end,\n    },\n    ...(refreshes ? { refreshes } : {}),\n    ...(select === undefined || !hasPayload ? {} : { select }),\n    ...(hasPayload\n      ? {\n          entities: [...(result.entities ?? [])],\n          settled: [...(result.settled ?? [])],\n          now: now ?? 0,\n        }\n      : {}),\n  }\n}\n\n/**\n * The retention roots of some projections: their requirements, their\n * connections (each with the union of what the projections select of its\n * items), and the connections listed by identity alone.\n */\nconst rootsOf = (\n  projections: ReadonlyArray<Projection<any, unknown>>,\n  options: RetainOptions,\n): RetentionRoots => {\n  const connections = new Map<string, ConnectionRoot>()\n  for (const identity of (options.connections ?? []).map(connectionIdentity)) {\n    connections.set(identity, { identity })\n  }\n  for (const { identity, select } of projections.flatMap(connectionsOf)) {\n    const current = connections.get(identity)?.select\n    connections.set(identity, {\n      identity,\n      select: current === undefined ? select : Requirement.mergeRelation(current, select),\n    })\n  }\n  return {\n    requirements: Requirement.merge(projections.flatMap(requirementsOf)),\n    connections: [...connections.values()].sort((a, b) => (a.identity < b.identity ? -1 : 1)),\n  }\n}\n\n/** Reads requirements and reports the Message that settles them. Never fails. */\nconst readMessage = (\n  requirements: ReadonlyArray<Requirement>,\n  now: () => number,\n): Effect.Effect<RemoteMessage, never, RemoteClient> =>\n  Effect.gen(function* () {\n    const client = yield* RemoteClient\n    const at = now()\n    const result = yield* Effect.result(\n      client.read({ version: REMOTE_PROTOCOL_VERSION, requests: requirements }),\n    )\n    return Result.isFailure(result)\n      ? { _tag: 'ReadFailed', requests: requirements, error: remoteError(result.failure) }\n      : { _tag: 'ReadReceived', requests: requirements, result: result.success, now: at }\n  })\n\n/** Runs a query and reports the page that refreshes its connection, or the failure. Never fails. */\nconst queryMessage = (\n  query: {\n    readonly identity: string\n    readonly window: QueryWindow\n    readonly select?: RelationRequirement | undefined\n  },\n  now: () => number = wallClock,\n): Effect.Effect<RemoteMessage, never, RemoteClient> =>\n  Effect.gen(function* () {\n    const client = yield* RemoteClient\n    const result = yield* Effect.result(\n      queryRequestOf(query).pipe(Effect.flatMap(request => client.query(request))),\n    )\n    return Result.isFailure(result)\n      ? { _tag: 'QueryFailed', connection: query.identity, error: remoteError(result.failure) }\n      : pageMessage(query.identity, result.success, true, query.window, query.select, now())\n  })\n\n/** A query the read entry runs, as its dependencies carry it: plain data Foldkit compares. */\nconst PlannedQuery = Schema.Struct({\n  identity: Schema.String,\n  window: WindowSchema,\n  select: RelationRequest,\n})\n\n/** The dependencies of the read entry: the entity fields to read and the queries to run. */\nexport interface ReadDependencies {\n  readonly requirements: ReadonlyArray<Requirement>\n  readonly queries: ReadonlyArray<Schema.Schema.Type<typeof PlannedQuery>>\n  /**\n   * The highest generation the fields this entry reads were refreshed at: a\n   * refresh of any of them restarts the entry, and a refresh of anything else\n   * leaves it running.\n   */\n  readonly refresh: number\n  /**\n   * Under a refreshing policy, when a value the entry holds next ages out and\n   * what is due then. Time reaches Remote only as a Message: the entry sleeps\n   * until then and emits `RefreshStarted`, which marks the fields stale, and\n   * the plan that follows fetches them. A Model that does not change past its\n   * `maxAge` is otherwise never looked at again.\n   */\n  readonly expires: Deadline | null\n}\n\n/**\n * The read entry: plans what `askedOf(model)` asks against the Model and runs\n * the entity read and the queries concurrently. Each Message it emits changes\n * the Model, so Foldkit recomputes the dependencies and restarts the stream\n * (`switchMap`): a merged page's items are planned by that next computation,\n * against the store as it then is, rather than read here unplanned. Nothing\n * the entry needs is spread over two Messages, since the second could be lost\n * to the restart; a page and its refresh are one `ConnectionMerged`.\n */\nconst observeEntry = <AppModel, Store extends RemoteModel, Message>(\n  bound: BoundRemote<AppModel, Store>,\n  askedOf: (model: AppModel) => Asked,\n  toMessage: (message: RemoteMessage) => Message,\n  options: ObserveOptions,\n): EntryWithoutKeepAlive<AppModel, Message, ReadDependencies, RemoteClient> => {\n  const { policy = RemotePolicy.cacheFirst, now = wallClock } = options\n  const read = (requirements: ReadonlyArray<Requirement>) =>\n    Effect.map(readMessage(requirements, now), toMessage)\n  const run = (query: ReadDependencies['queries'][number]) =>\n    Effect.map(queryMessage(query, now), toMessage)\n  // A plan is a function of the Remote model, what is asked, and the clock only\n  // until the next value ages out (`expires`, which `deadlineOf` computes as\n  // exactly that moment), so a Model change the Remote model is not part of\n  // (typing in a field) reuses it rather than walking every row again.\n  const planned = new WeakMap<\n    RemoteModel,\n    Map<string, { readonly until: number; readonly dependencies: ReadDependencies }>\n  >()\n  return {\n    dependenciesSchema: Schema.Struct({\n      requirements: Schema.Array(ReadRequest),\n      queries: Schema.Array(PlannedQuery),\n      refresh: Schema.Number,\n      expires: Schema.NullOr(Schema.Struct({ at: Schema.Number, due: Schema.Array(ReadRequest) })),\n    }),\n    modelToDependencies: model => {\n      const remote = bound.store.get(model)\n      const asked = askedOf(model)\n      const askedKey = stableStringify(asked)\n      const at = now()\n      let byAsked = planned.get(remote)\n      const known = byAsked?.get(askedKey)\n      if (known !== undefined && at < known.until) return known.dependencies\n      const plan = planAsked(remote, asked, RemotePolicy.toPlan(policy, at), bound.operators)\n      const dependencies: ReadDependencies = {\n        refresh: refreshedAt(\n          remote.refresh,\n          plan.requirements,\n          plan.queries.map(query => query.identity),\n        ),\n        requirements: plan.requirements,\n        queries: plan.queries.map(({ identity, window, select }) => ({\n          identity,\n          window,\n          select,\n        })),\n        expires: plan.expires,\n      }\n      if (byAsked === undefined) {\n        byAsked = new Map()\n        planned.set(remote, byAsked)\n      }\n      byAsked.set(askedKey, { until: plan.expires?.at ?? Infinity, dependencies })\n      return dependencies\n    },\n    dependenciesToStream: ({ requirements, queries, refresh, expires }) =>\n      Stream.concat(\n        Stream.fromIterable([\n          ...(requirements.length === 0\n            ? []\n            : [\n                // Absent fields read as `Loading` until the read lands.\n                toMessage({ _tag: 'ReadStarted', requests: requirements, refresh }),\n                // A refreshing policy also marks the present ones stale.\n                ...(RemotePolicy.refreshes(policy)\n                  ? [toMessage({ _tag: 'RefreshStarted', requests: requirements })]\n                  : []),\n              ]),\n          // A list with nothing to show reads `Loading` until its page lands.\n          ...(queries.length === 0\n            ? []\n            : [\n                toMessage({\n                  _tag: 'QueryStarted',\n                  connections: queries.map(query => query.identity),\n                }),\n              ]),\n        ]),\n        Stream.merge(\n          Stream.mergeAll(\n            [\n              ...(requirements.length === 0 ? [] : [Stream.fromEffect(read(requirements))]),\n              ...queries.map(query => Stream.fromEffect(run(query))),\n            ],\n            { concurrency: 'unbounded' },\n          ),\n          // The clock's say, as a Message. Under the Effect clock, so a test\n          // can move it; against `now`, so the same clock sets and fires it.\n          expires === null\n            ? Stream.empty\n            : Stream.fromEffect(\n                Effect.as(\n                  Effect.sleep(Math.max(0, expires.at - now())),\n                  toMessage({ _tag: 'RefreshStarted', requests: expires.due }),\n                ),\n              ),\n        ),\n      ),\n  }\n}\n\n// Where a restarted stream resumes, not a reason to restart it: every applied\n// event advances the cursor, and a restart per event would close and reopen\n// the server stream each time. Said in the schema rather than with Foldkit's\n// `keepAliveEquivalence`, which would change the entry's public type\n// (`EntryWithoutKeepAlive`, the only entry type Foldkit exports) for every\n// application that spreads Remote's entries into its own.\nconst resumeCursor = Schema.Number.pipe(Schema.overrideToEquivalence(() => () => true))\n\n/** The wait before a stream's restart after `failures` breaks in a row: Sync's transport backoff. */\nconst restartDelay = (options: LiveOptions, failures: number): Duration.Duration => {\n  const base = Duration.toMillis(Duration.fromInputUnsafe(options.retryBase ?? '50 millis'))\n  const max = Duration.toMillis(Duration.fromInputUnsafe(options.maxRetryDelay ?? '5 seconds'))\n  const backoff = Math.min(max, base * 2 ** Math.min(Math.max(failures, 1) - 1, 30))\n  return Duration.millis(backoff * (0.8 + Math.random() * 0.4))\n}\n\n/** The live entry: subscribes to `liveOf(model)` from the Model's resume cursor. */\nconst liveEntry = <AppModel, Store extends RemoteModel, Message>(\n  bound: BoundRemote<AppModel, Store>,\n  liveOf: (model: AppModel) => LiveAsk,\n  toMessage: (message: RemoteMessage) => Message,\n  options: LiveOptions,\n): EntryWithoutKeepAlive<AppModel, Message, LiveDependencies, RemoteClient> => ({\n  dependenciesSchema: Schema.Struct({\n    requirements: Schema.Array(ReadRequest),\n    queries: Schema.Array(QueryRequest),\n    cursor: resumeCursor,\n    floor: Schema.Number,\n    restarts: Schema.Number,\n    // Read when a break restarts the stream; an applied event resetting it is no reason to.\n    failures: resumeCursor,\n  }),\n  modelToDependencies: model => {\n    const asked = liveOf(model)\n    const stream = liveStreamKey(asked)\n    const remote = bound.store.get(model)\n    const health = remote.streams[stream]\n    return {\n      requirements: asked.requirements,\n      queries: asked.queries,\n      cursor: remote.live[stream]?.cursor ?? 0,\n      // A stream is the principal's: `forget` moves the floor, and it restarts.\n      floor: remote.refresh.floor,\n      restarts: health?.restarts ?? 0,\n      failures: health?.failures ?? 0,\n    }\n  },\n  dependenciesToStream: ({ requirements, queries, cursor, restarts, failures }) => {\n    if (requirements.length === 0 && queries.length === 0) return Stream.empty\n    const stream = liveStreamKey({ requirements, queries })\n    const live = Stream.unwrap(\n      Effect.gen(function* () {\n        const client = yield* RemoteClient\n        return client.live({ requirements, queries, after: cursor })\n      }),\n    ).pipe(\n      Stream.map(event =>\n        toMessage({\n          _tag: 'LiveReceived',\n          stream,\n          event,\n          now: (options.now ?? wallClock)(),\n        }),\n      ),\n      Stream.catchIf(\n        (\n          _error,\n        ): _error is\n          | RemoteLiveError\n          | RemoteLiveRefused\n          | RemoteProtocolError\n          | RemoteUnauthenticated => true,\n        error =>\n          Stream.succeed(\n            toMessage({\n              _tag: 'ReadFailed',\n              requests: requirements,\n              error: remoteError(error),\n              stream,\n            }),\n          ),\n      ),\n    )\n    if (restarts === 0) return live\n    // The server replays nothing a stream missed while it was down, so a\n    // restart refetches what the stream covers. The gap closes before the\n    // resubscribe, so a resubscribe that fails is a break of its own; were the\n    // two concurrent, its failure could land on the open gap and be ignored,\n    // and the late `GapCleared` would leave the stream stopped.\n    return Stream.fromEffect(Effect.sleep(restartDelay(options, failures))).pipe(\n      Stream.drain,\n      Stream.concat(\n        Stream.make(\n          toMessage({ _tag: 'RefreshStarted', requests: requirements }),\n          toMessage({ _tag: 'GapCleared', stream }),\n        ),\n      ),\n      Stream.concat(live),\n    )\n  },\n})\n\n/** The projection an active entry has for this Model; none while it is inactive. */\nconst projectionOf = <AppModel>(\n  entry: ActiveEntry<AppModel>,\n  model: AppModel,\n): Option.Option<Projection<AppModel, unknown>> => {\n  if ('projectionOf' in entry) return entry.projectionOf(model)\n  // A bare Surface without params reads whole; a source without `instancesOf`\n  // cannot happen, and resolves to nothing if it does.\n  if ('projection' in entry) return Option.some(entry.projection())\n  return Option.none()\n}\n\n/** One of an entry's reads, named for diagnostics: a lone Surface keeps its name, a family instance takes `Child[key]`. */\ninterface NamedProjection<AppModel> {\n  readonly name: string\n  readonly projection: Projection<AppModel, unknown>\n}\n\n/**\n * Every projection an entry resolves to for a Model: the lone one of a\n * `Surface.at`/`Surface.when` value or a bare Surface, or a family's parent\n * first and then each instance. The parent joins so an unloaded parent is\n * fetched before what it reveals; `Data.satisfy` reaches the instances in a\n * later pass. A caller that also passes the parent separately double-covers\n * its requirements, as overlapping Surfaces already do.\n */\nconst resolvedOf = <AppModel>(\n  entry: ActiveEntry<AppModel>,\n  model: AppModel,\n): ReadonlyArray<NamedProjection<AppModel>> => {\n  const source = entry as Partial<SurfaceSource<AppModel>>\n  if (typeof source.instancesOf === 'function') {\n    const instances = source.instancesOf(model)\n    const from = (entry as { readonly from?: ActiveSurface<AppModel> }).from\n    // A lone `Surface.at`/`Surface.when` keeps its name; a family names each\n    // instance after its key, with the parent first.\n    if (from === undefined)\n      return instances.map(instance => ({ name: entry.name, projection: instance.projection }))\n    return [\n      ...Option.toArray(from.projectionOf(model)).map(projection => ({\n        name: from.name,\n        projection,\n      })),\n      ...instances.map(instance => ({\n        name: `${entry.name}[${instance.key}]`,\n        projection: instance.projection,\n      })),\n    ]\n  }\n  return Option.toArray(projectionOf(entry, model)).map(projection => ({\n    name: entry.name,\n    projection,\n  }))\n}\n\n/** What some projections ask for together: their requirements and connections unioned. */\nconst askedUnion = (projections: ReadonlyArray<Projection<any, unknown>>): Asked => ({\n  requirements: projections.flatMap(requirementsOf),\n  connections: projections.flatMap(connectionsOf),\n})\n\n/**\n * `resolvedOf` computed once per Model: the read, live, and retain entries\n * all derive their dependencies from the same projections on the same Model\n * change, and a Surface's `model` callback (which lifts and builds schemas)\n * need not run three times for it. Models are objects, so the memo is weak.\n */\nconst memoizedResolved = <AppModel>(\n  entry: ActiveEntry<AppModel>,\n): ((model: AppModel) => ReadonlyArray<NamedProjection<AppModel>>) => {\n  const cache = new WeakMap<object, ReadonlyArray<NamedProjection<AppModel>>>()\n  return model => {\n    const key: unknown = model\n    if (typeof key !== 'object' || key === null) return resolvedOf(entry, model)\n    const known = cache.get(key)\n    if (known !== undefined) return known\n    const resolved = resolvedOf(entry, model)\n    cache.set(key, resolved)\n    return resolved\n  }\n}\n\n/**\n * What `Data.refresh` asks again: a projection, a Surface without params, one\n * entry of the active record (a `Surface.at`/`Surface.when` value, a family),\n * the whole record, or one list by its query and input (`Everyone.ref({})`),\n * whatever window reads it.\n */\nexport type RefreshTarget<AppModel, Queries extends string = string> =\n  | Projection<AppModel, unknown>\n  | ActiveEntry<AppModel>\n  | Readonly<Record<string, ActiveEntry<AppModel>>>\n  | QueryRef<Queries, any>\n\n/** How `Data.refresh` asks again. */\nexport interface RefreshOptions {\n  /** Only what failed: a \"Try again\" leaves what loaded as it is. */\n  readonly failed?: boolean | undefined\n}\n\n/** Why the server refused a write, as `mutation` declares it: none for any other failure, or one that does not decode. */\nconst refusalOf = <Refused>(\n  error: RemoteError,\n  mutation: MutationDescriptor<string, any, any, Refused>,\n): Option.Option<Refused> =>\n  error.refusal === undefined\n    ? Option.none()\n    : Schema.decodeUnknownOption(mutation.Refusal)(error.refusal)\n\n/** Refuses an entry of another application: two can share a Model type, and the owner token tells them apart. */\nconst assertOwnedBy = <AppModel>(contract: Contract, entry: ActiveEntry<AppModel>): void => {\n  if (contract.owner === undefined) return\n  const from = (entry as { readonly from?: ActiveSurface<AppModel> }).from\n  for (const surface of from === undefined ? [entry] : [entry, from]) {\n    if (surface.owner !== contract.owner) {\n      throw new Error(\n        `Remote: Surface \"${surface.name}\" belongs to another application than domain \"${contract.name}\"`,\n      )\n    }\n  }\n}\n\n/** Whether a refresh target is one list by its query and input. */\nconst isQueryRef = <AppModel>(target: RefreshTarget<AppModel>): target is QueryRef<string, any> =>\n  // No projection or entry has an identity, and a record's values are entries,\n  // never strings, so a record keyed `identity` cannot pass for a ref.\n  typeof (target as Partial<Record<'identity', unknown>>).identity === 'string'\n\n/** Whether a refresh target is a projection, the one kind that is not a Surface. */\nconst isProjection = <AppModel>(\n  target: RefreshTarget<AppModel>,\n): target is Projection<AppModel, unknown> =>\n  typeof (target as Partial<Record<'read', unknown>>).read === 'function'\n\n/** Whether a refresh target is one entry of an active record rather than the record. */\nconst isActiveEntry = <AppModel>(\n  target: ActiveEntry<AppModel> | Readonly<Record<string, ActiveEntry<AppModel>>>,\n): target is ActiveEntry<AppModel> => {\n  // A record's values are entries, never functions, so a key that happens to\n  // be named like a member cannot pass for one.\n  const members = target as Partial<Record<'projection' | 'projectionOf' | 'instancesOf', unknown>>\n  return (\n    typeof members.projectionOf === 'function' ||\n    typeof members.instancesOf === 'function' ||\n    typeof members.projection === 'function'\n  )\n}\n\n/** Every projection a refresh target reads for this Model, each entry resolved as the read entries resolve it. */\nconst targetProjections = <AppModel>(\n  contract: Contract,\n  target: Exclude<RefreshTarget<AppModel>, QueryRef<string, any>>,\n  model: AppModel,\n): ReadonlyArray<Projection<AppModel, unknown>> => {\n  if (isProjection(target)) return [target]\n  const entries = isActiveEntry(target) ? [target] : Object.values(target)\n  // Checked before any is resolved, so a refused call reads nothing.\n  for (const entry of entries) assertOwnedBy(contract, entry)\n  return entries.flatMap(entry => resolvedOf(entry, model).map(({ projection }) => projection))\n}\n\nexport const Remote = {\n  /** The submodel's schema, the same for every domain; embed it in the application Model. */\n  Model: remoteModelSchema(),\n  /** The submodel's initial value. */\n  initial: initialRemoteModel,\n  /**\n   * Remote's Message cases for `defineMessageUnion`: spread them into the\n   * application's union, and reduce the ones `Remote.reduces` recognizes with\n   * `RemoteDomain.reduce`.\n   */\n  messages: remoteMessageCases,\n  /** Whether a Message is one of Remote's, by tag. */\n  reduces: isRemoteMessage,\n  /**\n   * Remote's Messages as one Schema, for a wrapper variant in the\n   * application's union: `GotRemoteMessage: { message: Remote.Message }`. With\n   * a wrapper, `update` matches the application's union exhaustively and\n   * `Remote.fold` reduces what arrives inside it.\n   */\n  Message: defineMessageUnion(remoteMessageCases),\n  /**\n   * A bound domain under one wrapper variant of the application's union, the\n   * same shape Foldkit gives a Submodel: `toParentMessage` wraps Remote's\n   * Messages, the fold reduces them, and its `fetch`, `mutate`, and\n   * `subscriptions` yield the wrapper. Spreading `Remote.messages` and\n   * narrowing with `Remote.reduces` remains the shorter path for an\n   * application whose `update` only reduces.\n   *\n   * @example\n   * ```ts\n   * const Message = defineMessageUnion({ GotRemoteMessage: { message: Remote.Message } })\n   * const foldData = Remote.fold(Data, message => Message.GotRemoteMessage({ message }))\n   *\n   * const update = (model: Model, message: Message): Return =>\n   *   Message.match(message, {\n   *     GotRemoteMessage: ({ message }) => foldData(model, message),\n   *   })\n   * const subscriptions = Subscription.make<Model, Message, RemoteClient>()(() =>\n   *   foldData.subscriptions({ page: Surface.at(ProjectPage, …) }),\n   * )\n   * ```\n   */\n  fold: <Domain extends RemoteDomain<any, any, any, any, any>, ParentMessage>(\n    domain: Domain,\n    toParentMessage: (message: RemoteMessage) => ParentMessage,\n  ): RemoteFold<ModelOfDomain<Domain>, ParentMessage, Domain> => {\n    type AppModel = ModelOfDomain<Domain>\n    // The application's own update receives every Remote Message here, so it hears each failure.\n    const fold = (model: AppModel, message: RemoteMessage | RemoteMessageInput) => {\n      const reduced = reduceReporting(domain.store, domain.reduce, model, message, true)\n      return {\n        model: reduced.model,\n        commands: (reduced.commands ?? []).map(command => mapMessage(command, toParentMessage)),\n      }\n    }\n    return Object.assign(fold, {\n      mutate: (...args: Parameters<Domain['mutate']>) => {\n        const started = domain.mutate(\n          ...(args as Parameters<RemoteDomain<AppModel, any, any, any, any>['mutate']>),\n        )\n        return { ...started, command: mapMessage(started.command, toParentMessage) }\n      },\n      retry: (...args: Parameters<Domain['retry']>) =>\n        Option.map(\n          domain.retry(\n            ...(args as Parameters<RemoteDomain<AppModel, any, any, any, any>['retry']>),\n          ),\n          started => ({ ...started, command: mapMessage(started.command, toParentMessage) }),\n        ),\n      preload: (...args: Parameters<Domain['preload']>) =>\n        mapMessage(\n          domain.preload(\n            ...(args as Parameters<RemoteDomain<AppModel, any, any, any, any>['preload']>),\n          ),\n          toParentMessage,\n        ),\n      subscriptions: (\n        active: Readonly<Record<string, ActiveEntry<AppModel>>>,\n        options?: SubscriptionsOptions,\n      ) =>\n        markAll(\n          messagesAs(brandEntries(domain.subscriptions(active, options)), toParentMessage),\n        ) as never,\n    })\n  },\n\n  /**\n   * A patch of one entity's values, for a mutation's `optimistic` list or an\n   * overlay. Takes a `foldkit-entity` Entity or a Remote descriptor alike, so\n   * the domain you declared once is the one you patch:\n   * `Remote.patch(Project, 'p1', { name: 'Apollo II' })`. Values are the\n   * fields' wire shape, as the server writes them, except a relation, which is\n   * a ref (`owner: Remote.ref(User, 'u1')`), an array of refs, or `null` where\n   * it is optional. A ref key typed by hand, or a ref to another Entity, is\n   * refused, in the type and when the patch is made.\n   */\n  patch: <E extends EntityLike>(\n    entity: E,\n    id: string,\n    values: PatchValues<FieldsOf<E>>,\n  ): EntityPatch<NameOf<E>, FieldsOf<E>> => {\n    const descriptor = descriptorOf(entity)\n    return descriptor.patch(id, wireValues(descriptor, values)) as EntityPatch<\n      NameOf<E>,\n      FieldsOf<E>\n    >\n  },\n\n  /**\n   * A deletion of one entity, for a mutation's `optimistic` list or an\n   * overlay: `Remote.tombstone(Post, 'p1')`. Until it settles the row reads\n   * `NotFound` and leaves every list and relation, as an answer's `deleted`\n   * does; a failure brings it back. Keeping it gone is the answer's to say.\n   */\n  tombstone: <E extends EntityLike>(entity: E, id: string): PendingDelete => ({\n    _tag: 'Delete',\n    ...descriptorOf(entity).ref(id),\n  }),\n\n  /**\n   * A reference to one entity, for `ConnectionChange` and anything else that\n   * names a row: `Remote.ref(Project, 'p3')`. Either kind of entity, as with\n   * `Remote.patch`.\n   */\n  ref: <E extends EntityLike>(entity: E, id: string): EntityRef<NameOf<E>, FieldsOf<E>> =>\n    descriptorOf(entity).ref(id) as EntityRef<NameOf<E>, FieldsOf<E>>,\n\n  /**\n   * Declares a Remote domain and binds it to its place in the application Model\n   * in one step; the result carries the application-facing operations. The\n   * descriptor alone is `Remote.define`, the binding alone `Remote.at`.\n   */\n  make: <\n    AppModel,\n    Store extends RemoteModel,\n    const Entities extends readonly EntityLike[],\n    const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly [],\n    const Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly [],\n  >(config: {\n    readonly model: ModelRef<AppModel, Store>\n    readonly entities: Entities\n    readonly queries?: Queries\n    readonly mutations?: Mutations\n    /**\n     * Checks each prediction against the server's answer, and records a\n     * `PredictionMismatch` in `diagnostics` for each part that disagrees:\n     * `Value`, a field a pending write showed that the answer holds otherwise;\n     * `Placement`, a list placed in an order the server's first page does not\n     * keep (each placed list is fetched too, for its page; a pending edit is\n     * not checked, since the server does not have it yet); `Gap`, a row whose\n     * answer left out fields the client showed while it was pending and the\n     * store does not otherwise hold, so they are read again and the row reads\n     * `Loading` meanwhile. Everything else behaves as without it. For\n     * development and tests.\n     */\n    readonly verifyPredictions?: boolean | undefined\n    /**\n     * How the client runs a body's primitive operators when it judges rows it\n     * holds (`Operators`): the kernel's when not given. A body calling one this\n     * table lacks is judged by the server instead, as any row the client cannot\n     * judge is.\n     */\n    readonly operators?: MemoryOperators | undefined\n    /**\n     * Who reads, as a row (`Remote.ref(User, model.me)`), or none for a\n     * visitor: whom a declared write predicts each `Derived.exists` for. The\n     * store holds one viewer's values, as it holds one principal's: a change\n     * of viewer is a change of principal, which `Data.forget`s. Without it, an\n     * exists is predicted only where a write takes it away.\n     */\n    readonly viewer?:\n      | ((model: AppModel) => Option.Option<{ readonly entity: string; readonly id: string }>)\n      | undefined\n  }): RemoteDomain<AppModel, Store, Entities, Queries, Mutations> =>\n    bindDomain(defineRemote(config), config.model, {\n      verifyPredictions: config.verifyPredictions,\n      operators: config.operators,\n      viewer: config.viewer,\n    }),\n\n  /**\n   * Declares a Remote domain without binding it: its entities, queries, and\n   * mutations, plus the submodel. For a domain reused across applications or\n   * bound in a test; `Remote.make` is the one-step form.\n   */\n  define: defineRemote,\n\n  /**\n   * Binds a Remote domain to its store's location in the application Model. The\n   * registered entity names are carried on the returned value, so `Remote.select`\n   * rejects a selection for an entity this domain never declared. `operators`\n   * is the client's table, which a pending computed assignment is predicted by\n   * (`Operators.kernel` when not given), as `Remote.make`'s is.\n   */\n  at: <\n    AppModel,\n    Store extends RemoteModel,\n    Entities extends readonly EntityLike[],\n    Queries extends readonly QueryDescriptor<any, any, any>[],\n    Mutations extends readonly MutationDescriptor<any, any, any>[],\n  >(\n    definition: RemoteDescriptor<Entities, Queries, Mutations>,\n    store: ModelRef<AppModel, Store>,\n    options: { readonly operators?: MemoryOperators | undefined } = {},\n  ): BoundRemote<AppModel, Store, EntityName<Entities[number]>> =>\n    bindRemote(definition, store, options.operators ?? Operators.kernel),\n\n  /**\n   * The resume part for this domain, for `foldkit-ssr`'s `SSR.plan({ parts })`:\n   * a server render sends what the plan's active Surfaces read from the store,\n   * each connection with its boundaries and each live cursor with it, and\n   * nothing else. `id` tells two domains in one application apart.\n   */\n  resume: resumePart,\n\n  /**\n   * A Projection node that reads a `RemoteData` value out of the store. The id\n   * is supplied by the caller, usually from a Surface's params. The assembled\n   * value is decoded against the Selection, so malformed server data surfaces\n   * as `Failed` instead of being asserted into `Value`. A present value with a\n   * stale field reads as `Refreshing`: an observer is refetching it.\n   */\n  select: <AppModel, Store extends RemoteModel, Names extends string, Value, Name extends string>(\n    bound: BoundRemote<AppModel, Store, Names>,\n    given: EntitySelection<Value, Name> & Registered<Name, Names, 'Entity'>,\n  ) => {\n    const selection = selectionOf<Value, Name>(given)\n    assertRegistered(bound, 'Entity', bound.definition.registry.entities, selection.entity)\n    const relation = relationOf(selection)\n    const relationKey = stableStringify(relation)\n    return (id: string): Projection<AppModel, RemoteData<Value>> => ({\n      Model: remoteDataSchema(selection.schema),\n      dependencies: [],\n      metadata: RemoteRequirements.of({ ...relation, id }),\n      read: (root: AppModel): RemoteData<Value> => {\n        const store = storeOf(bound, root)\n        const key = entityKey(selection.entity, id)\n        // The store-dependent half is memoized per store snapshot; `undefined`\n        // means the store lacks the value. Whether that reads as `Loading` or\n        // `Initial` depends on the in-flight marks, which change independently\n        // of the store, so it is decided outside the memo.\n        const present = memoRead<RemoteData<Value> | undefined>(\n          [store],\n          `${key}\\u0000${relationKey}`,\n          () => {\n            if (isTombstone(store, key)) return { _tag: 'NotFound' }\n            const assembled = assemble(store, key, relation)\n            if (assembled === undefined) return unavailableFailure(store, key, relation)\n            const decoded = decodeRow(selection.schema, store[key]!.values, assembled.values)\n            return Result.isFailure(decoded)\n              ? { _tag: 'Failed', error: { _tag: 'DecodeError', message: decoded.failure.message } }\n              : assembled.refreshing\n                ? { _tag: 'Refreshing', value: decoded.success }\n                : { _tag: 'Ready', value: decoded.success }\n          },\n        )\n        // Decided outside the memo, as loading is: a failure can arrive\n        // without the store changing.\n        const remote = bound.store.get(root)\n        const failure = failureOf(remote, selection.entity, id, relation)\n        if (present !== undefined) {\n          // A value on screen whose refresh failed stays on screen, with the\n          // error, which `RemoteData.render` draws as stale.\n          return failure !== undefined &&\n            (present._tag === 'Ready' || present._tag === 'Refreshing')\n            ? { _tag: 'Failed', error: failure, previous: present.value }\n            : present\n        }\n        if (isLoadingThrough(remote, selection.entity, id, relation)) return { _tag: 'Loading' }\n        if (failure !== undefined) return { _tag: 'Failed', error: failure }\n        // A preview of something the server has not seen: what the overlay\n        // leaves out will never arrive, so waiting would be `Initial` for good.\n        if (onlyOverlaid(remote, selection.entity, id)) {\n          const lacking = missingFields(store, key, relation.fields)\n          return {\n            _tag: 'Failed',\n            error: {\n              _tag: 'Overlaid',\n              message: `${selection.entity} ${id} is shown only by an overlay, which does not hold ${\n                lacking.length === 0 ? 'what its relations select' : lacking.join(', ')\n              }; the server has not seen it, so nothing will fetch them.`,\n            },\n          }\n        }\n        // Nothing is fetching this: no active Surface observes it, which is\n        // usually a wiring mistake.\n        return { _tag: 'Initial' }\n      },\n    })\n  },\n\n  /**\n   * When what a projection shows was last received, and whether it is stale\n   * or loading. Pure, so a view can show \"updated 5s ago\" without I/O.\n   *\n   * `updatedAt` is the newest server write among what is shown, as the\n   * store dates it; `undefined` when nothing shown was received (nothing\n   * loaded, or only an optimistic preview). `stale` is any shown field or\n   * connection marked stale; `loading` is any of them in flight. Optimistic\n   * previews do not date: showing only one reads `updatedAt: undefined`.\n   */\n  meta: <AppModel, Store extends RemoteModel, Value>(\n    bound: BoundRemote<AppModel, Store>,\n    model: AppModel,\n    projection: Projection<AppModel, Value>,\n  ): ReadMeta => metaOf(bound.store.get(model), askedOf(projection), bound.operators),\n\n  /**\n   * The pure plan for a projection against a Model: the requirements its\n   * remote store does not satisfy, under `options` (freshness, force). A\n   * Surface's projection is `surface.projection(params)`.\n   */\n  plan: <AppModel, Store extends RemoteModel, Value>(\n    bound: BoundRemote<AppModel, Store>,\n    model: AppModel,\n    projection: Projection<AppModel, Value>,\n    options?: PlanOptions,\n  ): ReadonlyArray<Requirement> =>\n    planAsked(bound.store.get(model), askedOf(projection), options ?? {}, bound.operators)\n      .requirements,\n\n  /**\n   * The queries a projection needs run before its connections read: those the\n   * Model does not hold, or holds stale (every one under `force`).\n   */\n  planQueries: <AppModel, Store extends RemoteModel, Value>(\n    bound: BoundRemote<AppModel, Store>,\n    model: AppModel,\n    projection: Projection<AppModel, Value>,\n    options?: PlanOptions,\n  ): ReadonlyArray<QueryRef<string, unknown>> =>\n    planAsked(\n      bound.store.get(model),\n      askedOf(projection),\n      options ?? {},\n      bound.operators,\n    ).queries.flatMap(query => (query.ref === undefined ? [] : [query.ref])),\n\n  /**\n   * The store reads see: the base store under the pending optimistic layers.\n   * One store is shared by every read and plan of a Model whose remote state\n   * has not changed.\n   */\n  storeOf: <AppModel, Store extends RemoteModel>(\n    bound: BoundRemote<AppModel, Store>,\n    model: AppModel,\n  ): EntityStore => storeOf(bound, model),\n\n  /**\n   * The projection read against the server-derived store alone: the same\n   * requirements, planned the same way, with the pending optimistic layers and\n   * connection overlays left off. See the bound `Remote.confirmed`.\n   */\n  confirmed: <AppModel, Store extends RemoteModel, P extends Projection<AppModel, any>>(\n    bound: BoundRemote<AppModel, Store>,\n    projection: P,\n  ): P => confirmed(bound, projection),\n\n  /**\n   * Executes the plan against the `RemoteClient` and returns a new store. Used\n   * for SSR route prefetch, hover prefetch, and tests. Never called during render.\n   * `policy` decides what a present field means (default cache-first); `now`\n   * is the clock it reads, so the planner itself stays pure and time-injected.\n   */\n  prefetch: Effect.fn('Remote.prefetch')(function* <AppModel, Store extends RemoteModel, Value>(\n    bound: BoundRemote<AppModel, Store>,\n    model: AppModel,\n    projection: Projection<AppModel, Value>,\n    options: ObserveOptions = {},\n  ) {\n    const store = storeOf(bound, model)\n    const { policy = RemotePolicy.cacheFirst, now = wallClock } = options\n    const at = now()\n    const missing = plan(store, requirementsOf(projection), RemotePolicy.toPlan(policy, at))\n    if (missing.length === 0) return store\n    yield* Effect.annotateCurrentSpan('requirementCount', missing.length)\n    const client = yield* RemoteClient\n    const result = yield* client.read({ version: REMOTE_PROTOCOL_VERSION, requests: missing })\n    return writeRead(store, missing, result, at)\n  }),\n\n  /**\n   * Marks what a read requires as due again: a projection, a Surface without\n   * params, one entry of the active record, or the whole record, each entry\n   * resolved for this Model as `subscriptions` resolves it. Called from\n   * `update`: every selected field the store holds reads `Refreshing`, and\n   * every loaded query connection is invalidated. Nothing is fetched here.\n   * The read entries `Data.subscriptions` derives refetch it, because a stale\n   * field or connection is planned again under every policy, so a refresh never\n   * sends a request beside the entry already observing the same data.\n   *\n   * A refreshed connection's page replaces its pages, so items the server removed\n   * or reordered follow it; pages loaded past the first are dropped and paged\n   * again with `next`/`previous`. The read entries restart, so a read or query\n   * sent before the refresh is not applied after it.\n   *\n   * It is also how a failed read is retried: nothing that failed is asked\n   * again on its own, so its read stays `Failed` until this asks. A failed\n   * read with nothing to show reads `Loading` from here, and `Failed` again if\n   * the retry fails. `{ failed: true }` asks again only what failed, which is\n   * what a \"Try again\" means: what loaded keeps its value and its pages.\n   *\n   * The projection must be observed, which it is while it is on screen. Live\n   * subscriptions are left as they are. For data nothing observes (SSR, tests),\n   * use `Remote.prefetch` with `RemotePolicy.networkOnly`. Refreshing what is\n   * already being refreshed returns the same Model.\n   */\n  refresh: <AppModel, Store extends RemoteModel>(\n    bound: BoundRemote<AppModel, Store>,\n    model: AppModel,\n    target: RefreshTarget<AppModel>,\n    options: RefreshOptions = {},\n  ): AppModel => {\n    const remote = bound.store.get(model)\n    if (isQueryRef(target)) {\n      assertRegistered(bound, 'Query', bound.definition.registry.queries, target.query)\n      // Only a list the Model holds, or whose query failed, has anything to ask again.\n      const failed = Object.hasOwn(remote.failures.connections, target.identity)\n      const due =\n        failed || (options.failed !== true && remote.connections[target.identity] !== undefined)\n      return due\n        ? bound.store.set(model, invalidateConnections(remote, [target.identity]) as Store)\n        : model\n    }\n    const asked = askedUnion(targetProjections(bound.contract, target, model))\n    const merged = Requirement.mergeConnections(\n      asked.connections,\n    ) as ReadonlyArray<QueryRequirement>\n    // A loaded connection's current items are marked with the entities; its page\n    // is re-run by the read entry, and new items are planned when it lands.\n    const items = merged.flatMap(connection => {\n      const known = remote.connections[connection.identity]\n      return known === undefined\n        ? []\n        : itemsOf(\n            visibleItems(\n              known,\n              connection.identity,\n              remote.optimistic.overlays,\n              goneIn(remote.entities, remote.optimistic),\n            ).map(edge => edge.ref),\n            connection.select,\n          )\n    })\n    const asking = [...asked.requirements, ...items]\n    // `failed` asks again only what failed: each entity read whose own or\n    // related fields failed, and each list whose query did. The rest, a\n    // list's later pages included, stays as it is.\n    const connections =\n      options.failed === true\n        ? merged.filter(connection => connection.identity in remote.failures.connections)\n        : merged\n    const requirements = plan(\n      visibleStoreOf(remote.entities, remote.optimistic, bound.operators),\n      options.failed === true\n        ? asking.filter(\n            requirement =>\n              failureOf(remote, requirement.entity, requirement.id, requirement) !== undefined,\n          )\n        : asking,\n      { force: true },\n    )\n\n    // A connection the Model never loaded is already a query to run: there is\n    // nothing to invalidate and nothing to restart, so it takes no generation\n    // either — unless its query failed, which is exactly what a refresh retries.\n    const invalidated = connections\n      .filter(\n        connection =>\n          remote.connections[connection.identity] !== undefined ||\n          connection.identity in remote.failures.connections,\n      )\n      .map(connection => connection.identity)\n    const marks: RemoteMessage[] = [\n      ...(requirements.length === 0\n        ? []\n        : [{ _tag: 'RefreshStarted' as const, requests: requirements }]),\n      ...invalidated.map(connection => ({\n        _tag: 'ConnectionInvalidated' as const,\n        connection,\n      })),\n    ]\n    const marked = marks.reduce(updateRemote, remote)\n    // Fields already stale may be in a read that began before this refresh (a\n    // refreshing policy marks what it refetches); unless no read has begun since\n    // the last refresh, that read is restarted too.\n    const inFlight = requirements.some(requirement =>\n      requirement.fields.some(\n        field =>\n          remote.entities[entityKey(requirement.entity, requirement.id)]?.stale.has(field) ===\n            true && refreshIsInFlight(remote.refresh, requirement, field),\n      ),\n    )\n    // Marking what is already marked changes nothing, so the Model keeps its identity.\n    if (marked === remote && !inFlight) return model\n    const refresh = withRefreshRequested(marked.refresh, requirements, invalidated)\n    return bound.store.set(model, { ...marked, refresh } as Store)\n  },\n\n  /**\n   * Forgets everything the server told this Model: values, tombstones,\n   * unavailable fields, connections, live cursors, failures. What is known is\n   * known for a principal, and this is the one boundary for a login, a logout\n   * or a switch of organization: called from `update`, it performs no I/O, and\n   * every active Surface's read and live entries restart, so the screen asks\n   * again as whoever the client now is. A read or stream begun before is\n   * interrupted rather than landing after. A mutation in flight is treated as\n   * applied: its answer writes nothing here.\n   */\n  forget: <AppModel, Store extends RemoteModel>(\n    bound: BoundRemote<AppModel, Store>,\n    model: AppModel,\n  ): AppModel => bound.store.set(model, forgetRemote(bound.store.get(model)) as Store),\n\n  /**\n   * Writes a read result into the store, recording each field's applied window.\n   * `requests` are the planned requirements the result answers.\n   */\n  writeRead,\n\n  /**\n   * Adapts an Effect RPC client for `RemoteRpc` to `RemoteClient`, so an\n   * application provides the transport's RPC layer instead of writing the\n   * `LiveChange`-to-`LiveEvent` mapping by hand. The client `RpcClient.make`\n   * builds is accepted as it is: when its transport fails (`RpcClientError`),\n   * the call fails with its own Remote error, which the application shows and\n   * retries like any failed read, query, mutation or live stream.\n   */\n  /**\n   * Remote's client over any way of sending one JSON request and receiving its\n   * answer, for `clientLayer`: a worker, a server in the page. `RemoteServer.answer`\n   * is the other end.\n   */\n  json: jsonClient,\n\n  /**\n   * Remote's client over HTTP, for `clientLayer`: each call a `POST` of the JSON\n   * request to `url`. `headers` is read per request (a session token, say).\n   */\n  http: httpClient,\n\n  /**\n   * Remote's client over HTTP with live, for `clientLayer`: reads, queries,\n   * and mutations as `http` sends them, live requirements as one `POST`\n   * answered with a `text/event-stream` of changes.\n   * `foldkit-remote-server/fetch` is the other end.\n   */\n  httpWithLive: httpWithLiveClient,\n\n  clientLayer: <R = never>(\n    client: RemoteRpcClient<R, RpcClientError.RpcClientError | RemoteUnreachable>,\n    options: CoalesceOptions = {},\n  ): Layer.Layer<RemoteClient, never, R> =>\n    coalescedLayer(\n      Layer.effect(\n        RemoteClient,\n        Effect.gen(function* () {\n          // What the RPC client needs (a database under in-process handlers,\n          // nothing under a transport) is supplied once, when the layer is built.\n          const context = yield* Effect.context<R>()\n          return {\n            read: batch =>\n              client.FoldkitRemoteRead(batch).pipe(\n                Effect.catchTag(['RpcClientError', 'Unreachable'], error =>\n                  Effect.fail(new RemoteReadError({ message: error.message })),\n                ),\n                Effect.provideContext(context),\n              ),\n            query: request =>\n              client.FoldkitRemoteQuery(request).pipe(\n                Effect.catchTag(['RpcClientError', 'Unreachable'], error =>\n                  Effect.fail(new RemoteQueryError({ message: error.message })),\n                ),\n                Effect.provideContext(context),\n              ),\n            mutate: request =>\n              client.FoldkitRemoteMutate(request).pipe(\n                // The transport failed: the request may not have reached the server.\n                Effect.catchTag('RpcClientError', error =>\n                  Effect.fail(new RemoteUnreachable({ message: error.message })),\n                ),\n                Effect.provideContext(context),\n              ),\n            live: ({ requirements, queries, after }) =>\n              client\n                .FoldkitRemoteLive({\n                  version: REMOTE_PROTOCOL_VERSION,\n                  requirements,\n                  ...(queries.length === 0 ? {} : { queries }),\n                  after,\n                })\n                .pipe(\n                  Stream.catchTag(['RpcClientError', 'Unreachable'], error =>\n                    Stream.fail(new RemoteLiveError({ message: error.message })),\n                  ),\n                  Stream.map(liveEventOf),\n                  Stream.provideContext(context),\n                ),\n          }\n        }),\n      ),\n      options,\n    ),\n\n  /**\n   * Wraps a `RemoteClient` layer so its reads coalesce: requirements issued\n   * together become one batch, and a requirement already in flight is joined.\n   * `Remote.clientLayer` applies this; use it on a hand-written client.\n   */\n  coalesced: coalescedLayer,\n\n  /**\n   * A Foldkit Subscription entry that keeps the cache to what the active\n   * Surfaces reach. `projections` are the ones the application observes (the\n   * same it passes to `Remote.observe`), `connections` the query connections\n   * it shows; anything else is collected once the roots have been stable for\n   * `grace`, so a route transition that comes straight back does not thrash.\n   */\n  retain: <AppModel, Message = RemoteMessage>(\n    projections: ReadonlyArray<Projection<AppModel, unknown>>,\n    toMessage: (message: RemoteMessage) => Message = identityMessage as never,\n    options: RetainOptions = {},\n  ): EntryWithoutKeepAlive<AppModel, Message, RetentionRoots, never> => {\n    const roots = rootsOf(projections, options)\n    return {\n      dependenciesSchema: retentionRootsSchema,\n      modelToDependencies: () => roots,\n      dependenciesToStream: current =>\n        Stream.fromEffect(\n          Effect.succeed(toMessage({ _tag: 'RetentionChanged', roots: current })).pipe(\n            Effect.delay(options.grace ?? 0),\n          ),\n        ),\n    }\n  },\n\n  /**\n   * Runs a `Query` through `RemoteClient`, encoding its input from the ref.\n   * Pair the result with `Remote.queryMessage` to merge the page into the Model.\n   * With `select`, the server also returns the selected fields of the page's\n   * items, so one response populates both the connection and the store.\n   */\n  query: Effect.fn('Remote.query')(function* <Name extends string, Input>(\n    ref: QueryRef<Name, Input>,\n    select?: RelationRequirement | undefined,\n  ) {\n    const client = yield* RemoteClient\n    const input = yield* Schema.encodeUnknownEffect(ref.Input)(ref.input).pipe(\n      Effect.catchTag('SchemaError', error =>\n        Effect.fail(new RemoteQueryError({ message: error.message })),\n      ),\n    )\n    return yield* client.query({\n      query: ref.query,\n      input,\n      window: ref.window,\n      ...(select === undefined ? {} : { select }),\n    })\n  }),\n\n  /** The `RemoteMessage` that merges a query page into its connection. */\n  queryMessage: <Name extends string, Input>(\n    ref: QueryRef<Name, Input>,\n    result: Schema.Schema.Type<typeof QueryResult>,\n    select?: RelationRequirement | undefined,\n    now?: number | undefined,\n  ): RemoteMessage => pageMessage(ref.identity, result, false, ref.window, select, now),\n\n  /** A pure, serializable view of the whole cache. */\n  inspect: inspectRemote,\n\n  /** A pure, serializable view of one entity, or `undefined` if unknown. */\n  inspectEntity,\n\n  /**\n   * Runs a mutation through `RemoteClient`, decoding its typed Output and\n   * returning the result's normalized patches so the caller can reconcile them\n   * through `updateRemote`'s `MutationSucceeded` (or `Remote.mutateInto`).\n   */\n  mutate: mutateRemote,\n\n  /**\n   * Reads the clock where the reader acts, for `Data.mutate`'s `now`: a\n   * Command that yields `toMessage(now)`, the time in milliseconds since the\n   * epoch. It reads Effect's `Clock`, so a test pins it, and `Trace.run`\n   * runs it at the trace's time. Chirp's compose box answers a submit with\n   * `Remote.now(now => Message.ClockedPost({ post, now }))`, and\n   * `ClockedPost` starts the write.\n   */\n  now: <M>(\n    toMessage: (now: number) => M,\n  ): { readonly name: 'Remote.now'; readonly effect: Effect.Effect<M> } => ({\n    name: 'Remote.now',\n    effect: Effect.map(Clock.currentTimeMillis, toMessage),\n  }),\n\n  /**\n   * Runs a mutation and reconciles its patches into a `RemoteModel` in one step,\n   * returning the new model alongside the typed Output. The model-level form of\n   * `MutationStarted` → `RemoteClient.mutate` → `MutationSucceeded`; in an\n   * application the three are `update` (with `optimistic`), a Command, and the\n   * Message the Command returns, so the optimistic operations show meanwhile.\n   */\n  mutateInto: Effect.fn('Remote.mutateInto')(function* <\n    Name extends string,\n    Input,\n    Output,\n    AppModel,\n    Store extends RemoteModel,\n  >(\n    bound: BoundRemote<AppModel, Store>,\n    model: AppModel,\n    mutation: MutationDescriptor<Name, Input, Output>,\n    input: Input,\n    requestId: string,\n    options: MutateOptions = {},\n  ) {\n    const started = updateRemote(bound.store.get(model), {\n      _tag: 'MutationStarted',\n      requestId,\n      ...(options.optimistic === undefined ? {} : { optimistic: options.optimistic }),\n    })\n    const outcome = yield* mutateRemote(mutation, input, requestId, { now: options.now })\n    const settled = updateRemote(started, {\n      _tag: 'MutationSucceeded',\n      requestId,\n      entities: outcome.entities,\n      connections: outcome.connections,\n      deleted: outcome.deleted,\n      now: yield* Clock.currentTimeMillis,\n    })\n    return {\n      output: outcome.output,\n      model: bound.store.set(model, settled as Store),\n    }\n  }),\n\n  /**\n   * A Foldkit Subscription entry that plans a Surface's missing fields from the\n   * Model and fetches them through `RemoteClient`, emitting a `RemoteMessage`\n   * per outcome. Wrap it in an application Message (`toMessage`) and reduce it\n   * with the domain's `update`. Under a refreshing `policy` the entry first\n   * emits `RefreshStarted`, so the fields being refetched read as `Refreshing`\n   * while the request is pending.\n   */\n  observe: <\n    AppModel,\n    Store extends RemoteModel,\n    Names extends string,\n    Model,\n    SurfaceMessage,\n    Params,\n    Message = RemoteMessage,\n  >(\n    bound: BoundRemote<AppModel, Store, Names>,\n    surface: Surface<AppModel, Model, SurfaceMessage, Params>,\n    params: Params,\n    toMessage: (message: RemoteMessage) => Message = identityMessage as never,\n    options: ObserveOptions = {},\n  ): EntryWithoutKeepAlive<AppModel, Message, ReadDependencies, RemoteClient> =>\n    observeEntry(bound, () => askedOf(surface.projection(params)), toMessage, options),\n\n  /**\n   * A Foldkit Subscription entry that consumes the live stream for a Surface's\n   * requirements, emitting a `LiveReceived` per event and a `ReadFailed`\n   * carrying its `stream` when the stream breaks (including\n   * `ResumeUnavailable`). That records a gap on the stream rather than a failed\n   * read, since nothing was being read, and restarts the entry after a\n   * backoff; the restart refetches what it covers. The resume cursor is read\n   * from `RemoteModel.live`, so the application tracks no cursor of its own.\n   */\n  live: <\n    AppModel,\n    Store extends RemoteModel,\n    Names extends string,\n    Model,\n    SurfaceMessage,\n    Params,\n    Message = RemoteMessage,\n  >(\n    bound: BoundRemote<AppModel, Store, Names>,\n    surface: Surface<AppModel, Model, SurfaceMessage, Params>,\n    params: Params,\n    toMessage: (message: RemoteMessage) => Message = identityMessage as never,\n    options: LiveOptions = {},\n  ): EntryWithoutKeepAlive<AppModel, Message, LiveDependencies, RemoteClient> =>\n    liveEntry(\n      bound,\n      () => {\n        const projection = surface.projection(params)\n        // Every row the Surface reads; a list only where it is read live.\n        return { ...liveAskOf(askedOf(projection)), requirements: requirementsOf(projection) }\n      },\n      toMessage,\n      options,\n    ),\n}\n\n// A domain's Subscription entries are unbranded so an application can spread\n// them into its own `Subscription.make`; wiring hands them over as a branded record.\n/**\n * Each entry with its Messages as the parent's and its dependencies as they\n * were. The Model is the parent's already, and `Subscription.lift` would wrap\n * every entry's dependencies in `maybeDependencies` (since Foldkit 0.166).\n */\nconst messagesAs = <AppModel, ParentMessage>(\n  entries: Subscription.Subscriptions<AppModel, RemoteMessage, RemoteClient>,\n  toParentMessage: (message: RemoteMessage) => ParentMessage,\n) =>\n  Record.map(entries, entry => ({\n    ...entry,\n    dependenciesToStream: (dependencies: unknown, read: () => unknown) =>\n      Stream.map(entry.dependenciesToStream(dependencies, read), toParentMessage),\n  }))\n\ntype Answer = Extract<RemoteMessage, { readonly _tag: 'MutationSucceeded' }>\n\n/**\n * An answer with what it read folded into its patches, one per row, so a list\n * is placed by every value the answer wrote, a derived field it read included.\n */\nconst withAnswerRead = (answer: Answer): Answer => {\n  if (answer.read === undefined) return answer\n  const rows = new Map<string, NormalizedPatch>()\n  for (const patch of [...answer.entities, ...answer.read.result.entities]) {\n    const key = entityKey(patch.entity, patch.id)\n    const held = rows.get(key)\n    rows.set(\n      key,\n      held === undefined ? patch : { ...held, values: { ...held.values, ...patch.values } },\n    )\n  }\n  return { ...answer, entities: [...rows.values()] }\n}\n\nconst brandEntries = <AppModel>(\n  entries: Readonly<Record<string, RemoteEntry<AppModel, any>>>,\n): Subscription.Subscriptions<AppModel, RemoteMessage, RemoteClient> =>\n  Subscription.make<AppModel, RemoteMessage, RemoteClient>()(() => entries)\n\n/** The bound domain: the descriptor, the binding, and the operations over them. */\nconst bindDomain = <\n  AppModel,\n  Store extends RemoteModel,\n  Entities extends readonly EntityLike[],\n  Queries extends readonly QueryDescriptor<any, any, any>[],\n  Mutations extends readonly MutationDescriptor<any, any, any>[],\n>(\n  definition: RemoteDescriptor<Entities, Queries, Mutations>,\n  ref: ModelRef<AppModel, Store>,\n  options: {\n    readonly verifyPredictions?: boolean | undefined\n    readonly operators?: MemoryOperators | undefined\n    readonly viewer?:\n      | ((model: AppModel) => Option.Option<{ readonly entity: string; readonly id: string }>)\n      | undefined\n  } = {},\n): RemoteDomain<AppModel, Store, Entities, Queries, Mutations> => {\n  const operators = options.operators ?? Operators.kernel\n  const bound = bindRemote(definition, ref, operators)\n  const store = bound.store\n  const viewerOf = options.viewer ?? (() => Option.none())\n  // What a body's `Expr.viewer` reads here. The client has no reading of the\n  // time a server judges a list at, so a body over `Expr.now` is the server's.\n  const contextOf = (model: AppModel): ExprContext => ({\n    viewer: viewerOf(model),\n    now: Option.none(),\n  })\n  // Every reader any `subscriptions` call names, and every connection one keeps:\n  // retention is the domain's, so each call's retain entry roots them all, and\n  // one call with its own policy does not collect what another call reads.\n  const readers = new Map<\n    ActiveEntry<AppModel>,\n    (model: AppModel) => ReadonlyArray<NamedProjection<AppModel>>\n  >()\n  const keptConnections = new Set<string>()\n  /**\n   * What to do with a row a live event says was inserted into a connection.\n   *\n   * Resolved here rather than in the pure reducer because this is the only\n   * place with both the Model and the registry, and two separate things needed\n   * one or the other.\n   *\n   * **The declared policy reaches the decision.** `Query.connection(E, { live })`\n   * has always been typed, documented, carried on the descriptor and encoded in\n   * the Message schema — and nothing ever put it on a Message, so every live\n   * insert took the default whatever an application asked for. It does now.\n   *\n   * **A row the client can judge does not need a policy.** The policy exists\n   * because nothing could tell whether an inserted row belonged to the query.\n   * Where the body says it does not, `ignore` is not a guess. Where the body\n   * says it does, or the client cannot tell — a row it never fetched, or holds\n   * without a field the body reads — the declared policy is the answer, exactly\n   * as it was meant to be.\n   *\n   * Only membership is decided here. *Where* a row sorts needs text collation,\n   * which is the backend's, so the position the event carries stands.\n   */\n  const livePolicyFor = (model: AppModel, event: LiveEvent): LivePolicy | undefined => {\n    if (event._tag !== 'ConnectionInsert') return undefined\n    // An identity is always `name`, the separator, and the encoded input — it\n    // is minted in exactly one place — so the separator is always present.\n    const identity = event.connection\n    const descriptor = definition.registry.queries.get(\n      identity.slice(0, identity.indexOf(IDENTITY_SEPARATOR)),\n    )\n    const declared = (descriptor?.Result as Partial<ConnectionSpec> | undefined)?.live\n    if (descriptor?.body === undefined) return declared\n    const encoded = JSON.parse(identity.slice(identity.indexOf(IDENTITY_SEPARATOR) + 1)) as Record<\n      string,\n      unknown\n    >\n    const decided = belongsEncoded(\n      storeOf(bound, model),\n      descriptor,\n      encoded,\n      entityKey(event.edge.ref.entity, event.edge.ref.id),\n      operators,\n      contextOf(model),\n    )\n    return decided === 'no' ? { prepend: 'ignore', append: 'ignore' } : declared\n  }\n\n  // An application-union case has the runtime shape of the `RemoteMessage` it names.\n  const reduce = (model: AppModel, message: RemoteMessage | RemoteMessageInput): AppModel => {\n    const live =\n      message._tag === 'LiveReceived'\n        ? (message as Extract<RemoteMessage, { _tag: 'LiveReceived' }>)\n        : undefined\n    // A caller that said what it wanted keeps it; `updateRemote` on its own is\n    // unchanged, so the pure reducer stays testable without a registry.\n    const resolved =\n      live === undefined || live.policy !== undefined\n        ? message\n        : { ...live, policy: livePolicyFor(model, live.event) }\n    const remote = store.get(model)\n    const reduced = updateRemote(remote, resolved as RemoteMessage)\n    const answer =\n      message._tag === 'MutationSucceeded'\n        ? (message as Extract<RemoteMessage, { _tag: 'MutationSucceeded' }>)\n        : undefined\n    // A repeated answer finds every value it carries already held, so it\n    // changes nothing and invalidates nothing.\n    const next =\n      answer === undefined\n        ? placedNews(reduced, newsOf(message), remote.entities, contextOf(model))\n        : impactOf(\n            reduced,\n            remote.mutations.applied.has(answer.requestId) ? answer : withAnswerRead(answer),\n            remote.entities,\n            contextOf(model),\n          )\n    const checked =\n      answer === undefined || options.verifyPredictions !== true\n        ? next\n        : withAnswerChecked(model, remote, next, answer)\n    return checked === remote ? model : store.set(model, checked as Store)\n  }\n\n  /**\n   * `after` with each part of the request's prediction the answer disagreed\n   * with (`verifyPredictions`): a field it showed that the answer holds\n   * otherwise (`Value`), and a row it left without fields the client showed\n   * (`Gap`).\n   */\n  const withAnswerChecked = (\n    model: AppModel,\n    before: RemoteModel,\n    after: RemoteModel,\n    answer: Extract<RemoteMessage, { _tag: 'MutationSucceeded' }>,\n  ): RemoteModel => {\n    const { requestId } = answer\n    // A repeated answer writes nothing, so it leaves nothing out.\n    if (before.mutations.applied.has(requestId)) return after\n    const mutation = Option.map(\n      Option.fromUndefinedOr(before.mutations.writes.get(requestId)),\n      write => write.mutation,\n    )\n    const settled = store.set(model, after as Store)\n    const projections = [...readers.values()].flatMap(resolvedAt =>\n      resolvedAt(settled).map(({ projection }) => projection),\n    )\n    const found = [\n      ...valueMismatches(requestId, mutation, before, after, answer),\n      ...answerGaps(\n        requestId,\n        mutation,\n        before.optimistic,\n        after.optimistic,\n        visibleStoreOf(after.entities, after.optimistic, operators),\n        planAsked(unverified(after), askedUnion(projections), {}, operators).requirements,\n      ),\n    ]\n    return found.length === 0\n      ? after\n      : { ...after, diagnostics: withDiagnostics(after.diagnostics, found) }\n  }\n\n  /**\n   * `remote` with each list placed only to be checked (`placed`) read as it\n   * would be without the check: such a list is fetched for its page, and a\n   * stale list plans no reads of its rows, so a gap in them would go unseen.\n   */\n  const unverified = (remote: RemoteModel): RemoteModel => {\n    const checked = Object.keys(remote.placed).filter(\n      identity => remote.connections[identity] !== undefined,\n    )\n    if (checked.length === 0) return remote\n    const connections = { ...remote.connections }\n    for (const identity of checked)\n      connections[identity] = { ...connections[identity]!, stale: false }\n    return { ...remote, connections }\n  }\n\n  /**\n   * Each field the request's layer showed that its answer carries another\n   * value of. A field the answer does not carry is the `Gap`'s; one a request\n   * still pending also patches shows that request's value before and after,\n   * so it is not judged.\n   */\n  const valueMismatches = (\n    requestId: string,\n    mutation: Option.Option<string>,\n    before: RemoteModel,\n    after: RemoteModel,\n    answer: Extract<RemoteMessage, { _tag: 'MutationSucceeded' }>,\n  ): ReadonlyArray<PredictionMismatch> => {\n    const layer = before.optimistic.layers.find(each => each.id === requestId)\n    if (layer === undefined) return []\n    const shown = visibleStoreOf(before.entities, before.optimistic, operators)\n    const answered = new Map<string, Readonly<Record<string, unknown>>>()\n    for (const row of [...answer.entities, ...(answer.read?.result.entities ?? [])]) {\n      const key = entityKey(row.entity, row.id)\n      answered.set(key, { ...answered.get(key), ...row.values })\n    }\n    const stillPatched = new Set(\n      after.optimistic.layers.flatMap(each =>\n        each.patches.flatMap(patch =>\n          patchedFields(patch).map(field => `${entityKey(patch.entity, patch.id)}.${field}`),\n        ),\n      ),\n    )\n    return layer.patches.flatMap(patch => {\n      const key = entityKey(patch.entity, patch.id)\n      const values = answered.get(key)\n      const entry = shown[key]\n      if (values === undefined || entry === undefined || entry.tombstone) return []\n      return patchedFields(patch).flatMap(field =>\n        stillPatched.has(`${key}.${field}`) ||\n        !entry.present.has(field) ||\n        !Object.hasOwn(values, field) ||\n        sameData(entry.values[field], values[field])\n          ? []\n          : [\n              predictionMismatch(\n                PredictionPart.Value({\n                  requestId,\n                  mutation,\n                  entity: patch.entity,\n                  id: patch.id,\n                  field,\n                  shown: entry.values[field],\n                  answered: values[field],\n                }),\n              ),\n            ],\n      )\n    })\n  }\n\n  /** The registered query a connection identity names, and its encoded input. */\n  const queryOf = (\n    identity: string,\n  ): Option.Option<Pick<HeldConnection, 'descriptor' | 'encoded' | 'filtered'>> => {\n    const separator = identity.indexOf(IDENTITY_SEPARATOR)\n    const descriptor = definition.registry.queries.get(identity.slice(0, separator))\n    if (descriptor === undefined) return Option.none()\n    const encoded = JSON.parse(identity.slice(separator + 1)) as Record<string, unknown>\n    const over = descriptor.body?.entity.name\n    const filtered = (over === undefined ? undefined : definition.registry.filtered.get(over)) ?? []\n    return Option.some({ descriptor, encoded, filtered })\n  }\n\n  /**\n   * `pages` with each change to a row they hold placed, judged against\n   * `store`: a row that moved goes where the body's order puts it, and one\n   * that stopped matching leaves. A row a pending write creates joins where\n   * the body puts it, since the write holds all it is. Another row a change\n   * brings in is not added, since what the list selects of it may not be\n   * loaded, and a change the client cannot place leaves the row where it is.\n   */\n  const placedHeld = (\n    identity: string,\n    pages: Connection,\n    changes: ReadonlyArray<EntityChange>,\n    store: EntityStore,\n    // For pending placement, the viewer its operations were predicted for; none\n    // when no operation named one, and a body over the context is the server's.\n    context?: ExprContext,\n  ): Connection => {\n    const query = queryOf(identity)\n    if (Option.isNone(query)) return pages\n    // Built once: each change is of a row of its own, judged against the store\n    // as every change left it, so what the list held before them all is enough.\n    const holds = new Set(items(pages).map(edge => entityKey(edge.ref.entity, edge.ref.id)))\n    let placed = pages\n    for (const change of changes) {\n      const created = EntityChange.match(change, {\n        Changed: ({ created }) => created,\n        Deleted: () => false,\n      })\n      if (!holds.has(entityKey(change.entity, change.id)) && !created) continue\n      placed = Impact.$match(\n        impactOn({ ...query.value, connection: placed, holds }, store, change, operators, context),\n        {\n          Kept: () => placed,\n          Placed: ({ connection }) => connection,\n          Invalidated: () => placed,\n        },\n      )\n    }\n    return placed\n  }\n\n  /**\n   * What a list body's context reads while pending layers are placed: the\n   * viewer the newest operation was predicted for. The viewer is the\n   * reader's, so every operation since the last `forget` names the same one.\n   */\n  const layersContext = (layers: ReadonlyArray<EntityLayer>): ExprContext | undefined => {\n    const viewer = [...layers].reverse().find(layer => Option.isSome(layer.viewer))?.viewer\n    return viewer === undefined ? undefined : { viewer, now: Option.none() }\n  }\n\n  /**\n   * A loaded list with the pending layers placed in its pages, so a row a\n   * pending edit moves, or takes out of the list, shows where its answer\n   * will be placed until the edit settles.\n   */\n  const pendingPlaced = (remote: RemoteModel, identity: string, pages: Connection): Connection => {\n    const { layers } = remote.optimistic\n    if (layers.length === 0) return pages\n    return memoRead([pages, layers, remote.entities], `placed:${identity}`, () =>\n      placedHeld(\n        identity,\n        pages,\n        changesOf(\n          { entities: resolvedPatches(remote.entities, remote.optimistic, operators) },\n          remote.entities,\n        ),\n        visibleStoreOf(remote.entities, remote.optimistic, operators),\n        layersContext(layers),\n      ),\n    )\n  }\n\n  /**\n   * The edges a loaded list shows: its pages with pending edits placed, and\n   * each row an insert overlay shows (a pending create, a confirmed or a live\n   * insert) where the body's order puts it, or left out when it sorts past\n   * what is loaded. An overlay says a row is in the list; in a list the\n   * client can place, the order says where. A row it cannot place stays at\n   * the end its overlay names.\n   */\n  const shownEdges = (\n    remote: RemoteModel,\n    identity: string,\n    connection: Connection,\n  ): ReadonlyArray<Edge> => {\n    const pages = pendingPlaced(remote, identity, connection)\n    const inserts = remote.optimistic.overlays.some(\n      overlay => overlay.connection === identity && overlay.position !== 'remove',\n    )\n    const shown = inserts\n      ? insertsPlaced(remote, identity, pages)\n      : { pages, overlays: remote.optimistic.overlays }\n    return visibleItems(\n      shown.pages,\n      identity,\n      shown.overlays,\n      goneIn(remote.entities, remote.optimistic),\n    )\n  }\n\n  const insertsPlaced = (\n    remote: RemoteModel,\n    identity: string,\n    pages: Connection,\n  ): { readonly pages: Connection; readonly overlays: ReadonlyArray<ConnectionOverlay> } => {\n    const { overlays } = remote.optimistic\n    const store = visibleStoreOf(remote.entities, remote.optimistic, operators)\n    return memoRead([pages, overlays, store], `inserted:${identity}`, () => {\n      const query = queryOf(identity)\n      const body = Option.isSome(query) ? query.value.descriptor.body : undefined\n      if (Option.isNone(query) || body === undefined) return { pages, overlays }\n      // A row a later remove hides is placed too: `visibleItems` hides it\n      // wherever it is.\n      const inserted = new Map<string, Edge>()\n      for (const overlay of overlays) {\n        if (overlay.connection !== identity || overlay.position === 'remove') continue\n        for (const edge of overlay.edges) inserted.set(edge.key, edge)\n      }\n      const held = new Set(items(pages).map(edge => edge.key))\n      let placed = pages\n      const outside: Array<Edge> = []\n      for (const edge of inserted.values()) {\n        if (held.has(edge.key)) continue\n        const key = entityKey(edge.ref.entity, edge.ref.id)\n        RowPlace.$match(placeIn(store, placed, body, query.value.encoded, key, operators), {\n          Before: place => void (placed = withEdge(placed, edge, place)),\n          End: place => void (placed = withEdge(placed, edge, place)),\n          Outside: () => void outside.push(edge),\n          Unknown: () => undefined,\n        })\n      }\n      return {\n        pages: placed,\n        overlays:\n          outside.length === 0\n            ? overlays\n            : [\n                ...overlays,\n                { id: 'placed:outside', connection: identity, edges: outside, position: 'remove' },\n              ],\n      }\n    })\n  }\n\n  /**\n   * The loaded lists with what the server said of rows they hold placed: a\n   * read or a live patch that changes a held row's ordering or filtered field\n   * moves it, or takes it out, as a mutation's answer does. A list it cannot\n   * place stands as it is, as a read is no write: its own refetch or live\n   * stream says otherwise. Only a value the client held before counts, so a\n   * row's first read judges nothing.\n   */\n  const placedNews = (\n    remote: RemoteModel,\n    news: ReadonlyArray<NormalizedPatch>,\n    before: EntityStore,\n    context: ExprContext,\n  ): RemoteModel => {\n    if (news.length === 0) return remote\n    const held = news.map(patch => {\n      const values = before[entityKey(patch.entity, patch.id)]?.values ?? {}\n      return {\n        ...patch,\n        values: Object.fromEntries(\n          Object.entries(patch.values).filter(([field]) => Object.hasOwn(values, field)),\n        ),\n      }\n    })\n    const changes = changesOf({ entities: held }, before)\n    if (changes.length === 0) return remote\n    const placed: Record<string, Connection> = {}\n    for (const [identity, pages] of Object.entries(remote.connections)) {\n      const after = placedHeld(identity, pages, changes, remote.entities, context)\n      if (after !== pages) placed[identity] = after\n    }\n    return withPlacements(remote, placed, [])\n  }\n\n  /** The rows a read or a live patch says the server holds now. */\n  const newsOf = (message: RemoteMessage | RemoteMessageInput): ReadonlyArray<NormalizedPatch> => {\n    if (message._tag === 'ReadReceived') return message.result.entities\n    if (message._tag !== 'LiveReceived') return []\n    const event = message.event as LiveEvent\n    if (event._tag !== 'EntityPatched') return []\n    return [{ entity: event.ref.entity, id: event.ref.id, values: event.values }]\n  }\n\n  /**\n   * The loaded connections as a write left them: each judged by its body\n   * against the store as the write left it, a change it can place placed in\n   * its pages, and one it cannot invalidated for its read entry to fetch.\n   */\n  const impactOf = (\n    remote: RemoteModel,\n    answer: Extract<RemoteMessage, { readonly _tag: 'MutationSucceeded' }>,\n    // The store before the answer, to tell a value it changed from one it repeated.\n    before: EntityStore,\n    context: ExprContext,\n  ): RemoteModel => {\n    const changes = changesOf(answer, before)\n    if (changes.length === 0) return remote\n    // A row the answer itself put in or took out of a list is where the server\n    // says; every other change to that list's rows is judged as anywhere.\n    const named = new Map<string, Set<string>>()\n    for (const change of answer.connections ?? []) {\n      const keys = named.get(change.connection) ?? new Set<string>()\n      keys.add(change.edge.key)\n      named.set(change.connection, keys)\n    }\n    const visible = visibleStoreOf(remote.entities, remote.optimistic, operators)\n    const placed: Record<string, Connection> = {}\n    const invalidated: Array<string> = []\n    for (const identity of Object.keys(remote.connections)) {\n      const answered = named.get(identity)\n      const judged =\n        answered === undefined\n          ? changes\n          : changes.filter(change => !answered.has(entityKey(change.entity, change.id)))\n      if (judged.length === 0) continue\n      const query = queryOf(identity)\n      if (Option.isNone(query)) continue\n      const original = remote.connections[identity]!\n      // Each change is judged against the pages the one before it left. What the\n      // list holds is read once: a change is of a row of its own, judged against\n      // the store as the whole answer left it.\n      const holds = new Set(\n        visibleItems(\n          original,\n          identity,\n          remote.optimistic.overlays,\n          goneIn(remote.entities, remote.optimistic),\n        ).map(edge => entityKey(edge.ref.entity, edge.ref.id)),\n      )\n      let pages = original\n      let invalid = false\n      for (const change of judged) {\n        const held: HeldConnection = { ...query.value, connection: pages, holds }\n        const after = Impact.$match(impactOn(held, visible, change, operators, context), {\n          Kept: () => Option.some(pages),\n          Placed: ({ connection }) => Option.some(connection),\n          Invalidated: () => Option.none<Connection>(),\n        })\n        if (Option.isNone(after)) {\n          invalid = true\n          break\n        }\n        pages = after.value\n      }\n      if (invalid) invalidated.push(identity)\n      else if (pages !== original) placed[identity] = pages\n    }\n    return withPlacements(remote, placed, invalidated)\n  }\n\n  /**\n   * The lists placed and invalidated. Under `verifyPredictions`, each placed\n   * list is fetched too, and the order it was placed in kept to compare with\n   * the server's page.\n   */\n  const withPlacements = (\n    remote: RemoteModel,\n    placed: Readonly<Record<string, Connection>>,\n    invalidated: ReadonlyArray<string>,\n  ): RemoteModel => {\n    const identities = Object.keys(placed)\n    if (identities.length === 0) return invalidateConnections(remote, invalidated)\n    const withPlaced = { ...remote, connections: { ...remote.connections, ...placed } }\n    if (options.verifyPredictions !== true) return invalidateConnections(withPlaced, invalidated)\n    const firstPage = (connection: Connection | undefined) =>\n      (connection?.segments[0]?.edges ?? []).map(edge => edge.key)\n    const orders = Object.fromEntries(\n      identities.map(identity => {\n        const order = firstPage(placed[identity])\n        const kept = new Set(order)\n        return [\n          identity,\n          {\n            order,\n            dropped: firstPage(remote.connections[identity]).filter(key => !kept.has(key)),\n          },\n        ]\n      }),\n    )\n    return invalidateConnections({ ...withPlaced, placed: { ...remote.placed, ...orders } }, [\n      ...invalidated,\n      ...identities,\n    ])\n  }\n  const assertOwned = (entry: ActiveEntry<AppModel>) => assertOwnedBy(bound.contract, entry)\n  /**\n   * What the reader is shown of each entity in `model`, and what the write\n   * itself shows (`predicted`), for its answer to carry (#245, #265).\n   */\n  const shownAt = (\n    model: AppModel,\n    predicted: ReadonlyArray<OptimisticOperation>,\n  ): ReadonlyArray<RelationRequirement> =>\n    shownOf(\n      askedUnion(\n        [...readers.values()].flatMap(resolvedAt =>\n          resolvedAt(model).map(({ projection }) => projection),\n        ),\n      ),\n      predicted,\n    )\n  /**\n   * A durable write's request id, which is its operation id: this page's\n   * session and the next in its sequence, unique across tabs and loads. Only\n   * a retry names one, and only one the outbox holds.\n   */\n  const durableId = (remote: RemoteModel, mutation: string, given: string | undefined): string => {\n    if (given !== undefined) {\n      if (remote.outbox.queue.some(queued => operationOf(queued) === given)) return given\n      throw new Error(\n        `[foldkit-remote] Data.mutate(${mutation}, { durable: true, requestId: \"${given}\" }): a durable write is named by the outbox; pass no requestId`,\n      )\n    }\n    return Option.match(remote.outbox.session, {\n      onNone: () => {\n        throw new Error(\n          `[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`,\n        )\n      },\n      onSome: session => `${session}-${remote.mutations.sequence + 1}`,\n    })\n  }\n  /** The descriptor a recorded write names; only a hand-built `MutationStarted` names another. */\n  const registeredMutation = (name: string): MutationDescriptor<any, any, any> => {\n    const descriptor = definition.registry.mutations.get(name)\n    if (descriptor === undefined) {\n      throw new Error(\n        `Remote: a failed write names mutation \"${name}\", which domain \"${bound.contract.name}\" does not register`,\n      )\n    }\n    return descriptor\n  }\n  /**\n   * `prefetch` and `satisfy`, each Message they reduce also kept in `heard`,\n   * so `preload` can hand them to the Model as it is by the time they land.\n   */\n  const prefetchInto = (\n    model: AppModel,\n    projection: Projection<AppModel, unknown>,\n    options: ObserveOptions,\n    heard: Array<RemoteMessage>,\n  ) => {\n    const hear = (current: AppModel, message: RemoteMessage): AppModel => {\n      heard.push(message)\n      return reduce(current, message)\n    }\n    return Effect.gen(function* () {\n      const { policy = RemotePolicy.cacheFirst, now = wallClock } = options\n      const client = yield* RemoteClient\n      const planOptions = RemotePolicy.toPlan(policy, now())\n      let current = model\n      // The pages first, so their items join the one entity read below. A\n      // page with a payload already writes its items' selected fields, so\n      // the read below is only for what the server left out.\n      for (const query of planAsked(store.get(current), askedOf(projection), planOptions, operators)\n        .queries) {\n        const page = yield* queryRequestOf(query).pipe(\n          Effect.flatMap(request => client.query(request)),\n        )\n        current = hear(\n          current,\n          pageMessage(query.identity, page, true, query.window, query.select, now()),\n        )\n      }\n      const requirements = planAsked(\n        store.get(current),\n        askedOf(projection),\n        planOptions,\n        operators,\n      ).requirements\n      if (requirements.length === 0) return current\n      const at = now()\n      const result = yield* client.read({\n        version: REMOTE_PROTOCOL_VERSION,\n        requests: requirements,\n      })\n      return hear(current, { _tag: 'ReadReceived', requests: requirements, result, now: at })\n    })\n  }\n  const satisfyInto = (\n    model: AppModel,\n    active: Readonly<Record<string, ActiveEntry<AppModel>>>,\n    options: SatisfyOptions,\n    heard: Array<RemoteMessage>,\n  ) =>\n    Effect.gen(function* () {\n      const { passes = 8, now = wallClock } = options\n      const entries = Object.values(active)\n      entries.forEach(assertOwned)\n      const planOptions = RemotePolicy.toPlan(RemotePolicy.cacheFirst, now())\n      const plans = (\n        current: AppModel,\n        projections: ReadonlyArray<Projection<AppModel, unknown>>,\n      ) => {\n        const planned = planAsked(\n          store.get(current),\n          askedUnion(projections),\n          planOptions,\n          operators,\n        )\n        return planned.queries.length > 0 || planned.requirements.length > 0\n      }\n      let current = model\n      for (let pass = 0; pass < passes; pass++) {\n        if (\n          !entries.some(entry =>\n            plans(\n              current,\n              resolvedOf(entry, current).map(({ projection }) => projection),\n            ),\n          )\n        )\n          return current\n        for (const entry of entries) {\n          // Asked again over the Model the Surface before it left. A family\n          // resolves its parent first: a pass fetches the parent, and the\n          // instances the parent reveals are read in a later pass.\n          for (const { projection } of resolvedOf(entry, current))\n            current = yield* prefetchInto(current, projection, { now }, heard)\n        }\n      }\n      const reading = entries.flatMap(entry =>\n        resolvedOf(entry, current).filter(({ projection }) => plans(current, [projection])),\n      )\n      if (reading.length === 0) return current\n      return yield* new RemoteUnsatisfied({\n        surfaces: reading.map(({ name }) => name),\n        passes,\n      })\n    })\n  const domain: RemoteDomain<AppModel, Store, Entities, Queries, Mutations> = {\n    ...definition,\n    ...bound,\n    get: (selection, id) => Remote.select(bound, selection)(id),\n    live: (selection, id) => {\n      const projection = Remote.select(bound, selection)(id)\n      return {\n        ...projection,\n        metadata: RemoteRequirements.of(\n          ...requirementsOf(projection).map(requirement => ({ ...requirement, live: true })),\n        ),\n      }\n    },\n    active: (name, projectionOf) => {\n      const { owner } = bound.contract\n      if (owner === undefined)\n        throw new Error(\n          `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`,\n        )\n      return { name, owner, messages: [], projectionOf }\n    },\n    subscriptions: (active, options = {}) => {\n      // Dependencies differ per entry, as in Foldkit's own `Subscriptions` record.\n      const entries: Record<string, RemoteEntry<AppModel, any>> = {}\n      // Checked before any reader joins the domain, so a refused call adds none.\n      for (const entry of Object.values(active)) assertOwned(entry)\n      for (const [key, entry] of Object.entries(active)) {\n        const resolvedAt = readers.get(entry) ?? memoizedResolved(entry)\n        readers.set(entry, resolvedAt)\n        const asked = (model: AppModel) =>\n          askedUnion(resolvedAt(model).map(({ projection }) => projection))\n        entries[`${key}.read`] = observeEntry(bound, asked, identityMessage, options)\n        entries[`${key}.live`] = liveEntry(\n          bound,\n          model => liveAskOf(asked(model)),\n          identityMessage,\n          options,\n        )\n      }\n      for (const identity of options.connections ?? [])\n        keptConnections.add(connectionIdentity(identity))\n      entries.retain = {\n        dependenciesSchema: retentionRootsSchema,\n        modelToDependencies: model =>\n          rootsOf(\n            [...readers.values()].flatMap(resolvedAt =>\n              resolvedAt(model).map(({ projection }) => projection),\n            ),\n            { connections: [...keptConnections] },\n          ),\n        dependenciesToStream: (current: RetentionRoots) =>\n          Stream.fromEffect(\n            Effect.succeed<RemoteMessage>({ _tag: 'RetentionChanged', roots: current }).pipe(\n              Effect.delay(options.grace ?? 0),\n            ),\n          ),\n      }\n      markAll(entries)\n      // The loop above wrote exactly the keys the mapped type names.\n      return entries as SubscriptionEntries<AppModel, typeof active>\n    },\n    plan: (model, projection, options) => Remote.plan(bound, model, projection, options),\n    meta: (model, projection) => Remote.meta(bound, model, projection),\n    storeOf: model => storeOf(bound, model),\n    confirmed: projection => confirmed(bound, projection),\n    prefetch: (model, projection, options = {}) => prefetchInto(model, projection, options, []),\n    satisfy: (model, active, options = {}) => satisfyInto(model, active, options, []),\n    preload: (model, active, options = {}) => {\n      // A Surface of another application is a mistake in `update`, refused there.\n      Object.values(active).forEach(assertOwned)\n      return {\n        name: 'Remote.preload',\n        args: { active: Object.keys(active).join(', ') },\n        effect: Effect.suspend(() => {\n          const heard: Array<RemoteMessage> = []\n          // Speculative: however the read ends, defects included, what it\n          // heard is all it hands on, and the destination reads the rest.\n          return satisfyInto(model, active, options, heard).pipe(\n            Effect.exit,\n            Effect.map((): RemoteMessage => ({ _tag: 'Preloaded', messages: heard })),\n          )\n        }),\n      }\n    },\n    query: <Q extends QueryDescriptor<any, any, any>, Value, Entity extends string>(\n      query: Q,\n      input: QueryInput<Q>,\n      options: QueryOptions<Value, Entity, QueryEntity<Q>>,\n    ): QueryProjection<AppModel, Value, Q['name'], QueryInput<Q>> => {\n      assertRegistered(bound, 'Query', definition.registry.queries, query.name)\n      const { select: given, live, ...window } = options\n      const select = selectionOf<Value, Entity>(given)\n      for (const [side, size] of [\n        ['first', window.first],\n        ['last', window.last],\n      ] as const) {\n        if (size !== undefined && !(Number.isInteger(size) && size >= 0)) {\n          throw new Error(\n            `Remote: query \"${query.name}\" asks for ${side}: ${String(size)}; a page size is a non-negative integer`,\n          )\n        }\n      }\n      if (live === true && window.first === undefined) {\n        throw new Error(\n          `Remote: query \"${query.name}\" is read live without first; a list watched live is read again every tick, so it needs a size`,\n        )\n      }\n      const listed = (query.Result as Partial<ConnectionSpec>).entity\n      if (listed === undefined) {\n        throw new Error(\n          `Remote: query \"${query.name}\" is not a connection over an entity, so it has no page to select`,\n        )\n      }\n      if (select.entity !== listed) {\n        throw new Error(\n          `Remote: the selection is of \"${select.entity}\", but query \"${query.name}\" lists \"${listed}\"`,\n        )\n      }\n      const contract = placeableReadContract(\n        readContract(query.ref(input), select, window),\n        query.body,\n        operators,\n      )\n      const { ref, relation } = contract\n      const requirement = live === true ? { ...contract.requirement, live } : contract.requirement\n      const relationKey = stableStringify(relation)\n      // A read shows at most its window, whatever else loaded the connection:\n      // a picker's `first: 50` and a Block's `first: 3` of one query share it.\n      const sizeOf = (remote: RemoteModel) => windowSize(remote, ref)\n      const shown = (remote: RemoteModel, connection: Connection) =>\n        cutToWindow(shownEdges(remote, ref.identity, connection), ref.window, sizeOf(remote))\n      // The first failed field among the rows a list shows, if any. Decided\n      // outside the memo, which is keyed on what the rows are read from: a\n      // failure can arrive without any of it changing.\n      const failedItem = (\n        remote: RemoteModel,\n        connection: Connection,\n      ): { readonly _tag: 'Failed'; readonly error: RemoteError } | undefined => {\n        if (Object.keys(remote.failures.fields).length === 0) return undefined\n        for (const edge of shown(remote, connection).edges) {\n          if (edge.ref.entity !== relation.entity) continue\n          const error = failureOf(remote, edge.ref.entity, edge.ref.id, relation)\n          if (error !== undefined) return { _tag: 'Failed', error }\n        }\n        return undefined\n      }\n      // A page carries refs; its rows' fields are read after it lands. While\n      // that read is in flight the list is loading, not `Initial`.\n      const loadingItem = (\n        remote: RemoteModel,\n        connection: Connection,\n      ): { readonly _tag: 'Loading' } | undefined => {\n        if (remote.loading.size === 0) return undefined\n        for (const edge of shown(remote, connection).edges) {\n          if (edge.ref.entity !== relation.entity) continue\n          if (isLoadingThrough(remote, edge.ref.entity, edge.ref.id, relation)) {\n            return { _tag: 'Loading' }\n          }\n        }\n        return undefined\n      }\n      // The page as the rows held make it, before any failure is laid over it.\n      // A row missing a field is left out until it arrives, and the page reads\n      // `Refreshing` meanwhile: a list showing rows keeps showing them while a\n      // joined or re-read row is fetched. `undefined` when no row can be shown\n      // and no row the window would show was deleted: a list that lost its rows\n      // to a delete is a known list without them, not one waiting for its first\n      // rows (#263).\n      const readPage = (\n        remote: RemoteModel,\n        connection: Connection,\n      ): RemoteData<Page<Value>> | undefined => {\n        const visible = visibleStoreOf(remote.entities, remote.optimistic, operators)\n        return memoRead<RemoteData<Page<Value>> | undefined>(\n          [visible, connection, remote.optimistic.overlays],\n          `${ref.identity}\\u0000${relationKey}\\u0000${String(sizeOf(remote))}`,\n          () => {\n            const rows: Value[] = []\n            let refreshing = connection.stale\n            let missing = false\n            const { edges, cutBefore, cutAfter } = shown(remote, connection)\n            for (const edge of edges) {\n              const key = entityKey(edge.ref.entity, edge.ref.id)\n              const assembled = assemble(visible, key, relation)\n              if (assembled === undefined) {\n                const unavailable = unavailableFailure(visible, key, relation)\n                if (unavailable !== undefined) return unavailable\n                missing = true\n                continue\n              }\n              const decoded = decodeRow(select.schema, visible[key]!.values, assembled.values)\n              if (Result.isFailure(decoded)) {\n                return {\n                  _tag: 'Failed',\n                  error: { _tag: 'DecodeError', message: decoded.failure.message },\n                }\n              }\n              refreshing ||= assembled.refreshing\n              rows.push(decoded.success)\n            }\n            if (\n              missing &&\n              rows.length === 0 &&\n              !deletedInWindow(\n                items(connection),\n                new Set(shownEdges(remote, ref.identity, connection).map(edge => edge.key)),\n                ref.window,\n                sizeOf(remote),\n                goneIn(remote.entities, remote.optimistic),\n              )\n            ) {\n              return undefined\n            }\n            const page = {\n              items: rows,\n              hasNext: cutAfter || hasNext(connection),\n              hasPrevious: cutBefore || hasPrevious(connection),\n            }\n            return refreshing || missing\n              ? { _tag: 'Refreshing', value: page }\n              : { _tag: 'Ready', value: page }\n          },\n        )\n      }\n      return {\n        Model: remoteDataSchema(pageSchema(select.schema)) as Schema.Codec<\n          RemoteData<Page<Value>>,\n          unknown\n        >,\n        dependencies: [],\n        metadata: RemoteConnections.of(requirement),\n        ref,\n        selection: select as Selection<Value, string>,\n        read: (root: AppModel): RemoteData<Page<Value>> => {\n          const remote = store.get(root)\n          const connection = remote.connections[ref.identity]\n          const failure = remote.failures.connections[ref.identity]\n          // Invalidating a connection the Model never loaded records it stale with no\n          // segments: still nothing to show. (A loaded empty page is not stale.)\n          if (connection === undefined || (connection.stale && connection.segments.length === 0)) {\n            if (isQueryLoading(remote, ref.identity)) return { _tag: 'Loading' }\n            return failure === undefined ? { _tag: 'Initial' } : { _tag: 'Failed', error: failure }\n          }\n          // A query that answered is not the whole of a list: its rows' fields\n          // are read separately, and one of those failing is the list's failure.\n          const read = readPage(remote, connection) ??\n            failedItem(remote, connection) ??\n            loadingItem(remote, connection) ?? { _tag: 'Initial' }\n          if (failure === undefined) {\n            if (read._tag !== 'Ready' && read._tag !== 'Refreshing') return read\n            const item = failedItem(remote, connection)\n            return item === undefined\n              ? read\n              : { _tag: 'Failed', error: item.error, previous: read.value }\n          }\n          // The rows held before the failure are still the best there is, so they\n          // go with it as `previous`, which `RemoteData.render` shows as stale.\n          switch (read._tag) {\n            case 'Ready':\n            case 'Refreshing':\n              return { _tag: 'Failed', error: failure, previous: read.value }\n            case 'Failed':\n              return read\n            case 'Initial':\n            case 'Loading':\n            case 'NotFound':\n              return { _tag: 'Failed', error: failure }\n          }\n        },\n      }\n    },\n    more: (model, projection) => {\n      const remote = store.get(model)\n      const { ref } = projection\n      const size = windowSize(remote, ref)\n      const page = ref.window.first ?? ref.window.last\n      if (size === undefined || page === undefined || page === 0) return Option.none()\n      const read = projection.read(model)\n      const beyond =\n        (read._tag === 'Ready' || read._tag === 'Refreshing') &&\n        (ref.window.first === undefined ? read.value.hasPrevious : read.value.hasNext)\n      return beyond\n        ? Option.some(\n            bound.store.set(\n              model,\n              updateRemote(remote, {\n                _tag: 'WindowGrown',\n                window: windowGrowthKey(ref.identity, stableStringify(ref.window)),\n                size: size + page,\n              }) as Store,\n            ),\n          )\n        : Option.none()\n    },\n    explain: (model, projection, options) => {\n      const { ref } = projection\n      // Which active Surfaces read this connection, asked of the Model rather\n      // than of the projection: a Surface's projection is rebuilt per Model, so\n      // the only honest comparison is by connection identity. A family names\n      // each reading instance (`Grid[all]`), not just the Surface.\n      const reading = Object.values(options?.surfaces ?? {}).flatMap(source => {\n        const matched = resolvedOf(source, model).filter(({ projection: shown }) =>\n          connectionsOf(shown).some(connection => connection.identity === ref.identity),\n        )\n        // An inactive Surface reads nothing, which is not the same as reading\n        // something else.\n        if (matched.length === 0) return []\n        return [{ source, names: matched.map(({ name }) => name) }]\n      })\n      // The body lives on the descriptor, and a projection keeps only its\n      // `QueryRef` — so the explanation looks the definition back up by name.\n      // Which it can, because `Data` is bound to the domain that registered it.\n      const body = definition.registry.queries.get(ref.query)?.body\n      const [connection] = RemoteConnections.get(projection.metadata)\n      return {\n        domain: bound.contract.name,\n        query: ref.query,\n        input: Schema.encodeSync(ref.Input)(ref.input),\n        identity: ref.identity,\n        window: ref.window,\n        select: connection!.select,\n        ...(body === undefined\n          ? {}\n          : {\n              body: Relational.show(body),\n              dependencies: explainedDependencies(Relational.dependencies(body)),\n            }),\n        state: projection.read(model)._tag,\n        ...(options?.surfaces === undefined\n          ? {}\n          : {\n              surfaces: reading.flatMap(read => read.names),\n              activation: reading.flatMap(read => {\n                const activation = 'activation' in read.source ? read.source.activation : undefined\n                return activation === undefined\n                  ? []\n                  : [{ surface: read.source.name, ...activation }]\n              }),\n            }),\n      }\n    },\n    why: (model, projection, options) => {\n      const data = projection.read(model)\n      const asked = askedOf(projection)\n      const entries = options?.surfaces === undefined ? [] : Object.values(options.surfaces)\n      // Each active entry whose reads ask for all of this one: one that reads\n      // part of it cannot be why it is fetched.\n      const reading = entries.flatMap(entry => {\n        const names = resolvedOf(entry, model)\n          .filter(({ projection: shown }) => covers(askedOf(shown), asked))\n          .map(({ name }) => name)\n        return names.length === 0 ? [] : [{ entry, names }]\n      })\n      const surfaces =\n        options?.surfaces === undefined\n          ? Option.none()\n          : Option.some(reading.flatMap(read => read.names))\n      const initial: ReadonlyArray<Why> =\n        data._tag !== 'Initial'\n          ? []\n          : [\n              Option.match(surfaces, {\n                onNone: () => Why.NoActiveRecord(),\n                onSome: names =>\n                  names.length === 0 ? Why.NotObserved() : Why.NotFetching({ surfaces: names }),\n              }),\n            ]\n      const remote = store.get(model)\n      const live =\n        asked.requirements.some(requirement => requirement.live === true) ||\n        asked.connections.some(connection => connection.live === true)\n      const streams: ReadonlyArray<Why> = live\n        ? reading.flatMap(({ entry }): ReadonlyArray<Why> => {\n            return Match.valueTags(domain.liveStatus(model, entry), {\n              Idle: () => [],\n              Live: () => [],\n              Reconnecting: ({ attempt, error }) => [\n                Why.LiveReconnecting({ surface: entry.name, attempt, error }),\n              ],\n              Refused: ({ error }) => [Why.LiveRefused({ surface: entry.name, error })],\n            })\n          })\n        : []\n      const reader: WhyReader = {\n        remote,\n        visible: visibleStoreOf(remote.entities, remote.optimistic, operators),\n        listOf: identity => ({\n          query: Option.match(queryOf(identity), {\n            onNone: () => identity,\n            onSome: query => query.descriptor.name,\n          }),\n          identity,\n        }),\n        bodyOf: identity =>\n          Option.flatMap(queryOf(identity), query =>\n            Option.map(Option.fromUndefinedOr(query.descriptor.body), body => ({\n              body,\n              encoded: query.encoded,\n            })),\n          ),\n        edgesOf: ({ identity, window }) => {\n          const connection = remote.connections[identity] ?? emptyConnection\n          const placed = shownEdges(remote, identity, connection)\n          return {\n            shown: cutToWindow(placed, window, windowSize(remote, { identity, window })).edges,\n            placed,\n            pages: items(connection),\n          }\n        },\n        operators,\n        context: layersContext(remote.optimistic.layers),\n      }\n      return readWhy(\n        data._tag,\n        [...initial, ...failedReasons(data), ...reasonsOf(reader, asked), ...streams],\n        surfaces,\n      )\n    },\n    timeline: (start, history, reads, options) => {\n      let before = start\n      return history.flatMap((entry, index) => {\n        const from = before\n        before = entry.model\n        return Object.entries(reads).flatMap(([read, projection]): ReadonlyArray<ReadStep<any>> => {\n          const was = projection.read(from)\n          const is = projection.read(entry.model)\n          if (was._tag === is._tag) return []\n          return [\n            {\n              read,\n              index,\n              message: entry.message,\n              from: was._tag,\n              to: is._tag,\n              why: domain.why(entry.model, projection, options),\n              regression: regressed(was, is),\n            },\n          ]\n        })\n      })\n    },\n    filtered: (model, over, by, input) => {\n      assertRegistered(bound, 'Query', definition.registry.queries, by.name)\n      // A filter over a different Entity can never match anything, and would\n      // otherwise answer \"I checked the whole list and found nothing\" — a\n      // confident wrong answer rather than a refusal.\n      const filters = by.body?.entity.name\n      if (filters !== undefined && filters !== over.selection.entity) {\n        throw new Error(\n          `Remote: query \"${by.name}\" is over \"${filters}\", but the list is of \"${over.selection.entity}\", so it cannot filter it`,\n        )\n      }\n      const remote = store.get(model)\n      const connection = remote.connections[over.ref.identity]\n      const visible = visibleStoreOf(remote.entities, remote.optimistic, operators)\n      const edges =\n        connection === undefined ? [] : shownEdges(remote, over.ref.identity, connection)\n      const among = edges.map(edge => entityKey(edge.ref.entity, edge.ref.id))\n      let judged: Judged\n      try {\n        judged = matching(visible, by, input, { among, operators, context: contextOf(model) })\n      } catch (error) {\n        // An input the reference interpreter refuses (a search holding NUL) is\n        // one the server refuses too: nothing here can be said about the list.\n        // Thrown on, it would end the `update` that asked.\n        if (error instanceof QueryEvaluateError) return { items: [], complete: false }\n        throw error\n      }\n      const relation = relationOf(over.selection)\n\n      const items: unknown[] = []\n      let assembledAll = true\n      for (const key of judged.matched) {\n        const assembled = assemble(visible, key, relation)\n        // A matching row whose selected fields are not all here cannot be shown.\n        // It is not dropped from the truth, only from the list: `complete` says\n        // the answer is about less than the whole.\n        if (assembled === undefined) {\n          assembledAll = false\n          continue\n        }\n        const decoded = decodeRow(over.selection.schema, visible[key]!.values, assembled.values)\n        if (Result.isFailure(decoded)) {\n          assembledAll = false\n          continue\n        }\n        items.push(decoded.success)\n      }\n\n      return {\n        items: items as never,\n        // Whole only if every edge was judged, every match could be shown, and\n        // the list itself is all there. `hasNext`/`hasPrevious` read the outer\n        // boundaries alone, so `isGapped` is the third question: a connection\n        // paged from both ends is `Terminal` at both and still missing its\n        // middle.\n        complete:\n          judged.skipped.length === 0 &&\n          assembledAll &&\n          connection !== undefined &&\n          !isGapped(connection) &&\n          !hasNext(connection) &&\n          !hasPrevious(connection),\n      }\n    },\n    refresh: (model, target, options) => Remote.refresh(bound, model, target, options),\n    forget: model => Remote.forget(bound, model),\n    overlay: (model, id, optimistic) => reduce(model, { _tag: 'OverlayShown', id, optimistic }),\n    lift: (model, id) => reduce(model, { _tag: 'OverlayLifted', id }),\n    overlays: model => overlaysOf(store.get(model)),\n    visibleItems: (remote, connection) => {\n      const identity = connectionIdentity(connection)\n      return shownEdges(remote, identity, remote.connections[identity] ?? emptyConnection)\n    },\n    mutate: (model, mutation, input, options = {}) => {\n      assertRegistered(bound, 'Mutation', definition.registry.mutations, mutation.name)\n      const remote = store.get(model)\n      const durable = options.durable === true\n      const requestId = durable\n        ? durableId(remote, mutation.name, options.requestId)\n        : (options.requestId ?? `${bound.contract.name}-${remote.mutations.sequence + 1}`)\n      const tempId = `${requestId}.tmp`\n      // A retry of a failed request sends the operation id it was first sent with.\n      const known = Option.fromUndefinedOr(remote.mutations.operations.get(requestId))\n      // A declared write shows what it writes until the server answers; one given wins.\n      const viewer = viewerOf(model)\n      const visible = visibleStoreOf(remote.entities, remote.optimistic, bound.operators)\n      const predicted =\n        mutation.write === undefined\n          ? undefined\n          : predictionOfWrite(mutation.write, input, options.keys, {\n              derived: definition.registry.derived,\n              store: visible,\n              viewer,\n              now: Option.fromUndefinedOr(options.now),\n            })\n      // A write the client can tell the server refuses is refused here, as the\n      // server would refuse it, and nothing is sent or shown: one its held `may`\n      // forbids, then, as the server decides in that order, one whose row\n      // breaks an invariant.\n      const write = mutation.write\n      const refused =\n        write === undefined || options.optimistic !== undefined\n          ? Option.none()\n          : Option.orElse(\n              Option.map(\n                forbiddenByWrite(write, input, options.keys, visible),\n                ({ reason }): RemoteError =>\n                  remoteError(\n                    new RemoteForbidden({\n                      message: Option.getOrElse(reason, () => 'Forbidden'),\n                      ...Option.match(reason, {\n                        onNone: () => ({}),\n                        onSome: said => ({ reason: said }),\n                      }),\n                    }),\n                  ),\n              ),\n              () =>\n                Option.map(\n                  brokenByWrite(\n                    write,\n                    input,\n                    options.keys,\n                    { viewer, now: Option.fromUndefinedOr(options.now) },\n                    visible,\n                    bound.operators,\n                  ),\n                  (held): RemoteError =>\n                    remoteError({\n                      _tag: 'RemoteMutationError',\n                      message: held.message,\n                      refusal: Schema.encodeUnknownSync(mutation.Refusal)({\n                        _tag: 'Invalid',\n                        entity: Option.some(held.entity),\n                        rule: Option.some(held.id),\n                        message: held.message,\n                        path: held.path,\n                      }),\n                    }),\n                ),\n            )\n      const optimistic = Option.isSome(refused)\n        ? undefined\n        : typeof options.optimistic === 'function'\n          ? options.optimistic({ requestId, tempId })\n          : (options.optimistic ?? predicted)\n      // A write refused where it is made is settled at once, durable or not.\n      const queued = durable && Option.isNone(refused)\n      const started = updateRemote(remote, {\n        _tag: 'MutationStarted',\n        requestId,\n        ...(optimistic === undefined ? {} : { optimistic }),\n        ...(Option.isSome(viewer) ? { viewer: viewer.value } : {}),\n        write: {\n          mutation: mutation.name,\n          input,\n          ...(options.keys === undefined ? {} : { keys: options.keys }),\n          ...(options.now === undefined ? {} : { now: options.now }),\n          ...(queued\n            ? {\n                // Encoded here, so an input its Mutation cannot encode throws at the call.\n                durable: {\n                  input: Schema.encodeUnknownSync(mutation.Input)(input),\n                  shown: shownAt(model, optimistic ?? []),\n                },\n              }\n            : {}),\n        },\n      })\n      const startedModel = store.set(model, started as Store)\n      return {\n        model: startedModel,\n        requestId,\n        tempId,\n        command: {\n          name: `Remote.mutate(${mutation.name})`,\n          args: { requestId },\n          // Minted where the Command runs, so `update` stays pure; a retry finds it in the Model.\n          effect: Effect.flatMap(\n            Effect.sync(() => Option.getOrElse(known, mintOperation)),\n            (operation): Effect.Effect<RemoteMessage, never, RemoteClient> =>\n              queued\n                ? // The outbox sends it, once its store holds it.\n                  Effect.succeed({ _tag: 'MutationQueued', requestId })\n                : Option.isSome(refused)\n                  ? Effect.succeed({\n                      _tag: 'MutationFailed',\n                      requestId,\n                      error: refused.value,\n                      operation,\n                    })\n                  : mutateRemote(mutation, input, requestId, {\n                      keys: options.keys,\n                      operation,\n                      shown: shownAt(startedModel, optimistic ?? []),\n                      now: options.now,\n                    }).pipe(\n                      Effect.matchEffect({\n                        onFailure: error =>\n                          Effect.succeed<RemoteMessage>({\n                            _tag: 'MutationFailed',\n                            requestId,\n                            error: remoteError(error),\n                            operation,\n                          }),\n                        // Dated when it lands, by the clock a test pins.\n                        onSuccess: outcome =>\n                          Effect.map(Clock.currentTimeMillis, (at): RemoteMessage => ({\n                            _tag: 'MutationSucceeded',\n                            requestId,\n                            entities: outcome.entities,\n                            connections: outcome.connections,\n                            deleted: outcome.deleted,\n                            ...(outcome.read === undefined ? {} : { read: outcome.read }),\n                            now: at,\n                          })),\n                      }),\n                    ),\n          ),\n        },\n      }\n    },\n    mutation: (model, requestId) => mutationStatus(store.get(model).mutations, requestId),\n    refusal: (model, requestId, mutation) => {\n      const status = mutationStatus(store.get(model).mutations, requestId)\n      return status._tag === 'Failed' ? refusalOf(status.error, mutation) : Option.none()\n    },\n    failedWrites: (model: AppModel, mutation?: MutationDescriptor<any, any, any, any>) => {\n      if (mutation !== undefined)\n        assertRegistered(bound, 'Mutation', definition.registry.mutations, mutation.name)\n      const { mutations } = store.get(model)\n      // A retry in flight is pending again, and not listed until it fails again.\n      const listed = [...mutations.failed].flatMap(requestId => {\n        const write = mutations.writes.get(requestId)\n        const error = mutations.errors.get(requestId)\n        if (write === undefined || error === undefined || mutations.pending.has(requestId))\n          return []\n        if (mutation !== undefined && write.mutation !== mutation.name) return []\n        const descriptor = registeredMutation(write.mutation)\n        return [\n          {\n            requestId,\n            mutation: descriptor,\n            input: write.input,\n            error,\n            refusal: refusalOf(error, descriptor),\n          },\n        ]\n      })\n      // `Data.mutate` recorded each input as its mutation's Input.\n      return listed as never\n    },\n    retry: (model, requestId) => {\n      const { mutations, outbox } = store.get(model)\n      const write = mutations.writes.get(requestId)\n      if (write === undefined || mutationStatus(mutations, requestId)._tag !== 'Failed')\n        return Option.none()\n      return Option.some(\n        domain.mutate(model, registeredMutation(write.mutation), write.input, {\n          requestId,\n          optimistic: write.optimistic,\n          keys: write.keys,\n          // The same time, so the server stores what the retry shows again.\n          now: Option.getOrUndefined(write.now),\n          durable: outbox.queue.some(queued => operationOf(queued) === requestId),\n        }),\n      )\n    },\n    dismiss: (model, requestId) => {\n      const remote = store.get(model)\n      const dismissed = dismissQueued(remote, requestId)\n      if (dismissed !== remote) return store.set(model, dismissed as Store)\n      if (mutationStatus(remote.mutations, requestId)._tag !== 'Failed') return model\n      return store.set(model, {\n        ...remote,\n        mutations: forgetFailure(remote.mutations, requestId),\n      } as Store)\n    },\n    liveStatus: (model, active) => {\n      assertOwned(active)\n      const resolvedAt = readers.get(active) ?? memoizedResolved(active)\n      const live = liveAskOf(askedUnion(resolvedAt(model).map(({ projection }) => projection)))\n      if (live.requirements.length === 0 && live.queries.length === 0) return { _tag: 'Idle' }\n      const remote = store.get(model)\n      const stream = liveStreamKey(live)\n      const health = remote.streams[stream]\n      if (health === undefined) return { _tag: 'Live' }\n      return Option.match(health.refused, {\n        onSome: error => ({ _tag: 'Refused', error }),\n        onNone: () =>\n          remote.gaps.has(stream)\n            ? { _tag: 'Reconnecting', attempt: health.failures, error: health.error }\n            : { _tag: 'Live' },\n      })\n    },\n    outboxStatus: model => outboxStatus(store.get(model).outbox),\n    reduce,\n    inspect: model => inspectRemote(store.get(model)),\n    persistence: options => {\n      const connections = (options.connections ?? []).map(connectionIdentity)\n      const snapshotOf =\n        options.snapshot ??\n        ((remote: RemoteModel) => RemotePersistence.snapshotOf(remote, { connections }))\n      const debounce = options.debounce ?? '250 millis'\n      // The snapshot text is derived on every Model change; it changes only with\n      // the store, the connections and the scope, so it is kept by them.\n      let last: {\n        readonly entities: EntityStore\n        readonly connections: RemoteModel['connections']\n        readonly scope: string\n        readonly text: Option.Option<string>\n      } = { entities: emptyStore, connections: {}, scope: '', text: Option.none() }\n      const textOf = (remote: RemoteModel, scope: string): Option.Option<string> => {\n        if (\n          last.entities !== remote.entities ||\n          last.connections !== remote.connections ||\n          last.scope !== scope\n        ) {\n          last = {\n            entities: remote.entities,\n            connections: remote.connections,\n            scope,\n            text: Option.fromUndefinedOr(\n              RemotePersistence.dehydrate(snapshotOf(remote), {\n                scope,\n                maxBytes: options.maxBytes,\n              }),\n            ),\n          }\n        }\n        return last.text\n      }\n      // A store that cannot be read restores nothing, so nothing is saved\n      // under this key: an unread snapshot is never written over.\n      const hydratedFrom = (\n        key: string,\n        scope: string,\n      ): Effect.Effect<Option.Option<RemoteMessage>, never, KeyValueStore.KeyValueStore> =>\n        RemotePersistence.restore({ key, scope, maxBytes: options.maxBytes }).pipe(\n          Effect.map((snapshot): RemoteMessage => ({\n            _tag: 'Hydrated',\n            entities: snapshot.entities,\n            connections: snapshot.connections,\n            merge: 'preserve-existing',\n            from: key,\n          })),\n          Effect.option,\n        )\n      // Restores the key the Model is not yet restored from: at start, unless\n      // `init` began from `restore`, and whenever the key changes.\n      const restoreEntry: EntryWithoutKeepAlive<\n        AppModel,\n        RemoteMessage,\n        { readonly key: string; readonly scope: string; readonly restored: boolean },\n        KeyValueStore.KeyValueStore\n      > = {\n        dependenciesSchema: Schema.Struct({\n          key: Schema.String,\n          scope: Schema.String,\n          restored: Schema.Boolean,\n        }),\n        modelToDependencies: model => {\n          const key = options.key(model)\n          return {\n            key,\n            scope: options.scope(model),\n            restored: Option.contains(store.get(model).restoredFrom, key),\n          }\n        },\n        dependenciesToStream: ({ key, scope, restored }) =>\n          restored\n            ? Stream.empty\n            : Stream.fromEffect(hydratedFrom(key, scope)).pipe(\n                Stream.flatMap(Option.match({ onNone: () => Stream.empty, onSome: Stream.make })),\n              ),\n      }\n      const save: EntryWithoutKeepAlive<\n        AppModel,\n        RemoteMessage,\n        { readonly key: string; readonly restored: boolean; readonly text: Option.Option<string> },\n        KeyValueStore.KeyValueStore\n      > = {\n        dependenciesSchema: Schema.Struct({\n          key: Schema.String,\n          restored: Schema.Boolean,\n          text: Schema.OptionFromNullOr(Schema.String),\n        }),\n        modelToDependencies: model => {\n          const remote = store.get(model)\n          const key = options.key(model)\n          const restored = Option.contains(remote.restoredFrom, key)\n          return {\n            key,\n            restored,\n            text: restored ? textOf(remote, options.scope(model)) : Option.none(),\n          }\n        },\n        // A changed cache restarts this stream, so the wait is the debounce.\n        dependenciesToStream: ({ key, restored, text }) =>\n          restored\n            ? Stream.fromEffect(\n                Effect.gen(function* () {\n                  yield* Effect.sleep(debounce)\n                  const kv = yield* KeyValueStore.KeyValueStore\n                  // Too large to keep: no stale smaller snapshot may outlive it.\n                  yield* Option.match(text, {\n                    onNone: () => kv.remove(key),\n                    onSome: written => kv.set(key, written),\n                  })\n                }).pipe(\n                  // A full store keeps the snapshot it had; the next change tries again.\n                  Effect.ignore,\n                ),\n              ).pipe(Stream.drain)\n            : Stream.empty,\n      }\n      return {\n        key: `persistence:${bound.contract.name}`,\n        handles: [],\n        subscriptions: Subscription.make<AppModel, RemoteMessage, KeyValueStore.KeyValueStore>()(\n          () => ({ 'persistence.restore': restoreEntry, 'persistence.save': save }),\n        ),\n        restore: model =>\n          Effect.map(\n            hydratedFrom(options.key(model), options.scope(model)),\n            Option.match({ onNone: () => model, onSome: message => reduce(model, message) }),\n          ),\n      }\n    },\n    outbox: options => {\n      /** How this version reads a stored input of `mutation`; none for one it does not register. */\n      const inputOf = (mutation: string) =>\n        Option.map(\n          Option.fromUndefinedOr(definition.registry.mutations.get(mutation)),\n          descriptor => (input: unknown) =>\n            Option.map(Schema.decodeUnknownOption(descriptor.Input)(input), decoded => ({\n              decoded,\n            })),\n        )\n      const readOf = (\n        key: string,\n        scope: string,\n        stored: StoredOutbox,\n        extra: { readonly session?: string; readonly unsaved?: string } = {},\n      ): RemoteMessage => ({\n        _tag: 'OutboxRead',\n        key,\n        scope,\n        entries: readEntries(stored, inputOf),\n        done: stored.done,\n        ...extra,\n      })\n      /** Tells the other tabs on `key` the store changed, with the answer that changed it. */\n      const announce = (key: string, outcome: Option.Option<RemoteMessage>) =>\n        Effect.sync(() =>\n          Option.map(channelFor(key), channel => {\n            channel.postMessage({ outcome: Option.getOrUndefined(outcome) })\n            channel.close()\n          }),\n        )\n      /** The store with `change` merged in, under its lock, so two tabs never write it at once. */\n      const writeStored = (key: string, scope: string, change: StoredOutbox) =>\n        withLock(\n          storeLock(key),\n          Effect.gen(function* () {\n            // Another scope's waiting writes are never written over: a key that\n            // is not one per principal fails the save, and says why.\n            if (yield* othersWaiting(key, scope)) {\n              return yield* Effect.fail(\n                new Error(\n                  `the store under ${key} holds another scope's waiting writes; give each principal a key of its own`,\n                ),\n              )\n            }\n            const merged = mergeStored(yield* readStored(key, scope), change)\n            const kv = yield* KeyValueStore.KeyValueStore\n            yield* kv.set(key, storedText(merged, scope))\n            return merged\n          }),\n        )\n      /** What the store holds, as a page reads it; this page's own queue, and why, where it cannot be read. */\n      const restored = (key: string, scope: string, session: Option.Option<string>) =>\n        readStored(key, scope).pipe(\n          Effect.map(stored =>\n            readOf(\n              key,\n              scope,\n              stored,\n              Option.match(session, {\n                onNone: () => ({}),\n                onSome: minted => ({ session: minted }),\n              }),\n            ),\n          ),\n          Effect.catch(error =>\n            Effect.succeed(\n              readOf(\n                key,\n                scope,\n                { entries: [], done: [] },\n                {\n                  ...Option.match(session, {\n                    onNone: () => ({}),\n                    onSome: minted => ({ session: minted }),\n                  }),\n                  unsaved: error.message,\n                },\n              ),\n            ),\n          ),\n        )\n      /** Whether the page's queue is the one stored under `key` for `scope`. */\n      const holding = (outbox: RemoteModel['outbox'], key: string, scope: string) =>\n        Option.contains(outbox.key, key) && Option.contains(outbox.scope, scope)\n      const minted = (has: boolean) =>\n        has\n          ? Effect.succeed(Option.none<string>())\n          : Effect.sync(() => Option.some(mintOperation()))\n\n      // The queue's text changes only with the queue and the scope, so it is kept by them.\n      let lastText: {\n        readonly outbox: RemoteModel['outbox'] | undefined\n        readonly scope: string\n        readonly text: string\n      } = { outbox: undefined, scope: '', text: '' }\n      const textOf = (outbox: RemoteModel['outbox'], scope: string): string => {\n        if (lastText.outbox !== outbox || lastText.scope !== scope) {\n          lastText = { outbox, scope, text: storedText(storedOf(outbox), scope) }\n        }\n        return lastText.text\n      }\n\n      const restoreEntry: EntryWithoutKeepAlive<\n        AppModel,\n        RemoteMessage,\n        {\n          readonly key: string\n          readonly scope: string\n          readonly restored: boolean\n          readonly session: boolean\n        },\n        KeyValueStore.KeyValueStore\n      > = {\n        dependenciesSchema: Schema.Struct({\n          key: Schema.String,\n          scope: Schema.String,\n          restored: Schema.Boolean,\n          session: Schema.Boolean,\n        }),\n        modelToDependencies: model => {\n          const { outbox } = store.get(model)\n          const key = options.key(model)\n          const scope = options.scope(model)\n          return {\n            key,\n            scope,\n            restored: holding(outbox, key, scope),\n            session: Option.isSome(outbox.session),\n          }\n        },\n        dependenciesToStream: ({ key, scope, restored: done, session }) =>\n          done\n            ? Stream.empty\n            : Stream.fromEffect(\n                Effect.flatMap(minted(session), mint => restored(key, scope, mint)),\n              ),\n      }\n\n      // Written whenever the queue changes, merged with what other tabs wrote,\n      // and read back: what the store holds is what may be sent.\n      const save: EntryWithoutKeepAlive<\n        AppModel,\n        RemoteMessage,\n        { readonly key: string; readonly scope: string; readonly text: Option.Option<string> },\n        KeyValueStore.KeyValueStore\n      > = {\n        dependenciesSchema: Schema.Struct({\n          key: Schema.String,\n          scope: Schema.String,\n          text: Schema.OptionFromNullOr(Schema.String),\n        }),\n        modelToDependencies: model => {\n          const { outbox } = store.get(model)\n          const key = options.key(model)\n          const scope = options.scope(model)\n          return {\n            key,\n            scope,\n            // Saved only under the key and scope it was read for: never over a queue not yet read.\n            text: holding(outbox, key, scope) ? Option.some(textOf(outbox, scope)) : Option.none(),\n          }\n        },\n        dependenciesToStream: ({ key, scope, text }) =>\n          Option.match(text, {\n            onNone: () => Stream.empty,\n            onSome: written => {\n              const mine = storedFromText(written)\n              return Stream.fromEffect(\n                writeStored(key, scope, mine).pipe(\n                  Effect.tap(() => announce(key, Option.none())),\n                  Effect.map(merged => readOf(key, scope, merged)),\n                  // A store that cannot be written does not hold the writes back:\n                  // they are sent, and a reload before the answer loses them.\n                  Effect.catch(error =>\n                    Effect.succeed(readOf(key, scope, mine, { unsaved: error.message })),\n                  ),\n                ),\n              )\n            },\n          }),\n      }\n\n      /** Sends `write`, as the one tab on `key` that sends, until the server answers it. */\n      const sent = (key: string, scope: string, write: StoredWrite) =>\n        Stream.callback<RemoteMessage, never, KeyValueStore.KeyValueStore | RemoteClient>(queue => {\n          const emit = (message: RemoteMessage) => Queue.offer(queue, message)\n          /**\n           * The outcome told this tab and the others first, so each settles\n           * with the server's answer, then written to the store before the\n           * lock goes, so the next sender reads it.\n           */\n          const settle = (message: RemoteMessage, change: StoredOutbox) =>\n            emit(message).pipe(\n              Effect.andThen(announce(key, Option.some(message))),\n              Effect.andThen(writeStored(key, scope, change)),\n              Effect.andThen(announce(key, Option.none())),\n              // Unwritten, the store still says waiting: the next sender sends it\n              // again, and the operation id has the server answer from its record.\n              Effect.ignore,\n            )\n          const operation = write.operation\n          return withLock(\n            sendLock(key),\n            Effect.gen(function* () {\n              // Another tab may have settled it while this one waited for the lock.\n              const there = yield* Effect.option(readStored(key, scope))\n              if (Option.isSome(there) && settledIn(there.value, operation)) {\n                yield* emit(readOf(key, scope, there.value))\n                return\n              }\n              const mutation = registeredMutation(write.mutation)\n              const input = Schema.decodeUnknownSync(mutation.Input)(write.input)\n              for (let attempt = 1; ; attempt++) {\n                const result = yield* Effect.result(\n                  mutateRemote(mutation, input, operation, {\n                    keys: write.keys,\n                    operation,\n                    shown: write.shown,\n                    now: write.now,\n                  }),\n                )\n                if (Result.isSuccess(result)) {\n                  const outcome = result.success\n                  const at = yield* Clock.currentTimeMillis\n                  return yield* settle(\n                    {\n                      _tag: 'MutationSucceeded',\n                      requestId: operation,\n                      entities: outcome.entities,\n                      connections: outcome.connections,\n                      deleted: outcome.deleted,\n                      ...(outcome.read === undefined ? {} : { read: outcome.read }),\n                      now: at,\n                    },\n                    { entries: [], done: [operation] },\n                  )\n                }\n                const error = remoteError(result.failure)\n                // Nothing answered: kept waiting, and sent again after a wait.\n                if (result.failure._tag === 'Unreachable') {\n                  yield* emit({ _tag: 'OutboxDelayed', requestId: operation, attempt, error })\n                  yield* Effect.race(\n                    Effect.flatMap(backoff(attempt, options.retry), Effect.sleep),\n                    onlineAgain,\n                  )\n                  continue\n                }\n                return yield* settle(\n                  { _tag: 'MutationFailed', requestId: operation, error, operation },\n                  {\n                    entries: [\n                      { ...write, revision: write.revision + 1, state: { _tag: 'Failed', error } },\n                    ],\n                    done: [],\n                  },\n                )\n              }\n            }),\n          ).pipe(Effect.ensuring(Queue.end(queue)))\n        })\n\n      // The head's text changes only with the head, so a send is not restarted\n      // by anything else the Model does while it waits for its answer.\n      let lastHead: {\n        readonly outbox: RemoteModel['outbox'] | undefined\n        readonly head: Option.Option<string>\n      } = { outbox: undefined, head: Option.none() }\n      const headTextOf = (outbox: RemoteModel['outbox']): Option.Option<string> => {\n        if (lastHead.outbox !== outbox) {\n          lastHead = { outbox, head: Option.map(headOf(outbox), write => JSON.stringify(write)) }\n        }\n        return lastHead.head\n      }\n      const send: EntryWithoutKeepAlive<\n        AppModel,\n        RemoteMessage,\n        { readonly key: string; readonly scope: string; readonly head: Option.Option<string> },\n        KeyValueStore.KeyValueStore | RemoteClient\n      > = {\n        dependenciesSchema: Schema.Struct({\n          key: Schema.String,\n          scope: Schema.String,\n          head: Schema.OptionFromNullOr(Schema.String),\n        }),\n        modelToDependencies: model => {\n          const { outbox } = store.get(model)\n          const key = options.key(model)\n          const scope = options.scope(model)\n          return {\n            key,\n            scope,\n            // Another scope's queue is never sent: it was made as someone else.\n            head: holding(outbox, key, scope) ? headTextOf(outbox) : Option.none(),\n          }\n        },\n        dependenciesToStream: ({ key, scope, head }) =>\n          Option.match(head, {\n            onNone: () => Stream.empty,\n            onSome: text =>\n              sent(key, scope, Schema.decodeUnknownSync(StoredWrite)(JSON.parse(text))),\n          }),\n      }\n\n      /** What another tab announced: the answer it heard first, then the store as it now is. */\n      const heard = (key: string, scope: string, data: unknown) =>\n        Effect.map(restored(key, scope, Option.none()), (read): ReadonlyArray<RemoteMessage> => [\n          ...Option.toArray(outcomeOf(data)),\n          read,\n        ])\n      const watch: EntryWithoutKeepAlive<\n        AppModel,\n        RemoteMessage,\n        { readonly key: string; readonly scope: string; readonly restored: boolean },\n        KeyValueStore.KeyValueStore\n      > = {\n        dependenciesSchema: Schema.Struct({\n          key: Schema.String,\n          scope: Schema.String,\n          restored: Schema.Boolean,\n        }),\n        modelToDependencies: model => {\n          const key = options.key(model)\n          const scope = options.scope(model)\n          return {\n            key,\n            scope,\n            restored: holding(store.get(model).outbox, key, scope),\n          }\n        },\n        dependenciesToStream: ({ key, scope, restored: read }) =>\n          read\n            ? Stream.callback<unknown>(queue =>\n                Effect.acquireRelease(\n                  Effect.sync(() =>\n                    Option.map(channelFor(key), channel => {\n                      channel.onmessage = (event: MessageEvent<unknown>) => {\n                        Queue.offerUnsafe(queue, event.data)\n                      }\n                      return channel\n                    }),\n                  ),\n                  channel => Effect.sync(() => Option.map(channel, open => open.close())),\n                ),\n              ).pipe(\n                Stream.mapEffect(data => heard(key, scope, data)),\n                Stream.flatMap(messages => Stream.fromIterable(messages)),\n              )\n            : Stream.empty,\n      }\n\n      return {\n        key: `outbox:${bound.contract.name}`,\n        handles: [],\n        subscriptions: Subscription.make<\n          AppModel,\n          RemoteMessage,\n          KeyValueStore.KeyValueStore | RemoteClient\n        >()(() => ({\n          'outbox.restore': restoreEntry,\n          'outbox.save': save,\n          'outbox.send': send,\n          'outbox.watch': watch,\n        })),\n        restore: model =>\n          Effect.map(\n            Effect.flatMap(minted(Option.isSome(store.get(model).outbox.session)), mint =>\n              restored(options.key(model), options.scope(model), mint),\n            ),\n            message => reduce(model, message),\n          ),\n      }\n    },\n    wiring: (active, options = {}) => ({\n      key: `remote:${bound.contract.name}`,\n      shared: options.shared ?? [],\n      // Every domain claims the same tags with no per-domain discriminator, so\n      // the assembly's claimant check keeps one assembly to one domain.\n      handles: Record.keys(remoteMessageCases),\n      route: (model, message) =>\n        isRemoteMessage(message)\n          ? Option.some(\n              reduceReporting(\n                bound.store,\n                reduce,\n                model,\n                message,\n                (options.shared ?? []).some(tag => tag === 'MutationFailed'),\n              ),\n            )\n          : Option.none(),\n      subscriptions: brandEntries(domain.subscriptions(active, options)),\n      contract: bound.contract,\n    }),\n  }\n  return domain\n}\n\n/** The outbox's own answers, as another tab announced them: a settled write, and nothing else. */\nconst announcedOutcome = Schema.Struct({ outcome: Schema.optional(remoteMessageSchema) })\nconst outcomeOf = (data: unknown): Option.Option<RemoteMessage> =>\n  Option.filter(\n    Option.flatMap(Schema.decodeUnknownOption(announcedOutcome)(data), ({ outcome }) =>\n      Option.fromUndefinedOr(outcome),\n    ),\n    outcome => outcome._tag === 'MutationSucceeded' || outcome._tag === 'MutationFailed',\n  )\n\n/** The window keys of a `QueryOptions`, and only those, without the undefined ones. */\n/**\n * How many rows a read of `ref` shows: its window's `first` or `last`, as\n * `Data.more` has grown it. `undefined` for a window with a cursor or no size,\n * which shows whatever the connection holds.\n */\nconst windowSize = (\n  remote: RemoteModel,\n  ref: { readonly identity: string; readonly window: QueryWindow },\n): number | undefined => {\n  const { first, last, after, before } = ref.window\n  if (after !== undefined || before !== undefined) return undefined\n  const size = first ?? last\n  return size === undefined\n    ? undefined\n    : (remote.grown[windowGrowthKey(ref.identity, stableStringify(ref.window))] ?? size)\n}\n\n/** The edges a window of `size` shows, from the start (`first`) or the end (`last`), and which end it cut. */\nconst cutToWindow = (\n  edges: ReadonlyArray<Edge>,\n  window: QueryWindow,\n  size: number | undefined,\n): {\n  readonly edges: ReadonlyArray<Edge>\n  readonly cutBefore: boolean\n  readonly cutAfter: boolean\n} => {\n  if (size === undefined || edges.length <= size) {\n    return { edges, cutBefore: false, cutAfter: false }\n  }\n  return window.first === undefined\n    ? { edges: edges.slice(edges.length - size), cutBefore: true, cutAfter: false }\n    : { edges: edges.slice(0, size), cutBefore: false, cutAfter: true }\n}\n\n/**\n * Whether a row a window of `size` would show was deleted: one of `edges`\n * gone before the window, read from its end, fills with rows still `shown`.\n * A delete past the window is another window's (#287).\n */\nconst deletedInWindow = (\n  edges: ReadonlyArray<Edge>,\n  shown: ReadonlySet<string>,\n  window: QueryWindow,\n  size: number | undefined,\n  gone: (key: string) => boolean,\n): boolean => {\n  const ordered = window.first === undefined ? [...edges].reverse() : edges\n  let filled = 0\n  for (const edge of ordered) {\n    if (size !== undefined && filled >= size) return false\n    if (gone(entityKey(edge.ref.entity, edge.ref.id))) return true\n    if (shown.has(edge.key)) filled++\n  }\n  return false\n}\n\nconst pickWindow = (window: QueryWindowOptions): QueryWindow => ({\n  ...(window.first === undefined ? {} : { first: window.first }),\n  ...(window.last === undefined ? {} : { last: window.last }),\n  ...(window.after === undefined ? {} : { after: window.after }),\n  ...(window.before === undefined ? {} : { before: window.before }),\n})\n"],"mappings":"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"}