foldkit-remote 0.20.0 → 0.22.0

package/dist/model-B6zk1NMB.d.ts

@@ -0,0 +1,710 @@
+import { i as RemoteError } from "./remoteData-mK1suYi1.js";
+import { o as RemoteDiagnostic } from "./diagnostics-DHhVYflV.js";
+import { i as Edge, n as Connection, o as Segment } from "./connection-BRyaJy89.js";
+import { r as EntityStore } from "./store-ah2qjcJW.js";
+import { D as MutationState, a as OptimisticOperation, k as NormalizedPatch, o as OptimisticState, t as ConnectionChange } from "./optimistic-CECsfNGY.js";
+import { i as LivePolicy } from "./query-BuIU93xA.js";
+import { a as Requirement, n as RelationRequirement } from "./requirement-D57S2LpH.js";
+import { t as AnswerRead, w as ReadBatchResult } from "./wire-DthPcTM6.js";
+import { a as LiveEvent, s as LiveState } from "./live-BpTzlCnY.js";
+import { c as ReadEntry, i as OutboxState } from "./outbox-DNuc4kZp.js";
+import { r as RetentionRoots } from "./retain-BfNTvBRb.js";
+import { t as MergePolicy } from "./persistence-CCMnvg7-.js";
+import { Option, Schema } from "effect";
+/**
+ * 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;
+  /**
+   * The durable writes (`Data.mutate`'s `durable`) not yet settled, every
+   * tab's, in the order the outbox sends them, and what its store holds.
+   * Each is in `mutations` too, as any write is.
+   */
+  readonly outbox: OutboxState;
+  /**
+   * 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, and
+   * restores only a key the Model is not yet restored from.
+   */
+  readonly restoredFrom: Option.Option<string>;
+  /**
+   * Under `verifyPredictions`, 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>>;
+  /**
+   * What the client met and kept going past, oldest first: under
+   * `verifyPredictions` each part of a prediction the server's answer
+   * disagreed with, and each failed write the application's update does not
+   * hear. The newest
+   * 256 are kept; the wiring reports each as it is recorded.
+   */
+  readonly diagnostics: ReadonlyArray<RemoteDiagnostic>;
+  /**
+   * What retention keeps: the active Surfaces' roots, after those of the
+   * Surfaces most recently left (`departedLimit`). A list left is held stale,
+   * so going back reads it `Refreshing` while it refetches.
+   */
+  readonly recent: RetentionRoots;
+}
+/** 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>;
+}
+/** 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>;
+  /**
+   * The server's refusal of what it asks (`RemoteLiveRefused`). A refused
+   * stream is no gap and does not restart: asking again is refused again.
+   */
+  readonly refused: 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.
+ *
+ * `restoredFrom` is kept too: the emptied store is now what that key holds,
+ * so `Data.persistence` saves it over the old snapshot and never restores the
+ * key again. Restoring would bring back exactly what was forgotten.
+ */
+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;
+  /**
+   * Who the operation is predicted for: what a list's `Expr.viewer` reads
+   * while the client places the rows it changes. `Data.mutate` gives
+   * `Remote.make`'s viewer; absent, a list over the viewer is the server's.
+   */
+  readonly viewer?: {
+    readonly entity: string;
+    readonly id: string;
+  } | undefined;
+  /**
+   * Which mutation, with what input: what the ledger keeps until the
+   * request applies, so a failure can be listed and retried. `Data.mutate`
+   * always gives it.
+   */
+  readonly write?: {
+    readonly mutation: string;
+    readonly input: unknown;
+    readonly keys?: ReadonlyArray<string> | undefined;
+    /** When the reader acted: what the request sends, and a retry sends again. */
+    readonly now?: number | undefined;
+    /**
+     * Queued in the outbox rather than sent: the input encoded, and
+     * what the reader was shown, as the store keeps them. The request
+     * id is the operation id.
+     */
+    readonly durable?: {
+      readonly input: unknown;
+      readonly shown: ReadonlyArray<RelationRequirement>;
+    } | undefined;
+  } | undefined;
+} |
+/** What `Data.mutate`'s Command answers for a durable write, which the outbox sends: nothing. */
+{
+  readonly _tag: 'MutationQueued';
+  readonly requestId: string;
+} |
+/**
+ * What the outbox's store under `key` holds, read entry by entry: written
+ * there by this page or another tab. `session` is given by a restore, for
+ * a page that has none; `unsaved` says why the store could not be written,
+ * when it could not, and the entries are then this page's own.
+ */
+{
+  readonly _tag: 'OutboxRead';
+  readonly key: string;
+  readonly scope: string;
+  readonly session?: string | undefined;
+  readonly entries: ReadonlyArray<ReadEntry>;
+  readonly done: ReadonlyArray<string>;
+  readonly unsaved?: string | undefined;
+} |
+/** A durable write was sent and nothing answered; it is sent again after a wait. */
+{
+  readonly _tag: 'OutboxDelayed';
+  readonly requestId: string;
+  readonly attempt: number;
+  readonly error: RemoteError;
+} | {
+  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;
+  /**
+   * What the answer read of the rows it names, for the fields the request
+   * said it shows: written as a read is, in the same reduction.
+   */
+  readonly read?: Schema.Schema.Type<typeof AnswerRead> | 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>;
+} |
+/**
+ * What the Command reporting recorded diagnostics returns once it has. It
+ * changes nothing: the diagnostics stay in the Model.
+ */
+{
+  readonly _tag: 'CompletedReportDiagnostics';
+};
+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>>;
+    viewer: Schema.optional<Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+    }>>;
+    write: Schema.optional<Schema.Struct<{
+      readonly mutation: Schema.String;
+      readonly input: Schema.Unknown;
+      readonly keys: Schema.optional<Schema.$Array<Schema.String>>;
+      readonly now: Schema.optional<Schema.Number>;
+      readonly durable: Schema.optional<Schema.Struct<{
+        readonly input: Schema.Unknown;
+        readonly shown: Schema.$Array<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+      }>>;
+    }>>;
+  };
+  MutationQueued: {
+    requestId: Schema.String;
+  };
+  OutboxRead: {
+    key: Schema.String;
+    scope: Schema.String;
+    session: Schema.optional<Schema.String>;
+    entries: Schema.$Array<Schema.Unknown>;
+    done: Schema.$Array<Schema.String>;
+    unsaved: Schema.optional<Schema.String>;
+  };
+  OutboxDelayed: {
+    requestId: Schema.String;
+    attempt: Schema.Number;
+    error: Schema.Struct<{
+      readonly _tag: Schema.String;
+      readonly message: Schema.String;
+      readonly refusal: Schema.optional<Schema.Unknown>;
+      readonly reason: Schema.optional<Schema.String>;
+    }>;
+  };
+  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;
+    }>>>;
+    read: Schema.optional<Schema.Struct<{
+      readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+      readonly 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;
+  };
+  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>>>;
+  };
+  CompletedReportDiagnostics: {};
+};
+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;
+/**
+ * One mark per requested field, `entity\0id\0field`. A read is identified by
+ * what it asks for, not by a request id: two reads asking for one field share
+ * its mark, so the first answer clears it. Over-clearing shows `Initial` rather
+ * than a spinner, which is the safer way to be wrong. The refresh generations
+ * below key off the same marks, so "what a read asks for" means one thing.
+ */
+declare const fieldMark: (entity: string, id: string, field: string) => string;
+/** 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;
+/**
+ * The Remote Model with a failed or unreadable durable write settled by the
+ * reader (`Data.dismiss`): out of the queue and the ledger, and done, so every
+ * tab drops it. A waiting one, or one not queued, is the Model itself.
+ */
+declare const dismissQueued: (model: RemoteModel, requestId: string) => 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;
+export { updateRemote as A, overlaysOf as C, remoteMessageSchema as D, remoteMessageCases as E, withRefreshRequested as M, writeRead as N, remoteModelSchema as O, onlyOverlaid as S, refreshedAt as T, isLoading as _, RemoteMessageInput as a, isRemoteMessage as b, StreamHealth as c, failureOf as d, fieldMark as f, isFieldFailed as g, invalidateConnections as h, RemoteMessage as i, windowGrowthKey as j, retentionRootsSchema as k, dismissQueued as l, initialRemoteModel as m, PlacedOrder as n, RemoteMessageTag as o, forgetRemote as p, RefreshState as r, RemoteModel as s, Failures as t, emptyRefresh as u, isLoadingThrough as v, refreshIsInFlight as w, noFailures as x, isQueryLoading as y };
+//# sourceMappingURL=model-B6zk1NMB.d.ts.map