@abloatai/ablo 0.25.0 → 0.27.0

package/dist/react/useCurrentUserId.d.ts

@@ -1,13 +1,14 @@
 /**
- * Returns the app user ID passed to the nearest `<AbloProvider>`, when
- * the app chose to provide one.
+ * Returns the application user id passed to the nearest `<AbloProvider>`, or
+ * `null` when your app did not provide one.
  *
- * Hosted Ablo identity is resolved server-side from the API key, session,
- * or capability token. This hook is only for app-owned fields like
- * `assigneeId`; it is not required for Ablo sync to connect.
+ * Sync identity is resolved on the server from the API key or session, so this
+ * value is not required for sync to connect. It is here for your app's own
+ * fields — an assignee id, a presence label, a permission check — where the
+ * current user matters to your data rather than to the sync layer. Reach for it
+ * in leaf components that need the id, for example to fill in a mutation
+ * payload.
  *
- * Use this in leaf components that need the current user ID for
- * mutation payloads, presence labels, permission checks, etc.
  * @example
  * function TaskRow({ id }) {
  *   const userId = useCurrentUserId();

package/dist/react/useCurrentUserId.js

@@ -3,15 +3,16 @@ import { useContext } from 'react';
 import { AbloInternalContext } from './internalContext.js';
 import { AbloValidationError } from '../errors.js';
 /**
- * Returns the app user ID passed to the nearest `<AbloProvider>`, when
- * the app chose to provide one.
+ * Returns the application user id passed to the nearest `<AbloProvider>`, or
+ * `null` when your app did not provide one.
  *
- * Hosted Ablo identity is resolved server-side from the API key, session,
- * or capability token. This hook is only for app-owned fields like
- * `assigneeId`; it is not required for Ablo sync to connect.
+ * Sync identity is resolved on the server from the API key or session, so this
+ * value is not required for sync to connect. It is here for your app's own
+ * fields — an assignee id, a presence label, a permission check — where the
+ * current user matters to your data rather than to the sync layer. Reach for it
+ * in leaf components that need the id, for example to fill in a mutation
+ * payload.
  *
- * Use this in leaf components that need the current user ID for
- * mutation payloads, presence labels, permission checks, etc.
  * @example
  * function TaskRow({ id }) {
  *   const userId = useCurrentUserId();

package/dist/react/useErrorListener.d.ts

@@ -1,12 +1,12 @@
 /**
- * Register an imperative callback that fires whenever the provider
- * surfaces an error. Covers engine errors (bootstrap failures,
- * mutation rejections), WebSocket errors, and uncaught exceptions
- * inside `postBootstrap` hooks.
+ * Registers a callback that runs whenever the provider surfaces an error. This
+ * covers engine errors such as bootstrap failures and mutation rejections,
+ * WebSocket errors, and uncaught exceptions thrown inside `postBootstrap`
+ * hooks.
  *
- * Use this for telemetry (Sentry, Datadog), user-facing toasts, or
- * any side effect that should NOT trigger a re-render. The listener
- * is stored in a ref, so re-renders don't thrash the subscription.
+ * Use it for side effects that should not cause a re-render — telemetry,
+ * logging, or a toast. The callback is held in a ref, so a re-render does not
+ * resubscribe.
  *
  * @example
  * function ErrorToaster() {

package/dist/react/useErrorListener.js

@@ -3,14 +3,14 @@ import { useContext, useEffect, useRef } from 'react';
 import { AbloInternalContext } from './internalContext.js';
 import { AbloValidationError } from '../errors.js';
 /**
- * Register an imperative callback that fires whenever the provider
- * surfaces an error. Covers engine errors (bootstrap failures,
- * mutation rejections), WebSocket errors, and uncaught exceptions
- * inside `postBootstrap` hooks.
+ * Registers a callback that runs whenever the provider surfaces an error. This
+ * covers engine errors such as bootstrap failures and mutation rejections,
+ * WebSocket errors, and uncaught exceptions thrown inside `postBootstrap`
+ * hooks.
  *
- * Use this for telemetry (Sentry, Datadog), user-facing toasts, or
- * any side effect that should NOT trigger a re-render. The listener
- * is stored in a ref, so re-renders don't thrash the subscription.
+ * Use it for side effects that should not cause a re-render — telemetry,
+ * logging, or a toast. The callback is held in a ref, so a re-render does not
+ * resubscribe.
  *
  * @example
  * function ErrorToaster() {
@@ -27,13 +27,12 @@ export function useErrorListener(listener) {
         throw new AbloValidationError('useErrorListener: no <AbloProvider> mounted above this component. ' +
             'Wrap your tree with <AbloProvider ...> from @abloatai/ablo/react.', { code: 'no_ablo_provider' });
     }
-    // Stash the latest callback in a ref so the effect subscription
-    // stays stable across renders. Matches the `useEventCallback`
-    // pattern: late-bind the listener so callers can pass inline
-    // arrows without thrashing the subscription.
+    // Hold the latest callback in a ref so the subscription stays stable across
+    // renders. Late-binding the listener this way lets callers pass an inline
+    // arrow without resubscribing on every render.
     const ref = useRef(listener);
     ref.current = listener;
     useEffect(() => {
-        return ctx.subscribeError((err) => ref.current(err));
+        return ctx.subscribeError((err) => { ref.current(err); });
     }, [ctx]);
 }

package/dist/react/useMutationFailureListener.d.ts

@@ -5,15 +5,15 @@ export interface MutationFailurePayload {
     permanent?: boolean;
 }
 /**
- * Register a side-effect listener for mutation failures. Fires whenever
- * the underlying transaction queue rolls back an optimistic write —
- * permanent rejections (validation, FK, auth) and exhausted-retry
- * rollbacks (connection lost mid-burst).
+ * Subscribes a listener to mutation failures. The callback fires whenever the
+ * transaction queue rolls back an optimistic write — both permanent rejections
+ * (a validation, foreign-key, or authorization error) and rollbacks after the
+ * retries are exhausted (for example, the connection drops mid-write).
  *
- * Use this to mount a single `<MutationFailureBoundary>` near the app
- * shell that turns silent pool rollbacks into toasts / banners. The
- * listener is stored in a ref so re-renders don't thrash the
- * subscription — matches `useErrorListener`.
+ * A single listener mounted near the top of your component tree can turn these
+ * otherwise-silent rollbacks into toasts or banners. The callback is held in a
+ * ref, so re-renders do not tear down and re-create the underlying
+ * subscription.
  *
  * @example
  * function MutationFailureBoundary() {

package/dist/react/useMutationFailureListener.js

@@ -3,15 +3,15 @@ import { useContext, useEffect, useRef } from 'react';
 import { AbloInternalContext } from './internalContext.js';
 import { AbloValidationError } from '../errors.js';
 /**
- * Register a side-effect listener for mutation failures. Fires whenever
- * the underlying transaction queue rolls back an optimistic write —
- * permanent rejections (validation, FK, auth) and exhausted-retry
- * rollbacks (connection lost mid-burst).
+ * Subscribes a listener to mutation failures. The callback fires whenever the
+ * transaction queue rolls back an optimistic write — both permanent rejections
+ * (a validation, foreign-key, or authorization error) and rollbacks after the
+ * retries are exhausted (for example, the connection drops mid-write).
  *
- * Use this to mount a single `<MutationFailureBoundary>` near the app
- * shell that turns silent pool rollbacks into toasts / banners. The
- * listener is stored in a ref so re-renders don't thrash the
- * subscription — matches `useErrorListener`.
+ * A single listener mounted near the top of your component tree can turn these
+ * otherwise-silent rollbacks into toasts or banners. The callback is held in a
+ * ref, so re-renders do not tear down and re-create the underlying
+ * subscription.
  *
  * @example
  * function MutationFailureBoundary() {
@@ -33,6 +33,6 @@ export function useMutationFailureListener(listener) {
         const engine = ctx.engine;
         if (!engine)
             return;
-        return engine.onMutationFailure((payload) => ref.current(payload));
+        return engine.onMutationFailure((payload) => { ref.current(payload); });
     }, [ctx, ctx.engine]);
 }

package/dist/react/useMutators.d.ts

@@ -3,19 +3,19 @@ import type { MutatorDefs } from '../mutators/defineMutators.js';
 import type { UndoScope } from '../mutators/UndoManager.js';
 import type { ResolveSchema } from '../types/global.js';
 /**
- * useMutators — turn a `defineMutators` tree into callable invokers.
+ * Turns a mutator tree built with `defineMutators` into callable invokers. The
+ * returned object mirrors that tree one-to-one, but each leaf becomes an
+ * `(args) => Promise<TResult>` function.
  *
- * The returned object mirrors the mutator tree one-to-one, but each leaf is
- * now a `(args) => Promise<TResult>` function. Internally each invocation:
- *   1. Builds a fresh `Transaction` bound to the current store/org context.
- *   2. Calls the user's mutator with `{ tx, args }`.
- *   3. Returns the mutator's resolved value.
+ * Each invocation builds a fresh `Transaction` bound to the current store and
+ * organization, calls your mutator with `{ tx, args }`, and returns whatever
+ * the mutator resolves to.
  *
- * V1 error handling: if the mutator throws, we `console.error` + rethrow.
- * Any writes that already dispatched stay in place (no rollback). That
- * matches the existing behaviour of batch helpers like `saveManyOptimized`
- * and keeps the contract honest — consumers can layer their own try/catch
- * + compensating writes until V2 adds atomicity.
+ * If a mutator throws, the error propagates to the caller and any writes it
+ * already dispatched stay in place — there is no automatic rollback. Wrap the
+ * call in your own try/catch and issue compensating writes when you need to
+ * undo a partial change, or pass an `undoScope` (see {@link UseMutatorsOptions})
+ * to record inverses for undo and redo.
  */
 /**
  * Map a `MutatorFn` onto its invoker form — strip `tx`, keep `args`/return.

package/dist/react/useMutators.js

@@ -30,15 +30,21 @@ export function useMutators(schemaOrMutators, mutatorsOrOptions, maybeOptions) {
                 continue;
             const invokers = {};
             for (const mutatorName of Object.keys(group)) {
-                const fn = group[mutatorName];
+                const maybeFn = group[mutatorName];
+                if (!maybeFn)
+                    continue;
+                // Bind the narrowed value: `noUncheckedIndexedAccess` types the indexed
+                // read as `Fn | undefined`, and that narrowing doesn't survive into the
+                // deferred invoker closures below — a non-optional local does.
+                const fn = maybeFn;
                 const label = `${String(modelKey)}.${mutatorName}`;
                 invokers[mutatorName] = async (args) => {
                     // Recording path: wrap the transaction so each write snapshots its
                     // inverse. On success, push the captured entry to the scope.
                     //
                     // The whole snapshot → write → record sequence runs on the scope's
-                    // serialization chain so concurrent invocations (the slides UI fires
-                    // writes un-awaited) record in *invocation* order and never
+                    // serialization chain so concurrent invocations (a caller may fire
+                    // writes without awaiting them) record in invocation order and never
                     // interleave their shared-model snapshots. See UndoScope.runRecorded.
                     if (undoScope) {
                         return undoScope.runRecorded(async () => {
@@ -58,7 +64,7 @@ export function useMutators(schemaOrMutators, mutatorsOrOptions, maybeOptions) {
                             }
                         });
                     }
-                    // Non-recording path — plain transaction, identical to pre-undo V1.
+                    // Non-recording path — plain transaction, no inverse capture.
                     const tx = createTransaction(schema, store, organizationId);
                     try {
                         return await fn({ tx, args });

package/dist/react/useReactive.js

@@ -48,7 +48,7 @@ export function useReactive(compute, equals = defaultEquals) {
     // When `compute` identity changes, its closed-over observable source
     // may have swapped (e.g. useQuery memoized a new QueryView because
     // the where clause changed). The MobX reaction subscribed in
-    // `subscribe` only tracks the observables read on its FIRST run; if
+    // `subscribe` only tracks the observables read on its first run; if
     // the source swaps without a re-subscription, the reaction never
     // re-tracks the new observables and `getSnapshot` keeps returning
     // the stale value forever.
@@ -71,7 +71,7 @@ export function useReactive(compute, equals = defaultEquals) {
         // `compute` is a fresh inline arrow at virtually every call site, so this
         // branch runs on essentially every render. Reconcile the snapshot against
         // the latest closure, but only force a re-subscription when the value
-        // ACTUALLY changed. For the dominant case (same observable source, new
+        // actually changed. For the dominant case (same observable source, new
         // arrow identity, unchanged value) this avoids tearing down + recreating
         // the MobX reaction — and its double-compute — on every render. A genuine
         // source swap (a memoized compute closing over a new observable source)
@@ -98,7 +98,6 @@ export function useReactive(compute, equals = defaultEquals) {
                 onChange();
             }
         });
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [subscribeVersion]);
     const getSnapshot = useCallback(() => snapshotRef.current.value, []);
     return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);

package/dist/react/useSyncStatus.d.ts

@@ -1,10 +1,8 @@
 /**
- * Reactive sync-status snapshot as a discriminated union. Impossible
- * states (e.g., "connected AND offline") are unrepresentable — each
- * variant carries only the fields that make sense in that state.
- *
- * Inspired by Liveblocks' `useStatus()` and Zero's `useConnectionState()`:
- * one hook, one switch, no six-boolean guessing games.
+ * A snapshot of the current sync status, modeled as a discriminated union so
+ * impossible states — such as "connected and offline" at once — cannot be
+ * represented. Each variant carries only the fields that make sense in that
+ * state, so a single `switch` on `name` narrows to exactly what you can read.
  *
  * Variants:
  * - `initial` — the provider just mounted; no connection attempt yet.

package/dist/react/useUndoScope.d.ts

@@ -2,16 +2,14 @@ import type { Schema } from '../schema/schema.js';
 import type { UndoScope, UndoScopeOptions } from '../mutators/UndoManager.js';
 import type { ResolveSchema } from '../types/global.js';
 /**
- * useUndoScope — per-surface undo/redo for mutator invocations.
+ * Provides per-surface undo and redo for mutator invocations. Each named scope
+ * owns an independent undo/redo stack, so different parts of your app — a deck
+ * editor, a sidebar form — can undo separately without stepping on each other.
  *
- * Zero deliberately does NOT ship a built-in undo API; consumers build one
- * on top of mutation tracking. This is ours.
- *
- * Each named scope owns an independent undo/redo stack. Wire the returned
- * `scope` into `useMutators(schema, mutators, { undoScope: scope })` and the
- * invocations become recorded. `undo()` / `redo()` replay the inverses /
- * forwards as new transactions that do NOT re-record (the manager pushes
- * them between the two stacks explicitly).
+ * Wire the returned `scope` into `useMutators(schema, mutators, { undoScope:
+ * scope })` and those invocations become recorded. `undo()` and `redo()` replay
+ * the captured inverses and forwards as new transactions that do not record
+ * themselves; the manager moves the entry between the two stacks explicitly.
  *
  * @example
  * const { undo, redo, canUndo, canRedo, scope } = useUndoScope('deck-editor');

package/dist/react/useUndoScope.js

@@ -30,7 +30,7 @@ function getManager(key, factory) {
 export function useUndoScope(schemaOrName, nameOrOptions, maybeOptions) {
     const { store, organizationId, schema: ctxSchema } = useSyncContext();
     const isExplicit = typeof schemaOrName !== 'string';
-    const schema = isExplicit ? schemaOrName : ctxSchema;
+    const schema = isExplicit ? (schemaOrName) : ctxSchema;
     const name = isExplicit ? nameOrOptions : schemaOrName;
     const options = (isExplicit ? maybeOptions : nameOrOptions);
     if (!schema) {
@@ -53,12 +53,12 @@ export function useUndoScope(schemaOrName, nameOrOptions, maybeOptions) {
     useEffect(() => {
         setTick(0);
     }, [scope]);
-    // Re-render on ANY stack change — including entries recorded from the local-
+    // Re-render on any stack change — including entries recorded from the local-
     // mutation stream, which don't otherwise trigger a React update. Without this
     // `canUndo`/`canRedo` go stale in every consumer that didn't itself call
     // undo/redo (e.g. a keyboard handler whose Cmd+Z gate then never fires).
     useEffect(() => {
-        return scope.onChange(() => setTick((t) => t + 1));
+        return scope.onChange(() => { setTick((t) => t + 1); });
     }, [scope]);
     const size = scope.size();
     return {

package/dist/schema/coordination.d.ts

@@ -1,11 +1,8 @@
 /**
- * Coordination authoring helpers for the model `conflict` axis.
- *
- * Composable disposition functions + a `cn`/`cx`-style combinator, so a model
- * declares conflict behaviour the way the rest of the DSL reads
- * (`relation.belongsTo()`, `field.string()`) — and the way modern libraries
- * compose config (Better Auth's `plugins: [admin(), twoFactor()]`, shadcn's
- * `cx(a, b)`) — instead of a raw disposition map:
+ * Authoring helpers for a model's `conflict` axis — the setting that decides
+ * what happens when two writers touch the same row. Instead of writing a raw
+ * disposition map, you compose small, named functions the way the rest of the
+ * schema DSL reads (`relation.belongsTo()`, `field.string()`):
  *
  * ```ts
  * import { coordination, humansOverwrite, agentsReject } from '@abloatai/ablo/schema';
@@ -14,12 +11,11 @@
  * // → { user: 'overwrite', agent: 'reject' }  (a human's write wins, an agent's yields)
  * ```
  *
- * Each helper is named for the exact disposition it applies — the same
- * `overwrite | reject | notify` vocabulary used by write guards (`onStale`) —
- * and returns a partial {@link ConflictAxis}. {@link coordination} merges them
- * (later rules win on key collisions). The result is plain, serializable data —
- * the engine interpreter and schema round-trip are unchanged; this is only a
- * nicer authoring surface.
+ * Each helper is named for the disposition it applies — drawn from the same
+ * `overwrite | reject | notify` vocabulary the write guards use (`onStale`) —
+ * and returns a partial {@link ConflictAxis}. {@link coordination} merges the
+ * pieces, with later rules winning on key collisions. The result is plain,
+ * serializable data that the engine reads at commit time.
  */
 import type { ConflictAxis } from '../policy/types.js';
 /**
@@ -27,28 +23,28 @@ import type { ConflictAxis } from '../policy/types.js';
  * disposition helper below. Compose with {@link coordination}.
  */
 export type ConflictRule = ConflictAxis;
-/** A human's conflicting write OVERWRITES — wins; never blocked (LWW among humans). */
+/** A human's conflicting write wins and overwrites the other; it is never blocked. Among humans this gives last-write-wins. */
 export declare const humansOverwrite: () => ConflictRule;
-/** A human's conflicting write is REJECTED — yields to a held claim / stale snapshot. */
+/** A human's conflicting write is rejected, yielding to a held claim or a stale snapshot. */
 export declare const humansReject: () => ConflictRule;
-/** A human's stale write NOTIFIES — re-reads & re-applies instead of clobbering. */
+/** A human's stale write triggers a notification: it re-reads and re-applies rather than clobbering. */
 export declare const humansNotify: () => ConflictRule;
-/** An agent's conflicting write OVERWRITES — wins (rarely wanted). */
+/** An agent's conflicting write wins and overwrites the other (rarely what you want). */
 export declare const agentsOverwrite: () => ConflictRule;
-/** An agent's conflicting write is REJECTED — yields to a held claim / stale snapshot. */
+/** An agent's conflicting write is rejected, yielding to a held claim or a stale snapshot. */
 export declare const agentsReject: () => ConflictRule;
-/** An agent's stale write NOTIFIES — re-reads & re-applies instead of clobbering. */
+/** An agent's stale write triggers a notification: it re-reads and re-applies rather than clobbering. */
 export declare const agentsNotify: () => ConflictRule;
-/** A system/automation conflicting write OVERWRITES. */
+/** A system or automation write wins and overwrites the other. */
 export declare const systemOverwrite: () => ConflictRule;
-/** A system/automation conflicting write is REJECTED. */
+/** A system or automation write is rejected. */
 export declare const systemReject: () => ConflictRule;
-/** A system/automation stale write NOTIFIES (re-read & re-apply). */
+/** A system or automation stale write triggers a notification: it re-reads and re-applies. */
 export declare const systemNotify: () => ConflictRule;
 /**
- * Merge coordination rules into one {@link ConflictAxis} — the `cn`/`cx` of
- * conflict policy. Later rules win on key collisions; an omitted committer kind
- * falls through to the engine default at commit time.
+ * Merges coordination rules into a single {@link ConflictAxis}. Later rules win
+ * on key collisions, and a committer kind you leave out falls through to the
+ * engine's default at commit time.
  *
  * ```ts
  * coordination(humansOverwrite(), agentsReject())  // → { user: 'overwrite', agent: 'reject' }

package/dist/schema/coordination.js

@@ -1,11 +1,8 @@
 /**
- * Coordination authoring helpers for the model `conflict` axis.
- *
- * Composable disposition functions + a `cn`/`cx`-style combinator, so a model
- * declares conflict behaviour the way the rest of the DSL reads
- * (`relation.belongsTo()`, `field.string()`) — and the way modern libraries
- * compose config (Better Auth's `plugins: [admin(), twoFactor()]`, shadcn's
- * `cx(a, b)`) — instead of a raw disposition map:
+ * Authoring helpers for a model's `conflict` axis — the setting that decides
+ * what happens when two writers touch the same row. Instead of writing a raw
+ * disposition map, you compose small, named functions the way the rest of the
+ * schema DSL reads (`relation.belongsTo()`, `field.string()`):
  *
  * ```ts
  * import { coordination, humansOverwrite, agentsReject } from '@abloatai/ablo/schema';
@@ -14,38 +11,37 @@
  * // → { user: 'overwrite', agent: 'reject' }  (a human's write wins, an agent's yields)
  * ```
  *
- * Each helper is named for the exact disposition it applies — the same
- * `overwrite | reject | notify` vocabulary used by write guards (`onStale`) —
- * and returns a partial {@link ConflictAxis}. {@link coordination} merges them
- * (later rules win on key collisions). The result is plain, serializable data —
- * the engine interpreter and schema round-trip are unchanged; this is only a
- * nicer authoring surface.
+ * Each helper is named for the disposition it applies — drawn from the same
+ * `overwrite | reject | notify` vocabulary the write guards use (`onStale`) —
+ * and returns a partial {@link ConflictAxis}. {@link coordination} merges the
+ * pieces, with later rules winning on key collisions. The result is plain,
+ * serializable data that the engine reads at commit time.
  */
 // ── Humans (user sessions) ──────────────────────────────────────────────
-/** A human's conflicting write OVERWRITES — wins; never blocked (LWW among humans). */
+/** A human's conflicting write wins and overwrites the other; it is never blocked. Among humans this gives last-write-wins. */
 export const humansOverwrite = () => ({ user: 'overwrite' });
-/** A human's conflicting write is REJECTED — yields to a held claim / stale snapshot. */
+/** A human's conflicting write is rejected, yielding to a held claim or a stale snapshot. */
 export const humansReject = () => ({ user: 'reject' });
-/** A human's stale write NOTIFIES — re-reads & re-applies instead of clobbering. */
+/** A human's stale write triggers a notification: it re-reads and re-applies rather than clobbering. */
 export const humansNotify = () => ({ user: 'notify' });
 // ── Agents (AI) ─────────────────────────────────────────────────────────
-/** An agent's conflicting write OVERWRITES — wins (rarely wanted). */
+/** An agent's conflicting write wins and overwrites the other (rarely what you want). */
 export const agentsOverwrite = () => ({ agent: 'overwrite' });
-/** An agent's conflicting write is REJECTED — yields to a held claim / stale snapshot. */
+/** An agent's conflicting write is rejected, yielding to a held claim or a stale snapshot. */
 export const agentsReject = () => ({ agent: 'reject' });
-/** An agent's stale write NOTIFIES — re-reads & re-applies instead of clobbering. */
+/** An agent's stale write triggers a notification: it re-reads and re-applies rather than clobbering. */
 export const agentsNotify = () => ({ agent: 'notify' });
 // ── System / automation ─────────────────────────────────────────────────
-/** A system/automation conflicting write OVERWRITES. */
+/** A system or automation write wins and overwrites the other. */
 export const systemOverwrite = () => ({ system: 'overwrite' });
-/** A system/automation conflicting write is REJECTED. */
+/** A system or automation write is rejected. */
 export const systemReject = () => ({ system: 'reject' });
-/** A system/automation stale write NOTIFIES (re-read & re-apply). */
+/** A system or automation stale write triggers a notification: it re-reads and re-applies. */
 export const systemNotify = () => ({ system: 'notify' });
 /**
- * Merge coordination rules into one {@link ConflictAxis} — the `cn`/`cx` of
- * conflict policy. Later rules win on key collisions; an omitted committer kind
- * falls through to the engine default at commit time.
+ * Merges coordination rules into a single {@link ConflictAxis}. Later rules win
+ * on key collisions, and a committer kind you leave out falls through to the
+ * engine's default at commit time.
  *
  * ```ts
  * coordination(humansOverwrite(), agentsReject())  // → { user: 'overwrite', agent: 'reject' }