foldkit-remote 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,2000 @@
+import { Context, Duration, Effect, Layer, Option, Schema, Stream } from "effect";
+import { ActiveSurface, ConnectionRequirement, Contract, Invalid, ModelRef, Projection, RelationRequirement, RelationRequirement as RelationRequirement$1, Requirement, Requirement as Requirement$1, Surface } from "foldkit-surface";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
+import { KeyValueStore } from "effect/unstable/persistence";
+import { Command } from "foldkit/command";
+import { EntryWithoutKeepAlive } from "foldkit/subscription";
+//#region src/connection.d.ts
+export interface EdgeRef {
+  readonly entity: string;
+  readonly id: string;
+}
+/** `key` is the edge identity used for de-duplication. */
+export interface Edge {
+  readonly key: string;
+  readonly ref: EdgeRef;
+}
+export declare const edge: (ref: EdgeRef, key?: string) => Edge;
+export type Cursor = string;
+export type Boundary = {
+  readonly _tag: 'Terminal';
+} | {
+  readonly _tag: 'Cursor';
+  readonly cursor: Cursor;
+} | {
+  readonly _tag: 'Unknown';
+};
+export declare const terminal: Boundary;
+export declare const unknown: Boundary;
+export declare const cursor: (value: Cursor) => Boundary;
+export interface Segment {
+  readonly edges: readonly Edge[];
+  readonly start: Boundary;
+  readonly end: Boundary;
+}
+export interface Connection {
+  readonly segments: readonly Segment[];
+  readonly stale: boolean;
+}
+export declare const emptyConnection: Connection;
+export declare const segment: (edges: readonly Edge[], start: Boundary, end: Boundary) => Segment;
+/** Adds a page to the connection, joining contiguous or overlapping segments. */
+export declare const merge: (current: Connection, page: Segment) => Connection;
+/** Visible edges, segment by segment. */
+export declare const items: (connection: Connection) => ReadonlyArray<Edge>;
+/** There is more before the known region. Derived from boundaries, never row count. */
+export declare const hasPrevious: (connection: Connection) => boolean;
+/** There is more after the known region. Derived from boundaries, never row count. */
+export declare const hasNext: (connection: Connection) => boolean;
+/** A connection with more than one segment has an explicit unknown gap. */
+export declare const isGapped: (connection: Connection) => boolean;
+//#endregion
+//#region src/store.d.ts
+export type EntityKey = string;
+export 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>;
+  /** 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>>;
+}
+export type EntityStore = Readonly<Record<EntityKey, EntityEntry>>;
+/** The separator keeps an untrusted id from colliding with a prototype key. */
+export declare const entityKey: (entity: string, id: string) => EntityKey;
+export declare const emptyStore: EntityStore;
+export 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;
+}
+/**
+ * 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.
+ */
+export declare const writeEntities: (store: EntityStore, writes: ReadonlyArray<EntityWrite>, now?: number) => EntityStore;
+/** `writeEntities` for one entity. */
+export 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.
+ */
+export 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. */
+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 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. */
+export declare const remove: (store: EntityStore, key: EntityKey) => EntityStore;
+export declare const entry: (store: EntityStore, key: EntityKey) => Option.Option<EntityEntry>;
+export declare const isTombstone: (store: EntityStore, key: EntityKey) => boolean;
+/** A field is known only if it is present and not stale. */
+export declare const hasField: (store: EntityStore, key: EntityKey, field: string) => boolean;
+/** A present field whose value may be outdated; absent fields are not stale. */
+export 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`.
+ */
+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
+ * 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.
+ */
+export declare const missingFields: (store: EntityStore, key: EntityKey, fields: Iterable<string>, windows?: Readonly<Record<string, string>>) => ReadonlyArray<string>;
+//#endregion
+//#region src/mutation.d.ts
+export interface NormalizedPatch {
+  readonly entity: string;
+  readonly id: string;
+  readonly values: Readonly<Record<string, unknown>>;
+}
+export interface MutationState {
+  readonly pending: ReadonlySet<string>;
+  readonly applied: ReadonlySet<string>;
+  readonly failed: ReadonlySet<string>;
+  /**
+   * How many mutations this model has started. A bound domain takes its next
+   * request id from here, so `update` stays pure and the id exists before the
+   * Command runs.
+   */
+  readonly sequence: number;
+}
+export declare const emptyMutationState: MutationState;
+export declare const beginMutation: (state: MutationState, requestId: string) => MutationState;
+export declare const failMutation: (state: MutationState, requestId: string) => MutationState;
+export interface Reconciled {
+  readonly store: EntityStore;
+  readonly state: MutationState;
+}
+/**
+ * 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>) => Reconciled;
+/** A mutation an application declares: its name and input/output codecs. */
+export interface MutationDescriptor<Name extends string, Input, Output> {
+  readonly name: Name;
+  readonly Input: Schema.Codec<Input>;
+  readonly Output: Schema.Codec<Output>;
+}
+/** A codec, or the fields of a `Schema.Struct` where one is expected. */
+export type SchemaOrFields = Schema.Codec<any, any, any, any> | Schema.Struct.Fields;
+/** The decoded type of a codec, or of the Struct the fields describe. */
+export type TypeOf<S extends SchemaOrFields> = S extends Schema.Codec<infer T, any, any, any> ? T : S extends Schema.Struct.Fields ? Schema.Struct.Type<S> : never;
+/** The codec itself, or a `Schema.Struct` over the fields. */
+export declare const schemaOf: <S extends SchemaOrFields>(shape: S) => Schema.Codec<TypeOf<S>>;
+export declare const Mutation: {
+  /**
+   * Declares a mutation. `Input` and `Output` are codecs, or the fields of the
+   * `Schema.Struct` they would be (`{ id: ProjectId, name: Schema.String }`).
+   */
+  make: <const Name extends string, Input extends SchemaOrFields, Output extends SchemaOrFields>(name: Name, config: {
+    readonly Input: Input;
+    readonly Output: Output;
+  }) => MutationDescriptor<Name, TypeOf<Input>, TypeOf<Output>>;
+};
+//#endregion
+//#region src/optimistic.d.ts
+export interface EntityLayer {
+  readonly id: string;
+  readonly patches: ReadonlyArray<NormalizedPatch>;
+}
+/**
+ * Edges placed outside a connection's server-known region (`prepend`,
+ * `append`) or hidden from it (`remove`), owned by the request or live event
+ * that produced them.
+ */
+export 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. */
+export 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. */
+export type OptimisticOperation = NormalizedPatch | ConnectionChange;
+/** A connection, by identity string or by anything that carries one (a `QueryRef`). */
+export type ConnectionIdentity = string | {
+  readonly identity: string;
+};
+export declare const connectionIdentity: (connection: ConnectionIdentity) => string;
+/**
+ * Constructors for connection changes: what a request shows optimistically
+ * (`MutateOptions.optimistic`) and what a mutation source reports it made
+ * (`MutationOutcome.connections`).
+ */
+export 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.
+ */
+export declare const beginOptimistic: (optimistic: OptimisticState, requestId: string, operations: ReadonlyArray<OptimisticOperation>) => OptimisticState;
+/** Pending entity layers and connection overlays over the base store. */
+export interface OptimisticState {
+  readonly layers: ReadonlyArray<EntityLayer>;
+  readonly overlays: ReadonlyArray<ConnectionOverlay>;
+}
+export declare const emptyOptimistic: OptimisticState;
+export declare const addLayer: (optimistic: OptimisticState, layer: EntityLayer) => OptimisticState;
+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. */
+export 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.
+ */
+export 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.
+ */
+export declare const settleSuccess: (base: EntityStore, optimistic: OptimisticState, state: MutationState, requestId: string, entities: ReadonlyArray<NormalizedPatch>, connections?: ReadonlyArray<ConnectionChange>) => {
+  readonly store: EntityStore;
+  readonly state: MutationState;
+  readonly optimistic: OptimisticState;
+};
+/** A failed request's layer and overlays are dropped; the base was never mutated. */
+export 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.
+ */
+export declare const visibleItems: (connection: Connection, connectionId: string, overlays: ReadonlyArray<ConnectionOverlay>, store?: EntityStore) => ReadonlyArray<Edge>;
+//#endregion
+//#region src/query.d.ts
+export type LiveInsertion = 'visible' | 'boundary' | 'invalidate' | 'ignore';
+export interface LivePolicy {
+  readonly prepend?: LiveInsertion;
+  readonly append?: LiveInsertion;
+}
+export interface ConnectionSpec<Entity extends string = string> {
+  readonly entity: Entity;
+  readonly edgeKey?: Schema.Schema<unknown>;
+  readonly live?: LivePolicy;
+}
+export interface QueryWindow {
+  readonly first?: number | undefined;
+  readonly last?: number | undefined;
+  readonly after?: Cursor | undefined;
+  readonly before?: Cursor | undefined;
+}
+export 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;
+}
+export 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>;
+}
+/** Stable stringify: object keys sorted, undefined-valued keys dropped, so equal inputs encode equally. */
+export declare const stableStringify: (value: unknown) => string;
+/**
+ * `Result: Project` (or anything with the entity's `name`, as `Query.connection`
+ * takes) means a connection over it; a `ConnectionSpec` names its `entity`
+ * instead and is the result as given.
+ */
+export type ResultOf<Result> = Result extends {
+  readonly name: infer Entity extends string;
+} ? ConnectionSpec<Entity> : Result;
+export declare const Query: {
+  /** Declares the entity and options a query's result is a connection over. */
+  connection: <Entity extends string>(entity: {
+    readonly name: Entity;
+  }, options?: {
+    readonly edgeKey?: Schema.Schema<unknown>;
+    readonly live?: LivePolicy;
+  }) => ConnectionSpec<Entity>;
+  /**
+   * Declares a query. `Input` is a codec or the fields of the `Schema.Struct` it
+   * would be; `Result` is a `Query.connection(...)`, or the entity the result is
+   * a connection over.
+   */
+  make: <const Name extends string, Input extends SchemaOrFields, Result>(name: Name, config: {
+    readonly Input: Input;
+    readonly Result: Result;
+  }) => QueryDescriptor<Name, TypeOf<Input>, ResultOf<Result>>;
+  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;
+};
+//#endregion
+//#region src/live.d.ts
+export type LiveCursor = number;
+export 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;
+};
+export interface BoundaryCounts {
+  readonly before: number;
+  readonly after: number;
+}
+export interface LiveState {
+  /** Last applied cursor for this stream. */
+  readonly cursor: LiveCursor;
+  /** Connections marked stale by an invalidating event. */
+  readonly stale: ReadonlySet<string>;
+  /** Edges recorded outside the loaded boundary, not visible in `items`. */
+  readonly boundary: Readonly<Record<string, BoundaryCounts>>;
+}
+export declare const emptyLiveState: LiveState;
+export 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.
+ */
+export declare const classifyLive: (state: LiveState, cursor: LiveCursor) => LiveOutcome;
+export declare const invalidateConnection: (state: LiveState, connection: string) => LiveState;
+/**
+ * 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;
+  readonly outcome: LiveOutcome;
+}
+export declare const applyEntityEvent: (state: LiveState, store: EntityStore, event: Extract<LiveEvent, {
+  _tag: "EntityPatched" | "EntityDeleted";
+}>, now?: number) => EntityApplied;
+export interface ConnectionApplied {
+  readonly state: LiveState;
+  readonly optimistic: OptimisticState;
+  readonly outcome: LiveOutcome;
+}
+export declare const applyConnectionEvent: (state: LiveState, optimistic: OptimisticState, event: Extract<LiveEvent, {
+  _tag: "ConnectionInsert" | "ConnectionRemove" | "ConnectionInvalidate";
+}>, policy?: LivePolicy) => ConnectionApplied;
+export declare const isStale: (state: LiveState, connection: string) => boolean;
+/**
+ * Clears a connection's stale mark once a fresh page has been adopted. An
+ * invalidating event only records that a refetch is due; whoever merges the
+ * refetched page calls this so `isStale` stops reporting.
+ */
+export declare const refreshConnection: (state: LiveState, connection: string) => LiveState;
+/** `hasPrevious` accounting for edges recorded outside the loaded boundary. */
+export declare const liveHasPrevious: (connection: Connection, state: LiveState, connectionId: string) => boolean;
+/** `hasNext` accounting for edges recorded outside the loaded boundary. */
+export 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. */
+export interface ConnectionRoot {
+  readonly identity: string;
+  readonly select?: RelationRequirement$1 | undefined;
+}
+export interface RetentionRoots {
+  readonly requirements: ReadonlyArray<Requirement$1>;
+  /** Connections (`QueryRef.identity`) to keep, with their edges' targets and what `select` reaches through them. */
+  readonly connections: ReadonlyArray<ConnectionRoot>;
+}
+export 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.
+ */
+export 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.
+ */
+export 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. */
+export declare const REMOTE_CACHE_VERSION = 3;
+export 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. */
+export type MergePolicy = 'replace' | 'preserve-existing';
+export declare const RemotePersistence: {
+  /** The snapshot text, or `undefined` when it would exceed `maxBytes`. */
+  dehydrate: (store: EntityStore, options?: SnapshotOptions) => string | undefined;
+  /** The store a snapshot text holds, or `undefined` when it is refused. */
+  hydrate: (raw: string | undefined | null, options?: SnapshotOptions) => EntityStore | undefined;
+  /** A snapshot brought into a store by policy. */
+  mergeStores: (current: EntityStore, snapshot: EntityStore, policy: MergePolicy) => EntityStore;
+  /**
+   * 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: (store: EntityStore, options: {
+    readonly key: string;
+  } & SnapshotOptions) => Effect.Effect<void, KeyValueStore.KeyValueStoreError, KeyValueStore.KeyValueStore>;
+  /**
+   * Reads the cache. A missing key yields `emptyStore`; anything `hydrate`
+   * refuses yields `emptyStore` and removes the key, so the next `restore` is
+   * clean and the planner refetches.
+   */
+  restore: (options: {
+    readonly key: string;
+  } & SnapshotOptions) => Effect.Effect<Readonly<Record<string, EntityEntry>>, 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.
+ */
+export declare const REMOTE_PROTOCOL_VERSION = 3;
+declare const RemoteReadError_base: Schema.Class<RemoteReadError, Schema.TaggedStruct<"RemoteReadError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RemoteReadError extends RemoteReadError_base {}
+declare const RemoteMutationError_base: Schema.Class<RemoteMutationError, Schema.TaggedStruct<"RemoteMutationError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RemoteMutationError extends RemoteMutationError_base {}
+declare const RemoteLiveError_base: Schema.Class<RemoteLiveError, Schema.TaggedStruct<"RemoteLiveError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export 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. */
+export declare class RemoteProtocolError extends RemoteProtocolError_base {}
+/** A page size: a non-negative integer, refused at decode otherwise rather than defaulted. */
+export declare const PageSize: Schema.Number;
+export 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. */
+export declare const MAX_FIELDS_PER_REQUEST = 256;
+/** A selection may not nest relations deeper than this; the wire refuses more. */
+export declare const MAX_RELATION_DEPTH = 8;
+export declare const RelationRequest: Schema.Codec<RelationRequirement$1, RelationRequirement$1, never, never>;
+export declare const ReadRequest: Schema.Codec<Requirement$1, Requirement$1>;
+export declare const ReadBatch: Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requests: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+}>;
+export declare const NormalizedEntity: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+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>;
+  }>>;
+}>;
+export declare const MutationRequest: Schema.Struct<{
+  /** Stable across transport retries so a mutation is not applied twice. */
+  readonly requestId: Schema.String;
+  readonly mutation: Schema.String;
+  readonly input: Schema.Unknown;
+}>;
+export declare const LiveEdge: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly key: Schema.String;
+}>;
+/** A connection change a mutation confirms: the same facts a live event carries, without a cursor. */
+export declare const ConnectionChangeSchema: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"Insert">;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Remove">;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>]>;
+export declare const MutationResult: Schema.Struct<{
+  readonly output: Schema.Unknown;
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  /** Connection changes the mutation made, applied alongside its entity patches. */
+  readonly connections: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Insert">;
+    readonly connection: Schema.String;
+    readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Remove">;
+    readonly connection: Schema.String;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>]>>>;
+}>;
+export declare const LiveRequirement: Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requirements: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+  /** Resume cursor; events at or before it are duplicates. */
+  readonly after: Schema.Number;
+}>;
+/**
+ * A live change. Entity changes update the store; connection changes alter
+ * membership and ordering; both carry a per-stream cursor.
+ */
+export declare const LiveChange: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityPatched">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly changed: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityDeleted">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInsert">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionRemove">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInvalidate">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+}>]>;
+export declare const Read: Rpc.Rpc<"FoldkitRemoteRead", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requests: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, 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>;
+  }>>;
+}>, 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. */
+  readonly requestId: Schema.String;
+  readonly mutation: Schema.String;
+  readonly input: Schema.Unknown;
+}>, Schema.Struct<{
+  readonly output: Schema.Unknown;
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  /** Connection changes the mutation made, applied alongside its entity patches. */
+  readonly connections: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Insert">;
+    readonly connection: Schema.String;
+    readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Remove">;
+    readonly connection: Schema.String;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>]>>>;
+}>, typeof RemoteMutationError, never, never>;
+export declare const Live: Rpc.Rpc<"FoldkitRemoteLive", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requirements: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+  /** Resume cursor; events at or before it are duplicates. */
+  readonly after: Schema.Number;
+}>, import("effect/unstable/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityPatched">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly changed: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityDeleted">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInsert">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionRemove">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInvalidate">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+}>]>, Schema.Union<readonly [typeof RemoteLiveError, typeof RemoteProtocolError]>>, Schema.Never, never, never>;
+declare const RemoteQueryError_base: Schema.Class<RemoteQueryError, Schema.TaggedStruct<"RemoteQueryError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RemoteQueryError extends RemoteQueryError_base {}
+export declare const WireBoundary: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"Terminal">;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Cursor">;
+  readonly cursor: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Unknown">;
+}>]>;
+export declare const QueryRequest: Schema.Struct<{
+  readonly query: Schema.String;
+  readonly input: Schema.Unknown;
+  readonly window: Schema.Struct<{
+    readonly first: Schema.optional<Schema.Number>;
+    readonly last: Schema.optional<Schema.Number>;
+    readonly after: Schema.optional<Schema.String>;
+    readonly before: Schema.optional<Schema.String>;
+  }>;
+}>;
+export declare const QueryEdge: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly key: Schema.String;
+}>;
+export declare const QueryResult: Schema.Struct<{
+  readonly edges: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>>;
+  readonly start: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  readonly end: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+}>;
+export declare const QueryRpc: Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
+  readonly query: Schema.String;
+  readonly input: Schema.Unknown;
+  readonly window: Schema.Struct<{
+    readonly first: Schema.optional<Schema.Number>;
+    readonly last: Schema.optional<Schema.Number>;
+    readonly after: Schema.optional<Schema.String>;
+    readonly before: Schema.optional<Schema.String>;
+  }>;
+}>, Schema.Struct<{
+  readonly edges: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>>;
+  readonly start: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  readonly end: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+}>, typeof RemoteQueryError, never, never>;
+export declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requests: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, 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>;
+  }>>;
+}>, Schema.Union<readonly [typeof RemoteReadError, typeof RemoteProtocolError]>, never, never> | Rpc.Rpc<"FoldkitRemoteMutate", Schema.Struct<{
+  /** Stable across transport retries so a mutation is not applied twice. */
+  readonly requestId: Schema.String;
+  readonly mutation: Schema.String;
+  readonly input: Schema.Unknown;
+}>, Schema.Struct<{
+  readonly output: Schema.Unknown;
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  /** Connection changes the mutation made, applied alongside its entity patches. */
+  readonly connections: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Insert">;
+    readonly connection: Schema.String;
+    readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Remove">;
+    readonly connection: Schema.String;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>]>>>;
+}>, typeof RemoteMutationError, never, never> | Rpc.Rpc<"FoldkitRemoteLive", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requirements: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+  /** Resume cursor; events at or before it are duplicates. */
+  readonly after: Schema.Number;
+}>, import("effect/unstable/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityPatched">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly changed: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityDeleted">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInsert">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionRemove">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInvalidate">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+}>]>, Schema.Union<readonly [typeof RemoteLiveError, typeof RemoteProtocolError]>>, Schema.Never, never, never> | Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
+  readonly query: Schema.String;
+  readonly input: Schema.Unknown;
+  readonly window: Schema.Struct<{
+    readonly first: Schema.optional<Schema.Number>;
+    readonly last: Schema.optional<Schema.Number>;
+    readonly after: Schema.optional<Schema.String>;
+    readonly before: Schema.optional<Schema.String>;
+  }>;
+}>, Schema.Struct<{
+  readonly edges: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>>;
+  readonly start: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  readonly end: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+}>, typeof RemoteQueryError, never, never>>;
+//#endregion
+//#region src/remoteData.d.ts
+export interface RemoteError {
+  readonly _tag: string;
+  readonly message: string;
+}
+export type RemoteData<A> = {
+  readonly _tag: 'Initial';
+} | {
+  readonly _tag: 'Loading';
+} | {
+  readonly _tag: 'Ready';
+  readonly value: A;
+} | {
+  readonly _tag: 'Refreshing';
+  readonly value: A;
+} | {
+  readonly _tag: 'Failed';
+  readonly error: RemoteError;
+  readonly previous?: A;
+} | {
+  readonly _tag: 'NotFound';
+};
+export declare const remoteErrorSchema: Schema.Struct<{
+  readonly _tag: Schema.String;
+  readonly message: Schema.String;
+}>;
+export declare const remoteDataSchema: <A>(value: Schema.Schema<A>) => Schema.Schema<RemoteData<A>>;
+export declare const RemoteData: {
+  /**
+   * The `RemoteData` schema for a value schema. Exposed so a `RemoteData` can
+   * be embedded in a hand-written Model schema, not only through `Remote.select`.
+   */
+  schema: <A>(value: Schema.Schema<A>) => Schema.Schema<RemoteData<A>>;
+  /** Exhaustive: omitting a state is a compile error. */
+  match: <A, R>(data: RemoteData<A>, cases: {
+    readonly Initial: () => R;
+    readonly Loading: () => R;
+    readonly Ready: (value: A) => R;
+    readonly Refreshing: (value: A) => R;
+    readonly Failed: (error: RemoteError, previous: Option.Option<A>) => R;
+    readonly NotFound: () => R;
+  }) => R;
+  map: <A, B>(data: RemoteData<A>, f: (value: A) => B) => RemoteData<B>;
+};
+//#endregion
+//#region src/model.d.ts
+/**
+ * The normalized cache as a Foldkit Submodel. `Remote.make` returns a schema and
+ * an `update` for this shape; `Remote.update` reconciles every producer.
+ */
+export 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>>;
+  /** Optimistic entity layers and connection overlays over the base store. */
+  readonly optimistic: OptimisticState;
+  /** Live cursor and boundary state, keyed by the subscription's stream key. */
+  readonly live: Readonly<Record<string, LiveState>>;
+  /** Mutation pending/applied/failed ledger. */
+  readonly mutations: MutationState;
+  /** Streams whose live cursor fell behind; the caller should resync or refetch. */
+  readonly gaps: ReadonlySet<string>;
+}
+export declare const initialRemoteModel: RemoteModel;
+export declare const remoteModelSchema: () => Schema.Schema<RemoteModel>;
+/** The submodel's Messages; each reduces to `RemoteModel` through `Remote.update`. */
+export type RemoteMessage = {
+  readonly _tag: 'ReadReceived';
+  readonly requests: readonly Requirement$1[];
+  readonly result: Schema.Schema.Type<typeof ReadBatchResult>;
+  readonly now: number;
+} | {
+  readonly _tag: 'ReadFailed';
+  readonly requests: readonly Requirement$1[];
+  readonly error: RemoteError;
+} |
+/** A refetch of present fields began; they read as `Refreshing` until it lands. */
+{
+  readonly _tag: 'RefreshStarted';
+  readonly requests: readonly Requirement$1[];
+} |
+/** 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;
+  readonly merge: MergePolicy;
+} |
+/** A mutation began; its optimistic operations show until it settles. */
+{
+  readonly _tag: 'MutationStarted';
+  readonly requestId: string;
+  readonly optimistic?: ReadonlyArray<OptimisticOperation> | undefined;
+} | {
+  readonly _tag: 'MutationSucceeded';
+  readonly requestId: string;
+  readonly entities: readonly NormalizedPatch[];
+  /** Connection changes the server confirmed; they replace the request's own. */
+  readonly connections?: ReadonlyArray<ConnectionChange> | undefined;
+} | {
+  readonly _tag: 'MutationFailed';
+  readonly requestId: string;
+  readonly error: RemoteError;
+} | {
+  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;
+} | {
+  readonly _tag: 'ConnectionInvalidated';
+  readonly connection: string;
+} | {
+  readonly _tag: 'ConnectionRefreshed';
+  readonly connection: string;
+} |
+/** A query for the connection failed; it reads as it did before the request. */
+{
+  readonly _tag: 'QueryFailed';
+  readonly connection: string;
+  readonly error: RemoteError;
+};
+export declare const retentionRootsSchema: Schema.Struct<{
+  readonly requirements: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+  readonly connections: Schema.$Array<Schema.Struct<{
+    readonly identity: Schema.String;
+    readonly select: Schema.optional<Schema.Codec<import("foldkit-surface").RelationRequirement, import("foldkit-surface").RelationRequirement, never, never>>;
+  }>>;
+}>;
+/**
+ * The Messages' fields by tag, without `_tag`: what `defineMessageUnion` takes,
+ * so an application spreads them into its own union (`Remote.messages`).
+ */
+export declare const remoteMessageCases: {
+  ReadReceived: {
+    requests: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, 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>;
+      }>>;
+    }>;
+    now: Schema.Number;
+  };
+  ReadFailed: {
+    requests: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+    error: Schema.Struct<{
+      readonly _tag: Schema.String;
+      readonly message: Schema.String;
+    }>;
+  };
+  RefreshStarted: {
+    requests: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+  };
+  RetentionChanged: {
+    roots: Schema.Struct<{
+      readonly requirements: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+      readonly connections: Schema.$Array<Schema.Struct<{
+        readonly identity: Schema.String;
+        readonly select: Schema.optional<Schema.Codec<import("foldkit-surface").RelationRequirement, import("foldkit-surface").RelationRequirement, never, never>>;
+      }>>;
+    }>;
+  };
+  Hydrated: {
+    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>>;
+  };
+  MutationFailed: {
+    requestId: Schema.String;
+    error: Schema.Struct<{
+      readonly _tag: Schema.String;
+      readonly message: Schema.String;
+    }>;
+  };
+  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>;
+  };
+  ConnectionInvalidated: {
+    connection: Schema.String;
+  };
+  ConnectionRefreshed: {
+    connection: Schema.String;
+  };
+  QueryFailed: {
+    connection: Schema.String;
+    error: Schema.Struct<{
+      readonly _tag: Schema.String;
+      readonly message: Schema.String;
+    }>;
+  };
+};
+export type RemoteMessageTag = RemoteMessage['_tag'];
+/**
+ * A Remote Message as an application's union constructs it from
+ * `remoteMessageCases`: the same shape `RemoteMessage` names, with the runtime
+ * slots (`entities`, `event`, `page`) typed `unknown` by their schemas.
+ */
+export type RemoteMessageInput = { [Tag in RemoteMessageTag]: {
+  readonly _tag: Tag;
+} & Schema.Struct.Type<(typeof remoteMessageCases)[Tag]>; }[RemoteMessageTag];
+/**
+ * Whether a Message is one of Remote's, by tag. Narrows an application's union
+ * to its Remote cases, and its complement to the application's own.
+ */
+export declare const isRemoteMessage: <M extends {
+  readonly _tag: string;
+}>(message: M) => message is Extract<M, {
+  readonly _tag: RemoteMessageTag;
+}>;
+export declare const remoteMessageSchema: Schema.Schema<RemoteMessage>;
+/**
+ * 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.
+ */
+export declare const updateRemote: (model: RemoteModel, message: RemoteMessage) => RemoteModel;
+/**
+ * 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.
+ */
+export declare const writeRead: (store: EntityStore, requests: ReadonlyArray<Requirement$1>, result: Schema.Schema.Type<typeof ReadBatchResult>, now?: number) => EntityStore;
+//#endregion
+//#region src/coalesce.d.ts
+type Batch = Schema.Schema.Type<typeof ReadBatch>;
+type BatchResult = Schema.Schema.Type<typeof ReadBatchResult>;
+type ReadError = RemoteReadError | RemoteProtocolError;
+export type BatchRead = (batch: Batch) => Effect.Effect<BatchResult, ReadError>;
+type QueryRequestValue = Schema.Schema.Type<typeof QueryRequest>;
+type QueryResultValue = Schema.Schema.Type<typeof QueryResult>;
+export type QueryRun = (request: QueryRequestValue) => Effect.Effect<QueryResultValue, RemoteQueryError>;
+export 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. */
+export declare const requirementKey: (requirement: Requirement$1) => 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.
+ */
+export 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.
+ */
+export declare const coalesceReads: (read: BatchRead, options?: CoalesceOptions) => Effect.Effect<BatchRead>;
+//#endregion
+//#region src/client.d.ts
+declare const RemoteClient_base: Context.ServiceClass<RemoteClient, "foldkit-remote/RemoteClient", {
+  readonly read: (batch: Schema.Schema.Type<typeof ReadBatch>) => Effect.Effect<Schema.Schema.Type<typeof ReadBatchResult>, RemoteReadError | RemoteProtocolError>;
+  readonly query: (request: Schema.Schema.Type<typeof QueryRequest>) => Effect.Effect<Schema.Schema.Type<typeof QueryResult>, RemoteQueryError>;
+  readonly mutate: (request: Schema.Schema.Type<typeof MutationRequest>) => Effect.Effect<Schema.Schema.Type<typeof MutationResult>, RemoteMutationError>;
+  readonly live: (request: {
+    readonly requirements: ReadonlyArray<Requirement$1>;
+    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.
+ */
+export 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.
+ */
+export interface RemoteRpcClient<R = never> {
+  readonly FoldkitRemoteRead: (payload: Schema.Schema.Type<typeof ReadBatch>) => Effect.Effect<Schema.Schema.Type<typeof ReadBatchResult>, RemoteReadError | RemoteProtocolError, R>;
+  readonly FoldkitRemoteQuery: (payload: Schema.Schema.Type<typeof QueryRequest>) => Effect.Effect<Schema.Schema.Type<typeof QueryResult>, RemoteQueryError, R>;
+  readonly FoldkitRemoteMutate: (payload: Schema.Schema.Type<typeof MutationRequest>) => Effect.Effect<Schema.Schema.Type<typeof MutationResult>, RemoteMutationError, R>;
+  readonly FoldkitRemoteLive: (payload: Schema.Schema.Type<typeof LiveRequirement>) => Stream.Stream<Schema.Schema.Type<typeof LiveChange>, RemoteLiveError | RemoteProtocolError, R>;
+}
+/** Reconstructs the client's `ConnectionChange` from the wire's flattened edge. */
+export declare const connectionChangeOf: (change: Schema.Schema.Type<typeof ConnectionChangeSchema>) => ConnectionChange;
+/** Reconstructs the client's `LiveEvent` from the wire's flattened `LiveChange`. */
+export declare const liveEventOf: (change: Schema.Schema.Type<typeof LiveChange>) => LiveEvent;
+export declare const remoteError: (error: {
+  readonly _tag: string;
+  readonly message: string;
+}) => RemoteError;
+export 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.
+ */
+export declare const mutateRemote: <Name extends string, Input, Output>(mutation: MutationDescriptor<Name, Input, Output>, input: Input, requestId: string) => Effect.Effect<{
+  output: Output;
+  entities: readonly {
+    readonly entity: string;
+    readonly id: string;
+    readonly values: {
+      readonly [x: string]: unknown;
+    };
+  }[];
+  connections: ConnectionChange[];
+}, RemoteMutationError, RemoteClient>;
+//#endregion
+//#region src/relation.d.ts
+export interface RefParts {
+  readonly entity: string;
+  readonly id: string;
+}
+/** A page of refs as the wire and the store hold it. */
+export 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. */
+export declare const RelationAnnotation = "foldkitRemoteRelation";
+/** The target entity's name on the same codec, so a nested selection of another entity is refused. */
+export declare const RelationEntityAnnotation = "foldkitRemoteRelationEntity";
+export type RelationKind = 'one' | 'many' | 'page';
+export interface RelationShape {
+  readonly kind: RelationKind;
+  readonly nullable: boolean;
+  readonly entity: string;
+}
+/** Splits a ref key (`"Entity:id"`, the store key too) back into its parts. */
+export 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.
+ */
+export declare const refsIn: (value: unknown) => ReadonlyArray<RefParts>;
+/** The refs in a relation value that name the relation's target entity, and no other. */
+export declare const targetsOf: (value: unknown, relation: RelationRequirement$1) => ReadonlyArray<RefParts>;
+export 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.
+ */
+export 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. */
+export interface Page<Item> {
+  readonly items: ReadonlyArray<Item>;
+  readonly hasNext: boolean;
+  readonly hasPrevious: boolean;
+}
+/**
+ * The fields a projection reads of one entity, plus the slice it reads of each
+ * relation's target. `Shape` tells a parent selection whether this one is a
+ * paginated relation (`connection`) or a plain entity slice (`entity`).
+ */
+export 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$1>> | 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>`. */
+export 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. */
+export 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. */
+export 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]>; }>;
+export declare const pageSchema: (item: AnySchema) => AnySchema;
+/** The requirement a nested selection contributes for its relation's target. */
+export declare const relationOf: (selection: Selection<unknown>) => RelationRequirement$1;
+export declare const Selection: {
+  /**
+   * The fields to read of `entity`. A nested `Selection` on a relation field
+   * reads through the ref (or refs, or page of refs) the field holds into the
+   * target's fields; a scalar field cannot take one.
+   */
+  make: <Name extends string, F extends Schema.Struct.Fields, const Sel extends SelectionOf<F>>(entity: EntityDescriptor<Name, F>, selection: Sel) => Selection<SelectionValue<F, Sel>, Name, "entity">;
+  /**
+   * A paginated relation: one page of refs to `entity` with a window, or, with
+   * a nested selection, one page of targets assembled through it.
+   */
+  connection: {
+    <Name extends string, F extends Schema.Struct.Fields>(entity: EntityDescriptor<Name, F>, window: QueryWindow): Selection<RefPage<Name, F>, Name, "connection">;
+    <Name extends string, F extends Schema.Struct.Fields, Item>(entity: EntityDescriptor<Name, F>, window: QueryWindow, selection: Selection<Item, NoInfer<Name>, "entity">): Selection<Page<Item>, Name, "connection">;
+  };
+};
+interface Assembled {
+  readonly values: unknown;
+  readonly refreshing: boolean;
+}
+/**
+ * Reads an entity's selected fields out of the store, following each nested
+ * relation into its targets. `undefined` means some field, at any depth, is
+ * not present yet. A tombstoned target reads as `null` (or is dropped from a
+ * list), so the Selection's codec decides whether that is a failure.
+ */
+export declare const assemble: (store: EntityStore, key: string, requirement: RelationRequirement$1) => Assembled | undefined;
+//#endregion
+//#region src/entity.d.ts
+export type AnySchema = Schema.Schema<unknown>;
+declare const entityRefFields: unique symbol;
+/**
+ * A normalized reference to an entity. `F` is a phantom carrying the entity's
+ * fields so `Entity.patch` can type its patch; it is absent at runtime.
+ */
+export interface EntityRef<Name extends string, F extends Schema.Struct.Fields = Schema.Struct.Fields> {
+  readonly entity: Name;
+  readonly id: string;
+  readonly [entityRefFields]?: F;
+}
+export 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>;
+}
+/**
+ * A patch in wire shape: the values the store holds, so a relation is its ref
+ * key (`Entity.refKey`), not an `EntityRef`.
+ */
+export interface EntityPatch<Name extends string, F extends Schema.Struct.Fields> {
+  readonly entity: Name;
+  readonly id: string;
+  readonly values: Partial<Schema.Struct.Encoded<F>>;
+}
+/**
+ * One authoritative page of a paginated relation: refs (never inline entities)
+ * plus whether more exist. The adapter does not hold segmentation state; the
+ * client merges pages.
+ */
+export 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;
+}
+declare const Entity$1: {
+  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>, string>;
+  /** A relation by name, for recursive or forward references. */
+  refTo: <Name extends string>(name: Name) => Schema.Codec<EntityRef<Name>, string>;
+  /**
+   * 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/inspect.d.ts
+/** A serializable summary of a RemoteModel for DevTools and diagnostics. */
+export interface RemoteInspection {
+  readonly entities: ReadonlyArray<{
+    readonly key: string;
+    readonly present: ReadonlyArray<string>;
+    readonly stale: ReadonlyArray<string>;
+    readonly tombstone: boolean;
+    readonly updatedAt: number;
+    readonly windows: Readonly<Record<string, string>>;
+  }>;
+  readonly connections: ReadonlyArray<string>;
+  readonly live: ReadonlyArray<string>;
+  readonly gaps: ReadonlyArray<string>;
+  readonly mutations: {
+    readonly pending: ReadonlyArray<string>;
+    readonly failed: ReadonlyArray<string>;
+    readonly applied: number;
+  };
+}
+/** A pure, serializable view of the whole cache. */
+export declare const inspectRemote: (model: RemoteModel) => RemoteInspection;
+/** A pure, serializable view of one entity, or `undefined` if unknown. */
+export declare const inspectEntity: (model: RemoteModel, key: string) => RemoteInspection["entities"][number] | undefined;
+//#endregion
+//#region src/plan.d.ts
+type Window = NonNullable<Requirement$1['windows']>[string];
+/** A stable key for a window, so two equal windows compare equal. */
+export declare const windowKey: (window: Window) => string;
+export interface PlanFreshness {
+  readonly now: number;
+  /** A present entry older than this many milliseconds is refreshed whole. */
+  readonly freshness: number;
+}
+export interface PlanOptions {
+  readonly freshness?: PlanFreshness | undefined;
+  /** Plan every requested field, present or not, tombstoned or not. */
+  readonly force?: boolean | undefined;
+}
+export declare const plan: (store: EntityStore, requirements: readonly Requirement$1[], options?: PlanOptions) => ReadonlyArray<Requirement$1>;
+//#endregion
+//#region src/policy.d.ts
+export type RemotePolicy =
+/** Fetch only fields the store lacks (missing, stale, or re-windowed). */
+{
+  readonly _tag: 'CacheFirst';
+} |
+/**
+ * Keep present values visible, read them as `Refreshing`, and refetch an
+ * entry older than `maxAge` milliseconds.
+ */
+{
+  readonly _tag: 'StaleWhileRevalidate';
+  readonly maxAge: number;
+} |
+/** Fetch every selected field regardless of coverage; cached values stay visible meanwhile. */
+{
+  readonly _tag: 'NetworkOnly';
+};
+export declare const RemotePolicy: {
+  /** Fetch only what the store lacks. */
+  cacheFirst: {
+    readonly _tag: "CacheFirst";
+  };
+  /** Keep present values visible, read as `Refreshing`, and refetch an entry older than `maxAge` ms. */
+  staleWhileRevalidate: (options: {
+    readonly maxAge: number;
+  }) => RemotePolicy;
+  /** Fetch every selected field regardless of coverage; cached values stay visible meanwhile. */
+  networkOnly: {
+    readonly _tag: "NetworkOnly";
+  };
+  /** The planner options a policy compiles to at `now`. */
+  toPlan: (policy: RemotePolicy, now: number) => PlanOptions;
+  /**
+   * Whether a read under this policy may refetch fields the store already
+   * holds, so an observer marks them stale (read as `Refreshing`) while the
+   * request is pending.
+   */
+  refreshes: (policy: RemotePolicy) => boolean;
+};
+//#endregion
+//#region src/index.d.ts
+type EntityName<D> = D extends EntityDescriptor<infer Name, any> ? Name : never;
+type QueryName<D> = D extends QueryDescriptor<infer Name, any, any> ? Name : never;
+type MutationName<D> = D extends MutationDescriptor<infer Name, any, any> ? Name : never;
+/**
+ * Nothing when `Name` is one of the domain's registered `Names`; otherwise a
+ * branded failure naming the descriptor, so `Data.get(Team.select(…))` for an
+ * unregistered `Team` errors at the selection in one line.
+ */
+export type Registered<Name extends string, Names extends string, Kind extends string> = [Name] extends [Names] ? unknown : Invalid<`${Kind} "${Name}" is not registered with this Remote domain`>;
+/** Nothing when a selection is of the query's entity; otherwise a branded failure naming both. */
+export type SelectsEntity<Entity extends string, Of extends string> = [Entity] extends [Of] ? unknown : Invalid<`the selection is of "${Entity}", but the query lists "${Of}"`>;
+export interface RemoteDescriptor<Entities extends readonly EntityDescriptor<any, any>[] = readonly EntityDescriptor<any, any>[], Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly MutationDescriptor<any, any, any>[]> {
+  readonly entities: Entities;
+  readonly queries: Queries;
+  readonly mutations: Mutations;
+  readonly Model: Schema.Schema<RemoteModel>;
+  readonly initial: RemoteModel;
+  readonly Message: Schema.Schema<RemoteMessage>;
+  readonly update: (model: RemoteModel, message: RemoteMessage) => RemoteModel;
+  readonly rpc: typeof RemoteRpc;
+  /** Name-keyed lookups built from the declared entities, queries, and mutations. */
+  readonly registry: {
+    readonly entities: ReadonlyMap<string, EntityDescriptor<any, any>>;
+    readonly queries: ReadonlyMap<string, QueryDescriptor<any, any, any>>;
+    readonly mutations: ReadonlyMap<string, MutationDescriptor<any, any, any>>;
+  };
+}
+declare const boundRemoteNames: unique symbol;
+export interface BoundRemote<AppModel, Store extends RemoteModel, Names extends string = string> {
+  readonly definition: RemoteDescriptor;
+  readonly store: ModelRef<AppModel, Store>;
+  /** For `Module`: owns the store's Model path. */
+  readonly contract: Contract;
+  /** Phantom: the entity names this Remote definition registers. */
+  readonly [boundRemoteNames]?: Names;
+}
+type MutationInput<M> = M extends MutationDescriptor<any, infer Input, any> ? Input : never;
+export interface DomainMutateOptions {
+  /** Overrides the generated id, for a retry, a durable bridge, or a test. */
+  readonly requestId?: string | undefined;
+  /**
+   * What the request changes before the server answers, released when it
+   * settles. A function receives the generated ids, so a created entity can
+   * carry `tempId` until the result names the real one.
+   */
+  readonly optimistic?: ReadonlyArray<OptimisticOperation> | ((ids: {
+    readonly requestId: string;
+    readonly tempId: string;
+  }) => ReadonlyArray<OptimisticOperation>) | undefined;
+}
+/** A Foldkit Subscription entry of the Remote domain, emitting its Messages through `RemoteClient`. */
+export type RemoteEntry<AppModel, Dependencies> = EntryWithoutKeepAlive<AppModel, RemoteMessage, Dependencies, RemoteClient>;
+export interface SubscriptionsOptions extends ObserveOptions, LiveOptions, RetainOptions {}
+/** What `RemoteDomain.mutate` hands `update`: the Model with the request started, and the Command that settles it. */
+export interface MutationStarted<AppModel> {
+  readonly model: AppModel;
+  readonly requestId: string;
+  readonly tempId: string;
+  /** Yields `MutationSucceeded` or `MutationFailed`; never fails. */
+  readonly command: Command<RemoteMessage, never, RemoteClient>;
+}
+/**
+ * A Remote domain bound to its place in the application Model: the descriptor
+ * (`Remote.define`), the binding (`Remote.at`), and the application-facing
+ * operations over them. Every method compiles to the `Remote.*` function of the
+ * same name, which stays exported for tooling, SSR, and tests.
+ */
+export interface RemoteDomain<AppModel, Store extends RemoteModel, Entities extends readonly EntityDescriptor<any, any>[], Queries extends readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[]> extends BoundRemote<AppModel, Store, EntityName<Entities[number]>>, RemoteDescriptor<Entities, Queries, Mutations> {
+  /** `Remote.select`: a Projection reading one entity through a selection of a registered entity. */
+  get<Value, Name extends string>(selection: Selection<Value, Name, 'entity'> & Registered<Name, EntityName<Entities[number]>, 'Entity'>, id: string): Projection<AppModel, RemoteData<Value>>;
+  /**
+   * `get`, and the projection also subscribes to the entity's changes: its
+   * requirements are marked `live`, so `subscriptions` derives a live entry for
+   * the Surfaces that read it.
+   */
+  live<Value, Name extends string>(selection: Selection<Value, Name, 'entity'> & Registered<Name, EntityName<Entities[number]>, 'Entity'>, id: string): Projection<AppModel, RemoteData<Value>>;
+  /**
+   * A query connection read as a `Page` of items selected of the query's
+   * entity: `Initial` until the page and every item's selected fields are
+   * present, `Refreshing` while any of them is being refetched. The window is
+   * the page first asked for; the pages `next`, `previous` and `fetch` merge
+   * onto the connection read through the same projection.
+   */
+  query<Q extends QueryDescriptor<any, any, any>, Value, Entity extends string>(query: Q & Registered<Q['name'], QueryName<Queries[number]>, 'Query'>, input: QueryInput<Q>, options: QueryOptions<Value, Entity, QueryEntity<Q>>): QueryProjection<AppModel, Value, Q['name'], QueryInput<Q>>;
+  /** 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;
+  /** 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>;
+  /**
+   * 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
+   * Surface's params are a function of the Model (`Surface.at`), so what is
+   * fetched, subscribed, and retained follows the Model.
+   */
+  subscriptions(active: Readonly<Record<string, ActiveSurface<AppModel> | Surface<AppModel, any, any, void>>>, options?: SubscriptionsOptions): Readonly<Record<string, RemoteEntry<AppModel, any>>>;
+  /** `Remote.plan`: the requirements the store does not satisfy. */
+  plan<Value>(model: AppModel, projection: Projection<AppModel, Value>, options?: PlanOptions): ReadonlyArray<Requirement$1>;
+  /** `Remote.storeOf`: the visible store, base under the pending optimistic layers. */
+  storeOf(model: AppModel): EntityStore;
+  /**
+   * The plan run through `RemoteClient` and reduced into the Model: the
+   * projection's pending queries first, then the fields it lacks (the pages'
+   * items included). For SSR, route or hover prefetch, and tests.
+   */
+  prefetch<Value>(model: AppModel, projection: Projection<AppModel, Value>, options?: ObserveOptions): Effect.Effect<AppModel, RemoteReadError | RemoteProtocolError | RemoteQueryError, RemoteClient>;
+  /**
+   * Starts a registered mutation from `update`: applies `MutationStarted` (with
+   * the optimistic operations) to the Model and returns the Command that runs
+   * it and yields the settling Message. The request id comes from the model's
+   * mutation sequence unless `options.requestId` is given.
+   */
+  mutate<M extends MutationDescriptor<any, any, any>>(model: AppModel, mutation: M & Registered<M['name'], MutationName<Mutations[number]>, 'Mutation'>, input: MutationInput<M>, options?: DomainMutateOptions): MutationStarted<AppModel>;
+  /** `Remote.update` on the bound slice: reduces one of Remote's Messages, as `RemoteMessage` or as the application's union constructs it. */
+  reduce(model: AppModel, message: RemoteMessage | RemoteMessageInput): AppModel;
+  /** `Remote.inspect` of the bound slice. */
+  inspect(model: AppModel): RemoteInspection;
+}
+/** A projection's connection requirement with the `QueryRef` that runs it. */
+export interface QueryRequirement extends ConnectionRequirement {
+  readonly ref: QueryRef<string, unknown>;
+}
+/** A page forward (`first`, `after`) or back (`last`, `before`); mixing the two is a type error. */
+export type QueryWindowOptions = {
+  readonly first?: number | undefined;
+  readonly after?: string | undefined;
+  readonly last?: undefined;
+  readonly before?: undefined;
+} | {
+  readonly last: number;
+  readonly before?: string | undefined;
+  readonly first?: undefined;
+  readonly after?: undefined;
+};
+export type QueryOptions<Value, Entity extends string, Of extends string = Entity> = {
+  /** What to read of each item: a selection of the query's entity (`Of`). */
+  readonly select: Selection<Value, Entity, 'entity'> & SelectsEntity<Entity, Of>;
+} & QueryWindowOptions;
+/** A query connection read as a `Page` of selected items; `ref` is the connection with its first window. */
+export interface QueryProjection<AppModel, Value, Name extends string, Input> extends Projection<AppModel, RemoteData<Page<Value>>> {
+  readonly ref: QueryRef<Name, Input>;
+}
+/** The input of a query descriptor. */
+export type QueryInput<Q> = Q extends QueryDescriptor<any, infer Input, any> ? Input : never;
+/** The entity a query's connection is over. */
+export type QueryEntity<Q> = Q extends QueryDescriptor<any, any, ConnectionSpec<infer Entity>> ? Entity : string;
+export interface MutateOptions {
+  /** What the request changes before the server answers; released when it settles. */
+  readonly optimistic?: ReadonlyArray<OptimisticOperation> | undefined;
+}
+export interface RetainOptions {
+  /** The query connections the application shows, by `QueryRef` or identity. */
+  readonly connections?: ReadonlyArray<ConnectionIdentity> | undefined;
+  /** How long the roots must be stable before collecting; default none. */
+  readonly grace?: Duration.Input | undefined;
+}
+/** How `Remote.observe` and `Remote.prefetch` treat fields the store already holds. */
+export interface ObserveOptions {
+  /** Default `RemotePolicy.cacheFirst`. */
+  readonly policy?: RemotePolicy | undefined;
+  /** The clock a refreshing policy reads; default `Date.now`. */
+  readonly now?: (() => number) | undefined;
+}
+export interface LiveOptions {
+  /** The clock `LiveReceived` stamps events with; default `Date.now`. */
+  readonly now?: (() => number) | undefined;
+}
+/** A query the read entry runs, as its dependencies carry it: plain data Foldkit compares. */
+declare const PlannedQuery: Schema.Struct<{
+  readonly identity: Schema.String;
+  readonly window: Schema.Struct<{
+    readonly first: Schema.optional<Schema.Number>;
+    readonly last: Schema.optional<Schema.Number>;
+    readonly after: Schema.optional<Schema.String>;
+    readonly before: Schema.optional<Schema.String>;
+  }>;
+  readonly select: Schema.Codec<RelationRequirement, RelationRequirement, never, never>;
+}>;
+/** The dependencies of the read entry: the entity fields to read and the queries to run. */
+export interface ReadDependencies {
+  readonly requirements: ReadonlyArray<Requirement$1>;
+  readonly queries: ReadonlyArray<Schema.Schema.Type<typeof PlannedQuery>>;
+}
+export declare const Remote: {
+  /** The submodel's schema, the same for every domain; embed it in the application Model. */
+  Model: Schema.Schema<RemoteModel>;
+  /** The submodel's initial value. */
+  initial: RemoteModel;
+  /**
+   * Remote's Message cases for `defineMessageUnion`: spread them into the
+   * application's union, and reduce the ones `Remote.reduces` recognizes with
+   * `RemoteDomain.reduce`.
+   */
+  messages: {
+    ReadReceived: {
+      requests: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, 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>;
+        }>>;
+      }>;
+      now: Schema.Number;
+    };
+    ReadFailed: {
+      requests: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+      }>;
+    };
+    RefreshStarted: {
+      requests: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+    };
+    RetentionChanged: {
+      roots: Schema.Struct<{
+        readonly requirements: Schema.$Array<Schema.Codec<Requirement$1, Requirement$1, never, never>>;
+        readonly connections: Schema.$Array<Schema.Struct<{
+          readonly identity: Schema.String;
+          readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+        }>>;
+      }>;
+    };
+    Hydrated: {
+      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>>;
+    };
+    MutationFailed: {
+      requestId: Schema.String;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+      }>;
+    };
+    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>;
+    };
+    ConnectionInvalidated: {
+      connection: Schema.String;
+    };
+    ConnectionRefreshed: {
+      connection: Schema.String;
+    };
+    QueryFailed: {
+      connection: Schema.String;
+      error: Schema.Struct<{
+        readonly _tag: Schema.String;
+        readonly message: Schema.String;
+      }>;
+    };
+  };
+  /** Whether a Message is one of Remote's, by tag. */
+  reduces: <M extends {
+    readonly _tag: string;
+  }>(message: M) => message is Extract<M, {
+    readonly _tag: RemoteMessageTag;
+  }>;
+  /**
+   * Declares a Remote domain and binds it to its place in the application Model
+   * in one step; the result carries the application-facing operations. The
+   * descriptor alone is `Remote.define`, the binding alone `Remote.at`.
+   */
+  make: <AppModel, Store extends RemoteModel, const Entities extends readonly EntityDescriptor<any, any>[], const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly [], const Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly []>(config: {
+    readonly model: ModelRef<AppModel, Store>;
+    readonly entities: Entities;
+    readonly queries?: Queries;
+    readonly mutations?: Mutations;
+  }) => RemoteDomain<AppModel, Store, Entities, Queries, Mutations>;
+  /**
+   * Declares a Remote domain without binding it: its entities, queries, and
+   * mutations, plus the submodel. For a domain reused across applications or
+   * bound in a test; `Remote.make` is the one-step form.
+   */
+  define: <const Entities extends readonly EntityDescriptor<any, any>[], const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<any, any, any>[], const Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly MutationDescriptor<any, any, any>[]>(config: {
+    readonly entities: Entities;
+    readonly queries?: Queries;
+    readonly mutations?: Mutations;
+  }) => RemoteDescriptor<Entities, Queries, Mutations>;
+  /**
+   * Binds a Remote domain to its store's location in the application Model. The
+   * registered entity names are carried on the returned value, so `Remote.select`
+   * rejects a selection for an entity this domain never declared.
+   */
+  at: <AppModel, Store extends RemoteModel, Entities extends readonly EntityDescriptor<any, any>[], 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 Projection node that reads a `RemoteData` value out of the store. The id
+   * is supplied by the caller, usually from a Surface's params. The assembled
+   * value is decoded against the Selection, so malformed server data surfaces
+   * as `Failed` instead of being asserted into `Value`. A present value with a
+   * stale field reads as `Refreshing`: an observer is refetching it.
+   */
+  select: <AppModel, Store extends RemoteModel, Names extends string, Value, Name extends string>(bound: BoundRemote<AppModel, Store, Names>, selection: Selection<Value, Name, "entity"> & Registered<Name, Names, "Entity">) => (id: string) => Projection<AppModel, RemoteData<Value>>;
+  /**
+   * The pure plan for a projection against a Model: the requirements its
+   * remote store does not satisfy, under `options` (freshness, force). A
+   * Surface's projection is `surface.projection(params)`.
+   */
+  plan: <AppModel, Store extends RemoteModel, Value>(bound: BoundRemote<AppModel, Store>, model: AppModel, projection: Projection<AppModel, Value>, options?: PlanOptions) => ReadonlyArray<Requirement$1>;
+  /**
+   * The queries a projection needs run before its connections read: those the
+   * Model does not hold, or holds stale (every one under `force`).
+   */
+  planQueries: <AppModel, Store extends RemoteModel, Value>(bound: BoundRemote<AppModel, Store>, model: AppModel, projection: Projection<AppModel, Value>, options?: PlanOptions) => ReadonlyArray<QueryRef<string, unknown>>;
+  /**
+   * The store reads see: the base store under the pending optimistic layers.
+   * One store is shared by every read and plan of a Model whose remote state
+   * has not changed.
+   */
+  storeOf: <AppModel, Store extends RemoteModel>(bound: BoundRemote<AppModel, Store>, model: AppModel) => EntityStore;
+  /**
+   * Executes the plan against the `RemoteClient` and returns a new store. Used
+   * for SSR route prefetch, hover prefetch, and tests. Never called during render.
+   * `policy` decides what a present field means (default cache-first); `now`
+   * is the clock it reads, so the planner itself stays pure and time-injected.
+   */
+  prefetch: <AppModel, Store extends RemoteModel, Value>(bound: BoundRemote<AppModel, Store, string>, model: AppModel, projection: Projection<AppModel, Value>, options?: ObserveOptions | undefined) => Effect.Effect<Readonly<Record<string, EntityEntry>>, RemoteReadError | RemoteProtocolError, RemoteClient>;
+  /**
+   * 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$1>, result: Schema.Schema.Type<typeof ReadBatchResult>, now?: number) => EntityStore;
+  /**
+   * Adapts an Effect RPC client for `RemoteRpc` to `RemoteClient`, so an
+   * application provides the transport's RPC layer instead of writing the
+   * `LiveChange`-to-`LiveEvent` mapping by hand.
+   */
+  clientLayer: <R = never>(client: RemoteRpcClient<R>, options?: CoalesceOptions) => Layer.Layer<RemoteClient, never, R>;
+  /**
+   * Wraps a `RemoteClient` layer so its reads coalesce: requirements issued
+   * together become one batch, and a requirement already in flight is joined.
+   * `Remote.clientLayer` applies this; use it on a hand-written client.
+   */
+  coalesced: <E, R>(layer: Layer.Layer<RemoteClient, E, R>, options?: CoalesceOptions) => Layer.Layer<RemoteClient, E, R>;
+  /**
+   * A Foldkit Subscription entry that keeps the cache to what the active
+   * Surfaces reach. `projections` are the ones the application observes (the
+   * same it passes to `Remote.observe`), `connections` the query connections
+   * it shows; anything else is collected once the roots have been stable for
+   * `grace`, so a route transition that comes straight back does not thrash.
+   */
+  retain: <AppModel, Message = RemoteMessage>(projections: ReadonlyArray<Projection<AppModel, unknown>>, toMessage?: (message: RemoteMessage) => Message, options?: RetainOptions) => EntryWithoutKeepAlive<AppModel, Message, RetentionRoots, never>;
+  /**
+   * Runs a `Query` through `RemoteClient`, encoding its input from the ref.
+   * Pair the result with `Remote.queryMessage` to merge the page into the Model.
+   */
+  query: <Name extends string, Input>(ref: QueryRef<Name, Input>) => Effect.Effect<{
+    readonly edges: readonly {
+      readonly entity: string;
+      readonly id: string;
+      readonly key: string;
+    }[];
+    readonly start: {
+      readonly _tag: "Terminal";
+    } | {
+      readonly _tag: "Cursor";
+      readonly cursor: string;
+    } | {
+      readonly _tag: "Unknown";
+    };
+    readonly end: {
+      readonly _tag: "Terminal";
+    } | {
+      readonly _tag: "Cursor";
+      readonly cursor: string;
+    } | {
+      readonly _tag: "Unknown";
+    };
+  }, 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;
+  /**
+   * The edges a connection shows: its server-known region with pending and
+   * confirmed overlays placed around it, minus removed edges and edges whose
+   * target is a tombstone.
+   */
+  visibleItems: (model: RemoteModel, connection: ConnectionIdentity) => ReadonlyArray<Edge>;
+  /** A pure, serializable view of the whole cache. */
+  inspect: (model: RemoteModel) => RemoteInspection;
+  /** A pure, serializable view of one entity, or `undefined` if unknown. */
+  inspectEntity: (model: RemoteModel, key: string) => RemoteInspection["entities"][number] | undefined;
+  /**
+   * Runs a mutation through `RemoteClient`, decoding its typed Output and
+   * returning the result's normalized patches so the caller can reconcile them
+   * through `Remote.update`'s `MutationSucceeded` (or `Remote.mutateInto`).
+   */
+  mutate: <Name extends string, Input, Output>(mutation: MutationDescriptor<Name, Input, Output>, input: Input, requestId: string) => Effect.Effect<{
+    output: Output;
+    entities: readonly {
+      readonly entity: string;
+      readonly id: string;
+      readonly values: {
+        readonly [x: string]: unknown;
+      };
+    }[];
+    connections: ConnectionChange[];
+  }, RemoteMutationError, RemoteClient>;
+  /**
+   * Runs a mutation and reconciles its patches into a `RemoteModel` in one step,
+   * returning the new model alongside the typed Output. The model-level form of
+   * `MutationStarted` → `RemoteClient.mutate` → `MutationSucceeded`; in an
+   * application the three are `update` (with `optimistic`), a Command, and the
+   * Message the Command returns, so the optimistic operations show meanwhile.
+   */
+  mutateInto: <Name extends string, Input, Output, AppModel, Store extends RemoteModel>(bound: BoundRemote<AppModel, Store, string>, model: AppModel, mutation: MutationDescriptor<Name, Input, Output>, input: Input, requestId: string, options?: MutateOptions | undefined) => Effect.Effect<{
+    output: Output;
+    model: AppModel;
+  }, RemoteMutationError, RemoteClient>;
+  /**
+   * A Foldkit Subscription entry that plans a Surface's missing fields from the
+   * Model and fetches them through `RemoteClient`, emitting a `RemoteMessage`
+   * per outcome. Wrap it in an application Message (`toMessage`) and reduce it
+   * with the domain's `update`. Under a refreshing `policy` the entry first
+   * emits `RefreshStarted`, so the fields being refetched read as `Refreshing`
+   * while the request is pending.
+   */
+  observe: <AppModel, Store extends RemoteModel, Names extends string, Model, SurfaceMessage, Params, Message = RemoteMessage>(bound: BoundRemote<AppModel, Store, Names>, surface: Surface<AppModel, Model, SurfaceMessage, Params>, params: Params, toMessage?: (message: RemoteMessage) => Message, options?: ObserveOptions) => EntryWithoutKeepAlive<AppModel, Message, ReadDependencies, RemoteClient>;
+  /**
+   * A Foldkit Subscription entry that consumes the live stream for a Surface's
+   * requirements, emitting a `LiveReceived` per event and a `ReadFailed` when
+   * the stream breaks (including `ResumeUnavailable`). 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$1>;
+    readonly cursor: LiveCursor;
+  }, RemoteClient>;
+};
+//#endregion
+export { Entity$1 as Entity, type RelationRequirement, type Requirement };
+//# sourceMappingURL=index.d.mts.map