foldkit-remote 0.20.0 → 0.22.0

package/dist/index-BEvVAL76.d.mts

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