foldkit-remote 0.7.0 → 0.9.0

package/dist/index.d.mts

@@ -1,13 +1,13 @@
-import { Context, Duration, Effect, Layer, Option, Schema, Stream } from "effect";
+import { Context, Duration, Effect, Layer, Option, Result, Schema, Stream } from "effect";
 import * as Domain from "foldkit-entity";
 import { AnyEntity, AnyQuery, Dependencies, InputExpr, Query as Query$1 } from "foldkit-entity";
+import { Command } from "foldkit/command";
 import { EntryWithoutKeepAlive } from "foldkit/subscription";
 import { ActiveSurface, Contract, Invalid, Metadata, ModelRef, Projection, Surface, Wiring } from "foldkit-surface";
 import { Rpc, RpcGroup } from "effect/unstable/rpc";
 import { KeyValueStore } from "effect/unstable/persistence";
-import { Command } from "foldkit/command";
-//#region ../metadata/dist/index.d.mts
-//#region src/index.d.ts
+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;
@@ -59,7 +59,6 @@ declare const Metadata$1: {
   summarize: (metadata: Metadata$1) => readonly MetadataSummary[];
 };
 //#endregion
-//#endregion
 //#region src/connection.d.ts
 export interface EdgeRef {
   readonly entity: string;
@@ -202,6 +201,12 @@ export interface EntityEntry {
   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. */
@@ -221,6 +226,8 @@ export interface EntityWrite {
   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
@@ -240,6 +247,14 @@ export declare const setStale: (store: EntityStore, marks: ReadonlyArray<readonl
 export 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. */
 export 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.
+ */
+export 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. */
+export declare const isFieldUnavailable: (store: EntityStore, key: EntityKey, field: string) => boolean;
 /** Records that the entity is known to be absent, so it is not refetched. */
 export declare const tombstone: (store: EntityStore, key: EntityKey) => EntityStore;
 /** Forgets everything known about the entity, including a tombstone. */
@@ -257,7 +272,8 @@ export declare const isFieldStale: (store: EntityStore, key: EntityKey, field: s
 export 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. A
+ * (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.
@@ -304,15 +320,23 @@ export interface Reconciled {
   readonly store: EntityStore;
   readonly state: MutationState;
 }
+/** What a settled mutation wrote, as `MutationSucceeded` carries it. */
+export interface MutationAnswer {
+  readonly entities: ReadonlyArray<NormalizedPatch>;
+  /** Entities the mutation deleted; each is tombstoned. */
+  readonly deleted?: ReadonlyArray<{
+    readonly entity: string;
+    readonly id: string;
+  }> | undefined;
+  /** Injected clock reading of the answer, which dates what it writes. */
+  readonly now: number;
+}
 /**
  * Applies a mutation result once and marks the request settled. A second call
  * with the same `requestId` (a retry, or a live event describing the same change)
  * does not re-apply the entities, but still clears `pending`.
  */
-export declare const reconcileMutation: (store: EntityStore, state: MutationState, requestId: string, entities: ReadonlyArray<NormalizedPatch>, deleted?: ReadonlyArray<{
-  readonly entity: string;
-  readonly id: string;
-}>) => Reconciled;
+export declare const reconcileMutation: (store: EntityStore, state: MutationState, requestId: string, answer: MutationAnswer) => Reconciled;
 /** A mutation an application declares: its name and input/output codecs. */
 export interface MutationDescriptor<Name extends string, Input, Output> {
   readonly name: Name;
@@ -593,7 +617,12 @@ export declare const addLayer: (optimistic: OptimisticState, layer: EntityLayer)
 export declare const removeLayer: (optimistic: OptimisticState, id: string) => OptimisticState;
 export declare const addOverlay: (optimistic: OptimisticState, overlay: ConnectionOverlay) => OptimisticState;
 export declare const removeOverlay: (optimistic: OptimisticState, id: string) => OptimisticState;
-/** Base store with every layer applied in order. Later layers win. */
+/**
+ * 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.
+ */
 export declare const visibleStore: (base: EntityStore, optimistic: OptimisticState) => EntityStore;
 /**
  * A fresh page is newer than any settled overlay it covers: an edge the page
@@ -607,10 +636,10 @@ export declare const pruneOverlays: (optimistic: OptimisticState, connection: st
  * a later layer re-wins on rebase. Confirmed connection changes are recorded
  * once per request, as overlays the request no longer owns.
  */
-export declare const settleSuccess: (base: EntityStore, optimistic: OptimisticState, state: MutationState, requestId: string, entities: ReadonlyArray<NormalizedPatch>, connections?: ReadonlyArray<ConnectionChange>, deleted?: ReadonlyArray<{
-  readonly entity: string;
-  readonly id: string;
-}>) => {
+export 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;
@@ -675,11 +704,6 @@ export type LiveOutcome = 'applied' | 'duplicate' | 'gap';
  * spurious gap.
  */
 export declare const classifyLive: (state: LiveState, cursor: LiveCursor) => LiveOutcome;
-/**
- * A subscriber is woken only if the event changed a field it selects. A
- * change to an unselected field is skipped entirely.
- */
-export declare const shouldWake: (changed: ReadonlyArray<string>, selected: ReadonlyArray<string>) => boolean;
 export interface EntityApplied {
   readonly state: LiveState;
   readonly store: EntityStore;
@@ -740,7 +764,7 @@ export declare const gc: (state: Retained & {
 //#endregion
 //#region src/persistence.d.ts
 /** Bump when the serialized shape changes; a mismatch discards the cache. */
-export declare const REMOTE_CACHE_VERSION = 4;
+export declare const REMOTE_CACHE_VERSION = 5;
 /**
  * What survives a reload: the entity cache, and the connections an application
  * **declared** should come back.
@@ -832,7 +856,7 @@ export declare const RemotePersistence: {
  * server refuses a mismatch with `RemoteProtocolError`, so a shape change never
  * drifts silently: bump it whenever `ReadRequest` or `LiveRequirement` change.
  */
-export declare const REMOTE_PROTOCOL_VERSION = 3;
+export declare const REMOTE_PROTOCOL_VERSION = 4;
 declare const RemoteReadError_base: Schema.Class<RemoteReadError, Schema.TaggedStruct<"RemoteReadError", {
   readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -875,12 +899,27 @@ export declare const NormalizedEntity: Schema.Struct<{
   readonly id: Schema.String;
   readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
 }>;
+/**
+ * Fields a read asked for that the server answered without, and will not
+ * answer with: the client stops asking. It says nothing about why, so a rule
+ * that withholds a field is not itself on the wire.
+ */
+export declare const SettledFields: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly fields: Schema.$Array<Schema.String>;
+}>;
 export declare const ReadBatchResult: Schema.Struct<{
   readonly entities: Schema.$Array<Schema.Struct<{
     readonly entity: Schema.String;
     readonly id: Schema.String;
     readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
   }>>;
+  readonly settled: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>;
 }>;
 export declare const MutationRequest: Schema.Struct<{
   /** Stable across transport retries so a mutation is not applied twice. */
@@ -999,6 +1038,11 @@ export declare const Read: Rpc.Rpc<"FoldkitRemoteRead", Schema.Struct<{
     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>;
 export declare const Mutate: Rpc.Rpc<"FoldkitRemoteMutate", Schema.Struct<{
   /** Stable across transport retries so a mutation is not applied twice. */
@@ -1099,6 +1143,12 @@ export declare const QueryRequest: Schema.Struct<{
     readonly after: Schema.optional<Schema.String>;
     readonly before: Schema.optional<Schema.String>;
   }>;
+  /**
+   * What to read of each item, as the relation slice a read asks the server
+   * for. Absent for a query run without one: the response carries only edges,
+   * and the client's read entry fetches fields in a second round trip.
+   */
+  readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
 }>;
 export declare const QueryEdge: Schema.Struct<{
   readonly entity: Schema.String;
@@ -1127,6 +1177,21 @@ export declare const QueryResult: Schema.Struct<{
   }>, Schema.Struct<{
     readonly _tag: Schema.Literal<"Unknown">;
   }>]>;
+  /**
+   * The selected fields of the page's items, in the same shape a read batch
+   * returns. Absent from a server that predates payload planning: the client
+   * reads it as empty and fetches fields as before.
+   */
+  readonly entities: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>>;
+  readonly settled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>>;
 }>;
 export declare const QueryRpc: Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
   readonly query: Schema.String;
@@ -1137,6 +1202,12 @@ export declare const QueryRpc: Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
     readonly after: Schema.optional<Schema.String>;
     readonly before: Schema.optional<Schema.String>;
   }>;
+  /**
+   * What to read of each item, as the relation slice a read asks the server
+   * for. Absent for a query run without one: the response carries only edges,
+   * and the client's read entry fetches fields in a second round trip.
+   */
+  readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
 }>, Schema.Struct<{
   readonly edges: Schema.$Array<Schema.Struct<{
     readonly entity: Schema.String;
@@ -1159,6 +1230,21 @@ export declare const QueryRpc: Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
   }>, Schema.Struct<{
     readonly _tag: Schema.Literal<"Unknown">;
   }>]>;
+  /**
+   * The selected fields of the page's items, in the same shape a read batch
+   * returns. Absent from a server that predates payload planning: the client
+   * reads it as empty and fetches fields as before.
+   */
+  readonly entities: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>>;
+  readonly settled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>>;
 }>, typeof RemoteQueryError, never, never>;
 export declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", Schema.Struct<{
   readonly version: Schema.Number;
@@ -1169,6 +1255,11 @@ export declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", S
     readonly id: Schema.String;
     readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
   }>>;
+  readonly settled: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>;
 }>, Schema.Union<readonly [typeof RemoteReadError, typeof RemoteProtocolError]>, never, never> | Rpc.Rpc<"FoldkitRemoteMutate", Schema.Struct<{
   /** Stable across transport retries so a mutation is not applied twice. */
   readonly requestId: Schema.String;
@@ -1254,6 +1345,12 @@ export declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", S
     readonly after: Schema.optional<Schema.String>;
     readonly before: Schema.optional<Schema.String>;
   }>;
+  /**
+   * What to read of each item, as the relation slice a read asks the server
+   * for. Absent for a query run without one: the response carries only edges,
+   * and the client's read entry fetches fields in a second round trip.
+   */
+  readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
 }>, Schema.Struct<{
   readonly edges: Schema.$Array<Schema.Struct<{
     readonly entity: Schema.String;
@@ -1276,6 +1373,21 @@ export declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", S
   }>, Schema.Struct<{
     readonly _tag: Schema.Literal<"Unknown">;
   }>]>;
+  /**
+   * The selected fields of the page's items, in the same shape a read batch
+   * returns. Absent from a server that predates payload planning: the client
+   * reads it as empty and fetches fields as before.
+   */
+  readonly entities: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>>;
+  readonly settled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>>;
 }>, typeof RemoteQueryError, never, never>>;
 //#endregion
 //#region src/model.d.ts
@@ -1288,6 +1400,12 @@ export interface RemoteModel {
   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. */
@@ -1348,8 +1466,22 @@ export 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;
 }
 export 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.
+ */
+export declare const forgetRemote: (model: RemoteModel) => RemoteModel;
 export declare const initialRemoteModel: RemoteModel;
 export declare const remoteModelSchema: () => Schema.Codec<RemoteModel, unknown>;
 /** The submodel's Messages; each reduces to `RemoteModel` through `updateRemote`. */
@@ -1425,6 +1557,8 @@ export type RemoteMessage = {
     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;
@@ -1442,6 +1576,12 @@ export type RemoteMessage = {
 } | {
   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;
@@ -1457,6 +1597,26 @@ export type RemoteMessage = {
   readonly page: Segment;
   /** The page answers the connection's refresh, so the merge also clears `stale`. */
   readonly refreshes?: boolean | undefined;
+  /**
+   * The slice the query asked for, so the payload's entities write like a
+   * read: one request per matching edge. Absent for a page from a server
+   * that predates payload planning, which carries edges only.
+   */
+  readonly select?: RelationRequirement | undefined;
+  /** The selected fields of the page's items, as a read batch returns them. */
+  readonly entities?: ReadonlyArray<{
+    readonly entity: string;
+    readonly id: string;
+    readonly values: Record<string, unknown>;
+  }> | undefined;
+  /** Fields asked for that the server settled without a value. */
+  readonly settled?: ReadonlyArray<{
+    readonly entity: string;
+    readonly id: string;
+    readonly fields: ReadonlyArray<string>;
+  }> | undefined;
+  /** Injected clock reading of the answer, dating what the payload writes. */
+  readonly now?: number | undefined;
 } | {
   readonly _tag: 'ConnectionInvalidated';
   readonly connection: string;
@@ -1494,6 +1654,11 @@ export declare const remoteMessageCases: {
         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;
   };
@@ -1545,6 +1710,7 @@ export declare const remoteMessageCases: {
       readonly entity: Schema.String;
       readonly id: Schema.String;
     }>>>;
+    now: Schema.Number;
   };
   MutationFailed: {
     requestId: Schema.String;
@@ -1560,6 +1726,10 @@ export declare const remoteMessageCases: {
   OverlayLifted: {
     id: Schema.String;
   };
+  WindowGrown: {
+    window: Schema.String;
+    size: Schema.Number;
+  };
   LiveReceived: {
     stream: Schema.String;
     event: Schema.Unknown;
@@ -1573,6 +1743,18 @@ export declare const remoteMessageCases: {
     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;
@@ -1607,6 +1789,14 @@ export declare const isRemoteMessage: <M extends {
   readonly _tag: RemoteMessageTag;
 }>;
 export declare const remoteMessageSchema: Schema.Schema<RemoteMessage>;
+/** The key a grown window is kept under: its connection and the window first asked for. */
+export 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.
+ */
+export declare const onlyOverlaid: (model: RemoteModel, entity: string, id: string) => boolean;
 /** Whether a query for this connection is in flight. */
 export declare const isQueryLoading: (model: RemoteModel, identity: string) => boolean;
 /**
@@ -1637,7 +1827,12 @@ export declare const isLoading: (model: RemoteModel, entity: string, id: string,
 /**
  * The pure reducer all four producers share. A live event that arrives ahead of
  * its cursor is a gap: it is not applied, and the stream is recorded so the host
- * can resubscribe rather than silently miss facts.
+ * can resubscribe rather than silently miss facts. When every field a Message
+ * touches keeps its identity, `model` itself is returned, so the application's
+ * root keeps its identity and Foldkit does not render. The common no-ops do (a
+ * duplicate live event, a repeated `ReadStarted`); a repeated failure, or a
+ * `preserve-existing` restore of entities already held, still makes an equal
+ * copy.
  */
 export declare const updateRemote: (model: RemoteModel, message: RemoteMessage) => RemoteModel;
 /** Whether this field's last read failed and nothing has settled it since. */
@@ -1664,6 +1859,23 @@ export declare const failureOf: (model: RemoteModel, entity: string, id: string,
  */
 export declare const writeRead: (store: EntityStore, requests: ReadonlyArray<Requirement>, result: Schema.Schema.Type<typeof ReadBatchResult>, now?: number) => EntityStore;
 //#endregion
+//#region src/resume.d.ts
+/**
+ * A resume part, in the shape `foldkit-ssr`'s `SSR.plan` takes in `parts`.
+ * Declared here structurally, so neither package depends on the other.
+ */
+interface RemoteResumePart<AppModel> {
+  readonly id: string;
+  /** The metadata key names whose reads this part resumes. */
+  readonly covers: ReadonlyArray<string>;
+  readonly capture: (model: AppModel, projections: ReadonlyArray<{
+    readonly metadata: Metadata;
+  }>) => unknown;
+  readonly restore: (model: AppModel, value: unknown) => Result.Result<AppModel, string>;
+  /** Whether a Subscription entry is one of this domain's, which may start late. */
+  readonly deferrable: (key: string, entry: unknown) => boolean;
+}
+//#endregion
 //#region src/coalesce.d.ts
 type Batch = Schema.Schema.Type<typeof ReadBatch>;
 type BatchResult = Schema.Schema.Type<typeof ReadBatchResult>;
@@ -1882,6 +2094,12 @@ interface Assembled {
  * list), so the Selection's codec decides whether that is a failure.
  */
 export declare const assemble: (store: EntityStore, key: string, requirement: RelationRequirement) => Assembled | undefined;
+/**
+ * The first field `requirement` reads, at any depth, that the server settled
+ * without a value, as `Entity:id.field`. A read that consults it says why it
+ * cannot assemble rather than waiting on a field nothing will fetch.
+ */
+export declare const unavailableOf: (store: EntityStore, key: string, requirement: RelationRequirement) => string | undefined;
 //#endregion
 //#region src/entity.d.ts
 export type AnySchema = Schema.Schema<unknown>;
@@ -2078,6 +2296,7 @@ export interface RemoteInspection {
     readonly key: string;
     readonly present: ReadonlyArray<string>;
     readonly stale: ReadonlyArray<string>;
+    readonly unavailable: ReadonlyArray<string>;
     readonly tombstone: boolean;
     readonly updatedAt: number;
     readonly windows: Readonly<Record<string, string>>;
@@ -2215,6 +2434,23 @@ export interface PlanOptions {
   /** Plan every requested field, present or not, tombstoned or not. */
   readonly force?: boolean | undefined;
 }
+/** When present values next go stale, and the requirements of the entities that do. */
+export interface Deadline {
+  readonly at: number;
+  readonly due: ReadonlyArray<Requirement>;
+}
+/**
+ * The earliest moment a value `requirements` read, following the relations the
+ * store holds as `plan` does, goes stale under `freshness`, with the
+ * requirements of the entities that go stale then. A field the server settled
+ * without a value ages with its entity too, since `plan` asks for it again once
+ * the entity expires. Nothing when no such field is still fresh: what is
+ * already expired or stale is planned, not awaited, which is what keeps a
+ * timer from firing on what it already fired on. It is the next moment the
+ * plan can change with the clock alone, which the read entry relies on to
+ * reuse its plan until then.
+ */
+export declare const deadlineOf: (store: EntityStore, requirements: readonly Requirement[], freshness: PlanFreshness) => Deadline | undefined;
 export declare const plan: (store: EntityStore, requirements: readonly Requirement[], options?: PlanOptions) => ReadonlyArray<Requirement>;
 //#endregion
 //#region src/policy.d.ts
@@ -2323,6 +2559,8 @@ export interface DomainMutateOptions {
     readonly requestId: string;
     readonly tempId: string;
   }) => ReadonlyArray<OptimisticOperation>) | undefined;
+  /** The clock `MutationSucceeded` stamps the answer with; default `Date.now`, read at each use. */
+  readonly now?: (() => number) | undefined;
 }
 /** A Foldkit Subscription entry of the Remote domain, emitting its Messages through `RemoteClient`. */
 export type RemoteEntry<AppModel, Dependencies> = EntryWithoutKeepAlive<AppModel, RemoteMessage, Dependencies, RemoteClient>;
@@ -2331,9 +2569,15 @@ export type RemoteEntry<AppModel, Dependencies> = EntryWithoutKeepAlive<AppModel
  * and a live entry per key (the live one idles when nothing is read live), and
  * `retain`.
  */
-export type SubscriptionEntries<AppModel, Active> = { readonly [K in keyof Active & (string | number) as `${K}.read` | `${K}.live`]: RemoteEntry<AppModel, any>; } & {
-  readonly retain: RemoteEntry<AppModel, any>;
+export type SubscriptionEntries<AppModel, Active, Message = RemoteMessage> = { readonly [K in keyof Active & (string | number) as `${K}.read`]: EntryWithoutKeepAlive<AppModel, Message, ReadDependencies, RemoteClient>; } & { readonly [K in keyof Active & (string | number) as `${K}.live`]: EntryWithoutKeepAlive<AppModel, Message, LiveDependencies, RemoteClient>; } & {
+  readonly retain: EntryWithoutKeepAlive<AppModel, Message, RetentionRoots, never>;
 };
+/** The dependencies of a live entry: what it subscribes to, and where a restart resumes. */
+export interface LiveDependencies {
+  readonly requirements: ReadonlyArray<Requirement>;
+  readonly cursor: LiveCursor;
+  readonly floor: number;
+}
 export interface SubscriptionsOptions extends ObserveOptions, LiveOptions, RetainOptions {}
 /** A Remote domain's wiring for an assembly: it routes Remote's Messages into `reduce`, brings its Subscriptions and contract, and requires `RemoteClient` from the runtime's resources Layer. */
 export type RemoteWiring<AppModel> = Wiring<AppModel, RemoteMessage | RemoteMessageInput, RemoteClient>;
@@ -2368,10 +2612,13 @@ export interface RemoteDomain<AppModel, Store extends RemoteModel, Entities exte
    * onto the connection read through the same projection.
    */
   query<Q extends QueryDescriptor<any, any, any>, Value, Entity extends string>(query: Q & Registered<Q['name'], QueryName<Queries[number]>, 'Query'>, input: QueryInput<Q>, options: QueryOptions<Value, Entity, QueryEntity<Q>>): QueryProjection<AppModel, Value, Q['name'], QueryInput<Q>>;
-  /** The `QueryRef` for the page after the loaded end (same page size), or `undefined` when there is none or its cursor is unknown. */
-  next<Name extends string, Input>(model: AppModel, projection: QueryProjection<AppModel, any, Name, Input>): QueryRef<Name, Input> | undefined;
-  /** The `QueryRef` for the page before the loaded start, or `undefined`. */
-  previous<Name extends string, Input>(model: AppModel, projection: QueryProjection<AppModel, any, Name, Input>): QueryRef<Name, Input> | undefined;
+  /**
+   * "Load more": the Model with the read's window grown by one page, so it
+   * shows that many more rows; the read entry fetches what the connection
+   * lacks. None when the read shows everything there is (or is not a sized
+   * window). Called from `update`.
+   */
+  more<Name extends string, Input>(model: AppModel, projection: QueryProjection<AppModel, any, Name, Input>): Option.Option<AppModel>;
   /**
    * What a query read is and what it currently is, as one serializable value —
    * data-query-DESIGN §29.1: the domain, the definition and its input, the
@@ -2422,30 +2669,44 @@ export interface RemoteDomain<AppModel, Store extends RemoteModel, Entities exte
    * fetch. The server stays authoritative for which rows exist.
    */
   filtered<Value, Name extends string, Input, Q extends QueryDescriptor<any, any, any>>(model: AppModel, over: QueryProjection<AppModel, Value, Name, Input>, by: Q & Registered<Q['name'], QueryName<Queries[number]>, 'Query'>, input: QueryInput<Q>): Matched<Value>;
-  /** A Command that runs the query and yields the `ConnectionMerged` (or `QueryFailed`) that reduces it: "load more". */
-  fetch(ref: QueryRef<string, unknown>): Command<RemoteMessage, never, RemoteClient>;
   /**
    * Shows operations over the store with no request behind them, as a mutation's
    * `optimistic` ones show while it is in flight: every Selection and view draws
    * them. For a preview of a change nobody has made. They stay until `lift`;
-   * showing an id again replaces what it showed. Called from `update`.
+   * showing an id again replaces what it showed. Called from `update`. A read
+   * of an entity only overlays show, lacking a field it selects, is `Failed`
+   * (`Overlaid`): nothing will fetch that field.
    */
   overlay(model: AppModel, id: string, optimistic: ReadonlyArray<OptimisticOperation>): AppModel;
   /** Lifts what `overlay` showed under this id. Lifting nothing returns the same Model. */
   lift(model: AppModel, id: string): AppModel;
   /** `Remote.refresh`: marks what a projection or a Surface requires as due, for its read entry to refetch. */
   refresh(model: AppModel, target: Projection<AppModel, unknown> | Surface<AppModel, any, any, void>): AppModel;
+  /** `Remote.forget`: the Model with every server-derived fact gone, for a change of principal. */
+  forget(model: AppModel): AppModel;
+  /**
+   * A read of this domain as an active Surface, for `subscriptions` and
+   * `wiring`: `projectionOf` is what it reads for a Model, none while it
+   * reads nothing. It belongs to the domain's application, and lists no
+   * Messages: it is a requirement, not a sender. A domain made from a raw
+   * optic names no application, so this throws for one.
+   */
+  active<Value>(name: string, projectionOf: (model: AppModel) => Option.Option<Projection<AppModel, Value>>): ActiveSurface<AppModel>;
   /**
    * The Foldkit Subscription entries for the active Surfaces, keyed for
    * `Subscription.make`: a read entry per Surface (`Remote.observe`), a live
    * entry per Surface that reads through `live` (`Remote.live`), and one
-   * retain entry with every active Surface as a root (`Remote.retain`). A
+   * retain entry (`Remote.retain`). Retention is the domain's: the retain
+   * entry of every call roots the active Surfaces of every call, so reads
+   * split over calls (one per policy) do not collect each other's data. A
    * Surface's params are a function of the Model (`Surface.at`), so what is
    * fetched, subscribed, and retained follows the Model.
    */
   subscriptions<const Active extends Readonly<Record<string, ActiveSurface<AppModel> | Surface<AppModel, any, any, void>>>>(active: Active, options?: SubscriptionsOptions): SubscriptionEntries<AppModel, Active>;
   /** `Remote.plan`: the requirements the store does not satisfy. */
   plan<Value>(model: AppModel, projection: Projection<AppModel, Value>, options?: PlanOptions): ReadonlyArray<Requirement>;
+  /** `Remote.meta`: when what a projection shows was last received, and whether it is stale or loading. */
+  meta<Value>(model: AppModel, projection: Projection<AppModel, Value>): ReadMeta;
   /** `Remote.storeOf`: the visible store, base under the pending optimistic layers. */
   storeOf(model: AppModel): EntityStore;
   /**
@@ -2478,6 +2739,17 @@ export interface RemoteDomain<AppModel, Store extends RemoteModel, Entities exte
    * items included). For SSR, route or hover prefetch, and tests.
    */
   prefetch<Value>(model: AppModel, projection: Projection<AppModel, Value>, options?: ObserveOptions): Effect.Effect<AppModel, RemoteReadError | RemoteProtocolError | RemoteQueryError, RemoteClient>;
+  /**
+   * The Model with everything the active Surfaces read, for a render that
+   * fetches nothing (SSR, a prerender). Each pass prefetches every Surface
+   * that plans a read, over the Model the one before it left, so a Surface
+   * active only once another's read has arrived is read in the next pass (or
+   * the same one, when it comes later in `active`). It stops at the first
+   * pass that plans nothing, and fails with `RemoteUnsatisfied` when
+   * `options.passes` run out first. Reads are cache-first: a field already
+   * held is not asked again.
+   */
+  satisfy(model: AppModel, active: Readonly<Record<string, ActiveSurface<AppModel> | Surface<AppModel, any, any, void>>>, options?: SatisfyOptions): Effect.Effect<AppModel, RemoteReadError | RemoteProtocolError | RemoteQueryError | RemoteUnsatisfied, RemoteClient>;
   /**
    * Starts a registered mutation from `update`: applies `MutationStarted` (with
    * the optimistic operations) to the Model and returns the Command that runs
@@ -2503,6 +2775,28 @@ export interface RemoteDomain<AppModel, Store extends RemoteModel, Entities exte
   /** `Remote.inspect` of the bound slice. */
   inspect(model: AppModel): RemoteInspection;
 }
+/** What `Remote.fold(Data, …).mutate` starts: `Data.mutate`'s result with its Command lifted. */
+export type FoldedMutationStarted<AppModel, ParentMessage> = Omit<MutationStarted<AppModel>, 'command'> & {
+  readonly command: Command<ParentMessage, never, RemoteClient>;
+};
+/**
+ * A bound domain folded under one of the application's own Message variants,
+ * from `Remote.fold`. Calling it reduces a Remote Message into the Model; the
+ * members that produce Messages, `fetch`, `mutate`, and `subscriptions`,
+ * yield the wrapper Message instead of `RemoteMessage`, with the lift recorded
+ * so Story and Scene can resolve a fetch or a mutation by Remote's own answer.
+ * Members that only read or write the Model (`get`, `refresh`, `next`,
+ * `overlay`, and the rest) stay on the domain itself.
+ */
+export interface RemoteFold<AppModel, ParentMessage, Domain extends RemoteDomain<AppModel, any, any, any, any>> {
+  (model: AppModel, message: RemoteMessage | RemoteMessageInput): Update.Return<AppModel, ParentMessage>;
+  /** `Data.mutate`, its Command lifted. */
+  readonly mutate: (...args: Parameters<Domain['mutate']>) => FoldedMutationStarted<AppModel, ParentMessage>;
+  /** `Data.subscriptions`, every entry lifted to the wrapper Message. */
+  readonly subscriptions: <const Active extends Readonly<Record<string, ActiveSurface<AppModel> | Surface<AppModel, any, any, void>>>>(active: Active, options?: SubscriptionsOptions) => SubscriptionEntries<AppModel, Active, ParentMessage>;
+}
+/** The application Model a bound domain is over. */
+export type ModelOfDomain<Domain> = Domain extends RemoteDomain<infer AppModel, any, any, any, any> ? AppModel : never;
 /** A projection's connection requirement with the `QueryRef` that runs it. */
 export interface QueryRequirement extends ConnectionRequirement {
   readonly ref: QueryRef<string, unknown>;
@@ -2533,9 +2827,23 @@ export interface QueryProjection<AppModel, Value, Name extends string, Input> ex
 export type QueryInput<Q> = Q extends QueryDescriptor<any, infer Input, any> ? Input : never;
 /** The entity a query's connection is over. */
 export type QueryEntity<Q> = Q extends QueryDescriptor<any, any, ConnectionSpec<infer Entity>> ? Entity : string;
+/**
+ * When what a projection shows was last received, and whether it is stale
+ * or loading. See `Remote.meta`.
+ */
+export interface ReadMeta {
+  /** The newest server write among what is shown; none received reads `undefined`. */
+  readonly updatedAt: number | undefined;
+  /** Any shown field or connection is marked stale. */
+  readonly stale: boolean;
+  /** Any shown field or connection is in flight. */
+  readonly loading: boolean;
+}
 export interface MutateOptions {
   /** What the request changes before the server answers; released when it settles. */
   readonly optimistic?: ReadonlyArray<OptimisticOperation> | undefined;
+  /** The clock `MutationSucceeded` stamps the answer with; default `Date.now`, read at each use. */
+  readonly now?: (() => number) | undefined;
 }
 export interface RetainOptions {
   /** The query connections the application shows, by `QueryRef` or identity. */
@@ -2547,11 +2855,29 @@ export interface RetainOptions {
 export interface ObserveOptions {
   /** Default `RemotePolicy.cacheFirst`. */
   readonly policy?: RemotePolicy | undefined;
-  /** The clock a refreshing policy reads; default `Date.now`. */
+  /** The clock a refreshing policy reads; default `Date.now`, read at each use. */
   readonly now?: (() => number) | undefined;
 }
+/** How `Data.satisfy` reads: how many passes it may take, and the clock. */
+export interface SatisfyOptions {
+  /** At most this many passes over the Surfaces; default 8. */
+  readonly passes?: number | undefined;
+  /** The clock the reads are stamped with; default `Date.now`, read at each use. */
+  readonly now?: (() => number) | undefined;
+}
+declare const RemoteUnsatisfied_base: Schema.Class<RemoteUnsatisfied, Schema.TaggedStruct<"RemoteUnsatisfied", {
+  readonly surfaces: Schema.$Array<Schema.String>;
+  readonly passes: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * `Data.satisfy` reached its bound with Surfaces still reading, such as a
+ * chain whose every read reveals one more. It names them, so a page that
+ * would have rendered them loading fails instead. (A read the server leaves
+ * unanswered settles as missing and ends the loop.)
+ */
+export declare class RemoteUnsatisfied extends RemoteUnsatisfied_base {}
 export interface LiveOptions {
-  /** The clock `LiveReceived` stamps events with; default `Date.now`. */
+  /** The clock `LiveReceived` stamps events with; default `Date.now`, read at each use. */
   readonly now?: (() => number) | undefined;
 }
 /** A query the read entry runs, as its dependencies carry it: plain data Foldkit compares. */
@@ -2575,6 +2901,14 @@ export interface ReadDependencies {
    * leaves it running.
    */
   readonly refresh: number;
+  /**
+   * Under a refreshing policy, when a value the entry holds next ages out and
+   * what is due then. Time reaches Remote only as a Message: the entry sleeps
+   * until then and emits `RefreshStarted`, which marks the fields stale, and
+   * the plan that follows fetches them. A Model that does not change past its
+   * `maxAge` is otherwise never looked at again.
+   */
+  readonly expires: Deadline | null;
 }
 export declare const Remote: {
   /** The submodel's schema, the same for every domain; embed it in the application Model. */
@@ -2595,6 +2929,11 @@ export declare const Remote: {
           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;
     };
@@ -2646,6 +2985,7 @@ export declare const Remote: {
         readonly entity: Schema.String;
         readonly id: Schema.String;
       }>>>;
+      now: Schema.Number;
     };
     MutationFailed: {
       requestId: Schema.String;
@@ -2661,6 +3001,10 @@ export declare const Remote: {
     OverlayLifted: {
       id: Schema.String;
     };
+    WindowGrown: {
+      window: Schema.String;
+      size: Schema.Number;
+    };
     LiveReceived: {
       stream: Schema.String;
       event: Schema.Unknown;
@@ -2674,6 +3018,18 @@ export declare const Remote: {
       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;
@@ -2695,6 +3051,160 @@ export declare const Remote: {
   }>(message: M) => message is Extract<M, {
     readonly _tag: RemoteMessageTag;
   }>;
+  /**
+   * Remote's Messages as one Schema, for a wrapper variant in the
+   * application's union: `GotRemoteMessage: { message: Remote.Message }`. With
+   * a wrapper, `update` matches the application's union exhaustively and
+   * `Remote.fold` reduces what arrives inside it.
+   */
+  Message: import("foldkit/message").MessageUnion<{
+    ReadReceived: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      result: Schema.Struct<{
+        readonly entities: Schema.$Array<Schema.Struct<{
+          readonly entity: Schema.String;
+          readonly id: Schema.String;
+          readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+        }>>;
+        readonly settled: Schema.$Array<Schema.Struct<{
+          readonly entity: Schema.String;
+          readonly id: Schema.String;
+          readonly fields: Schema.$Array<Schema.String>;
+        }>>;
+      }>;
+      now: Schema.Number;
+    };
+    ReadFailed: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+      }>;
+      stream: Schema.optional<Schema.String>;
+    };
+    RefreshStarted: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+    };
+    ReadStarted: {
+      requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      refresh: Schema.optional<Schema.Number>;
+    };
+    QueryStarted: {
+      connections: Schema.$Array<Schema.String>;
+    };
+    RetentionChanged: {
+      roots: Schema.Struct<{
+        readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+        readonly connections: Schema.$Array<Schema.Struct<{
+          readonly identity: Schema.String;
+          readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+        }>>;
+      }>;
+    };
+    Hydrated: {
+      connections: Schema.optional<Schema.Unknown>;
+      entities: Schema.Unknown;
+      merge: Schema.Union<readonly [Schema.Literal<"replace">, Schema.Literal<"preserve-existing">]>;
+    };
+    MutationStarted: {
+      requestId: Schema.String;
+      optimistic: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    };
+    MutationSucceeded: {
+      requestId: Schema.String;
+      entities: Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+      }>>;
+      connections: Schema.optional<Schema.$Array<Schema.Unknown>>;
+      deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+      }>>>;
+      now: Schema.Number;
+    };
+    MutationFailed: {
+      requestId: Schema.String;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+      }>;
+    };
+    OverlayShown: {
+      id: Schema.String;
+      optimistic: Schema.$Array<Schema.Unknown>;
+    };
+    OverlayLifted: {
+      id: Schema.String;
+    };
+    WindowGrown: {
+      window: Schema.String;
+      size: Schema.Number;
+    };
+    LiveReceived: {
+      stream: Schema.String;
+      event: Schema.Unknown;
+      policy: Schema.optional<Schema.Unknown>;
+      now: Schema.Number;
+    };
+    GapCleared: {
+      stream: Schema.String;
+    };
+    ConnectionMerged: {
+      connection: Schema.String;
+      page: Schema.Unknown;
+      refreshes: Schema.optional<Schema.Boolean>;
+      select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+      entities: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+      }>>>;
+      settled: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly fields: Schema.$Array<Schema.String>;
+      }>>>;
+      now: Schema.optional<Schema.Number>;
+    };
+    ConnectionInvalidated: {
+      connection: Schema.String;
+    };
+    ConnectionRefreshed: {
+      connection: Schema.String;
+    };
+    QueryFailed: {
+      connection: Schema.String;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+      }>;
+    };
+  }>;
+  /**
+   * A bound domain under one wrapper variant of the application's union, the
+   * same shape Foldkit gives a Submodel: `toParentMessage` wraps Remote's
+   * Messages, the fold reduces them, and its `fetch`, `mutate`, and
+   * `subscriptions` yield the wrapper. Spreading `Remote.messages` and
+   * narrowing with `Remote.reduces` remains the shorter path for an
+   * application whose `update` only reduces.
+   *
+   * @example
+   * ```ts
+   * const Message = defineMessageUnion({ GotRemoteMessage: { message: Remote.Message } })
+   * const foldData = Remote.fold(Data, message => Message.GotRemoteMessage({ message }))
+   *
+   * const update = (model: Model, message: Message): Return =>
+   *   Message.match(message, {
+   *     GotRemoteMessage: ({ message }) => foldData(model, message),
+   *   })
+   * const subscriptions = Subscription.make<Model, Message, RemoteClient>()(() =>
+   *   foldData.subscriptions({ page: Surface.at(ProjectPage, …) }),
+   * )
+   * ```
+   */
+  fold: <Domain extends RemoteDomain<any, any, any, any, any>, ParentMessage>(domain: Domain, toParentMessage: (message: RemoteMessage) => ParentMessage) => RemoteFold<ModelOfDomain<Domain>, ParentMessage, Domain>;
   /**
    * A patch of one entity's values, for a mutation's `optimistic` list or an
    * overlay. Takes a `foldkit-entity` Entity or a Remote descriptor alike, so
@@ -2737,6 +3247,17 @@ export declare const Remote: {
    * rejects a selection for an entity this domain never declared.
    */
   at: <AppModel, Store extends RemoteModel, Entities extends readonly EntityLike[], Queries extends readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[]>(definition: RemoteDescriptor<Entities, Queries, Mutations>, store: ModelRef<AppModel, Store>) => BoundRemote<AppModel, Store, EntityName<Entities[number]>>;
+  /**
+   * The resume part for this domain, for `foldkit-ssr`'s `SSR.plan({ parts })`:
+   * a server render sends what the plan's active Surfaces read from the store,
+   * each connection with its boundaries and each live cursor with it, and
+   * nothing else. `id` tells two domains in one application apart.
+   */
+  resume: <AppModel, Store extends RemoteModel>(domain: {
+    readonly store: ModelRef<AppModel, Store>;
+  }, options?: {
+    readonly id?: string | undefined;
+  }) => RemoteResumePart<AppModel>;
   /**
    * A Projection node that reads a `RemoteData` value out of the store. The id
    * is supplied by the caller, usually from a Surface's params. The assembled
@@ -2745,6 +3266,17 @@ export declare const Remote: {
    * stale field reads as `Refreshing`: an observer is refetching it.
    */
   select: <AppModel, Store extends RemoteModel, Names extends string, Value, Name extends string>(bound: BoundRemote<AppModel, Store, Names>, given: EntitySelection<Value, Name> & Registered<Name, Names, "Entity">) => (id: string) => Projection<AppModel, RemoteData<Value>>;
+  /**
+   * When what a projection shows was last received, and whether it is stale
+   * or loading. Pure, so a view can show "updated 5s ago" without I/O.
+   *
+   * `updatedAt` is the newest server write among what is shown, as the
+   * store dates it; `undefined` when nothing shown was received (nothing
+   * loaded, or only an optimistic preview). `stale` is any shown field or
+   * connection marked stale; `loading` is any of them in flight. Optimistic
+   * previews do not date: showing only one reads `updatedAt: undefined`.
+   */
+  meta: <AppModel, Store extends RemoteModel, Value>(bound: BoundRemote<AppModel, Store>, model: AppModel, projection: Projection<AppModel, Value>) => ReadMeta;
   /**
    * The pure plan for a projection against a Model: the requirements its
    * remote store does not satisfy, under `options` (freshness, force). A
@@ -2797,6 +3329,17 @@ export declare const Remote: {
    * already being refreshed returns the same Model.
    */
   refresh: <AppModel, Store extends RemoteModel>(bound: BoundRemote<AppModel, Store>, model: AppModel, target: Projection<AppModel, unknown> | Surface<AppModel, any, any, void>) => AppModel;
+  /**
+   * Forgets everything the server told this Model: values, tombstones,
+   * unavailable fields, connections, live cursors, failures. What is known is
+   * known for a principal, and this is the one boundary for a login, a logout
+   * or a switch of organization: called from `update`, it performs no I/O, and
+   * every active Surface's read and live entries restart, so the screen asks
+   * again as whoever the client now is. A read or stream begun before is
+   * interrupted rather than landing after. A mutation in flight is treated as
+   * applied: its answer writes nothing here.
+   */
+  forget: <AppModel, Store extends RemoteModel>(bound: BoundRemote<AppModel, Store>, model: AppModel) => AppModel;
   /**
    * Writes a read result into the store, recording each field's applied window.
    * `requests` are the planned requirements the result answers.
@@ -2825,8 +3368,10 @@ export declare const Remote: {
   /**
    * Runs a `Query` through `RemoteClient`, encoding its input from the ref.
    * Pair the result with `Remote.queryMessage` to merge the page into the Model.
+   * With `select`, the server also returns the selected fields of the page's
+   * items, so one response populates both the connection and the store.
    */
-  query: <Name extends string, Input>(ref: QueryRef<Name, Input>) => Effect.Effect<{
+  query: <Name extends string, Input>(ref: QueryRef<Name, Input>, select?: RelationRequirement | undefined) => Effect.Effect<{
     readonly edges: readonly {
       readonly entity: string;
       readonly id: string;
@@ -2848,9 +3393,21 @@ export declare const Remote: {
     } | {
       readonly _tag: "Unknown";
     };
+    readonly entities?: readonly {
+      readonly entity: string;
+      readonly id: string;
+      readonly values: {
+        readonly [x: string]: unknown;
+      };
+    }[] | undefined;
+    readonly settled?: readonly {
+      readonly entity: string;
+      readonly id: string;
+      readonly fields: readonly string[];
+    }[] | undefined;
   }, RemoteQueryError, RemoteClient>;
   /** The `RemoteMessage` that merges a query page into its connection. */
-  queryMessage: <Name extends string, Input>(ref: QueryRef<Name, Input>, result: Schema.Schema.Type<typeof QueryResult>) => RemoteMessage;
+  queryMessage: <Name extends string, Input>(ref: QueryRef<Name, Input>, result: Schema.Schema.Type<typeof QueryResult>, select?: RelationRequirement | undefined, now?: number | undefined) => RemoteMessage;
   /**
    * The edges a connection shows: its server-known region with pending and
    * confirmed overlays placed around it, minus removed edges and edges whose
@@ -2909,11 +3466,8 @@ export declare const Remote: {
    * read, since nothing was being read. The resume cursor is read
    * from `RemoteModel.live`, so the application tracks no cursor of its own.
    */
-  live: <AppModel, Store extends RemoteModel, Names extends string, Model, SurfaceMessage, Params, Message = RemoteMessage>(bound: BoundRemote<AppModel, Store, Names>, surface: Surface<AppModel, Model, SurfaceMessage, Params>, params: Params, toMessage?: (message: RemoteMessage) => Message, options?: LiveOptions) => EntryWithoutKeepAlive<AppModel, Message, {
-    readonly requirements: ReadonlyArray<Requirement>;
-    readonly cursor: LiveCursor;
-  }, RemoteClient>;
+  live: <AppModel, Store extends RemoteModel, Names extends string, Model, SurfaceMessage, Params, Message = RemoteMessage>(bound: BoundRemote<AppModel, Store, Names>, surface: Surface<AppModel, Model, SurfaceMessage, Params>, params: Params, toMessage?: (message: RemoteMessage) => Message, options?: LiveOptions) => EntryWithoutKeepAlive<AppModel, Message, LiveDependencies, RemoteClient>;
 };
 //#endregion
-export { Entity$1 as Entity };
+export { Entity$1 as Entity, type RemoteResumePart };
 //# sourceMappingURL=index.d.mts.map