@thomasfosterau/legation 0.0.0 → 0.1.0

package/dist/src-FWXpu_vP.js

@@ -0,0 +1,1082 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.js";
+import { $ as make$5, $t as apply, An as resolve, Bn as StoreError, Ct as makeMemory, D as make$6, En as registry$2, F as ofPlan, Gt as runPlanVia, Hn as UnknownCollectionError, Ht as edgeSelects, I as requestedOf, It as make$4, Kt as runRows, L as snapshotOf, Lt as registry$3, Mn as BackendError, Mt as transitionOf, Nn as DuplicateNameError, Pn as FilterDeclarationError, R as verdictOf, S as AuthPolicy, St as freezePending, T as SyncMiddleware, Tn as make$3, Ut as plan, Vn as TransportError, Vt as applyWindows, Wt as run, X as fromOrigin, at as offline, d as CvrStore, en as hash, et as resyncAttachedEngines, h as Backend, it as makeInMemory, k as fromEngine, kn as kindOf, m as makeMemoryStore, nn as parseOrder, nt as ServerHandler, o as makeWith, q as relatedKey, qt as tryPlan, s as InvalidationBus, tt as ClientTransport, u as makeInProcess, w as IdentityResolver, wt as Mutation, xt as StoredRow, yt as ClientStore, zn as QueryError, zt as QueryResolver } from "./MemoryBackend-DxP8t4ge.js";
+import * as Arr from "effect/Array";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import * as P from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import * as Stream from "effect/Stream";
+import * as Ref from "effect/Ref";
+import * as Exit from "effect/Exit";
+import * as R from "effect/Record";
+import * as Scope from "effect/Scope";
+import * as Semaphore from "effect/Semaphore";
+import * as Clock from "effect/Clock";
+// src/Node.ts
+/**
+* Node
+*
+* A typed resource (ADR-0022): scalar attributes plus {@link Edge}s to
+* other nodes. The Node definition is the single source of truth the rest
+* of the system derives from — its row schema (the identity attribute + its
+* attributes + the foreign-key fields its `one` edges declare), the
+* {@link Collection} the engine materializes, the joins and sync windows its
+* edges imply, and the fan-out **derivable set** (ADR-0023: `one`-edge keys
+* + declared `hintKeys`), and the **filterable set** (ADR-0028, #154: the
+* fields a client may filter or sort by, with their operators and kinds).
+*
+* Ids are branded per node type, so a `products` id cannot be passed where
+* a `categories` id is expected; `one`-edge fields carry the **target**
+* type's brand.
+*
+* A node's **identity attribute** is the attribute supplying its row id. It
+* defaults to a synthetic branded `id` added to the row, and a domain with
+* natural keys names one of its own attributes instead (`id: "username"`) —
+* so the key is stored once, not duplicated into an `id` nothing keeps equal
+* to it. Everything downstream reads the declared name: the derived
+* collection's id extractor, both ends of every edge's join (each resolved
+* from its own node, so the two ends may differ), and the filterable set a
+* client's `where` / `order` is admitted against. Row ids are strings on the
+* wire and in CVR bookkeeping either way (ADR-0008) — this names which
+* attribute supplies the string, nothing more.
+*
+* Edges reference targets by name; {@link registry} closes the graph and
+* validates it (targets exist, inverses resolve to a matching `one` edge),
+* then derives the engine's `CollectionRegistry` — so the existing engine,
+* `Related` joins, and auth filters consume Node definitions unchanged
+* while later ADR-0022 program steps move onto them directly.
+*/
+var Node_exports = /* @__PURE__ */ __exportAll({
+	Id: () => Id,
+	derivableSet: () => derivableSet,
+	make: () => make$2,
+	registry: () => registry$1
+});
+/** Create the branded id schema for a node type. */
+const Id = (type) => Schema.String.pipe(Schema.brand(`${type}/id`));
+/** Define a node type. */
+const make$2 = (type, options) => {
+	const edges = options.edges ?? {};
+	const id = Id(type);
+	const identity = options.id ?? "id";
+	if (options.id !== void 0) assertTextIdentity(type, options.id, options.attributes);
+	const viaFields = {};
+	Arr.forEach(Object.values(edges), (edge) => {
+		if (edge.kind === "one") viaFields[edge.via] = Id(edge.target);
+	});
+	const declaration = resolve({
+		collection: type,
+		attributes: options.attributes,
+		identity,
+		keyFields: [identity, ...Object.keys(viaFields)],
+		filterable: options.filterable,
+		sortable: options.sortable
+	});
+	const row = Schema.Struct({
+		...options.id === void 0 ? { id } : {},
+		...options.attributes,
+		...viaFields
+	});
+	return {
+		type,
+		id: identity,
+		attributes: options.attributes,
+		edges,
+		hintKeys: options.hintKeys ?? [],
+		indexes: options.indexes ?? [],
+		filterable: declaration.filterable,
+		sortable: declaration.sortable,
+		Id: id,
+		row
+	};
+};
+/**
+* A declared identity attribute must carry the row id, and a row id is a
+* string on the wire (ADR-0008) — so an attribute whose literal kind is
+* derivably something else is a definition defect, not a runtime surprise at
+* the filter boundary. A kind that cannot be derived at all passes: the
+* declaration is taken at its word, exactly as `filterable` does.
+*/
+const assertTextIdentity = (type, identity, attributes) => {
+	const attribute = attributes[identity];
+	const kind = attribute === void 0 ? void 0 : kindOf(attribute);
+	if (kind === void 0 || kind === "text") return;
+	throw new FilterDeclarationError({
+		collection: type,
+		field: identity,
+		message: `Node "${type}" declares "${identity}" as its identity attribute, but its literal kind is "${kind}"; a row id is a string`
+	});
+};
+/**
+* The fields of a node eligible for fine fan-out topics (ADR-0023): its
+* `one`-edge keys plus declared `hintKeys`. Declared on the node, so
+* topic registration and write-derivation cannot disagree.
+*/
+const derivableSet = (node) => {
+	const fields = new Set(node.hintKeys);
+	Arr.forEach(Object.values(node.edges), (edge) => {
+		if (edge.kind === "one") fields.add(edge.via);
+	});
+	return fields;
+};
+/** Resolve a collection-valued edge's key field from its inverse. */
+const inverseVia = (node, name, edge, nodes) => {
+	const target = nodes.get(edge.target);
+	if (target === void 0) throw new UnknownCollectionError({
+		from: node.type,
+		relationship: name,
+		collection: edge.target
+	});
+	const inverse = target.edges[edge.inverse];
+	if (inverse === void 0 || inverse.kind !== "one" || inverse.target !== node.type) throw new UnknownCollectionError({
+		from: node.type,
+		relationship: `${name} (inverse "${edge.inverse}" is not a one-edge back to ${node.type})`,
+		collection: edge.target
+	});
+	return inverse.via;
+};
+/**
+* The identity attribute of an edge's target — resolved per-node, because
+* the two ends of one edge may name different identities (`comments.author →
+* users.username` while `comments.article → articles.slug`).
+*/
+const identityOf = (node, name, target, nodes) => {
+	const resolved = nodes.get(target);
+	if (resolved === void 0) throw new UnknownCollectionError({
+		from: node.type,
+		relationship: name,
+		collection: target
+	});
+	return resolved.id;
+};
+/** Derive the engine collection for one node (registry context required). */
+const toCollection = (node, nodes) => {
+	const relationships = [];
+	Arr.forEach(Object.entries(node.edges), ([name, edge]) => {
+		if (edge.kind === "one") relationships.push({
+			name,
+			kind: "one",
+			collection: edge.target,
+			localField: edge.via,
+			foreignField: identityOf(node, name, edge.target, nodes)
+		});
+		else relationships.push({
+			name,
+			kind: edge.kind,
+			collection: edge.target,
+			localField: node.id,
+			foreignField: inverseVia(node, name, edge, nodes),
+			...edge.kind === "paginated" ? { order: parseOrder(edge.order) } : {}
+		});
+	});
+	return make$3({
+		name: node.type,
+		schema: node.row,
+		id: (value) => value[node.id] ?? "",
+		identity: node.id,
+		relationships,
+		...Arr.isReadonlyArrayNonEmpty(node.indexes) ? { indexes: node.indexes } : {},
+		filterable: node.filterable,
+		sortable: node.sortable
+	});
+};
+/**
+* Every field of a node's row: its identity attribute, its attributes, its
+* `one`-edge keys. A declared identity is one of the attributes already; an
+* undeclared one is the synthetic `id`.
+*/
+const rowFields = (node) => {
+	const fields = /* @__PURE__ */ new Set([node.id, ...Object.keys(node.attributes)]);
+	Arr.forEach(Object.values(node.edges), (edge) => {
+		if (edge.kind === "one") fields.add(edge.via);
+	});
+	return fields;
+};
+/**
+* A paginated edge's declared `order` is what its per-parent windows sort
+* the **target** by (ADR-0024), so those fields join the target's
+* `sortable` here — declared on the node graph, so window registration and
+* the filterable set cannot disagree (as `one`-edge keys are `eq` / `in`).
+* An order field the target's row does not carry is a definition defect.
+*/
+const withEdgeOrders = (node, definitions) => {
+	const sortable = new Set(node.sortable);
+	const fields = rowFields(node);
+	Arr.forEach(definitions, (source) => Arr.forEach(Object.entries(source.edges), ([name, edge]) => {
+		if (edge.kind !== "paginated" || edge.target !== node.type) return;
+		Arr.forEach(parseOrder(edge.order), (term) => {
+			if (!fields.has(term.field)) throw new FilterDeclarationError({
+				collection: node.type,
+				field: term.field,
+				message: `Paginated edge "${name}" on ${source.type} orders "${node.type}" by "${term.field}", which is not a field of its row`
+			});
+			sortable.add(term.field);
+		});
+	}));
+	return sortable.size === node.sortable.length ? node : {
+		...node,
+		sortable: [...sortable]
+	};
+};
+/**
+* Close and validate the node graph: unique types, every edge target
+* present, every collection-valued edge's `inverse` resolving to a `one`
+* edge back to the declaring node, every paginated edge's order over fields
+* its target carries. Returns the graph — each node's `sortable` widened by
+* the paginated edges ordering it — plus the derived engine
+* `CollectionRegistry`.
+*/
+const registry$1 = (definitions) => {
+	const declared = /* @__PURE__ */ new Map();
+	Arr.forEach(definitions, (node) => {
+		if (declared.has(node.type)) throw new DuplicateNameError({
+			kind: "collection",
+			name: node.type
+		});
+		declared.set(node.type, node);
+	});
+	Arr.forEach(definitions, (node) => {
+		Arr.forEach(Object.entries(node.edges), ([name, edge]) => {
+			if (!declared.has(edge.target)) throw new UnknownCollectionError({
+				from: node.type,
+				relationship: name,
+				collection: edge.target
+			});
+			if (edge.kind !== "one") inverseVia(node, name, edge, declared);
+		});
+	});
+	const nodes = /* @__PURE__ */ new Map();
+	Arr.forEach(definitions, (node) => {
+		nodes.set(node.type, withEdgeOrders(node, definitions));
+	});
+	return {
+		nodes,
+		collections: registry$2([...nodes.values()].map((node) => toCollection(node, nodes)))
+	};
+};
+// src/Edge.ts
+var Edge_exports = /* @__PURE__ */ __exportAll({
+	many: () => many,
+	one: () => one,
+	paginated: () => paginated
+});
+/** Declare a reference to a single `target` node, stored in field `via`. */
+const one = (target, options) => ({
+	kind: "one",
+	target,
+	via: options.via
+});
+/** Declare the dependent collection of `target` nodes (unbounded). */
+const many = (target, options) => ({
+	kind: "many",
+	target,
+	inverse: options.inverse
+});
+/** Declare the dependent collection of `target` nodes, paged by cursor. */
+const paginated = (target, options) => ({
+	kind: "paginated",
+	target,
+	inverse: options.inverse,
+	order: options.order
+});
+// src/CrudMutation.ts
+/**
+* CrudMutation
+*
+* The **graph-derived CRUD mutations** (ADR-0030 §5): for every node a graph
+* declares, a `{type}/create`, `{type}/update` and `{type}/delete`
+* {@link Mutation}, whose args are in the **graph row form** — the flat row
+* a node-graph replica stores, attributes and `one`-edge `via` keys side by
+* side — with the client (optimistic) handler that writes it. They are what a
+* plain write means when nobody said otherwise: the JSON:API façade's default
+* intent mapping journals a reflected `POST` / `PATCH` / `DELETE` as one of
+* them (`@thomasfosterau/legation-jsonapi`'s `JsonApiFacade`).
+*
+* Args, for a node `reviews` with an edge `product: Edge.one("products", { via: "productId" })`:
+*
+* - `reviews/create`: `{ type: "reviews", id, attributes }`, `attributes`
+*   holding the row's fields (`productId` among them). The handler puts the
+*   row `{ ...attributes, [node.id]: id }`.
+* - `reviews/update`: the same shape, with only the fields being set. The
+*   handler merges them over the current row and is a **no-op when the row
+*   is absent**, so a patch journaled behind a create that the server later
+*   rejects leaves no phantom row behind (ADR-0030 §2).
+* - `reviews/delete`: `{ type: "reviews", id }`. The handler deletes the row
+*   (a no-op when it is absent).
+*
+* The args schemas are permissive (`attributes` is a record of unknown
+* values), so the encoded and decoded forms coincide and a JSON body can be
+* journaled as decoded. Attribute values are not validated here: the server's
+* handler under the same name is the authority (ADR-0008), and a value it
+* refuses surfaces as a permanent rejection.
+*
+* **Not `Derive.ts`'s mutations.** `@thomasfosterau/legation-jsonapi`'s
+* resource-derived CRUD mutators share these names but store a different row
+* shape (`JsonApiRow`: attributes flat, `relationships` nested, for the
+* client-direct stack with no node graph), and their `update` puts a partial
+* row when the row is absent. An engine registers one family or the other,
+* never both. These are for a replica built from a node graph.
+*
+* The server half is the app's: register a backend handler under each name
+* the client registers, applying the app's own write rules.
+*/
+var CrudMutation_exports = /* @__PURE__ */ __exportAll({
+	DeleteArgs: () => DeleteArgs,
+	WriteArgs: () => WriteArgs,
+	entries: () => entries,
+	name: () => name,
+	registry: () => registry
+});
+/** The mutation name for a type and an operation: `"{type}/{operation}"`. */
+const name = (type, operation) => `${type}/${operation}`;
+/** The args of a `{type}/create` or `{type}/update`: the row's fields as a record, keyed by its id. */
+const WriteArgs = Schema.Struct({
+	type: Schema.String,
+	id: Schema.String,
+	attributes: Schema.Record(Schema.String, Schema.Unknown)
+});
+/** The args of a `{type}/delete`. */
+const DeleteArgs = Schema.Struct({
+	type: Schema.String,
+	id: Schema.String
+});
+const derivesFor = (writes, type, operation) => writes === void 0 || (writes[type] ?? []).includes(operation);
+/** The derived mutations of one node, filtered by `writes`. */
+const nodeEntries = (node, writes) => {
+	const { type } = node;
+	const identity = node.id;
+	const entries = [];
+	if (derivesFor(writes, type, "create")) entries.push({
+		type,
+		operation: "create",
+		mutator: make$4(name(type, "create"), WriteArgs),
+		local: (args, writer) => writer.put(type, args.id, {
+			...args.attributes,
+			[identity]: args.id
+		})
+	});
+	if (derivesFor(writes, type, "update")) entries.push({
+		type,
+		operation: "update",
+		mutator: make$4(name(type, "update"), WriteArgs),
+		local: (args, writer) => Effect.flatMap(writer.get(type, args.id), (current) => current === void 0 ? Effect.void : writer.put(type, args.id, {
+			...current,
+			...args.attributes,
+			[identity]: args.id
+		}))
+	});
+	if (derivesFor(writes, type, "delete")) entries.push({
+		type,
+		operation: "delete",
+		mutator: make$4(name(type, "delete"), DeleteArgs),
+		local: (args, writer) => writer.del(type, args.id)
+	});
+	return entries;
+};
+/**
+* The graph-derived CRUD mutations of every node in the graph (those `writes`
+* selects), as registry entries an app spreads beside its own named
+* mutations: `Mutation.registry([...mine, ...CrudMutation.entries(nodes)])`.
+*
+* @example
+* ```ts
+* import * as Schema from "effect/Schema";
+* import { CrudMutation, Edge, Mutation, Node } from "@thomasfosterau/legation";
+*
+* const products = Node.make("products", { attributes: { name: Schema.String } });
+* const reviews = Node.make("reviews", {
+*   attributes: { rating: Schema.Number },
+*   edges: { product: Edge.one("products", { via: "productId" }) },
+* });
+* const nodes = Node.registry([products, reviews]);
+*
+* const registry = Mutation.registry(
+*   CrudMutation.entries(nodes, { writes: { reviews: ["create", "delete"] } })
+* );
+* console.log([...registry.mutators.keys()]); // ["reviews/create", "reviews/delete"]
+* ```
+*/
+const entries = (nodes, options) => [...nodes.nodes.values()].flatMap((node) => nodeEntries(node, options?.writes));
+/** The graph-derived CRUD mutations as a registry of their own. Duplicate names cannot occur. */
+const registry = (nodes, options) => registry$3(entries(nodes, options));
+// src/Client.ts
+/**
+* Client
+*
+* The one-per-thread object (ADR-0022): it runs many {@link Query} reads
+* and mutations, and **where a read is answered is configuration, never a
+* concept the UI sees**:
+*
+* - {@link make} owns the engine in this thread (store + transport come
+*   from context; the sync loop starts automatically — the class of bug
+*   where an app forgets `runSync` ends here). Starting the loop is **not**
+*   the same as auto-pushing, though: on its own it only wires the baseline
+*   triggers (pull on poke, push+pull on reconnect), so a mutation journaled
+*   on an already-connected client sits until one of those fires or the app
+*   calls `push` explicitly. Auto-push is `syncLoop.pushDebounce` — opt in
+*   with it if writes should reach the server without anything else
+*   happening first (the examples use `"300 millis"`).
+* - {@link connect} joins an engine hosted elsewhere — a service worker,
+*   an Electron main process, a daemon — over a `MirrorChannel`; the
+*   machinery behind it (the mirror) is internal vocabulary.
+*
+* Reads are declarative ({@link Query.Read}); **observing subscribes**: a
+* live read registers its windows for the stream's lifetime through a
+* per-window ledger (one voice per window, however many observers), and
+* `subscribe` pins a read's windows — root and, with `include`, edge —
+* beyond any observer. A subscription can also be named by its JSON:API
+* URL (`subscribe(url)`, ADR-0029 section 2) when the Client is built with
+* {@link UrlReads}; the canonical URL is then the subscription's identity
+* for devtools and the façade. Includes resolve through the view's
+* auto-subscribing relational read — host-side on a connected engine,
+* locally on an owned one — with the plan's edge windows applied.
+*
+* **Reads have three tiers and the UI sees none of them** (ADR-0025):
+* `query` answers from the replica when a subscription in this Client's
+* ledger **covers** the read — conjunct subsumption with strict windows
+* (ADR-0029 section 3, `Coverage`); otherwise it falls through to the server — point-in-time,
+* auth-filtered, no CVR, results never entering the replica — degrading
+* back to the local answer when no transport read is available or the
+* server is unreachable (offline-first: local is always an answer).
+* `observe` never falls through: observing subscribes, which IS the
+* upgrade from a one-shot fallthrough to a live, replica-backed read.
+*/
+var Client_exports = /* @__PURE__ */ __exportAll({
+	Client: () => Client,
+	connect: () => connect,
+	fromView: () => fromView,
+	make: () => make$1
+});
+/** One more unit of `kind` on a count that tracks `tracked`. */
+const oneMore = (count, kind, tracked) => (count ?? 0) + (kind === tracked ? 1 : 0);
+/** One unit of `kind` fewer on a count that tracks `tracked`, never below zero. */
+const oneFewer = (count, kind, tracked) => Math.max(0, count - (kind === tracked ? 1 : 0));
+/** Nobody holds the entry any more. */
+const unheld = (interest) => interest.observers === 0 && interest.pins === 0;
+/**
+* An entry with one unit of `kind` fewer. The canonical URL is a pin's
+* identity, so it goes with the last pin even while observers keep the
+* entry: {@link Client.coverageOf} names only what {@link Client.subscriptions}
+* lists.
+*/
+const oneFewerOn = (current, kind) => {
+	const { url, ...rest } = current;
+	const pins = oneFewer(current.pins, kind, "explicit");
+	return {
+		...rest,
+		observers: oneFewer(current.observers, kind, "observer"),
+		pins,
+		...pins > 0 && url !== void 0 ? { url } : {}
+	};
+};
+/**
+* The ledger key of a registration: the root window's hash alone, or with
+* its edge selects — the same key the mirror protocol gives a relational
+* registration — so a read with `include` is its own entry beside the
+* plain root, and each entry is what coverage compares against.
+*/
+const keyOf = (registration) => Arr.isReadonlyArrayEmpty(registration.edges) ? hash(registration.root) : relatedKey(registration.root.collection, registration.root, registration.edges);
+const noUrlReads = (url) => new QueryError({
+	message: "Client.subscribe(url): this Client has no URL reads; build it with `urls` (`JsonApiQuery.urlReads(nodes)` from @thomasfosterau/legation-jsonapi) to subscribe by URL",
+	query: url
+});
+/**
+* Build a Client over any view. The window ledger lives here, so however
+* many observers a window has — and however the view refcounts — the
+* Client speaks with one voice per window: subscribe on first interest,
+* unsubscribe when the last observer ends and no explicit pin remains.
+*/
+const fromView = (nodes, view, options = {}) => {
+	const urls = options.urls;
+	const ledger = Ref.makeUnsafe(/* @__PURE__ */ new Map());
+	const roots = Ref.makeUnsafe(/* @__PURE__ */ new Map());
+	const edgeScopes = /* @__PURE__ */ new Map();
+	const lock = Semaphore.makeUnsafe(1);
+	const holdRoot = (root) => Ref.modify(roots, (map) => {
+		const key = hash(root);
+		const count = map.get(key) ?? 0;
+		return [count === 0, new Map(map).set(key, count + 1)];
+	}).pipe(Effect.flatMap((first) => first ? view.subscribe(root).pipe(Effect.orDie) : Effect.void));
+	const dropRoot = (root) => Ref.modify(roots, (map) => {
+		const key = hash(root);
+		const count = map.get(key) ?? 0;
+		const next = new Map(map);
+		if (count <= 1) next.delete(key);
+		else next.set(key, count - 1);
+		return [count === 1, next];
+	}).pipe(Effect.flatMap((last) => last ? view.unsubscribe(root).pipe(Effect.ignore) : Effect.void));
+	const openEdges = (key, registration) => Effect.gen(function* () {
+		const scope = yield* Scope.make();
+		const { root, edges } = registration;
+		yield* view.pinEdges(nodes.collections, root.collection, root, edges).pipe(Scope.provide(scope));
+		edgeScopes.set(key, scope);
+	});
+	const closeEdges = (key) => Effect.suspend(() => {
+		const scope = edgeScopes.get(key);
+		edgeScopes.delete(key);
+		return scope === void 0 ? Effect.void : Scope.close(scope, Exit.void);
+	});
+	const register = (key, registration) => holdRoot(registration.root).pipe(Effect.andThen(Arr.isReadonlyArrayEmpty(registration.edges) ? Effect.void : openEdges(key, registration)));
+	const unregister = (key, registration) => closeEdges(key).pipe(Effect.andThen(dropRoot(registration.root)));
+	/** Add one unit of interest; registers with the view when it is the first. */
+	const acquire = (registration, kind, url) => Semaphore.withPermit(lock, acquireUnlocked(registration, kind, url));
+	const acquireUnlocked = (registration, kind, url) => Ref.modify(ledger, (map) => {
+		const key = keyOf(registration);
+		const current = map.get(key);
+		const known = url ?? current?.url;
+		const next = new Map(map).set(key, {
+			root: registration.root,
+			edges: registration.edges,
+			observers: oneMore(current?.observers, kind, "observer"),
+			pins: oneMore(current?.pins, kind, "explicit"),
+			...known === void 0 ? {} : { url: known }
+		});
+		return [current === void 0 ? key : void 0, next];
+	}).pipe(Effect.flatMap((key) => key === void 0 ? Effect.void : register(key, registration)));
+	/** Drop one unit of interest; releases from the view when it was the last. */
+	const release = (registration, kind) => Semaphore.withPermit(lock, releaseUnlocked(registration, kind));
+	const releaseUnlocked = (registration, kind) => Ref.modify(ledger, (map) => {
+		const key = keyOf(registration);
+		const current = map.get(key);
+		if (current === void 0) return [void 0, map];
+		const updated = oneFewerOn(current, kind);
+		const next = new Map(map);
+		if (unheld(updated)) {
+			next.delete(key);
+			return [key, next];
+		}
+		next.set(key, updated);
+		return [void 0, next];
+	}).pipe(Effect.flatMap((key) => key === void 0 ? Effect.void : unregister(key, registration)));
+	/**
+	* Drop every registration this Client holds, releasing each through the
+	* view exactly as the last observer or pin would. A reset's subscriptions
+	* are as much the superseded identity's as its rows: a ledger entry left
+	* behind would keep `coverageOf` claiming the new principal's reads are
+	* answerable locally, and would re-pull the old windows on the next sync.
+	* Roots are deduped the way {@link dropRoot} counts them, so the view hears
+	* one release per window however many entries shared it.
+	*/
+	const clearLedger = Semaphore.withPermit(lock, Effect.gen(function* () {
+		const entries = yield* Ref.getAndSet(ledger, /* @__PURE__ */ new Map());
+		yield* Ref.set(roots, /* @__PURE__ */ new Map());
+		const released = /* @__PURE__ */ new Set();
+		yield* Effect.forEach(entries, ([key, interest]) => Effect.gen(function* () {
+			yield* closeEdges(key);
+			const root = hash(interest.root);
+			if (released.has(root)) return;
+			released.add(root);
+			yield* view.unsubscribe(interest.root).pipe(Effect.ignore);
+		}), {
+			concurrency: 1,
+			discard: true
+		});
+	}));
+	const noBoundary = () => Effect.fail(new StoreError({ message: "Client.reset: this Client is connected to an engine hosted elsewhere (Client.connect), which owns the durable replica. Reset the Client that owns the engine — in the service worker or other host — instead." }));
+	const boundary = view.identityBoundary;
+	const reset = (identity) => boundary === void 0 ? noBoundary() : Effect.gen(function* () {
+		if (transitionOf((yield* boundary.current) ?? "@legation/unstamped", identity) === "Reset") yield* clearLedger;
+		return yield* boundary.reset(identity);
+	});
+	const targetOfUrl = (url) => urls === void 0 ? Effect.fail(noUrlReads(url)) : Effect.gen(function* () {
+		const read = yield* urls.parse(url);
+		const plan = yield* tryPlan(nodes, read);
+		return {
+			registration: ofPlan(plan),
+			url: yield* urls.canonical(read)
+		};
+	});
+	const targetOfRead = (read) => Effect.gen(function* () {
+		const plan = yield* tryPlan(nodes, read);
+		const url = urls === void 0 ? void 0 : Option.getOrUndefined(yield* Effect.option(urls.canonical(read)));
+		return {
+			registration: ofPlan(plan),
+			url
+		};
+	});
+	const targetOf = (input) => P.isString(input) ? targetOfUrl(input) : targetOfRead(input);
+	const verdictOf$1 = (plan, rowsOf = view.query) => requestedOf(nodes.collections, plan, rowsOf).pipe(Effect.flatMap((requested) => Ref.get(ledger).pipe(Effect.flatMap((interests) => Effect.forEach(interests.values(), (interest) => view.pulled(keyOf(interest)).pipe(Effect.map((pulled) => ({
+		...interest,
+		pulled
+	}))))), Effect.map((entries) => verdictOf(entries, requested)))), Effect.catchTag([
+		"MutatorError",
+		"StoreError",
+		"TransportError",
+		"QueryError"
+	], () => Effect.succeed({ _tag: "Uncovered" })));
+	const queryOnce = (read) => {
+		const readThrough = view.read;
+		if (readThrough === void 0) return run(view, nodes, read);
+		const compiled = plan(nodes, read);
+		const local = Effect.suspend(() => run(view, nodes, read));
+		return view.query(compiled.root).pipe(Effect.orElseSucceed(() => void 0), Effect.flatMap((snapshot) => snapshot === void 0 ? runPlanVia(readThrough, nodes, compiled).pipe(Effect.catch(() => local)) : verdictOf$1(compiled, snapshotOf({
+			subset: compiled.root,
+			rows: snapshot
+		}, view.query)).pipe(Effect.flatMap((verdict) => verdict._tag === "Covered" ? runRows(view, nodes, read, snapshot) : runPlanVia(readThrough, nodes, compiled).pipe(Effect.catch(() => local))))));
+	};
+	const observe = (read) => {
+		const compiled = plan(nodes, read);
+		if (Arr.isReadonlyArrayEmpty(compiled.edges)) {
+			const registration = ofPlan(compiled);
+			return Stream.unwrap(Effect.acquireRelease(acquire(registration, "observer"), () => release(registration, "observer")).pipe(Effect.as(view.observe(compiled.root).pipe(Stream.orDie, Stream.map((rows) => rows.map((row) => ({
+				...row,
+				related: {}
+			})))))));
+		}
+		return Stream.unwrap(view.related(nodes.collections, read.collection, compiled.root, edgeSelects(compiled)).pipe(Effect.map((stream) => stream.pipe(Stream.map((rows) => applyWindows(compiled, rows))))));
+	};
+	return {
+		nodes,
+		query: queryOnce,
+		observe,
+		subscribe: (input) => targetOf(input).pipe(Effect.flatMap(({ registration, url }) => acquire(registration, "explicit", url))),
+		unsubscribe: (input) => targetOf(input).pipe(Effect.flatMap(({ registration }) => release(registration, "explicit"))),
+		subscriptions: Ref.get(ledger).pipe(Effect.map((interests) => [...interests.values()].flatMap((entry) => entry.pins > 0 && entry.url !== void 0 ? [entry.url] : []))),
+		coverageOf: (read, options) => {
+			const plan$1 = plan(nodes, read);
+			return verdictOf$1(plan$1, options?.snapshot === void 0 ? view.query : snapshotOf(options.snapshot, view.query));
+		},
+		reset,
+		identity: boundary === void 0 ? noBoundary() : boundary.current,
+		quarantines: boundary === void 0 ? noBoundary() : boundary.quarantines,
+		quarantinedMutations: (identity) => boundary === void 0 ? noBoundary() : boundary.quarantinedMutations(identity),
+		discardQuarantine: (identity) => boundary === void 0 ? noBoundary() : boundary.discardQuarantine(identity),
+		mutate: (mutation, args) => view.mutate(mutation, args),
+		mutateWithAck: (mutation, args) => view.mutateWithAck(mutation, args),
+		beginFormMutation: (form, mutation, args) => view.beginFormMutation === void 0 ? Effect.fail(new TransportError({ message: "Client.beginFormMutation: this view carries no enhanced form submit (it has neither an engine nor a host to ask)" })) : view.beginFormMutation(form, mutation, args),
+		mutationStates: view.mutationStates,
+		view
+	};
+};
+/**
+* The Client as a service — for runtimes and bindings that carry "the one
+* per-thread object" in context (ADR-0022).
+*/
+const Client = Context.Service("@thomasfosterau/legation/Client");
+/** The view options of a larger option set, absent keys left absent. */
+const viewOptions = (options) => options.urls === void 0 ? {} : { urls: options.urls };
+/** The `indexes` declared on each of `nodes`' collections, by collection name. */
+const declaredIndexes = (nodes) => {
+	const indexes = {};
+	Arr.forEach(nodes.collections, ([name, collection]) => {
+		if (collection.indexes !== void 0 && Arr.isReadonlyArrayNonEmpty(collection.indexes)) indexes[name] = collection.indexes;
+	});
+	return indexes;
+};
+/**
+* A Client that owns the engine in this thread. Zero wiring works:
+* `Client.make({ nodes, mutations })` is a purely local Client over an
+* in-memory store. Add `transport: { url }` for the standard remote setup,
+* or pass/provide full `ClientStore`/`ClientTransport` implementations for
+* anything else — options win over context, context over defaults.
+*
+* Returns the Client with the engine and store it built ({@link Made}), so
+* an app that needs an engine-level capability (devtools) need not build the
+* engine by hand.
+*/
+const make$1 = (options) => Effect.gen(function* () {
+	const store = options.store ?? Option.getOrUndefined(yield* Effect.serviceOption(ClientStore)) ?? (yield* makeMemory);
+	const clientGroupId = options.clientGroupId ?? `group-${crypto.randomUUID()}`;
+	const configured = options.transport !== void 0 && "url" in options.transport ? yield* fromOrigin({
+		origin: options.transport.url,
+		clientGroupId
+	}) : options.transport;
+	const contextual = Option.getOrUndefined(yield* Effect.serviceOption(ClientTransport));
+	const transport = configured ?? contextual ?? offline;
+	const sync = options.sync ?? (configured ?? contextual) !== void 0;
+	const indexes = declaredIndexes(options.nodes);
+	const engine = yield* make$5({
+		clientId: options.clientId ?? `client-${crypto.randomUUID()}`,
+		clientGroupId,
+		mutators: options.mutations,
+		...options.queries === void 0 ? {} : { queries: options.queries },
+		...options.syncLoop === void 0 ? {} : { syncLoop: options.syncLoop },
+		...!R.isEmptyReadonlyRecord(indexes) ? { indexes } : {},
+		...options.autoIndex === void 0 ? {} : { autoIndex: options.autoIndex }
+	}).pipe(Effect.provideService(ClientStore, store), Effect.provideService(ClientTransport, transport));
+	if (options.identity !== void 0) yield* engine.reset(options.identity).pipe(Effect.orDie);
+	if (sync) yield* Effect.forkScoped(engine.runSync.pipe(Effect.orDie));
+	return {
+		client: fromView(options.nodes, fromEngine(engine), viewOptions(options)),
+		engine,
+		store
+	};
+});
+/**
+* A Client over an engine hosted elsewhere (service worker, Electron main,
+* a daemon), joined over a `MirrorChannel`. Reads and writes cross the
+* channel; relational reads resolve host-side.
+*/
+const connect = (options) => Effect.gen(function* () {
+	const mirror = yield* make$6({
+		channel: options.channel,
+		mutators: options.mutations
+	});
+	return fromView(options.nodes, mirror, viewOptions(options));
+});
+// src/Hydration.ts
+/**
+* Hydration
+*
+* Move a client's durable state across a serialisation boundary: `dehydrate`
+* reads a {@link ClientStore} into a plain {@link Snapshot}; `hydrate` writes a
+* snapshot back into a store. Between the two the snapshot is JSON — the value
+* an SSR response embeds, a devtools export writes to disk, or a client hands to a
+* worker.
+*
+* ## SSR flow
+*
+* The server renders a page over a *real* engine per request: an in-memory
+* {@link ClientStore} plus a {@link ClientTransport} to the sync server. It
+* `subscribe`s the subsets the page needs, `pull`s once, then `dehydrate`s the
+* store — capturing the confirmed rows, the pull cookie, and any journalled
+* mutations. That snapshot ships to the browser (JSON-encoded in the document).
+* The client builds its durable store, `hydrate`s the snapshot into it, and
+* constructs the engine over that store. The first render already has rows (no
+* loading flash), and because the cookie came across too the client's first
+* pull continues the CVR conversation from where the server left off — no
+* refetch of state the server already sent.
+*
+* The transport is the seam that makes this work off-process. Pull is the
+* correctness path, so subscribe → pull → dehydrate behaves identically
+* against a remote Server: the renderer need not hold the backend. A
+* single-process app passes nothing and gets a loop-back transport over the
+* in-context {@link ServerHandler}; a split deployment (a SvelteKit Worker
+* rendering against a separate API Worker) passes its own carrier.
+*
+* ## Seeded-versions caveat
+*
+* A snapshot carries each row's authoritative `version`. Those versions must be
+* genuine backend versions for CVR diffing to converge cheaply on the next
+* pull: the server compares them against its record and sends only the delta.
+* Self-invented versions are *safe* — they never corrupt state — but they will
+* not match the server's CVR, so the next pull degrades to the reset path (the
+* server sends a `Clear` followed by full puts). The same caveat applies to
+* {@link ClientEngine.seed}.
+*
+* ## Validation
+*
+* `hydrate` decodes the snapshot through {@link Snapshot} before writing,
+* so a `dehydrate → JSON.stringify → JSON.parse → hydrate` round-trip is
+* schema-checked end to end; a malformed snapshot fails as a `StoreError`.
+* Only the *envelopes* are validated — row values and mutation args stay
+* `Unknown` and round-trip untouched (ADR-0014), exactly like the store's own
+* persisted codecs. Use {@link SnapshotFromJson} to fold the JSON step into the
+* decode.
+*/
+var Hydration_exports = /* @__PURE__ */ __exportAll({
+	Snapshot: () => Snapshot,
+	SnapshotFromJson: () => SnapshotFromJson,
+	SnapshotRow: () => SnapshotRow,
+	dehydrate: () => dehydrate,
+	hydrate: () => hydrate,
+	hydrateIfEmpty: () => hydrateIfEmpty,
+	isEmpty: () => isEmpty,
+	rowsFor: () => rowsFor,
+	snapshot: () => snapshot
+});
+/**
+* One dehydrated row: a {@link StoredRow} tagged with the collection it belongs
+* to, so the flat `rows` array reconstructs the per-collection layout on
+* hydrate. `value` stays `Unknown` (envelope-validated only, ADR-0014).
+*/
+const SnapshotRow = Schema.Struct({
+	collection: Schema.String,
+	...StoredRow.fields
+});
+/**
+* A serialisable capture of a {@link ClientStore}: confirmed rows (flattened
+* with their collection), the pull cookie, the pending-mutation journal, the
+* acknowledged-but-unpulled tail (#336), and each client's mutation id counter
+* (#271). The tail and the counters are optional so a snapshot taken before
+* they existed still loads, as an empty tail and no counters. The schema is
+* the source of truth; {@link Snapshot} is derived from it.
+*
+* The counters are what let a client id be reused across the hydration
+* boundary: once acknowledgements have drained the journal, they are the only
+* record of the ids the backend has already applied, and a hydrated store
+* without them would issue those ids again, which the backend skips as
+* duplicates (a silent lost write).
+*/
+const Snapshot = Schema.Struct({
+	rows: Schema.Array(SnapshotRow),
+	cookie: Schema.optional(Schema.String),
+	journal: Schema.Array(Mutation),
+	unpulled: Schema.optional(Schema.Array(Mutation)),
+	counters: Schema.optional(Schema.Record(Schema.String, Schema.Number.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0)))))
+});
+/**
+* JSON codec for a {@link Snapshot}: `decode` parses a JSON string and validates
+* it in one step (SSR/devtools ingest), `encode` produces the JSON string.
+*/
+const SnapshotFromJson = Schema.fromJsonString(Snapshot);
+const storeError = (message) => (cause) => new StoreError({
+	message,
+	cause
+});
+/**
+* The replica read member by member: the path for a store without `snapshot`. Its reads are not one
+* state, so a pull or a push acknowledgement can land between them (#392).
+*/
+const readMembers = (store) => Effect.gen(function* () {
+	const rows = [];
+	yield* Effect.forEach(yield* store.listCollections, (collection) => Effect.gen(function* () {
+		Arr.forEach(yield* store.listRows(collection), (row) => {
+			rows.push({
+				collection,
+				row
+			});
+		});
+	}), {
+		concurrency: 1,
+		discard: true
+	});
+	return {
+		rows,
+		cookie: yield* store.getCookie,
+		journal: yield* store.pendingMutations,
+		unpulled: yield* store.unpulled,
+		counters: yield* store.mutationCounters
+	};
+});
+/**
+* Read a {@link ClientStore} into a {@link Snapshot}: enumerate the collections,
+* gather their confirmed rows (flattened with the collection), the cookie, the
+* journal, the unpulled tail and the mutation counters. The tail and the
+* counters are each left out when empty, so a snapshot without them keeps its
+* previous shape.
+*
+* The five parts are one state when the store offers {@link ClientStore.snapshot}
+* (the memory and key-value stores do): a pull or a push acknowledgement lands wholly
+* before or wholly after the read (#392). A store without it is read member by member.
+*/
+const dehydrate = (store) => Effect.gen(function* () {
+	const state = yield* store.snapshot ?? readMembers(store);
+	const base = {
+		rows: state.rows.map(({ collection, row }) => ({
+			collection,
+			id: row.id,
+			version: row.version,
+			value: row.value
+		})),
+		...state.cookie !== void 0 ? { cookie: state.cookie } : {},
+		journal: state.journal,
+		...Arr.isReadonlyArrayNonEmpty(state.unpulled) ? { unpulled: state.unpulled } : {}
+	};
+	return R.isEmptyRecord(state.counters) ? base : {
+		...base,
+		counters: state.counters
+	};
+});
+/**
+* Write a {@link Snapshot} into a {@link ClientStore}: validate it through
+* {@link Snapshot} (so a malformed snapshot fails as a `StoreError`), then
+* put the rows, set the cookie if present, park the unpulled tail, raise the
+* store's mutation counters to the snapshot's, and append the journal, skipping
+* any entry the tail already holds. A snapshot without a tail parks nothing. An
+* outstanding pull release is finished first.
+*
+* The counters are raised, never lowered (#271): a client id reused after
+* hydration continues above every id the snapshot's store had issued, so it
+* never reissues an id the backend has already applied. A snapshot without
+* counters leaves the store's as they are.
+*
+* A running {@link ClientEngine} built over the store re-reads its view and built
+* indexes afterwards: a direct write does not go through the engine, so without this
+* an indexed query could return a row whose indexed field changed (#350). The re-read
+* runs when a write fails too, since the rows written before the failure are in the
+* store. It reaches only the engines built over this exact store object: a store
+* wrapped in a new object (`ClientStore.of({ ...store })`) is not seen, so its engine
+* can stay stale. The same re-read tracks the appended journal entries in its
+* `mutationStates` as `"pending"` (#358), so they settle like a local mutation. Journal ids
+* should be ids this client has not already settled: an id the map has evicted is tracked again,
+* and its outcome event can then follow a second time.
+*
+* The writes are not atomic. Between the first `putRow` and the re-read, an indexed
+* read on an async store can see the old index against the new rows. Once `hydrate`
+* returns or fails, the engine's view and indexes match the store again.
+*
+* `hydrate` does not take the overlay lock of an engine built over the store, so it must
+* not run while that engine is pulling. Its first step finishes an outstanding pull release
+* (#387). If that release is a live pull's, the pull's remaining row writes then land over
+* the snapshot's rows. Hydrate before the engine starts, or while it is stopped.
+*/
+const hydrate = (store, snapshot) => Effect.gen(function* () {
+	const decoded = yield* Schema.decodeUnknownEffect(Snapshot)(snapshot).pipe(Effect.mapError(storeError("Invalid snapshot")));
+	yield* Effect.gen(function* () {
+		yield* store.finishRelease;
+		yield* Effect.forEach(decoded.rows, ({ collection, ...row }) => Effect.gen(function* () {
+			yield* store.putRow(collection, row);
+		}), {
+			concurrency: 1,
+			discard: true
+		});
+		if (decoded.cookie !== void 0) yield* store.setCookie(decoded.cookie);
+		if (decoded.unpulled !== void 0) yield* store.parkUnpulled(decoded.unpulled);
+		if (decoded.counters !== void 0) yield* store.raiseMutationCounters(decoded.counters);
+		const parked = new Set((yield* store.unpulled).map((m) => `${m.clientId}\u0000${m.mutationId}`));
+		yield* Effect.forEach(decoded.journal, (mutation) => Effect.gen(function* () {
+			if (parked.has(`${mutation.clientId}\u0000${mutation.mutationId}`)) return;
+			yield* store.appendMutation(mutation);
+		}), {
+			concurrency: 1,
+			discard: true
+		});
+		yield* freezePending(store);
+	}).pipe(Effect.ensuring(resyncAttachedEngines(store)));
+});
+/**
+* Whether a store holds nothing: no rows, no cookie, no journalled or unpulled mutations.
+* The "fresh browser" test {@link hydrateIfEmpty} gates on.
+*/
+const isEmpty = (store) => Effect.gen(function* () {
+	if ((yield* store.getCookie) !== void 0) return false;
+	if (Arr.isReadonlyArrayNonEmpty(yield* store.pendingMutations)) return false;
+	if (Arr.isReadonlyArrayNonEmpty(yield* store.unpulled)) return false;
+	const holding = yield* Effect.findFirst(yield* store.listCollections, (collection) => Effect.map(store.listRows(collection), Arr.isReadonlyArrayNonEmpty));
+	return Option.isNone(holding);
+});
+/**
+* {@link hydrate}, but only into an empty store; returns whether it hydrated.
+*
+* This is the right client-boot default over a *durable* store: on a repeat
+* visit the store already holds rows, a cookie, and possibly journalled
+* offline mutations that are all fresher than the SSR snapshot — hydrating
+* over them would regress the cookie (and with it the CVR conversation) and
+* clobber newer confirmed rows. An empty store (first visit, cleared storage)
+* takes the snapshot wholesale.
+*/
+const hydrateIfEmpty = (store, snapshot) => Effect.gen(function* () {
+	if (!(yield* isEmpty(store))) return false;
+	yield* hydrate(store, snapshot);
+	return true;
+});
+/**
+* Project a snapshot onto a read, locally and synchronously: the snapshot's
+* rows for the read's collection, filtered/sorted/windowed by the read's
+* compiled root window. This is how a component derives its initial value
+* (e.g. the rune hooks' `initial` option) from the page's snapshot — during
+* SSR and on first client render — without touching an engine.
+*
+* `include`d edges are not resolved here: a snapshot is flat rows, and
+* resolving edges is the Client's job once the engine is up. Seed the base
+* rows and let the first live emission fill the edges in.
+*/
+const rowsFor = (snapshot, nodes, read) => apply(snapshot.rows.filter((row) => row.collection === read.collection).map((row) => ({
+	id: row.id,
+	value: row.value
+})), plan(nodes, read).root);
+/** The snapshot render itself, over an already-built carrier. */
+const renderOver = (transport, options) => Effect.scoped(Effect.gen(function* () {
+	const store = yield* makeMemory;
+	const engine = yield* make$5({
+		clientId: options.clientId ?? "ssr",
+		clientGroupId: options.clientGroupId,
+		mutators: options.mutations ?? registry$3([])
+	}).pipe(Effect.provideService(ClientStore, store), Effect.provideService(ClientTransport, transport));
+	yield* Effect.forEach(options.reads, (read) => Effect.gen(function* () {
+		yield* engine.subscribe(plan(options.nodes, read).root);
+	}), {
+		concurrency: 1,
+		discard: true
+	});
+	yield* engine.pull;
+	return yield* dehydrate(store);
+}));
+function snapshot(options) {
+	const supplied = options.transport;
+	if (supplied !== void 0) return renderOver(supplied, options);
+	return Effect.scoped(Effect.gen(function* () {
+		const handler = yield* ServerHandler;
+		const transport = yield* makeInMemory(handler, options.clientGroupId);
+		return yield* renderOver(transport, options);
+	}));
+}
+// src/Server.ts
+/**
+* Server
+*
+* The one server-side object (ADR-0022): built once over the {@link Backend}
+* and auth seams, it exposes the protocol **handler** (push/pull with CVR
+* diffing — mount it on any router or carrier) and **broadcast**, the single
+* verb for "these resources changed".
+*
+* Mutation writes pushed through the handler broadcast implicitly (the push
+* path publishes their hints); `broadcast` is for everything else — cron
+* jobs, admin tools, any writer that bypasses mutations (ADR-0019's
+* out-of-band story in one line). Underneath it is unchanged poke-then-pull:
+* hints are droppable latency optimizations, pull is the correctness path.
+*
+* CVR storage and the fan-out bus are **options with working defaults**
+* (in-memory store, in-process bus); scale-out swaps them (a shared
+* KeyValueStore, a serialized broker — ADR-0011) without touching app code.
+* The Server is logical: its parts deploy separately (per-user rooms,
+* fan-out shards — ADR-0022's reference topology), and ADR-0023's
+* topic-derived fan-out lands behind `broadcast` without changing its
+* signature.
+*
+* A third verb, **mutate**, runs one named Mutation server-side as one of a
+* client group's mutations (ADR-0030, amendment #215): the entry point a form
+* action calls. It is a push minus the transport, so it goes through the
+* handler's push path (identity, middleware, the backend's ledger, the
+* broadcast), and it answers a {@link Receipt} carrying the backend's ruling.
+*/
+var Server_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+/**
+* Read one mutation's ruling off a push response: rejected when the response
+* lists it, acknowledged when the client's watermark covers it. A response
+* that does neither breaks Backend guarantee 1, so it is a defect.
+*/
+const receiptOf = (response, clientId, mutationId) => {
+	const rejected = response.rejected?.find((entry) => entry.clientId === clientId && entry.mutationId === mutationId);
+	if (rejected !== void 0) return Effect.succeed({
+		clientId,
+		mutationId,
+		phase: "rejected",
+		reason: rejected.reason
+	});
+	const watermark = response.lastMutationIds[clientId] ?? 0;
+	return watermark >= mutationId ? Effect.succeed({
+		clientId,
+		mutationId,
+		phase: "acknowledged"
+	}) : Effect.die(new BackendError({ message: `Server.mutate: the backend neither applied nor rejected mutation ${mutationId} of client ${clientId} (its watermark is ${watermark})` }));
+};
+/** Build the Server: handler + broadcast over backend and auth. */
+const make = (options) => Effect.gen(function* () {
+	const cvr = options.cvr ?? (yield* makeMemoryStore);
+	const bus = options.bus ?? (yield* makeInProcess);
+	let handler = makeWith(options.options).pipe(Effect.provideService(Backend, options.backend), Effect.provideService(AuthPolicy, options.auth.policy), Effect.provideService(CvrStore, cvr), Effect.provideService(InvalidationBus, bus));
+	if (options.auth.identity !== void 0) handler = handler.pipe(Effect.provideService(IdentityResolver, options.auth.identity));
+	if (options.queries !== void 0) handler = handler.pipe(Effect.provideService(QueryResolver, options.queries));
+	if (options.middleware !== void 0) handler = handler.pipe(Effect.provideService(SyncMiddleware, options.middleware));
+	const built = yield* handler;
+	const mutate = (request) => Effect.gen(function* () {
+		const args = yield* Schema.encodeEffect(request.mutation.args)(request.args).pipe(Effect.orDie);
+		const createdAt = yield* Clock.currentTimeMillis;
+		const response = yield* built.handlePush({
+			clientGroupId: request.clientGroupId,
+			mutations: [{
+				clientId: request.clientId,
+				mutationId: request.mutationId,
+				mutator: request.mutation.name,
+				args,
+				createdAt
+			}],
+			schemaVersion: request.schemaVersion
+		});
+		return yield* receiptOf(response, request.clientId, request.mutationId);
+	});
+	return {
+		handler: built,
+		broadcast: (change) => bus.publish([{
+			collection: change.collection,
+			ids: change.ids ?? []
+		}]),
+		mutate
+	};
+});
+export { Edge_exports as a, CrudMutation_exports as i, Hydration_exports as n, Node_exports as o, Client_exports as r, Server_exports as t };
+
+//# sourceMappingURL=src-FWXpu_vP.js.map