foldkit-remote 0.14.1 → 0.16.0

package/dist/{index-CXAGo7Dz.d.mts → index-eVkkbhPA.d.mts}

@@ -7,57 +7,91 @@ import { EntryWithoutKeepAlive } from "foldkit/subscription";
 import { ActiveSurface, Contract, Invalid, Metadata, ModelRef, Projection, Surface, SurfaceSource, Wiring } from "foldkit-surface";
 import { Rpc, RpcClientError, RpcGroup } from "effect/rpc";
 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[];
-};
+//#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/connection.d.ts
 interface EdgeRef {
@@ -208,92 +242,6 @@ declare const RemoteData: {
   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;
@@ -429,59 +377,171 @@ declare const Mutation: {
   }) => MutationDescriptor<Name, TypeOf<Input>, TypeOf<Output>, Refused>;
 };
 //#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;
+//#region src/optimistic.d.ts
+interface EntityLayer {
+  readonly id: string;
+  readonly patches: ReadonlyArray<NormalizedPatch>;
 }
 /**
- * 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.
+ * 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.
  */
-type QueryInputs<Input> = { readonly [K in keyof Input & string]: InputExpr<Input[K]>; };
+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;
 /**
- * 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.
+ * 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/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. */
@@ -497,6 +557,14 @@ type ResultOf<Result> = Result extends {
 /** 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: {
+  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").Ordering>) => <E extends AnyEntity>(self: Query<E>) => Query<E>;
+  orderFor: (self: AnyQuery, input: Readonly<Record<string, unknown>>) => ReadonlyArray<import("foldkit-entity").OrderTerm>;
+  placement: (self: AnyQuery, input: Readonly<Record<string, unknown>>) => import("foldkit-entity").Placement;
+  dependencies: (self: AnyQuery) => import("foldkit-entity").QueryDependencies;
+  unsupported: (self: AnyQuery, supported: ReadonlyArray<import("foldkit-entity").Operation>) => ReadonlyArray<import("foldkit-entity").Operation>;
+  show: (self: AnyQuery) => string;
   /** Declares the entity and options a query's result is a connection over. */
   connection: <Entity extends string>(entity: {
     readonly name: Entity;
@@ -542,19 +610,11 @@ declare const Query$1: {
   }) => RelationalQueryOf<E>, options?: {
     readonly edgeKey?: Schema.Schema<unknown>;
     readonly live?: LivePolicy;
-  }) => QueryDescriptor<Name, TypeOf<Input>, ConnectionSpec<E["name"]>>;
+  }) => 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").Ordering>) => <E extends AnyEntity>(self: Query<E>) => Query<E>;
-  orderFor: (self: AnyQuery, input: Readonly<Record<string, unknown>>) => ReadonlyArray<import("foldkit-entity").OrderTerm>;
-  placement: (self: AnyQuery, input: Readonly<Record<string, unknown>>) => import("foldkit-entity").Placement;
-  dependencies: (self: AnyQuery) => import("foldkit-entity").QueryDependencies;
-  unsupported: (self: AnyQuery, supported: ReadonlyArray<import("foldkit-entity").Operation>) => ReadonlyArray<import("foldkit-entity").Operation>;
-  show: (self: AnyQuery) => string;
 };
 //#endregion
 //#region src/requirement.d.ts
@@ -604,9 +664,9 @@ declare const Requirement: {
   mergeConnections: typeof mergeConnections;
 };
 /** Remote's entity requirements on a Projection, unioned per entity and id as nodes compose. */
-declare const RemoteRequirements: MetadataKey<Requirement>;
+declare const RemoteRequirements: import("foldkit-metadata").MetadataKey<Requirement>;
 /** Remote's query connections on a Projection, unioned per connection and window. */
-declare const RemoteConnections: MetadataKey<ConnectionRequirement>;
+declare const RemoteConnections: import("foldkit-metadata").MetadataKey<ConnectionRequirement>;
 /** The entity requirements a Projection carries. */
 declare const requirementsOf: (projection: {
   readonly metadata: Metadata;
@@ -616,372 +676,67 @@ declare const connectionsOf: (projection: {
   readonly metadata: Metadata;
 }) => ReadonlyArray<ConnectionRequirement>;
 //#endregion
-//#region src/optimistic.d.ts
-interface EntityLayer {
-  readonly id: string;
-  readonly patches: ReadonlyArray<NormalizedPatch>;
-}
+//#region src/wire.d.ts
 /**
- * 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.
+ * 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.
  */
-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;
+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;
+  /** The mutation's own `Refusal`, encoded, when the server refused it as one. */
+  readonly refusal: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+declare class RemoteMutationError extends RemoteMutationError_base {}
+declare const RemoteForbidden_base: Schema.Class<RemoteForbidden, Schema.TaggedStruct<"Forbidden", {
+  readonly message: Schema.String;
+  readonly reason: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 /**
- * Constructors for connection changes: what a request shows optimistically
- * (`MutateOptions.optimistic`) and what a mutation source reports it made
- * (`MutationOutcome.connections`).
+ * The server refused who is asking: they may not do this, and asking again
+ * as the same principal is refused again. `reason` is the application's own
+ * words for the person who asked; without it the refusal says nothing of why.
  */
-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;
-  /** The mutation's own `Refusal`, encoded, when the server refused it as one. */
-  readonly refusal: Schema.optional<Schema.Unknown>;
-}>, import("effect/Cause").YieldableError>;
-declare class RemoteMutationError extends RemoteMutationError_base {}
-declare const RemoteForbidden_base: Schema.Class<RemoteForbidden, Schema.TaggedStruct<"Forbidden", {
-  readonly message: Schema.String;
-  readonly reason: Schema.optional<Schema.String>;
-}>, import("effect/Cause").YieldableError>;
-/**
- * The server refused who is asking: they may not do this, and asking again
- * as the same principal is refused again. `reason` is the application's own
- * words for the person who asked; without it the refusal says nothing of why.
- */
-declare class RemoteForbidden extends RemoteForbidden_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>;
-}>;
+declare class RemoteForbidden extends RemoteForbidden_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
@@ -1333,21 +1088,47 @@ declare const QueryRpc: Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
     readonly fields: Schema.$Array<Schema.String>;
   }>>>;
 }>, typeof RemoteQueryError, never, never>;
-declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", Schema.Struct<{
+declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteLive", Schema.Struct<{
   readonly version: Schema.Number;
-  readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+  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 entities: Schema.$Array<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 values: Schema.$Record<Schema.String, Schema.Unknown>;
-  }>>;
-  readonly settled: Schema.$Array<Schema.Struct<{
+    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 fields: Schema.$Array<Schema.String>;
-  }>>;
-}>, Schema.Union<readonly [typeof RemoteReadError, typeof RemoteProtocolError]>, never, never> | Rpc.Rpc<"FoldkitRemoteMutate", Schema.Struct<{
+    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<"FoldkitRemoteMutate", Schema.Struct<{
   /** Stable across transport retries so a mutation is not applied twice. */
   readonly requestId: Schema.String;
   readonly mutation: Schema.String;
@@ -1385,47 +1166,7 @@ declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", Schema.S
     readonly entity: Schema.String;
     readonly id: Schema.String;
   }>>>;
-}>, Schema.Union<readonly [typeof RemoteMutationError, typeof RemoteForbidden]>, 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<{
+}>, Schema.Union<readonly [typeof RemoteMutationError, typeof RemoteForbidden]>, never, never> | Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
   readonly query: Schema.String;
   readonly input: Schema.Unknown;
   readonly window: Schema.Struct<{
@@ -1467,1022 +1208,1204 @@ declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", Schema.S
    * 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>>;
+  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> | 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>>;
+//#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/model.d.ts
+//#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';
 /**
- * The normalized cache as a Foldkit Submodel. `Remote.define` returns a schema
- * and an `update` for this shape; `updateRemote` reconciles every producer.
+ * 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.
  */
-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. */
+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;
-  /** 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 that broke, by an error or by an event ahead of their cursor, and
-   * have not resubscribed since: changes after the break are missed until the
-   * live entry restarts them and refetches what they cover.
-   */
-  readonly gaps: ReadonlySet<string>;
-  /** Each live stream that has ever broken, by stream key. One that never broke is absent. */
-  readonly streams: Readonly<Record<string, StreamHealth>>;
-  /**
-   * 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;
-  /**
-   * The storage key the cache was last restored from, through `Hydrated`'s
-   * `from`. `Data.persistence` saves under a key only once its own snapshot is
-   * in, so a save at startup cannot write the empty store over it.
-   */
-  readonly restoredFrom: Option.Option<string>;
+  readonly outcome: LiveOutcome;
   /**
-   * Under `verifyPlacement`, the order each list was placed in, by edge key,
-   * and the rows placing took out of its first page, until the server's page
-   * for it arrives to be compared with them.
+   * 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 placed: Readonly<Record<string, PlacedOrder>>;
-  /** Under `verifyPlacement`, each placement the server's page disagreed with. */
-  readonly placementMismatches: ReadonlyArray<PlacementMismatch>;
+  readonly invalidated?: string | undefined;
 }
-/** A list's first page as the client placed it: its keys in order, and those it took out. */
-interface PlacedOrder {
-  readonly order: ReadonlyArray<string>;
-  readonly dropped: ReadonlyArray<string>;
+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/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 | RemoteForbidden>;
+  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 | RemoteForbidden | TransportError, R>;
+  readonly FoldkitRemoteLive: (payload: Schema.Schema.Type<typeof LiveRequirement>) => Stream.Stream<Schema.Schema.Type<typeof LiveChange>, RemoteLiveError | RemoteProtocolError | TransportError, R>;
 }
-/** A list the client placed rows in one order and the server then listed in another. */
-interface PlacementMismatch {
-  readonly connection: string;
-  /** The keys as placed, as far as the server's page reached. */
-  readonly placed: ReadonlyArray<string>;
-  /** The keys of the server's first page. */
-  readonly served: ReadonlyArray<string>;
+/** 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;
+  readonly refusal?: unknown;
+  readonly reason?: string | undefined;
+}) => 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, unknown>, input: Input, requestId: string, keys?: readonly string[] | undefined) => Effect.Effect<{
+  output: Output;
+  entities: readonly {
+    readonly entity: string;
+    readonly id: string;
+    readonly values: {
+      readonly [x: string]: unknown;
+    };
+  }[];
+  connections: ConnectionChange[];
+  deleted: readonly {
+    readonly entity: string;
+    readonly id: string;
+  }[];
+}, RemoteForbidden | RemoteMutationError, RemoteClient>;
+//#endregion
+//#region src/relation.d.ts
+interface RefParts {
+  readonly entity: string;
+  readonly id: string;
 }
-/** How a live stream has fared, as its live entry restarts it. */
-interface StreamHealth {
-  /** How many times it broke. The live entry restarts on each, so it only grows. */
-  readonly restarts: number;
-  /** Breaks since its last applied event: what the restart's backoff grows with. */
-  readonly failures: number;
-  /** Why it last broke; none for a gap, which is not an error. */
-  readonly error: Option.Option<RemoteError>;
+/** 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;
 }
 /**
- * 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.
+ * 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.
  */
-interface Failures {
-  readonly connections: Readonly<Record<string, RemoteError>>;
-  readonly fields: Readonly<Record<string, RemoteError>>;
-}
-declare const noFailures: Failures;
+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;
 /**
- * `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.
+ * 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.
  */
-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 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;
 }
-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.
+ * 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`).
  */
-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;
+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 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 live
-   * entry restarts it.
+   * 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.
    */
-  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;
+  from: <Name extends string, S extends Schema.Constraint>(selection: Domain.Selection<Name, unknown, S>) => Selection<S['Type'], Name, 'entity'>;
   /**
-   * 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.
+   * 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.
    */
-  readonly connections?: Readonly<Record<string, ReadonlyArray<ReadonlyArray<Edge>>>> | undefined;
-  readonly merge: MergePolicy;
-  /** The storage key the snapshot was read from, when it was: `restoredFrom`. */
-  readonly from?: string | undefined;
-} |
-/** 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;
+  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'>;
   /**
-   * 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.
+   * A paginated relation: one page of refs to `entity` with a window, or, with
+   * a nested selection, one page of targets assembled through it.
    */
-  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;
-} |
+  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;
+}
 /**
- * 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.
+ * 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.
  */
-{
-  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>>;
-  }>>;
-}>;
+declare const assemble: (store: EntityStore, key: string, requirement: RelationRequirement) => Assembled | undefined;
 /**
- * The Messages' fields by tag, without `_tag`: what `defineMessageUnion` takes,
- * so an application spreads them into its own union (`Remote.messages`).
+ * 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 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;
-      readonly refusal: Schema.optional<Schema.Unknown>;
-      readonly reason: Schema.optional<Schema.String>;
-    }>;
-    stream: Schema.optional<Schema.String>;
-  };
-  RefreshStarted: {
-    requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
-  };
-  ReadStarted: {
-    requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
-    refresh: Schema.optional<Schema.Number>;
-  };
-  QueryStarted: {
-    connections: Schema.$Array<Schema.String>;
-  };
-  RetentionChanged: {
-    roots: Schema.Struct<{
-      readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
-      readonly connections: Schema.$Array<Schema.Struct<{
-        readonly identity: Schema.String;
-        readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
-      }>>;
-    }>;
-  };
-  Hydrated: {
-    connections: Schema.optional<Schema.Unknown>;
-    from: Schema.optional<Schema.String>;
-    entities: Schema.Unknown;
-    merge: Schema.Union<readonly [Schema.Literal<"replace">, Schema.Literal<"preserve-existing">]>;
-  };
-  MutationStarted: {
-    requestId: Schema.String;
-    optimistic: Schema.optional<Schema.$Array<Schema.Unknown>>;
-  };
-  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;
-      readonly refusal: Schema.optional<Schema.Unknown>;
-      readonly reason: Schema.optional<Schema.String>;
-    }>;
-  };
-  OverlayShown: {
-    id: Schema.String;
-    optimistic: Schema.$Array<Schema.Unknown>;
-  };
-  OverlayLifted: {
-    id: Schema.String;
-  };
-  WindowGrown: {
-    window: Schema.String;
-    size: Schema.Number;
-  };
-  LiveReceived: {
-    stream: Schema.String;
-    event: Schema.Unknown;
-    policy: Schema.optional<Schema.Unknown>;
-    now: Schema.Number;
-  };
-  GapCleared: {
-    stream: Schema.String;
-  };
-  ConnectionMerged: {
-    connection: Schema.String;
-    page: Schema.Unknown;
-    refreshes: Schema.optional<Schema.Boolean>;
-    select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
-    entities: Schema.optional<Schema.$Array<Schema.Struct<{
-      readonly entity: Schema.String;
-      readonly id: Schema.String;
-      readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
-    }>>>;
-    settled: Schema.optional<Schema.$Array<Schema.Struct<{
-      readonly entity: Schema.String;
-      readonly id: Schema.String;
-      readonly fields: Schema.$Array<Schema.String>;
-    }>>>;
-    now: Schema.optional<Schema.Number>;
-  };
-  ConnectionInvalidated: {
-    connection: Schema.String;
-  };
-  ConnectionRefreshed: {
-    connection: Schema.String;
-  };
-  QueryFailed: {
-    connection: Schema.String;
-    error: Schema.Struct<{
-      readonly _tag: Schema.String;
-      readonly message: Schema.String;
-      readonly refusal: Schema.optional<Schema.Unknown>;
-      readonly reason: Schema.optional<Schema.String>;
-    }>;
-  };
-};
-type RemoteMessageTag = RemoteMessage['_tag'];
+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 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.
+ * 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.
  */
-type RemoteMessageInput = { [Tag in RemoteMessageTag]: {
-  readonly _tag: Tag;
-} & Schema.Struct.Type<(typeof remoteMessageCases)[Tag]>; }[RemoteMessageTag];
+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>;
+}
 /**
- * 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.
+ * 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.
  */
-declare const isRemoteMessage: <M extends {
-  readonly _tag: string;
-}>(message: M) => message is Extract<M, {
-  readonly _tag: RemoteMessageTag;
-}>;
-declare const remoteMessageSchema: Schema.Schema<RemoteMessage>;
-/** The ids `OverlayShown` shows now, each once, in the order they are drawn. */
-declare const overlaysOf: (model: RemoteModel) => ReadonlyArray<string>;
-/** 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.
+ * 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.
  */
-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;
+type RefKey<Name extends string> = `${Name}:${string}`;
 /**
- * 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.
+ * A patch in wire shape: the values the store holds, so a relation is its ref
+ * key (`Entity.refKey`), not an `EntityRef`.
  */
-declare const refreshedAt: (refresh: RefreshState, requests: ReadonlyArray<Requirement>, connections?: ReadonlyArray<string>) => number;
+interface EntityPatch<Name extends string, F extends Schema.Struct.Fields> {
+  readonly entity: Name;
+  readonly id: string;
+  readonly values: Partial<Schema.Struct.Encoded<F>>;
+}
 /**
- * Marks every field of `requests` and every connection in `connections`
- * refreshed at the next generation.
+ * 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.
  */
-declare const withRefreshRequested: (refresh: RefreshState, requests: ReadonlyArray<Requirement>, connections?: ReadonlyArray<string>) => RefreshState;
+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: typeof 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
 /**
- * Marks connections as needing to be asked again, and restarts a read of them
- * already in flight: a page requested before what invalidated it could land
- * after it, saying what is no longer true. `Remote.refresh` marks the same way.
+ * 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.
  */
-declare const invalidateConnections: (model: RemoteModel, connections: ReadonlyArray<string>) => RemoteModel;
+interface Matched<A> {
+  readonly items: ReadonlyArray<A>;
+  /** Whether every row the answer is about was judged. */
+  readonly complete: boolean;
+}
 /**
- * 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.
+ * 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.
  */
-declare const refreshIsInFlight: (refresh: RefreshState, request: Requirement, field: string) => boolean;
+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;
+}
 /**
- * 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`.
+ * 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 isLoading: (model: RemoteModel, entity: string, id: string, fields: ReadonlyArray<string>) => boolean;
+declare const matching: <Name extends string, Input>(store: EntityStore, descriptor: QueryDescriptor<Name, Input, unknown>, input: Input, options?: MatchingOptions) => Judged;
 /**
- * The pure reducer all four producers share. A live event that arrives ahead of
- * its cursor is a gap: it is not applied, and the stream is recorded so its
- * live entry restarts it rather than silently missing facts. When every field a Message
- * touches keeps its identity, `model` itself is returned, so the application's
- * root keeps its identity and Foldkit does not render. The common no-ops do (a
- * duplicate live event, a repeated `ReadStarted`); a repeated failure, or a
- * `preserve-existing` restore of entities already held, still makes an equal
- * copy.
+ * 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.
  */
-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;
+type Belongs = 'yes' | 'no' | 'unknown';
 /**
- * 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.
+ * 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 isLoadingThrough: (model: RemoteModel, entity: string, id: string, relation: RelationRequirement) => boolean;
+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/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 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.
+ * 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 failureOf: (model: RemoteModel, entity: string, id: string, relation: RelationRequirement) => RemoteError | undefined;
+declare const reachable: (store: EntityStore, roots: RetentionRoots, connections: Readonly<Record<string, Connection>>, optimistic: OptimisticState, pending: ReadonlySet<string>) => ReadonlySet<EntityKey>;
 /**
- * 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.
+ * 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 writeRead: (store: EntityStore, requests: ReadonlyArray<Requirement>, result: Schema.Schema.Type<typeof ReadBatchResult>, now?: number) => EntityStore;
+declare const gc: (state: Retained & {
+  readonly mutations: MutationState;
+}, roots: RetentionRoots) => Retained;
 //#endregion
-//#region src/resume.d.ts
+//#region src/persistence.d.ts
+/** Bump when the serialized shape changes; a mismatch discards the cache. */
+declare const REMOTE_CACHE_VERSION = 5;
 /**
- * A resume part, in the shape `foldkit-ssr`'s `SSR.plan` takes in `parts`.
- * Declared here structurally, so neither package depends on the other.
+ * 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 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 {
+interface Snapshot {
+  readonly entities: EntityStore;
   /**
-   * How long a batch waits to collect more requirements before it runs.
-   * Requirements issued concurrently coalesce even at the default of no wait.
+   * 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 window?: Duration.Input | undefined;
+  readonly connections: Readonly<Record<string, ReadonlyArray<ReadonlyArray<Edge>>>>;
 }
-/** 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.
+ * A snapshot of a Model, keeping the entity cache and only the connections
+ * named.
+ *
+ * Naming none — the default — is exactly what Remote did before connections
+ * could be kept at all: a disposable, server-derived cache.
  */
-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 | RemoteForbidden>;
-  readonly live: (request: {
-    readonly requirements: ReadonlyArray<Requirement>;
-    readonly after: LiveCursor;
-  }) => Stream.Stream<LiveEvent, RemoteLiveError | RemoteProtocolError>;
-}>;
+declare const snapshotOf: (model: {
+  readonly entities: EntityStore;
+  readonly connections: Readonly<Record<string, Connection>>;
+}, options?: {
+  readonly connections?: ReadonlyArray<ConnectionIdentity> | undefined;
+}) => Snapshot;
+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 transport boundary. `foldkit-remote` never talks to a transport directly;
- * it depends on this Effect service, which a later phase wires to Effect RPC.
+ * 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 class RemoteClient extends RemoteClient_base {}
+declare function dehydrate(snapshot: Snapshot, options?: SnapshotOptions & {
+  readonly maxBytes?: undefined;
+}): string;
+declare function dehydrate(snapshot: Snapshot, options?: SnapshotOptions): string | undefined;
 /**
- * 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.
+ * The store a snapshot text holds, or `undefined` when the text is missing,
+ * oversized, not this version, for another scope, or malformed. Hydrating the
+ * same text twice yields equal stores.
  */
-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 | RemoteForbidden | 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;
-  readonly refusal?: unknown;
-  readonly reason?: string | undefined;
-}) => RemoteError;
-declare const coalescedLayer: <E, R>(layer: Layer.Layer<RemoteClient, E, R>, options?: CoalesceOptions) => Layer.Layer<RemoteClient, E, R>;
+declare const hydrate: (raw: string | undefined | null, options?: SnapshotOptions) => Snapshot | undefined;
 /**
- * `Remote.mutate` as a standalone effect, so `Remote.mutateInto` can reuse it
- * without the object literal referencing itself.
+ * Brings a snapshot into a store that may already hold entries. `replace`
+ * takes the snapshot's entry for every key it has; `preserve-existing` keeps
+ * an entry the current store already has (it is at least as fresh as a
+ * snapshot taken earlier). Either way, keys only the current store has stay.
  */
-declare const mutateRemote: <Name extends string, Input, Output>(mutation: MutationDescriptor<Name, Input, Output, unknown>, input: Input, requestId: string, keys?: readonly string[] | undefined) => Effect.Effect<{
-  output: Output;
-  entities: readonly {
-    readonly entity: string;
-    readonly id: string;
-    readonly values: {
-      readonly [x: string]: unknown;
-    };
-  }[];
-  connections: ConnectionChange[];
-  deleted: readonly {
-    readonly entity: string;
-    readonly id: string;
-  }[];
-}, RemoteMutationError | RemoteForbidden, RemoteClient>;
+declare const mergeStores: (current: EntityStore, snapshot: EntityStore, policy: MergePolicy) => EntityStore;
+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: typeof hydrate;
+  /**
+   * 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: typeof snapshotOf;
+  /** A snapshot's entities brought into a store by policy. */
+  mergeStores: typeof mergeStores;
+  /** 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/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;
-  readonly refusal: Schema.optional<Schema.Unknown>;
-  /** Who is asking was refused, with the application's reason when it gave one. */
-  readonly forbidden: Schema.optional<Schema.Struct<{
-    readonly reason: Schema.optional<Schema.String>;
-  }>>;
-}>]>;
-type RemoteJsonAnswer = typeof RemoteJsonAnswer.Type;
+//#region src/model.d.ts
 /**
- * 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.
+ * The normalized cache as a Foldkit Submodel. `Remote.define` returns a schema
+ * and an `update` for this shape; `updateRemote` reconciles every producer.
  */
-type RemoteJsonSend = (request: string) => Promise<unknown>;
-//#endregion
-//#region src/sse.d.ts
-/** What `httpWithLive` needs besides the URL. Mirrors `http`, plus the fetch itself. */
-interface LiveFetchOptions {
-  /** Read per request, so a token that changes reaches the next call. */
-  readonly headers?: (() => Readonly<Record<string, string>>) | undefined;
-  /** Defaults to the global one; pass it to route calls elsewhere in tests. */
-  readonly fetch?: typeof fetch | undefined;
+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 that broke, by an error or by an event ahead of their cursor, and
+   * have not resubscribed since: changes after the break are missed until the
+   * live entry restarts them and refetches what they cover.
+   */
+  readonly gaps: ReadonlySet<string>;
+  /** Each live stream that has ever broken, by stream key. One that never broke is absent. */
+  readonly streams: Readonly<Record<string, StreamHealth>>;
+  /**
+   * 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;
+  /**
+   * The storage key the cache was last restored from, through `Hydrated`'s
+   * `from`. `Data.persistence` saves under a key only once its own snapshot is
+   * in, so a save at startup cannot write the empty store over it.
+   */
+  readonly restoredFrom: Option.Option<string>;
+  /**
+   * Under `verifyPlacement`, the order each list was placed in, by edge key,
+   * and the rows placing took out of its first page, until the server's page
+   * for it arrives to be compared with them.
+   */
+  readonly placed: Readonly<Record<string, PlacedOrder>>;
+  /** Under `verifyPlacement`, each placement the server's page disagreed with. */
+  readonly placementMismatches: ReadonlyArray<PlacementMismatch>;
 }
-/** Remote's live stream over fetch: `serveFetch`'s live open as a `Stream`. */
-declare const liveFetch: (url: string, options?: LiveFetchOptions) => RemoteRpcClient["FoldkitRemoteLive"];
-/**
- * Remote's client over HTTP with live: reads, queries, and mutations as
- * `http` sends them, live as `liveFetch` streams it, for `clientLayer`.
- */
-declare const httpWithLive: (url: string, options?: LiveFetchOptions) => RemoteRpcClient;
-//#endregion
-//#region src/relation.d.ts
-interface RefParts {
-  readonly entity: string;
-  readonly id: string;
+/** A list's first page as the client placed it: its keys in order, and those it took out. */
+interface PlacedOrder {
+  readonly order: ReadonlyArray<string>;
+  readonly dropped: ReadonlyArray<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;
+/** A list the client placed rows in one order and the server then listed in another. */
+interface PlacementMismatch {
+  readonly connection: string;
+  /** The keys as placed, as far as the server's page reached. */
+  readonly placed: ReadonlyArray<string>;
+  /** The keys of the server's first page. */
+  readonly served: ReadonlyArray<string>;
 }
-/** 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;
+/** How a live stream has fared, as its live entry restarts it. */
+interface StreamHealth {
+  /** How many times it broke. The live entry restarts on each, so it only grows. */
+  readonly restarts: number;
+  /** Breaks since its last applied event: what the restart's backoff grows with. */
+  readonly failures: number;
+  /** Why it last broke; none for a gap, which is not an error. */
+  readonly error: Option.Option<RemoteError>;
 }
 /**
- * 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.
+ * 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.
  */
-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;
+interface Failures {
+  readonly connections: Readonly<Record<string, RemoteError>>;
+  readonly fields: Readonly<Record<string, RemoteError>>;
+}
+declare const noFailures: Failures;
 /**
- * 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.
+ * `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.
  */
-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;
+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 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`).
+ * 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.
  */
-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: {
+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 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.
+   * 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 live
+   * entry restarts it.
    */
-  from: <Name extends string, S extends Schema.Constraint>(selection: Domain.Selection<Name, unknown, S>) => Selection<S["Type"], Name, "entity">;
+  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 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.
+   * 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.
    */
-  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">;
+  readonly connections?: Readonly<Record<string, ReadonlyArray<ReadonlyArray<Edge>>>> | undefined;
+  readonly merge: MergePolicy;
+  /** The storage key the snapshot was read from, when it was: `restoredFrom`. */
+  readonly from?: string | undefined;
+} |
+/** 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;
   /**
-   * A paginated relation: one page of refs to `entity` with a window, or, with
-   * a nested selection, one page of targets assembled through it.
+   * 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.
    */
-  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;
-}
+  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;
+} |
 /**
- * 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.
+ * 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.
  */
-declare const assemble: (store: EntityStore, key: string, requirement: RelationRequirement) => Assembled | undefined;
+{
+  readonly _tag: 'QueryFailed';
+  readonly connection: string;
+  readonly error: RemoteError;
+} |
 /**
- * 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.
+ * What `Data.preload` read for a destination, as the Messages that wrote it,
+ * reduced in order into the Model as it is now rather than the one the
+ * preload started from.
  */
-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;
+{
+  readonly _tag: 'Preloaded';
+  readonly messages: ReadonlyArray<RemoteMessage>;
+};
+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>>;
+  }>>;
+}>;
 /**
- * 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.
+ * The Messages' fields by tag, without `_tag`: what `defineMessageUnion` takes,
+ * so an application spreads them into its own union (`Remote.messages`).
  */
-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>;
-}
+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;
+      readonly refusal: Schema.optional<Schema.Unknown>;
+      readonly reason: Schema.optional<Schema.String>;
+    }>;
+    stream: Schema.optional<Schema.String>;
+  };
+  RefreshStarted: {
+    requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+  };
+  ReadStarted: {
+    requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+    refresh: Schema.optional<Schema.Number>;
+  };
+  QueryStarted: {
+    connections: Schema.$Array<Schema.String>;
+  };
+  RetentionChanged: {
+    roots: Schema.Struct<{
+      readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      readonly connections: Schema.$Array<Schema.Struct<{
+        readonly identity: Schema.String;
+        readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+      }>>;
+    }>;
+  };
+  Hydrated: {
+    connections: Schema.optional<Schema.Unknown>;
+    from: Schema.optional<Schema.String>;
+    entities: Schema.Unknown;
+    merge: Schema.Union<readonly [Schema.Literal<"replace">, Schema.Literal<"preserve-existing">]>;
+  };
+  MutationStarted: {
+    requestId: Schema.String;
+    optimistic: Schema.optional<Schema.$Array<Schema.Unknown>>;
+  };
+  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;
+      readonly refusal: Schema.optional<Schema.Unknown>;
+      readonly reason: Schema.optional<Schema.String>;
+    }>;
+  };
+  OverlayShown: {
+    id: Schema.String;
+    optimistic: Schema.$Array<Schema.Unknown>;
+  };
+  OverlayLifted: {
+    id: Schema.String;
+  };
+  WindowGrown: {
+    window: Schema.String;
+    size: Schema.Number;
+  };
+  LiveReceived: {
+    stream: Schema.String;
+    event: Schema.Unknown;
+    policy: Schema.optional<Schema.Unknown>;
+    now: Schema.Number;
+  };
+  GapCleared: {
+    stream: Schema.String;
+  };
+  ConnectionMerged: {
+    connection: Schema.String;
+    page: Schema.Unknown;
+    refreshes: Schema.optional<Schema.Boolean>;
+    select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+    entities: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+    }>>>;
+    settled: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly fields: Schema.$Array<Schema.String>;
+    }>>>;
+    now: Schema.optional<Schema.Number>;
+  };
+  ConnectionInvalidated: {
+    connection: Schema.String;
+  };
+  ConnectionRefreshed: {
+    connection: Schema.String;
+  };
+  QueryFailed: {
+    connection: Schema.String;
+    error: Schema.Struct<{
+      readonly _tag: Schema.String;
+      readonly message: Schema.String;
+      readonly refusal: Schema.optional<Schema.Unknown>;
+      readonly reason: Schema.optional<Schema.String>;
+    }>;
+  };
+  Preloaded: {
+    messages: Schema.$Array<Schema.suspend<Schema.Codec<RemoteMessage, unknown, never, never>>>;
+  };
+};
+type RemoteMessageTag = RemoteMessage['_tag'];
 /**
- * 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 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];
 /**
- * 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.
+ * 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.
  */
-type RefKey<Name extends string> = `${Name}:${string}`;
+declare const isRemoteMessage: <M extends {
+  readonly _tag: string;
+}>(message: M) => message is Extract<M, {
+  readonly _tag: RemoteMessageTag;
+}>;
+declare const remoteMessageSchema: Schema.Codec<RemoteMessage, unknown>;
+/** The ids `OverlayShown` shows now, each once, in the order they are drawn. */
+declare const overlaysOf: (model: RemoteModel) => ReadonlyArray<string>;
+/** The key a grown window is kept under: its connection and the window first asked for. */
+declare const windowGrowthKey: (identity: string, window: string) => string;
 /**
- * A patch in wire shape: the values the store holds, so a relation is its ref
- * key (`Entity.refKey`), not an `EntityRef`.
+ * 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.
  */
-interface EntityPatch<Name extends string, F extends Schema.Struct.Fields> {
-  readonly entity: Name;
-  readonly id: string;
-  readonly values: Partial<Schema.Struct.Encoded<F>>;
-}
+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;
 /**
- * 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.
+ * 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.
  */
-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;
+declare const refreshedAt: (refresh: RefreshState, requests: ReadonlyArray<Requirement>, connections?: ReadonlyArray<string>) => number;
 /**
- * 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
+ * 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;
 /**
- * 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.
+ * Marks connections as needing to be asked again, and restarts a read of them
+ * already in flight: a page requested before what invalidated it could land
+ * after it, saying what is no longer true. `Remote.refresh` marks the same way.
  */
-interface Matched<A> {
-  readonly items: ReadonlyArray<A>;
-  /** Whether every row the answer is about was judged. */
-  readonly complete: boolean;
-}
+declare const invalidateConnections: (model: RemoteModel, connections: ReadonlyArray<string>) => RemoteModel;
 /**
- * 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.
+ * 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.
  */
-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;
-}
+declare const refreshIsInFlight: (refresh: RefreshState, request: Requirement, field: string) => boolean;
 /**
- * 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.
+ * 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 matching: <Name extends string, Input>(store: EntityStore, descriptor: QueryDescriptor<Name, Input, unknown>, input: Input, options?: MatchingOptions) => Judged;
+declare const isLoading: (model: RemoteModel, entity: string, id: string, fields: ReadonlyArray<string>) => boolean;
 /**
- * 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.
+ * The pure reducer all four producers share. A live event that arrives ahead of
+ * its cursor is a gap: it is not applied, and the stream is recorded so its
+ * live entry restarts it rather than silently missing facts. When every field a Message
+ * touches keeps its identity, `model` itself is returned, so the application's
+ * root keeps its identity and Foldkit does not render. The common no-ops do (a
+ * duplicate live event, a repeated `ReadStarted`); a repeated failure, or a
+ * `preserve-existing` restore of entities already held, still makes an equal
+ * copy.
  */
-type Belongs = 'yes' | 'no' | 'unknown';
+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;
 /**
- * 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.
+ * 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 belongsEncoded: <Name extends string, Input>(store: EntityStore, descriptor: QueryDescriptor<Name, Input, unknown>, encoded: Readonly<Record<string, unknown>>, key: EntityKey) => Belongs;
+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/inspect.d.ts
 /** A query body's `Dependencies` as plain data: each field by its Entity's name and key. */
@@ -2532,7 +2455,7 @@ interface RemoteInspection {
 /** 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;
+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.
@@ -2684,7 +2607,7 @@ type RemotePolicy =
 declare const RemotePolicy: {
   /** Fetch only what the store lacks. */
   cacheFirst: {
-    readonly _tag: "CacheFirst";
+    readonly _tag: 'CacheFirst';
   };
   /** Keep present values visible, read as `Refreshing`, and refetch an entry older than `maxAge` ms. */
   staleWhileRevalidate: (options: {
@@ -2692,7 +2615,7 @@ declare const RemotePolicy: {
   }) => RemotePolicy;
   /** Fetch every selected field regardless of coverage; cached values stay visible meanwhile. */
   networkOnly: {
-    readonly _tag: "NetworkOnly";
+    readonly _tag: 'NetworkOnly';
   };
   /** The planner options a policy compiles to at `now`. */
   toPlan: (policy: RemotePolicy, now: number) => PlanOptions;
@@ -2704,6 +2627,89 @@ declare const RemotePolicy: {
   refreshes: (policy: RemotePolicy) => boolean;
 };
 //#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;
+}
+/**
+ * The resume part for a Remote domain, for `SSR.plan`'s `parts`: it sends
+ * what the plan's active Surfaces read from this domain's store, and nothing
+ * else of it. `id` tells two domains in one application apart.
+ */
+declare const resumePart: <AppModel, Store extends RemoteModel>(domain: {
+  readonly store: ModelRef<AppModel, Store>;
+}, options?: {
+  readonly id?: string | undefined;
+}) => RemoteResumePart<AppModel>;
+//#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;
+  readonly refusal: Schema.optional<Schema.Unknown>;
+  /** Who is asking was refused, with the application's reason when it gave one. */
+  readonly forbidden: Schema.optional<Schema.Struct<{
+    readonly reason: Schema.optional<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>;
+/** Remote's client over `send`, for `Remote.clientLayer`. */
+declare const json: (send: RemoteJsonSend) => RemoteRpcClient;
+/**
+ * Remote's client over HTTP: each call a `POST` of the request to `url`, the
+ * answer its JSON body whatever its status. A 403 is answered as forbidden
+ * unless its body says so itself, as the server's own does: one from
+ * middleware in front of Remote (a refused session) may say only `{ error }`.
+ * `headers` is read per request, so a token that changes reaches the next
+ * call. `fetch` defaults to the global one; pass it to route calls through
+ * another implementation in tests.
+ */
+declare const http: (url: string, options?: {
+  readonly headers?: (() => Readonly<Record<string, string>>) | undefined;
+  readonly fetch?: typeof fetch | undefined;
+}) => RemoteRpcClient;
+//#endregion
+//#region src/sse.d.ts
+/** What `httpWithLive` needs besides the URL. Mirrors `http`, plus the fetch itself. */
+interface LiveFetchOptions {
+  /** Read per request, so a token that changes reaches the next call. */
+  readonly headers?: (() => Readonly<Record<string, string>>) | undefined;
+  /** Defaults to the global one; pass it to route calls elsewhere in tests. */
+  readonly fetch?: typeof fetch | undefined;
+}
+/** Remote's live stream over fetch: `serveFetch`'s live open as a `Stream`. */
+declare const liveFetch: (url: string, options?: LiveFetchOptions) => RemoteRpcClient['FoldkitRemoteLive'];
+/**
+ * Remote's client over HTTP with live: reads, queries, and mutations as
+ * `http` sends them, live as `liveFetch` streams it, for `clientLayer`.
+ */
+declare const httpWithLive: (url: string, options?: LiveFetchOptions) => RemoteRpcClient;
+//#endregion
 //#region src/placement.d.ts
 /** Where a row falls in a loaded list. */
 type RowPlace = Data.TaggedEnum<{
@@ -2724,65 +2730,43 @@ type RowPlace = Data.TaggedEnum<{
   };
 }>;
 declare const RowPlace: {
-  readonly Unknown: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Unknown";
-    readonly reason: string;
-  }, "_tag">;
-  readonly Before: Data.TaggedEnum.ConstructorFrom<{
+  readonly $is: <Tag extends "Before" | "End" | "Outside" | "Unknown">(tag: Tag) => (u: unknown) => u is Extract<{
     readonly _tag: "Before";
     readonly segment: number;
     readonly edge: string;
-  }, "_tag">;
-  readonly End: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "End";
-    readonly segment: number;
-  }, "_tag">;
-  readonly Outside: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Outside";
-  }, "_tag">;
-  readonly $is: <Tag extends "Unknown" | "Before" | "End" | "Outside">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Unknown";
-    readonly reason: string;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Before";
+    readonly _tag: "End";
     readonly segment: number;
-    readonly edge: string;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "End";
-    readonly segment: number;
+    readonly _tag: "Outside";
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Outside";
+    readonly _tag: "Unknown";
+    readonly reason: string;
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends {
-      readonly Unknown: (args: {
-        readonly _tag: "Unknown";
-        readonly reason: string;
-      }) => any;
-      readonly Before: (args: {
-        readonly _tag: "Before";
-        readonly segment: number;
-        readonly edge: string;
-      }) => any;
-      readonly End: (args: {
-        readonly _tag: "End";
-        readonly segment: number;
-      }) => any;
-      readonly Outside: (args: {
-        readonly _tag: "Outside";
-      }) => any;
-    }>(cases: Cases): (value: {
+    <Cases extends { readonly [Tag in "Before" | "End" | "Outside" | "Unknown"]: (args: Extract<{
+      readonly _tag: "Before";
+      readonly segment: number;
+      readonly edge: string;
+    } | {
+      readonly _tag: "End";
+      readonly segment: number;
+    } | {
+      readonly _tag: "Outside";
+    } | {
       readonly _tag: "Unknown";
       readonly reason: string;
-    } | {
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
       readonly _tag: "Before";
       readonly segment: number;
       readonly edge: string;
@@ -2791,28 +2775,25 @@ declare const RowPlace: {
       readonly segment: number;
     } | {
       readonly _tag: "Outside";
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Unknown" | "Before" | "End" | "Outside"]>>;
-    <Cases extends {
-      readonly Unknown: (args: {
-        readonly _tag: "Unknown";
-        readonly reason: string;
-      }) => any;
-      readonly Before: (args: {
-        readonly _tag: "Before";
-        readonly segment: number;
-        readonly edge: string;
-      }) => any;
-      readonly End: (args: {
-        readonly _tag: "End";
-        readonly segment: number;
-      }) => any;
-      readonly Outside: (args: {
-        readonly _tag: "Outside";
-      }) => any;
-    }>(value: {
+    } | {
       readonly _tag: "Unknown";
       readonly reason: string;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Before" | "End" | "Outside" | "Unknown"]>>;
+    <Cases extends { readonly [Tag in "Before" | "End" | "Outside" | "Unknown"]: (args: Extract<{
+      readonly _tag: "Before";
+      readonly segment: number;
+      readonly edge: string;
+    } | {
+      readonly _tag: "End";
+      readonly segment: number;
+    } | {
+      readonly _tag: "Outside";
     } | {
+      readonly _tag: "Unknown";
+      readonly reason: string;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
       readonly _tag: "Before";
       readonly segment: number;
       readonly edge: string;
@@ -2821,8 +2802,27 @@ declare const RowPlace: {
       readonly segment: number;
     } | {
       readonly _tag: "Outside";
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Unknown" | "Before" | "End" | "Outside"]>>;
+    } | {
+      readonly _tag: "Unknown";
+      readonly reason: string;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Before" | "End" | "Outside" | "Unknown"]>>;
   };
+  readonly Before: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Before";
+    readonly segment: number;
+    readonly edge: string;
+  }, "_tag">;
+  readonly End: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "End";
+    readonly segment: number;
+  }, "_tag">;
+  readonly Outside: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Outside";
+  }, "_tag">;
+  readonly Unknown: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Unknown";
+    readonly reason: string;
+  }, "_tag">;
 };
 /**
  * Where the row stored under `key` falls in `connection`, by `body`'s order
@@ -3166,6 +3166,19 @@ interface RemoteDomain<AppModel, Store extends RemoteModel, Entities extends rea
    * held is not asked again.
    */
   satisfy(model: AppModel, active: Readonly<Record<string, ActiveEntry<AppModel>>>, options?: SatisfyOptions): Effect.Effect<AppModel, RemoteReadError | RemoteProtocolError | RemoteQueryError | RemoteUnsatisfied, RemoteClient>;
+  /**
+   * `satisfy` from `update`, for a destination the reader has not reached:
+   * a hover over a link, or a navigation the app expects. `model` is the
+   * Model as it would be there (the route set to the target's); the Command
+   * reads what `active` would read in it and yields one `Preloaded`
+   * carrying the Messages that wrote it, which reduce into the Model as it is
+   * by then. It never fails: a read that fails is one the destination makes
+   * again, and what was read before it still arrives.
+   *
+   * What it reads is kept like any other read until the next change of what
+   * is retained, so preload close to the navigation it expects.
+   */
+  preload(model: AppModel, active: Readonly<Record<string, ActiveEntry<AppModel>>>, options?: SatisfyOptions): Command<RemoteMessage, never, RemoteClient>;
   /**
    * Starts a registered mutation from `update`: applies `MutationStarted` (with
    * the optimistic operations) to the Model and returns the Command that runs
@@ -3230,6 +3243,8 @@ interface RemoteFold<AppModel, ParentMessage, Domain extends RemoteDomain<AppMod
   (model: AppModel, message: RemoteMessage | RemoteMessageInput): Update.Return<AppModel, ParentMessage>;
   /** `Data.mutate`, its Command lifted. */
   readonly mutate: (...args: Parameters<Domain['mutate']>) => FoldedMutationStarted<AppModel, ParentMessage>;
+  /** `Data.preload`, its Command lifted. */
+  readonly preload: (...args: Parameters<Domain['preload']>) => Command<ParentMessage, never, RemoteClient>;
   /** `Data.subscriptions`, every entry lifted to the wrapper Message. */
   readonly subscriptions: <const Active extends Readonly<Record<string, ActiveEntry<AppModel>>>>(active: Active, options?: SubscriptionsOptions) => SubscriptionEntries<AppModel, Active, ParentMessage>;
 }
@@ -3325,6 +3340,14 @@ interface LiveOptions {
   /** The longest a restart waits. Default `5 seconds`. */
   readonly maxRetryDelay?: Duration.Input | undefined;
 }
+/** Declares a Remote domain: its entities, queries, and mutations, plus the submodel. */
+declare const defineRemote: <const Entities extends readonly EntityLike[], const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<any, any, any>[], const Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly MutationDescriptor<any, any, any>[]>(config: {
+  readonly entities: Entities;
+  readonly queries?: Queries;
+  readonly mutations?: Mutations;
+}) => RemoteDescriptor<Entities, Queries, Mutations>;
+/** Binds a Remote domain to its store's location in the application Model. */
+declare const bindRemote: <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]>>;
 /** A query the read entry runs, as its dependencies carry it: plain data Foldkit compares. */
 declare const PlannedQuery: Schema.Struct<{
   readonly identity: Schema.String;
@@ -3496,13 +3519,12 @@ declare const Remote: {
         readonly reason: Schema.optional<Schema.String>;
       }>;
     };
+    Preloaded: {
+      messages: Schema.$Array<Schema.suspend<Schema.Codec<RemoteMessage, unknown, never, never>>>;
+    };
   };
   /** 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;
-  }>;
+  reduces: typeof isRemoteMessage;
   /**
    * Remote's Messages as one Schema, for a wrapper variant in the
    * application's union: `GotRemoteMessage: { message: Remote.Message }`. With
@@ -3640,6 +3662,9 @@ declare const Remote: {
         readonly reason: Schema.optional<Schema.String>;
       }>;
     };
+    Preloaded: {
+      messages: Schema.$Array<Schema.suspend<Schema.Codec<RemoteMessage, unknown, never, never>>>;
+    };
   }>;
   /**
    * A bound domain under one wrapper variant of the application's union, the
@@ -3704,28 +3729,20 @@ declare const Remote: {
    * 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, unknown>[]>(config: {
-    readonly entities: Entities;
-    readonly queries?: Queries;
-    readonly mutations?: Mutations;
-  }) => RemoteDescriptor<Entities, Queries, Mutations>;
+  define: typeof defineRemote;
   /**
    * Binds a Remote domain to its store's location in the application Model. The
    * registered entity names are carried on the returned value, so `Remote.select`
    * rejects a selection for an entity this domain never declared.
    */
-  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]>>;
+  at: typeof bindRemote;
   /**
    * 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>;
+  resume: typeof resumePart;
   /**
    * A Projection node that reads a `RemoteData` value out of the store. The id
    * is supplied by the caller, usually from a Surface's params. The assembled
@@ -3733,7 +3750,7 @@ declare const Remote: {
    * 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>>;
+  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.
@@ -3774,7 +3791,7 @@ declare const Remote: {
    * `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>;
+  prefetch: <AppModel, Store extends RemoteModel, Value>(bound: BoundRemote<AppModel, Store, string>, model: AppModel, projection: Projection<AppModel, Value>, options?: ObserveOptions | undefined) => Effect.Effect<Readonly<Record<string, EntityEntry>>, RemoteProtocolError | RemoteReadError, 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`,
@@ -3812,7 +3829,7 @@ declare const Remote: {
    * 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;
+  writeRead: typeof writeRead;
   /**
    * Adapts an Effect RPC client for `RemoteRpc` to `RemoteClient`, so an
    * application provides the transport's RPC layer instead of writing the
@@ -3826,29 +3843,26 @@ declare const Remote: {
    * answer, for `clientLayer`: a worker, a server in the page. `RemoteServer.answer`
    * is the other end.
    */
-  json: (send: RemoteJsonSend) => RemoteRpcClient;
+  json: typeof json;
   /**
    * Remote's client over HTTP, for `clientLayer`: each call a `POST` of the JSON
    * request to `url`. `headers` is read per request (a session token, say).
    */
-  http: (url: string, options?: {
-    readonly headers?: (() => Readonly<Record<string, string>>) | undefined;
-    readonly fetch?: typeof fetch | undefined;
-  }) => RemoteRpcClient;
+  http: typeof http;
   /**
    * Remote's client over HTTP with live, for `clientLayer`: reads, queries,
    * and mutations as `http` sends them, live requirements as one `POST`
    * answered with a `text/event-stream` of changes.
    * `foldkit-remote-server/fetch` is the other end.
    */
-  httpWithLive: (url: string, options?: LiveFetchOptions) => RemoteRpcClient;
+  httpWithLive: typeof httpWithLive;
   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>;
+  coalesced: typeof coalescedLayer;
   /**
    * A Foldkit Subscription entry that keeps the cache to what the active
    * Surfaces reach. `projections` are the ones the application observes (the
@@ -3901,9 +3915,9 @@ declare const Remote: {
   /** The `RemoteMessage` that merges a query page into its connection. */
   queryMessage: <Name extends string, Input>(ref: QueryRef<Name, Input>, result: Schema.Schema.Type<typeof QueryResult>, select?: RelationRequirement | undefined, now?: number | undefined) => RemoteMessage;
   /** A pure, serializable view of the whole cache. */
-  inspect: (model: RemoteModel) => RemoteInspection;
+  inspect: typeof inspectRemote;
   /** A pure, serializable view of one entity, or `undefined` if unknown. */
-  inspectEntity: (model: RemoteModel, key: string) => RemoteInspection["entities"][number] | undefined;
+  inspectEntity: typeof inspectEntity;
   /**
    * Runs a mutation through `RemoteClient`, decoding its typed Output and
    * returning the result's normalized patches so the caller can reconcile them
@@ -3923,7 +3937,7 @@ declare const Remote: {
       readonly entity: string;
       readonly id: string;
     }[];
-  }, RemoteMutationError | RemoteForbidden, RemoteClient>;
+  }, RemoteForbidden | 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
@@ -3934,7 +3948,7 @@ declare const Remote: {
   mutateInto: <Name extends string, Input, Output, AppModel, Store extends RemoteModel>(bound: BoundRemote<AppModel, Store, string>, model: AppModel, mutation: MutationDescriptor<Name, Input, Output, unknown>, input: Input, requestId: string, options?: MutateOptions | undefined) => Effect.Effect<{
     output: Output;
     model: AppModel;
-  }, RemoteMutationError | RemoteForbidden, RemoteClient>;
+  }, RemoteForbidden | RemoteMutationError, RemoteClient>;
   /**
    * A Foldkit Subscription entry that plans a Surface's missing fields from the
    * Model and fetches them through `RemoteClient`, emitting a `RemoteMessage`
@@ -3956,5 +3970,5 @@ declare const Remote: {
   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 { Matched as $, writeEntity as $i, RelationRequest as $n, RemoteConnections as $r, RemoteResumePart as $t, RemoteWiring as A, patchOfWrite as Ai, withRefreshRequested as An, emptyLiveState as Ar, refsIn as At, PlanFreshness as B, entry as Bi, MutationRequest as Bn, addOverlay as Br, RemoteClient as Bt, Registered as C, SchemaOrFields as Ci, refreshedAt as Cn, LiveCursor as Cr, RelationAnnotation as Ct, RemoteEntry as D, failMutation as Di, retentionRootsSchema as Dn, applyConnectionEvent as Dr, aliasedField as Dt, RemoteDomain as E, emptyMutationState as Ei, remoteModelSchema as En, LiveState as Er, RelationShape as Et, SubscriptionsOptions as F, EntityStore as Fi, LiveEdge as Fn, ConnectionOverlay as Fr, httpWithLive as Ft, ExplainedDependencies as G, markStale as Gi, QueryRequest as Gn, removeLayer as Gr, mutateRemote as Gt, deadlineOf as H, isFieldStale as Hi, NormalizedEntity as Hn, connectionIdentity as Hr, coalescedLayer as Ht, RowPlace as I, EntityWrite as Ii, LiveRequirement as In, EntityLayer as Ir, liveFetch as It, RemoteInspection as J, remove as Ji, REMOTE_PROTOCOL_VERSION as Jn, settleSuccess as Jr, CoalesceOptions as Jt, QueryExplanation as K, missingFields as Ki, QueryResult as Kn, removeOverlay as Kr, remoteError as Kt, placeIn as L, clearStale as Li, MAX_FIELDS_PER_REQUEST as Ln, OptimisticOperation as Lr, RemoteJsonAnswer as Lt, SatisfyOptions as M, schemaOf as Mi, ConnectionChangeSchema as Mn, liveHasPrevious as Mr, relationShape as Mt, SelectsEntity as N, EntityEntry as Ni, Live as Nn, ConnectionChange as Nr, targetsOf as Nt, RemoteFold as O, mutationStatus as Oi, updateRemote as On, applyEntityEvent as Or, isRefPage as Ot, SubscriptionEntries as P, EntityKey as Pi, LiveChange as Pn, ConnectionIdentity as Pr, LiveFetchOptions as Pt, Judged as Q, writeEntities as Qi, ReadRequest as Qn, RelationRequirement as Qr, requirementKey as Qt, RemotePolicy as R, emptyStore as Ri, MAX_RELATION_DEPTH as Rn, OptimisticState as Rr, RemoteJsonRequest as Rt, ReadMeta as S, Refusal as Si, refreshIsInFlight as Sn, EntityApplied as Sr, RefParts as St, RemoteDescriptor as T, beginMutation as Ti, remoteMessageSchema as Tn, LiveOutcome as Tr, RelationKind as Tt, plan as U, isFieldUnavailable as Ui, PageSize as Un, emptyOptimistic as Ur, connectionChangeOf as Ut, PlanOptions as V, hasField as Vi, MutationResult as Vn, beginOptimistic as Vr, RemoteRpcClient as Vt, windowKey as W, isTombstone as Wi, QueryEdge as Wn, pruneOverlays as Wr, liveEventOf as Wt, inspectRemote as X, setUnavailable as Xi, ReadBatch as Xn, visibleStore as Xr, coalesceQueries as Xt, inspectEntity as Y, setStale as Yi, Read as Yn, visibleItems as Yr, QueryRun as Yt, Belongs as Z, tombstone as Zi, ReadBatchResult as Zn, ConnectionRequirement as Zr, coalesceReads as Zt, QueryOptions as _, items as _a, MutationDescriptor as _i, isQueryLoading as _n, RetentionRoots as _r, pageSchema as _t, EntitySelection as a, Boundary as aa, IDENTITY_SEPARATOR as ai, RemoteMessageInput as an, RemoteReadError as ar, EntityDescriptor as at, QueryWindowOptions as b, terminal as ba, NormalizedPatch as bi, onlyOverlaid as bn, BoundaryCounts as br, RELATION_ALIAS as bt, LiveOptions as c, Edge as ca, Query$1 as ci, StreamHealth as cn, WindowSchema as cr, FieldsFrom as ct, MutateOptions as d, cursor as da, QueryRef as di, forgetRemote as dn, REMOTE_CACHE_VERSION as dr, Page as dt, Freshness as ea, RemoteRequirements as ei, Failures as en, RemoteForbidden as er, MatchingOptions as et, MutationStarted as f, edge as fa, QueryWindow as fi, initialRemoteModel as fn, RemotePersistence as fr, Selection as ft, QueryInput as g, isGapped as ga, MutationAnswer as gi, isLoadingThrough as gn, Retained as gr, assemble as gt, QueryEntity as h, hasPrevious as ha, Mutation as hi, isLoading as hn, ConnectionRoot as hr, SelectionValueOf as ht, EntityLike as i, remoteErrorSchema as ia, ConnectionSpec as ii, RemoteMessage as in, RemoteQueryError as ir, Entity$2 as it, RetainOptions as j, reconcileMutation as ji, writeRead as jn, liveHasNext as jr, relationAlias as jt, RemoteUnsatisfied as k, optimisticOfWrite as ki, windowGrowthKey as kn, classifyLive as kr, refParts as kt, LiveStatus as l, EdgeRef as la, QueryDescriptor as li, emptyRefresh as ln, WireBoundary as lr, RefKey as lt, PersistenceOptions as m, hasNext as ma, stableStringify as mi, isFieldFailed as mn, SnapshotOptions as mr, SelectionValue as mt, BoundRemote as n, RemoteError as na, connectionsOf as ni, PlacementMismatch as nn, RemoteMutationError as nr, matching as nt, FoldedMutationStarted as o, Connection as oa, LiveInsertion as oi, RemoteMessageTag as on, RemoteRpc as or, EntityPatch as ot, ObserveOptions as p, emptyConnection as pa, ResultOf as pi, invalidateConnections as pn, Snapshot as pr, SelectionOf as pt, ReadDiagnosis as q, readField as qi, QueryRpc as qn, settleFailure as qr, BatchRead as qt, DomainMutateOptions as r, remoteDataSchema as ra, requirementsOf as ri, RefreshState as rn, RemoteProtocolError as rr, AnySchema as rt, LiveDependencies as s, Cursor as sa, LivePolicy as si, RemoteModel as sn, SettledFields as sr, EntityRef as st, ActiveEntry as t, RemoteData as ta, Requirement as ti, PlacedOrder as tn, RemoteLiveError as tr, belongsEncoded as tt, ModelOfDomain as u, Segment as ua, QueryInputs as ui, failureOf as un, MergePolicy as ur, RefPage as ut, QueryProjection as v, merge as va, MutationState as vi, isRemoteMessage as vn, gc as vr, relationOf as vt, Remote as w, TypeOf as wi, remoteMessageCases as wn, LiveEvent as wr, RelationEntityAnnotation as wt, ReadDependencies as x, unknown as xa, Reconciled as xi, overlaysOf as xn, ConnectionApplied as xr, RefPageValue as xt, QueryRequirement as y, segment as ya, MutationStatus as yi, noFailures as yn, reachable as yr, unavailableOf as yt, Deadline as z, entityKey as zi, Mutate as zn, addLayer as zr, RemoteJsonSend as zt };
-//# sourceMappingURL=index-CXAGo7Dz.d.mts.map
+export { QueryExplanation as $, terminal as $i, coalesceReads as $n, ConnectionOverlay as $r, Entity$2 as $t, RemoteWiring as A, patchOfWrite as Ai, RemoteRpcClient as An, SettledFields as Ar, remoteModelSchema as At, liveFetch as B, Cursor as Bi, LiveEvent as Bn, ConnectionSpec as Br, SnapshotOptions as Bt, Registered as C, SchemaOrFields as Ci, isRefPage as Cn, RemoteForbidden as Cr, noFailures as Ct, RemoteEntry as D, failMutation as Di, relationShape as Dn, RemoteQueryError as Dr, refreshedAt as Dt, RemoteDomain as E, emptyMutationState as Ei, relationAlias as En, RemoteProtocolError as Er, refreshIsInFlight as Et, SubscriptionsOptions as F, RemoteError as Fi, remoteError as Fn, RemoteConnections as Fr, writeRead as Ft, RemotePolicy as G, edge as Gi, classifyLive as Gn, QueryDescriptor as Gr, reachable as Gt, RemoteJsonRequest as H, EdgeRef as Hi, LiveState as Hn, LiveInsertion as Hr, Retained as Ht, RowPlace as I, remoteDataSchema as Ii, BoundaryCounts as In, RemoteRequirements as Ir, MergePolicy as It, PlanOptions as J, hasPrevious as Ji, liveHasPrevious as Jn, QueryWindow as Jr, Matched as Jt, Deadline as K, emptyConnection as Ki, emptyLiveState as Kn, QueryInputs as Kr, Belongs as Kt, placeIn as L, remoteErrorSchema as Li, ConnectionApplied as Ln, Requirement as Lr, REMOTE_CACHE_VERSION as Lt, SatisfyOptions as M, schemaOf as Mi, connectionChangeOf as Mn, WireBoundary as Mr, updateRemote as Mt, SelectsEntity as N, Freshness as Ni, liveEventOf as Nn, ConnectionRequirement as Nr, windowGrowthKey as Nt, RemoteFold as O, mutationStatus as Oi, targetsOf as On, RemoteReadError as Or, remoteMessageCases as Ot, SubscriptionEntries as P, RemoteData as Pi, mutateRemote as Pn, RelationRequirement as Pr, withRefreshRequested as Pt, ExplainedDependencies as Q, segment as Qi, coalesceQueries as Qn, ConnectionIdentity as Qr, AnySchema as Qt, LiveFetchOptions as R, Boundary as Ri, EntityApplied as Rn, connectionsOf as Rr, RemotePersistence as Rt, ReadMeta as S, Refusal as Si, aliasedField as Sn, RelationRequest as Sr, isRemoteMessage as St, RemoteDescriptor as T, beginMutation as Ti, refsIn as Tn, RemoteMutationError as Tr, overlaysOf as Tt, RemoteJsonSend as U, Segment as Ui, applyConnectionEvent as Un, LivePolicy as Ur, RetentionRoots as Ut, RemoteJsonAnswer as V, Edge as Vi, LiveOutcome as Vn, IDENTITY_SEPARATOR as Vr, ConnectionRoot as Vt, RemoteResumePart as W, cursor as Wi, applyEntityEvent as Wn, Query$1 as Wr, gc as Wt, plan as X, items as Xi, CoalesceOptions as Xn, stableStringify as Xr, belongsEncoded as Xt, deadlineOf as Y, isGapped as Yi, BatchRead as Yn, ResultOf as Yr, MatchingOptions as Yt, windowKey as Z, merge as Zi, QueryRun as Zn, ConnectionChange as Zr, matching as Zt, QueryOptions as _, setStale as _a, MutationDescriptor as _i, RefParts as _n, REMOTE_PROTOCOL_VERSION as _r, invalidateConnections as _t, EntitySelection as a, clearStale as aa, beginOptimistic as ai, RefPage as an, LiveRequirement as ar, PlacedOrder as at, QueryWindowOptions as b, writeEntities as ba, NormalizedPatch as bi, RelationKind as bn, ReadBatchResult as br, isLoadingThrough as bt, LiveOptions as c, entry as ca, pruneOverlays as ci, SelectionOf as cn, Mutate as cr, RemoteMessage as ct, MutateOptions as d, isFieldUnavailable as da, settleFailure as di, assemble as dn, NormalizedEntity as dr, RemoteModel as dt, unknown as ea, EntityLayer as ei, EntityDescriptor as en, requirementKey as er, ReadDiagnosis as et, MutationStarted as f, isTombstone as fa, settleSuccess as fi, pageSchema as fn, PageSize as fr, StreamHealth as ft, QueryInput as g, remove as ga, MutationAnswer as gi, RefPageValue as gn, QueryRpc as gr, initialRemoteModel as gt, QueryEntity as h, readField as ha, Mutation as hi, RELATION_ALIAS as hn, QueryResult as hr, forgetRemote as ht, EntityLike as i, EntityWrite as ia, addOverlay as ii, RefKey as in, LiveEdge as ir, Failures as it, RetainOptions as j, reconcileMutation as ji, coalescedLayer as jn, WindowSchema as jr, retentionRootsSchema as jt, RemoteUnsatisfied as k, optimisticOfWrite as ki, RemoteClient as kn, RemoteRpc as kr, remoteMessageSchema as kt, LiveStatus as l, hasField as la, removeLayer as li, SelectionValue as ln, MutationRequest as lr, RemoteMessageInput as lt, PersistenceOptions as m, missingFields as ma, visibleStore as mi, unavailableOf as mn, QueryRequest as mr, failureOf as mt, BoundRemote as n, EntityKey as na, OptimisticState as ni, EntityRef as nn, Live as nr, inspectEntity as nt, FoldedMutationStarted as o, emptyStore as oa, connectionIdentity as oi, Page as on, MAX_FIELDS_PER_REQUEST as or, PlacementMismatch as ot, ObserveOptions as p, markStale as pa, visibleItems as pi, relationOf as pn, QueryEdge as pr, emptyRefresh as pt, PlanFreshness as q, hasNext as qi, liveHasNext as qn, QueryRef as qr, Judged as qt, DomainMutateOptions as r, EntityStore as ra, addLayer as ri, FieldsFrom as rn, LiveChange as rr, inspectRemote as rt, LiveDependencies as s, entityKey as sa, emptyOptimistic as si, Selection as sn, MAX_RELATION_DEPTH as sr, RefreshState as st, ActiveEntry as t, EntityEntry as ta, OptimisticOperation as ti, EntityPatch as tn, ConnectionChangeSchema as tr, RemoteInspection as tt, ModelOfDomain as u, isFieldStale as ua, removeOverlay as ui, SelectionValueOf as un, MutationResult as ur, RemoteMessageTag as ut, QueryProjection as v, setUnavailable as va, MutationState as vi, RelationAnnotation as vn, Read as vr, isFieldFailed as vt, Remote as w, TypeOf as wi, refParts as wn, RemoteLiveError as wr, onlyOverlaid as wt, ReadDependencies as x, writeEntity as xa, Reconciled as xi, RelationShape as xn, ReadRequest as xr, isQueryLoading as xt, QueryRequirement as y, tombstone as ya, MutationStatus as yi, RelationEntityAnnotation as yn, ReadBatch as yr, isLoading as yt, httpWithLive as z, Connection as zi, LiveCursor as zn, requirementsOf as zr, Snapshot as zt };
+//# sourceMappingURL=index-eVkkbhPA.d.mts.map