@thomasfosterau/legation-jsonapi 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1708 @@
+import { ApiError as ApiError$1, Document, Filter, Handlers, Resource } from "@thomasfosterau/effect-jsonapi";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Context from "effect/Context";
+import * as Result from "effect/Result";
+import * as HttpClient from "effect/http/HttpClient";
+import * as Option from "effect/Option";
+import { Authorization, AuthorizationError, Backend, BackendError, Client, ClientStore, Collection, CrudMutation, FilterPolicy, Mutator, MutatorError, Node, Predicate, Query as Query$1, QueryError, StoreError } from "@thomasfosterau/legation";
+import * as HttpApi from "effect/http-api/HttpApi";
+import { ClientEngine, ClientView, Coverage, MutationState, Related, Subset } from "@thomasfosterau/legation/internal";
+import * as Duration from "effect/Duration";
+import * as Stream from "effect/Stream";
+import * as HttpServerResponse from "effect/http/HttpServerResponse";
+import * as Layer from "effect/Layer";
+import { KeyValueStore } from "effect/persistence";
+import * as HttpClientError from "effect/http/HttpClientError";
+import * as HttpClientResponse from "effect/http/HttpClientResponse";
+import * as HttpApiEndpoint from "effect/http-api/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/http-api/HttpApiGroup";
+import { HttpServerRequest } from "effect/http/HttpServerRequest";
+import * as Scope from "effect/Scope";
+declare const SyncError_base: Schema.Class<SyncError, Schema.TaggedStruct<"SyncError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * Base error for synchronizer operations.
+ */
+export declare class SyncError extends SyncError_base {}
+declare const NetworkError_base: Schema.Class<NetworkError, Schema.TaggedStruct<"NetworkError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * Network-related error (connection failure, timeout, etc.).
+ */
+export declare class NetworkError extends NetworkError_base {}
+declare const ParseError_base: Schema.Class<ParseError, Schema.TaggedStruct<"ParseError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * Parsing error for JSON:API documents.
+ */
+export declare class ParseError extends ParseError_base {}
+declare const ApiError_base: Schema.Class<ApiError, Schema.TaggedStruct<"ApiError", {
+  readonly message: Schema.String;
+  readonly errors: Schema.$Array<Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.String>;
+    readonly links: Schema.optionalKey<Schema.Struct<{
+      readonly about: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+        readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+        readonly rel: Schema.optionalKey<Schema.String>;
+        readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly type: Schema.optionalKey<Schema.String>;
+        readonly hreflang: Schema.optionalKey<Schema.String>;
+        readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>]>>;
+      readonly type: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+        readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+        readonly rel: Schema.optionalKey<Schema.String>;
+        readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly type: Schema.optionalKey<Schema.String>;
+        readonly hreflang: Schema.optionalKey<Schema.String>;
+        readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>]>>;
+    }>>;
+    readonly status: Schema.optionalKey<Schema.String>;
+    readonly code: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly detail: Schema.optionalKey<Schema.String>;
+    readonly source: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+      readonly pointer: Schema.String;
+    }>, Schema.Struct<{
+      readonly parameter: Schema.String;
+    }>, Schema.Struct<{
+      readonly header: Schema.String;
+    }>]>>;
+    readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * API error carrying the JSON:API error objects returned by the server.
+ */
+export declare class ApiError extends ApiError_base {}
+declare const ConflictError_base: Schema.Class<ConflictError, Schema.TaggedStruct<"ConflictError", {
+  readonly message: Schema.String;
+  readonly localVersion: Schema.optional<Schema.String>;
+  readonly remoteVersion: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * Conflict error raised when local and remote resource versions mismatch.
+ */
+export declare class ConflictError extends ConflictError_base {}
+declare namespace schema_d_exports {
+  export { JsonApiDocument, JsonApiError, LinkObject, Links, Relationship, ResourceIdentifier, ResourceObject, decodeDocument };
+}
+/**
+ * Schema for a JSON:API link object (`{ href, ... }`), adopted from the
+ * library's spec-compliant definition.
+ */
+declare const LinkObject: Schema.Struct<{
+  readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+  readonly rel: Schema.optionalKey<Schema.String>;
+  readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+  readonly title: Schema.optionalKey<Schema.String>;
+  readonly type: Schema.optionalKey<Schema.String>;
+  readonly hreflang: Schema.optionalKey<Schema.String>;
+  readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>;
+/** A JSON:API link object. */
+type LinkObject = typeof LinkObject.Type;
+/**
+ * Schema for a JSON:API `links` object. The spec allows arbitrary link names,
+ * so this is a record of link values; `self` / `related` are simply well-known
+ * keys within it.
+ */
+declare const Links: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+  readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+  readonly rel: Schema.optionalKey<Schema.String>;
+  readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+  readonly title: Schema.optionalKey<Schema.String>;
+  readonly type: Schema.optionalKey<Schema.String>;
+  readonly hreflang: Schema.optionalKey<Schema.String>;
+  readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>]>>;
+/** A JSON:API `links` object: arbitrary link names → string | link object. */
+type Links = typeof Links.Type;
+/**
+ * Schema for a JSON:API resource identifier (`{ type, id, meta? }`).
+ */
+declare const ResourceIdentifier: Schema.Struct<{
+  readonly type: Schema.String;
+  readonly id: Schema.String;
+  readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>;
+/** A JSON:API resource identifier (`{ type, id, meta? }`). */
+type ResourceIdentifier = typeof ResourceIdentifier.Type;
+/**
+ * Schema for a JSON:API relationship (`{ data?, links?, meta? }`). The
+ * `data` member may be a single identifier, an array of identifiers, or
+ * `null`.
+ */
+declare const Relationship: Schema.Struct<{
+  readonly data: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.String;
+    readonly id: Schema.String;
+    readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>, Schema.$Array<Schema.Struct<{
+    readonly type: Schema.String;
+    readonly id: Schema.String;
+    readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>>]>>>;
+  readonly links: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+    readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+    readonly rel: Schema.optionalKey<Schema.String>;
+    readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly type: Schema.optionalKey<Schema.String>;
+    readonly hreflang: Schema.optionalKey<Schema.String>;
+    readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>]>>>;
+  readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>;
+/** A JSON:API relationship (`{ data?, links?, meta? }`). */
+type Relationship = typeof Relationship.Type;
+/**
+ * Schema for a JSON:API resource object (a resource identifier plus
+ * optional `attributes`, `relationships`, and `links`).
+ */
+declare const ResourceObject: Schema.Struct<{
+  readonly type: Schema.String;
+  readonly id: Schema.String;
+  readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly relationships: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
+    readonly data: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.String;
+      readonly id: Schema.String;
+      readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>, Schema.$Array<Schema.Struct<{
+      readonly type: Schema.String;
+      readonly id: Schema.String;
+      readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>>]>>>;
+    readonly links: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+      readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+      readonly rel: Schema.optionalKey<Schema.String>;
+      readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+      readonly title: Schema.optionalKey<Schema.String>;
+      readonly type: Schema.optionalKey<Schema.String>;
+      readonly hreflang: Schema.optionalKey<Schema.String>;
+      readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>]>>>;
+    readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>>>;
+  readonly links: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+    readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+    readonly rel: Schema.optionalKey<Schema.String>;
+    readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly type: Schema.optionalKey<Schema.String>;
+    readonly hreflang: Schema.optionalKey<Schema.String>;
+    readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>]>>>;
+}>;
+/** A JSON:API resource object (identifier + optional attributes/relationships/links). */
+type ResourceObject = typeof ResourceObject.Type;
+/**
+ * Schema for a JSON:API error object, adopted from the library's
+ * spec-compliant definition.
+ */
+declare const JsonApiError: Schema.Struct<{
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly links: Schema.optionalKey<Schema.Struct<{
+    readonly about: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+      readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+      readonly rel: Schema.optionalKey<Schema.String>;
+      readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+      readonly title: Schema.optionalKey<Schema.String>;
+      readonly type: Schema.optionalKey<Schema.String>;
+      readonly hreflang: Schema.optionalKey<Schema.String>;
+      readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>]>>;
+    readonly type: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+      readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+      readonly rel: Schema.optionalKey<Schema.String>;
+      readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+      readonly title: Schema.optionalKey<Schema.String>;
+      readonly type: Schema.optionalKey<Schema.String>;
+      readonly hreflang: Schema.optionalKey<Schema.String>;
+      readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>]>>;
+  }>>;
+  readonly status: Schema.optionalKey<Schema.String>;
+  readonly code: Schema.optionalKey<Schema.String>;
+  readonly title: Schema.optionalKey<Schema.String>;
+  readonly detail: Schema.optionalKey<Schema.String>;
+  readonly source: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly pointer: Schema.String;
+  }>, Schema.Struct<{
+    readonly parameter: Schema.String;
+  }>, Schema.Struct<{
+    readonly header: Schema.String;
+  }>]>>;
+  readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>;
+/** A JSON:API error object. */
+type JsonApiError = typeof JsonApiError.Type;
+/**
+ * Schema for a top-level JSON:API document.
+ *
+ * The `data` member may be a single resource, a collection of resources, a
+ * resource identifier (or collection thereof), or `null`. The other
+ * top-level members (`errors`, `meta`, `included`, `links`, `jsonapi`) are
+ * all optional. The `jsonapi` member reuses the library's `JsonApiObject`.
+ */
+declare const JsonApiDocument: Schema.Struct<{
+  readonly data: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.String;
+    readonly id: Schema.String;
+    readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly relationships: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
+      readonly data: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.String;
+        readonly id: Schema.String;
+        readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>, Schema.$Array<Schema.Struct<{
+        readonly type: Schema.String;
+        readonly id: Schema.String;
+        readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>>]>>>;
+      readonly links: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+        readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+        readonly rel: Schema.optionalKey<Schema.String>;
+        readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly type: Schema.optionalKey<Schema.String>;
+        readonly hreflang: Schema.optionalKey<Schema.String>;
+        readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>]>>>;
+      readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>>>;
+    readonly links: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+      readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+      readonly rel: Schema.optionalKey<Schema.String>;
+      readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+      readonly title: Schema.optionalKey<Schema.String>;
+      readonly type: Schema.optionalKey<Schema.String>;
+      readonly hreflang: Schema.optionalKey<Schema.String>;
+      readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>]>>>;
+  }>, Schema.$Array<Schema.Struct<{
+    readonly type: Schema.String;
+    readonly id: Schema.String;
+    readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly relationships: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
+      readonly data: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.String;
+        readonly id: Schema.String;
+        readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>, Schema.$Array<Schema.Struct<{
+        readonly type: Schema.String;
+        readonly id: Schema.String;
+        readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>>]>>>;
+      readonly links: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+        readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+        readonly rel: Schema.optionalKey<Schema.String>;
+        readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly type: Schema.optionalKey<Schema.String>;
+        readonly hreflang: Schema.optionalKey<Schema.String>;
+        readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>]>>>;
+      readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>>>;
+    readonly links: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+      readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+      readonly rel: Schema.optionalKey<Schema.String>;
+      readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+      readonly title: Schema.optionalKey<Schema.String>;
+      readonly type: Schema.optionalKey<Schema.String>;
+      readonly hreflang: Schema.optionalKey<Schema.String>;
+      readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>]>>>;
+  }>>, Schema.Struct<{
+    readonly type: Schema.String;
+    readonly id: Schema.String;
+    readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>, Schema.$Array<Schema.Struct<{
+    readonly type: Schema.String;
+    readonly id: Schema.String;
+    readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>>]>>>;
+  readonly errors: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.String>;
+    readonly links: Schema.optionalKey<Schema.Struct<{
+      readonly about: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+        readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+        readonly rel: Schema.optionalKey<Schema.String>;
+        readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly type: Schema.optionalKey<Schema.String>;
+        readonly hreflang: Schema.optionalKey<Schema.String>;
+        readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>]>>;
+      readonly type: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+        readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+        readonly rel: Schema.optionalKey<Schema.String>;
+        readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly type: Schema.optionalKey<Schema.String>;
+        readonly hreflang: Schema.optionalKey<Schema.String>;
+        readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>]>>;
+    }>>;
+    readonly status: Schema.optionalKey<Schema.String>;
+    readonly code: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly detail: Schema.optionalKey<Schema.String>;
+    readonly source: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+      readonly pointer: Schema.String;
+    }>, Schema.Struct<{
+      readonly parameter: Schema.String;
+    }>, Schema.Struct<{
+      readonly header: Schema.String;
+    }>]>>;
+    readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>>>;
+  readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly included: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly type: Schema.String;
+    readonly id: Schema.String;
+    readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly relationships: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
+      readonly data: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.String;
+        readonly id: Schema.String;
+        readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>, Schema.$Array<Schema.Struct<{
+        readonly type: Schema.String;
+        readonly id: Schema.String;
+        readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>>]>>>;
+      readonly links: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+        readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+        readonly rel: Schema.optionalKey<Schema.String>;
+        readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly type: Schema.optionalKey<Schema.String>;
+        readonly hreflang: Schema.optionalKey<Schema.String>;
+        readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+      }>]>>>;
+      readonly meta: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>>>;
+    readonly links: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+      readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+      readonly rel: Schema.optionalKey<Schema.String>;
+      readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+      readonly title: Schema.optionalKey<Schema.String>;
+      readonly type: Schema.optionalKey<Schema.String>;
+      readonly hreflang: Schema.optionalKey<Schema.String>;
+      readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>]>>>;
+  }>>>;
+  readonly links: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.URLFromString, Schema.String]>, Schema.Struct<{
+    readonly href: Schema.Union<readonly [Schema.URLFromString, Schema.String]>;
+    readonly rel: Schema.optionalKey<Schema.String>;
+    readonly describedby: Schema.optionalKey<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly type: Schema.optionalKey<Schema.String>;
+    readonly hreflang: Schema.optionalKey<Schema.String>;
+    readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>]>>>;
+  readonly jsonapi: Schema.optional<Schema.Struct<{
+    readonly version: Schema.optionalKey<Schema.Literals<readonly ["1.0", "1.1"]>>;
+    readonly ext: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>>;
+    readonly profile: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.URLFromString, Schema.String]>>>;
+    readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+  }>>;
+}>;
+/**
+ * A top-level JSON:API document. Derived from {@link JsonApiDocument}
+ * so the type and the validator cannot drift.
+ */
+type JsonApiDocument = typeof JsonApiDocument.Type;
+/**
+ * Decode an unknown value (e.g. a parsed HTTP response body) into a
+ * `JsonApiDocument`. Schema failures become `ParseError`, with the schema
+ * issue attached as `cause`.
+ */
+declare const decodeDocument: (input: unknown) => Effect.Effect<JsonApiDocument, ParseError>;
+/**
+ * A single JSON:API `sort` term: a field and a direction, matching the decoded
+ * shape of the library's `Query.Sort` codec.
+ */
+interface SortTerm {
+  readonly field: string;
+  readonly direction: "asc" | "desc";
+}
+/** The pagination strategies the library models, as a decoded value. */
+declare const PageParams: Schema.Union<readonly [Schema.Struct<{
+  readonly offset: Schema.optionalKey<Schema.FiniteFromString>;
+  readonly limit: Schema.optionalKey<Schema.FiniteFromString>;
+}>, Schema.Struct<{
+  readonly number: Schema.optionalKey<Schema.FiniteFromString>;
+  readonly size: Schema.optionalKey<Schema.FiniteFromString>;
+}>, Schema.Struct<{
+  readonly cursor: Schema.optionalKey<Schema.String>;
+  readonly size: Schema.optionalKey<Schema.FiniteFromString>;
+}>]>;
+/**
+ * JSON:API `page` parameters: offset/limit, number/size, or cursor/size — the
+ * strategies exposed by the library's `Query.Page`.
+ */
+type PageParams = typeof PageParams.Type;
+/**
+ * JSON:API Request Options. `filter` is a filter-grammar AST (ADR-0028;
+ * `Filter.eq("status", "open")`, `Filter.and(...)`, …), encoded exactly
+ * through the grammar's canonical `filter[...]` form by
+ * `JsonApiQuery.buildQueryString`.
+ */
+interface JsonApiRequestOptions {
+  include?: ReadonlyArray<string>;
+  fields?: Readonly<Record<string, ReadonlyArray<string>>>;
+  sort?: ReadonlyArray<SortTerm>;
+  filter?: Filter.Node;
+  page?: PageParams;
+}
+declare namespace JsonApiQuery_d_exports {
+  export { DecodedQuery, PageWindow, ParsedRead, Projection, QueryEncoder, SingleRowQuery, buildQueryString, canonical, defaultEncoder, flatFilter, foldConstants, fromFilterAst, invalidParameter, parseParams, parseRead, querySchema, resourcesOf, singleRowParams, singleRowSchema, toFilterAst, toRequestOptions, urlReads };
+}
+/**
+ * The engine form of a filter AST, or a typed `QueryError` naming the field
+ * whose literal {@link literalOf} rejects: `Compare` / `In` / `NotIn` /
+ * `IsNull` map node for node, `And` / `Or` / `Not` recurse, and the empty
+ * conjunction (the grammar's "true") is `Predicate.always`. The map is
+ * structural — a singleton group, which the grammar's normal form keeps
+ * after deduplicating `Or(x, x)`, stays a singleton group rather than
+ * collapsing through `Predicate.or` — so {@link canonical} is idempotent.
+ * Literals are the codec's decoded scalars; a `Date` (a `DateFromString`
+ * attribute) becomes its ISO-8601 UTC text (see the module doc's encode
+ * note). Field names are copied verbatim — the module doc's
+ * field-namespace precondition.
+ *
+ * This module's own callers ({@link readOf}, {@link filterOf}) never see
+ * this fail: their ASTs are decoded through {@link resourcesOf}'s synthetic
+ * resource, whose filterable attributes admit only wire scalars, or are
+ * built by {@link toFilterAst} from a `Predicate.Literal`, which is one
+ * already. The typed failure exists for this function's public contract —
+ * any caller bridging an AST built over a resource with a richer decoded
+ * attribute type (a `Date`-valued one aside, which is handled) — not for
+ * either call site here.
+ */
+declare const fromFilterAst: (ast: Filter.Node) => Result.Result<Predicate.Predicate, QueryError>;
+/**
+ * The grammar form of a predicate, or `None` where it has no URL form:
+ * `Exists` (server-only, ADR-0028 §5), an empty `In` / `NotIn` list, or a
+ * `null` literal (the deprecated wire form of `isnull`; it evaluates to
+ * unknown and cannot be folded). `True` is the empty conjunction.
+ * `fromFilterAst ∘ toFilterAst` is the identity on every constructor-built
+ * predicate it accepts.
+ */
+declare const toFilterAst: (predicate: Predicate.Predicate) => Option.Option<Filter.Node>;
+/**
+ * Fold the definite constants out of a predicate, exactly under ADR-0028's
+ * three-valued semantics: an empty `In` is false and an empty `NotIn` is
+ * true for every row (the compilers render them `1 = 0` / `1 = 1`), a
+ * false conjunct or a true disjunct decides its connective, and true
+ * conjuncts / false disjuncts vanish. Unknown is never folded — a `null`
+ * literal stays where it is. The result is `Predicate.always`, the empty
+ * `Or` (false), or a predicate free of empty lists.
+ */
+declare const foldConstants: (predicate: Predicate.Predicate) => Predicate.Predicate;
+/**
+ * The node graph as effect-jsonapi resource definitions, one per node —
+ * the declaration the URL codecs are derived from. Attributes are typed by
+ * the node's filterable set (kind and operators), relationships are its
+ * edges; nothing else about the resource is faithful (a document is never
+ * serialised through it). Memoised per registry.
+ */
+declare const resourcesOf: (nodes: Node.NodeRegistry) => ReadonlyMap<string, Resource.Any>;
+/**
+ * The root window's page parameters: `page[limit]` is the read's `first`
+ * (a positive integer), `page[after]` its `after` cursor (a row id,
+ * opaque on the wire), `page[offset]` its `offset` (a non-negative
+ * integer, #209 — every audited app's pagination idiom). `page[offset]`
+ * and `page[after]` are different pagination idioms; {@link parseParams}
+ * rejects a request naming both, and {@link decodedOf} emits `limit` then
+ * whichever of `after` / `offset` the read carries — the order the
+ * canonical string keeps.
+ */
+declare const PageWindow: {
+  limit: Schema.optionalKey<Schema.FiniteFromString>;
+  after: Schema.optionalKey<Schema.String>;
+  offset: Schema.optionalKey<Schema.FiniteFromString>;
+};
+/** The decoded shape of a collection's query, as the node-derived codec produces it. */
+interface DecodedQuery {
+  readonly include?: ReadonlyArray<string>;
+  readonly fields?: Readonly<Record<string, ReadonlyArray<string>>>;
+  readonly sort?: ReadonlyArray<SortTerm>;
+  readonly page?: {
+    readonly limit?: number;
+    readonly after?: string;
+    readonly offset?: number;
+  };
+  readonly filter?: Filter.Node;
+}
+/**
+ * The query codec of a collection's `list` endpoint — `include`, `fields[…]`,
+ * `sort`, `page[…]` and `filter[…]` exactly as the node graph declares them:
+ * the codec {@link parseParams} decodes with, so an effect-jsonapi endpoint
+ * served by a derived handler (`RestHandlers.list`) declares the grammar the
+ * handler parses when it is passed as `Endpoint.list(R, { query })`.
+ * effect-jsonapi's own `filter: true` derives a grammar from the *resource*
+ * instead, and the two spell a to-one relationship's filter differently: the
+ * resource grammar names the relationship (`filter[category]=c-audio`), the
+ * node graph — and every URL the engine emits ({@link canonical}) — names the
+ * key field (`filter[categoryId]=c-audio`, as ADR-0029's URLs do). One codec
+ * on both sides keeps the endpoint's contract and the handler's parse the
+ * same language. Every edge is includable under it, so a resource served
+ * with it declares its collection-valued edges `Relationship.many`, never
+ * `paginated` (whose `include=` only the resource grammar refuses). Throws a
+ * `QueryError` for an unknown collection — a definition-time defect.
+ */
+declare const querySchema: (nodes: Node.NodeRegistry, collection: string) => Schema.Codec<DecodedQuery, Readonly<Record<string, unknown>>>;
+/** The decoded shape of a single-resource request's query: `include` and `fields[…]` only. */
+interface SingleRowQuery {
+  readonly include?: ReadonlyArray<string>;
+  readonly fields?: Readonly<Record<string, ReadonlyArray<string>>>;
+}
+/**
+ * The query codec of a collection's `get` endpoint — `include` and
+ * `fields[…]` exactly as the node graph declares them, the two parameters a
+ * single-resource request takes ({@link singleRowParams}) — for
+ * `Endpoint.get(R, { query })`, the counterpart of {@link querySchema}: the
+ * endpoint's contract and the derived handler's parse are one grammar on
+ * the single-row route too. Throws a `QueryError` for an unknown collection.
+ */
+declare const singleRowSchema: (nodes: Node.NodeRegistry, collection: string) => Schema.Codec<SingleRowQuery, Readonly<Record<string, unknown>>>;
+/** A sparse-fieldset projection: attribute names by resource type (ADR-0029 §5). */
+type Projection = Readonly<Record<string, ReadonlyArray<string>>>;
+/**
+ * A parsed URL: the declarative read, the `fields[]` projection beside it,
+ * and — from {@link parseRead} of a `/{type}/{id}` path — the row id the
+ * path addressed, so the caller knows to write a single-resource document
+ * (the read already carries it as `filter[id]`, first 1).
+ */
+interface ParsedRead {
+  readonly read: Query$1.Read;
+  readonly fields?: Projection;
+  readonly id?: string;
+}
+/**
+ * The rejection of one query parameter, in the shape every check here
+ * raises (`parameter` names the offending key, so a caller answers 400 with
+ * `source.parameter`). Exported for a caller that checks a parsed URL
+ * against a declaration of its own — the replica-side writer against the
+ * resource it is bound to — and must reject the way the codec does.
+ */
+declare const invalidParameter: (collection: string, parameter: string, detail: string) => QueryError;
+/**
+ * Parse a collection's query parameters into a read. `include`, `fields`,
+ * `sort`, `page` and `filter` are decoded with the node-derived query codec
+ * (unknown filter fields, undeclared operators, literals of the wrong kind,
+ * unsortable fields, unknown sparse fields and nested include paths all
+ * fail with a `QueryError` naming the parameter) and mapped onto the read;
+ * `fields[]` rides beside it as the projection.
+ */
+declare const parseParams: (nodes: Node.NodeRegistry, collection: string, params: URLSearchParams | Readonly<Record<string, string | ReadonlyArray<string>>>) => Effect.Effect<ParsedRead, QueryError>;
+/**
+ * The query of a single-row read — `filter[id]=…`, first 1 (ADR-0029 §3) —
+ * from a `/{type}/{id}` request's own query, which takes `include` and
+ * `fields[…]` only. Shared by {@link parseRead} and the derived `get`
+ * handler, which has the id from the route instead of the path.
+ */
+declare const singleRowParams: (collection: string, id: string, params: URLSearchParams) => Effect.Effect<URLSearchParams, QueryError>;
+/**
+ * Parse a request URL into a read. The collection is the path's last
+ * segment that names a node (`/api/products?…`, any prefix), or the
+ * segment before a row id (`/api/products/p-1?…`, which reads as
+ * `filter[id]=p-1` with `first` 1). The query is then {@link parseParams}.
+ */
+declare const parseRead: (nodes: Node.NodeRegistry, url: string | URL) => Effect.Effect<ParsedRead, QueryError>;
+/**
+ * The canonical URL of a read — `/{collection}?{query}` (no API prefix;
+ * `parseRead` accepts it back) — through effect-jsonapi's canonical encoder
+ * over the compiled plan: one string per plan, whatever spelling the read
+ * used (`where` as a map or a predicate, conjuncts in any order, `True`
+ * conjuncts). It is the subscription identity of ADR-0029 §2. Throws a
+ * `QueryError` for a read the plan or the grammar refuses: an unknown
+ * collection or edge, a field outside the filterable set, an `Exists`, a
+ * `null` literal, or a per-edge window. A `fields[]` projection rides
+ * along when given.
+ */
+declare const canonical: (nodes: Node.NodeRegistry, read: Query$1.Read, fields?: Projection) => string;
+/**
+ * The `Client.UrlReads` seam over this bridge (#159, ADR-0029 §2): pass as
+ * `urls` to `Client.make` / `Client.connect` / `Client.fromView` so
+ * `client.subscribe(url)` parses through {@link parseRead} and keys the pin
+ * by {@link canonical}, and to an engine host (`ServiceWorkerHost.run`) so
+ * a page with no Client can register by URL. The `fields[]` projection a
+ * URL carries is dropped: it never changes what a subscription syncs
+ * (ADR-0029 §5), so two URLs differing only in `fields[]` are one
+ * subscription.
+ */
+declare const urlReads: (nodes: Node.NodeRegistry) => Client.UrlReads;
+/**
+ * The canonical flat `filter[...]` record of a filter AST — the grammar's
+ * own encoder (`Query.Filter`), so the shorthand, the group form, escaping
+ * and member order are effect-jsonapi's byte for byte.
+ */
+declare const flatFilter: (ast: Filter.Node) => Readonly<Record<string, string>>;
+/**
+ * Build the JSON:API query string (with its leading `?`, or `` when empty)
+ * for `include` / `fields` / `filter` / `sort` / `page`, in the canonical
+ * family order and percent-encoding (`Query.serialise`). `filter` is a
+ * filter AST, encoded exactly through {@link flatFilter}.
+ */
+declare const buildQueryString: (options?: JsonApiRequestOptions) => string;
+/**
+ * Encode a subset into a JSON:API query string (incl. leading `?`, or ``),
+ * or `None` when no row can match it (the request is skipped). A predicate
+ * without a URL form is a `QueryError`: the backend fails closed.
+ */
+interface QueryEncoder {
+  readonly encode: (subset: Subset.Subset) => Effect.Effect<Option.Option<string>, QueryError>;
+}
+/**
+ * The request options a subset encodes to, or `None` when its predicate
+ * folds to false. The filter is the whole predicate, constants folded;
+ * `orderBy` becomes `sort`. Limit and cursor are not pushed: the window is
+ * applied locally over the exact filter. Throws a `QueryError` for a
+ * predicate with no URL form (`Exists`, a `null` literal).
+ */
+declare const toRequestOptions: (subset: Subset.Subset) => Option.Option<JsonApiRequestOptions>;
+/** The shipped encoder: exact under ADR-0028 (see the module doc). */
+declare const defaultEncoder: QueryEncoder;
+declare namespace CollectionLoader_d_exports {
+  export { CollectionRow, JsonApiSource, LoadedRows, RelationshipRef, ResourceValue$1 as ResourceValue, buildQueryString, documentToRows, load, loadOne, parseResponse, resourceToRow };
+}
+/** A relationship as it lands in a row value: linkage only, no documents. */
+type RelationshipRef = {
+  readonly type: string;
+  readonly id: string;
+} | ReadonlyArray<{
+  readonly type: string;
+  readonly id: string;
+}> | null;
+/** The value a JSON:API resource takes as a collection row. */
+interface ResourceValue$1 {
+  readonly type: string;
+  readonly id: string;
+  readonly attributes: Record<string, unknown>;
+  readonly relationships: Record<string, RelationshipRef>;
+}
+/** A collection row materialized from a resource: (collection, id, value). */
+interface CollectionRow {
+  readonly collection: string;
+  readonly id: string;
+  readonly value: ResourceValue$1;
+}
+/** The rows a document yields: its primary data and its compound `included`. */
+interface LoadedRows {
+  readonly rows: ReadonlyArray<CollectionRow>;
+  readonly included: ReadonlyArray<CollectionRow>;
+}
+/** Map a resource (or bare identifier) to a collection row. */
+declare const resourceToRow: (resource: ResourceObject | ResourceIdentifier) => CollectionRow;
+/** Map a whole document to its primary rows and its `included` rows. */
+declare const documentToRows: (document: JsonApiDocument) => LoadedRows;
+/** The JSON:API endpoint a loader reads from. */
+interface JsonApiSource {
+  readonly baseUrl: string;
+}
+/** The {@link JsonApiSource} service loaders read from. */
+declare const JsonApiSource: Context.Service<JsonApiSource, JsonApiSource>;
+/** Validate a JSON:API response into a document (non-2xx / `errors` → ApiError). */
+declare const parseResponse: (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<JsonApiDocument, ParseError | ApiError | HttpClientError.HttpClientError>;
+/** Load a collection (`GET /{type}`) into rows. */
+declare const load: (type: string, options?: JsonApiRequestOptions) => Effect.Effect<LoadedRows, ParseError | ApiError | HttpClientError.HttpClientError, HttpClient.HttpClient | JsonApiSource>;
+/** Load a single resource (`GET /{type}/{id}`); `undefined` if absent. */
+declare const loadOne: (type: string, id: string, options?: JsonApiRequestOptions) => Effect.Effect<CollectionRow | undefined, ParseError | ApiError | HttpClientError.HttpClientError, HttpClient.HttpClient | JsonApiSource>;
+declare namespace Convention_d_exports {
+  export { EndpointRef, Operation, ResourceEndpoints, ResourceMap, classify, isAtomicEndpoint, isParam, reflectAtomic, reflectResources, segmentsOf };
+}
+/** A JSON:API role a CRUD endpoint plays for one resource type. */
+type Operation = "list" | "getOne" | "create" | "update" | "delete";
+/** A reflected endpoint we can address on the app's HttpApi. */
+interface EndpointRef {
+  readonly groupId: string;
+  readonly name: string;
+  readonly method: string;
+  /** Route template as declared, e.g. `/todos/:id`. */
+  readonly path: string;
+}
+/** The CRUD endpoints discovered for one resource type (collection). */
+interface ResourceEndpoints {
+  readonly type: string;
+  readonly list?: EndpointRef;
+  readonly getOne?: EndpointRef;
+  readonly create?: EndpointRef;
+  readonly update?: EndpointRef;
+  readonly delete?: EndpointRef;
+}
+/** Resource endpoints keyed by type (collection name). */
+type ResourceMap = ReadonlyMap<string, ResourceEndpoints>;
+/** A route template's segments, empty ones dropped (`/todos/:id` is `["todos", ":id"]`). */
+declare const segmentsOf: (path: string) => ReadonlyArray<string>;
+/** Whether a template segment is a path parameter (`:id`). */
+declare const isParam: (segment: string) => boolean;
+/**
+ * Classify a (method, path) into a resource type + role, or `undefined` if
+ * it isn't a conventional JSON:API CRUD route — `/{type}` or `/{type}/:id`,
+ * where the type is a static segment and the only param is a trailing id
+ * (nested routes like `/todos/:id/comments` are not CRUD on a single type).
+ */
+declare const classify: (method: string, path: string) => {
+  readonly type: string;
+  readonly operation: Operation;
+} | undefined;
+/**
+ * Whether an endpoint takes an `atomic:operations` request document: some
+ * payload schema (any content type) is an object with a top-level
+ * `atomic:operations` member, possibly one arm of a union. This is what
+ * makes an endpoint the atomic operations endpoint — not its path, which is
+ * configurable.
+ */
+declare const isAtomicEndpoint: (endpoint: HttpApiEndpoint.Top) => boolean;
+/**
+ * Reflect an `HttpApi` into its JSON:API resource surface. The first endpoint
+ * matching each (type, role) wins; later duplicates are ignored. An atomic
+ * operations endpoint is never a resource (see `reflectAtomic`).
+ */
+declare const reflectResources: <Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>) => ResourceMap;
+/**
+ * Reflect an `HttpApi`'s atomic operations endpoint, if it declares one: the
+ * first endpoint whose request payload is an `atomic:operations` document.
+ * `JsonApiSync` uses it to push a batch as one all-or-nothing request.
+ */
+declare const reflectAtomic: <Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>) => EndpointRef | undefined;
+declare namespace Derive_d_exports {
+  export { CreateArgs, DeleteArgs, Derived, JsonApiRow, OperationInfo, RowSchema, UpdateArgs, collectionFor, derive, mutatorName, toRow };
+}
+/**
+ * The engine row for a JSON:API resource: attributes flattened to the top
+ * level so predicates and orderBy address them directly (e.g.
+ * `Predicate.eq("status", "open")`), exactly as JSON:API `filter[status]`
+ * does. The keys `id` and `relationships` are reserved.
+ */
+interface JsonApiRow {
+  readonly id: string;
+  readonly relationships: Record<string, RelationshipRef>;
+  readonly [field: string]: unknown;
+}
+/** Flatten a loaded resource into an engine row (attributes at top level). */
+declare const toRow: (value: ResourceValue$1) => JsonApiRow;
+/** Permissive codec for a row (the engine never decodes rows through it). */
+declare const RowSchema: Schema.Codec<JsonApiRow>;
+/** The collection for a resource type: rows keyed by resource id. */
+declare const collectionFor: (type: string) => Collection.Collection<JsonApiRow>;
+/** The mutator name for a (type, operation): `"{type}/{operation}"`. */
+declare const mutatorName: (type: string, operation: Operation) => string;
+/** Create: the full resource to insert (client supplies the id). */
+declare const CreateArgs: Schema.Struct<{
+  readonly type: Schema.String;
+  readonly id: Schema.String;
+  readonly attributes: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly relationships: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>;
+/** The type {@link CreateArgs} decodes to. */
+type CreateArgs = typeof CreateArgs.Type;
+/** Update: a partial attribute patch, merged over the current row. */
+declare const UpdateArgs: Schema.Struct<{
+  readonly type: Schema.String;
+  readonly id: Schema.String;
+  readonly attributes: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+/** The type {@link UpdateArgs} decodes to. */
+type UpdateArgs = typeof UpdateArgs.Type;
+/** Delete: address one row. */
+declare const DeleteArgs: Schema.Struct<{
+  readonly type: Schema.String;
+  readonly id: Schema.String;
+}>;
+/** The type {@link DeleteArgs} decodes to. */
+type DeleteArgs = typeof DeleteArgs.Type;
+/** Which CRUD operation a derived mutator performs, and on what type. */
+interface OperationInfo {
+  readonly operation: Operation;
+  readonly type: string;
+}
+/**
+ * What {@link derive} produces from a resource map: collections, mutators and their CRUD mapping.
+ */
+interface Derived {
+  readonly collections: ReadonlyArray<Collection.AnyCollection>;
+  /** Mutator definitions + client (optimistic) handlers. */
+  readonly registry: Mutator.MutatorRegistry;
+  /** Mutator name → CRUD operation + type, for the authoritative backend. */
+  readonly operations: ReadonlyMap<string, OperationInfo>;
+}
+/**
+ * Derive collections, CRUD mutators, and operation metadata from a resource
+ * map. A mutator is only derived when the resource exposes the corresponding
+ * write endpoint (no create endpoint ⇒ no `create` mutator).
+ */
+declare const derive: (resources: ResourceMap) => Derived;
+declare namespace DocumentWriter_d_exports {
+  export { CollectionDocument, DataDocument, Identifier, Input, Linkage, RelationshipValue, ResourceValue, collection, data, idOf, relatedValuesOf };
+}
+/** A resource identifier: `{ type, id }`. */
+interface Identifier {
+  readonly type: string;
+  readonly id: string;
+}
+/**
+ * A relationship object as written: inline linkage for `one` / `many`
+ * edges; links for a paginated edge, with its rows' linkage when resolved.
+ */
+type RelationshipValue = {
+  readonly data: Identifier | ReadonlyArray<Identifier> | null;
+} | {
+  readonly links: {
+    readonly self: string;
+    readonly related: string;
+  };
+  readonly data?: ReadonlyArray<Identifier>;
+};
+/** A resource object as written: the node's attributes and its edges' relationships. */
+interface ResourceValue {
+  readonly type: string;
+  readonly id: string;
+  readonly attributes: Readonly<Record<string, unknown>>;
+  readonly relationships?: Readonly<Record<string, RelationshipValue>>;
+}
+/** A collection document: `{ data: [...], included?, links }`, with `included` exactly when the read has an `include`. */
+type CollectionDocument = Handlers.DocumentValue<ReadonlyArray<ResourceValue>, ResourceValue>;
+/** A single-resource document: `{ data: resource | null, included?, links }`, with `included` exactly when the read has an `include`. */
+type DataDocument = Handlers.DocumentValue<ResourceValue | null, ResourceValue>;
+/** Edge rows by collection, then row id, then edge name (see {@link Input.linkage}). */
+type Linkage = ReadonlyMap<string, ReadonlyMap<string, Readonly<Record<string, ReadonlyArray<unknown>>>>>;
+/** What a document is a function of (ADR-0029 §6). */
+interface Input {
+  readonly nodes: Node.NodeRegistry;
+  /** The read as parsed from the URL — its `include` selects `included`, its plan is `links.self`. */
+  readonly read: Query$1.Read;
+  /**
+   * The read's resolved rows (`Query.runVia` / `Query.run`): root rows in
+   * window order, each with the edge rows resolved onto `related`. Edges
+   * beyond `read.include` may be present (the linkage plan resolves every
+   * declared `many` edge); they contribute linkage, not `included`.
+   */
+  readonly rows: ReadonlyArray<Related.RelatedRow>;
+  /**
+   * Collection-valued edge rows resolved for resources beyond the root rows
+   * — the included resources' own `many` edges — by collection, then row
+   * id, then edge name. Consulted where a row has no `related` entry for
+   * the edge; a parent listed with an empty array gets `data: []`.
+   */
+  readonly linkage?: Linkage;
+  /** The `fields[]` projection, applied to attributes at the end. */
+  readonly fields?: Projection;
+  /** Prepended to every link (the api's mount path, e.g. `/jsonapi`); default `""`. */
+  readonly prefix?: string;
+}
+/** The row id a row value carries (node rows carry `id` in the value). */
+declare const idOf: (value: unknown) => string;
+/** A resolved edge's value as its rows: a list as it is, a single row alone, `null` / `undefined` as none. */
+declare const relatedValuesOf: (value: Related.RelatedValue) => ReadonlyArray<unknown>;
+/**
+ * The collection document of a read: every row of its page as primary
+ * data, the included edges compounded, `links.self` canonical and
+ * `links.next` (and, for an offset read past the first page, `links.prev`)
+ * when the page is full. Throws for a read the canonical encoder refuses
+ * (a per-edge window, an `Exists`) — such a read has no URL, so it is
+ * never one a URL produced.
+ */
+declare const collection: (input: Input) => CollectionDocument;
+/**
+ * The single-resource document of a read: the first row as primary data
+ * (`null` when the read matched nothing — the caller decides the 404), the
+ * included edges compounded, `links.self` canonical.
+ */
+declare const data: (input: Input) => DataDocument;
+declare namespace Ledger_d_exports {
+  export { GroupLedger, LedgerStore, Rejection, emptyGroup, keyValue, memory };
+}
+/** A permanent rejection the ledger remembers: the mutation and the reason it was refused. */
+interface Rejection {
+  readonly clientId: string;
+  readonly mutationId: number;
+  readonly reason: string;
+}
+/** One client group's ledger, as a store holds it. */
+interface GroupLedger {
+  /** Highest acknowledged mutation id per client. */
+  readonly lastMutationIds: Readonly<Record<string, number>>;
+  /** The rejections still remembered, for replayed copies and pulls. */
+  readonly rejections: ReadonlyArray<Rejection>;
+}
+/** An empty group ledger: nothing acknowledged, nothing remembered. */
+declare const emptyGroup: GroupLedger;
+/**
+ * Where a `JsonApiBackend` reads and writes each client group's ledger (#468).
+ * `read` is called once per group when the backend first needs it; `write`
+ * replaces the group's stored ledger after each change, and only after the
+ * server has applied the writes the change acknowledges.
+ */
+interface LedgerStore {
+  /** The stored ledger of a client group, or {@link emptyGroup} when it has none. */
+  readonly read: (clientGroupId: string) => Effect.Effect<GroupLedger, BackendError>;
+  /** Replace a client group's stored ledger with `ledger`. */
+  readonly write: (clientGroupId: string, ledger: GroupLedger) => Effect.Effect<void, BackendError>;
+}
+/**
+ * The in-memory ledger store: it persists nothing, so the backend keeps each
+ * group's ledger in its own memory for the life of the instance. A restart of
+ * the backend forgets every acknowledged id and remembered rejection.
+ */
+declare const memory: LedgerStore;
+/**
+ * A ledger store over an Effect `KeyValueStore`: each client group's ledger is
+ * one JSON value under `${prefix}${clientGroupId}`. Use a durable key/value
+ * store (a file system, SQL or browser storage layer) for it to survive a
+ * restart. A stored value that does not decode is a `BackendError`, not an
+ * empty ledger, so a corrupt store is never mistaken for a fresh one.
+ */
+declare const keyValue: (store: KeyValueStore.KeyValueStore, options?: {
+  readonly prefix?: string | undefined;
+}) => LedgerStore;
+declare namespace JsonApiBackend_d_exports {
+  export { JsonApiBackendConfig, Write, make$2 as make, versionOf };
+}
+/**
+ * One JSON:API write — the unit both delivery paths speak: a create (`POST`,
+ * or atomic `add`), update (`PATCH` / `update`) or delete (`DELETE` /
+ * `remove`) of one resource. Creates carry the client-generated id.
+ */
+interface Write {
+  readonly operation: "create" | "update" | "delete";
+  readonly type: string;
+  readonly id: string;
+  readonly attributes?: Record<string, unknown>;
+  readonly relationships?: Record<string, unknown>;
+}
+/** Configuration for {@link make}. */
+interface JsonApiBackendConfig {
+  /** Base URL the resource paths are resolved against (no trailing slash). */
+  readonly baseUrl: string;
+  readonly resources: ResourceMap;
+  /** Mutator definitions, for decoding/validating pushed args. */
+  readonly mutators: ReadonlyMap<string, Mutator.AnyMutator>;
+  /** Mutator name → CRUD operation + type. */
+  readonly operations: ReadonlyMap<string, OperationInfo>;
+  /**
+   * Mutators beyond the derived CRUD ones, and how to express each one's
+   * decoded args as a single JSON:API `Write`. Consulted before `operations`,
+   * so an app can push its own named intents through this backend as long
+   * as each is one create/update/delete of one resource.
+   */
+  readonly writes?: ReadonlyMap<string, (args: unknown) => Write> | undefined;
+  /**
+   * The server's JSON:API Atomic Operations endpoint (`POST {path}`), when it
+   * has one. With it set, `applyMutations` pushes a whole batch as one
+   * all-or-nothing `atomic:operations` request; without it, each mutation is
+   * its own request. `JsonApiSync` fills this in from the reflected api
+   * (`Convention.reflectAtomic`).
+   */
+  readonly atomic?: {
+    readonly path: string;
+  } | undefined;
+  /** Subset → JSON:API query string. Defaults to the exact filter-grammar encoder. */
+  readonly query?: QueryEncoder | undefined;
+  /**
+   * Relationship names to compound-load per collection (`?include=...`). When a
+   * listing pulls in related resources, they are harvested so an auto-subscribed
+   * `id IN (...)` subset over those collections is served from the same response
+   * — no extra round trip. See `Relationships.related`.
+   */
+  readonly includes?: Readonly<Record<string, ReadonlyArray<string>>> | undefined;
+  /**
+   * Where each client group's ledger (its acknowledged mutation ids and
+   * remembered rejections) is kept across restarts (#468). Unset, the ledger
+   * lives in this instance's memory (`Ledger.memory`), so a restart forgets it.
+   * `Ledger.keyValue` over a durable Effect `KeyValueStore` keeps it.
+   */
+  readonly ledger?: LedgerStore | undefined;
+}
+/** A content-hash row version: a plain REST API exposes no version token. */
+declare const versionOf: (value: unknown) => string;
+/** Build the JsonApiBackend from its config; requires an `HttpClient`. */
+declare const make$2: (config: JsonApiBackendConfig) => Effect.Effect<Backend.Backend, never, HttpClient.HttpClient>;
+declare namespace FacadeWrites_d_exports {
+  export { Intent, IntentOf, InvalidWriteArgs, Preferences, Refusal, Target, decodeWrite, graphIntentOf, preferencesOf, writesOf };
+}
+/** The preferences a façade write reads from `Prefer` (RFC 7240 §4); others are forwarded untouched. */
+interface Preferences {
+  /** `Prefer: respond-async`: journal and answer a receipt even when online. */
+  readonly respondAsync: boolean;
+  /** `Prefer: handling=strict`: never journal. */
+  readonly strict: boolean;
+  /** `Prefer: wait=N`, in seconds, when present and a non-negative integer. */
+  readonly wait?: number;
+}
+/** Read the `Prefer` headers of a request (several headers and comma-separated lists alike). */
+declare const preferencesOf: (headers: Headers) => Preferences;
+/**
+ * Why a write's body cannot be journaled, as the error object an offline
+ * façade answers with (ADR-0030 §3): `400 invalid_document`, `409
+ * type_mismatch` / `id_mismatch`, `422 unsupported_relationship`, or the
+ * `client_id_required` a `POST` without an id meets.
+ */
+interface Refusal {
+  readonly status: 400 | 409 | 422 | 503;
+  readonly code: "invalid_document" | "type_mismatch" | "id_mismatch" | "unsupported_relationship" | "client_id_required";
+  readonly title: string;
+  readonly detail: string;
+  readonly pointer?: string;
+}
+/** What a write route matched: its operation, the route's type, and the path's id for `PATCH` / `DELETE`. */
+type Target = {
+  readonly operation: "create";
+  readonly type: string;
+} | {
+  readonly operation: "update" | "delete";
+  readonly type: string;
+  readonly id: string;
+};
+/**
+ * Decode a write's body structurally into a `Write` whose `relationships`
+ * are flattened into `one`-edge ids by relationship name (`null` clears).
+ * A `DELETE` reads no body. Fails with the {@link Refusal} the offline façade
+ * answers with; a create without a client id is refused only once the rest
+ * of its body has passed.
+ */
+declare const decodeWrite: (node: Node.AnyNode, target: Target, body: Effect.Effect<string, unknown>) => Effect.Effect<Write, Refusal>;
+/** The mutation a write is journaled as: a registered mutator name and its encoded args. */
+interface Intent {
+  readonly mutator: string;
+  readonly args: unknown;
+}
+/**
+ * The intent mapping (ADR-0030 §5): a decoded `Write` to the mutation the
+ * engine journals, or `undefined` when the write is not interceptable.
+ * `relationships` arrive flattened by {@link decodeWrite}: relationship name
+ * to related id (or `null`).
+ */
+type IntentOf = (write: Write) => Intent | undefined;
+/**
+ * The default intent mapping: the graph-derived CRUD mutations
+ * (`CrudMutation`), args in the graph row form — the attributes plus, per
+ * `one` edge the payload links, its `via` key.
+ */
+declare const graphIntentOf: (nodes: Node.NodeRegistry) => IntentOf;
+declare const InvalidWriteArgs_base: Schema.Class<InvalidWriteArgs, Schema.TaggedStruct<"InvalidWriteArgs", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** Graph-derived CRUD args that do not fit the mutation they were journaled under. */
+declare class InvalidWriteArgs extends InvalidWriteArgs_base {}
+/**
+ * The inverse of {@link graphIntentOf} (ADR-0030 §5): for every graph-derived
+ * CRUD mutation (`CrudMutation`, filtered by `options.writes` as the registry
+ * is), how its args replay as one JSON:API write. Pass it as a
+ * `JsonApiBackend`'s `writes`, so a node-graph app's journaled `{type}/create`,
+ * `{type}/update` and `{type}/delete` reach the server as `POST`, `PATCH` and
+ * `DELETE` (or atomic operations), with each `one` edge's `via` key rebuilt as
+ * the relationship's linkage. The write's `type` is always the mutation's own:
+ * args naming another type are refused ({@link InvalidWriteArgs}).
+ */
+declare const writesOf: (nodes: Node.NodeRegistry, options?: CrudMutation.Options) => NonNullable<JsonApiBackendConfig["writes"]>;
+declare namespace RestHandlers_d_exports {
+  export { CollectionDocumentOf, DataDocumentOf, ErrorDocument, GetInput, GetOptions, ListInput, Options$2 as Options, RestHandlers, make$1 as make, queryErrorDocument };
+}
+/** What the derived handlers run over: the graph, the read path's seams, and the request's identity. */
+interface Options$2 {
+  /** The node graph the URLs are parsed against and the rows are written by. */
+  readonly nodes: Node.NodeRegistry;
+  /** The storage contract the read evaluates through. */
+  readonly backend: Backend.Backend;
+  /** The deny-by-default auth policy, with the filterable declarations (#154). */
+  readonly policy: Authorization.AuthPolicy;
+  /**
+   * The identity seam: an HTTP request to the `SyncContext` the auth filters
+   * see — the HTTP analogue of `IdentityResolver`, which resolves a client
+   * group. Derive `identity` from the verified session (a forwarded header
+   * the app trusts, a session token); never from anything a browser can
+   * forge. `clientGroupId` names the carrier (`"http"`) or the session.
+   */
+  readonly context: (request: HttpServerRequest) => Effect.Effect<Backend.SyncContext, AuthorizationError>;
+  /** The interception seam around reads (`onRead`); absent means passthrough. */
+  readonly middleware?: Authorization.SyncMiddleware;
+  /** The api's mount path, prepended to every link (`/jsonapi`); default `""`. */
+  readonly prefix?: string;
+}
+/** The handler input a `list` endpoint gives (the rest of the request is not needed). */
+interface ListInput {
+  readonly request: HttpServerRequest;
+}
+/** The handler input a `get` endpoint gives: the `:id` path parameter and the request. */
+interface GetInput {
+  readonly params: {
+    readonly id: string;
+  };
+  readonly request: HttpServerRequest;
+}
+/** The collection document type of a resource's default `Endpoint.list` success. */
+type CollectionDocumentOf<R extends Resource.Any> = Document.CollectionDocument<R, Resource.DefaultIncluded<R["relationships"]>, typeof Document.AnyMeta>["Type"];
+/** The single-resource document type of a resource's default `Endpoint.get` success. */
+type DataDocumentOf<R extends Resource.Any> = Document.DataDocument<R, Resource.DefaultIncluded<R["relationships"]>, typeof Document.AnyMeta>["Type"];
+/** Options of a derived `get`: the endpoint's own 404. */
+interface GetOptions<E> {
+  /** The error to fail with when no row matches — the `ApiError` class the endpoint declares. */
+  readonly notFound: () => E;
+}
+/** The derived handler factories, bound to one graph and one read path. */
+interface RestHandlers {
+  /**
+   * The `list` handler of a resource: `GET /{type}?…` as a read over the
+   * node of the same type. Typed as the resource's default collection
+   * document; the endpoint's success encoder checks the document at
+   * runtime, so a resource whose declaration disagrees with the node graph
+   * (an attribute the node calls an edge) fails there, not silently.
+   */
+  readonly list: <R extends Resource.Any>(resource: R) => (input: ListInput) => Effect.Effect<CollectionDocumentOf<R> | HttpServerResponse.HttpServerResponse>;
+  /**
+   * The `get` handler of a resource: `GET /{type}/{id}?…` as the read
+   * `filter[id]={id}`, first 1, taking `include` and `fields[…]` only.
+   */
+  readonly get: <R extends Resource.Any, E>(resource: R, options: GetOptions<E>) => (input: GetInput) => Effect.Effect<DataDocumentOf<R> | HttpServerResponse.HttpServerResponse, E>;
+}
+/** A JSON:API error document value (the shape `ApiError.toDocument` produces). */
+type ErrorDocument = typeof ApiError$1.WireDocument.Type;
+/**
+ * The 400 error document of a URL the grammar rejects: the codec's own
+ * document (`Middleware.schemaErrorDocument`, one error object per issue,
+ * each with `source.parameter`) when the rejection came from decoding; the
+ * same shape around the `QueryError`'s message and `parameter` when it came
+ * from the graph checks that run before decoding (an undeclared include, a
+ * `fields[]` type the read cannot carry). The façade answers a parse failure
+ * with this document too (ADR-0029 §1).
+ */
+declare const queryErrorDocument: (error: QueryError) => ErrorDocument;
+/**
+ * Bind the derived handlers to a graph and a read path. The node of a
+ * resource is looked up by its `type` when the handler is built and the
+ * resource's relationships are checked against the node's edges then, so a
+ * declaration the graph cannot serve is a definition-time defect, never a
+ * 500.
+ */
+declare const make$1: (options: Options$2) => RestHandlers;
+declare namespace JsonApiFacade_d_exports {
+  export { FetchHandler, Options$1 as Options, fetchHandler, offlineDocument, offlineResponse, servedAtHeader };
+}
+/** What the façade is built from: the api's routes, the graph, the replica and its ledger. */
+interface Options$1<Id extends string, Groups extends HttpApiGroup.Constraint> {
+  /** The node graph URLs are parsed against and documents are written by. */
+  readonly nodes: Node.NodeRegistry;
+  /**
+   * The app's api; its `list` / `getOne` routes (the api's own prefix
+   * included) whose type is a node of the graph are what the façade
+   * recognises. Its read endpoints must be declared with the graph's codec
+   * (the module doc's parity assumption).
+   */
+  readonly api: HttpApi.HttpApi<Id, Groups>;
+  /**
+   * Where the api is served as the browser sees it, in front of the routes
+   * the api declares: an origin (`https://api.example.com`), an
+   * origin-relative path (`/proxy`), or `""` (default) for the page's own
+   * origin with no extra path.
+   */
+  readonly baseUrl?: string;
+  /** The replica a covered read runs over: `ClientView.fromEngine(engine)` in a worker, `client.view` over a Client. */
+  readonly view: ClientView.Reader;
+  /**
+   * The ledger's verdict for a read — `client.coverageOf`, or
+   * `Coverage.coverageOf(nodes, view.query, host.registrations)` over the registrations
+   * an `EngineHost` holds on mirrors' behalf. A request is answered locally
+   * only when every read it needs is covered. `options.snapshot` is the root
+   * rows the façade read for the request, with their subset: the verdict is
+   * judged over them for that subset (#426), and any other read is judged as usual.
+   */
+  readonly coverageOf: (read: Query$1.Read, options?: Coverage.JudgeOptions) => Effect.Effect<Coverage.Verdict>;
+  /**
+   * The replica's CVR cookie, for `x-legation-served-at` — the store's
+   * `getCookie`, read only when a response is synthesised. Absent, or
+   * failing, the header is empty.
+   */
+  readonly cookie?: Effect.Effect<string | undefined, unknown>;
+  /**
+   * The resource declarations linkage follows — those the api's endpoints
+   * are declared with, so the replica writes the relationships the server
+   * writes. Default: the graph's synthetic resources (see `ReplicaDocuments`).
+   */
+  readonly resources?: ReadonlyMap<string, Resource.Any>;
+  /**
+   * The prefix of every link in a document. Default: the matched route's
+   * own prefix (`/jsonapi` for a route `/jsonapi/products`), which is what
+   * a server mounting the api at its declared prefix writes.
+   */
+  readonly prefix?: string;
+  /** Whether the network is reachable; default `navigator.onLine !== false` (reachable where there is no `navigator`). */
+  readonly online?: () => boolean;
+  /**
+   * The engine's journal seam for façade writes (ADR-0030 §5): in a worker,
+   * `host.engine.mutateWithAck`. Absent, the façade intercepts no write: a
+   * `POST` / `PATCH` / `DELETE` is never its business, as before ADR-0030.
+   */
+  readonly mutate?: (mutator: string, args: unknown) => Effect.Effect<ClientEngine.MutationHandle, MutatorError | StoreError>;
+  /**
+   * The intent mapping: a decoded write to the mutation the engine journals,
+   * or `undefined` when it is not interceptable. Default: the graph-derived
+   * CRUD mutations (`CrudMutation`, `FacadeWrites.graphIntentOf`), which the
+   * engine's registry must then carry (`CrudMutation.entries(nodes)`), with a
+   * server handler under each name.
+   */
+  readonly intentOf?: IntentOf;
+  /**
+   * Which reflected write routes may be intercepted, per type: owning this
+   * declaration means owning the server's side of it (handlers under the
+   * mutation names, creates that honour the client id, ADR-0030 §4).
+   * Default: every reflected `create` / `update` / `delete` route of a type
+   * the graph declares.
+   */
+  readonly writes?: CrudMutation.Writes;
+  /**
+   * The pull to signal after a write forwarded online succeeded
+   * ({@link FetchHandler.forwarded}): in a worker, `host.engine.pull`. Its
+   * failure is ignored; the sync loop pulls again on its own.
+   */
+  readonly pull?: Effect.Effect<unknown, unknown>;
+  /**
+   * The engine's mutation-state map (`engine.mutationStates`, #116), which
+   * the mutation status URL `{prefix}/_legation/mutations/{mutationId}` is
+   * answered from (ADR-0030 §2, `MutationStatus`). Absent, that route is not
+   * the façade's. A worker composing the façade should raise the engine's
+   * `mutationStateRetention.maxTerminal`, so a settled phase outlives a busy
+   * session.
+   */
+  readonly mutationStates?: Stream.Stream<MutationState.MutationStateMap>;
+  /** The cap on a status request's `Prefer: wait`; default 30 seconds. */
+  readonly maxWait?: Duration.Input;
+}
+/** The built façade. */
+interface FetchHandler {
+  /**
+   * Whether a request is the façade's business: a `GET` accepting
+   * `application/vnd.api+json` on a reflected read route under `baseUrl`,
+   * or — with {@link Options.mutate} set — a `POST` / `PATCH` / `DELETE` on a
+   * reflected write route the façade may intercept, accepting the media
+   * type and (for `POST` / `PATCH`) sending it without the atomic extension
+   * (ADR-0030 §3). A worker asks it for every method, clones a matched
+   * write before forwarding it, and turns a forward that rejected at the
+   * transport into {@link FetchHandler.offline}.
+   */
+  readonly matches: (request: Request) => boolean;
+  /**
+   * The façade's answer: a document (200), the codec's 400 for a URL the
+   * grammar rejects, the 503 `offline` document for an uncovered request
+   * while offline, a `202` write receipt for a write it journals (offline,
+   * or on `Prefer: respond-async`) — or `undefined` when the request is not
+   * the façade's business, is uncovered and online, or is a write to
+   * forward, for the caller to forward unchanged. A write's body is read
+   * from a clone, so the request itself can still be forwarded. A store
+   * failure while reading the replica is a defect, as `Query.run` treats it.
+   */
+  readonly handle: (request: Request) => Effect.Effect<Response | undefined>;
+  /**
+   * What a worker answers when the forward of a request {@link matches} held
+   * for rejected at the transport, the other half of ADR-0029 §4's
+   * definition: for a write, the request is journaled and answered with a
+   * `202` receipt (pass the clone taken before forwarding, whose body is
+   * unread); otherwise, or when the write cannot be journaled, the 503
+   * `offline` response with the replica's current cookie.
+   */
+  readonly offline: (request: Request) => Effect.Effect<Response>;
+  /**
+   * Tell the façade what a forwarded request came back with: after a `2xx`
+   * to a write it {@link matches}, it signals {@link Options.pull} so a
+   * covered read soon shows the server's row (ADR-0030 §3). A worker runs it
+   * in the background (`event.waitUntil`); it never fails.
+   */
+  readonly forwarded: (request: Request, response: Response) => Effect.Effect<void>;
+}
+/** The header a locally served response carries: the replica's CVR cookie at the time of the answer. */
+declare const servedAtHeader = "x-legation-served-at";
+/** The 503 error document of an uncovered request while offline (ADR-0029 §4). */
+declare const offlineDocument: ErrorDocument;
+/** The 503 response of an uncovered request while offline, marked with the cookie when known. */
+declare const offlineResponse: (cookie?: string) => Response;
+/**
+ * Build the façade over an api and a replica. Route reflection and the
+ * writer's declaration checks run here, so a declaration the graph cannot
+ * serve is a definition-time defect, never a response.
+ */
+declare const fetchHandler: <Id extends string, Groups extends HttpApiGroup.Constraint>(options: Options$1<Id, Groups>) => FetchHandler;
+declare namespace JsonApiSync_d_exports {
+  export { JsonApi, JsonApiSyncOptions, inspect, layer, start };
+}
+/**
+ * An app's JSON:API surface defined with Effect `HttpApi`, with its identifier
+ * and group types erased. `HttpApi`'s group parameter is invariant, so the
+ * entry points below are generic over the concrete api rather than accepting
+ * this alias directly.
+ */
+type JsonApi = HttpApi.Constraint;
+/** Options for {@link layer}. */
+interface JsonApiSyncOptions {
+  /** Base URL the resource paths resolve against (no trailing slash). */
+  readonly baseUrl: string;
+  /** This client's id (stable per device/tab). */
+  readonly clientId: string;
+  /** The client group this client belongs to (shared journal scope). */
+  readonly clientGroupId: string;
+  /** Override the Subset → JSON:API query encoding (e.g. your own package). */
+  readonly queryEncoder?: QueryEncoder | undefined;
+  /**
+   * Relationship names to compound-load per collection (`?include=...`), so
+   * `Relationships.related` resolves them without extra round trips.
+   */
+  readonly includes?: Readonly<Record<string, ReadonlyArray<string>>> | undefined;
+  /**
+   * Where the backend keeps its ledger (acknowledged mutation ids and remembered
+   * rejections) across restarts (#468). Unset, it is `Ledger.keyValue` over
+   * `keyValueStore` when that is given, and otherwise in memory, where a restart
+   * of the backend forgets it. A durable ledger needs a durable client store too
+   * (`keyValueStore` or `store`): with the in-memory store, a reload restarts the
+   * client's mutation ids at 1, the ledger already acknowledges them, and the
+   * backend skips the new writes as already applied, with no error.
+   */
+  readonly ledger?: LedgerStore | undefined;
+  /**
+   * The durable Effect `KeyValueStore` the client store is built over (#468). When
+   * it is set, the client store defaults to `ClientStore.layerKeyValue()` over it
+   * (unless `store` is given), and the ledger defaults to `Ledger.keyValue` over it
+   * (unless `ledger` is given), so one key/value store keeps the journal and the
+   * ledger across a reload. A `store` given with it must be built over this same
+   * key/value store: `store` is an opaque layer, so the layer cannot check that.
+   */
+  readonly keyValueStore?: KeyValueStore.KeyValueStore | undefined;
+  /**
+   * Atomic operations. When the api advertises the JSON:API Atomic Operations
+   * extension (an endpoint taking an `atomic:operations` document, e.g.
+   * effect-jsonapi's `Endpoint.operations`), the backend pushes each batch as
+   * one all-or-nothing request to it — detected from the api by default.
+   * Pass `false` to keep one request per mutation, or `{ path }` to name the
+   * endpoint explicitly (an api that serves it outside the reflected
+   * `HttpApi`).
+   */
+  readonly atomic?: false | {
+    readonly path: string;
+  } | undefined;
+  /**
+   * Periodic pull interval — the correctness backstop that picks up changes
+   * made elsewhere ("realtime" is periodic pull for client-direct deployment).
+   * Defaults to 5 seconds; set to `null` to disable interval pulling.
+   */
+  readonly pullInterval?: Duration.Input | null | undefined;
+  /**
+   * Auto-push debounce window. When set, mutations are pushed automatically
+   * (coalesced) without an app-level `push` call.
+   */
+  readonly pushDebounce?: Duration.Input | undefined;
+  /**
+   * The client store backing the engine. Defaults to `ClientStore.layerKeyValue()`
+   * over `keyValueStore` when that is given, and otherwise to the in-memory store.
+   * A durable store (e.g. `IndexedDbClientStore.layerWindow()` from
+   * `@thomasfosterau/legation-browser`, or `ClientStore.layerKeyValue` over localStorage)
+   * keeps the journal and confirmed rows across reloads (offline-first). It needs
+   * a durable ledger too: pass `keyValueStore` (the key/value store it is built
+   * over) or `ledger`. With the in-memory ledger, a reload forgets the
+   * acknowledged ids, and the backend refuses every later push with a
+   * mutation-id gap.
+   */
+  readonly store?: Layer.Layer<ClientStore.ClientStore> | undefined;
+}
+/**
+ * Reflect + derive an api's resources, collections, mutators, operations —
+ * and its atomic operations endpoint, when it declares one.
+ */
+declare const inspect: <Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>) => {
+  readonly resources: ResourceMap;
+  readonly atomic?: EndpointRef;
+} & Derived;
+/**
+ * The full client-direct stack as a layer: provide an `HttpClient`, get a
+ * ready `ClientEngine`. CVR store and invalidation bus are in-process; the
+ * client store defaults to in-memory, or to the durable store over
+ * `keyValueStore` (pass it for offline persistence and a durable ledger across
+ * reloads, or pass `store` and `ledger` for another durable store).
+ */
+declare const layer: <Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>, options: JsonApiSyncOptions) => Layer.Layer<ClientEngine.ClientEngine, never, HttpClient.HttpClient>;
+/**
+ * Start syncing: run the engine's sync loop. Interval pull, push-on-mutate,
+ * pull-on-poke and push+pull-on-reconnect are all scheduled by the core loop
+ * (configure the interval/debounce on `layer`'s options). Requires a `Scope` —
+ * fork it into the app's runtime and the fibers live until the scope closes.
+ */
+declare const start: Effect.Effect<void, never, ClientEngine.ClientEngine | Scope.Scope>;
+declare namespace MutationStatus_d_exports {
+  export { StatusDocument, StatusResource, current, defaultMaxWait, document, parseId, resourceType, segment, settled, unknownDocument };
+}
+/** The JSON:API type of a status resource; `_legation` and this type are never an app's. */
+declare const resourceType = "legation-mutations";
+/** The path segments of the status route after the api prefix: `/_legation/mutations/{id}`. */
+declare const segment = "_legation";
+/** The default cap on `Prefer: wait`: a `respondWith` promise must not outlive the worker's patience. */
+declare const defaultMaxWait: Duration.Input;
+/** The status resource of one tracked mutation. */
+interface StatusResource {
+  readonly type: typeof resourceType;
+  readonly id: string;
+  readonly attributes: {
+    readonly phase: MutationState.MutationPhase;
+    readonly mutator: string;
+    readonly journaledAt: number;
+    readonly settledAt?: number;
+    readonly reason?: string;
+  };
+  readonly links: {
+    readonly self: string;
+    readonly resource?: string;
+  };
+}
+/** The `200` document of the status URL: one status resource. */
+interface StatusDocument {
+  readonly data: StatusResource;
+}
+/** The status document of a tracked mutation; `prefix` is where the api is mounted, as links see it. */
+declare const document: (nodes: Node.NodeRegistry, prefix: string, state: MutationState.MutationState) => StatusDocument;
+/** The `404 unknown_mutation` error document. */
+declare const unknownDocument: (id: string) => ErrorDocument;
+/** A mutation id as the route carries it: a positive integer, or none. */
+declare const parseId: (raw: string) => Option.Option<number>;
+/** One mutation's state now, from the engine's map stream (it emits the current map first). */
+declare const current: (states: Stream.Stream<MutationState.MutationStateMap>, mutationId: number) => Effect.Effect<Option.Option<MutationState.MutationState>>;
+/**
+ * The mutation's state once it leaves `pending` (or is no longer tracked),
+ * or as it is when `wait` elapses first.
+ */
+declare const settled: (states: Stream.Stream<MutationState.MutationStateMap>, mutationId: number, wait: Duration.Duration) => Effect.Effect<Option.Option<MutationState.MutationState>>;
+declare namespace NodeBridge_d_exports {
+  export { FromResourceOptions, InversesAnnotation, KindsAnnotation, ResourceBridgeError, SyncAnnotationRecord, SyncAnnotations, fromResource, registry, syncAnnotations };
+}
+declare const ResourceBridgeError_base: Schema.Class<ResourceBridgeError, Schema.TaggedStruct<"ResourceBridgeError", {
+  readonly resource: Schema.String;
+  readonly relationship: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** A definition-time mismatch between a resource graph and the node model. */
+declare class ResourceBridgeError extends ResourceBridgeError_base {}
+/** The annotation key naming the inverse edge of collection relationships, by relationship name. */
+declare const InversesAnnotation = "@legation/inverses";
+/** The annotation key naming the literal kind of filterable fields, by row field. */
+declare const KindsAnnotation = "@legation/kinds";
+/** The sync metadata a resource can declare about itself (#220). */
+interface SyncAnnotations {
+  /**
+   * The inverse edge name on the target, by `many` / `paginated` relationship
+   * name — needed only where discovery is ambiguous or impossible.
+   */
+  readonly inverses?: Readonly<Record<string, string>>;
+  /**
+   * The literal kind of a filterable field, by row field, where its schema
+   * cannot tell it: an `instant` stored as text. The field must be declared
+   * filterable on the resource.
+   */
+  readonly kinds?: Readonly<Record<string, FilterPolicy.LiteralKind>>;
+}
+/** {@link SyncAnnotations} as resource annotations, under the bridge's keys. */
+type SyncAnnotationRecord = {
+  readonly [InversesAnnotation]?: SyncAnnotations["inverses"];
+  readonly [KindsAnnotation]?: SyncAnnotations["kinds"];
+};
+/**
+ * The resource annotations that declare `sync`, to pass as (or merge into)
+ * `Resource.make`'s `annotations` or `Resource.annotate`'s.
+ */
+declare const syncAnnotations: (sync: SyncAnnotations) => SyncAnnotationRecord;
+/** Per-resource overrides for {@link fromResource} / {@link registry}. */
+interface FromResourceOptions {
+  /**
+   * The foreign-key field a `one`/`optional` relationship's edge stores its
+   * id in, by relationship name. Defaults to `` `${name}Id` ``.
+   */
+  readonly via?: Record<string, string>;
+  /**
+   * One-edges beyond the resource's relationships, by edge name — promote
+   * a foreign-key **attribute** to an edge when the resource graph is
+   * acyclic and could not declare the relationship itself (see the module
+   * doc). The attribute named by `via` moves out of the node's attributes;
+   * the edge's key field replaces it.
+   */
+  readonly edges?: Record<string, {
+    readonly target: string;
+    readonly via: string;
+  }>;
+  /**
+   * The inverse edge name on the target, by relationship name — required
+   * only when discovery is ambiguous (the target has several one-edges
+   * back) or impossible (it has none).
+   */
+  readonly inverses?: Record<string, string>;
+  /**
+   * The edge order for `paginated` relationships, by relationship name
+   * (field names, `-` prefixed for descending). Required for every
+   * `paginated` relationship — order is part of the edge's identity.
+   */
+  readonly order?: Record<string, ReadonlyArray<string>>;
+  /** Passed through to the node (fine fan-out topics — ADR-0023). */
+  readonly hintKeys?: ReadonlyArray<string>;
+  /**
+   * Overrides and additions to the resource's own filterable declaration
+   * (ADR-0028, #154; see the module doc), by row field: the operators
+   * alone (the literal kind is derived from the attribute schema), or
+   * `{ operators, kind }` where the schema cannot tell the kind (an
+   * `instant` stored as text). An entry replaces the resource's declaration
+   * for that field. `id` and every bridged one-edge's key field are
+   * filterable by `eq` / `in` regardless.
+   */
+  readonly filterable?: Record<string, FilterPolicy.FilterableInput>;
+  /** Sortable fields beyond the resource's `Sort.able` declaration; `id` is always sortable. */
+  readonly sortable?: ReadonlyArray<string>;
+}
+/**
+ * Derive a {@link Node} definition from a single JSON:API resource
+ * definition. Inverse discovery here sees only the target resource's own
+ * relationships — bridge a whole graph with {@link registry} to discover
+ * across option-declared edges too.
+ */
+declare const fromResource: (resource: Resource.Any, options?: FromResourceOptions) => Node.AnyNode;
+/**
+ * Bridge a whole resource graph and close it as a validated
+ * {@link Node.NodeRegistry} — nodes plus the derived engine
+ * `CollectionRegistry`, ready for `Client.make` / `Server.make`.
+ * Options are keyed by resource type.
+ */
+declare const registry: (resources: ReadonlyArray<Resource.Any>, options?: Record<string, FromResourceOptions>) => Node.NodeRegistry;
+declare namespace Relationships_d_exports {
+  export { Lookup, RelatedRow, RelatedValue, hydrate, observe, query, related, resolve };
+}
+/** A resolved relationship: a row, a list of rows, `null`, or `undefined`. */
+type RelatedValue = JsonApiRow | ReadonlyArray<JsonApiRow> | null | undefined;
+/** A base row with its named relationships resolved against the mirror. */
+interface RelatedRow {
+  readonly id: string;
+  readonly value: JsonApiRow;
+  readonly related: Record<string, RelatedValue>;
+}
+/** Look up a row by (collection, id) from the local mirror. */
+type Lookup = (collection: string, id: string) => JsonApiRow | undefined;
+/** Resolve one relationship of a row against a lookup (linkage → value[s]). */
+declare const resolve: (lookup: Lookup, value: JsonApiRow, name: string) => RelatedValue;
+/** Resolve several named relationships of a row. */
+declare const hydrate: (lookup: Lookup, value: JsonApiRow, names: ReadonlyArray<string>) => Record<string, RelatedValue>;
+/**
+ * Resolve a subset's rows together with their named relationships, reading the
+ * referenced collections from the engine's local view. Delegates to
+ * {@link Related.queryWith} with the linkage strategy.
+ */
+declare const query: (engine: ClientEngine.ClientEngine, subset: Subset.Subset, names: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<RelatedRow>, never, never>;
+/**
+ * Live version of {@link query} as an incrementally-maintained join. Delegates
+ * to {@link Related.observeWith}: a write to a referenced row re-hydrates the
+ * join without re-querying the base; a base change that shifts referenced
+ * collections re-establishes the observers.
+ */
+declare const observe: (engine: ClientEngine.ClientEngine, subset: Subset.Subset, names: ReadonlyArray<string>) => Stream.Stream<ReadonlyArray<RelatedRow>, never, never>;
+/**
+ * Auto-subscribing relational read: subscribes the base subset and the narrowed
+ * `id IN (...)` subsets of each referenced collection, tracks the live linkage,
+ * and tears the subscriptions down when the scope closes. Delegates to
+ * {@link Related.relatedWith}. Pair with the backend's `includes` config to
+ * deliver the related rows in the parent's response (no extra round trip).
+ */
+declare const related: (engine: ClientEngine.ClientEngine, subset: Subset.Subset, names: ReadonlyArray<string>) => Effect.Effect<Stream.Stream<ReadonlyArray<RelatedRow>, never, never>, never, Scope.Scope>;
+/** A batch of subsets evaluated to rows — the row source a read runs over. */
+type Fetch<E> = (subsets: ReadonlyArray<Subset.Subset>) => Effect.Effect<ReadonlyArray<Related.SourcedRow>, E>;
+declare namespace ReplicaDocuments_d_exports {
+  export { Document$1 as Document, Options, ReplicaDocuments, fetchOf, make };
+}
+/** What the replica-side writer is bound to: the graph, the declarations linkage follows, the link prefix. */
+interface Options {
+  /** The node graph URLs are parsed against, reads compile through and rows are written by. */
+  readonly nodes: Node.NodeRegistry;
+  /**
+   * The resource declarations linkage follows, by type — the resources the
+   * app's REST endpoints are declared with, so the replica emits exactly
+   * the relationships the derived REST handler emits. Default: the node
+   * graph's synthetic resources (`JsonApiQuery.resourcesOf(nodes)`), every
+   * collection edge resolved. Every resource is checked against its node
+   * when the writer is built; a read on a type no resource declares fails
+   * with a `QueryError`.
+   */
+  readonly resources?: ReadonlyMap<string, Resource.Any>;
+  /** The api's mount path, prepended to every link (`/jsonapi`); default `""`. */
+  readonly prefix?: string;
+}
+/** A document a URL yields: a collection document for `/{type}`, a single-resource document for `/{type}/{id}`. */
+type Document$1 = CollectionDocument | DataDocument;
+/** The replica-side writer, bound to one graph and one set of declarations. */
+interface ReplicaDocuments {
+  /**
+   * Run a parsed read over the view and write its collection document.
+   * Fails with a `QueryError` for a collection no bound resource declares,
+   * or an `include` / `fields[type]` the bound resource does not declare.
+   */
+  readonly collection: (view: ClientView.Reader, parsed: ParsedRead) => Effect.Effect<CollectionDocument, QueryError>;
+  /**
+   * Run a parsed read over the view and write its single-resource document:
+   * the first row, or `data: null` when the replica holds no matching row
+   * (the caller decides the 404). Fails as {@link ReplicaDocuments.collection}.
+   */
+  readonly data: (view: ClientView.Reader, parsed: ParsedRead) => Effect.Effect<DataDocument, QueryError>;
+  /**
+   * Parse a URL (`JsonApiQuery.parseRead`: the read and its `fields[]`
+   * projection together) and write the document it addresses — a
+   * single-resource document for `/{type}/{id}`, a collection document
+   * otherwise. Fails with the `QueryError` the grammar gives, naming the
+   * parameter, for a URL the server would reject the same way; and as
+   * {@link ReplicaDocuments.collection} for what the bound resource does
+   * not declare.
+   */
+  readonly fromUrl: (view: ClientView.Reader, url: string | URL) => Effect.Effect<Document$1, QueryError>;
+  /**
+   * The reads a request needs covered for its document to be faithful: the
+   * read as stated, then one whole-collection read per collection the
+   * declared linkage resolves from beyond the read's includes (see the
+   * module doc). The caller checks each with `Client.coverageOf`. Fails
+   * with a `QueryError` for a collection no bound resource declares — a
+   * request the façade sends to the network.
+   */
+  readonly toCover: (read: Query$1.Read) => Effect.Effect<ReadonlyArray<Query$1.Read>, QueryError>;
+}
+/**
+ * The local view as a row source: each subset evaluated over the replica
+ * (confirmed rows with the optimistic overlay), rows tagged with their
+ * collection, batches concatenated in subset order — the shape
+ * `SyncServer.readSubsets` gives the REST tier. The subsets of a batch are
+ * independent, so they run concurrently. A store failure is a defect, as
+ * `Query.run` treats it.
+ */
+declare const fetchOf: (view: ClientView.Reader) => Fetch<never>;
+/** Bind the replica-side writer to a graph and its declarations (a definition-time check of every declaration). */
+declare const make: (options: Options) => ReplicaDocuments;
+export { CollectionLoader_d_exports as CollectionLoader, Convention_d_exports as Convention, Derive_d_exports as Derive, DocumentWriter_d_exports as DocumentWriter, FacadeWrites_d_exports as FacadeWrites, JsonApiBackend_d_exports as JsonApiBackend, type JsonApiDocument, type JsonApiError, JsonApiFacade_d_exports as JsonApiFacade, JsonApiQuery_d_exports as JsonApiQuery, type JsonApiRequestOptions, schema_d_exports as JsonApiSchema, JsonApiSync_d_exports as JsonApiSync, Ledger_d_exports as Ledger, type LinkObject, type Links, MutationStatus_d_exports as MutationStatus, NodeBridge_d_exports as NodeBridge, type Relationship, Relationships_d_exports as Relationships, ReplicaDocuments_d_exports as ReplicaDocuments, type ResourceIdentifier, type ResourceObject, RestHandlers_d_exports as RestHandlers };
+//# sourceMappingURL=index.d.ts.map