@thomasfosterau/legation 0.0.0 → 0.1.0

package/dist/index-CPPfp0F4.d.ts

@@ -0,0 +1,399 @@
+import { $ as MutatorRegistry, Bt as StoreError, I as LocalRow, Lt as MutatorError, Q as Mutator, U as ServerHandler, Ut as VersionNotSupportedError, V as ClientTransport, Vt as TransportError, X as AnyMutator, Z as LocalHandler, c as CvrStore, f as IdentityResolver, o as InvalidationBus, p as SyncMiddleware, pt as NodeRegistry, r as SyncServerOptions, st as Backend, tt as ClientStore, u as AuthPolicy, x as Read, y as QueryResolver } from "./MemoryBackend-BziXwfcs.js";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+declare namespace CrudMutation_d_exports {
+  export { DeleteArgs, Entry, Operation, Options, WriteArgs, Writes, entries, name, registry };
+}
+/** The three operations a graph-derived mutation performs. */
+type Operation = "create" | "update" | "delete";
+/**
+ * Which operations to derive, per node type. A type absent from the map gets
+ * none; an absent map derives all three for every node.
+ */
+type Writes = Readonly<Record<string, ReadonlyArray<Operation>>>;
+/** The mutation name for a type and an operation: `"{type}/{operation}"`. */
+declare const name: (type: string, operation: Operation) => string;
+/** The args of a `{type}/create` or `{type}/update`: the row's fields as a record, keyed by its id. */
+declare const WriteArgs: Schema.Struct<{
+  readonly type: Schema.String;
+  readonly id: Schema.String;
+  readonly attributes: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+/** The decoded (and encoded) args of a create or an update. */
+type WriteArgs = typeof WriteArgs.Type;
+/** The args of a `{type}/delete`. */
+declare const DeleteArgs: Schema.Struct<{
+  readonly type: Schema.String;
+  readonly id: Schema.String;
+}>;
+/** The decoded (and encoded) args of a delete. */
+type DeleteArgs = typeof DeleteArgs.Type;
+/** One derived mutation: its definition, its client handler, and what it does to which type. */
+interface Entry {
+  readonly mutator: AnyMutator;
+  readonly local: LocalHandler<any>;
+  readonly type: string;
+  readonly operation: Operation;
+}
+/** Options for {@link entries} and {@link registry}. */
+interface Options {
+  /** Which operations to derive per type; default all three for every node. */
+  readonly writes?: Writes | undefined;
+}
+/**
+ * The graph-derived CRUD mutations of every node in the graph (those `writes`
+ * selects), as registry entries an app spreads beside its own named
+ * mutations: `Mutation.registry([...mine, ...CrudMutation.entries(nodes)])`.
+ *
+ * @example
+ * ```ts
+ * import * as Schema from "effect/Schema";
+ * import { CrudMutation, Edge, Mutation, Node } from "@thomasfosterau/legation";
+ *
+ * const products = Node.make("products", { attributes: { name: Schema.String } });
+ * const reviews = Node.make("reviews", {
+ *   attributes: { rating: Schema.Number },
+ *   edges: { product: Edge.one("products", { via: "productId" }) },
+ * });
+ * const nodes = Node.registry([products, reviews]);
+ *
+ * const registry = Mutation.registry(
+ *   CrudMutation.entries(nodes, { writes: { reviews: ["create", "delete"] } })
+ * );
+ * console.log([...registry.mutators.keys()]); // ["reviews/create", "reviews/delete"]
+ * ```
+ */
+declare const entries: (nodes: NodeRegistry, options?: Options) => ReadonlyArray<Entry>;
+/** The graph-derived CRUD mutations as a registry of their own. Duplicate names cannot occur. */
+declare const registry: (nodes: NodeRegistry, options?: Options) => MutatorRegistry;
+declare namespace Hydration_d_exports {
+  export { RemoteSnapshotOptions, Snapshot, SnapshotError, SnapshotFromJson, SnapshotOptions, SnapshotRow, dehydrate, hydrate, hydrateIfEmpty, isEmpty, rowsFor, snapshot };
+}
+/**
+ * One dehydrated row: a {@link StoredRow} tagged with the collection it belongs
+ * to, so the flat `rows` array reconstructs the per-collection layout on
+ * hydrate. `value` stays `Unknown` (envelope-validated only, ADR-0014).
+ */
+declare const SnapshotRow: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly version: Schema.Union<readonly [Schema.String, Schema.Number]>;
+  readonly value: Schema.Unknown;
+  readonly collection: Schema.String;
+}>;
+/**
+ * A serialisable capture of a {@link ClientStore}: confirmed rows (flattened
+ * with their collection), the pull cookie, the pending-mutation journal, the
+ * acknowledged-but-unpulled tail (#336), and each client's mutation id counter
+ * (#271). The tail and the counters are optional so a snapshot taken before
+ * they existed still loads, as an empty tail and no counters. The schema is
+ * the source of truth; {@link Snapshot} is derived from it.
+ *
+ * The counters are what let a client id be reused across the hydration
+ * boundary: once acknowledgements have drained the journal, they are the only
+ * record of the ids the backend has already applied, and a hydrated store
+ * without them would issue those ids again, which the backend skips as
+ * duplicates (a silent lost write).
+ */
+declare const Snapshot: Schema.Struct<{
+  readonly rows: Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly version: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    readonly value: Schema.Unknown;
+    readonly collection: Schema.String;
+  }>>;
+  readonly cookie: Schema.optional<Schema.String>;
+  readonly journal: Schema.$Array<Schema.Struct<{
+    readonly clientId: Schema.String;
+    readonly mutationId: Schema.Number;
+    readonly mutator: Schema.String;
+    readonly args: Schema.Unknown;
+    readonly createdAt: Schema.Number;
+  }>>;
+  readonly unpulled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly clientId: Schema.String;
+    readonly mutationId: Schema.Number;
+    readonly mutator: Schema.String;
+    readonly args: Schema.Unknown;
+    readonly createdAt: Schema.Number;
+  }>>>;
+  readonly counters: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+}>;
+/** The type {@link Snapshot} decodes to. */
+type Snapshot = typeof Snapshot.Type;
+/** The type {@link SnapshotRow} decodes to. */
+type SnapshotRow = typeof SnapshotRow.Type;
+/**
+ * JSON codec for a {@link Snapshot}: `decode` parses a JSON string and validates
+ * it in one step (SSR/devtools ingest), `encode` produces the JSON string.
+ */
+declare const SnapshotFromJson: Schema.fromJsonString<Schema.Struct<{
+  readonly rows: Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly version: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    readonly value: Schema.Unknown;
+    readonly collection: Schema.String;
+  }>>;
+  readonly cookie: Schema.optional<Schema.String>;
+  readonly journal: Schema.$Array<Schema.Struct<{
+    readonly clientId: Schema.String;
+    readonly mutationId: Schema.Number;
+    readonly mutator: Schema.String;
+    readonly args: Schema.Unknown;
+    readonly createdAt: Schema.Number;
+  }>>;
+  readonly unpulled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly clientId: Schema.String;
+    readonly mutationId: Schema.Number;
+    readonly mutator: Schema.String;
+    readonly args: Schema.Unknown;
+    readonly createdAt: Schema.Number;
+  }>>>;
+  readonly counters: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+}>>;
+/** The type {@link SnapshotFromJson} decodes to. */
+type SnapshotFromJson = typeof SnapshotFromJson.Type;
+/**
+ * Read a {@link ClientStore} into a {@link Snapshot}: enumerate the collections,
+ * gather their confirmed rows (flattened with the collection), the cookie, the
+ * journal, the unpulled tail and the mutation counters. The tail and the
+ * counters are each left out when empty, so a snapshot without them keeps its
+ * previous shape.
+ *
+ * The five parts are one state when the store offers {@link ClientStore.snapshot}
+ * (the memory and key-value stores do): a pull or a push acknowledgement lands wholly
+ * before or wholly after the read (#392). A store without it is read member by member.
+ */
+declare const dehydrate: (store: ClientStore) => Effect.Effect<Snapshot, StoreError>;
+/**
+ * Write a {@link Snapshot} into a {@link ClientStore}: validate it through
+ * {@link Snapshot} (so a malformed snapshot fails as a `StoreError`), then
+ * put the rows, set the cookie if present, park the unpulled tail, raise the
+ * store's mutation counters to the snapshot's, and append the journal, skipping
+ * any entry the tail already holds. A snapshot without a tail parks nothing. An
+ * outstanding pull release is finished first.
+ *
+ * The counters are raised, never lowered (#271): a client id reused after
+ * hydration continues above every id the snapshot's store had issued, so it
+ * never reissues an id the backend has already applied. A snapshot without
+ * counters leaves the store's as they are.
+ *
+ * A running {@link ClientEngine} built over the store re-reads its view and built
+ * indexes afterwards: a direct write does not go through the engine, so without this
+ * an indexed query could return a row whose indexed field changed (#350). The re-read
+ * runs when a write fails too, since the rows written before the failure are in the
+ * store. It reaches only the engines built over this exact store object: a store
+ * wrapped in a new object (`ClientStore.of({ ...store })`) is not seen, so its engine
+ * can stay stale. The same re-read tracks the appended journal entries in its
+ * `mutationStates` as `"pending"` (#358), so they settle like a local mutation. Journal ids
+ * should be ids this client has not already settled: an id the map has evicted is tracked again,
+ * and its outcome event can then follow a second time.
+ *
+ * The writes are not atomic. Between the first `putRow` and the re-read, an indexed
+ * read on an async store can see the old index against the new rows. Once `hydrate`
+ * returns or fails, the engine's view and indexes match the store again.
+ *
+ * `hydrate` does not take the overlay lock of an engine built over the store, so it must
+ * not run while that engine is pulling. Its first step finishes an outstanding pull release
+ * (#387). If that release is a live pull's, the pull's remaining row writes then land over
+ * the snapshot's rows. Hydrate before the engine starts, or while it is stopped.
+ */
+declare const hydrate: (store: ClientStore, snapshot: Snapshot) => Effect.Effect<void, StoreError>;
+/**
+ * Whether a store holds nothing: no rows, no cookie, no journalled or unpulled mutations.
+ * The "fresh browser" test {@link hydrateIfEmpty} gates on.
+ */
+declare const isEmpty: (store: ClientStore) => Effect.Effect<boolean, StoreError>;
+/**
+ * {@link hydrate}, but only into an empty store; returns whether it hydrated.
+ *
+ * This is the right client-boot default over a *durable* store: on a repeat
+ * visit the store already holds rows, a cookie, and possibly journalled
+ * offline mutations that are all fresher than the SSR snapshot — hydrating
+ * over them would regress the cookie (and with it the CVR conversation) and
+ * clobber newer confirmed rows. An empty store (first visit, cleared storage)
+ * takes the snapshot wholesale.
+ */
+declare const hydrateIfEmpty: (store: ClientStore, snapshot: Snapshot) => Effect.Effect<boolean, StoreError>;
+/**
+ * Project a snapshot onto a read, locally and synchronously: the snapshot's
+ * rows for the read's collection, filtered/sorted/windowed by the read's
+ * compiled root window. This is how a component derives its initial value
+ * (e.g. the rune hooks' `initial` option) from the page's snapshot — during
+ * SSR and on first client render — without touching an engine.
+ *
+ * `include`d edges are not resolved here: a snapshot is flat rows, and
+ * resolving edges is the Client's job once the engine is up. Seed the base
+ * rows and let the first live emission fill the edges in.
+ */
+declare const rowsFor: (snapshot: Snapshot, nodes: NodeRegistry, read: Read) => ReadonlyArray<LocalRow>;
+/** Options for {@link snapshot}. */
+interface SnapshotOptions {
+  /**
+   * The client group the render belongs to — the browser's group id (e.g.
+   * carried in an HTTP cookie), so the cookie in the produced snapshot
+   * continues that group's CVR conversation on the client's first pull.
+   */
+  readonly clientGroupId: string;
+  /** Client id for the request-scoped engine (never pushes). Default `"ssr"`. */
+  readonly clientId?: string;
+  /** The node graph the reads compile against. */
+  readonly nodes: NodeRegistry;
+  /** The reads the page needs — subscribed and pulled once. */
+  readonly reads: ReadonlyArray<Read>;
+  /** Mutation registry for the request-scoped engine. Default: none. */
+  readonly mutations?: MutatorRegistry;
+  /**
+   * The carrier the request-scoped engine pulls over. Omit it for the
+   * in-process default — a loop-back transport to the in-context
+   * {@link ServerHandler} — which is what a single-process app wants.
+   *
+   * Pass one when the renderer is *not* the process holding the backend: a
+   * SvelteKit Worker rendering against a separate API Worker, an SSR tier in
+   * front of a remote sync server. Whatever the carrier, it must preserve the
+   * CVR conversation end to end — the request's `clientGroupId` reaches the
+   * Server unchanged, and the Server's fresh cookie comes back in the pull
+   * response — or the snapshot's cookie belongs to a conversation the client
+   * is not in, and its first pull silently degrades to the reset path.
+   */
+  readonly transport?: ClientTransport;
+}
+/** {@link SnapshotOptions} with the carrier supplied — no `ServerHandler` needed. */
+interface RemoteSnapshotOptions extends SnapshotOptions {
+  readonly transport: ClientTransport;
+}
+/** What a snapshot render can fail with. */
+type SnapshotError = StoreError | TransportError | MutatorError | VersionNotSupportedError;
+/**
+ * Produce an SSR snapshot over a request-scoped engine: build an in-memory
+ * {@link ClientStore}, subscribe the page's subsets over the given
+ * {@link ClientTransport}, pull once, and {@link dehydrate}. Everything is
+ * scoped to the call — nothing outlives it.
+ *
+ * With `options.transport` the render needs nothing from context; without it
+ * the in-process path applies and the app's sync server is taken from context
+ * as `ServerHandler`, carried by a loop-back transport.
+ *
+ * This is the server half of the SSR flow described above; run it inside a
+ * request handler (a SvelteKit `load`, a Next.js loader). Framework packages
+ * wrap this — they add the framework's own plumbing (a cookie, a `load`
+ * signature), never their own hydration logic.
+ */
+declare function snapshot(options: RemoteSnapshotOptions): Effect.Effect<Snapshot, SnapshotError>;
+/** The in-process form: renders against the app's sync server, the `ServerHandler` in context. */
+declare function snapshot(options: SnapshotOptions): Effect.Effect<Snapshot, SnapshotError, ServerHandler>;
+declare namespace Server_d_exports {
+  export { Broadcast, MakeOptions, MutateRequest, Receipt, Server, make };
+}
+/** A change announcement for {@link Server.broadcast}. */
+interface Broadcast {
+  readonly collection: string;
+  /** The changed row ids, when the writer knows them (finer fan-out). */
+  readonly ids?: ReadonlyArray<string>;
+}
+/**
+ * One Mutation for {@link Server.mutate} to run: the client group, the client
+ * and mutation id that name it, and the Mutation with its args.
+ *
+ * A form action passes a **form client** id minted for the rendered form, with
+ * mutation id `1` (ADR-0030 #215 §2). A mutation id is per client and
+ * contiguous, so the action must not borrow the next id of a tab's engine.
+ */
+interface MutateRequest<Args, ArgsEncoded> {
+  /** The client group the mutation belongs to (ADR-0020's client-group cookie). */
+  readonly clientGroupId: string;
+  /** The client that names the mutation: a form client id for a form action. */
+  readonly clientId: string;
+  /** The mutation's id for that client: `1` for a freshly rendered form. */
+  readonly mutationId: number;
+  /** The Mutation definition to run; its name selects the backend's handler. */
+  readonly mutation: Mutator<string, Args, ArgsEncoded>;
+  /**
+   * The args, as the form layer hands them over: decoded and validated. They
+   * are encoded against `mutation.args` for the backend, which decodes them
+   * again as for a pushed mutation.
+   */
+  readonly args: Args;
+  /** The schema version to check, as a push carries it (#48); unset when omitted. */
+  readonly schemaVersion?: string | undefined;
+}
+/**
+ * What {@link Server.mutate} answers: the mutation it ran, named by its client
+ * and mutation id, and the backend's ruling (ADR-0030 #215 §3). The phase uses
+ * `MutationState`'s vocabulary: `acknowledged`, or `rejected` with the reason
+ * the backend gave. A client holding an optimistic effect for this mutation
+ * releases it when a pull's `lastMutationIds` covers it, not on the receipt.
+ */
+type Receipt = {
+  readonly clientId: string;
+  readonly mutationId: number;
+  readonly phase: "acknowledged";
+} | {
+  readonly clientId: string;
+  readonly mutationId: number;
+  readonly phase: "rejected";
+  /** The backend's permanent-rejection reason. */
+  readonly reason: string;
+};
+/** One per backend: the protocol `handler` plus `broadcast` for out-of-band changes. */
+interface Server {
+  /** The sync protocol handler — mount it on any router or carrier. */
+  readonly handler: ServerHandler;
+  /**
+   * Announce out-of-band changes: subscribers whose windows may be
+   * affected are poked and pull. Writes pushed through {@link handler}
+   * broadcast implicitly.
+   */
+  readonly broadcast: (change: Broadcast) => Effect.Effect<void>;
+  /**
+   * Run one named Mutation as one of a client group's mutations, and answer
+   * its {@link Receipt} (ADR-0030 #215 §1–§3).
+   *
+   * The path is the push path minus the transport: the group's identity is
+   * resolved through the `IdentityResolver`, the middleware's `onPush` runs,
+   * the backend applies the mutation with its id bumped in the same
+   * transaction as its effects (a permanent rejection bumps it with no
+   * effects, ADR-0008), and the write's hints are broadcast as a pushed
+   * write's are. A pull from any client of the group then lists `clientId` in
+   * `lastMutationIds`.
+   *
+   * A resubmission of the same `(clientId, mutationId)` is a replay: the
+   * backend's ledger skips it, the handler does not run again, and the call
+   * answers the original ruling (a rejection from the backend's rejection
+   * memory, Backend guarantee 4).
+   *
+   * Args that do not encode against the Mutation's schema are a defect of the
+   * hand-over from the form layer, not a field error (§5): the effect dies.
+   * Every other failure (identity, middleware, a transient backend error, an
+   * unsupported schema version) fails as the push path does.
+   */
+  readonly mutate: <Args, ArgsEncoded>(request: MutateRequest<Args, ArgsEncoded>) => Effect.Effect<Receipt, TransportError | VersionNotSupportedError>;
+}
+/**
+ * Options for {@link make}: the backend and auth are required; CVR storage and the bus default
+ * to in-memory / in-process.
+ */
+interface MakeOptions {
+  /** The storage contract (ADR-0009). */
+  readonly backend: Backend;
+  readonly auth: {
+    /** Deny-by-default per-collection filters. */
+    readonly policy: AuthPolicy;
+    /** Resolve a client group to its identity (session binding). */
+    readonly identity?: IdentityResolver;
+  };
+  /** Named-query resolution (server-authoritative subsets). */
+  readonly queries?: QueryResolver;
+  /** Cross-cutting interception (tenancy, cost control, telemetry). */
+  readonly middleware?: SyncMiddleware;
+  /** CVR storage; defaults to in-memory. */
+  readonly cvr?: CvrStore;
+  /** The hint fan-out bus; defaults to in-process. */
+  readonly bus?: InvalidationBus;
+  /** Handler tuning passthrough. */
+  readonly options?: SyncServerOptions;
+}
+/** Build the Server: handler + broadcast over backend and auth. */
+declare const make: (options: MakeOptions) => Effect.Effect<Server, never, Scope.Scope>;
+export { Hydration_d_exports as n, CrudMutation_d_exports as r, Server_d_exports as t };
+//# sourceMappingURL=index-CPPfp0F4.d.ts.map

package/dist/index-CPPfp0F4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CPPfp0F4.d.ts","names":["Mutator.AnyMutator","Mutator.LocalHandler","Node.NodeRegistry","Mutator.MutatorRegistry","Node.NodeRegistry","Query.Read","ClientEngineModule.LocalRow","Mutator.MutatorRegistry","Mutator.Mutator","Transport.ServerHandler","BackendService","Authorization.AuthPolicy","Authorization.IdentityResolver","Query.QueryResolver","Authorization.SyncMiddleware","Cvr.CvrStore","InvalidationBus.InvalidationBus","SyncServer.SyncServerOptions"],"sources":["../src/CrudMutation.ts","../src/Hydration.ts","../src/Server.ts"],"mappings":";;;;;;;;KA+CY;;;;;KAMA,SAAS,SAAS,eAAe,cAAc;;cAG9C,OAAQ,cAAc,WAAW;;cAGjC,WAAS,OAAA;;;;;;KAOV,mBAAmB,UAAU;;cAG5B,YAAU,OAAA;;;;;KAGX,oBAAoB,WAAW;;UAG1B;WACN,SAASA;WACT,OAAOC;WACP;WACA,WAAW;;;UAIL;;WAEN,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;cAwEP,UAAW,OAAOC,cAAmB,UAAU,YAAU,cAAc;;cAIvE,WAAY,OAAOA,cAAmB,UAAU,YAAUC;;;;;;;;;cClF1D,aAAW,OAAA;;;;;;;;;;;;;;;;;;;;cAmBX,UAAQ,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAcT,kBAAkB,SAAS;;KAG3B,qBAAqB,YAAY;;;;;cAMhC,kBAAgB,OAAA,eAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAGjB,0BAA0B,iBAAiB;;;;;;;;;;;;cAyC1C,YAAa,OAAO,gBAAc,OAAO,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkD1D,UAAW,OAAO,aAAa,UAAU,aAAW,OAAO,aAAa;;;;;cAoDxE,UAAW,OAAO,gBAAc,OAAO,gBAAgB;;;;;;;;;;;cAqBvD,iBACX,OAAO,aACP,UAAU,aACT,OAAO,gBAAgB;;;;;;;;;;;;cAkBb,UACX,UAAU,UACV,OAAOC,cACP,MAAMC,SACL,cAAcC;;UASA;;;;;;WAMN;;WAEA;;WAEA,OAAOF;;WAEP,OAAO,cAAcC;;WAErB,YAAYE;;;;;;;;;;;;;;WAcZ,YAAY;;;UAIN,8BAA8B;WACpC,WAAW;;;KAIV,gBAAgB,aAAa,iBAAiB,eAAe;;;;;;;;;;;;;;;;iBA8CzD,SAAS,SAAS,wBAAwB,OAAO,OAAO,UAAU;;iBAElE,SACd,SAAS,kBACR,OAAO,OAAO,UAAU,eAAe;;;;;UC5WzB;WACN;;WAEA,MAAM;;;;;;;;;;UAWA,cAAc,MAAM;;WAE1B;;WAEA;;WAEA;;WAEA,UAAUC,gBAAwB,MAAM;;;;;;WAMxC,MAAM;;WAEN;;;;;;;;;KAUC;WAEG;WACA;WACA;;WAGA;WACA;WACA;;WAEA;;;UAIE;;WAEN,SAASC;;;;;;WAMT,YAAY,QAAQ,cAAc,OAAO;;;;;;;;;;;;;;;;;;;;;;;WAuBzC,SAAS,MAAM,aACtB,SAAS,cAAc,MAAM,iBAC1B,OAAO,OAAO,SAAS,iBAAiB;;;;;;UAiC9B;;WAEN,SAASC;WACT;;aAEE,QAAQC;;aAER,WAAWC;;;WAGb,UAAUC;;WAEV,aAAaC;;WAEb,MAAMC;;WAEN,MAAMC;;WAEN,UAAUC;;;cAIR,OAAQ,SAAS,gBAAc,OAAO,OAAO,eAAe,MAAM"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { At as Predicate_d_exports, Bt as StoreError, Ft as JournalError, Ht as UnknownCollectionError, It as MutationRejected, Lt as MutatorError, Mt as BackendError, Nt as DuplicateNameError, Pt as FilterDeclarationError, Rt as ProtocolError, Ut as VersionNotSupportedError, Vt as TransportError, W as Transport_d_exports, b as Query_d_exports, ct as Backend_d_exports, d as Authorization_d_exports, et as Mutator_d_exports, ht as Edge_d_exports, jt as AuthorizationError, m as Client_d_exports, mt as Node_d_exports, n as MemoryBackend_d_exports, nt as ClientStore_d_exports, ot as Aggregate_d_exports, rt as Identity_d_exports, vt as Collection_d_exports, yt as FilterPolicy_d_exports, zt as QueryError } from "./MemoryBackend-BziXwfcs.js";
+import { n as Hydration_d_exports, r as CrudMutation_d_exports, t as Server_d_exports } from "./index-CPPfp0F4.js";
+export { Aggregate_d_exports as Aggregate, Authorization_d_exports as Authorization, AuthorizationError, Backend_d_exports as Backend, BackendError, Client_d_exports as Client, ClientStore_d_exports as ClientStore, Collection_d_exports as Collection, CrudMutation_d_exports as CrudMutation, DuplicateNameError, Edge_d_exports as Edge, FilterDeclarationError, FilterPolicy_d_exports as FilterPolicy, Hydration_d_exports as Hydration, Identity_d_exports as Identity, JournalError, MemoryBackend_d_exports as MemoryBackend, Mutator_d_exports as Mutation, Mutator_d_exports as Mutator, MutationRejected, MutatorError, Node_d_exports as Node, Predicate_d_exports as Predicate, ProtocolError, Query_d_exports as Query, QueryError, Server_d_exports as Server, StoreError, Transport_d_exports as Transport, TransportError, UnknownCollectionError, VersionNotSupportedError };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { Bn as StoreError, Bt as Query_exports, C as Authorization_exports, Cn as Collection_exports, Fn as JournalError, Ft as Mutator_exports, Hn as UnknownCollectionError, In as MutationRejected, Ln as MutatorError, Mn as BackendError, Nn as DuplicateNameError, On as FilterPolicy_exports, Pn as FilterDeclarationError, Rn as ProtocolError, Rt as Aggregate_exports, Un as VersionNotSupportedError, Vn as TransportError, bt as ClientStore_exports, g as Backend_exports, in as Predicate_exports, jn as AuthorizationError, jt as Identity_exports, rt as Transport_exports, t as MemoryBackend_exports, zn as QueryError } from "./MemoryBackend-DxP8t4ge.js";
+import { a as Edge_exports, i as CrudMutation_exports, n as Hydration_exports, o as Node_exports, r as Client_exports, t as Server_exports } from "./src-FWXpu_vP.js";
+export { Aggregate_exports as Aggregate, Authorization_exports as Authorization, AuthorizationError, Backend_exports as Backend, BackendError, Client_exports as Client, ClientStore_exports as ClientStore, Collection_exports as Collection, CrudMutation_exports as CrudMutation, DuplicateNameError, Edge_exports as Edge, FilterDeclarationError, FilterPolicy_exports as FilterPolicy, Hydration_exports as Hydration, Identity_exports as Identity, JournalError, MemoryBackend_exports as MemoryBackend, Mutator_exports as Mutation, Mutator_exports as Mutator, MutationRejected, MutatorError, Node_exports as Node, Predicate_exports as Predicate, ProtocolError, Query_exports as Query, QueryError, Server_exports as Server, StoreError, Transport_exports as Transport, TransportError, UnknownCollectionError, VersionNotSupportedError };