foldkit-remote 0.20.0 → 0.22.0

package/dist/index.d.ts

@@ -0,0 +1,1542 @@
+import { a as remoteDataSchema, i as RemoteError, n as Freshness, o as remoteErrorSchema, r as RemoteData, t as Denied } from "./remoteData-mK1suYi1.js";
+import { a as PredictionPart, i as PredictionMismatch, n as OutboxUnreadable, o as RemoteDiagnostic, r as OutboxUnsaved, s as WriteUnheard, t as LiveRefused } from "./diagnostics-DHhVYflV.js";
+import { _ as unknown, a as EdgeRef, c as edge, d as hasPrevious, f as isGapped, g as terminal, h as segment, i as Edge, l as emptyConnection, m as merge, n as Connection, o as Segment, p as items, r as Cursor, s as cursor, t as Boundary, u as hasNext } from "./connection-BRyaJy89.js";
+import { S as writeEntity, _ as remove, a as askAgain, b as tombstone, c as entityKey, d as isFieldStale, f as isFieldUnavailable, g as readField, h as missingFields, i as EntityWrite, l as entry, m as markStale, n as EntityKey, o as clearStale, p as isTombstone, r as EntityStore, s as emptyStore, t as EntityEntry, u as hasField, v as setStale, x as writeEntities, y as setUnavailable } from "./store-ah2qjcJW.js";
+import { A as PendingDelete, B as derivedOfWrite, C as DerivedBy, D as MutationState, E as MutationDescriptor, F as SchemaOrFields, G as mutationStatus, H as failMutation, I as StartedWrite, J as predictionOfWrite, K as optimisticOfWrite, L as TypeOf, M as Reconciled, N as Refusal, O as MutationStatus, P as RefusalOfWrite, R as beginMutation, S as visibleStore, T as MutationAnswer, U as forbiddenByWrite, V as emptyMutationState, W as forgetFailure, X as schemaOf, Y as reconcileMutation, Z as settledLater, _ as removeOverlay, a as OptimisticOperation, b as settleSuccess, c as addOverlay, d as emptyOptimistic, f as goneIn, g as removeLayer, h as pruneOverlays, i as EntityLayer, j as PendingPatch, k as NormalizedPatch, l as beginOptimistic, m as plannedStore, n as ConnectionIdentity, o as OptimisticState, p as heldOnlyByRequests, q as patchOfWrite, r as ConnectionOverlay, s as addLayer, t as ConnectionChange, u as connectionIdentity, v as resolvedPatches, w as Mutation, x as visibleItems, y as settleFailure, z as brokenByWrite } from "./optimistic-CECsfNGY.js";
+import { a as Query, c as QueryRef, d as queryIdentity, f as stableStringify, i as LivePolicy, l as QueryWindow, n as IDENTITY_SEPARATOR, o as QueryDescriptor, r as LiveInsertion, s as QueryInputs, t as ConnectionSpec, u as ResultOf } from "./query-BuIU93xA.js";
+import { a as Requirement, i as RemoteRequirements, n as RelationRequirement, o as connectionsOf, r as RemoteConnections, s as requirementsOf, t as ConnectionRequirement } from "./requirement-D57S2LpH.js";
+import { A as RemoteMutationError, B as WireBoundary, C as ReadBatch, D as RemoteForbidden, E as RelationRequest, F as RemoteUnauthenticated, I as RemoteUnreachable, L as SettledFields, M as RemoteQueryError, N as RemoteReadError, O as RemoteLiveError, P as RemoteRpc, R as ShownSlice, S as Read, T as ReadRequest, _ as QueryEdge, a as LiveEdge, b as QueryRpc, c as MAX_LIVE_QUERIES, d as Mutate, f as MutationRequest, g as PageSize, h as OperationId, i as LiveChange, j as RemoteProtocolError, k as RemoteLiveRefused, l as MAX_RELATION_DEPTH, m as NormalizedEntity, n as ConnectionChangeSchema, o as LiveRequirement, p as MutationResult, r as Live, s as MAX_FIELDS_PER_REQUEST, t as AnswerRead, u as MAX_SHOWN_ENTITIES, v as QueryRequest, w as ReadBatchResult, x as REMOTE_PROTOCOL_VERSION, y as QueryResult, z as WindowSchema } from "./wire-DthPcTM6.js";
+import { a as coalesceReads, i as coalesceQueries, n as CoalesceOptions, o as requirementKey, r as QueryRun, t as BatchRead } from "./coalesce-CLAr92Nk.js";
+import { a as LiveEvent, c as applyConnectionEvent, d as emptyLiveState, f as liveHasNext, i as LiveCursor, l as applyEntityEvent, n as ConnectionApplied, o as LiveOutcome, p as liveHasPrevious, r as EntityApplied, s as LiveState, t as BoundaryCounts, u as classifyLive } from "./live-BpTzlCnY.js";
+import { a as connectionChangeOf, c as mutateRemote, i as coalescedLayer, l as remoteError, n as RemoteJsonClient, o as liveEventOf, r as RemoteRpcClient, s as mintOperation, t as RemoteClient } from "./client-B055kQuP.js";
+import { a as RelationEntityAnnotation, c as aliasedField, d as refsIn, f as relationAlias, i as RelationAnnotation, l as isRefPage, m as targetsOf, n as RefPageValue, o as RelationKind, p as relationShape, r as RefParts, s as RelationShape, t as RELATION_ALIAS, u as refParts } from "./relation-BLBGOZom.js";
+import { _ as relationOf, a as EntityRef, c as RefKey, d as Selection, f as SelectionOf, g as pageSchema, h as assemble, i as EntityPatch, l as RefPage, m as SelectionValueOf, n as Entity, o as FieldsFrom, p as SelectionValue, r as EntityDescriptor, s as PatchValues, t as AnySchema, u as Page, v as unavailableOf } from "./entity-CgsG5Uel.js";
+import { a as belongsEncoded, i as MatchingOptions, n as Judged, o as matching, r as Matched, t as Belongs } from "./matching-DF5F9Us8.js";
+import { a as Why, i as ShownBy, n as ReadStep, o as WhyTerm, r as ReadWhy } from "./why-kgp_Wr3z.js";
+import { a as OutboxStatus, l as RetryOptions, n as OutboxItemState, t as OutboxItem } from "./outbox-DNuc4kZp.js";
+import { a as gc, i as departedLimit, n as Retained, o as reachable, r as RetentionRoots, s as recentRoots, t as ConnectionRoot } from "./retain-BfNTvBRb.js";
+import { a as SnapshotOptions, i as Snapshot, n as REMOTE_CACHE_VERSION, r as RemotePersistence, t as MergePolicy } from "./persistence-CCMnvg7-.js";
+import { A as updateRemote, C as overlaysOf, D as remoteMessageSchema, E as remoteMessageCases, M as withRefreshRequested, N as writeRead, O as remoteModelSchema, S as onlyOverlaid, T as refreshedAt, _ as isLoading, a as RemoteMessageInput, b as isRemoteMessage, c as StreamHealth, d as failureOf, f as fieldMark, g as isFieldFailed, h as invalidateConnections, i as RemoteMessage, j as windowGrowthKey, k as retentionRootsSchema, l as dismissQueued, m as initialRemoteModel, n as PlacedOrder, o as RemoteMessageTag, p as forgetRemote, r as RefreshState, s as RemoteModel, t as Failures, u as emptyRefresh, v as isLoadingThrough, w as refreshIsInFlight, x as noFailures, y as isQueryLoading } from "./model-B6zk1NMB.js";
+import { a as inspectRemote, i as inspectEntity, n as QueryExplanation, r as RemoteInspection, t as ExplainedDependencies } from "./inspect-DtRQGCRP.js";
+import { a as plan, i as deadlineOf, n as PlanFreshness, o as windowKey, r as PlanOptions, t as Deadline } from "./plan-D9cftxC_.js";
+import { t as RemotePolicy } from "./policy-DsWHmIAq.js";
+import { r as RemoteResumePart, s as resumePart } from "./resume-Ct5R6yli.js";
+import { a as json, i as http, n as RemoteJsonRequest, r as RemoteJsonSend, t as RemoteJsonAnswer } from "./json-DowLl1eB.js";
+import { n as httpWithLive, r as liveFetch, t as LiveFetchOptions } from "./sse-C7LhdbiQ.js";
+import { n as placeIn, t as RowPlace } from "./placement-jZdsIpmj.js";
+import { Duration, Effect, Layer, Option, Schema } from "effect";
+import { ActiveSurface, Contract, Diagnostic, Diagnostics, Focus, Invalid, ModelRef, Projection, ReportDiagnostic, Surface, SurfaceSource, Wiring } from "foldkit-surface";
+import * as Domain from "foldkit-entity";
+import { MemoryOperators } from "foldkit-entity";
+import { RpcClientError } from "effect/rpc";
+import { KeyValueStore } from "effect/persistence";
+import { Command } from "foldkit/command";
+import { EntryWithoutKeepAlive } from "foldkit/subscription";
+import * as Update from "foldkit/update";
+/** What a domain registers: a Remote descriptor, or a `foldkit-entity` Entity (read through `Entity.from`). */
+export type EntityLike = EntityDescriptor<any, any> | Domain.AnyEntity;
+/**
+ * What a read selects: a Remote Selection, or a `foldkit-entity` Selection
+ * (read through `Selection.from`).
+ */
+export type EntitySelection<Value, Name extends string, Id extends string = string> = Selection<Value, Name, 'entity'> | Domain.Selection<Name, unknown, Schema.Constraint & {
+  readonly Type: Value;
+}, Id>;
+/** The Remote descriptor either kind of entity reads as, at the type level. */
+type DescriptorOf<E extends EntityLike> = E extends EntityDescriptor<any, any> ? E : E extends Domain.AnyEntity ? EntityDescriptor<E['name'], FieldsFrom<E>> : never;
+type NameOf<E extends EntityLike> = DescriptorOf<E> extends EntityDescriptor<infer N, any> ? N : never;
+type FieldsOf<E extends EntityLike> = DescriptorOf<E> extends EntityDescriptor<any, infer F> ? F : never;
+type EntityName<D> = D extends {
+  readonly name: infer Name extends string;
+} ? Name : never;
+type QueryName<D> = D extends QueryDescriptor<infer Name, any, any> ? Name : never;
+type MutationName<D> = D extends MutationDescriptor<infer Name, any, any> ? Name : never;
+/**
+ * Nothing when `Name` is one of the domain's registered `Names`; otherwise a
+ * branded failure naming the descriptor, so `Data.get(Team.select(…))` for an
+ * unregistered `Team` errors at the selection in one line.
+ */
+export type Registered<Name extends string, Names extends string, Kind extends string> = [Name] extends [Names] ? unknown : Invalid<`${Kind} "${Name}" is not registered with this Remote domain`>;
+/** Nothing when a selection is of the query's entity; otherwise a branded failure naming both. */
+export type SelectsEntity<Entity extends string, Of extends string> = [Entity] extends [Of] ? unknown : Invalid<`the selection is of "${Entity}", but the query lists "${Of}"`>;
+export interface RemoteDescriptor<Entities extends readonly EntityLike[] = readonly EntityLike[], Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly MutationDescriptor<any, any, any>[]> {
+  readonly entities: Entities;
+  readonly queries: Queries;
+  readonly mutations: Mutations;
+  readonly Model: Schema.Codec<RemoteModel, unknown>;
+  readonly initial: RemoteModel;
+  readonly Message: Schema.Schema<RemoteMessage>;
+  readonly update: (model: RemoteModel, message: RemoteMessage) => RemoteModel;
+  readonly rpc: typeof RemoteRpc;
+  /** Name-keyed lookups built from the declared entities, queries, and mutations. */
+  readonly registry: {
+    readonly entities: ReadonlyMap<string, EntityDescriptor<any, any>>;
+    readonly queries: ReadonlyMap<string, QueryDescriptor<any, any, any>>;
+    readonly mutations: ReadonlyMap<string, MutationDescriptor<any, any, any>>;
+    /**
+     * Per entity name, the members its server filters rows by under a rule
+     * the client does not run (`ReadFilter`), so a change to one is fetched,
+     * not placed.
+     */
+    readonly filtered: ReadonlyMap<string, ReadonlyArray<string>>;
+    /**
+     * Per entity name, the members other registered Entities derive over its
+     * relations (`Derived.count`, `Derived.exists`), which a write of it
+     * moves: what a declared write predicts.
+     */
+    readonly derived: ReadonlyMap<string, ReadonlyArray<DerivedBy>>;
+  };
+}
+declare const boundRemoteNames: unique symbol;
+export interface BoundRemote<AppModel, Store extends RemoteModel, Names extends string = string> {
+  readonly definition: RemoteDescriptor;
+  /** The focus of the store's place in the application Model. */
+  readonly store: Focus<AppModel, Store>;
+  /** For `Module`: owns the store's Model path. */
+  readonly contract: Contract;
+  /**
+   * How the client runs primitive operators: `Remote.make`'s table, which a
+   * pending computed assignment is predicted by wherever the store is read.
+   */
+  readonly operators: MemoryOperators;
+  /** Phantom: the entity names this Remote definition registers. */
+  readonly [boundRemoteNames]?: Names;
+}
+type MutationInput<M> = M extends MutationDescriptor<any, infer Input, any> ? Input : never;
+type MutationRefusal<M> = M extends MutationDescriptor<any, any, any, infer Refused> ? Refused : never;
+/** How `Data.persistence` keeps the cache across a reload. */
+export interface PersistenceOptions<AppModel> {
+  /**
+   * Where the snapshot is stored, from the Model: one key per principal, so a
+   * change of principal reads and writes another snapshot.
+   */
+  readonly key: (model: AppModel) => string;
+  /** Who the snapshot is for; one taken under another scope is discarded. */
+  readonly scope: (model: AppModel) => string;
+  /** The query connections whose rows survive a reload; none by default. */
+  readonly connections?: ReadonlyArray<ConnectionIdentity> | undefined;
+  /** What to keep, when it is not `snapshotOf` the `connections`. */
+  readonly snapshot?: ((remote: RemoteModel) => Snapshot) | undefined;
+  /** A snapshot larger than this is neither written nor read. */
+  readonly maxBytes?: number | undefined;
+  /** How long the cache must be unchanged before it is written; default 250 milliseconds. */
+  readonly debounce?: Duration.Input | undefined;
+}
+/** `Data.persistence`'s wiring, and the restore its runtime's `init` starts from. */
+export interface PersistenceWiring<AppModel> extends Wiring<AppModel, RemoteMessage, KeyValueStore.KeyValueStore> {
+  /**
+   * The Model with the snapshot stored under its `key` restored, as the wiring
+   * would restore it. Resolve it as the runtime's `flags` and start `init`
+   * from it, so the first frame draws the stored rows; the wiring then
+   * restores only when `key` changes. A store it cannot read leaves the Model
+   * as it is, and the wiring tries again.
+   */
+  readonly restore: (model: AppModel) => Effect.Effect<AppModel, never, KeyValueStore.KeyValueStore>;
+}
+/** How `Data.outbox` keeps durable writes across a reload. */
+export interface OutboxOptions<AppModel> {
+  /**
+   * Where the queue is stored, from the Model: one key per principal, so one
+   * person's waiting writes are never sent as another's.
+   */
+  readonly key: (model: AppModel) => string;
+  /**
+   * Who the queue is for, the principal. One stored under another scope reads
+   * as empty and is never written over; a page whose scope changes sends
+   * nothing it read for the old one, and reads the new one's.
+   */
+  readonly scope: (model: AppModel) => string;
+  /** The wait between sends nothing answered: 1 second doubling to 30, unless given. */
+  readonly retry?: RetryOptions | undefined;
+}
+/** `Data.outbox`'s wiring, and the restore its runtime's `init` starts from. */
+export interface OutboxWiring<AppModel> extends Wiring<AppModel, RemoteMessage, KeyValueStore.KeyValueStore | RemoteClient> {
+  /**
+   * The Model with the stored queue under its `key` read back, as the wiring
+   * would read it, and this page's session minted. Resolve it as the runtime's
+   * `flags` and start `init` from it: a durable write needs the session, and
+   * the first frame then shows the waiting writes.
+   */
+  readonly restore: (model: AppModel) => Effect.Effect<AppModel, never, KeyValueStore.KeyValueStore>;
+}
+export interface DomainMutateOptions {
+  /** Overrides the generated id, for a retry, a durable bridge, or a test. Not with `durable`. */
+  readonly requestId?: string | undefined;
+  /**
+   * Queues the write in `Data.outbox` rather than sending it: stored first,
+   * sent in order by one tab, sent again after a reload with the same
+   * operation id and `now`, and after a failure that nothing answered. Its
+   * Command answers `MutationQueued`; the outbox's Subscriptions send it. Needs
+   * the outbox's `restore` to have run, and an input its Mutation encodes.
+   */
+  readonly durable?: boolean | undefined;
+  /**
+   * What the request changes before the server answers, released when it
+   * settles. A function receives the generated ids, so a created entity can
+   * carry `tempId` until the result names the real one.
+   */
+  readonly optimistic?: ReadonlyArray<OptimisticOperation> | ((ids: {
+    readonly requestId: string;
+    readonly tempId: string;
+  }) => ReadonlyArray<OptimisticOperation>) | undefined;
+  /**
+   * When the reader acted, in milliseconds since the epoch: what a time the
+   * write sets (`Expr.now` in `Entity.sets`) is predicted as, and the same
+   * number the request sends, which the server takes within its `clockSkew`.
+   * Read it where the action is, with `Remote.now`, since `update` reads no
+   * clock. Without it the time is not predicted, and the server's clock decides.
+   */
+  readonly now?: number | undefined;
+  /**
+   * For a mutation that is a `Write`: the input keys to write, when only some
+   * changed (what an author edited). The rest of the input is still sent, whole.
+   */
+  readonly keys?: ReadonlyArray<string> | undefined;
+}
+/**
+ * One entry of the active record `subscriptions`, `wiring` and `satisfy`
+ * take: a Surface as the Model activates it (`Surface.at`/`Surface.when`),
+ * a source of keyed instances (`Surface.each`, or any `SurfaceSource`), or a
+ * Surface without params read whole. A family joins its parent's
+ * requirements with its instances', so passing the family alone fetches both
+ * the page and what the page reveals.
+ */
+export type ActiveEntry<AppModel> = ActiveSurface<AppModel> | Surface<AppModel, any, any, void> | SurfaceSource<AppModel>;
+/** A Foldkit Subscription entry of the Remote domain, emitting its Messages through `RemoteClient`. */
+export type RemoteEntry<AppModel, Dependencies> = EntryWithoutKeepAlive<AppModel, RemoteMessage, Dependencies, RemoteClient>;
+/**
+ * The entries `RemoteDomain.subscriptions` returns for an active record: a read
+ * and a live entry per key (the live one idles when nothing is read live), and
+ * `retain`.
+ */
+export type SubscriptionEntries<AppModel, Active, Message = RemoteMessage> = { readonly [K in keyof Active & (string | number) as `${K}.read`]: EntryWithoutKeepAlive<AppModel, Message, ReadDependencies, RemoteClient>; } & { readonly [K in keyof Active & (string | number) as `${K}.live`]: EntryWithoutKeepAlive<AppModel, Message, LiveDependencies, RemoteClient>; } & {
+  readonly retain: EntryWithoutKeepAlive<AppModel, Message, RetentionRoots, never>;
+};
+/** The dependencies of a live entry: what it subscribes to, and where a restart resumes. */
+export interface LiveDependencies {
+  readonly requirements: ReadonlyArray<Requirement>;
+  /** The lists read live, each as its read sends it. */
+  readonly queries: ReadonlyArray<Schema.Schema.Type<typeof QueryRequest>>;
+  readonly cursor: LiveCursor;
+  readonly floor: number;
+  /** How many times the stream broke; each break restarts it. */
+  readonly restarts: number;
+  /** Breaks since its last applied event, which the restart's backoff grows with. */
+  readonly failures: number;
+}
+/**
+ * Whether what an active entry reads live is arriving. `Reconnecting` is a
+ * stream that broke and waits to resubscribe; until it has, changes are
+ * missed, and its rows may be out of date. `Refused` is a stream the server
+ * would not open for what it asks: it is not retried until that changes.
+ */
+export type LiveStatus =
+/** It reads nothing live. */
+{
+  readonly _tag: 'Idle';
+} |
+/** Subscribed, and not broken since. */
+{
+  readonly _tag: 'Live';
+} | {
+  readonly _tag: 'Reconnecting';
+  /** Breaks in a row, the first being 1. */
+  readonly attempt: number;
+  /** Why it broke; none for a gap in its events. */
+  readonly error: Option.Option<RemoteError>;
+} |
+/** The server refused it (`RemoteLiveRefused`); it waits for what it asks to change. */
+{
+  readonly _tag: 'Refused';
+  readonly error: RemoteError;
+};
+export interface SubscriptionsOptions extends ObserveOptions, LiveOptions, RetainOptions {}
+/**
+ * A Remote domain's wiring for an assembly: it routes Remote's Messages into
+ * `reduce`, brings its Subscriptions and contract, and requires `RemoteClient`
+ * from the runtime's resources Layer. The `Shared` tags reach the
+ * application's own update too, after Remote has reduced them.
+ */
+export type RemoteWiring<AppModel, Shared extends RemoteMessageTag = never> = Wiring<AppModel, RemoteMessage | RemoteMessageInput, RemoteClient, RemoteMessageTag> & {
+  readonly shared: ReadonlyArray<Shared>;
+};
+/** How `Data.wiring` joins an assembly: its Subscriptions' options, and what the application hears. */
+export interface WiringOptions<Shared extends RemoteMessageTag = never> extends SubscriptionsOptions {
+  /**
+   * Remote's Messages the application's own `update` receives as well, after
+   * Remote has reduced them, so the Model it gets already holds what they say:
+   * `['MutationFailed']` to react to a write that failed.
+   */
+  readonly shared?: ReadonlyArray<Shared> | undefined;
+}
+/**
+ * A write that failed and is neither retried nor dismissed, typed by its
+ * mutation: what `Data.failedWrites` lists.
+ */
+export interface FailedWrite<M extends MutationDescriptor<any, any, any, any>> {
+  readonly requestId: string;
+  readonly mutation: M;
+  /** The input it was started with, to show or give back. */
+  readonly input: MutationInput<M>;
+  readonly error: RemoteError;
+  /** Why the server refused it, as `mutation` declares; none for any other failure. */
+  readonly refusal: Option.Option<MutationRefusal<M>>;
+}
+/** `FailedWrite` of each of a union of mutations. */
+export type FailedWriteOf<M> = M extends MutationDescriptor<any, any, any, any> ? FailedWrite<M> : never;
+/** What `RemoteDomain.mutate` hands `update`: the Model with the request started, and the Command that settles it. */
+export interface MutationStarted<AppModel> {
+  readonly model: AppModel;
+  readonly requestId: string;
+  readonly tempId: string;
+  /** Yields `MutationSucceeded` or `MutationFailed`; never fails. */
+  readonly command: Command<RemoteMessage, never, RemoteClient>;
+}
+/**
+ * A Remote domain bound to its place in the application Model: the descriptor
+ * (`Remote.define`), the binding (`Remote.at`), and the application-facing
+ * operations over them. Every method compiles to the `Remote.*` function of the
+ * same name, which stays exported for tooling, SSR, and tests.
+ */
+export interface RemoteDomain<AppModel, Store extends RemoteModel, Entities extends readonly EntityLike[], Queries extends readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[]> extends BoundRemote<AppModel, Store, EntityName<Entities[number]>>, RemoteDescriptor<Entities, Queries, Mutations> {
+  /** `Remote.select`: a Projection reading one entity through a selection of a registered entity. */
+  get<Value, Name extends string, Id extends string = string>(selection: EntitySelection<Value, Name, Id> & Registered<Name, EntityName<Entities[number]>, 'Entity'>, id: NoInfer<Id>): Projection<AppModel, RemoteData<Value>>;
+  /**
+   * `get`, and the projection also subscribes to the entity's changes: its
+   * requirements are marked `live`, so `subscriptions` derives a live entry for
+   * the Surfaces that read it.
+   */
+  live<Value, Name extends string, Id extends string = string>(selection: EntitySelection<Value, Name, Id> & Registered<Name, EntityName<Entities[number]>, 'Entity'>, id: NoInfer<Id>): Projection<AppModel, RemoteData<Value>>;
+  /**
+   * A query connection read as a `Page` of items selected of the query's
+   * entity: `Initial` until the page and every item's selected fields are
+   * present, `Refreshing` while any of them is being refetched. The window is
+   * the page first asked for; the pages `next`, `previous` and `fetch` merge
+   * onto the connection read through the same projection.
+   */
+  query<Q extends QueryDescriptor<any, any, any>, Value, Entity extends string>(query: Q & Registered<Q['name'], QueryName<Queries[number]>, 'Query'>, input: QueryInput<Q>, options: QueryOptions<Value, Entity, QueryEntity<Q>>): QueryProjection<AppModel, Value, Q['name'], QueryInput<Q>>;
+  /**
+   * "Load more": the Model with the read's window grown by one page, so it
+   * shows that many more rows; the read entry fetches what the connection
+   * lacks. None when the read shows everything there is (or is not a sized
+   * window). Called from `update`.
+   */
+  more<Name extends string, Input>(model: AppModel, projection: QueryProjection<AppModel, any, Name, Input>): Option.Option<AppModel>;
+  /**
+   * What a query read is and what it currently is, as one serializable value —
+   * data-query-DESIGN §29.1: the domain, the definition and its input, the
+   * connection identity, the window, the Selection, the body as readable text
+   * with what it depends on, and what the read answers from this Model.
+   *
+   * Pure, so a DevTools panel showing it shows something the Model can be
+   * replayed to.
+   *
+   * Given `surfaces` — the same active record `subscriptions` takes — it also
+   * reports which of them read this connection, and why each is active where
+   * that is a readable fact (`Surface.when`) rather than a callback
+   * (`Surface.at`). A Projection cannot carry this itself: several Surfaces may
+   * read one connection, so it is not a property of the read.
+   */
+  explain<Name extends string, Input>(model: AppModel, projection: QueryProjection<AppModel, any, Name, Input>, options?: {
+    readonly surfaces?: Readonly<Record<string, ActiveSurface<AppModel> | SurfaceSource<AppModel>>> | undefined;
+  }): QueryExplanation;
+  /**
+   * Why a read shows what it shows. Any Remote read: `Data.get`, `Data.live`
+   * or `Data.query`, or a projection made of them.
+   *
+   * `because` is every fact the Model holds about what it reads, as typed
+   * references: a list or a row's fields missing, stale, in flight or
+   * failed; a pending write showing a value, and which `where` term put a row
+   * in a list or took it out. The reason that decides the state comes first,
+   * and `message` says it, with what restarts it. For `Initial`, given
+   * `surfaces` (the record `subscriptions` takes), it tells the two wiring
+   * mistakes apart: no active Surface reads it, or one does and Remote's
+   * Subscriptions are not running. Pure: it reads the Model and plans nothing.
+   */
+  why(model: AppModel, projection: Projection<AppModel, RemoteData<unknown>>, options?: {
+    readonly surfaces?: Readonly<Record<string, ActiveSurface<AppModel> | SurfaceSource<AppModel>>> | undefined;
+  }): ReadWhy;
+  /**
+   * Each change of each read's tag across a recorded history (the Messages
+   * `update` handled, each with the Model it left, as Foldkit's devtools
+   * records them), with the Message that made it and `why` at the Model it
+   * changed to. `regression` marks a read that showed a value and stopped
+   * with no reason a reader can see (#234).
+   */
+  timeline<Message>(start: AppModel, history: ReadonlyArray<{
+    readonly message: Message;
+    readonly model: AppModel;
+  }>, reads: Readonly<Record<string, Projection<AppModel, RemoteData<unknown>>>>, options?: {
+    readonly surfaces?: Readonly<Record<string, ActiveSurface<AppModel> | SurfaceSource<AppModel>>> | undefined;
+  }): ReadonlyArray<ReadStep<Message>>;
+  /**
+   * The rows of a loaded list that a body matches, decoded as the list decodes
+   * them — a filter that asks the server nothing.
+   *
+   * **It filters a list; it does not run a query.** That distinction is what
+   * keeps it honest. "Which rows match" would need to know that the list holds
+   * every row the body could match, which is predicate containment and is
+   * deliberately not built. "Which rows *of this list* match" is decidable from
+   * what is already here, and is what a search box over a loaded page actually
+   * wants.
+   *
+   * `complete` says whether the answer is about the whole list: every edge
+   * judged, and the connection terminal at both ends. An incomplete answer is
+   * not wrong — it is about less than the caller may have meant, which is why
+   * it is said rather than left for a view to assume.
+   *
+   * Creates no connection, so there is nothing new to retain and nothing new to
+   * fetch. The server stays authoritative for which rows exist.
+   */
+  filtered<Value, Name extends string, Input, Q extends QueryDescriptor<any, any, any>>(model: AppModel, over: QueryProjection<AppModel, Value, Name, Input>, by: Q & Registered<Q['name'], QueryName<Queries[number]>, 'Query'>, input: QueryInput<Q>): Matched<Value>;
+  /**
+   * Shows operations over the store with no request behind them, as a mutation's
+   * `optimistic` ones show while it is in flight: every Selection and view draws
+   * them. For a preview of a change nobody has made. They stay until `lift`;
+   * showing an id again replaces what it showed. Called from `update`. A read
+   * of an entity only overlays show, lacking a field it selects, is `Failed`
+   * (`Overlaid`): nothing will fetch that field.
+   */
+  overlay(model: AppModel, id: string, optimistic: ReadonlyArray<OptimisticOperation>): AppModel;
+  /** Lifts what `overlay` showed under this id. Lifting nothing returns the same Model. */
+  lift(model: AppModel, id: string): AppModel;
+  /**
+   * The ids `overlay` shows now, in the order they are drawn, a later one over
+   * an earlier: what a caller that overlays from its own state reconciles
+   * against.
+   */
+  overlays(model: AppModel): ReadonlyArray<string>;
+  /**
+   * The edges a connection shows, as its reads draw them: the server's pages
+   * with pending edits placed, each inserted row where the body's order puts
+   * it (or at the end its overlay names, when it cannot be placed), minus
+   * removed edges and tombstones. Takes the `RemoteModel`, so a persistence
+   * `snapshot` can store a list as it is shown.
+   */
+  visibleItems(remote: RemoteModel, connection: ConnectionIdentity): ReadonlyArray<Edge>;
+  /**
+   * `Remote.refresh`: marks what `target` reads for this Model as due, for its
+   * read entries to refetch. `target` is a projection, a Surface without
+   * params, one entry of the active record, or the record itself, whose
+   * params come from the Model as they do for `subscriptions`; or a
+   * registered query's ref, which invalidates that list whatever its window. With
+   * `{ failed: true }` only what failed is asked again: a "Try again".
+   */
+  refresh(model: AppModel, target: RefreshTarget<AppModel, QueryName<Queries[number]>>, options?: RefreshOptions): AppModel;
+  /** `Remote.forget`: the Model with every server-derived fact gone, for a change of principal. */
+  forget(model: AppModel): AppModel;
+  /**
+   * A read of this domain as an active Surface, for `subscriptions` and
+   * `wiring`: `projectionOf` is what it reads for a Model, none while it
+   * reads nothing. It belongs to the domain's application, and lists no
+   * Messages: it is a requirement, not a sender. A domain made from a raw
+   * optic names no application, so this throws for one.
+   */
+  active<Value>(name: string, projectionOf: (model: AppModel) => Option.Option<Projection<AppModel, Value>>): ActiveSurface<AppModel, Value>;
+  /**
+   * The Foldkit Subscription entries for the active record, keyed for
+   * `Subscription.make`: a read entry per record entry (`Remote.observe`), a
+   * live entry per record entry that reads through `live` (`Remote.live`), and
+   * one retain entry (`Remote.retain`). A `Surface.each` family is one record
+   * entry whose read unions its parent's requirements with its instances'.
+   * Retention is the domain's: the retain entry of every call roots the active
+   * Surfaces of every call, so reads split over calls (one per policy) do not
+   * collect each other's data. A Surface's params are a function of the Model
+   * (`Surface.at`), so what is fetched, subscribed, and retained follows the
+   * Model.
+   */
+  subscriptions<const Active extends Readonly<Record<string, ActiveEntry<AppModel>>>>(active: Active, options?: SubscriptionsOptions): SubscriptionEntries<AppModel, Active>;
+  /** `Remote.plan`: the requirements the store does not satisfy. */
+  plan<Value>(model: AppModel, projection: Projection<AppModel, Value>, options?: PlanOptions): ReadonlyArray<Requirement>;
+  /** `Remote.meta`: when what a projection shows was last received, and whether it is stale or loading. */
+  meta<Value>(model: AppModel, projection: Projection<AppModel, Value>): ReadMeta;
+  /** `Remote.storeOf`: the visible store, base under the pending optimistic layers. */
+  storeOf(model: AppModel): EntityStore;
+  /**
+   * `Remote.confirmed`: the same projection read against the server-derived
+   * store alone, with every pending optimistic layer and connection overlay
+   * left off. What it plans is unchanged — the requirements are the
+   * projection's own — so observing it reads exactly what observing the
+   * projection reads; only what it *shows* differs.
+   *
+   * A view usually wants the projection itself, which is the visible read:
+   * the optimistic layers are there so a change shows before the server has
+   * agreed to it. This is for the reader that must not believe a change until
+   * the server has confirmed it, which in practice is an Agent capability
+   * reporting that what it was asked to do is done:
+   *
+   * ```ts
+   * Agent.when({
+   *   projection: Data.confirmed(ProjectPage.model.project),
+   *   predicate: (project, request) => project.name === request.name,
+   * })
+   * ```
+   *
+   * There is deliberately no `visible`: a projection is already the visible
+   * read, and a wrapper that only forwards would be a second name for it.
+   */
+  confirmed<P extends Projection<AppModel, any>>(projection: P): P;
+  /**
+   * The plan run through `RemoteClient` and reduced into the Model: the
+   * projection's pending queries first, then the fields it lacks (the pages'
+   * items included). For SSR, route or hover prefetch, and tests.
+   */
+  prefetch<Value>(model: AppModel, projection: Projection<AppModel, Value>, options?: ObserveOptions): Effect.Effect<AppModel, RemoteReadError | RemoteProtocolError | RemoteQueryError | RemoteUnauthenticated, RemoteClient>;
+  /**
+   * The Model with everything the active Surfaces read, for a render that
+   * fetches nothing (SSR, a prerender). Each pass prefetches every Surface
+   * that plans a read, over the Model the one before it left, so a Surface
+   * active only once another's read has arrived is read in the next pass (or
+   * the same one, when it comes later in `active`). It stops at the first
+   * pass that plans nothing, and fails with `RemoteUnsatisfied` when
+   * `options.passes` run out first. Reads are cache-first: a field already
+   * held is not asked again. A server that could not tell who is asking
+   * fails it with `RemoteUnauthenticated`, for the host to answer as it
+   * answers a lost session.
+   */
+  satisfy(model: AppModel, active: Readonly<Record<string, ActiveEntry<AppModel>>>, options?: SatisfyOptions): Effect.Effect<AppModel, RemoteReadError | RemoteProtocolError | RemoteQueryError | RemoteUnauthenticated | RemoteUnsatisfied, RemoteClient>;
+  /**
+   * `satisfy` from `update`, for a destination the reader has not reached:
+   * a hover over a link, or a navigation the app expects. `model` is the
+   * Model as it would be there (the route set to the target's); the Command
+   * reads what `active` would read in it and yields one `Preloaded`
+   * carrying the Messages that wrote it, which reduce into the Model as it is
+   * by then. It never fails: a read that fails is one the destination makes
+   * again, and what was read before it still arrives.
+   *
+   * What it reads is kept like any other read until the next change of what
+   * is retained, so preload close to the navigation it expects.
+   */
+  preload(model: AppModel, active: Readonly<Record<string, ActiveEntry<AppModel>>>, options?: SatisfyOptions): Command<RemoteMessage, never, RemoteClient>;
+  /**
+   * Starts a registered mutation from `update`: applies `MutationStarted` (with
+   * the optimistic operations) to the Model and returns the Command that runs
+   * it and yields the settling Message. The request id comes from the model's
+   * mutation sequence unless `options.requestId` is given.
+   */
+  mutate<M extends MutationDescriptor<any, any, any>>(model: AppModel, mutation: M & Registered<M['name'], MutationName<Mutations[number]>, 'Mutation'>, input: MutationInput<M>, options?: DomainMutateOptions): MutationStarted<AppModel>;
+  /**
+   * What Remote knows of a mutation `mutate` started, by its request id:
+   * pending, applied, or failed with the error the server or transport gave.
+   */
+  mutation(model: AppModel, requestId: string): MutationStatus;
+  /**
+   * Why the server refused a mutation, as the value its `Refusal` declares:
+   * none while it is pending or applied, when it failed for another reason,
+   * or when the refusal does not decode as `mutation`'s.
+   */
+  refusal<Refused>(model: AppModel, requestId: string, mutation: MutationDescriptor<string, any, any, Refused>): Option.Option<Refused>;
+  /**
+   * The writes that failed and are still owed an answer, oldest first, each
+   * with its mutation, the input it was started with, and why it failed. Given
+   * a mutation, only its writes, with its input type. A write is listed until
+   * `retry` sends it again, `dismiss` forgets it, or `forget` changes the
+   * principal; nothing drops one on a timer, since that would hide a failure
+   * the reader has not seen.
+   */
+  failedWrites(model: AppModel): ReadonlyArray<FailedWriteOf<Mutations[number]>>;
+  failedWrites<M extends MutationDescriptor<any, any, any, any>>(model: AppModel, mutation: M & Registered<M['name'], MutationName<Mutations[number]>, 'Mutation'>): ReadonlyArray<FailedWrite<M>>;
+  /**
+   * Sends a failed write again as itself: the same input, request id and
+   * operation id (so a server that applied it answers from its record), with
+   * its optimistic operations shown again. None unless `failedWrites` lists it.
+   * A durable one is queued again, and the outbox sends it.
+   */
+  retry(model: AppModel, requestId: string): Option.Option<MutationStarted<AppModel>>;
+  /**
+   * Forgets a failed write, so `failedWrites` no longer lists it; a durable one,
+   * or one the outbox cannot read, goes from its store and every tab. Anything
+   * else (a write still waiting, too) returns the same Model.
+   */
+  dismiss(model: AppModel, requestId: string): AppModel;
+  /**
+   * The durable writes not yet settled, every tab's, in the order the outbox
+   * sends them: how many wait, how many the server refused, and each one's
+   * state, for a "3 changes waiting" line.
+   */
+  outboxStatus(model: AppModel): OutboxStatus;
+  /**
+   * Whether what `active` reads live is arriving: `Reconnecting` from the
+   * moment its stream breaks until it resubscribes, which its live entry does
+   * on its own, with backoff.
+   */
+  liveStatus(model: AppModel, active: ActiveEntry<AppModel>): LiveStatus;
+  /** `updateRemote` on the bound slice: reduces one of Remote's Messages, as `RemoteMessage` or as the application's union constructs it. */
+  reduce(model: AppModel, message: RemoteMessage | RemoteMessageInput): AppModel;
+  /**
+   * How this domain joins an assembly: it routes Remote's Messages into
+   * `reduce`, brings its Subscriptions and contract, and requires
+   * `RemoteClient` from the runtime's resources Layer. One assembly holds at
+   * most one Remote wiring: every domain claims the same tags, and routing
+   * takes the first claimant. `shared` names the Messages the application's
+   * own update hears too.
+   */
+  wiring: <const Active extends Readonly<Record<string, ActiveEntry<AppModel>>>, const Shared extends RemoteMessageTag = never>(active: Active, options?: WiringOptions<Shared>) => RemoteWiring<AppModel, Shared>;
+  /**
+   * Keeps the cache across a reload, as a wiring beside `wiring`: the stored
+   * snapshot for `key` is restored (`Hydrated`, with what the store already
+   * holds kept over it, so a page resumed from the server wins) whenever the
+   * Model is not yet restored from `key`; and the cache is written back when it
+   * changes, once its own snapshot is in. Start `init` from its `restore` so
+   * the first frame already holds the snapshot. Overlays, optimistic layers,
+   * the mutation ledger, live cursors and gaps are never stored. A change of
+   * principal should `forget` in `update`, and name another `key`.
+   */
+  persistence(options: PersistenceOptions<AppModel>): PersistenceWiring<AppModel>;
+  /**
+   * Keeps durable writes (`mutate`'s `durable`) across a reload and sends
+   * them, as a wiring beside `wiring`: the queue is written to `key` before a
+   * write is sent, sent oldest first by one tab (a Web Lock), sent again after
+   * a failure that nothing answered with a backoff, and read back by every
+   * tab. Start `init` from its `restore`. A change of principal should
+   * `forget` in `update`, and name another `key`.
+   */
+  outbox(options: OutboxOptions<AppModel>): OutboxWiring<AppModel>;
+  /** `Remote.inspect` of the bound slice. */
+  inspect(model: AppModel): RemoteInspection;
+}
+/** What `Remote.fold(Data, …).mutate` starts: `Data.mutate`'s result with its Command lifted. */
+export type FoldedMutationStarted<AppModel, ParentMessage> = Omit<MutationStarted<AppModel>, 'command'> & {
+  readonly command: Command<ParentMessage, never, RemoteClient>;
+};
+/**
+ * A bound domain folded under one of the application's own Message variants,
+ * from `Remote.fold`. Calling it reduces a Remote Message into the Model; the
+ * members that produce Messages, `fetch`, `mutate`, and `subscriptions`,
+ * yield the wrapper Message instead of `RemoteMessage`, with the lift recorded
+ * so Story and Scene can resolve a fetch or a mutation by Remote's own answer.
+ * Members that only read or write the Model (`get`, `refresh`, `next`,
+ * `overlay`, and the rest) stay on the domain itself.
+ */
+export interface RemoteFold<AppModel, ParentMessage, Domain extends RemoteDomain<AppModel, any, any, any, any>> {
+  (model: AppModel, message: RemoteMessage | RemoteMessageInput): Update.Return<AppModel, ParentMessage>;
+  /** `Data.mutate`, its Command lifted. */
+  readonly mutate: (...args: Parameters<Domain['mutate']>) => FoldedMutationStarted<AppModel, ParentMessage>;
+  /** `Data.retry`, its Command lifted. */
+  readonly retry: (...args: Parameters<Domain['retry']>) => Option.Option<FoldedMutationStarted<AppModel, ParentMessage>>;
+  /** `Data.preload`, its Command lifted. */
+  readonly preload: (...args: Parameters<Domain['preload']>) => Command<ParentMessage, never, RemoteClient>;
+  /** `Data.subscriptions`, every entry lifted to the wrapper Message. */
+  readonly subscriptions: <const Active extends Readonly<Record<string, ActiveEntry<AppModel>>>>(active: Active, options?: SubscriptionsOptions) => SubscriptionEntries<AppModel, Active, ParentMessage>;
+}
+/** The application Model a bound domain is over. */
+export type ModelOfDomain<Domain> = Domain extends RemoteDomain<infer AppModel, any, any, any, any> ? AppModel : never;
+/** A projection's connection requirement with the `QueryRef` that runs it. */
+export interface QueryRequirement extends ConnectionRequirement {
+  readonly ref: QueryRef<string, unknown>;
+}
+/** A page forward (`first`, `after`) or back (`last`, `before`); mixing the two is a type error. */
+export type QueryWindowOptions = {
+  readonly first?: number | undefined;
+  readonly after?: string | undefined;
+  readonly last?: undefined;
+  readonly before?: undefined;
+} | {
+  readonly last: number;
+  readonly before?: string | undefined;
+  readonly first?: undefined;
+  readonly after?: undefined;
+};
+export type QueryOptions<Value, Entity extends string, Of extends string = Entity> = {
+  /** What to read of each item: a selection of the query's entity (`Of`). */
+  readonly select: EntitySelection<Value, Entity> & SelectsEntity<Entity, Of>;
+  /**
+   * Watch the list live while a Surface reads it: rows that join, change or
+   * leave it are streamed (by a live source that watches queries, such as
+   * `foldkit-remote-drizzle`'s `pollLive`). Needs `first`.
+   */
+  readonly live?: boolean | undefined;
+} & QueryWindowOptions;
+/** A query connection read as a `Page` of selected items; `ref` is the connection with its first window. */
+export interface QueryProjection<AppModel, Value, Name extends string, Input> extends Projection<AppModel, RemoteData<Page<Value>>> {
+  readonly ref: QueryRef<Name, Input>;
+  /** What it reads of each item, so a filter over the same list decodes identically. */
+  readonly selection: Selection<Value, string>;
+}
+/** The input of a query descriptor. */
+export type QueryInput<Q> = Q extends QueryDescriptor<any, infer Input, any> ? Input : never;
+/** The entity a query's connection is over. */
+export type QueryEntity<Q> = Q extends QueryDescriptor<any, any, ConnectionSpec<infer Entity>> ? Entity : string;
+/**
+ * When what a projection shows was last received, and whether it is stale
+ * or loading. See `Remote.meta`.
+ */
+export interface ReadMeta {
+  /** The newest server write among what is shown; none received reads `undefined`. */
+  readonly updatedAt: number | undefined;
+  /** Any shown field or connection is marked stale. */
+  readonly stale: boolean;
+  /** Any shown field or connection is in flight. */
+  readonly loading: boolean;
+}
+export interface MutateOptions {
+  /** What the request changes before the server answers; released when it settles. */
+  readonly optimistic?: ReadonlyArray<OptimisticOperation> | undefined;
+  /**
+   * When the reader acted, in milliseconds since the epoch, as `Remote.now`
+   * read it: sent for a time the write sets, which the server takes within
+   * its `clockSkew`.
+   */
+  readonly now?: number | undefined;
+}
+export interface RetainOptions {
+  /** The query connections the application shows, by `QueryRef` or identity. */
+  readonly connections?: ReadonlyArray<ConnectionIdentity> | undefined;
+  /** How long the roots must be stable before collecting; default none. */
+  readonly grace?: Duration.Input | undefined;
+}
+/** How `Remote.observe` and `Remote.prefetch` treat fields the store already holds. */
+export interface ObserveOptions {
+  /** Default `RemotePolicy.cacheFirst`. */
+  readonly policy?: RemotePolicy | undefined;
+  /** The clock a refreshing policy reads; default `Date.now`, read at each use. */
+  readonly now?: (() => number) | undefined;
+}
+/** How `Data.satisfy` reads: how many passes it may take, and the clock. */
+export interface SatisfyOptions {
+  /** At most this many passes over the Surfaces; default 8. */
+  readonly passes?: number | undefined;
+  /** The clock the reads are stamped with; default `Date.now`, read at each use. */
+  readonly now?: (() => number) | undefined;
+}
+declare const RemoteUnsatisfied_base: Schema.Class<RemoteUnsatisfied, Schema.TaggedStruct<"RemoteUnsatisfied", {
+  readonly surfaces: Schema.$Array<Schema.String>;
+  readonly passes: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * `Data.satisfy` reached its bound with Surfaces still reading, such as a
+ * chain whose every read reveals one more. It names them, so a page that
+ * would have rendered them loading fails instead. (A read the server leaves
+ * unanswered settles as missing and ends the loop.)
+ */
+export declare class RemoteUnsatisfied extends RemoteUnsatisfied_base {}
+export interface LiveOptions {
+  /** The clock `LiveReceived` stamps events with; default `Date.now`, read at each use. */
+  readonly now?: (() => number) | undefined;
+  /**
+   * The first restart's delay after a stream breaks, doubled for each break in
+   * a row, with ±20% jitter: Sync's transport policy. Default `50 millis`.
+   */
+  readonly retryBase?: Duration.Input | undefined;
+  /** The longest a restart waits. Default `5 seconds`. */
+  readonly maxRetryDelay?: Duration.Input | undefined;
+}
+/** Declares a Remote domain: its entities, queries, and mutations, plus the submodel. */
+declare const defineRemote: <const Entities extends readonly EntityLike[], const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<any, any, any>[], const Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly MutationDescriptor<any, any, any>[]>(config: {
+  readonly entities: Entities;
+  readonly queries?: Queries;
+  readonly mutations?: Mutations;
+}) => RemoteDescriptor<Entities, Queries, Mutations>;
+/** A query the read entry runs, as its dependencies carry it: plain data Foldkit compares. */
+declare const PlannedQuery: Schema.Struct<{
+  readonly identity: Schema.String;
+  readonly window: Schema.Struct<{
+    readonly first: Schema.optional<Schema.Number>;
+    readonly last: Schema.optional<Schema.Number>;
+    readonly after: Schema.optional<Schema.String>;
+    readonly before: Schema.optional<Schema.String>;
+  }>;
+  readonly select: Schema.Codec<RelationRequirement, RelationRequirement, never, never>;
+}>;
+/** The dependencies of the read entry: the entity fields to read and the queries to run. */
+export interface ReadDependencies {
+  readonly requirements: ReadonlyArray<Requirement>;
+  readonly queries: ReadonlyArray<Schema.Schema.Type<typeof PlannedQuery>>;
+  /**
+   * The highest generation the fields this entry reads were refreshed at: a
+   * refresh of any of them restarts the entry, and a refresh of anything else
+   * leaves it running.
+   */
+  readonly refresh: number;
+  /**
+   * Under a refreshing policy, when a value the entry holds next ages out and
+   * what is due then. Time reaches Remote only as a Message: the entry sleeps
+   * until then and emits `RefreshStarted`, which marks the fields stale, and
+   * the plan that follows fetches them. A Model that does not change past its
+   * `maxAge` is otherwise never looked at again.
+   */
+  readonly expires: Deadline | null;
+}
+/**
+ * What `Data.refresh` asks again: a projection, a Surface without params, one
+ * entry of the active record (a `Surface.at`/`Surface.when` value, a family),
+ * the whole record, or one list by its query and input (`Everyone.ref({})`),
+ * whatever window reads it.
+ */
+export type RefreshTarget<AppModel, Queries extends string = string> = Projection<AppModel, unknown> | ActiveEntry<AppModel> | Readonly<Record<string, ActiveEntry<AppModel>>> | QueryRef<Queries, any>;
+/** How `Data.refresh` asks again. */
+export interface RefreshOptions {
+  /** Only what failed: a "Try again" leaves what loaded as it is. */
+  readonly failed?: boolean | undefined;
+}
+export declare const Remote: {
+  /** The submodel's schema, the same for every domain; embed it in the application Model. */
+  Model: Schema.Codec<RemoteModel, unknown, never, never>;
+  /** The submodel's initial value. */
+  initial: RemoteModel;
+  /**
+   * Remote's Message cases for `defineMessageUnion`: spread them into the
+   * application's union, and reduce the ones `Remote.reduces` recognizes with
+   * `RemoteDomain.reduce`.
+   */
+  messages: {
+    ReadReceived: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      result: Schema.Struct<{
+        readonly entities: Schema.$Array<Schema.Struct<{
+          readonly entity: Schema.String;
+          readonly id: Schema.String;
+          readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+        }>>;
+        readonly settled: Schema.$Array<Schema.Struct<{
+          readonly entity: Schema.String;
+          readonly id: Schema.String;
+          readonly fields: Schema.$Array<Schema.String>;
+        }>>;
+      }>;
+      now: Schema.Number;
+    };
+    ReadFailed: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+        readonly refusal: Schema.optional<Schema.Unknown>;
+        readonly reason: Schema.optional<Schema.String>;
+      }>;
+      stream: Schema.optional<Schema.String>;
+    };
+    RefreshStarted: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+    };
+    ReadStarted: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      refresh: Schema.optional<Schema.Number>;
+    };
+    QueryStarted: {
+      connections: Schema.$Array<Schema.String>;
+    };
+    RetentionChanged: {
+      roots: Schema.Struct<{
+        readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+        readonly connections: Schema.$Array<Schema.Struct<{
+          readonly identity: Schema.String;
+          readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+        }>>;
+      }>;
+    };
+    Hydrated: {
+      connections: Schema.optional<Schema.Unknown>;
+      from: Schema.optional<Schema.String>;
+      entities: Schema.Unknown;
+      merge: Schema.Union<readonly [Schema.Literal<"replace">, Schema.Literal<"preserve-existing">]>;
+    };
+    MutationStarted: {
+      requestId: Schema.String;
+      optimistic: Schema.optional<Schema.$Array<Schema.Unknown>>;
+      viewer: Schema.optional<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+      }>>;
+      write: Schema.optional<Schema.Struct<{
+        readonly mutation: Schema.String;
+        readonly input: Schema.Unknown;
+        readonly keys: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly now: Schema.optional<Schema.Number>;
+        readonly durable: Schema.optional<Schema.Struct<{
+          readonly input: Schema.Unknown;
+          readonly shown: Schema.$Array<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+        }>>;
+      }>>;
+    };
+    MutationQueued: {
+      requestId: Schema.String;
+    };
+    OutboxRead: {
+      key: Schema.String;
+      scope: Schema.String;
+      session: Schema.optional<Schema.String>;
+      entries: Schema.$Array<Schema.Unknown>;
+      done: Schema.$Array<Schema.String>;
+      unsaved: Schema.optional<Schema.String>;
+    };
+    OutboxDelayed: {
+      requestId: Schema.String;
+      attempt: Schema.Number;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+        readonly refusal: Schema.optional<Schema.Unknown>;
+        readonly reason: Schema.optional<Schema.String>;
+      }>;
+    };
+    MutationSucceeded: {
+      requestId: Schema.String;
+      entities: Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+      }>>;
+      connections: Schema.optional<Schema.$Array<Schema.Unknown>>;
+      deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+      }>>>;
+      read: Schema.optional<Schema.Struct<{
+        readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+        readonly result: Schema.Struct<{
+          readonly entities: Schema.$Array<Schema.Struct<{
+            readonly entity: Schema.String;
+            readonly id: Schema.String;
+            readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+          }>>;
+          readonly settled: Schema.$Array<Schema.Struct<{
+            readonly entity: Schema.String;
+            readonly id: Schema.String;
+            readonly fields: Schema.$Array<Schema.String>;
+          }>>;
+        }>;
+      }>>;
+      now: Schema.Number;
+    };
+    MutationFailed: {
+      requestId: Schema.String;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+        readonly refusal: Schema.optional<Schema.Unknown>;
+        readonly reason: Schema.optional<Schema.String>;
+      }>;
+      operation: Schema.String;
+    };
+    OverlayShown: {
+      id: Schema.String;
+      optimistic: Schema.$Array<Schema.Unknown>;
+    };
+    OverlayLifted: {
+      id: Schema.String;
+    };
+    WindowGrown: {
+      window: Schema.String;
+      size: Schema.Number;
+    };
+    LiveReceived: {
+      stream: Schema.String;
+      event: Schema.Unknown;
+      policy: Schema.optional<Schema.Unknown>;
+      now: Schema.Number;
+    };
+    GapCleared: {
+      stream: Schema.String;
+    };
+    ConnectionMerged: {
+      connection: Schema.String;
+      page: Schema.Unknown;
+      refreshes: Schema.optional<Schema.Boolean>;
+      select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+      entities: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+      }>>>;
+      settled: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly fields: Schema.$Array<Schema.String>;
+      }>>>;
+      now: Schema.optional<Schema.Number>;
+    };
+    ConnectionInvalidated: {
+      connection: Schema.String;
+    };
+    ConnectionRefreshed: {
+      connection: Schema.String;
+    };
+    QueryFailed: {
+      connection: Schema.String;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+        readonly refusal: Schema.optional<Schema.Unknown>;
+        readonly reason: Schema.optional<Schema.String>;
+      }>;
+    };
+    Preloaded: {
+      messages: Schema.$Array<Schema.suspend<Schema.Codec<RemoteMessage, unknown, never, never>>>;
+    };
+    CompletedReportDiagnostics: {};
+  };
+  /** Whether a Message is one of Remote's, by tag. */
+  reduces: typeof isRemoteMessage;
+  /**
+   * Remote's Messages as one Schema, for a wrapper variant in the
+   * application's union: `GotRemoteMessage: { message: Remote.Message }`. With
+   * a wrapper, `update` matches the application's union exhaustively and
+   * `Remote.fold` reduces what arrives inside it.
+   */
+  Message: import("foldkit/message").MessageUnion<{
+    ReadReceived: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      result: Schema.Struct<{
+        readonly entities: Schema.$Array<Schema.Struct<{
+          readonly entity: Schema.String;
+          readonly id: Schema.String;
+          readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+        }>>;
+        readonly settled: Schema.$Array<Schema.Struct<{
+          readonly entity: Schema.String;
+          readonly id: Schema.String;
+          readonly fields: Schema.$Array<Schema.String>;
+        }>>;
+      }>;
+      now: Schema.Number;
+    };
+    ReadFailed: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+        readonly refusal: Schema.optional<Schema.Unknown>;
+        readonly reason: Schema.optional<Schema.String>;
+      }>;
+      stream: Schema.optional<Schema.String>;
+    };
+    RefreshStarted: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+    };
+    ReadStarted: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      refresh: Schema.optional<Schema.Number>;
+    };
+    QueryStarted: {
+      connections: Schema.$Array<Schema.String>;
+    };
+    RetentionChanged: {
+      roots: Schema.Struct<{
+        readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+        readonly connections: Schema.$Array<Schema.Struct<{
+          readonly identity: Schema.String;
+          readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+        }>>;
+      }>;
+    };
+    Hydrated: {
+      connections: Schema.optional<Schema.Unknown>;
+      from: Schema.optional<Schema.String>;
+      entities: Schema.Unknown;
+      merge: Schema.Union<readonly [Schema.Literal<"replace">, Schema.Literal<"preserve-existing">]>;
+    };
+    MutationStarted: {
+      requestId: Schema.String;
+      optimistic: Schema.optional<Schema.$Array<Schema.Unknown>>;
+      viewer: Schema.optional<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+      }>>;
+      write: Schema.optional<Schema.Struct<{
+        readonly mutation: Schema.String;
+        readonly input: Schema.Unknown;
+        readonly keys: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly now: Schema.optional<Schema.Number>;
+        readonly durable: Schema.optional<Schema.Struct<{
+          readonly input: Schema.Unknown;
+          readonly shown: Schema.$Array<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+        }>>;
+      }>>;
+    };
+    MutationQueued: {
+      requestId: Schema.String;
+    };
+    OutboxRead: {
+      key: Schema.String;
+      scope: Schema.String;
+      session: Schema.optional<Schema.String>;
+      entries: Schema.$Array<Schema.Unknown>;
+      done: Schema.$Array<Schema.String>;
+      unsaved: Schema.optional<Schema.String>;
+    };
+    OutboxDelayed: {
+      requestId: Schema.String;
+      attempt: Schema.Number;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+        readonly refusal: Schema.optional<Schema.Unknown>;
+        readonly reason: Schema.optional<Schema.String>;
+      }>;
+    };
+    MutationSucceeded: {
+      requestId: Schema.String;
+      entities: Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+      }>>;
+      connections: Schema.optional<Schema.$Array<Schema.Unknown>>;
+      deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+      }>>>;
+      read: Schema.optional<Schema.Struct<{
+        readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+        readonly result: Schema.Struct<{
+          readonly entities: Schema.$Array<Schema.Struct<{
+            readonly entity: Schema.String;
+            readonly id: Schema.String;
+            readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+          }>>;
+          readonly settled: Schema.$Array<Schema.Struct<{
+            readonly entity: Schema.String;
+            readonly id: Schema.String;
+            readonly fields: Schema.$Array<Schema.String>;
+          }>>;
+        }>;
+      }>>;
+      now: Schema.Number;
+    };
+    MutationFailed: {
+      requestId: Schema.String;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+        readonly refusal: Schema.optional<Schema.Unknown>;
+        readonly reason: Schema.optional<Schema.String>;
+      }>;
+      operation: Schema.String;
+    };
+    OverlayShown: {
+      id: Schema.String;
+      optimistic: Schema.$Array<Schema.Unknown>;
+    };
+    OverlayLifted: {
+      id: Schema.String;
+    };
+    WindowGrown: {
+      window: Schema.String;
+      size: Schema.Number;
+    };
+    LiveReceived: {
+      stream: Schema.String;
+      event: Schema.Unknown;
+      policy: Schema.optional<Schema.Unknown>;
+      now: Schema.Number;
+    };
+    GapCleared: {
+      stream: Schema.String;
+    };
+    ConnectionMerged: {
+      connection: Schema.String;
+      page: Schema.Unknown;
+      refreshes: Schema.optional<Schema.Boolean>;
+      select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+      entities: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+      }>>>;
+      settled: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly fields: Schema.$Array<Schema.String>;
+      }>>>;
+      now: Schema.optional<Schema.Number>;
+    };
+    ConnectionInvalidated: {
+      connection: Schema.String;
+    };
+    ConnectionRefreshed: {
+      connection: Schema.String;
+    };
+    QueryFailed: {
+      connection: Schema.String;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+        readonly refusal: Schema.optional<Schema.Unknown>;
+        readonly reason: Schema.optional<Schema.String>;
+      }>;
+    };
+    Preloaded: {
+      messages: Schema.$Array<Schema.suspend<Schema.Codec<RemoteMessage, unknown, never, never>>>;
+    };
+    CompletedReportDiagnostics: {};
+  }>;
+  /**
+   * A bound domain under one wrapper variant of the application's union, the
+   * same shape Foldkit gives a Submodel: `toParentMessage` wraps Remote's
+   * Messages, the fold reduces them, and its `fetch`, `mutate`, and
+   * `subscriptions` yield the wrapper. Spreading `Remote.messages` and
+   * narrowing with `Remote.reduces` remains the shorter path for an
+   * application whose `update` only reduces.
+   *
+   * @example
+   * ```ts
+   * const Message = defineMessageUnion({ GotRemoteMessage: { message: Remote.Message } })
+   * const foldData = Remote.fold(Data, message => Message.GotRemoteMessage({ message }))
+   *
+   * const update = (model: Model, message: Message): Return =>
+   *   Message.match(message, {
+   *     GotRemoteMessage: ({ message }) => foldData(model, message),
+   *   })
+   * const subscriptions = Subscription.make<Model, Message, RemoteClient>()(() =>
+   *   foldData.subscriptions({ page: Surface.at(ProjectPage, …) }),
+   * )
+   * ```
+   */
+  fold: <Domain extends RemoteDomain<any, any, any, any, any>, ParentMessage>(domain: Domain, toParentMessage: (message: RemoteMessage) => ParentMessage) => RemoteFold<ModelOfDomain<Domain>, ParentMessage, Domain>;
+  /**
+   * A patch of one entity's values, for a mutation's `optimistic` list or an
+   * overlay. Takes a `foldkit-entity` Entity or a Remote descriptor alike, so
+   * the domain you declared once is the one you patch:
+   * `Remote.patch(Project, 'p1', { name: 'Apollo II' })`. Values are the
+   * fields' wire shape, as the server writes them, except a relation, which is
+   * a ref (`owner: Remote.ref(User, 'u1')`), an array of refs, or `null` where
+   * it is optional. A ref key typed by hand, or a ref to another Entity, is
+   * refused, in the type and when the patch is made.
+   */
+  patch: <E extends EntityLike>(entity: E, id: string, values: PatchValues<FieldsOf<E>>) => EntityPatch<NameOf<E>, FieldsOf<E>>;
+  /**
+   * A deletion of one entity, for a mutation's `optimistic` list or an
+   * overlay: `Remote.tombstone(Post, 'p1')`. Until it settles the row reads
+   * `NotFound` and leaves every list and relation, as an answer's `deleted`
+   * does; a failure brings it back. Keeping it gone is the answer's to say.
+   */
+  tombstone: <E extends EntityLike>(entity: E, id: string) => PendingDelete;
+  /**
+   * A reference to one entity, for `ConnectionChange` and anything else that
+   * names a row: `Remote.ref(Project, 'p3')`. Either kind of entity, as with
+   * `Remote.patch`.
+   */
+  ref: <E extends EntityLike>(entity: E, id: string) => EntityRef<NameOf<E>, FieldsOf<E>>;
+  /**
+   * Declares a Remote domain and binds it to its place in the application Model
+   * in one step; the result carries the application-facing operations. The
+   * descriptor alone is `Remote.define`, the binding alone `Remote.at`.
+   */
+  make: <AppModel, Store extends RemoteModel, const Entities extends readonly EntityLike[], const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly [], const Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly []>(config: {
+    readonly model: ModelRef<AppModel, Store>;
+    readonly entities: Entities;
+    readonly queries?: Queries;
+    readonly mutations?: Mutations;
+    /**
+     * Checks each prediction against the server's answer, and records a
+     * `PredictionMismatch` in `diagnostics` for each part that disagrees:
+     * `Value`, a field a pending write showed that the answer holds otherwise;
+     * `Placement`, a list placed in an order the server's first page does not
+     * keep (each placed list is fetched too, for its page; a pending edit is
+     * not checked, since the server does not have it yet); `Gap`, a row whose
+     * answer left out fields the client showed while it was pending and the
+     * store does not otherwise hold, so they are read again and the row reads
+     * `Loading` meanwhile. Everything else behaves as without it. For
+     * development and tests.
+     */
+    readonly verifyPredictions?: boolean | undefined;
+    /**
+     * How the client runs a body's primitive operators when it judges rows it
+     * holds (`Operators`): the kernel's when not given. A body calling one this
+     * table lacks is judged by the server instead, as any row the client cannot
+     * judge is.
+     */
+    readonly operators?: MemoryOperators | undefined;
+    /**
+     * Who reads, as a row (`Remote.ref(User, model.me)`), or none for a
+     * visitor: whom a declared write predicts each `Derived.exists` for. The
+     * store holds one viewer's values, as it holds one principal's: a change
+     * of viewer is a change of principal, which `Data.forget`s. Without it, an
+     * exists is predicted only where a write takes it away.
+     */
+    readonly viewer?: ((model: AppModel) => Option.Option<{
+      readonly entity: string;
+      readonly id: string;
+    }>) | undefined;
+  }) => RemoteDomain<AppModel, Store, Entities, Queries, Mutations>;
+  /**
+   * Declares a Remote domain without binding it: its entities, queries, and
+   * mutations, plus the submodel. For a domain reused across applications or
+   * bound in a test; `Remote.make` is the one-step form.
+   */
+  define: typeof defineRemote;
+  /**
+   * Binds a Remote domain to its store's location in the application Model. The
+   * registered entity names are carried on the returned value, so `Remote.select`
+   * rejects a selection for an entity this domain never declared. `operators`
+   * is the client's table, which a pending computed assignment is predicted by
+   * (`Operators.kernel` when not given), as `Remote.make`'s is.
+   */
+  at: <AppModel, Store extends RemoteModel, Entities extends readonly EntityLike[], Queries extends readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[]>(definition: RemoteDescriptor<Entities, Queries, Mutations>, store: ModelRef<AppModel, Store>, options?: {
+    readonly operators?: MemoryOperators | undefined;
+  }) => BoundRemote<AppModel, Store, EntityName<Entities[number]>>;
+  /**
+   * The resume part for this domain, for `foldkit-ssr`'s `SSR.plan({ parts })`:
+   * a server render sends what the plan's active Surfaces read from the store,
+   * each connection with its boundaries and each live cursor with it, and
+   * nothing else. `id` tells two domains in one application apart.
+   */
+  resume: typeof resumePart;
+  /**
+   * A Projection node that reads a `RemoteData` value out of the store. The id
+   * is supplied by the caller, usually from a Surface's params. The assembled
+   * value is decoded against the Selection, so malformed server data surfaces
+   * as `Failed` instead of being asserted into `Value`. A present value with a
+   * stale field reads as `Refreshing`: an observer is refetching it.
+   */
+  select: <AppModel, Store extends RemoteModel, Names extends string, Value, Name extends string>(bound: BoundRemote<AppModel, Store, Names>, given: EntitySelection<Value, Name> & Registered<Name, Names, 'Entity'>) => (id: string) => Projection<AppModel, RemoteData<Value>>;
+  /**
+   * When what a projection shows was last received, and whether it is stale
+   * or loading. Pure, so a view can show "updated 5s ago" without I/O.
+   *
+   * `updatedAt` is the newest server write among what is shown, as the
+   * store dates it; `undefined` when nothing shown was received (nothing
+   * loaded, or only an optimistic preview). `stale` is any shown field or
+   * connection marked stale; `loading` is any of them in flight. Optimistic
+   * previews do not date: showing only one reads `updatedAt: undefined`.
+   */
+  meta: <AppModel, Store extends RemoteModel, Value>(bound: BoundRemote<AppModel, Store>, model: AppModel, projection: Projection<AppModel, Value>) => ReadMeta;
+  /**
+   * The pure plan for a projection against a Model: the requirements its
+   * remote store does not satisfy, under `options` (freshness, force). A
+   * Surface's projection is `surface.projection(params)`.
+   */
+  plan: <AppModel, Store extends RemoteModel, Value>(bound: BoundRemote<AppModel, Store>, model: AppModel, projection: Projection<AppModel, Value>, options?: PlanOptions) => ReadonlyArray<Requirement>;
+  /**
+   * The queries a projection needs run before its connections read: those the
+   * Model does not hold, or holds stale (every one under `force`).
+   */
+  planQueries: <AppModel, Store extends RemoteModel, Value>(bound: BoundRemote<AppModel, Store>, model: AppModel, projection: Projection<AppModel, Value>, options?: PlanOptions) => ReadonlyArray<QueryRef<string, unknown>>;
+  /**
+   * The store reads see: the base store under the pending optimistic layers.
+   * One store is shared by every read and plan of a Model whose remote state
+   * has not changed.
+   */
+  storeOf: <AppModel, Store extends RemoteModel>(bound: BoundRemote<AppModel, Store>, model: AppModel) => EntityStore;
+  /**
+   * The projection read against the server-derived store alone: the same
+   * requirements, planned the same way, with the pending optimistic layers and
+   * connection overlays left off. See the bound `Remote.confirmed`.
+   */
+  confirmed: <AppModel, Store extends RemoteModel, P extends Projection<AppModel, any>>(bound: BoundRemote<AppModel, Store>, projection: P) => P;
+  /**
+   * Executes the plan against the `RemoteClient` and returns a new store. Used
+   * for SSR route prefetch, hover prefetch, and tests. Never called during render.
+   * `policy` decides what a present field means (default cache-first); `now`
+   * is the clock it reads, so the planner itself stays pure and time-injected.
+   */
+  prefetch: <AppModel, Store extends RemoteModel, Value>(bound: BoundRemote<AppModel, Store, string>, model: AppModel, projection: Projection<AppModel, Value>, options?: ObserveOptions | undefined) => Effect.Effect<Readonly<Record<string, EntityEntry>>, RemoteProtocolError | RemoteReadError | RemoteUnauthenticated, RemoteClient>;
+  /**
+   * Marks what a read requires as due again: a projection, a Surface without
+   * params, one entry of the active record, or the whole record, each entry
+   * resolved for this Model as `subscriptions` resolves it. Called from
+   * `update`: every selected field the store holds reads `Refreshing`, and
+   * every loaded query connection is invalidated. Nothing is fetched here.
+   * The read entries `Data.subscriptions` derives refetch it, because a stale
+   * field or connection is planned again under every policy, so a refresh never
+   * sends a request beside the entry already observing the same data.
+   *
+   * A refreshed connection's page replaces its pages, so items the server removed
+   * or reordered follow it; pages loaded past the first are dropped and paged
+   * again with `next`/`previous`. The read entries restart, so a read or query
+   * sent before the refresh is not applied after it.
+   *
+   * It is also how a failed read is retried: nothing that failed is asked
+   * again on its own, so its read stays `Failed` until this asks. A failed
+   * read with nothing to show reads `Loading` from here, and `Failed` again if
+   * the retry fails. `{ failed: true }` asks again only what failed, which is
+   * what a "Try again" means: what loaded keeps its value and its pages.
+   *
+   * The projection must be observed, which it is while it is on screen. Live
+   * subscriptions are left as they are. For data nothing observes (SSR, tests),
+   * use `Remote.prefetch` with `RemotePolicy.networkOnly`. Refreshing what is
+   * already being refreshed returns the same Model.
+   */
+  refresh: <AppModel, Store extends RemoteModel>(bound: BoundRemote<AppModel, Store>, model: AppModel, target: RefreshTarget<AppModel>, options?: RefreshOptions) => AppModel;
+  /**
+   * Forgets everything the server told this Model: values, tombstones,
+   * unavailable fields, connections, live cursors, failures. What is known is
+   * known for a principal, and this is the one boundary for a login, a logout
+   * or a switch of organization: called from `update`, it performs no I/O, and
+   * every active Surface's read and live entries restart, so the screen asks
+   * again as whoever the client now is. A read or stream begun before is
+   * interrupted rather than landing after. A mutation in flight is treated as
+   * applied: its answer writes nothing here.
+   */
+  forget: <AppModel, Store extends RemoteModel>(bound: BoundRemote<AppModel, Store>, model: AppModel) => AppModel;
+  /**
+   * Writes a read result into the store, recording each field's applied window.
+   * `requests` are the planned requirements the result answers.
+   */
+  writeRead: typeof writeRead;
+  /**
+   * Adapts an Effect RPC client for `RemoteRpc` to `RemoteClient`, so an
+   * application provides the transport's RPC layer instead of writing the
+   * `LiveChange`-to-`LiveEvent` mapping by hand. The client `RpcClient.make`
+   * builds is accepted as it is: when its transport fails (`RpcClientError`),
+   * the call fails with its own Remote error, which the application shows and
+   * retries like any failed read, query, mutation or live stream.
+   */
+  /**
+   * Remote's client over any way of sending one JSON request and receiving its
+   * answer, for `clientLayer`: a worker, a server in the page. `RemoteServer.answer`
+   * is the other end.
+   */
+  json: typeof json;
+  /**
+   * Remote's client over HTTP, for `clientLayer`: each call a `POST` of the JSON
+   * request to `url`. `headers` is read per request (a session token, say).
+   */
+  http: typeof http;
+  /**
+   * Remote's client over HTTP with live, for `clientLayer`: reads, queries,
+   * and mutations as `http` sends them, live requirements as one `POST`
+   * answered with a `text/event-stream` of changes.
+   * `foldkit-remote-server/fetch` is the other end.
+   */
+  httpWithLive: typeof httpWithLive;
+  clientLayer: <R = never>(client: RemoteRpcClient<R, RpcClientError.RpcClientError | RemoteUnreachable>, options?: CoalesceOptions) => Layer.Layer<RemoteClient, never, R>;
+  /**
+   * Wraps a `RemoteClient` layer so its reads coalesce: requirements issued
+   * together become one batch, and a requirement already in flight is joined.
+   * `Remote.clientLayer` applies this; use it on a hand-written client.
+   */
+  coalesced: typeof coalescedLayer;
+  /**
+   * A Foldkit Subscription entry that keeps the cache to what the active
+   * Surfaces reach. `projections` are the ones the application observes (the
+   * same it passes to `Remote.observe`), `connections` the query connections
+   * it shows; anything else is collected once the roots have been stable for
+   * `grace`, so a route transition that comes straight back does not thrash.
+   */
+  retain: <AppModel, Message = RemoteMessage>(projections: ReadonlyArray<Projection<AppModel, unknown>>, toMessage?: (message: RemoteMessage) => Message, options?: RetainOptions) => EntryWithoutKeepAlive<AppModel, Message, RetentionRoots, never>;
+  /**
+   * Runs a `Query` through `RemoteClient`, encoding its input from the ref.
+   * Pair the result with `Remote.queryMessage` to merge the page into the Model.
+   * With `select`, the server also returns the selected fields of the page's
+   * items, so one response populates both the connection and the store.
+   */
+  query: <Name extends string, Input>(ref: QueryRef<Name, Input>, select?: RelationRequirement | undefined) => Effect.Effect<{
+    readonly edges: readonly {
+      readonly entity: string;
+      readonly id: string;
+      readonly key: string;
+    }[];
+    readonly start: {
+      readonly _tag: "Terminal";
+    } | {
+      readonly _tag: "Cursor";
+      readonly cursor: string;
+    } | {
+      readonly _tag: "Unknown";
+    };
+    readonly end: {
+      readonly _tag: "Terminal";
+    } | {
+      readonly _tag: "Cursor";
+      readonly cursor: string;
+    } | {
+      readonly _tag: "Unknown";
+    };
+    readonly entities?: readonly {
+      readonly entity: string;
+      readonly id: string;
+      readonly values: {
+        readonly [x: string]: unknown;
+      };
+    }[] | undefined;
+    readonly settled?: readonly {
+      readonly entity: string;
+      readonly id: string;
+      readonly fields: readonly string[];
+    }[] | undefined;
+  }, RemoteQueryError | RemoteUnauthenticated, RemoteClient>;
+  /** The `RemoteMessage` that merges a query page into its connection. */
+  queryMessage: <Name extends string, Input>(ref: QueryRef<Name, Input>, result: Schema.Schema.Type<typeof QueryResult>, select?: RelationRequirement | undefined, now?: number | undefined) => RemoteMessage;
+  /** A pure, serializable view of the whole cache. */
+  inspect: typeof inspectRemote;
+  /** A pure, serializable view of one entity, or `undefined` if unknown. */
+  inspectEntity: typeof inspectEntity;
+  /**
+   * Runs a mutation through `RemoteClient`, decoding its typed Output and
+   * returning the result's normalized patches so the caller can reconcile them
+   * through `updateRemote`'s `MutationSucceeded` (or `Remote.mutateInto`).
+   */
+  mutate: <Name extends string, Input, Output>(mutation: MutationDescriptor<Name, Input, Output, unknown>, input: Input, requestId: string, options?: {
+    readonly keys?: ReadonlyArray<string> | undefined;
+    readonly operation?: string | undefined;
+    readonly shown?: ReadonlyArray<RelationRequirement> | undefined;
+    readonly now?: number | undefined;
+  } | undefined) => Effect.Effect<{
+    output: Output;
+    entities: readonly {
+      readonly entity: string;
+      readonly id: string;
+      readonly values: {
+        readonly [x: string]: unknown;
+      };
+    }[];
+    connections: ConnectionChange[];
+    deleted: readonly {
+      readonly entity: string;
+      readonly id: string;
+    }[];
+    read: {
+      readonly requests: readonly Requirement[];
+      readonly result: {
+        readonly entities: readonly {
+          readonly entity: string;
+          readonly id: string;
+          readonly values: {
+            readonly [x: string]: unknown;
+          };
+        }[];
+        readonly settled: readonly {
+          readonly entity: string;
+          readonly id: string;
+          readonly fields: readonly string[];
+        }[];
+      };
+    } | undefined;
+  }, RemoteForbidden | RemoteMutationError | RemoteUnauthenticated | RemoteUnreachable, RemoteClient>;
+  /**
+   * Reads the clock where the reader acts, for `Data.mutate`'s `now`: a
+   * Command that yields `toMessage(now)`, the time in milliseconds since the
+   * epoch. It reads Effect's `Clock`, so a test pins it, and `Trace.run`
+   * runs it at the trace's time. Chirp's compose box answers a submit with
+   * `Remote.now(now => Message.ClockedPost({ post, now }))`, and
+   * `ClockedPost` starts the write.
+   */
+  now: <M>(toMessage: (now: number) => M) => {
+    readonly name: 'Remote.now';
+    readonly effect: Effect.Effect<M>;
+  };
+  /**
+   * Runs a mutation and reconciles its patches into a `RemoteModel` in one step,
+   * returning the new model alongside the typed Output. The model-level form of
+   * `MutationStarted` → `RemoteClient.mutate` → `MutationSucceeded`; in an
+   * application the three are `update` (with `optimistic`), a Command, and the
+   * Message the Command returns, so the optimistic operations show meanwhile.
+   */
+  mutateInto: <Name extends string, Input, Output, AppModel, Store extends RemoteModel>(bound: BoundRemote<AppModel, Store, string>, model: AppModel, mutation: MutationDescriptor<Name, Input, Output, unknown>, input: Input, requestId: string, options?: MutateOptions | undefined) => Effect.Effect<{
+    output: Output;
+    model: AppModel;
+  }, RemoteForbidden | RemoteMutationError | RemoteUnauthenticated | RemoteUnreachable, RemoteClient>;
+  /**
+   * A Foldkit Subscription entry that plans a Surface's missing fields from the
+   * Model and fetches them through `RemoteClient`, emitting a `RemoteMessage`
+   * per outcome. Wrap it in an application Message (`toMessage`) and reduce it
+   * with the domain's `update`. Under a refreshing `policy` the entry first
+   * emits `RefreshStarted`, so the fields being refetched read as `Refreshing`
+   * while the request is pending.
+   */
+  observe: <AppModel, Store extends RemoteModel, Names extends string, Model, SurfaceMessage, Params, Message = RemoteMessage>(bound: BoundRemote<AppModel, Store, Names>, surface: Surface<AppModel, Model, SurfaceMessage, Params>, params: Params, toMessage?: (message: RemoteMessage) => Message, options?: ObserveOptions) => EntryWithoutKeepAlive<AppModel, Message, ReadDependencies, RemoteClient>;
+  /**
+   * A Foldkit Subscription entry that consumes the live stream for a Surface's
+   * requirements, emitting a `LiveReceived` per event and a `ReadFailed`
+   * carrying its `stream` when the stream breaks (including
+   * `ResumeUnavailable`). That records a gap on the stream rather than a failed
+   * read, since nothing was being read, and restarts the entry after a
+   * backoff; the restart refetches what it covers. The resume cursor is read
+   * from `RemoteModel.live`, so the application tracks no cursor of its own.
+   */
+  live: <AppModel, Store extends RemoteModel, Names extends string, Model, SurfaceMessage, Params, Message = RemoteMessage>(bound: BoundRemote<AppModel, Store, Names>, surface: Surface<AppModel, Model, SurfaceMessage, Params>, params: Params, toMessage?: (message: RemoteMessage) => Message, options?: LiveOptions) => EntryWithoutKeepAlive<AppModel, Message, LiveDependencies, RemoteClient>;
+};
+export { AnswerRead, AnySchema, BatchRead, Belongs, Boundary, BoundaryCounts, CoalesceOptions, Connection, ConnectionApplied, ConnectionChange, ConnectionChangeSchema, ConnectionIdentity, ConnectionOverlay, ConnectionRequirement, ConnectionRoot, ConnectionSpec, Cursor, Deadline, Denied, DerivedBy, type Diagnostic, Diagnostics, Edge, EdgeRef, Entity, EntityApplied, EntityDescriptor, EntityEntry, EntityKey, EntityLayer, EntityPatch, EntityRef, EntityStore, EntityWrite, ExplainedDependencies, Failures, FieldsFrom, Freshness, IDENTITY_SEPARATOR, Judged, Live, LiveChange, LiveCursor, LiveEdge, LiveEvent, type LiveFetchOptions, LiveInsertion, LiveOutcome, LivePolicy, type LiveRefused, LiveRequirement, LiveState, MAX_FIELDS_PER_REQUEST, MAX_LIVE_QUERIES, MAX_RELATION_DEPTH, MAX_SHOWN_ENTITIES, Matched, MatchingOptions, MergePolicy, Mutate, Mutation, MutationAnswer, MutationDescriptor, MutationRequest, MutationResult, MutationState, MutationStatus, NormalizedEntity, NormalizedPatch, OperationId, OptimisticOperation, OptimisticState, type OutboxItem, OutboxItemState, type OutboxStatus, type OutboxUnreadable, type OutboxUnsaved, Page, PageSize, PatchValues, PendingDelete, PendingPatch, PlacedOrder, PlanFreshness, PlanOptions, type PredictionMismatch, PredictionPart, Query, QueryDescriptor, QueryEdge, QueryExplanation, QueryInputs, QueryRef, QueryRequest, QueryResult, QueryRpc, QueryRun, QueryWindow, RELATION_ALIAS, REMOTE_CACHE_VERSION, REMOTE_PROTOCOL_VERSION, Read, ReadBatch, ReadBatchResult, ReadRequest, type ReadStep, ReadWhy, Reconciled, RefKey, RefPage, RefPageValue, RefParts, RefreshState, Refusal, RefusalOfWrite, RelationAnnotation, RelationEntityAnnotation, RelationKind, RelationRequest, RelationRequirement, RelationShape, RemoteClient, RemoteConnections, RemoteData, type RemoteDiagnostic, RemoteError, RemoteForbidden, RemoteInspection, RemoteJsonAnswer, RemoteJsonClient, RemoteJsonRequest, type RemoteJsonSend, RemoteLiveError, RemoteLiveRefused, RemoteMessage, RemoteMessageInput, RemoteMessageTag, RemoteModel, RemoteMutationError, RemotePersistence, RemotePolicy, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteRequirements, type RemoteResumePart, RemoteRpc, RemoteRpcClient, RemoteUnauthenticated, RemoteUnreachable, type ReportDiagnostic, Requirement, ResultOf, Retained, RetentionRoots, type RetryOptions, RowPlace, SchemaOrFields, Segment, Selection, SelectionOf, SelectionValue, SelectionValueOf, SettledFields, ShownBy, ShownSlice, Snapshot, SnapshotOptions, StartedWrite, StreamHealth, TypeOf, Why, WhyTerm, WindowSchema, WireBoundary, type WriteUnheard, addLayer, addOverlay, aliasedField, applyConnectionEvent, applyEntityEvent, askAgain, assemble, beginMutation, beginOptimistic, belongsEncoded, brokenByWrite, classifyLive, clearStale, coalesceQueries, coalesceReads, coalescedLayer, connectionChangeOf, connectionIdentity, connectionsOf, cursor, deadlineOf, departedLimit, derivedOfWrite, dismissQueued, edge, emptyConnection, emptyLiveState, emptyMutationState, emptyOptimistic, emptyRefresh, emptyStore, entityKey, entry, failMutation, failureOf, fieldMark, forbiddenByWrite, forgetFailure, forgetRemote, gc, goneIn, hasField, hasNext, hasPrevious, heldOnlyByRequests, httpWithLive, initialRemoteModel, inspectEntity, inspectRemote, invalidateConnections, isFieldFailed, isFieldStale, isFieldUnavailable, isGapped, isLoading, isLoadingThrough, isQueryLoading, isRefPage, isRemoteMessage, isTombstone, items, liveEventOf, liveFetch, liveHasNext, liveHasPrevious, markStale, matching, merge, mintOperation, missingFields, mutateRemote, mutationStatus, noFailures, onlyOverlaid, optimisticOfWrite, overlaysOf, pageSchema, patchOfWrite, placeIn, plan, plannedStore, predictionOfWrite, pruneOverlays, queryIdentity, reachable, readField, recentRoots, reconcileMutation, refParts, refreshIsInFlight, refreshedAt, refsIn, relationAlias, relationOf, relationShape, remoteDataSchema, remoteError, remoteErrorSchema, remoteMessageCases, remoteMessageSchema, remoteModelSchema, remove, removeLayer, removeOverlay, requirementKey, requirementsOf, resolvedPatches, retentionRootsSchema, schemaOf, segment, setStale, setUnavailable, settleFailure, settleSuccess, settledLater, stableStringify, targetsOf, terminal, tombstone, unavailableOf, unknown, updateRemote, visibleItems, visibleStore, windowGrowthKey, windowKey, withRefreshRequested, writeEntities, writeEntity, writeRead };
+//# sourceMappingURL=index.d.ts.map