foldkit-remote 0.11.0 → 0.13.0

package/dist/index-Dh4qdXfE.d.mts

@@ -0,0 +1,3531 @@
+import { Context, Duration, Effect, Layer, Option, Result, Schema, Stream } from "effect";
+import * as Domain from "foldkit-entity";
+import { AnyEntity, AnyQuery, Dependencies, InputExpr, Query } from "foldkit-entity";
+import { Command } from "foldkit/command";
+import { EntryWithoutKeepAlive } from "foldkit/subscription";
+import { ActiveSurface, Contract, Invalid, Metadata, ModelRef, Projection, Surface, Wiring } from "foldkit-surface";
+import { Rpc, RpcClientError, RpcGroup } from "effect/rpc";
+import { KeyValueStore } from "effect/persistence";
+import * as Update from "foldkit/update";
+//#region ../metadata/src/index.d.ts
+/** Marks a `Metadata` value. Its entries are private to this module. */
+declare const MetadataTypeId: unique symbol;
+type MetadataTypeId = typeof MetadataTypeId;
+/**
+ * Declarative facts an interpreter attaches to a node it does not own, such as
+ * the server data a Remote selection needs. The carrier holds and combines
+ * them without knowing what they mean; a package reads only the key it owns.
+ *
+ * Opaque: only a key's `of` and `Metadata.combine` make one, so entries cannot
+ * be forged past a key's type or `merge`, and they are frozen.
+ */
+interface Metadata$1 {
+  readonly [MetadataTypeId]: MetadataTypeId;
+}
+/**
+ * An interpreter's typed slot in `Metadata`. Lookup is by the key object, never
+ * its `name`, so two packages cannot collide by choosing the same string.
+ */
+interface MetadataKey<A> {
+  /** For tooling output only. */
+  readonly name: string;
+  /** Normalizes the entries gathered from combined values, e.g. unioning duplicates. */
+  readonly merge: (values: ReadonlyArray<A>) => ReadonlyArray<A>;
+  /** One line per entry for tooling output. */
+  readonly summarize: (value: A) => string;
+  readonly of: (...values: ReadonlyArray<A>) => Metadata$1;
+  readonly get: (metadata: Metadata$1) => ReadonlyArray<A>;
+}
+/** One key's entries as serializable text, named by the key. */
+interface MetadataSummary {
+  readonly name: string;
+  readonly entries: readonly string[];
+}
+declare const Metadata$1: {
+  /**
+   * Declares an interpreter's slot. Call once per package, at module level:
+   * entries are found by the key object, so two copies of a package (a
+   * duplicated install, a reloaded module) do not see each other's entries.
+   */
+  key: <A>(name: string, options: {
+    readonly merge: (values: ReadonlyArray<A>) => ReadonlyArray<A>;
+    readonly summarize: (value: A) => string;
+  }) => MetadataKey<A>;
+  empty: Metadata$1;
+  /** True only for a value this module made; a copy or a hand-built brand is not one. */
+  is: (value: unknown) => value is Metadata$1;
+  /** Gathers every part's entries and runs each key's `merge` over its group. */
+  combine: (parts: ReadonlyArray<Metadata$1>) => Metadata$1;
+  summarize: (metadata: Metadata$1) => readonly MetadataSummary[];
+};
+//#endregion
+//#region src/connection.d.ts
+interface EdgeRef {
+  readonly entity: string;
+  readonly id: string;
+}
+/** `key` is the edge identity used for de-duplication. */
+interface Edge {
+  readonly key: string;
+  readonly ref: EdgeRef;
+}
+declare const edge: (ref: EdgeRef, key?: string) => Edge;
+type Cursor = string;
+type Boundary = {
+  readonly _tag: 'Terminal';
+} | {
+  readonly _tag: 'Cursor';
+  readonly cursor: Cursor;
+} | {
+  readonly _tag: 'Unknown';
+};
+declare const terminal: Boundary;
+declare const unknown: Boundary;
+declare const cursor: (value: Cursor) => Boundary;
+interface Segment {
+  readonly edges: readonly Edge[];
+  readonly start: Boundary;
+  readonly end: Boundary;
+}
+interface Connection {
+  readonly segments: readonly Segment[];
+  readonly stale: boolean;
+}
+declare const emptyConnection: Connection;
+declare const segment: (edges: readonly Edge[], start: Boundary, end: Boundary) => Segment;
+/** Adds a page to the connection, joining contiguous or overlapping segments. */
+declare const merge: (current: Connection, page: Segment) => Connection;
+/** Visible edges, segment by segment. */
+declare const items: (connection: Connection) => ReadonlyArray<Edge>;
+/** There is more before the known region. Derived from boundaries, never row count. */
+declare const hasPrevious: (connection: Connection) => boolean;
+/** There is more after the known region. Derived from boundaries, never row count. */
+declare const hasNext: (connection: Connection) => boolean;
+/** A connection with more than one segment has an explicit unknown gap. */
+declare const isGapped: (connection: Connection) => boolean;
+//#endregion
+//#region src/remoteData.d.ts
+interface RemoteError {
+  readonly _tag: string;
+  readonly message: string;
+}
+type RemoteData<A> = {
+  readonly _tag: 'Initial';
+} | {
+  readonly _tag: 'Loading';
+} | {
+  readonly _tag: 'Ready';
+  readonly value: A;
+} | {
+  readonly _tag: 'Refreshing';
+  readonly value: A;
+} | {
+  readonly _tag: 'Failed';
+  readonly error: RemoteError;
+  readonly previous?: A;
+} | {
+  readonly _tag: 'NotFound';
+};
+/**
+ * What `RemoteData.render` tells the `data` branch about the value it is
+ * given: whether a newer answer is on its way, and whether this one is what
+ * was last known good before a read failed. It is one tag rather than two
+ * booleans because a value cannot be both at once, and a type that can say so
+ * invites a view to handle a state that never arrives.
+ */
+type Freshness = {
+  readonly _tag: 'Fresh';
+} | {
+  readonly _tag: 'Refreshing';
+} | {
+  readonly _tag: 'Stale';
+  readonly error: RemoteError;
+};
+declare const remoteErrorSchema: Schema.Struct<{
+  readonly _tag: Schema.String;
+  readonly message: Schema.String;
+}>;
+declare const remoteDataSchema: <A>(value: Schema.Schema<A>) => Schema.Codec<RemoteData<A>, unknown>;
+declare const RemoteData: {
+  /**
+   * The `RemoteData` schema for a value schema. Exposed so a `RemoteData` can
+   * be embedded in a hand-written Model schema, not only through `Remote.select`.
+   */
+  schema: <A>(value: Schema.Schema<A>) => Schema.Schema<RemoteData<A>>;
+  /**
+   * Whether the read has an answer: `Ready`, `Refreshing`, `Failed` or
+   * `NotFound`. `Initial` and `Loading` are still waiting for one.
+   */
+  answered: <A>(data: RemoteData<A>) => boolean;
+  /** Exhaustive: omitting a state is a compile error. */
+  match: <A, R>(data: RemoteData<A>, cases: {
+    readonly Initial: () => R;
+    readonly Loading: () => R;
+    readonly Ready: (value: A) => R;
+    readonly Refreshing: (value: A) => R;
+    readonly Failed: (error: RemoteError, previous: Option.Option<A>) => R;
+    readonly NotFound: () => R;
+  }) => R;
+  /**
+   * The view-oriented fold: the six states as the three things a view actually
+   * draws, under the policy that useful data stays on screen. A value that is
+   * being refetched, or that a later read failed to replace, still reaches
+   * `data` — with `freshness` saying which — instead of being replaced by a
+   * spinner or an error the reader cannot act on.
+   *
+   * ```ts
+   * RemoteData.render(model.user, {
+   *   loading: () => UserSkeleton(),
+   *   notFound: () => NoSuchUser(),
+   *   failed: error => ErrorView(error),
+   *   data: (user, freshness) => UserView({ user, dimmed: freshness._tag !== 'Fresh' }),
+   * })
+   * ```
+   *
+   * `notFound` is its own branch and not optional: a row the server answered
+   * for and does not have is neither loading nor a failure, and drawing it as
+   * either is a spinner that never ends or an error nobody can fix.
+   *
+   * This does not replace `match`, which is the exhaustive fold over the states
+   * themselves. Reach for `match` when the six states really do draw
+   * differently, and for this when they draw the usual three ways.
+   */
+  render: <A, R>(data: RemoteData<A>, cases: {
+    readonly loading: () => R;
+    readonly notFound: () => R;
+    readonly failed: (error: RemoteError) => R;
+    readonly data: (value: A, freshness: Freshness) => R;
+  }) => R;
+  map: <A, B>(data: RemoteData<A>, f: (value: A) => B) => RemoteData<B>;
+};
+//#endregion
+//#region src/store.d.ts
+type EntityKey = string;
+interface EntityEntry {
+  readonly values: Readonly<Record<string, unknown>>;
+  readonly present: ReadonlySet<string>;
+  /** Present fields whose value may be outdated (revalidation needed). */
+  readonly stale: ReadonlySet<string>;
+  /**
+   * Fields the server settled without a value: asked for, and answered without
+   * them, whatever the reason. Not planned again until a refresh asks; a later
+   * write of the field clears it.
+   */
+  readonly unavailable: ReadonlySet<string>;
+  /** The entity is known to be absent; a later write clears this. */
+  readonly tombstone: boolean;
+  /** Injected clock reading of the last write; never read from ambient state. */
+  readonly updatedAt: number;
+  /**
+   * The canonical window each present field was fetched with (`""` for none).
+   * A later request with a *known, different* window is planned as missing.
+   */
+  readonly windows: Readonly<Record<string, string>>;
+}
+type EntityStore = Readonly<Record<EntityKey, EntityEntry>>;
+/** The separator keeps an untrusted id from colliding with a prototype key. */
+declare const entityKey: (entity: string, id: string) => EntityKey;
+declare const emptyStore: EntityStore;
+interface EntityWrite {
+  readonly key: EntityKey;
+  readonly values: Readonly<Record<string, unknown>>;
+  /** The canonical window each written relation field was fetched with. */
+  readonly windows?: Readonly<Record<string, string>> | undefined;
+  /** When this write dates the entity, instead of the batch's `now`. */
+  readonly updatedAt?: number | undefined;
+}
+/**
+ * Merges known values into many entities, copying the store once. Every
+ * written field becomes present and non-stale; a tombstone is cleared because
+ * the entity is evidently not absent.
+ */
+declare const writeEntities: (store: EntityStore, writes: ReadonlyArray<EntityWrite>, now?: number) => EntityStore;
+/** `writeEntities` for one entity. */
+declare const writeEntity: (store: EntityStore, key: EntityKey, values: Readonly<Record<string, unknown>>, now?: number, windows?: Readonly<Record<string, string>>) => EntityStore;
+/**
+ * Marks present fields stale (`true`) or ends their staleness (`false`) across
+ * many entities, copying the store once. A field never present stays missing;
+ * an unknown entity is left alone.
+ */
+declare const setStale: (store: EntityStore, marks: ReadonlyArray<readonly [key: EntityKey, fields: Iterable<string>]>, stale: boolean) => EntityStore;
+/** Marks present fields stale; fields that were never present stay missing. */
+declare const markStale: (store: EntityStore, key: EntityKey, fields: Iterable<string>) => EntityStore;
+/** Ends a refresh that did not land: the fields are present again as they were. */
+declare const clearStale: (store: EntityStore, key: EntityKey, fields: Iterable<string>) => EntityStore;
+/**
+ * Records fields the server settled without a value. A present field is left
+ * as it is: the answer that settled it was not about the value it holds.
+ * `false` forgets the marks, which is how a refresh asks again.
+ */
+declare const setUnavailable: (store: EntityStore, marks: ReadonlyArray<readonly [key: EntityKey, fields: Iterable<string>]>, unavailable: boolean) => EntityStore;
+/** Whether the server settled this field without a value, and nothing has written it since. */
+declare const isFieldUnavailable: (store: EntityStore, key: EntityKey, field: string) => boolean;
+/** Records that the entity is known to be absent, so it is not refetched. */
+declare const tombstone: (store: EntityStore, key: EntityKey) => EntityStore;
+/** Forgets everything known about the entity, including a tombstone. */
+declare const remove: (store: EntityStore, key: EntityKey) => EntityStore;
+declare const entry: (store: EntityStore, key: EntityKey) => Option.Option<EntityEntry>;
+declare const isTombstone: (store: EntityStore, key: EntityKey) => boolean;
+/** A field is known only if it is present and not stale. */
+declare const hasField: (store: EntityStore, key: EntityKey, field: string) => boolean;
+/** A present field whose value may be outdated; absent fields are not stale. */
+declare const isFieldStale: (store: EntityStore, key: EntityKey, field: string) => boolean;
+/**
+ * Reads a present field, stale or not. Absence and a tombstone both yield
+ * `Option.none()`; a present `undefined`/`null` yields `Option.some`.
+ */
+declare const readField: (store: EntityStore, key: EntityKey, field: string) => Option.Option<unknown>;
+/**
+ * The fields the planner must fetch. A tombstone makes every field known
+ * (absent), so it returns an empty list and the entity is not refetched, and a
+ * field the server settled without a value is known the same way. A
+ * requested window that differs from the one a field was fetched with also
+ * marks it missing, but only when the stored window is known (never `""`), so a
+ * writer that does not record windows cannot cause a refetch loop.
+ */
+declare const missingFields: (store: EntityStore, key: EntityKey, fields: Iterable<string>, windows?: Readonly<Record<string, string>>) => ReadonlyArray<string>;
+//#endregion
+//#region src/mutation.d.ts
+interface NormalizedPatch {
+  readonly entity: string;
+  readonly id: string;
+  readonly values: Readonly<Record<string, unknown>>;
+}
+interface MutationState {
+  readonly pending: ReadonlySet<string>;
+  readonly applied: ReadonlySet<string>;
+  readonly failed: ReadonlySet<string>;
+  /** Why each request in `failed` failed, kept exactly as long as `failed` keeps its id. */
+  readonly errors: ReadonlyMap<string, RemoteError>;
+  /**
+   * How many mutations this model has started. A bound domain takes its next
+   * request id from here, so `update` stays pure and the id exists before the
+   * Command runs.
+   */
+  readonly sequence: number;
+}
+declare const emptyMutationState: MutationState;
+declare const beginMutation: (state: MutationState, requestId: string) => MutationState;
+declare const failMutation: (state: MutationState, requestId: string, error: RemoteError) => MutationState;
+/** What Remote knows of one mutation request, by the id `mutate` returned. */
+type MutationStatus =
+/** Never started here, or settled so long ago its id has left the window. */
+{
+  readonly _tag: 'Unknown';
+} | {
+  readonly _tag: 'Pending';
+} | {
+  readonly _tag: 'Applied';
+} | {
+  readonly _tag: 'Failed';
+  readonly error: RemoteError;
+};
+declare const mutationStatus: (state: MutationState, requestId: string) => MutationStatus;
+interface Reconciled {
+  readonly store: EntityStore;
+  readonly state: MutationState;
+}
+/** What a settled mutation wrote, as `MutationSucceeded` carries it. */
+interface MutationAnswer {
+  readonly entities: ReadonlyArray<NormalizedPatch>;
+  /** Entities the mutation deleted; each is tombstoned. */
+  readonly deleted?: ReadonlyArray<{
+    readonly entity: string;
+    readonly id: string;
+  }> | undefined;
+  /** Injected clock reading of the answer, which dates what it writes. */
+  readonly now: number;
+}
+/**
+ * Applies a mutation result once and marks the request settled. A second call
+ * with the same `requestId` (a retry, or a live event describing the same change)
+ * does not re-apply the entities, but still clears `pending`.
+ */
+declare const reconcileMutation: (store: EntityStore, state: MutationState, requestId: string, answer: MutationAnswer) => Reconciled;
+/** A mutation an application declares: its name and input/output codecs. */
+interface MutationDescriptor<Name extends string, Input, Output> {
+  readonly name: Name;
+  readonly Input: Schema.Codec<Input>;
+  readonly Output: Schema.Codec<Output>;
+}
+/** A codec, or the fields of a `Schema.Struct` where one is expected. */
+type SchemaOrFields = Schema.Codec<any, any, any, any> | Schema.Struct.Fields;
+/** The decoded type of a codec, or of the Struct the fields describe. */
+type TypeOf<S extends SchemaOrFields> = S extends Schema.Codec<infer T, any, any, any> ? T : S extends Schema.Struct.Fields ? Schema.Struct.Type<S> : never;
+/** The codec itself, or a `Schema.Struct` over the fields. */
+declare const schemaOf: <S extends SchemaOrFields>(shape: S) => Schema.Codec<TypeOf<S>>;
+declare const Mutation: {
+  /**
+   * Declares a mutation. `Input` and `Output` are codecs, or the fields of the
+   * `Schema.Struct` they would be (`{ id: ProjectId, name: Schema.String }`).
+   */
+  make: <const Name extends string, Input extends SchemaOrFields, Output extends SchemaOrFields>(name: Name, config: {
+    readonly Input: Input;
+    readonly Output: Output;
+  }) => MutationDescriptor<Name, TypeOf<Input>, TypeOf<Output>>;
+};
+//#endregion
+//#region src/query.d.ts
+type LiveInsertion = 'visible' | 'boundary' | 'invalidate' | 'ignore';
+interface LivePolicy {
+  readonly prepend?: LiveInsertion;
+  readonly append?: LiveInsertion;
+}
+interface ConnectionSpec<Entity extends string = string> {
+  readonly entity: Entity;
+  readonly edgeKey?: Schema.Schema<unknown>;
+  readonly live?: LivePolicy;
+}
+interface QueryWindow {
+  readonly first?: number | undefined;
+  readonly last?: number | undefined;
+  readonly after?: Cursor | undefined;
+  readonly before?: Cursor | undefined;
+}
+interface QueryRef<Name extends string, Input> {
+  readonly query: Name;
+  readonly input: Input;
+  /** The input codec, so a `QueryRef` can encode itself without its descriptor. */
+  readonly Input: Schema.Codec<Input>;
+  readonly window: QueryWindow;
+  /** Connection identity: descriptor + canonical input, excluding the window. */
+  readonly identity: string;
+}
+interface QueryDescriptor<Name extends string, Input, Result> {
+  readonly name: Name;
+  readonly Input: Schema.Codec<Input>;
+  readonly Result: Result;
+  readonly ref: (input: Input) => QueryRef<Name, Input>;
+  /**
+   * What the query means, when it was declared with `Query.define`: the rows it
+   * is about, as a value an interpreter can compile. A descriptor from
+   * `Query.make` has none — its meaning lives in whatever the server registered
+   * to answer it — and a source is free to answer either.
+   */
+  readonly body?: AnyQuery | undefined;
+}
+/**
+ * The inputs of a definition's body: one placeholder per key of `Input`, typed
+ * as that key's value. A body is built once, so these stand for what the query
+ * will be given rather than being it.
+ */
+type QueryInputs<Input> = { readonly [K in keyof Input & string]: InputExpr<Input[K]>; };
+/**
+ * What separates a query's name from its canonical encoded input in a
+ * connection identity.
+ *
+ * NUL, because `JSON.stringify` escapes it inside a string (`\u0000`) and a
+ * query name is a TypeScript identifier — so the first occurrence is always the
+ * boundary, and a name or an input value cannot forge one. Anything recovering
+ * the query from an identity splits here.
+ */
+declare const IDENTITY_SEPARATOR = "\0";
+/** Stable stringify: object keys sorted, undefined-valued keys dropped, so equal inputs encode equally. */
+declare const stableStringify: (value: unknown) => string;
+/**
+ * `Result: Project` (or anything with the entity's `name`, as `Query.connection`
+ * takes) means a connection over it; a `ConnectionSpec` names its `entity`
+ * instead and is the result as given.
+ */
+type ResultOf<Result> = Result extends {
+  readonly name: infer Entity extends string;
+} ? ConnectionSpec<Entity> : Result;
+/** A relational `Query` over one Entity, as `Query.define`'s body returns. */
+type RelationalQueryOf<E extends AnyEntity> = ReturnType<typeof Query.from<E>>;
+declare const Query$1: {
+  /** Declares the entity and options a query's result is a connection over. */
+  connection: <Entity extends string>(entity: {
+    readonly name: Entity;
+  }, options?: {
+    readonly edgeKey?: Schema.Schema<unknown>;
+    readonly live?: LivePolicy;
+  }) => ConnectionSpec<Entity>;
+  /**
+   * Declares a query. `Input` is a codec or the fields of the `Schema.Struct` it
+   * would be; `Result` is a `Query.connection(...)`, or the entity the result is
+   * a connection over.
+   */
+  make: <const Name extends string, Input extends SchemaOrFields, Result>(name: Name, config: {
+    readonly Input: Input;
+    readonly Result: Result;
+  }) => QueryDescriptor<Name, TypeOf<Input>, ResultOf<Result>>;
+  /**
+   * Declares a query by what it means. The body is built once, here, and the
+   * `input` it is given holds placeholders rather than values — there is
+   * nothing yet to branch on, so a condition that depends on what was passed is
+   * a comparison over the placeholder:
+   *
+   * ```ts
+   * const PostsBySlug = Query.define('PostsBySlug', { slug: Schema.String }, ({ input }) =>
+   *   Query.from(Post).pipe(
+   *     Query.where(Expr.eq(Post.fields.slug, input.slug)),
+   *     Query.orderBy(Order.asc(Post.fields.id)),
+   *   ),
+   * )
+   * ```
+   *
+   * What comes back is an ordinary `QueryDescriptor` — the same name, `Input`,
+   * `ref` and connection identity `Query.make` gives — carrying its `body`
+   * besides. A server can compile that body instead of being told the same
+   * thing again in its own dialect, and one that would rather answer the query
+   * its own way still can.
+   *
+   * The result is a connection over the Entity the body reads, so it is not
+   * named twice.
+   */
+  define: <const Name extends string, Input extends SchemaOrFields, E extends AnyEntity>(name: Name, Input: Input, body: (context: {
+    readonly input: QueryInputs<TypeOf<Input>>;
+  }) => RelationalQueryOf<E>, options?: {
+    readonly edgeKey?: Schema.Schema<unknown>;
+    readonly live?: LivePolicy;
+  }) => QueryDescriptor<Name, TypeOf<Input>, ConnectionSpec<E["name"]>>;
+  first: (count: number) => <R extends QueryRef<string, unknown>>(ref: R) => R;
+  last: (count: number) => <R extends QueryRef<string, unknown>>(ref: R) => R;
+  after: (cursor: Cursor) => <R extends QueryRef<string, unknown>>(ref: R) => R;
+  before: (cursor: Cursor) => <R extends QueryRef<string, unknown>>(ref: R) => R;
+  from: <E extends AnyEntity>(entity: E) => Query<E>;
+  where: (...predicates: ReadonlyArray<import("foldkit-entity").Predicate>) => <E extends AnyEntity>(self: Query<E>) => Query<E>;
+  orderBy: (...terms: ReadonlyArray<import("foldkit-entity").OrderTerm>) => <E extends AnyEntity>(self: Query<E>) => Query<E>;
+  dependencies: (self: AnyQuery) => import("foldkit-entity").Dependencies;
+  unsupported: (self: AnyQuery, supported: ReadonlyArray<import("foldkit-entity").Operation>) => ReadonlyArray<import("foldkit-entity").Operation>;
+  show: (self: AnyQuery) => string;
+};
+//#endregion
+//#region src/requirement.d.ts
+/**
+ * The slice required of an entity. `windows` carries a pagination window per
+ * relation field, and `relations` the slice required of each relation's
+ * target, so one requirement describes a whole selection graph.
+ */
+interface RelationRequirement {
+  readonly entity: string;
+  readonly fields: readonly string[];
+  readonly windows?: Readonly<Record<string, QueryWindow>> | undefined;
+  readonly relations?: Readonly<Record<string, RelationRequirement>> | undefined;
+}
+interface Requirement extends RelationRequirement {
+  readonly id: string;
+  /** The projection also subscribes to changes of this entity (`Data.live`). */
+  readonly live?: boolean | undefined;
+}
+/**
+ * A query connection a projection reads: the page it first asks for and the
+ * slice it selects of each item. `identity` is the connection's (query plus
+ * canonical input, excluding the window).
+ */
+interface ConnectionRequirement {
+  readonly identity: string;
+  readonly window: QueryWindow;
+  readonly select: RelationRequirement;
+}
+/**
+ * Merges connection requirements for the same connection and window into one,
+ * unioning what they select of each item; the first keeps its other properties.
+ */
+declare function mergeConnections(connections: readonly ConnectionRequirement[]): readonly ConnectionRequirement[];
+/** Unions two relation slices for the same target: fields, windows, and nested relations. */
+declare function mergeRelation(current: RelationRequirement, next: RelationRequirement): RelationRequirement;
+/** Unions requirements for the same entity + id, dropping duplicate fields. */
+declare function mergeRequirements(requirements: readonly Requirement[]): readonly Requirement[];
+/**
+ * Requirement helpers, for the packages that plan and serve requirements.
+ * `merge` unions same-entity+id requirements; `mergeRelation` unions two
+ * slices of one target (fields, windows, nested relations).
+ */
+declare const Requirement: {
+  merge: typeof mergeRequirements;
+  mergeRelation: typeof mergeRelation;
+  mergeConnections: typeof mergeConnections;
+};
+/** Remote's entity requirements on a Projection, unioned per entity and id as nodes compose. */
+declare const RemoteRequirements: MetadataKey<Requirement>;
+/** Remote's query connections on a Projection, unioned per connection and window. */
+declare const RemoteConnections: MetadataKey<ConnectionRequirement>;
+/** The entity requirements a Projection carries. */
+declare const requirementsOf: (projection: {
+  readonly metadata: Metadata;
+}) => ReadonlyArray<Requirement>;
+/** The query connections a Projection carries. */
+declare const connectionsOf: (projection: {
+  readonly metadata: Metadata;
+}) => ReadonlyArray<ConnectionRequirement>;
+//#endregion
+//#region src/optimistic.d.ts
+interface EntityLayer {
+  readonly id: string;
+  readonly patches: ReadonlyArray<NormalizedPatch>;
+}
+/**
+ * Edges placed outside a connection's server-known region (`prepend`,
+ * `append`) or hidden from it (`remove`), owned by the request or live event
+ * that produced them.
+ */
+interface ConnectionOverlay {
+  readonly id: string;
+  readonly connection: string;
+  readonly edges: ReadonlyArray<Edge>;
+  readonly position: 'prepend' | 'append' | 'remove';
+}
+/** A connection change a request makes optimistically or a mutation result confirms. */
+type ConnectionChange = {
+  readonly _tag: 'Insert';
+  readonly connection: string;
+  readonly position: 'prepend' | 'append';
+  readonly edge: Edge;
+} | {
+  readonly _tag: 'Remove';
+  readonly connection: string;
+  readonly edge: Edge;
+};
+/** What a request changes before the server answers: entity patches and connection changes. */
+type OptimisticOperation = NormalizedPatch | ConnectionChange;
+/** A connection, by identity string or by anything that carries one (a `QueryRef`). */
+type ConnectionIdentity = string | {
+  readonly identity: string;
+};
+declare const connectionIdentity: (connection: ConnectionIdentity) => string;
+/**
+ * Constructors for connection changes: what a request shows optimistically
+ * (`MutateOptions.optimistic`) and what a mutation source reports it made
+ * (`MutationOutcome.connections`).
+ */
+declare const ConnectionChange: {
+  /** Show `ref` at the front of the connection until the request settles. */
+  prepend: (connection: ConnectionIdentity, ref: {
+    readonly entity: string;
+    readonly id: string;
+  }) => ConnectionChange;
+  /** Show `ref` at the end of the connection until the request settles. */
+  append: (connection: ConnectionIdentity, ref: {
+    readonly entity: string;
+    readonly id: string;
+  }) => ConnectionChange;
+  /** Hide `ref` from the connection until the request settles. */
+  remove: (connection: ConnectionIdentity, ref: {
+    readonly entity: string;
+    readonly id: string;
+  }) => ConnectionChange;
+};
+/**
+ * Applies a request's operations: its patches become one layer and its
+ * connection changes become overlays, all owned by `requestId` so settling
+ * removes every one of them together.
+ */
+declare const beginOptimistic: (optimistic: OptimisticState, requestId: string, operations: ReadonlyArray<OptimisticOperation>) => OptimisticState;
+/** Pending entity layers and connection overlays over the base store. */
+interface OptimisticState {
+  readonly layers: ReadonlyArray<EntityLayer>;
+  readonly overlays: ReadonlyArray<ConnectionOverlay>;
+}
+declare const emptyOptimistic: OptimisticState;
+declare const addLayer: (optimistic: OptimisticState, layer: EntityLayer) => OptimisticState;
+declare const removeLayer: (optimistic: OptimisticState, id: string) => OptimisticState;
+declare const addOverlay: (optimistic: OptimisticState, overlay: ConnectionOverlay) => OptimisticState;
+declare const removeOverlay: (optimistic: OptimisticState, id: string) => OptimisticState;
+/**
+ * Base store with every layer applied in order. Later layers win. A patch is
+ * not news from the server, so it keeps the date of the value under it; an
+ * entity only a request holds (a temporary id) is not the server's to age, and
+ * is dated `Infinity`, so freshness never plans or times it.
+ */
+declare const visibleStore: (base: EntityStore, optimistic: OptimisticState) => EntityStore;
+/**
+ * A fresh page is newer than any settled overlay it covers: an edge the page
+ * carries no longer needs an insert overlay, and a `remove` overlay hiding it
+ * is stale (the server says it is back). A pending request's overlays are
+ * left alone; they settle with the request.
+ */
+declare const pruneOverlays: (optimistic: OptimisticState, connection: string, covered: ReadonlySet<string>, pending: ReadonlySet<string>) => OptimisticState;
+/**
+ * Applies a result idempotently and releases the request's layer and overlays:
+ * a later layer re-wins on rebase. Confirmed connection changes are recorded
+ * once per request, as overlays the request no longer owns.
+ */
+declare const settleSuccess: (base: EntityStore, optimistic: OptimisticState, state: MutationState, requestId: string, answer: MutationAnswer & {
+  /** Connection changes the server confirmed; they replace the request's own. */
+  readonly connections?: ReadonlyArray<ConnectionChange> | undefined;
+}) => {
+  readonly store: EntityStore;
+  readonly state: MutationState;
+  readonly optimistic: OptimisticState;
+};
+/** A failed request's layer and overlays are dropped; the base was never mutated. */
+declare const settleFailure: (optimistic: OptimisticState, requestId: string) => OptimisticState;
+/**
+ * Visible edges for one connection: applicable overlays are placed outside the
+ * server-known segments and de-duplicated by edge identity (across overlays too),
+ * so a pending insert never corrupts server-known ordering; a `remove` overlay
+ * hides its edges wherever they are, and so does a tombstone on the edge's
+ * target when `store` is given. A later prepend lands before an earlier one, a
+ * later append after, so pending inserts read in the order they were made.
+ * Boundaries still come from the connection's segments.
+ */
+declare const visibleItems: (connection: Connection, connectionId: string, overlays: ReadonlyArray<ConnectionOverlay>, store?: EntityStore) => ReadonlyArray<Edge>;
+//#endregion
+//#region src/live.d.ts
+type LiveCursor = number;
+type LiveEvent = {
+  readonly _tag: 'EntityPatched';
+  readonly ref: EdgeRef;
+  readonly values: Readonly<Record<string, unknown>>;
+  readonly changed: ReadonlyArray<string>;
+  readonly cursor: LiveCursor;
+} | {
+  readonly _tag: 'EntityDeleted';
+  readonly ref: EdgeRef;
+  readonly cursor: LiveCursor;
+} | {
+  readonly _tag: 'ConnectionInsert';
+  readonly connection: string;
+  readonly position: 'prepend' | 'append';
+  readonly edge: Edge;
+  readonly cursor: LiveCursor;
+} | {
+  readonly _tag: 'ConnectionRemove';
+  readonly connection: string;
+  readonly edge: Edge;
+  readonly cursor: LiveCursor;
+} | {
+  readonly _tag: 'ConnectionInvalidate';
+  readonly connection: string;
+  readonly cursor: LiveCursor;
+};
+interface BoundaryCounts {
+  readonly before: number;
+  readonly after: number;
+}
+interface LiveState {
+  /** Last applied cursor for this stream. */
+  readonly cursor: LiveCursor;
+  /** Edges recorded outside the loaded boundary, not visible in `items`. */
+  readonly boundary: Readonly<Record<string, BoundaryCounts>>;
+}
+declare const emptyLiveState: LiveState;
+type LiveOutcome = 'applied' | 'duplicate' | 'gap';
+/**
+ * Ordering per stream: at most the next cursor; ahead is a gap. Cursor `0` means
+ * "no baseline yet" (cursors are 1-based), so the first event of a stream is
+ * accepted whatever its cursor — otherwise a stream not starting at 1 would be a
+ * spurious gap.
+ */
+declare const classifyLive: (state: LiveState, cursor: LiveCursor) => LiveOutcome;
+interface EntityApplied {
+  readonly state: LiveState;
+  readonly store: EntityStore;
+  readonly outcome: LiveOutcome;
+}
+declare const applyEntityEvent: (state: LiveState, store: EntityStore, event: Extract<LiveEvent, {
+  _tag: "EntityPatched" | "EntityDeleted";
+}>, now?: number) => EntityApplied;
+interface ConnectionApplied {
+  readonly state: LiveState;
+  readonly optimistic: OptimisticState;
+  readonly outcome: LiveOutcome;
+  /**
+   * A connection the event says to refetch. Reported rather than recorded here,
+   * because staleness lives on the connection in the Model — which is what the
+   * planner and every read consult. It used to be written into a set on this
+   * live state that nothing read, so an invalidating event did nothing at all.
+   */
+  readonly invalidated?: string | undefined;
+}
+declare const applyConnectionEvent: (state: LiveState, optimistic: OptimisticState, event: Extract<LiveEvent, {
+  _tag: "ConnectionInsert" | "ConnectionRemove" | "ConnectionInvalidate";
+}>, policy?: LivePolicy) => ConnectionApplied;
+/** `hasPrevious` accounting for edges recorded outside the loaded boundary. */
+declare const liveHasPrevious: (connection: Connection, state: LiveState, connectionId: string) => boolean;
+/** `hasNext` accounting for edges recorded outside the loaded boundary. */
+declare const liveHasNext: (connection: Connection, state: LiveState, connectionId: string) => boolean;
+//#endregion
+//#region src/retain.d.ts
+/** A connection to keep: its identity, and what a page of it selects of each item, if a projection reads it. */
+interface ConnectionRoot {
+  readonly identity: string;
+  readonly select?: RelationRequirement | undefined;
+}
+interface RetentionRoots {
+  readonly requirements: ReadonlyArray<Requirement>;
+  /** Connections (`QueryRef.identity`) to keep, with their edges' targets and what `select` reaches through them. */
+  readonly connections: ReadonlyArray<ConnectionRoot>;
+}
+interface Retained {
+  readonly entities: EntityStore;
+  readonly connections: Readonly<Record<string, Connection>>;
+  readonly optimistic: OptimisticState;
+}
+/**
+ * The entity keys the roots reach: each root entity, the targets its retained
+ * fields refer to, and recursively the targets a nested relation selects.
+ */
+declare const reachable: (store: EntityStore, roots: RetentionRoots, connections: Readonly<Record<string, Connection>>, optimistic: OptimisticState, pending: ReadonlySet<string>) => ReadonlySet<EntityKey>;
+/**
+ * Drops every entity the roots do not reach, every connection they do not
+ * name, and every settled overlay on a dropped connection, keeping whatever a
+ * pending request's layer or overlays touch. Pure.
+ */
+declare const gc: (state: Retained & {
+  readonly mutations: MutationState;
+}, roots: RetentionRoots) => Retained;
+//#endregion
+//#region src/persistence.d.ts
+/** Bump when the serialized shape changes; a mismatch discards the cache. */
+declare const REMOTE_CACHE_VERSION = 5;
+/**
+ * What survives a reload: the entity cache, and the connections an application
+ * **declared** should come back.
+ *
+ * Connections are session state by default and stay that way — `snapshotOf`
+ * takes none unless asked. What a declared one keeps is its **edges and
+ * nothing else**, which is not a simplification but the rule: a connection's
+ * boundaries are cursors the server minted, and a cursor may name server state
+ * that no longer exists. Restoring one would be claiming to know where the
+ * page ends. The shape has nowhere to put a cursor, so that cannot be got
+ * wrong later.
+ */
+interface Snapshot {
+  readonly entities: EntityStore;
+  /**
+   * By connection identity: its **segments**, each a run of edges. No
+   * boundaries.
+   *
+   * Segments rather than one flat list, because the gaps between them are
+   * knowledge too. A connection paged from both ends holds a head and a tail
+   * with an unfetched middle; flattening those into one run would claim the
+   * tail's first row follows the head's last, which is a thing the client was
+   * never told.
+   */
+  readonly connections: Readonly<Record<string, ReadonlyArray<ReadonlyArray<Edge>>>>;
+}
+interface SnapshotOptions {
+  /**
+   * Who or what the snapshot is for (a user id, a tenant, a build). A snapshot
+   * taken under another scope is discarded rather than shown to the wrong
+   * reader. Default: unscoped, which only matches unscoped.
+   */
+  readonly scope?: string | undefined;
+  /** Snapshots larger than this many bytes are not written and not read. */
+  readonly maxBytes?: number | undefined;
+}
+/** How a snapshot meets a store that already has entries. */
+type MergePolicy = 'replace' | 'preserve-existing';
+/**
+ * The snapshot text, or `undefined` when it would exceed `maxBytes`. Build the
+ * snapshot with `snapshotOf`, which is where the connections that survive are
+ * named; runtime state — optimistic layers, live cursors, gaps, the mutation
+ * ledger — is never in one.
+ */
+declare function dehydrate(snapshot: Snapshot, options?: SnapshotOptions & {
+  readonly maxBytes?: undefined;
+}): string;
+declare function dehydrate(snapshot: Snapshot, options?: SnapshotOptions): string | undefined;
+declare const RemotePersistence: {
+  /** The snapshot text, or `undefined` when it would exceed `maxBytes`. */
+  dehydrate: typeof dehydrate;
+  /** What a snapshot text holds, or `undefined` when it is refused. */
+  hydrate: (raw: string | undefined | null, options?: SnapshotOptions) => Snapshot | undefined;
+  /**
+   * What to keep of a Model, naming the connections that should survive a
+   * reload. Naming none is the default and is what Remote always did.
+   */
+  snapshotOf: (model: {
+    readonly entities: EntityStore;
+    readonly connections: Readonly<Record<string, Connection>>;
+  }, options?: {
+    readonly connections?: ReadonlyArray<ConnectionIdentity> | undefined;
+  }) => Snapshot;
+  /** A snapshot's entities brought into a store by policy. */
+  mergeStores: (current: EntityStore, snapshot: EntityStore, policy: MergePolicy) => EntityStore;
+  /** The cache as a fresh session has it; what a refused `restore` yields. */
+  emptySnapshot: Snapshot;
+  /**
+   * Writes the snapshot under `key`, or removes the key when the store would
+   * exceed `maxBytes`, so a stale smaller snapshot cannot outlive a larger
+   * store it no longer describes.
+   */
+  save: (snapshot: Snapshot, options: {
+    readonly key: string;
+  } & SnapshotOptions) => Effect.Effect<void, KeyValueStore.KeyValueStoreError, KeyValueStore.KeyValueStore>;
+  /**
+   * Reads the cache. A missing key yields `emptySnapshot`; anything `hydrate`
+   * refuses yields `emptySnapshot` and removes the key, so the next `restore`
+   * is clean and the planner refetches.
+   */
+  restore: (options: {
+    readonly key: string;
+  } & SnapshotOptions) => Effect.Effect<Snapshot, KeyValueStore.KeyValueStoreError, KeyValueStore.KeyValueStore>;
+};
+//#endregion
+//#region src/wire.d.ts
+/**
+ * The read/live protocol version. A batch names the version it speaks and the
+ * server refuses a mismatch with `RemoteProtocolError`, so a shape change never
+ * drifts silently: bump it whenever `ReadRequest` or `LiveRequirement` change.
+ */
+declare const REMOTE_PROTOCOL_VERSION = 4;
+declare const RemoteReadError_base: Schema.Class<RemoteReadError, Schema.TaggedStruct<"RemoteReadError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RemoteReadError extends RemoteReadError_base {}
+declare const RemoteMutationError_base: Schema.Class<RemoteMutationError, Schema.TaggedStruct<"RemoteMutationError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RemoteMutationError extends RemoteMutationError_base {}
+declare const RemoteLiveError_base: Schema.Class<RemoteLiveError, Schema.TaggedStruct<"RemoteLiveError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RemoteLiveError extends RemoteLiveError_base {}
+declare const RemoteProtocolError_base: Schema.Class<RemoteProtocolError, Schema.TaggedStruct<"RemoteProtocolError", {
+  readonly message: Schema.String;
+  readonly expected: Schema.Number;
+  readonly received: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** The peer speaks another protocol version; nothing was read. */
+declare class RemoteProtocolError extends RemoteProtocolError_base {}
+/** A page size: a non-negative integer, refused at decode otherwise rather than defaulted. */
+declare const PageSize: Schema.Number;
+declare const WindowSchema: 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>;
+}>;
+/** A request may not name more fields of one entity than this; a selection never does. */
+declare const MAX_FIELDS_PER_REQUEST = 256;
+/** A selection may not nest relations deeper than this; the wire refuses more. */
+declare const MAX_RELATION_DEPTH = 8;
+declare const RelationRequest: Schema.Codec<RelationRequirement, RelationRequirement, never, never>;
+declare const ReadRequest: Schema.Codec<Requirement, Requirement>;
+declare const ReadBatch: Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+}>;
+declare const NormalizedEntity: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+/**
+ * Fields a read asked for that the server answered without, and will not
+ * answer with: the client stops asking. It says nothing about why, so a rule
+ * that withholds a field is not itself on the wire.
+ */
+declare const SettledFields: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly fields: Schema.$Array<Schema.String>;
+}>;
+declare const ReadBatchResult: 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>;
+  }>>;
+}>;
+declare const MutationRequest: Schema.Struct<{
+  /** Stable across transport retries so a mutation is not applied twice. */
+  readonly requestId: Schema.String;
+  readonly mutation: Schema.String;
+  readonly input: Schema.Unknown;
+}>;
+declare const LiveEdge: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly key: Schema.String;
+}>;
+/** A connection change a mutation confirms: the same facts a live event carries, without a cursor. */
+declare const ConnectionChangeSchema: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"Insert">;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Remove">;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>]>;
+declare const MutationResult: Schema.Struct<{
+  readonly output: Schema.Unknown;
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  /** Connection changes the mutation made, applied alongside its entity patches. */
+  readonly connections: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Insert">;
+    readonly connection: Schema.String;
+    readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Remove">;
+    readonly connection: Schema.String;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>]>>>;
+  /** Entities the mutation deleted; the client knows them absent from then on. */
+  readonly deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+  }>>>;
+}>;
+declare const LiveRequirement: Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+  /** Resume cursor; events at or before it are duplicates. */
+  readonly after: Schema.Number;
+}>;
+/**
+ * A live change. Entity changes update the store; connection changes alter
+ * membership and ordering; both carry a per-stream cursor.
+ */
+declare const LiveChange: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityPatched">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly changed: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityDeleted">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInsert">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionRemove">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInvalidate">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+}>]>;
+declare const Read: Rpc.Rpc<"FoldkitRemoteRead", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+}>, 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>;
+  }>>;
+}>, Schema.Union<readonly [typeof RemoteReadError, typeof RemoteProtocolError]>, never, never>;
+declare const Mutate: Rpc.Rpc<"FoldkitRemoteMutate", Schema.Struct<{
+  /** Stable across transport retries so a mutation is not applied twice. */
+  readonly requestId: Schema.String;
+  readonly mutation: Schema.String;
+  readonly input: Schema.Unknown;
+}>, Schema.Struct<{
+  readonly output: Schema.Unknown;
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  /** Connection changes the mutation made, applied alongside its entity patches. */
+  readonly connections: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Insert">;
+    readonly connection: Schema.String;
+    readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Remove">;
+    readonly connection: Schema.String;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>]>>>;
+  /** Entities the mutation deleted; the client knows them absent from then on. */
+  readonly deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+  }>>>;
+}>, typeof RemoteMutationError, never, never>;
+declare const Live: Rpc.Rpc<"FoldkitRemoteLive", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+  /** Resume cursor; events at or before it are duplicates. */
+  readonly after: Schema.Number;
+}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityPatched">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly changed: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityDeleted">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInsert">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionRemove">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInvalidate">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+}>]>, Schema.Union<readonly [typeof RemoteLiveError, typeof RemoteProtocolError]>>, Schema.Never, never, never>;
+declare const RemoteQueryError_base: Schema.Class<RemoteQueryError, Schema.TaggedStruct<"RemoteQueryError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RemoteQueryError extends RemoteQueryError_base {}
+declare const WireBoundary: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"Terminal">;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Cursor">;
+  readonly cursor: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Unknown">;
+}>]>;
+declare const QueryRequest: Schema.Struct<{
+  readonly query: Schema.String;
+  readonly input: Schema.Unknown;
+  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>;
+  }>;
+  /**
+   * What to read of each item, as the relation slice a read asks the server
+   * for. Absent for a query run without one: the response carries only edges,
+   * and the client's read entry fetches fields in a second round trip.
+   */
+  readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+}>;
+declare const QueryEdge: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly key: Schema.String;
+}>;
+declare const QueryResult: Schema.Struct<{
+  readonly edges: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>>;
+  readonly start: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  readonly end: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  /**
+   * The selected fields of the page's items, in the same shape a read batch
+   * returns. Absent from a server that predates payload planning: the client
+   * reads it as empty and fetches fields as before.
+   */
+  readonly entities: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>>;
+  readonly settled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>>;
+}>;
+declare const QueryRpc: Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
+  readonly query: Schema.String;
+  readonly input: Schema.Unknown;
+  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>;
+  }>;
+  /**
+   * What to read of each item, as the relation slice a read asks the server
+   * for. Absent for a query run without one: the response carries only edges,
+   * and the client's read entry fetches fields in a second round trip.
+   */
+  readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+}>, Schema.Struct<{
+  readonly edges: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>>;
+  readonly start: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  readonly end: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  /**
+   * The selected fields of the page's items, in the same shape a read batch
+   * returns. Absent from a server that predates payload planning: the client
+   * reads it as empty and fetches fields as before.
+   */
+  readonly entities: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>>;
+  readonly settled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>>;
+}>, typeof RemoteQueryError, never, never>;
+declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+}>, 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>;
+  }>>;
+}>, Schema.Union<readonly [typeof RemoteReadError, typeof RemoteProtocolError]>, never, never> | Rpc.Rpc<"FoldkitRemoteMutate", Schema.Struct<{
+  /** Stable across transport retries so a mutation is not applied twice. */
+  readonly requestId: Schema.String;
+  readonly mutation: Schema.String;
+  readonly input: Schema.Unknown;
+}>, Schema.Struct<{
+  readonly output: Schema.Unknown;
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  /** Connection changes the mutation made, applied alongside its entity patches. */
+  readonly connections: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Insert">;
+    readonly connection: Schema.String;
+    readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Remove">;
+    readonly connection: Schema.String;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>]>>>;
+  /** Entities the mutation deleted; the client knows them absent from then on. */
+  readonly deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+  }>>>;
+}>, typeof RemoteMutationError, never, never> | Rpc.Rpc<"FoldkitRemoteLive", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+  /** Resume cursor; events at or before it are duplicates. */
+  readonly after: Schema.Number;
+}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityPatched">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly changed: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityDeleted">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInsert">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionRemove">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInvalidate">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+}>]>, Schema.Union<readonly [typeof RemoteLiveError, typeof RemoteProtocolError]>>, Schema.Never, never, never> | Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
+  readonly query: Schema.String;
+  readonly input: Schema.Unknown;
+  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>;
+  }>;
+  /**
+   * What to read of each item, as the relation slice a read asks the server
+   * for. Absent for a query run without one: the response carries only edges,
+   * and the client's read entry fetches fields in a second round trip.
+   */
+  readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+}>, Schema.Struct<{
+  readonly edges: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>>;
+  readonly start: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  readonly end: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  /**
+   * The selected fields of the page's items, in the same shape a read batch
+   * returns. Absent from a server that predates payload planning: the client
+   * reads it as empty and fetches fields as before.
+   */
+  readonly entities: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>>;
+  readonly settled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>>;
+}>, typeof RemoteQueryError, never, never>>;
+//#endregion
+//#region src/model.d.ts
+/**
+ * The normalized cache as a Foldkit Submodel. `Remote.define` returns a schema
+ * and an `update` for this shape; `updateRemote` reconciles every producer.
+ */
+interface RemoteModel {
+  /** Entity values, presence, staleness, tombstones, and applied windows. */
+  readonly entities: EntityStore;
+  /** Normalized ordered connections, keyed by connection identity. */
+  readonly connections: Readonly<Record<string, Connection>>;
+  /**
+   * How many rows `Data.more` has grown a read's window to, by
+   * `windowGrowthKey`. A read shows at most its window, so this is what "load
+   * more" changes; it lives here because a list holds no state of its own.
+   */
+  readonly grown: Readonly<Record<string, number>>;
+  /** Optimistic entity layers and connection overlays over the base store. */
+  readonly optimistic: OptimisticState;
+  /** Live cursor and boundary state, keyed by the subscription's stream key. */
+  readonly live: Readonly<Record<string, LiveState>>;
+  /** Mutation pending/applied/failed ledger. */
+  readonly mutations: MutationState;
+  /** Streams whose live cursor fell behind; the caller should resync or refetch. */
+  readonly gaps: ReadonlySet<string>;
+  /**
+   * The `entity\0id\0field` marks a read is currently fetching. A field absent
+   * from the store reads as `Loading` while its mark is here and `Initial`
+   * otherwise, which is what separates "being fetched" from "nothing is
+   * fetching this".
+   */
+  readonly loading: ReadonlySet<string>;
+  /**
+   * `Remote.refresh` generations, held per field rather than for the store as a
+   * whole. A read entry restarts when the generation over the fields it plans
+   * moves, so a read sent before a refresh of its own fields cannot land after
+   * it, and a refresh of one field leaves every other entry's read alone.
+   */
+  readonly refresh: RefreshState;
+  /**
+   * The reads that failed and have not been settled since, so a read can say
+   * `Failed` rather than `Initial`.
+   *
+   * Without them a read that failed before anything loaded read exactly like
+   * one nobody had asked for, and nothing asked again: a read entry restarts
+   * only when what it plans changes, and a failure changed nothing. What failed
+   * is not planned again on its own either, so a persistent error is not
+   * retried every time an unrelated read restarts the entry. `Remote.refresh`
+   * is how a view retries.
+   */
+  readonly failures: Failures;
+}
+/**
+ * Failed reads, as the errors they failed with.
+ *
+ * `connections` is by connection identity, and is settled by a page arriving,
+ * an invalidation, or retention dropping the connection. `fields` is by field
+ * mark (`entity\0id\0field`, the marks `loading` uses), and is settled by the
+ * field being written again, a refresh asking for it, or retention dropping the
+ * entity. A read of it in flight reads `Loading` over the failure without
+ * settling it: if that read fails too, the failure is simply recorded again.
+ */
+interface Failures {
+  readonly connections: Readonly<Record<string, RemoteError>>;
+  readonly fields: Readonly<Record<string, RemoteError>>;
+}
+declare const noFailures: Failures;
+/**
+ * `Remote.refresh` generations, per field mark. `generation` is the last one
+ * handed out; `requested` is when each field was last refreshed, and `started`
+ * is the generation each field's read last began under. Holding them per field
+ * is what keeps one Projection's refresh from restarting every read entry.
+ */
+interface RefreshState {
+  readonly generation: number;
+  readonly requested: ReadonlyMap<string, number>;
+  readonly started: ReadonlyMap<string, number>;
+  /**
+   * The generation every entry is refreshed at, at least: `forgetRemote` moves
+   * it, so every read and live entry restarts, and a read or stream begun for
+   * the principal before is interrupted rather than landing after.
+   */
+  readonly floor: number;
+}
+declare const emptyRefresh: RefreshState;
+/**
+ * The Model with everything the server told it forgotten: values, tombstones,
+ * unavailable fields, connections, live cursors, failures, and what is in
+ * flight. For a change of principal, whose facts these were. The mutation
+ * sequence is kept, so request ids stay unique, and a mutation in flight is
+ * treated as applied: its answer, when it comes, writes nothing here.
+ */
+declare const forgetRemote: (model: RemoteModel) => RemoteModel;
+declare const initialRemoteModel: RemoteModel;
+declare const remoteModelSchema: () => Schema.Codec<RemoteModel, unknown>;
+/** The submodel's Messages; each reduces to `RemoteModel` through `updateRemote`. */
+type RemoteMessage = {
+  readonly _tag: 'ReadReceived';
+  readonly requests: readonly Requirement[];
+  readonly result: Schema.Schema.Type<typeof ReadBatchResult>;
+  readonly now: number;
+} | {
+  readonly _tag: 'ReadFailed';
+  readonly requests: readonly Requirement[];
+  readonly error: RemoteError;
+  /**
+   * The live stream whose subscription broke, when this is that rather
+   * than a read. Nothing was being read, so no field failed: the stream is
+   * recorded as a gap, since changes after it are missed until the host
+   * resubscribes.
+   */
+  readonly stream?: string | undefined;
+} |
+/** A refetch of present fields began; they read as `Refreshing` until it lands. */
+{
+  readonly _tag: 'RefreshStarted';
+  readonly requests: readonly Requirement[];
+} |
+/** A read began; the fields it asks for that the store lacks read as `Loading`. */
+{
+  readonly _tag: 'ReadStarted';
+  readonly requests: readonly Requirement[];
+  /** The refresh generation the read was planned under. */
+  readonly refresh?: number | undefined;
+} |
+/**
+ * Queries for these connections were sent. One with nothing to show reads
+ * `Loading` until its page or its failure arrives, which is what separates
+ * "being fetched" from `Initial`, "nothing is fetching this".
+ */
+{
+  readonly _tag: 'QueryStarted';
+  readonly connections: readonly string[];
+} |
+/** The active Surfaces' roots changed; everything they do not reach is collected. */
+{
+  readonly _tag: 'RetentionChanged';
+  readonly roots: RetentionRoots;
+} |
+/** A restored snapshot meets the store; runtime state is untouched. */
+{
+  readonly _tag: 'Hydrated';
+  readonly entities: EntityStore;
+  /**
+   * The connections a snapshot declared should survive, as their edges.
+   * Restored with **unknown** boundaries and marked stale: the rows show
+   * at once and the connection is refetched, because a persisted cursor
+   * may name server state that is gone.
+   */
+  readonly connections?: Readonly<Record<string, ReadonlyArray<ReadonlyArray<Edge>>>> | undefined;
+  readonly merge: MergePolicy;
+} |
+/** A mutation began; its optimistic operations show until it settles. */
+{
+  readonly _tag: 'MutationStarted';
+  readonly requestId: string;
+  readonly optimistic?: ReadonlyArray<OptimisticOperation> | undefined;
+} | {
+  readonly _tag: 'MutationSucceeded';
+  readonly requestId: string;
+  readonly entities: readonly NormalizedPatch[];
+  /** Connection changes the server confirmed; they replace the request's own. */
+  readonly connections?: ReadonlyArray<ConnectionChange> | undefined;
+  /** Entities the mutation deleted: tombstoned, which hides them from every connection. */
+  readonly deleted?: ReadonlyArray<{
+    readonly entity: string;
+    readonly id: string;
+  }> | undefined;
+  /** Injected clock reading of the answer: how fresh the written entities are. */
+  readonly now: number;
+} | {
+  readonly _tag: 'MutationFailed';
+  readonly requestId: string;
+  readonly error: RemoteError;
+} |
+/**
+ * Operations shown over the store with no request behind them, until they are
+ * lifted: a preview of a change nobody has made. Showing an id again replaces
+ * what it showed.
+ */
+{
+  readonly _tag: 'OverlayShown';
+  readonly id: string;
+  readonly optimistic: ReadonlyArray<OptimisticOperation>;
+} | {
+  readonly _tag: 'OverlayLifted';
+  readonly id: string;
+} |
+/** `Data.more`: a read's window, by `windowGrowthKey`, now shows `size` rows. */
+{
+  readonly _tag: 'WindowGrown';
+  readonly window: string;
+  readonly size: number;
+} | {
+  readonly _tag: 'LiveReceived';
+  readonly stream: string;
+  readonly event: LiveEvent;
+  readonly policy?: LivePolicy;
+  readonly now: number;
+} | {
+  readonly _tag: 'GapCleared';
+  readonly stream: string;
+} | {
+  readonly _tag: 'ConnectionMerged';
+  readonly connection: string;
+  readonly page: Segment;
+  /** The page answers the connection's refresh, so the merge also clears `stale`. */
+  readonly refreshes?: boolean | undefined;
+  /**
+   * The slice the query asked for, so the payload's entities write like a
+   * read: one request per matching edge. Absent for a page from a server
+   * that predates payload planning, which carries edges only.
+   */
+  readonly select?: RelationRequirement | undefined;
+  /** The selected fields of the page's items, as a read batch returns them. */
+  readonly entities?: ReadonlyArray<{
+    readonly entity: string;
+    readonly id: string;
+    readonly values: Record<string, unknown>;
+  }> | undefined;
+  /** Fields asked for that the server settled without a value. */
+  readonly settled?: ReadonlyArray<{
+    readonly entity: string;
+    readonly id: string;
+    readonly fields: ReadonlyArray<string>;
+  }> | undefined;
+  /** Injected clock reading of the answer, dating what the payload writes. */
+  readonly now?: number | undefined;
+} | {
+  readonly _tag: 'ConnectionInvalidated';
+  readonly connection: string;
+} | {
+  readonly _tag: 'ConnectionRefreshed';
+  readonly connection: string;
+} |
+/**
+ * A query for the connection failed. Its pages stay as they were, and it
+ * reads `Failed` — with them as `previous`, when it has any — until a page
+ * arrives, it is invalidated, or retention drops it.
+ */
+{
+  readonly _tag: 'QueryFailed';
+  readonly connection: string;
+  readonly error: RemoteError;
+};
+declare const retentionRootsSchema: 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>>;
+  }>>;
+}>;
+/**
+ * The Messages' fields by tag, without `_tag`: what `defineMessageUnion` takes,
+ * so an application spreads them into its own union (`Remote.messages`).
+ */
+declare const remoteMessageCases: {
+  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;
+    }>;
+    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>;
+    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>>;
+  };
+  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;
+    }>>>;
+    now: Schema.Number;
+  };
+  MutationFailed: {
+    requestId: Schema.String;
+    error: Schema.Struct<{
+      readonly _tag: Schema.String;
+      readonly message: 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;
+    }>;
+  };
+};
+type RemoteMessageTag = RemoteMessage['_tag'];
+/**
+ * A Remote Message as an application's union constructs it from
+ * `remoteMessageCases`: the same shape `RemoteMessage` names, with the runtime
+ * slots (`entities`, `event`, `page`) typed `unknown` by their schemas.
+ */
+type RemoteMessageInput = { [Tag in RemoteMessageTag]: {
+  readonly _tag: Tag;
+} & Schema.Struct.Type<(typeof remoteMessageCases)[Tag]>; }[RemoteMessageTag];
+/**
+ * Whether a Message is one of Remote's, by tag. Narrows an application's union
+ * to its Remote cases, and its complement to the application's own.
+ */
+declare const isRemoteMessage: <M extends {
+  readonly _tag: string;
+}>(message: M) => message is Extract<M, {
+  readonly _tag: RemoteMessageTag;
+}>;
+declare const remoteMessageSchema: Schema.Schema<RemoteMessage>;
+/** The key a grown window is kept under: its connection and the window first asked for. */
+declare const windowGrowthKey: (identity: string, window: string) => string;
+/**
+ * Whether only overlays show this entity: the server has told the store
+ * nothing of it and no request's layer writes it, so nothing will fetch what an
+ * overlay leaves out.
+ */
+declare const onlyOverlaid: (model: RemoteModel, entity: string, id: string) => boolean;
+/** Whether a query for this connection is in flight. */
+declare const isQueryLoading: (model: RemoteModel, identity: string) => boolean;
+/**
+ * The generation a read is planned under: the highest any of the fields it
+ * reads or connections it runs was refreshed at. A read entry carries this as a
+ * dependency, so it restarts when what it observes is refreshed and not when
+ * anything else is.
+ */
+declare const refreshedAt: (refresh: RefreshState, requests: ReadonlyArray<Requirement>, connections?: ReadonlyArray<string>) => number;
+/**
+ * Marks every field of `requests` and every connection in `connections`
+ * refreshed at the next generation.
+ */
+declare const withRefreshRequested: (refresh: RefreshState, requests: ReadonlyArray<Requirement>, connections?: ReadonlyArray<string>) => RefreshState;
+/**
+ * Whether one field's read already began under the generation that field was
+ * last refreshed at. Such a read is in flight and would otherwise outlive the
+ * refresh, so the refresh takes a new generation to restart it even though the
+ * field is already stale.
+ */
+declare const refreshIsInFlight: (refresh: RefreshState, request: Requirement, field: string) => boolean;
+/**
+ * Whether a read is fetching any of `fields` for this entity. Consulted only
+ * when the store lacks the value, which is what separates `Loading` from
+ * `Initial`.
+ */
+declare const isLoading: (model: RemoteModel, entity: string, id: string, fields: ReadonlyArray<string>) => boolean;
+/**
+ * The pure reducer all four producers share. A live event that arrives ahead of
+ * its cursor is a gap: it is not applied, and the stream is recorded so the host
+ * can resubscribe rather than silently miss facts. When every field a Message
+ * touches keeps its identity, `model` itself is returned, so the application's
+ * root keeps its identity and Foldkit does not render. The common no-ops do (a
+ * duplicate live event, a repeated `ReadStarted`); a repeated failure, or a
+ * `preserve-existing` restore of entities already held, still makes an equal
+ * copy.
+ */
+declare const updateRemote: (model: RemoteModel, message: RemoteMessage) => RemoteModel;
+/** Whether this field's last read failed and nothing has settled it since. */
+declare const isFieldFailed: (model: RemoteModel, entity: string, id: string, field: string) => boolean;
+/**
+ * Whether a read is fetching any field `relation` reads of an entity, its own
+ * or, through each relation the store holds, its targets'. A value whose owner
+ * is being fetched is loading, not `Initial`: nothing is missing a fetch.
+ */
+declare const isLoadingThrough: (model: RemoteModel, entity: string, id: string, relation: RelationRequirement) => boolean;
+/**
+ * The first failure among the fields `relation` reads of an entity, following
+ * each relation the store holds into its targets, as `assemble` does. A read
+ * that consults it shows `Failed` for a related entity's failure too, rather
+ * than waiting on a field nothing will fetch.
+ */
+declare const failureOf: (model: RemoteModel, entity: string, id: string, relation: RelationRequirement) => RemoteError | undefined;
+/**
+ * Writes a read result into the store, recording each field's applied window so
+ * a later request with a different window refetches. A relation page requested
+ * with a cursor is merged onto the page already stored, so "load more"
+ * accumulates rather than replaces. Every read path should use this rather than
+ * reducing `writeEntity` by hand.
+ */
+declare const writeRead: (store: EntityStore, requests: ReadonlyArray<Requirement>, result: Schema.Schema.Type<typeof ReadBatchResult>, now?: number) => EntityStore;
+//#endregion
+//#region src/resume.d.ts
+/**
+ * A resume part, in the shape `foldkit-ssr`'s `SSR.plan` takes in `parts`.
+ * Declared here structurally, so neither package depends on the other.
+ */
+interface RemoteResumePart<AppModel> {
+  readonly id: string;
+  /** The metadata key names whose reads this part resumes. */
+  readonly covers: ReadonlyArray<string>;
+  readonly capture: (model: AppModel, projections: ReadonlyArray<{
+    readonly metadata: Metadata;
+  }>) => unknown;
+  readonly restore: (model: AppModel, value: unknown) => Result.Result<AppModel, string>;
+  /** Whether a Subscription entry is one of this domain's, which may start late. */
+  readonly deferrable: (key: string, entry: unknown) => boolean;
+}
+//#endregion
+//#region src/coalesce.d.ts
+type Batch = Schema.Schema.Type<typeof ReadBatch>;
+type BatchResult = Schema.Schema.Type<typeof ReadBatchResult>;
+type ReadError = RemoteReadError | RemoteProtocolError;
+type BatchRead = (batch: Batch) => Effect.Effect<BatchResult, ReadError>;
+type QueryRequestValue = Schema.Schema.Type<typeof QueryRequest>;
+type QueryResultValue = Schema.Schema.Type<typeof QueryResult>;
+type QueryRun = (request: QueryRequestValue) => Effect.Effect<QueryResultValue, RemoteQueryError>;
+interface CoalesceOptions {
+  /**
+   * How long a batch waits to collect more requirements before it runs.
+   * Requirements issued concurrently coalesce even at the default of no wait.
+   */
+  readonly window?: Duration.Input | undefined;
+}
+/** A stable key for a requirement, so an equal requirement in flight is joined. */
+declare const requirementKey: (requirement: Requirement) => string;
+/**
+ * Wraps a raw query so that an identical query in flight (same query, input,
+ * and window) is joined rather than run again; distinct queries run
+ * concurrently. A page answers exactly one window, so nothing is batched.
+ */
+declare const coalesceQueries: (query: QueryRun, options?: CoalesceOptions) => Effect.Effect<QueryRun>;
+/**
+ * Wraps a raw batch read so that requirements are batched and deduplicated.
+ * Every waiter receives the whole batch result; `Remote.writeRead` is
+ * idempotent, so writing it more than once is harmless.
+ */
+declare const coalesceReads: (read: BatchRead, options?: CoalesceOptions) => Effect.Effect<BatchRead>;
+//#endregion
+//#region src/client.d.ts
+declare const RemoteClient_base: Context.ServiceClass<RemoteClient, "foldkit-remote/RemoteClient", {
+  readonly read: (batch: Schema.Schema.Type<typeof ReadBatch>) => Effect.Effect<Schema.Schema.Type<typeof ReadBatchResult>, RemoteReadError | RemoteProtocolError>;
+  readonly query: (request: Schema.Schema.Type<typeof QueryRequest>) => Effect.Effect<Schema.Schema.Type<typeof QueryResult>, RemoteQueryError>;
+  readonly mutate: (request: Schema.Schema.Type<typeof MutationRequest>) => Effect.Effect<Schema.Schema.Type<typeof MutationResult>, RemoteMutationError>;
+  readonly live: (request: {
+    readonly requirements: ReadonlyArray<Requirement>;
+    readonly after: LiveCursor;
+  }) => Stream.Stream<LiveEvent, RemoteLiveError | RemoteProtocolError>;
+}>;
+/**
+ * The transport boundary. `foldkit-remote` never talks to a transport directly;
+ * it depends on this Effect service, which a later phase wires to Effect RPC.
+ */
+declare class RemoteClient extends RemoteClient_base {}
+/**
+ * The methods an Effect RPC client for `RemoteRpc` exposes. `R` is the
+ * environment a handler needs; it defaults to `never`, which is what a real
+ * transport client satisfies. `RemoteServer.handlers` returns this type with its
+ * own `R`, so the two sides cannot drift apart.
+ *
+ * `TransportError` is what the transport itself may fail with on top of the
+ * declared errors: `RpcClientError` for the client `RpcClient.make` builds,
+ * `never` for in-process handlers.
+ */
+interface RemoteRpcClient<R = never, TransportError = never> {
+  readonly FoldkitRemoteRead: (payload: Schema.Schema.Type<typeof ReadBatch>) => Effect.Effect<Schema.Schema.Type<typeof ReadBatchResult>, RemoteReadError | RemoteProtocolError | TransportError, R>;
+  readonly FoldkitRemoteQuery: (payload: Schema.Schema.Type<typeof QueryRequest>) => Effect.Effect<Schema.Schema.Type<typeof QueryResult>, RemoteQueryError | TransportError, R>;
+  readonly FoldkitRemoteMutate: (payload: Schema.Schema.Type<typeof MutationRequest>) => Effect.Effect<Schema.Schema.Type<typeof MutationResult>, RemoteMutationError | TransportError, R>;
+  readonly FoldkitRemoteLive: (payload: Schema.Schema.Type<typeof LiveRequirement>) => Stream.Stream<Schema.Schema.Type<typeof LiveChange>, RemoteLiveError | RemoteProtocolError | TransportError, R>;
+}
+/** Reconstructs the client's `ConnectionChange` from the wire's flattened edge. */
+declare const connectionChangeOf: (change: Schema.Schema.Type<typeof ConnectionChangeSchema>) => ConnectionChange;
+/** Reconstructs the client's `LiveEvent` from the wire's flattened `LiveChange`. */
+declare const liveEventOf: (change: Schema.Schema.Type<typeof LiveChange>) => LiveEvent;
+declare const remoteError: (error: {
+  readonly _tag: string;
+  readonly message: string;
+}) => RemoteError;
+declare const coalescedLayer: <E, R>(layer: Layer.Layer<RemoteClient, E, R>, options?: CoalesceOptions) => Layer.Layer<RemoteClient, E, R>;
+/**
+ * `Remote.mutate` as a standalone effect, so `Remote.mutateInto` can reuse it
+ * without the object literal referencing itself.
+ */
+declare const mutateRemote: <Name extends string, Input, Output>(mutation: MutationDescriptor<Name, Input, Output>, input: Input, requestId: string) => 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;
+  }[];
+}, RemoteMutationError, RemoteClient>;
+//#endregion
+//#region src/json.d.ts
+/** A request: which of Remote's calls, and its payload as the RPC protocol encodes it. */
+declare const RemoteJsonRequest: Schema.Struct<{
+  readonly operation: Schema.Literals<readonly ["read", "query", "mutate"]>;
+  readonly payload: Schema.Unknown;
+}>;
+type RemoteJsonRequest = typeof RemoteJsonRequest.Type;
+/** An answer: the call's result, or why there is none. */
+declare const RemoteJsonAnswer: Schema.Union<readonly [Schema.Struct<{
+  readonly result: Schema.Unknown;
+}>, Schema.Struct<{
+  readonly error: Schema.String;
+}>]>;
+type RemoteJsonAnswer = typeof RemoteJsonAnswer.Type;
+/**
+ * Sends one request's text and resolves with its answer as parsed JSON. It
+ * rejects when nothing came back, and the call fails with that message.
+ */
+type RemoteJsonSend = (request: string) => Promise<unknown>;
+//#endregion
+//#region src/relation.d.ts
+interface RefParts {
+  readonly entity: string;
+  readonly id: string;
+}
+/** A page of refs as the wire and the store hold it. */
+interface RefPageValue {
+  readonly refs: ReadonlyArray<string>;
+  readonly hasNext: boolean;
+  readonly hasPrevious: boolean;
+}
+/** Marks the codec `Entity.ref`/`Entity.refPage` produce, so a Selection can tell the field's shape. */
+declare const RelationAnnotation = "foldkitRemoteRelation";
+/** The target entity's name on the same codec, so a nested selection of another entity is refused. */
+declare const RelationEntityAnnotation = "foldkitRemoteRelationEntity";
+type RelationKind = 'one' | 'many' | 'page';
+interface RelationShape {
+  readonly kind: RelationKind;
+  readonly nullable: boolean;
+  readonly entity: string;
+}
+/**
+ * A page of a relation that is a whole list is read under a name of its own, the
+ * field's name and the page's size: `comments@first=10`. It is a field like any
+ * other to the store, the planner, and the wire, so the whole list and a page of
+ * it are held side by side, merged, marked stale, and persisted each on its own.
+ * The server reads the name apart, reads the relation with the window, and
+ * answers under the alias. A cursor is not part of the name: a page read from a
+ * cursor merges onto the page it continues.
+ */
+declare const RELATION_ALIAS = "@";
+/** The alias a relation field is read under, for a window of this size. */
+declare const relationAlias: (field: string, window: {
+  readonly first?: number | undefined;
+  readonly last?: number | undefined;
+  readonly after?: string | undefined;
+  readonly before?: string | undefined;
+}) => string;
+/** The field an alias reads; a name that is no alias is its own field. */
+declare const aliasedField: (name: string) => string;
+/** Splits a ref key (`"Entity:id"`, the store key too) back into its parts. */
+declare const refParts: (encoded: string) => RefParts;
+/**
+ * The refs a relation value carries, in order. Anything that is not a ref key,
+ * an array of them, or a page of them contributes nothing.
+ */
+declare const refsIn: (value: unknown) => ReadonlyArray<RefParts>;
+/** The refs in a relation value that name the relation's target entity, and no other. */
+declare const targetsOf: (value: unknown, relation: RelationRequirement) => ReadonlyArray<RefParts>;
+declare const isRefPage: (value: unknown) => value is RefPageValue;
+/**
+ * The relation shape an entity field schema declares: a ref (`one`), a nullable
+ * ref, an array of refs (`many`), or a page of refs (`page`). `undefined` for a
+ * scalar field, which cannot take a nested selection.
+ */
+declare const relationShape: (schema: Schema.Top) => RelationShape | undefined;
+//#endregion
+//#region src/selection.d.ts
+/** One page of a paginated relation with each target assembled through a nested selection. */
+interface Page<Item> {
+  readonly items: ReadonlyArray<Item>;
+  readonly hasNext: boolean;
+  readonly hasPrevious: boolean;
+}
+/**
+ * The fields a projection reads of one entity, plus the slice it reads of each
+ * relation's target. `Shape` tells a parent selection whether this one is a
+ * paginated relation (`connection`) or a plain entity slice (`entity`).
+ */
+interface Selection<Value, Name extends string = string, Shape extends 'entity' | 'connection' = 'entity' | 'connection'> {
+  readonly entity: Name;
+  readonly fields: readonly string[];
+  /** A pure codec: entity fields carry no decoding or encoding services. */
+  readonly schema: Schema.Codec<Value, unknown, never, never>;
+  /** Pagination windows for nested relation fields, keyed by field name. */
+  readonly connections?: Readonly<Record<string, QueryWindow>> | undefined;
+  /** The slice required of each nested relation's target, keyed by field name. */
+  readonly relations?: Readonly<Record<string, RelationRequirement>> | undefined;
+  /** Present when this selection is itself a paginated relation. */
+  readonly window?: QueryWindow | undefined;
+  /** Phantom: see `Shape`. */
+  readonly shape?: Shape | undefined;
+}
+/** Flattens a mapped type so hovers show the picked fields, not the machinery. */
+type Simplify<T> = T extends (infer O) ? { readonly [K in keyof O]: O[K]; } : never;
+/** The value a Selection reads: `Selection.Value<typeof ProjectCard>`. */
+type SelectionValueOf<S> = S extends Selection<infer V, any, any> ? V : never;
+/** The nested selections a relation field admits: of its target entity, in the shapes its value takes. */
+type NestedFor<Field> = Exclude<Field, null | undefined> extends ReadonlyArray<EntityRef<infer Name, any>> ? Selection<unknown, Name, 'entity' | 'connection'> : Exclude<Field, null | undefined> extends RefPage<infer Name, any> ? Selection<unknown, Name, 'entity' | 'connection'> : Exclude<Field, null | undefined> extends EntityRef<infer Name, any> ? Selection<unknown, Name, 'entity'> : never;
+/** What a selection of an entity with fields `F` may pick: `true` per scalar, a nested selection per relation. */
+type SelectionOf<F extends Schema.Struct.Fields> = { readonly [K in keyof F]?: true | NestedFor<Schema.Schema.Type<F[K]>>; };
+/** `T | null` when the field admits `null` or `undefined` (both assemble to `null`). */
+type Nullable<Field, T> = [Extract<Field, null | undefined>] extends [never] ? T : T | null;
+/** A nested selection's value takes the shape of the field it selects through. */
+type NestedValue<Field, Sel> = Sel extends Selection<infer V, string, 'connection'> ? Nullable<Field, V> : Sel extends Selection<infer V, string, 'entity'> ? Nullable<Field, Exclude<Field, null | undefined> extends ReadonlyArray<EntityRef<any, any>> ? ReadonlyArray<V> : Exclude<Field, null | undefined> extends RefPage<any, any> ? Page<V> : V> : never;
+/** The value a selection `Sel` of fields `F` reads. */
+type SelectionValue<F extends Schema.Struct.Fields, Sel> = Simplify<{ readonly [K in keyof Sel & keyof F]: Sel[K] extends true ? Schema.Schema.Type<F[K]> : NestedValue<Schema.Schema.Type<F[K]>, Sel[K]>; }>;
+declare const pageSchema: (item: AnySchema) => AnySchema;
+/** The requirement a nested selection contributes for its relation's target. */
+declare const relationOf: (selection: Selection<unknown>) => RelationRequirement;
+declare const Selection: {
+  /**
+   * The Remote Selection of a `foldkit-entity` Selection: the same members, read
+   * from Remote's store. `true` on a relation reads its refs, as it does here.
+   */
+  from: <Name extends string, S extends Schema.Constraint>(selection: Domain.Selection<Name, unknown, S>) => Selection<S["Type"], Name, "entity">;
+  /**
+   * The fields to read of `entity`. A nested `Selection` on a relation field
+   * reads through the ref (or refs, or page of refs) the field holds into the
+   * target's fields; a scalar field cannot take one.
+   */
+  make: <Name extends string, F extends Schema.Struct.Fields, const Sel extends SelectionOf<F>>(entity: EntityDescriptor<Name, F>, selection: Sel) => Selection<SelectionValue<F, Sel>, Name, "entity">;
+  /**
+   * A paginated relation: one page of refs to `entity` with a window, or, with
+   * a nested selection, one page of targets assembled through it.
+   */
+  connection: {
+    <Name extends string, F extends Schema.Struct.Fields>(entity: EntityDescriptor<Name, F>, window: QueryWindow): Selection<RefPage<Name, F>, Name, "connection">;
+    <Name extends string, F extends Schema.Struct.Fields, Item>(entity: EntityDescriptor<Name, F>, window: QueryWindow, selection: Selection<Item, NoInfer<Name>, "entity">): Selection<Page<Item>, Name, "connection">;
+  };
+};
+interface Assembled {
+  readonly values: unknown;
+  readonly refreshing: boolean;
+}
+/**
+ * Reads an entity's selected fields out of the store, following each nested
+ * relation into its targets. `undefined` means some field, at any depth, is
+ * not present yet. A tombstoned target reads as `null` (or is dropped from a
+ * list), so the Selection's codec decides whether that is a failure.
+ */
+declare const assemble: (store: EntityStore, key: string, requirement: RelationRequirement) => Assembled | undefined;
+/**
+ * The first field `requirement` reads, at any depth, that the server settled
+ * without a value, as `Entity:id.field`. A read that consults it says why it
+ * cannot assemble rather than waiting on a field nothing will fetch.
+ */
+declare const unavailableOf: (store: EntityStore, key: string, requirement: RelationRequirement) => string | undefined;
+//#endregion
+//#region src/entity.d.ts
+type AnySchema = Schema.Schema<unknown>;
+declare const entityRefFields: unique symbol;
+/**
+ * A normalized reference to an entity. `F` is a phantom carrying the entity's
+ * fields so `Entity.patch` can type its patch; it is absent at runtime.
+ */
+interface EntityRef<Name extends string, F extends Schema.Struct.Fields = Schema.Struct.Fields> {
+  readonly entity: Name;
+  readonly id: string;
+  readonly [entityRefFields]?: F;
+}
+interface EntityDescriptor<Name extends string, F extends Schema.Struct.Fields> {
+  readonly name: Name;
+  readonly schema: Schema.Struct<F>;
+  readonly fields: F;
+  ref(id: Schema.Schema.Type<F['id']>): EntityRef<Name, F>;
+  /** The fields a Surface reads of this entity; `Selection.make(entity, …)` with the entity as receiver. */
+  select<const Sel extends SelectionOf<F>>(selection: Sel): Selection<SelectionValue<F, Sel>, Name, 'entity'>;
+  /** A patch of this entity's wire-shaped values; `Entity.patch(entity.ref(id), values)`. */
+  patch(id: Schema.Schema.Type<F['id']>, values: Partial<Schema.Struct.Encoded<F>>): EntityPatch<Name, F>;
+}
+/**
+ * Relations are **references**, never inline target schemas: a ref cannot
+ * reconstruct a full entity, and dereferencing is a store concern. Because the
+ * target schema is not inlined, recursive relations cannot arise through the
+ * schema graph.
+ */
+/**
+ * A ref as the wire carries it: the target's name, a colon, and its id. Typed
+ * with the name, so a relation to `User` takes `'User:u1'` and not a ref to
+ * some other entity, which would read as a row that does not exist.
+ */
+type RefKey<Name extends string> = `${Name}:${string}`;
+/**
+ * A patch in wire shape: the values the store holds, so a relation is its ref
+ * key (`Entity.refKey`), not an `EntityRef`.
+ */
+interface EntityPatch<Name extends string, F extends Schema.Struct.Fields> {
+  readonly entity: Name;
+  readonly id: string;
+  readonly values: Partial<Schema.Struct.Encoded<F>>;
+}
+/**
+ * One authoritative page of a paginated relation: refs (never inline entities)
+ * plus whether more exist. The adapter does not hold segmentation state; the
+ * client merges pages.
+ */
+interface RefPage<Name extends string, F extends Schema.Struct.Fields = Schema.Struct.Fields> {
+  readonly refs: ReadonlyArray<EntityRef<Name, F>>;
+  readonly hasNext: boolean;
+  readonly hasPrevious: boolean;
+}
+/** The ref codec a `foldkit-entity` relation becomes: one ref, a nullable ref, or an array of refs. */
+type RelationField<Spec> = Spec extends Domain.RelationSpec<infer Target, infer Cardinality, infer Optional> ? Cardinality extends 'many' ? Schema.$Array<Schema.Codec<EntityRef<Target['name']>, RefKey<Target['name']>>> : Optional extends true ? Schema.NullOr<Schema.Codec<EntityRef<Target['name']>, RefKey<Target['name']>>> : Schema.Codec<EntityRef<Target['name']>, RefKey<Target['name']>> : never;
+/**
+ * The fields Remote stores for a `foldkit-entity` Entity: its own fields, its
+ * derived members (the server supplies them like any field), and each relation
+ * as refs.
+ */
+type FieldsFrom<E> = E extends Domain.Entity<any, infer Fields, infer Relations, infer Derived> ? Fields & { readonly [K in keyof Derived]: Derived[K]['schema']; } & { readonly [K in keyof Relations]: RelationField<Relations[K]>; } : never;
+declare const Entity$2: {
+  /**
+   * The Remote descriptor of a `foldkit-entity` Entity. Relations declared with
+   * `Entity.relate` become ref fields, so the store, the planner, and the server
+   * treat it as they treat an `Entity.make` descriptor.
+   */
+  from: <E extends Domain.AnyEntity>(entity: E & {
+    readonly fields: {
+      readonly id: unknown;
+    };
+  }) => EntityDescriptor<E["name"], FieldsFrom<E>>;
+  make: <const Name extends string, const F extends Schema.Struct.Fields & {
+    readonly id: Schema.Schema<unknown>;
+  }>(name: Name, schema: Schema.Struct<F>) => EntityDescriptor<Name, F>;
+  /** A relation to a known entity, decoded as a reference. */
+  ref: <Name extends string, F extends Schema.Struct.Fields>(entity: EntityDescriptor<Name, F>) => Schema.Codec<EntityRef<Name, F>, RefKey<Name>>;
+  /** A relation by name, for recursive or forward references. */
+  refTo: <Name extends string>(name: Name) => Schema.Codec<EntityRef<Name>, RefKey<Name>>;
+  /**
+   * The wire key a relation field carries (`"Entity:id"`). Adapters that read a
+   * foreign key emit this so the ref codec can decode it on the client.
+   */
+  refKey: (ref: {
+    readonly entity: string;
+    readonly id: string;
+  }) => string;
+  /** Splits a ref key back into its entity and id. */
+  refParts: (encoded: string) => RefParts;
+  /** A relation value of one authoritative page of refs. */
+  refPage: <Name extends string, F extends Schema.Struct.Fields>(entity: EntityDescriptor<Name, F>) => Schema.Codec<RefPage<Name, F>, {
+    readonly refs: ReadonlyArray<string>;
+    readonly hasNext: boolean;
+    readonly hasPrevious: boolean;
+  }>;
+  /**
+   * A normalized patch for an entity, typed against its fields' wire shape:
+   * write a relation as its ref key (`Entity.refKey`), as the server does.
+   */
+  patch: <Name extends string, F extends Schema.Struct.Fields>(ref: EntityRef<Name, F>, patch: Partial<Schema.Struct.Encoded<F>>) => EntityPatch<Name, F>;
+};
+//#endregion
+//#region src/matching.d.ts
+/**
+ * An answer over the rows the client holds — never over the rows that exist.
+ *
+ * `complete` is the whole reason this is its own type rather than a `Page`. A
+ * `Page` carries `hasNext`/`hasPrevious`, which are facts the *server* stated
+ * about rows beyond the ones it delivered; a local answer has no such facts and
+ * cannot invent them. What it can say is whether the population it judged was
+ * all of it, which is decidable: a connection terminal at both ends is wholly
+ * held, and nothing was skipped for a missing field.
+ *
+ * An incomplete answer is not wrong — it is an answer about less than the
+ * caller may have meant, and the flag is what lets a view say "3 so far" rather
+ * than "3", or a caller decide to ask the server.
+ */
+interface Matched<A> {
+  readonly items: ReadonlyArray<A>;
+  /** Whether every row the answer is about was judged. */
+  readonly complete: boolean;
+}
+/**
+ * What the rows the client holds had to say about a body.
+ *
+ * `skipped` is the honest half. A row missing a field the body reads cannot be
+ * judged — it is neither a match nor a non-match — and dropping it silently
+ * would turn "I could not tell" into "no". Naming it lets a caller decide:
+ * fetch the field, ask the server, or say the answer is partial.
+ */
+interface Judged {
+  /** Keys of the rows that satisfy the body, in the order the body asks for. */
+  readonly matched: ReadonlyArray<EntityKey>;
+  /** Keys of rows held but missing a field the body reads, so not judged either way. */
+  readonly skipped: ReadonlyArray<EntityKey>;
+}
+interface MatchingOptions {
+  /**
+   * Judge only these keys. Without it every row of the body's Entity in the
+   * store is a candidate, which is what a filter over a loaded list wants; with
+   * it, a caller narrows to a connection's own edges.
+   */
+  readonly among?: ReadonlyArray<EntityKey> | undefined;
+}
+/**
+ * The rows of `descriptor`'s Entity that the store holds and the body matches.
+ *
+ * The input is given **decoded**, as an application writes it, and encoded here
+ * through the descriptor's own `Input` codec. That is deliberate and is the
+ * whole reason this takes a descriptor rather than a bare body: a store holds
+ * wire values, so an input has to be in that space to be compared against them,
+ * and handing an interpreter a decoded value is a mistake **no runtime error
+ * catches** — the reference interpreter answers "no rows", which reads exactly
+ * like a correct answer. Doing it here means a caller cannot get it wrong.
+ *
+ * Literals in the body are deliberately *not* encoded. A literal written in
+ * domain terms is already broken against the server, which binds it to a column
+ * the same way; accepting it here would make the client quietly more permissive
+ * than the thing it has to agree with.
+ */
+declare const matching: <Name extends string, Input>(store: EntityStore, descriptor: QueryDescriptor<Name, Input, unknown>, input: Input, options?: MatchingOptions) => Judged;
+/**
+ * Whether one row belongs to a query, as far as the client can tell.
+ *
+ * Three answers, and the third is the one that makes this usable. `'unknown'`
+ * is a row the store never fetched, or holds without a field the body reads —
+ * a caller that collapses it into `'no'` has turned "I could not tell" into an
+ * answer, which is the mistake this whole module is shaped against.
+ *
+ * **Membership is decidable where position is not.** Whether a row satisfies
+ * `eq`, `isNull` or `contains` needs no collation: equality on text is exact
+ * and `contains` folds ASCII, both stated in §6.0.1. *Where* a row sorts needs
+ * text collation, which is the backend's and deliberately outside the
+ * conformant subset — so this answers the half that is always answerable, and
+ * ordering stays the server's until a query can declare its collation.
+ */
+type Belongs = 'yes' | 'no' | 'unknown';
+/**
+ * Takes the input **encoded**, because its one caller holds it that way: a
+ * connection identity carries the canonical encoded input, and making it decode
+ * only for this to encode again would be a round trip that can fail.
+ *
+ * A decoded-input sibling was written first and deleted: nothing called it. The
+ * asymmetry with `matching`, which takes a decoded input, is the shape of the
+ * two real callers rather than an oversight.
+ */
+declare const belongsEncoded: <Name extends string, Input>(store: EntityStore, descriptor: QueryDescriptor<Name, Input, unknown>, encoded: Readonly<Record<string, unknown>>, key: EntityKey) => Belongs;
+//#endregion
+//#region src/inspect.d.ts
+/** A query body's `Dependencies` as plain data: each field by its Entity's name and key. */
+interface ExplainedDependencies {
+  readonly fields: ReadonlyArray<{
+    readonly entity: string;
+    readonly key: string;
+  }>;
+  readonly inputs: Dependencies['inputs'];
+  readonly operations: Dependencies['operations'];
+}
+/** A serializable summary of a RemoteModel for DevTools and diagnostics. */
+interface RemoteInspection {
+  readonly entities: ReadonlyArray<{
+    readonly key: string;
+    readonly present: ReadonlyArray<string>;
+    readonly stale: ReadonlyArray<string>;
+    readonly unavailable: ReadonlyArray<string>;
+    readonly tombstone: boolean;
+    readonly updatedAt: number;
+    readonly windows: Readonly<Record<string, string>>;
+  }>;
+  readonly connections: ReadonlyArray<string>;
+  readonly live: ReadonlyArray<string>;
+  readonly gaps: ReadonlyArray<string>;
+  /**
+   * The `entity\0id\0field` marks of reads in flight, and a
+   * `\0connection\0identity` mark for each query in flight. This is what "Remote is
+   * working" means here, and it is read from the Model rather than from the
+   * fibers doing the work: a tool that shows it shows something the Model can
+   * be replayed to, and nothing that needs the runtime to be asked.
+   */
+  readonly loading: ReadonlyArray<string>;
+  /**
+   * The reads that failed and are not yet settled: queries by connection
+   * identity, entity fields by `entity\0id\0field` mark, each with its error.
+   */
+  readonly failures: Failures;
+  readonly mutations: {
+    readonly pending: ReadonlyArray<string>;
+    readonly failed: ReadonlyArray<string>;
+    readonly applied: number;
+  };
+}
+/** A pure, serializable view of the whole cache. */
+declare const inspectRemote: (model: RemoteModel) => RemoteInspection;
+/** A pure, serializable view of one entity, or `undefined` if unknown. */
+declare const inspectEntity: (model: RemoteModel, key: string) => RemoteInspection["entities"][number] | undefined;
+/**
+ * Why a read shows what it shows, in words, and for `Initial`, which of the
+ * usual mistakes it is.
+ *
+ * `Initial` means nothing is fetching the read, and that is almost always
+ * wiring rather than the network: no active Surface reads it, or one does and
+ * Remote's Subscriptions are not running. The Model can tell those apart when
+ * it is given the active record, so this says which, and what to do.
+ */
+interface ReadDiagnosis {
+  readonly state: RemoteData<unknown>['_tag'];
+  /**
+   * For `Initial` only. `NotObserved`: no active Surface reads it.
+   * `NotFetching`: one does, and nothing is fetching it, so Remote's
+   * Subscriptions are most likely not installed. `Unknown`: no active record
+   * was given to tell.
+   */
+  readonly reason?: 'NotObserved' | 'NotFetching' | 'Unknown' | undefined;
+  /** One or two sentences a developer can act on. */
+  readonly message: string;
+  /** The active Surfaces reading it, when the active record was given. */
+  readonly surfaces?: ReadonlyArray<string> | undefined;
+}
+/**
+ * What one query read is, and what it currently is — data-query-DESIGN §29.1.
+ *
+ * Every member is gathered from something that already existed: the read was
+ * always this many pieces, and nothing had ever been asked to put them in one
+ * place. It is plain serializable data, so a DevTools panel, a log line and a
+ * test assert on the same value.
+ *
+ * Two members of §29.1's sketch are **not** here, and their absence is the
+ * finding rather than an omission:
+ *
+ * - **Surface.** A Projection does not know which Surface reads it, and often
+ *   several do — so it is not a property of the read, and `explain` cannot
+ *   recover it alone. Given the active Surfaces (the same record
+ *   `subscriptions` takes), it reports **every** Surface reading the connection
+ *   rather than guessing one, and omits the member entirely when it was not
+ *   given them.
+ * - **Executor.** The thing that answers a query is a `RemoteClient` Layer in
+ *   the runtime, not a value in the Model, and a pure read of the Model cannot
+ *   see it. That is the same boundary that makes this function pure and
+ *   replayable, so it is worth more than the line of text.
+ *
+ * And one that the design proposed and this does not want: *expectation*
+ * (required versus optional). §11 left it unbuilt for want of a consumer, and
+ * the explanation was the likeliest consumer. It turns out not to need it — a
+ * query's result is a connection, so the shape is a `Page`, decided by the
+ * definition rather than by the read. Nothing here has an opinion about whether
+ * an empty one is an error, because nothing here has to have one.
+ */
+interface QueryExplanation {
+  /** The bound Remote domain that answers it. */
+  readonly domain: string;
+  /** The definition's name. */
+  readonly query: string;
+  /** The input as encoded, which is what the identity is built from. */
+  readonly input: unknown;
+  /** The connection identity: definition plus canonical input, excluding the window. */
+  readonly identity: string;
+  /** How much of the connection this read asks for. */
+  readonly window: QueryWindow;
+  /** What it reads of each item, as the slice asked of the server. */
+  readonly select: RelationRequirement;
+  /**
+   * What the query means, as readable text — `Query.show`, and so neither SQL
+   * nor whatever the backend compiled. Absent for a definition made with
+   * `Query.make`, whose meaning lives on the server that answers it.
+   */
+  readonly body?: string | undefined;
+  /**
+   * The fields, inputs and operations the body reads; absent with the body.
+   * Plain data, so it serializes: a field is its Entity's name and key, which
+   * is unambiguous because a query reads one Entity.
+   */
+  readonly dependencies?: ExplainedDependencies | undefined;
+  /** What the read answers from this Model right now. */
+  readonly state: RemoteData<unknown>['_tag'];
+  /**
+   * The active Surfaces reading this connection at this Model, if the active
+   * record was supplied. Plural because several may, which is why a Projection
+   * cannot carry the answer itself.
+   */
+  readonly surfaces?: ReadonlyArray<string> | undefined;
+  /**
+   * Why each of those Surfaces is active, where it was placed with
+   * `Surface.when` — the Model path and the tag, without running anything. A
+   * Surface placed with `Surface.at` has no entry: a callback cannot be read.
+   */
+  readonly activation?: ReadonlyArray<{
+    readonly surface: string;
+    readonly path: readonly string[];
+    readonly tag: string;
+  }> | undefined;
+}
+//#endregion
+//#region src/plan.d.ts
+type Window = NonNullable<Requirement['windows']>[string];
+/** A stable key for a window, so two equal windows compare equal. */
+declare const windowKey: (window: Window) => string;
+interface PlanFreshness {
+  readonly now: number;
+  /** A present entry older than this many milliseconds is refreshed whole. */
+  readonly freshness: number;
+}
+interface PlanOptions {
+  readonly freshness?: PlanFreshness | undefined;
+  /** Plan every requested field, present or not, tombstoned or not. */
+  readonly force?: boolean | undefined;
+}
+/** When present values next go stale, and the requirements of the entities that do. */
+interface Deadline {
+  readonly at: number;
+  readonly due: ReadonlyArray<Requirement>;
+}
+/**
+ * The earliest moment a value `requirements` read, following the relations the
+ * store holds as `plan` does, goes stale under `freshness`, with the
+ * requirements of the entities that go stale then. A field the server settled
+ * without a value ages with its entity too, since `plan` asks for it again once
+ * the entity expires. Nothing when no such field is still fresh: what is
+ * already expired or stale is planned, not awaited, which is what keeps a
+ * timer from firing on what it already fired on. It is the next moment the
+ * plan can change with the clock alone, which the read entry relies on to
+ * reuse its plan until then.
+ */
+declare const deadlineOf: (store: EntityStore, requirements: readonly Requirement[], freshness: PlanFreshness) => Deadline | undefined;
+declare const plan: (store: EntityStore, requirements: readonly Requirement[], options?: PlanOptions) => ReadonlyArray<Requirement>;
+//#endregion
+//#region src/policy.d.ts
+type RemotePolicy =
+/** Fetch only fields the store lacks (missing, stale, or re-windowed). */
+{
+  readonly _tag: 'CacheFirst';
+} |
+/**
+ * Keep present values visible, read them as `Refreshing`, and refetch an
+ * entry older than `maxAge` milliseconds.
+ */
+{
+  readonly _tag: 'StaleWhileRevalidate';
+  readonly maxAge: number;
+} |
+/** Fetch every selected field regardless of coverage; cached values stay visible meanwhile. */
+{
+  readonly _tag: 'NetworkOnly';
+};
+declare const RemotePolicy: {
+  /** Fetch only what the store lacks. */
+  cacheFirst: {
+    readonly _tag: "CacheFirst";
+  };
+  /** Keep present values visible, read as `Refreshing`, and refetch an entry older than `maxAge` ms. */
+  staleWhileRevalidate: (options: {
+    readonly maxAge: number;
+  }) => RemotePolicy;
+  /** Fetch every selected field regardless of coverage; cached values stay visible meanwhile. */
+  networkOnly: {
+    readonly _tag: "NetworkOnly";
+  };
+  /** The planner options a policy compiles to at `now`. */
+  toPlan: (policy: RemotePolicy, now: number) => PlanOptions;
+  /**
+   * Whether a read under this policy may refetch fields the store already
+   * holds, so an observer marks them stale (read as `Refreshing`) while the
+   * request is pending.
+   */
+  refreshes: (policy: RemotePolicy) => boolean;
+};
+//#endregion
+//#region src/index.d.ts
+/** What a domain registers: a Remote descriptor, or a `foldkit-entity` Entity (read through `Entity.from`). */
+type EntityLike = EntityDescriptor<any, any> | Domain.AnyEntity;
+/**
+ * What a read selects: a Remote Selection, or a `foldkit-entity` Selection
+ * (read through `Selection.from`).
+ */
+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.
+ */
+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. */
+type SelectsEntity<Entity extends string, Of extends string> = [Entity] extends [Of] ? unknown : Invalid<`the selection is of "${Entity}", but the query lists "${Of}"`>;
+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>>;
+  };
+}
+declare const boundRemoteNames: unique symbol;
+interface BoundRemote<AppModel, Store extends RemoteModel, Names extends string = string> {
+  readonly definition: RemoteDescriptor;
+  readonly store: ModelRef<AppModel, Store>;
+  /** For `Module`: owns the store's Model path. */
+  readonly contract: Contract;
+  /** Phantom: the entity names this Remote definition registers. */
+  readonly [boundRemoteNames]?: Names;
+}
+type MutationInput<M> = M extends MutationDescriptor<any, infer Input, any> ? Input : never;
+interface DomainMutateOptions {
+  /** Overrides the generated id, for a retry, a durable bridge, or a test. */
+  readonly requestId?: string | 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;
+  /** The clock `MutationSucceeded` stamps the answer with; default `Date.now`, read at each use. */
+  readonly now?: (() => number) | undefined;
+}
+/** A Foldkit Subscription entry of the Remote domain, emitting its Messages through `RemoteClient`. */
+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`.
+ */
+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. */
+interface LiveDependencies {
+  readonly requirements: ReadonlyArray<Requirement>;
+  readonly cursor: LiveCursor;
+  readonly floor: number;
+}
+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. */
+type RemoteWiring<AppModel> = Wiring<AppModel, RemoteMessage | RemoteMessageInput, RemoteClient>;
+/** What `RemoteDomain.mutate` hands `update`: the Model with the request started, and the Command that settles it. */
+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.
+ */
+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>>> | undefined;
+  }): QueryExplanation;
+  /**
+   * Why a read shows what it shows, in words. Any Remote read: `Data.get`,
+   * `Data.live` or `Data.query`.
+   *
+   * Its point is `Initial`, which means nothing is fetching the read and is
+   * almost always a wiring mistake. Given `surfaces`, the same active record
+   * `subscriptions` takes, it says which: no active Surface reads it, or one
+   * does and Remote's Subscriptions are not running. Pure, like `explain`.
+   */
+  why(model: AppModel, projection: Projection<AppModel, RemoteData<unknown>>, options?: {
+    readonly surfaces?: Readonly<Record<string, ActiveSurface<AppModel>>> | undefined;
+  }): ReadDiagnosis;
+  /**
+   * 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;
+  /** `Remote.refresh`: marks what a projection or a Surface requires as due, for its read entry to refetch. */
+  refresh(model: AppModel, target: Projection<AppModel, unknown> | Surface<AppModel, any, any, void>): 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>;
+  /**
+   * The Foldkit Subscription entries for the active Surfaces, keyed for
+   * `Subscription.make`: a read entry per Surface (`Remote.observe`), a live
+   * entry per Surface that reads through `live` (`Remote.live`), and one
+   * retain entry (`Remote.retain`). 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, ActiveSurface<AppModel> | Surface<AppModel, any, any, void>>>>(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, 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.
+   */
+  satisfy(model: AppModel, active: Readonly<Record<string, ActiveSurface<AppModel> | Surface<AppModel, any, any, void>>>, options?: SatisfyOptions): Effect.Effect<AppModel, RemoteReadError | RemoteProtocolError | RemoteQueryError | RemoteUnsatisfied, 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;
+  /** `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.
+   */
+  wiring: <const Active extends Readonly<Record<string, ActiveSurface<AppModel> | Surface<AppModel, any, any, void>>>>(active: Active, options?: SubscriptionsOptions) => RemoteWiring<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. */
+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.
+ */
+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.subscriptions`, every entry lifted to the wrapper Message. */
+  readonly subscriptions: <const Active extends Readonly<Record<string, ActiveSurface<AppModel> | Surface<AppModel, any, any, void>>>>(active: Active, options?: SubscriptionsOptions) => SubscriptionEntries<AppModel, Active, ParentMessage>;
+}
+/** The application Model a bound domain is over. */
+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. */
+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. */
+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;
+};
+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>;
+} & QueryWindowOptions;
+/** A query connection read as a `Page` of selected items; `ref` is the connection with its first window. */
+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. */
+type QueryInput<Q> = Q extends QueryDescriptor<any, infer Input, any> ? Input : never;
+/** The entity a query's connection is over. */
+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`.
+ */
+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;
+}
+interface MutateOptions {
+  /** What the request changes before the server answers; released when it settles. */
+  readonly optimistic?: ReadonlyArray<OptimisticOperation> | undefined;
+  /** The clock `MutationSucceeded` stamps the answer with; default `Date.now`, read at each use. */
+  readonly now?: (() => number) | undefined;
+}
+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. */
+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. */
+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.)
+ */
+declare class RemoteUnsatisfied extends RemoteUnsatisfied_base {}
+interface LiveOptions {
+  /** The clock `LiveReceived` stamps events with; default `Date.now`, read at each use. */
+  readonly now?: (() => number) | undefined;
+}
+/** 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. */
+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;
+}
+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;
+      }>;
+      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>;
+      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>>;
+    };
+    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;
+      }>>>;
+      now: Schema.Number;
+    };
+    MutationFailed: {
+      requestId: Schema.String;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: 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;
+      }>;
+    };
+  };
+  /** Whether a Message is one of Remote's, by tag. */
+  reduces: <M extends {
+    readonly _tag: string;
+  }>(message: M) => message is Extract<M, {
+    readonly _tag: RemoteMessageTag;
+  }>;
+  /**
+   * 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;
+      }>;
+      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>;
+      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>>;
+    };
+    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;
+      }>>>;
+      now: Schema.Number;
+    };
+    MutationFailed: {
+      requestId: Schema.String;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: 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;
+      }>;
+    };
+  }>;
+  /**
+   * 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; a relation is its ref key
+   * (`'User:u1'`).
+   */
+  patch: <E extends EntityLike>(entity: E, id: string, values: Partial<Schema.Struct.Encoded<FieldsOf<E>>>) => EntityPatch<NameOf<E>, FieldsOf<E>>;
+  /**
+   * 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;
+  }) => 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: <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>;
+  /**
+   * 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.
+   */
+  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>) => 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: <AppModel, Store extends RemoteModel>(domain: {
+    readonly store: ModelRef<AppModel, Store>;
+  }, options?: {
+    readonly id?: string | undefined;
+  }) => RemoteResumePart<AppModel>;
+  /**
+   * 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>>, RemoteReadError | RemoteProtocolError, RemoteClient>;
+  /**
+   * Marks what a projection, or a Surface without params, requires as due again.
+   * 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 query is retried: a connection whose query failed
+   * is not run again on its own, so its read stays `Failed` until this asks.
+   *
+   * 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: Projection<AppModel, unknown> | Surface<AppModel, any, any, void>) => 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: (store: EntityStore, requests: ReadonlyArray<Requirement>, result: Schema.Schema.Type<typeof ReadBatchResult>, now?: number) => EntityStore;
+  /**
+   * 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: (send: RemoteJsonSend) => RemoteRpcClient;
+  /**
+   * 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: (url: string, options?: {
+    readonly headers?: () => Readonly<Record<string, string>>;
+  }) => RemoteRpcClient;
+  clientLayer: <R = never>(client: RemoteRpcClient<R, RpcClientError.RpcClientError>, 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: <E, R>(layer: Layer.Layer<RemoteClient, E, R>, options?: CoalesceOptions) => Layer.Layer<RemoteClient, E, R>;
+  /**
+   * 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, 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;
+  /**
+   * The edges a connection shows: its server-known region with pending and
+   * confirmed overlays placed around it, minus removed edges and edges whose
+   * target is a tombstone.
+   */
+  visibleItems: (model: RemoteModel, connection: ConnectionIdentity) => ReadonlyArray<Edge>;
+  /** A pure, serializable view of the whole cache. */
+  inspect: (model: RemoteModel) => RemoteInspection;
+  /** A pure, serializable view of one entity, or `undefined` if unknown. */
+  inspectEntity: (model: RemoteModel, key: string) => RemoteInspection["entities"][number] | undefined;
+  /**
+   * 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>, input: Input, requestId: string) => 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;
+    }[];
+  }, RemoteMutationError, RemoteClient>;
+  /**
+   * 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>, input: Input, requestId: string, options?: MutateOptions | undefined) => Effect.Effect<{
+    output: Output;
+    model: AppModel;
+  }, RemoteMutationError, 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. 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>;
+};
+//#endregion
+export { Entity$2 as $, isGapped as $i, Snapshot as $n, ResultOf as $r, failureOf as $t, SelectsEntity as A, readField as Ai, PageSize as An, pruneOverlays as Ar, RemoteJsonRequest as At, ExplainedDependencies as B, remoteDataSchema as Bi, RelationRequest as Bn, RemoteRequirements as Br, CoalesceOptions as Bt, RemoteDomain as C, entry as Ci, LiveRequirement as Cn, OptimisticOperation as Cr, isRefPage as Ct, RemoteWiring as D, isTombstone as Di, MutationRequest as Dn, beginOptimistic as Dr, relationShape as Dt, RemoteUnsatisfied as E, isFieldUnavailable as Ei, Mutate as En, addOverlay as Er, relationAlias as Et, PlanFreshness as F, writeEntities as Fi, REMOTE_PROTOCOL_VERSION as Fn, visibleItems as Fr, connectionChangeOf as Ft, inspectRemote as G, Edge as Gi, RemoteReadError as Gn, IDENTITY_SEPARATOR as Gr, RemoteResumePart as Gt, ReadDiagnosis as H, Boundary as Hi, RemoteMutationError as Hn, connectionsOf as Hr, coalesceQueries as Ht, PlanOptions as I, writeEntity as Ii, Read as In, visibleStore as Ir, liveEventOf as It, Matched as J, cursor as Ji, WindowSchema as Jn, Query$1 as Jr, RemoteMessage as Jt, Belongs as K, EdgeRef as Ki, RemoteRpc as Kn, LiveInsertion as Kr, Failures as Kt, deadlineOf as L, Freshness as Li, ReadBatch as Ln, ConnectionRequirement as Lr, mutateRemote as Lt, SubscriptionsOptions as M, setStale as Mi, QueryRequest as Mn, removeOverlay as Mr, RemoteClient as Mt, RemotePolicy as N, setUnavailable as Ni, QueryResult as Nn, settleFailure as Nr, RemoteRpcClient as Nt, RetainOptions as O, markStale as Oi, MutationResult as On, connectionIdentity as Or, targetsOf as Ot, Deadline as P, tombstone as Pi, QueryRpc as Pn, settleSuccess as Pr, coalescedLayer as Pt, AnySchema as Q, hasPrevious as Qi, RemotePersistence as Qn, QueryWindow as Qr, emptyRefresh as Qt, plan as R, RemoteData as Ri, ReadBatchResult as Rn, RelationRequirement as Rr, remoteError as Rt, RemoteDescriptor as S, entityKey as Si, LiveEdge as Sn, EntityLayer as Sr, aliasedField as St, RemoteFold as T, isFieldStale as Ti, MAX_RELATION_DEPTH as Tn, addLayer as Tr, refsIn as Tt, RemoteInspection as U, Connection as Ui, RemoteProtocolError as Un, requirementsOf as Ur, coalesceReads as Ut, QueryExplanation as V, remoteErrorSchema as Vi, RemoteLiveError as Vn, Requirement as Vr, QueryRun as Vt, inspectEntity as W, Cursor as Wi, RemoteQueryError as Wn, ConnectionSpec as Wr, requirementKey as Wt, belongsEncoded as X, emptyConnection as Xi, MergePolicy as Xn, QueryInputs as Xr, RemoteMessageTag as Xt, MatchingOptions as Y, edge as Yi, WireBoundary as Yn, QueryDescriptor as Yr, RemoteMessageInput as Yt, matching as Z, hasNext as Zi, REMOTE_CACHE_VERSION as Zn, QueryRef as Zr, RemoteModel as Zt, QueryWindowOptions as _, EntityKey as _i, withRefreshRequested as _n, liveHasNext as _r, RefParts as _t, FoldedMutationStarted as a, MutationStatus as ai, isQueryLoading as an, reachable as ar, RefPage as at, Registered as b, clearStale as bi, Live as bn, ConnectionIdentity as br, RelationKind as bt, ModelOfDomain as c, SchemaOrFields as ci, onlyOverlaid as cn, EntityApplied as cr, SelectionOf as ct, ObserveOptions as d, emptyMutationState as di, remoteMessageCases as dn, LiveOutcome as dr, assemble as dt, items as ea, stableStringify as ei, forgetRemote as en, SnapshotOptions as er, EntityDescriptor as et, QueryEntity as f, failMutation as fi, remoteMessageSchema as fn, LiveState as fr, pageSchema as ft, QueryRequirement as g, EntityEntry as gi, windowGrowthKey as gn, emptyLiveState as gr, RefPageValue as gt, QueryProjection as h, schemaOf as hi, updateRemote as hn, classifyLive as hr, RELATION_ALIAS as ht, EntitySelection as i, unknown as ia, MutationState as ii, isLoadingThrough as in, gc as ir, RefKey as it, SubscriptionEntries as j, remove as ji, QueryEdge as jn, removeLayer as jr, RemoteJsonSend as jt, SatisfyOptions as k, missingFields as ki, NormalizedEntity as kn, emptyOptimistic as kr, RemoteJsonAnswer as kt, MutateOptions as l, TypeOf as li, refreshIsInFlight as ln, LiveCursor as lr, SelectionValue as lt, QueryOptions as m, reconcileMutation as mi, retentionRootsSchema as mn, applyEntityEvent as mr, unavailableOf as mt, DomainMutateOptions as n, segment as na, MutationAnswer as ni, isFieldFailed as nn, Retained as nr, EntityRef as nt, LiveDependencies as o, NormalizedPatch as oi, isRemoteMessage as on, BoundaryCounts as or, Page as ot, QueryInput as p, mutationStatus as pi, remoteModelSchema as pn, applyConnectionEvent as pr, relationOf as pt, Judged as q, Segment as qi, SettledFields as qn, LivePolicy as qr, RefreshState as qt, EntityLike as r, terminal as ra, MutationDescriptor as ri, isLoading as rn, RetentionRoots as rr, FieldsFrom as rt, LiveOptions as s, Reconciled as si, noFailures as sn, ConnectionApplied as sr, Selection as st, BoundRemote as t, merge as ta, Mutation as ti, initialRemoteModel as tn, ConnectionRoot as tr, EntityPatch as tt, MutationStarted as u, beginMutation as ui, refreshedAt as un, LiveEvent as ur, SelectionValueOf as ut, ReadDependencies as v, EntityStore as vi, writeRead as vn, liveHasPrevious as vr, RelationAnnotation as vt, RemoteEntry as w, hasField as wi, MAX_FIELDS_PER_REQUEST as wn, OptimisticState as wr, refParts as wt, Remote as x, emptyStore as xi, LiveChange as xn, ConnectionOverlay as xr, RelationShape as xt, ReadMeta as y, EntityWrite as yi, ConnectionChangeSchema as yn, ConnectionChange as yr, RelationEntityAnnotation as yt, windowKey as z, RemoteError as zi, ReadRequest as zn, RemoteConnections as zr, BatchRead as zt };
+//# sourceMappingURL=index-Dh4qdXfE.d.mts.map