foldkit-remote 0.18.1 → 0.19.0

package/README.md

@@ -1424,6 +1424,15 @@ effect on rows it did not return.
 `Unknown` for an id never started here (or settled so long ago it left the
 bounded ledger). A retry reuses its id, and the latest outcome wins.
 
+A request id names a request to this client only: it is a counter in the
+Model, so it restarts on reload and two clients' first requests share it. To a
+server, a mutation is named by its **operation**, an id minted where it is first
+sent (`crypto.randomUUID()`), unique across clients. A failed request keeps its
+operation, and a retry with the same `requestId` (`Data.mutate(model, M, input,
+{ requestId })`) sends it again, so a server that keeps a record of its writes
+can recognise the retry. After a reload the record of it is gone, and the same
+request id is a new operation.
+
 A mutation can say what the server may refuse it with, as data rather than a
 message to parse:
 
@@ -1441,7 +1450,14 @@ A mutation can also be a declared write: `Mutation.write(name, write)` over a
 `foldkit-entity` `Write.update`, `Write.insert` or `Write.delete`. Its input is
 the write's, it answers nothing of its own, and `Data.mutate` shows an update's
 or an insert's row until the server answers, so it needs no `optimistic` list;
-a delete shows nothing until its answer removes the row everywhere. `keys` names the input keys
+a delete shows nothing until its answer removes the row everywhere. An update's
+`increment` is shown as a prediction: its amount is added to the value the store
+holds whenever the row is read, so a change that reaches the store meanwhile is
+added to rather than hidden, and two pending increments add up. A field the
+client has not read is not guessed; it shows the server's sum when the answer
+comes. The prediction is never authority: the server decides, and its answer
+replaces it. The [declared writes guide](../../docs/declared-writes.md) follows
+one write from here to the statement that lands it. `keys` names the input keys
 an author changed: only those are shown, and the request carries them for the
 server to write; the input is still sent and validated whole.
 
@@ -1454,7 +1470,18 @@ Data.mutate(model, EditProject, { id: 'p1', name: 'Apollo II', status: 'active'
 ```
 
 `Refusal.field(key, reason)` names an input key and why; `Refusal.conflict`
-says the row moved on. The server sends the refusal encoded by this schema and
+says the row moved on, and `Refusal.unmet` that it does not hold what a declared
+write's `when` asks of it. A `Mutation.write` is refused as unmet only when its
+write has a `when`, and its `Refusal` type says so: without one it stays
+`Conflict`, so a match over it needs no `Unmet` arm. `Refusal.invalid` says the
+row it would leave breaks an invariant of its Entity (`Entity.invariant`): its
+`rule` and `path`, which a form shows the `message` beside, or none and empty
+when the invariant reads something the caller may not see. Every
+`Mutation.write` may be refused so, since the server's Entity may hold
+invariants the client's does not show. `Refusal.isInvalidBy(refusal, invariant)`
+asks whether it names one invariant, given as `Entity.invariant` returned it
+(export it beside the Entity), so its id is never spelled again; an unnamed
+refusal matches none. The server sends the refusal encoded by this schema and
 `Data.refusal` decodes it by the same one; it is none while the mutation is
 pending or applied, or when it failed for another reason.
 
@@ -2074,9 +2101,11 @@ above.
 `Remote.mutateInto(bound, model, mutation, input, requestId, { optimistic, now })` is
 the one-step imperative start/run/settle form for SSR and tests.
 
-`Remote.mutate(mutation, input, requestId)` is the transport call itself. It
-decodes the typed `Output` and returns normalized entity patches and confirmed
-connection changes for a caller to reduce through `updateRemote`.
+`Remote.mutate(mutation, input, requestId, { keys, operation })` is the
+transport call itself. It decodes the typed `Output` and returns normalized
+entity patches and confirmed connection changes for a caller to reduce through
+`updateRemote`. It mints an operation id when none is given; a caller retrying
+a request passes the one it first sent.
 
 `MutationSucceeded` reconciles at most once per `requestId`; an unknown or
 already-applied settlement is a no-op. It carries `now`, the clock reading of

package/dist/{index-86gaaCWm.d.mts → index-Bx_lCC85.d.mts}

@@ -1,7 +1,7 @@
 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, Dependencies, InputExpr, Query, Write } from "foldkit-entity";
+import { AnyEntity, AnyQuery, AnyWrite, BoundWrite, ConditionedWrite, Dependencies, InputExpr, Invariant, 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";
@@ -279,12 +279,25 @@ interface NormalizedPatch {
   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
@@ -294,7 +307,7 @@ interface MutationState {
 }
 declare const emptyMutationState: MutationState;
 declare const beginMutation: (state: MutationState, requestId: string) => MutationState;
-declare const failMutation: (state: MutationState, requestId: string, error: RemoteError) => 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. */
@@ -347,6 +360,18 @@ interface MutationDescriptor<Name extends string, Input, Output, Refused = unkno
    */
   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. */
@@ -356,6 +381,14 @@ declare const Refusal: {
   }>;
   /** 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";
@@ -366,7 +399,30 @@ declare const Refusal: {
   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. */
@@ -381,10 +437,10 @@ 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). A delete shows nothing, since no operation removes a row from every
+ * 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<NormalizedPatch>;
+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
@@ -396,10 +452,11 @@ declare const Mutation: {
    * 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.
+   * `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>(name: Name, write: Write<any, Fields>) => MutationDescriptor<Name, Schema.Struct.Type<Fields>, {}, typeof Refusal.conflict.Type> & {
-    readonly write: Write<any, Fields>;
+  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;
@@ -411,7 +468,7 @@ declare const Mutation: {
 //#region src/optimistic.d.ts
 interface EntityLayer {
   readonly id: string;
-  readonly patches: ReadonlyArray<NormalizedPatch>;
+  readonly patches: ReadonlyArray<PendingPatch>;
 }
 /**
  * Edges placed outside a connection's server-known region (`prepend`,
@@ -436,7 +493,7 @@ type ConnectionChange = {
   readonly edge: Edge;
 };
 /** What a request changes before the server answers: entity patches and connection changes. */
-type OptimisticOperation = NormalizedPatch | ConnectionChange;
+type OptimisticOperation = PendingPatch | ConnectionChange;
 /** A connection, by identity string or by anything that carries one (a `QueryRef`). */
 type ConnectionIdentity = string | {
   readonly identity: string;
@@ -487,6 +544,13 @@ declare const removeOverlay: (optimistic: OptimisticState, id: string) => Optimi
  * 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
@@ -801,9 +865,21 @@ declare const ReadBatchResult: Schema.Struct<{
     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<{
-  /** Stable across transport retries so a mutation is not applied twice. */
+  /**
+   * 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. */
@@ -927,8 +1003,14 @@ declare const Read: Rpc.Rpc<"FoldkitRemoteRead", Schema.Struct<{
   }>>;
 }>, Schema.Union<readonly [typeof RemoteReadError, typeof RemoteProtocolError, typeof RemoteUnauthenticated]>, never, never>;
 declare const Mutate: Rpc.Rpc<"FoldkitRemoteMutate", Schema.Struct<{
-  /** Stable across transport retries so a mutation is not applied twice. */
+  /**
+   * 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. */
@@ -1171,8 +1253,14 @@ declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteLive", Schema.S
   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<{
-  /** Stable across transport retries so a mutation is not applied twice. */
+  /**
+   * 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. */
@@ -1424,11 +1512,24 @@ declare const remoteError: (error: {
   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, keys?: readonly string[] | undefined) => Effect.Effect<{
+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;
@@ -2127,6 +2228,8 @@ type RemoteMessage = {
   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
@@ -2296,6 +2399,7 @@ declare const remoteMessageCases: {
       readonly refusal: Schema.optional<Schema.Unknown>;
       readonly reason: Schema.optional<Schema.String>;
     }>;
+    operation: Schema.String;
   };
   OverlayShown: {
     id: Schema.String;
@@ -3516,6 +3620,7 @@ declare const Remote: {
         readonly refusal: Schema.optional<Schema.Unknown>;
         readonly reason: Schema.optional<Schema.String>;
       }>;
+      operation: Schema.String;
     };
     OverlayShown: {
       id: Schema.String;
@@ -3659,6 +3764,7 @@ declare const Remote: {
         readonly refusal: Schema.optional<Schema.Unknown>;
         readonly reason: Schema.optional<Schema.String>;
       }>;
+      operation: Schema.String;
     };
     OverlayShown: {
       id: Schema.String;
@@ -3973,7 +4079,10 @@ declare const Remote: {
    * 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, keys?: readonly string[] | undefined) => Effect.Effect<{
+  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;
@@ -4020,5 +4129,5 @@ declare const Remote: {
   live: <AppModel, Store extends RemoteModel, Names extends string, Model, SurfaceMessage, Params, Message = RemoteMessage>(bound: BoundRemote<AppModel, Store, Names>, surface: Surface<AppModel, Model, SurfaceMessage, Params>, params: Params, toMessage?: (message: RemoteMessage) => Message, options?: LiveOptions) => EntryWithoutKeepAlive<AppModel, Message, LiveDependencies, RemoteClient>;
 };
 //#endregion
-export { QueryExplanation as $, merge as $i, coalesceReads as $n, ConnectionIdentity as $r, Entity$2 as $t, RemoteWiring as A, optimisticOfWrite as Ai, RemoteRpcClient as An, RemoteUnauthenticated as Ar, remoteModelSchema as At, liveFetch as B, Boundary as Bi, LiveEvent as Bn, requirementsOf as Br, SnapshotOptions as Bt, Registered as C, writeEntity as Ca, Refusal as Ci, isRefPage as Cn, RemoteForbidden as Cr, noFailures as Ct, RemoteEntry as D, emptyMutationState as Di, relationShape as Dn, RemoteQueryError as Dr, refreshedAt as Dt, RemoteDomain as E, beginMutation as Ei, relationAlias as En, RemoteProtocolError as Er, refreshIsInFlight as Et, SubscriptionsOptions as F, Freshness as Fi, remoteError as Fn, RelationRequirement as Fr, writeRead as Ft, RemotePolicy as G, Segment as Gi, classifyLive as Gn, Query$1 as Gr, reachable as Gt, RemoteJsonRequest as H, Cursor as Hi, LiveState as Hn, IDENTITY_SEPARATOR as Hr, Retained as Ht, RowPlace as I, RemoteData as Ii, BoundaryCounts as In, RemoteConnections as Ir, MergePolicy as It, PlanOptions as J, emptyConnection as Ji, liveHasPrevious as Jn, QueryRef as Jr, Matched as Jt, Deadline as K, cursor as Ki, emptyLiveState as Kn, QueryDescriptor as Kr, Belongs as Kt, placeIn as L, RemoteError as Li, ConnectionApplied as Ln, RemoteRequirements as Lr, REMOTE_CACHE_VERSION as Lt, SatisfyOptions as M, reconcileMutation as Mi, connectionChangeOf as Mn, WindowSchema as Mr, updateRemote as Mt, SelectsEntity as N, schemaOf as Ni, liveEventOf as Nn, WireBoundary as Nr, windowGrowthKey as Nt, RemoteFold as O, failMutation as Oi, targetsOf as On, RemoteReadError as Or, remoteMessageCases as Ot, SubscriptionEntries as P, Denied as Pi, mutateRemote as Pn, ConnectionRequirement as Pr, withRefreshRequested as Pt, ExplainedDependencies as Q, items as Qi, coalesceQueries as Qn, ConnectionChange as Qr, AnySchema as Qt, LiveFetchOptions as R, remoteDataSchema as Ri, EntityApplied as Rn, Requirement as Rr, RemotePersistence as Rt, ReadMeta as S, writeEntities as Sa, Reconciled as Si, aliasedField as Sn, RelationRequest as Sr, isRemoteMessage as St, RemoteDescriptor as T, TypeOf as Ti, refsIn as Tn, RemoteMutationError as Tr, overlaysOf as Tt, RemoteJsonSend as U, Edge as Ui, applyConnectionEvent as Un, LiveInsertion as Ur, RetentionRoots as Ut, RemoteJsonAnswer as V, Connection as Vi, LiveOutcome as Vn, ConnectionSpec as Vr, ConnectionRoot as Vt, RemoteResumePart as W, EdgeRef as Wi, applyEntityEvent as Wn, LivePolicy as Wr, gc as Wt, plan as X, hasPrevious as Xi, CoalesceOptions as Xn, ResultOf as Xr, belongsEncoded as Xt, deadlineOf as Y, hasNext as Yi, BatchRead as Yn, QueryWindow as Yr, MatchingOptions as Yt, windowKey as Z, isGapped as Zi, QueryRun as Zn, stableStringify as Zr, matching as Zt, QueryOptions as _, readField as _a, MutationAnswer as _i, RefParts as _n, REMOTE_PROTOCOL_VERSION as _r, invalidateConnections as _t, EntitySelection as a, EntityStore as aa, addOverlay as ai, RefPage as an, LiveRequirement as ar, PlacedOrder as at, QueryWindowOptions as b, setUnavailable as ba, MutationStatus as bi, RelationKind as bn, ReadBatchResult as br, isLoadingThrough as bt, LiveOptions as c, emptyStore as ca, emptyOptimistic as ci, SelectionOf as cn, Mutate as cr, RemoteMessage as ct, MutateOptions as d, hasField as da, removeOverlay as di, assemble as dn, NormalizedEntity as dr, RemoteModel as dt, segment as ea, ConnectionOverlay as ei, EntityDescriptor as en, requirementKey as er, ReadDiagnosis as et, MutationStarted as f, isFieldStale as fa, settleFailure as fi, pageSchema as fn, PageSize as fr, StreamHealth as ft, QueryInput as g, missingFields as ga, Mutation as gi, RefPageValue as gn, QueryRpc as gr, initialRemoteModel as gt, QueryEntity as h, markStale as ha, visibleStore as hi, RELATION_ALIAS as hn, QueryResult as hr, forgetRemote as ht, EntityLike as i, EntityKey as ia, addLayer as ii, RefKey as in, LiveEdge as ir, Failures as it, RetainOptions as j, patchOfWrite as ji, coalescedLayer as jn, SettledFields as jr, retentionRootsSchema as jt, RemoteUnsatisfied as k, mutationStatus as ki, RemoteClient as kn, RemoteRpc as kr, remoteMessageSchema as kt, LiveStatus as l, entityKey as la, pruneOverlays as li, SelectionValue as ln, MutationRequest as lr, RemoteMessageInput as lt, PersistenceOptions as m, isTombstone as ma, visibleItems as mi, unavailableOf as mn, QueryRequest as mr, failureOf as mt, BoundRemote as n, unknown as na, OptimisticOperation as ni, EntityRef as nn, Live as nr, inspectEntity as nt, FoldedMutationStarted as o, EntityWrite as oa, beginOptimistic as oi, Page as on, MAX_FIELDS_PER_REQUEST as or, PlacementMismatch as ot, ObserveOptions as p, isFieldUnavailable as pa, settleSuccess as pi, relationOf as pn, QueryEdge as pr, emptyRefresh as pt, PlanFreshness as q, edge as qi, liveHasNext as qn, QueryInputs as qr, Judged as qt, DomainMutateOptions as r, EntityEntry as ra, OptimisticState as ri, FieldsFrom as rn, LiveChange as rr, inspectRemote as rt, LiveDependencies as s, clearStale as sa, connectionIdentity as si, Selection as sn, MAX_RELATION_DEPTH as sr, RefreshState as st, ActiveEntry as t, terminal as ta, EntityLayer as ti, EntityPatch as tn, ConnectionChangeSchema as tr, RemoteInspection as tt, ModelOfDomain as u, entry as ua, removeLayer as ui, SelectionValueOf as un, MutationResult as ur, RemoteMessageTag as ut, QueryProjection as v, remove as va, MutationDescriptor as vi, RelationAnnotation as vn, Read as vr, isFieldFailed as vt, Remote as w, SchemaOrFields as wi, refParts as wn, RemoteLiveError as wr, onlyOverlaid as wt, ReadDependencies as x, tombstone as xa, NormalizedPatch as xi, RelationShape as xn, ReadRequest as xr, isQueryLoading as xt, QueryRequirement as y, setStale as ya, MutationState as yi, RelationEntityAnnotation as yn, ReadBatch as yr, isLoading as yt, httpWithLive as z, remoteErrorSchema as zi, LiveCursor as zn, connectionsOf as zr, Snapshot as zt };
-//# sourceMappingURL=index-86gaaCWm.d.mts.map
+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-Bx_lCC85.d.mts.map

package/dist/index-Bx_lCC85.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Bx_lCC85.d.mts","names":["RelationalQuery","Query","Entity","_$__store_js0.EntityEntry","jsonClient","httpClient","httpWithLiveClient","_$__optimistic_js0.ConnectionChange","_$__wire_js0.RemoteForbidden"],"sources":["../src/store.ts","../src/connection.ts","../src/remoteData.ts","../src/mutation.ts","../src/optimistic.ts","../src/query.ts","../src/requirement.ts","../src/wire.ts","../src/coalesce.ts","../src/live.ts","../src/client.ts","../src/relation.ts","../src/selection.ts","../src/entity.ts","../src/matching.ts","../src/retain.ts","../src/persistence.ts","../src/model.ts","../src/inspect.ts","../src/plan.ts","../src/policy.ts","../src/resume.ts","../src/json.ts","../src/sse.ts","../src/placement.ts","../src/index.ts"],"mappings":"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"}

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as QueryExplanation, $i as merge, $n as coalesceReads, $r as ConnectionIdentity, $t as Entity, A as RemoteWiring, Ai as optimisticOfWrite, An as RemoteRpcClient, Ar as RemoteUnauthenticated, At as remoteModelSchema, B as liveFetch, Bi as Boundary, Bn as LiveEvent, Br as requirementsOf, Bt as SnapshotOptions, C as Registered, Ca as writeEntity, Ci as Refusal, Cn as isRefPage, Cr as RemoteForbidden, Ct as noFailures, D as RemoteEntry, Di as emptyMutationState, Dn as relationShape, Dr as RemoteQueryError, Dt as refreshedAt, E as RemoteDomain, Ei as beginMutation, En as relationAlias, Er as RemoteProtocolError, Et as refreshIsInFlight, F as SubscriptionsOptions, Fi as Freshness, Fn as remoteError, Fr as RelationRequirement, Ft as writeRead, G as RemotePolicy, Gi as Segment, Gn as classifyLive, Gr as Query, Gt as reachable, H as RemoteJsonRequest, Hi as Cursor, Hn as LiveState, Hr as IDENTITY_SEPARATOR, Ht as Retained, I as RowPlace, Ii as RemoteData, In as BoundaryCounts, Ir as RemoteConnections, It as MergePolicy, J as PlanOptions, Ji as emptyConnection, Jn as liveHasPrevious, Jr as QueryRef, Jt as Matched, K as Deadline, Ki as cursor, Kn as emptyLiveState, Kr as QueryDescriptor, Kt as Belongs, L as placeIn, Li as RemoteError, Ln as ConnectionApplied, Lr as RemoteRequirements, Lt as REMOTE_CACHE_VERSION, M as SatisfyOptions, Mi as reconcileMutation, Mn as connectionChangeOf, Mr as WindowSchema, Mt as updateRemote, N as SelectsEntity, Ni as schemaOf, Nn as liveEventOf, Nr as WireBoundary, Nt as windowGrowthKey, O as RemoteFold, Oi as failMutation, On as targetsOf, Or as RemoteReadError, Ot as remoteMessageCases, P as SubscriptionEntries, Pi as Denied, Pn as mutateRemote, Pr as ConnectionRequirement, Pt as withRefreshRequested, Q as ExplainedDependencies, Qi as items, Qn as coalesceQueries, Qr as ConnectionChange, Qt as AnySchema, R as LiveFetchOptions, Ri as remoteDataSchema, Rn as EntityApplied, Rr as Requirement, Rt as RemotePersistence, S as ReadMeta, Sa as writeEntities, Si as Reconciled, Sn as aliasedField, Sr as RelationRequest, St as isRemoteMessage, T as RemoteDescriptor, Ti as TypeOf, Tn as refsIn, Tr as RemoteMutationError, Tt as overlaysOf, U as RemoteJsonSend, Ui as Edge, Un as applyConnectionEvent, Ur as LiveInsertion, Ut as RetentionRoots, V as RemoteJsonAnswer, Vi as Connection, Vn as LiveOutcome, Vr as ConnectionSpec, Vt as ConnectionRoot, W as RemoteResumePart, Wi as EdgeRef, Wn as applyEntityEvent, Wr as LivePolicy, Wt as gc, X as plan, Xi as hasPrevious, Xn as CoalesceOptions, Xr as ResultOf, Xt as belongsEncoded, Y as deadlineOf, Yi as hasNext, Yn as BatchRead, Yr as QueryWindow, Yt as MatchingOptions, Z as windowKey, Zi as isGapped, Zn as QueryRun, Zr as stableStringify, Zt as matching, _ as QueryOptions, _a as readField, _i as MutationAnswer, _n as RefParts, _r as REMOTE_PROTOCOL_VERSION, _t as invalidateConnections, a as EntitySelection, aa as EntityStore, ai as addOverlay, an as RefPage, ar as LiveRequirement, at as PlacedOrder, b as QueryWindowOptions, ba as setUnavailable, bi as MutationStatus, bn as RelationKind, br as ReadBatchResult, bt as isLoadingThrough, c as LiveOptions, ca as emptyStore, ci as emptyOptimistic, cn as SelectionOf, cr as Mutate, ct as RemoteMessage, d as MutateOptions, da as hasField, di as removeOverlay, dn as assemble, dr as NormalizedEntity, dt as RemoteModel, ea as segment, ei as ConnectionOverlay, en as EntityDescriptor, er as requirementKey, et as ReadDiagnosis, f as MutationStarted, fa as isFieldStale, fi as settleFailure, fn as pageSchema, fr as PageSize, ft as StreamHealth, g as QueryInput, ga as missingFields, gi as Mutation, gn as RefPageValue, gr as QueryRpc, gt as initialRemoteModel, h as QueryEntity, ha as markStale, hi as visibleStore, hn as RELATION_ALIAS, hr as QueryResult, ht as forgetRemote, i as EntityLike, ia as EntityKey, ii as addLayer, in as RefKey, ir as LiveEdge, it as Failures, j as RetainOptions, ji as patchOfWrite, jn as coalescedLayer, jr as SettledFields, jt as retentionRootsSchema, k as RemoteUnsatisfied, ki as mutationStatus, kn as RemoteClient, kr as RemoteRpc, kt as remoteMessageSchema, l as LiveStatus, la as entityKey, li as pruneOverlays, ln as SelectionValue, lr as MutationRequest, lt as RemoteMessageInput, m as PersistenceOptions, ma as isTombstone, mi as visibleItems, mn as unavailableOf, mr as QueryRequest, mt as failureOf, n as BoundRemote, na as unknown, ni as OptimisticOperation, nn as EntityRef, nr as Live, nt as inspectEntity, o as FoldedMutationStarted, oa as EntityWrite, oi as beginOptimistic, on as Page, or as MAX_FIELDS_PER_REQUEST, ot as PlacementMismatch, p as ObserveOptions, pa as isFieldUnavailable, pi as settleSuccess, pn as relationOf, pr as QueryEdge, pt as emptyRefresh, q as PlanFreshness, qi as edge, qn as liveHasNext, qr as QueryInputs, qt as Judged, r as DomainMutateOptions, ra as EntityEntry, ri as OptimisticState, rn as FieldsFrom, rr as LiveChange, rt as inspectRemote, s as LiveDependencies, sa as clearStale, si as connectionIdentity, sn as Selection, sr as MAX_RELATION_DEPTH, st as RefreshState, t as ActiveEntry, ta as terminal, ti as EntityLayer, tn as EntityPatch, tr as ConnectionChangeSchema, tt as RemoteInspection, u as ModelOfDomain, ua as entry, ui as removeLayer, un as SelectionValueOf, ur as MutationResult, ut as RemoteMessageTag, v as QueryProjection, va as remove, vi as MutationDescriptor, vn as RelationAnnotation, vr as Read, vt as isFieldFailed, w as Remote, wi as SchemaOrFields, wn as refParts, wr as RemoteLiveError, wt as onlyOverlaid, x as ReadDependencies, xa as tombstone, xi as NormalizedPatch, xn as RelationShape, xr as ReadRequest, xt as isQueryLoading, y as QueryRequirement, ya as setStale, yi as MutationState, yn as RelationEntityAnnotation, yr as ReadBatch, yt as isLoading, z as httpWithLive, zi as remoteErrorSchema, zn as LiveCursor, zr as connectionsOf, zt as Snapshot } from "./index-86gaaCWm.mjs";
-export { ActiveEntry, AnySchema, BatchRead, Belongs, BoundRemote, Boundary, BoundaryCounts, CoalesceOptions, Connection, ConnectionApplied, ConnectionChange, ConnectionChangeSchema, ConnectionIdentity, ConnectionOverlay, ConnectionRequirement, ConnectionRoot, ConnectionSpec, Cursor, Deadline, Denied, DomainMutateOptions, Edge, EdgeRef, Entity, EntityApplied, EntityDescriptor, EntityEntry, EntityKey, EntityLayer, EntityLike, EntityPatch, EntityRef, EntitySelection, EntityStore, EntityWrite, ExplainedDependencies, Failures, FieldsFrom, FoldedMutationStarted, Freshness, IDENTITY_SEPARATOR, Judged, Live, LiveChange, LiveCursor, LiveDependencies, LiveEdge, LiveEvent, type LiveFetchOptions, LiveInsertion, LiveOptions, LiveOutcome, LivePolicy, LiveRequirement, LiveState, LiveStatus, MAX_FIELDS_PER_REQUEST, MAX_RELATION_DEPTH, Matched, MatchingOptions, MergePolicy, ModelOfDomain, Mutate, MutateOptions, Mutation, MutationAnswer, MutationDescriptor, MutationRequest, MutationResult, MutationStarted, MutationState, MutationStatus, NormalizedEntity, NormalizedPatch, ObserveOptions, OptimisticOperation, OptimisticState, Page, PageSize, PersistenceOptions, PlacedOrder, PlacementMismatch, PlanFreshness, PlanOptions, Query, QueryDescriptor, QueryEdge, QueryEntity, QueryExplanation, QueryInput, QueryInputs, QueryOptions, QueryProjection, QueryRef, QueryRequest, QueryRequirement, QueryResult, QueryRpc, QueryRun, QueryWindow, QueryWindowOptions, RELATION_ALIAS, REMOTE_CACHE_VERSION, REMOTE_PROTOCOL_VERSION, Read, ReadBatch, ReadBatchResult, ReadDependencies, ReadDiagnosis, ReadMeta, ReadRequest, Reconciled, RefKey, RefPage, RefPageValue, RefParts, RefreshState, Refusal, Registered, RelationAnnotation, RelationEntityAnnotation, RelationKind, RelationRequest, RelationRequirement, RelationShape, Remote, RemoteClient, RemoteConnections, RemoteData, RemoteDescriptor, RemoteDomain, RemoteEntry, RemoteError, RemoteFold, RemoteForbidden, RemoteInspection, RemoteJsonAnswer, RemoteJsonRequest, type RemoteJsonSend, RemoteLiveError, RemoteMessage, RemoteMessageInput, RemoteMessageTag, RemoteModel, RemoteMutationError, RemotePersistence, RemotePolicy, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteRequirements, type RemoteResumePart, RemoteRpc, RemoteRpcClient, RemoteUnauthenticated, RemoteUnsatisfied, RemoteWiring, Requirement, ResultOf, RetainOptions, Retained, RetentionRoots, RowPlace, SatisfyOptions, SchemaOrFields, Segment, Selection, SelectionOf, SelectionValue, SelectionValueOf, SelectsEntity, SettledFields, Snapshot, SnapshotOptions, StreamHealth, SubscriptionEntries, SubscriptionsOptions, TypeOf, WindowSchema, WireBoundary, addLayer, addOverlay, aliasedField, applyConnectionEvent, applyEntityEvent, assemble, beginMutation, beginOptimistic, belongsEncoded, classifyLive, clearStale, coalesceQueries, coalesceReads, coalescedLayer, connectionChangeOf, connectionIdentity, connectionsOf, cursor, deadlineOf, edge, emptyConnection, emptyLiveState, emptyMutationState, emptyOptimistic, emptyRefresh, emptyStore, entityKey, entry, failMutation, failureOf, forgetRemote, gc, hasField, hasNext, hasPrevious, httpWithLive, initialRemoteModel, inspectEntity, inspectRemote, invalidateConnections, isFieldFailed, isFieldStale, isFieldUnavailable, isGapped, isLoading, isLoadingThrough, isQueryLoading, isRefPage, isRemoteMessage, isTombstone, items, liveEventOf, liveFetch, liveHasNext, liveHasPrevious, markStale, matching, merge, missingFields, mutateRemote, mutationStatus, noFailures, onlyOverlaid, optimisticOfWrite, overlaysOf, pageSchema, patchOfWrite, placeIn, plan, pruneOverlays, reachable, readField, reconcileMutation, refParts, refreshIsInFlight, refreshedAt, refsIn, relationAlias, relationOf, relationShape, remoteDataSchema, remoteError, remoteErrorSchema, remoteMessageCases, remoteMessageSchema, remoteModelSchema, remove, removeLayer, removeOverlay, requirementKey, requirementsOf, retentionRootsSchema, schemaOf, segment, setStale, setUnavailable, settleFailure, settleSuccess, stableStringify, targetsOf, terminal, tombstone, unavailableOf, unknown, updateRemote, visibleItems, visibleStore, windowGrowthKey, windowKey, withRefreshRequested, writeEntities, writeEntity, writeRead };
+import { $ as QueryExplanation, $i as emptyConnection, $n as coalesceQueries, $r as stableStringify, $t as Entity, A as RemoteWiring, Ai as TypeOf, An as RemoteRpcClient, Ar as RemoteReadError, At as remoteModelSchema, B as liveFetch, Bi as Freshness, Bn as LiveCursor, Br as Requirement, Bt as SnapshotOptions, C as Registered, Ca as remove, Ci as MutationStatus, Cn as isRefPage, Cr as ReadRequest, Ct as noFailures, D as RemoteEntry, Da as writeEntities, Di as Refusal, Dn as relationShape, Dr as RemoteMutationError, Dt as refreshedAt, E as RemoteDomain, Ea as tombstone, Ei as Reconciled, En as relationAlias, Er as RemoteLiveError, Et as refreshIsInFlight, F as SubscriptionsOptions, Fi as optimisticOfWrite, Fn as mutateRemote, Fr as WireBoundary, Ft as writeRead, G as RemotePolicy, Gi as Boundary, Gn as applyEntityEvent, Gr as LiveInsertion, Gt as reachable, H as RemoteJsonRequest, Hi as RemoteError, Hn as LiveOutcome, Hr as requirementsOf, Ht as Retained, I as RowPlace, Ii as patchOfWrite, In as remoteError, Ir as ConnectionRequirement, It as MergePolicy, J as PlanOptions, Ji as Edge, Jn as liveHasNext, Jr as QueryDescriptor, Jt as Matched, K as Deadline, Ki as Connection, Kn as classifyLive, Kr as LivePolicy, Kt as Belongs, L as placeIn, Li as reconcileMutation, Ln as BoundaryCounts, Lr as RelationRequirement, Lt as REMOTE_CACHE_VERSION, M as SatisfyOptions, Mi as emptyMutationState, Mn as connectionChangeOf, Mr as RemoteUnauthenticated, Mt as updateRemote, N as SelectsEntity, Ni as failMutation, Nn as liveEventOf, Nr as SettledFields, Nt as windowGrowthKey, O as RemoteFold, Oa as writeEntity, Oi as RefusalOfWrite, On as targetsOf, Or as RemoteProtocolError, Ot as remoteMessageCases, P as SubscriptionEntries, Pi as mutationStatus, Pn as mintOperation, Pr as WindowSchema, Pt as withRefreshRequested, Q as ExplainedDependencies, Qi as edge, Qn as QueryRun, Qr as ResultOf, Qt as AnySchema, R as LiveFetchOptions, Ri as schemaOf, Rn as ConnectionApplied, Rr as RemoteConnections, Rt as RemotePersistence, S as ReadMeta, Sa as readField, Si as MutationState, Sn as aliasedField, Sr as ReadBatchResult, St as isRemoteMessage, T as RemoteDescriptor, Ta as setUnavailable, Ti as PendingPatch, Tn as refsIn, Tr as RemoteForbidden, Tt as overlaysOf, U as RemoteJsonSend, Ui as remoteDataSchema, Un as LiveState, Ur as ConnectionSpec, Ut as RetentionRoots, V as RemoteJsonAnswer, Vi as RemoteData, Vn as LiveEvent, Vr as connectionsOf, Vt as ConnectionRoot, W as RemoteResumePart, Wi as remoteErrorSchema, Wn as applyConnectionEvent, Wr as IDENTITY_SEPARATOR, Wt as gc, X as plan, Xi as Segment, Xn as BatchRead, Xr as QueryRef, Xt as belongsEncoded, Y as deadlineOf, Yi as EdgeRef, Yn as liveHasPrevious, Yr as QueryInputs, Yt as MatchingOptions, Z as windowKey, Zi as cursor, Zn as CoalesceOptions, Zr as QueryWindow, Zt as matching, _ as QueryOptions, _a as isFieldStale, _i as visibleItems, _n as RefParts, _r as QueryResult, _t as invalidateConnections, a as EntitySelection, aa as segment, ai as OptimisticState, an as RefPage, ar as LiveEdge, at as PlacedOrder, b as QueryWindowOptions, ba as markStale, bi as MutationAnswer, bn as RelationKind, br as Read, bt as isLoadingThrough, c as LiveOptions, ca as EntityEntry, ci as beginOptimistic, cn as SelectionOf, cr as MAX_RELATION_DEPTH, ct as RemoteMessage, d as MutateOptions, da as EntityWrite, di as pruneOverlays, dn as assemble, dr as MutationResult, dt as RemoteModel, ea as hasNext, ei as ConnectionChange, en as EntityDescriptor, er as coalesceReads, et as ReadDiagnosis, f as MutationStarted, fa as clearStale, fi as removeLayer, fn as pageSchema, fr as NormalizedEntity, ft as StreamHealth, g as QueryInput, ga as hasField, gi as settleSuccess, gn as RefPageValue, gr as QueryRequest, gt as initialRemoteModel, h as QueryEntity, ha as entry, hi as settleFailure, hn as RELATION_ALIAS, hr as QueryEdge, ht as forgetRemote, i as EntityLike, ia as merge, ii as OptimisticOperation, in as RefKey, ir as LiveChange, it as Failures, j as RetainOptions, ji as beginMutation, jn as coalescedLayer, jr as RemoteRpc, jt as retentionRootsSchema, k as RemoteUnsatisfied, ki as SchemaOrFields, kn as RemoteClient, kr as RemoteQueryError, kt as remoteMessageSchema, l as LiveStatus, la as EntityKey, li as connectionIdentity, ln as SelectionValue, lr as Mutate, lt as RemoteMessageInput, m as PersistenceOptions, ma as entityKey, mi as resolvedPatches, mn as unavailableOf, mr as PageSize, mt as failureOf, n as BoundRemote, na as isGapped, ni as ConnectionOverlay, nn as EntityRef, nr as ConnectionChangeSchema, nt as inspectEntity, o as FoldedMutationStarted, oa as terminal, oi as addLayer, on as Page, or as LiveRequirement, ot as PlacementMismatch, p as ObserveOptions, pa as emptyStore, pi as removeOverlay, pn as relationOf, pr as OperationId, pt as emptyRefresh, q as PlanFreshness, qi as Cursor, qn as emptyLiveState, qr as Query, qt as Judged, r as DomainMutateOptions, ra as items, ri as EntityLayer, rn as FieldsFrom, rr as Live, rt as inspectRemote, s as LiveDependencies, sa as unknown, si as addOverlay, sn as Selection, sr as MAX_FIELDS_PER_REQUEST, st as RefreshState, t as ActiveEntry, ta as hasPrevious, ti as ConnectionIdentity, tn as EntityPatch, tr as requirementKey, tt as RemoteInspection, u as ModelOfDomain, ua as EntityStore, ui as emptyOptimistic, un as SelectionValueOf, ur as MutationRequest, ut as RemoteMessageTag, v as QueryProjection, va as isFieldUnavailable, vi as visibleStore, vn as RelationAnnotation, vr as QueryRpc, vt as isFieldFailed, w as Remote, wa as setStale, wi as NormalizedPatch, wn as refParts, wr as RelationRequest, wt as onlyOverlaid, x as ReadDependencies, xa as missingFields, xi as MutationDescriptor, xn as RelationShape, xr as ReadBatch, xt as isQueryLoading, y as QueryRequirement, ya as isTombstone, yi as Mutation, yn as RelationEntityAnnotation, yr as REMOTE_PROTOCOL_VERSION, yt as isLoading, z as httpWithLive, zi as Denied, zn as EntityApplied, zr as RemoteRequirements, zt as Snapshot } from "./index-Bx_lCC85.mjs";
+export { ActiveEntry, AnySchema, BatchRead, Belongs, BoundRemote, Boundary, BoundaryCounts, CoalesceOptions, Connection, ConnectionApplied, ConnectionChange, ConnectionChangeSchema, ConnectionIdentity, ConnectionOverlay, ConnectionRequirement, ConnectionRoot, ConnectionSpec, Cursor, Deadline, Denied, DomainMutateOptions, Edge, EdgeRef, Entity, EntityApplied, EntityDescriptor, EntityEntry, EntityKey, EntityLayer, EntityLike, EntityPatch, EntityRef, EntitySelection, EntityStore, EntityWrite, ExplainedDependencies, Failures, FieldsFrom, FoldedMutationStarted, Freshness, IDENTITY_SEPARATOR, Judged, Live, LiveChange, LiveCursor, LiveDependencies, LiveEdge, LiveEvent, type LiveFetchOptions, LiveInsertion, LiveOptions, LiveOutcome, LivePolicy, LiveRequirement, LiveState, LiveStatus, MAX_FIELDS_PER_REQUEST, MAX_RELATION_DEPTH, Matched, MatchingOptions, MergePolicy, ModelOfDomain, Mutate, MutateOptions, Mutation, MutationAnswer, MutationDescriptor, MutationRequest, MutationResult, MutationStarted, MutationState, MutationStatus, NormalizedEntity, NormalizedPatch, ObserveOptions, OperationId, OptimisticOperation, OptimisticState, Page, PageSize, PendingPatch, PersistenceOptions, PlacedOrder, PlacementMismatch, PlanFreshness, PlanOptions, Query, QueryDescriptor, QueryEdge, QueryEntity, QueryExplanation, QueryInput, QueryInputs, QueryOptions, QueryProjection, QueryRef, QueryRequest, QueryRequirement, QueryResult, QueryRpc, QueryRun, QueryWindow, QueryWindowOptions, RELATION_ALIAS, REMOTE_CACHE_VERSION, REMOTE_PROTOCOL_VERSION, Read, ReadBatch, ReadBatchResult, ReadDependencies, ReadDiagnosis, ReadMeta, ReadRequest, Reconciled, RefKey, RefPage, RefPageValue, RefParts, RefreshState, Refusal, RefusalOfWrite, Registered, RelationAnnotation, RelationEntityAnnotation, RelationKind, RelationRequest, RelationRequirement, RelationShape, Remote, RemoteClient, RemoteConnections, RemoteData, RemoteDescriptor, RemoteDomain, RemoteEntry, RemoteError, RemoteFold, RemoteForbidden, RemoteInspection, RemoteJsonAnswer, RemoteJsonRequest, type RemoteJsonSend, RemoteLiveError, RemoteMessage, RemoteMessageInput, RemoteMessageTag, RemoteModel, RemoteMutationError, RemotePersistence, RemotePolicy, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteRequirements, type RemoteResumePart, RemoteRpc, RemoteRpcClient, RemoteUnauthenticated, RemoteUnsatisfied, RemoteWiring, Requirement, ResultOf, RetainOptions, Retained, RetentionRoots, RowPlace, SatisfyOptions, SchemaOrFields, Segment, Selection, SelectionOf, SelectionValue, SelectionValueOf, SelectsEntity, SettledFields, Snapshot, SnapshotOptions, StreamHealth, SubscriptionEntries, SubscriptionsOptions, TypeOf, WindowSchema, WireBoundary, addLayer, addOverlay, aliasedField, applyConnectionEvent, applyEntityEvent, assemble, beginMutation, beginOptimistic, belongsEncoded, classifyLive, clearStale, coalesceQueries, coalesceReads, coalescedLayer, connectionChangeOf, connectionIdentity, connectionsOf, cursor, deadlineOf, edge, emptyConnection, emptyLiveState, emptyMutationState, emptyOptimistic, emptyRefresh, emptyStore, entityKey, entry, failMutation, failureOf, forgetRemote, gc, hasField, hasNext, hasPrevious, httpWithLive, initialRemoteModel, inspectEntity, inspectRemote, invalidateConnections, isFieldFailed, isFieldStale, isFieldUnavailable, isGapped, isLoading, isLoadingThrough, isQueryLoading, isRefPage, isRemoteMessage, isTombstone, items, liveEventOf, liveFetch, liveHasNext, liveHasPrevious, markStale, matching, merge, mintOperation, missingFields, mutateRemote, mutationStatus, noFailures, onlyOverlaid, optimisticOfWrite, overlaysOf, pageSchema, patchOfWrite, placeIn, plan, pruneOverlays, reachable, readField, reconcileMutation, refParts, refreshIsInFlight, refreshedAt, refsIn, relationAlias, relationOf, relationShape, remoteDataSchema, remoteError, remoteErrorSchema, remoteMessageCases, remoteMessageSchema, remoteModelSchema, remove, removeLayer, removeOverlay, requirementKey, requirementsOf, resolvedPatches, retentionRootsSchema, schemaOf, segment, setStale, setUnavailable, settleFailure, settleSuccess, stableStringify, targetsOf, terminal, tombstone, unavailableOf, unknown, updateRemote, visibleItems, visibleStore, windowGrowthKey, windowKey, withRefreshRequested, writeEntities, writeEntity, writeRead };

package/dist/index.mjs

@@ -1 +1 @@
-export { J as ConnectionChange, zt as ConnectionChangeSchema, j as Denied, pt as Entity, vn as IDENTITY_SEPARATOR, Bt as Live, Vt as LiveChange, Ht as LiveEdge, Ut as LiveRequirement, Wt as MAX_FIELDS_PER_REQUEST, Gt as MAX_RELATION_DEPTH, Kt as Mutate, xn as Mutation, qt as MutationRequest, Jt as MutationResult, Yt as NormalizedEntity, Xt as PageSize, yn as Query, Zt as QueryEdge, Qt as QueryRequest, $t as QueryResult, en as QueryRpc, Jn as RELATION_ALIAS, F as REMOTE_CACHE_VERSION, tn as REMOTE_PROTOCOL_VERSION, nn as Read, rn as ReadBatch, in as ReadBatchResult, an as ReadRequest, Sn as Refusal, Yn as RelationAnnotation, Xn as RelationEntityAnnotation, on as RelationRequest, t as Remote, At as RemoteClient, ir as RemoteConnections, M as RemoteData, sn as RemoteForbidden, a as RemoteJsonAnswer, o as RemoteJsonRequest, cn as RemoteLiveError, ln as RemoteMutationError, I as RemotePersistence, s as RemotePolicy, un as RemoteProtocolError, dn as RemoteQueryError, fn as RemoteReadError, ar as RemoteRequirements, pn as RemoteRpc, mn as RemoteUnauthenticated, n as RemoteUnsatisfied, or as Requirement, dt as RowPlace, mt as Selection, hn as SettledFields, gn as WindowSchema, _n as WireBoundary, Y as addLayer, X as addOverlay, Zn as aliasedField, H as applyConnectionEvent, U as applyEntityEvent, ht as assemble, Cn as beginMutation, Z as beginOptimistic, lt as belongsEncoded, W as classifyLive, jn as clearStale, It as coalesceQueries, Lt as coalesceReads, jt as coalescedLayer, Mt as connectionChangeOf, Q as connectionIdentity, sr as connectionsOf, yt as cursor, z as deadlineOf, bt as edge, xt as emptyConnection, G as emptyLiveState, wn as emptyMutationState, $ as emptyOptimistic, c as emptyRefresh, Mn as emptyStore, Nn as entityKey, Pn as entry, Tn as failMutation, l as failureOf, u as forgetRemote, L as gc, Fn as hasField, St as hasNext, Ct as hasPrevious, r as httpWithLive, d as initialRemoteModel, st as inspectEntity, ct as inspectRemote, f as invalidateConnections, p as isFieldFailed, In as isFieldStale, Ln as isFieldUnavailable, wt as isGapped, m as isLoading, h as isLoadingThrough, g as isQueryLoading, Qn as isRefPage, _ as isRemoteMessage, Rn as isTombstone, Tt as items, Nt as liveEventOf, i as liveFetch, K as liveHasNext, q as liveHasPrevious, zn as markStale, ut as matching, Et as merge, Bn as missingFields, Pt as mutateRemote, En as mutationStatus, v as noFailures, y as onlyOverlaid, Dn as optimisticOfWrite, b as overlaysOf, gt as pageSchema, On as patchOfWrite, ft as placeIn, B as plan, et as pruneOverlays, R as reachable, Vn as readField, kn as reconcileMutation, $n as refParts, x as refreshIsInFlight, S as refreshedAt, er as refsIn, tr as relationAlias, _t as relationOf, nr as relationShape, N as remoteDataSchema, Ft as remoteError, P as remoteErrorSchema, C as remoteMessageCases, w as remoteMessageSchema, T as remoteModelSchema, Hn as remove, tt as removeLayer, nt as removeOverlay, Rt as requirementKey, cr as requirementsOf, E as retentionRootsSchema, An as schemaOf, Dt as segment, Un as setStale, Wn as setUnavailable, rt as settleFailure, it as settleSuccess, bn as stableStringify, rr as targetsOf, Ot as terminal, Gn as tombstone, vt as unavailableOf, kt as unknown, D as updateRemote, at as visibleItems, ot as visibleStore, O as windowGrowthKey, V as windowKey, k as withRefreshRequested, Kn as writeEntities, qn as writeEntity, A as writeRead } from "./src-Cp71fJac.mjs";
+export { J as ConnectionChange, Vt as ConnectionChangeSchema, j as Denied, mt as Entity, xn as IDENTITY_SEPARATOR, Ht as Live, Ut as LiveChange, Wt as LiveEdge, Gt as LiveRequirement, Kt as MAX_FIELDS_PER_REQUEST, qt as MAX_RELATION_DEPTH, Jt as Mutate, wn as Mutation, Yt as MutationRequest, Xt as MutationResult, Zt as NormalizedEntity, Qt as OperationId, $t as PageSize, Sn as Query, en as QueryEdge, tn as QueryRequest, nn as QueryResult, rn as QueryRpc, Zn as RELATION_ALIAS, F as REMOTE_CACHE_VERSION, in as REMOTE_PROTOCOL_VERSION, an as Read, on as ReadBatch, sn as ReadBatchResult, cn as ReadRequest, Tn as Refusal, Qn as RelationAnnotation, $n as RelationEntityAnnotation, ln as RelationRequest, t as Remote, jt as RemoteClient, sr as RemoteConnections, M as RemoteData, un as RemoteForbidden, a as RemoteJsonAnswer, o as RemoteJsonRequest, dn as RemoteLiveError, fn as RemoteMutationError, I as RemotePersistence, s as RemotePolicy, pn as RemoteProtocolError, mn as RemoteQueryError, hn as RemoteReadError, cr as RemoteRequirements, gn as RemoteRpc, _n as RemoteUnauthenticated, n as RemoteUnsatisfied, lr as Requirement, ft as RowPlace, ht as Selection, vn as SettledFields, yn as WindowSchema, bn as WireBoundary, Y as addLayer, X as addOverlay, er as aliasedField, H as applyConnectionEvent, U as applyEntityEvent, gt as assemble, En as beginMutation, Z as beginOptimistic, ut as belongsEncoded, W as classifyLive, Pn as clearStale, Rt as coalesceQueries, zt as coalesceReads, Mt as coalescedLayer, Nt as connectionChangeOf, Q as connectionIdentity, ur as connectionsOf, bt as cursor, z as deadlineOf, xt as edge, St as emptyConnection, G as emptyLiveState, Dn as emptyMutationState, $ as emptyOptimistic, c as emptyRefresh, Fn as emptyStore, In as entityKey, Ln as entry, On as failMutation, l as failureOf, u as forgetRemote, L as gc, Rn as hasField, Ct as hasNext, wt as hasPrevious, r as httpWithLive, d as initialRemoteModel, ct as inspectEntity, lt as inspectRemote, f as invalidateConnections, p as isFieldFailed, zn as isFieldStale, Bn as isFieldUnavailable, Tt as isGapped, m as isLoading, h as isLoadingThrough, g as isQueryLoading, tr as isRefPage, _ as isRemoteMessage, Vn as isTombstone, Et as items, Pt as liveEventOf, i as liveFetch, K as liveHasNext, q as liveHasPrevious, Hn as markStale, dt as matching, Dt as merge, Ft as mintOperation, Un as missingFields, It as mutateRemote, kn as mutationStatus, v as noFailures, y as onlyOverlaid, An as optimisticOfWrite, b as overlaysOf, _t as pageSchema, jn as patchOfWrite, pt as placeIn, B as plan, et as pruneOverlays, R as reachable, Wn as readField, Mn as reconcileMutation, nr as refParts, x as refreshIsInFlight, S as refreshedAt, rr as refsIn, ir as relationAlias, vt as relationOf, ar as relationShape, N as remoteDataSchema, Lt as remoteError, P as remoteErrorSchema, C as remoteMessageCases, w as remoteMessageSchema, T as remoteModelSchema, Gn as remove, tt as removeLayer, nt as removeOverlay, Bt as requirementKey, dr as requirementsOf, rt as resolvedPatches, E as retentionRootsSchema, Nn as schemaOf, Ot as segment, Kn as setStale, qn as setUnavailable, it as settleFailure, at as settleSuccess, Cn as stableStringify, or as targetsOf, kt as terminal, Jn as tombstone, yt as unavailableOf, At as unknown, D as updateRemote, ot as visibleItems, st as visibleStore, O as windowGrowthKey, V as windowKey, k as withRefreshRequested, Yn as writeEntities, Xn as writeEntity, A as writeRead } from "./src-fsYu0YoT.mjs";

package/dist/port.d.mts

@@ -1,4 +1,4 @@
-import { kn as RemoteClient } from "./index-86gaaCWm.mjs";
+import { kn as RemoteClient } from "./index-Bx_lCC85.mjs";
 import { Effect, Layer } from "effect";
 import { RpcClient } from "effect/rpc";
 import * as WorkerRunner from "effect/workers/WorkerRunner";

package/dist/port.mjs

@@ -1,4 +1,4 @@
-import { pn as RemoteRpc, t as Remote } from "./src-Cp71fJac.mjs";
+import { gn as RemoteRpc, t as Remote } from "./src-fsYu0YoT.mjs";
 import { Deferred, Effect, Exit, Layer, Queue, Scope } from "effect";
 import { RpcClient } from "effect/rpc";
 import * as Worker from "effect/workers/Worker";