@abloatai/ablo 0.25.0 → 0.27.0

package/dist/client/sessionMint.js

@@ -1,37 +1,32 @@
 /**
- * `mintSession` — the ONE implementation behind `sessions.create`, shared by the
- * stateful `Ablo` client and the stateless protocol / HTTP client so the two can
- * never drift on HOW a token is minted.
+ * Mints a session token. This is the single implementation behind
+ * `sessions.create`, shared by the schema-aware client and the schemaless HTTP
+ * client so the two never disagree on how a token is produced.
  *
- * Minting is a pure control-plane HTTP call (no socket, no synced pool): a backend
- * holding a secret `sk_` exchanges it for a short-lived scoped token — `ek_` for an
- * `{ user }` session (full end-user authority) or `rk_` for an `{ agent }` session
- * (scoped to exactly the operations named in `can`). The two arms map to the
- * server's two mint doors:
+ * Minting is a plain control-plane HTTP call — no socket, no synced data. A
+ * backend holding a secret key (`sk_`) exchanges it for a short-lived, scoped
+ * token whose kind depends on the session requested:
  *
- *   `{ user }`  → POST /auth/ephemeral-keys → `ek_`. The user-session door;
- *                 routing this arm through /auth/capability is structurally
- *                 impossible — that route rejects participantKind 'user' outright
- *                 (`invalid_participant_kind`, the 2026-06-11 Pulse cascade where
- *                 the SDK's own blessed pattern 403'd and integrators fell back to
- *                 minting humans as agents).
- *   `{ agent }` → POST /auth/capability → scoped `rk_`. `can: { tasks: ['update'] }`
- *                 serializes to the wire allowlist (`tasks.update`); the Hub matches
- *                 it against every registered alias of the model.
+ *   `{ user }`  → POST /auth/ephemeral-keys, returning an `ek_` key that carries
+ *                 full end-user authority. This is the only route that mints a
+ *                 user session; the capability route rejects a `user`
+ *                 participant with `invalid_participant_kind`.
+ *   `{ agent }` → POST /auth/capability, returning an `rk_` key scoped to exactly
+ *                 the operations named in `can`. For example
+ *                 `can: { tasks: ['update'] }` becomes the wire allowlist entry
+ *                 `tasks.update`, which the server matches against the model's
+ *                 registered names.
  *
- * The caller supplies the resolved control-plane credential + base URL in `ctx`;
- * WHICH key to use (the original `sk_`, never a derived `rk_` the startup exchange
- * may have installed) is the caller's concern — see the two call sites.
- *
- * Type-only imports of `CreateSessionParams` / `AbloSession` keep this module a
- * leaf (no runtime cycle back to `Ablo.ts`): at runtime it depends on `auth` +
- * `schema` only.
+ * The caller supplies the already-resolved secret key and base URL in
+ * {@link MintSessionContext}. Choosing which key to pass — the original secret
+ * key, not a derived key that an earlier exchange may have produced — is the
+ * caller's responsibility.
  */
 import { exchangeApiKey, mintUserSessionKey } from '../auth/index.js';
 /**
- * Mint a session token from an already-resolved `sk_` credential + base URL.
- * Discriminates the `{ user }` / `{ agent }` union onto the server's two mint
- * doors and reshapes each flat response into the `AbloSession` resource.
+ * Mints a session token from an already-resolved secret key and base URL.
+ * Routes the `{ user }` or `{ agent }` request to the matching mint endpoint
+ * and reshapes the response into an {@link AbloSession}.
  */
 export async function mintSession(params, ctx) {
     const { apiKey, baseUrl } = ctx;
@@ -64,10 +59,10 @@ export async function mintSession(params, ctx) {
         };
     }
     const operations = Object.entries(params.can).flatMap(([model, ops]) => {
-        // Translate the schema key the developer used in `can` to the wire
-        // typename the Hub gates on — see `modelTypenames` above. Falls back to
-        // the key when no map is supplied (schemaless client) or the key isn't
-        // in it, preserving the prior behaviour exactly for those callers.
+        // Translate the schema key the developer used in `can` into the wire type
+        // name the server checks — see `modelTypenames` above. Falls back to the
+        // key itself when no map is supplied (the schemaless client) or the key is
+        // absent from it.
         const ns = ctx.modelTypenames?.[model] ?? model;
         return (ops ?? []).map((op) => `${ns.toLowerCase()}.${op}`);
     });

package/dist/client/validateAbloOptions.d.ts

@@ -1,22 +1,20 @@
 /**
- * Up-front validation of `AbloOptions`. Returns the first error
- * encountered or null if all checks pass — caller writes the error
- * into `store.syncStatus` so consumers see it through the existing
- * status surface rather than catching it at the call site.
+ * Validates the options passed when constructing a client, before any
+ * connection is attempted. Returns the first problem it finds as an
+ * {@link AbloError}, or null when every check passes. The caller records that
+ * error on the client's sync status, so a misconfiguration surfaces through the
+ * normal status channel rather than throwing at the call site.
  *
- * Extracted from `Ablo.ts` (which was ~2300 LOC of constructor wiring)
- * so the validation rules are readable in isolation. The order of
- * checks matters: missing `url` is checked before identity options
- * because the error messages reference URLs and would mislead if a
- * URL was actually present.
+ * The order of checks matters: a missing `url` is reported before any identity
+ * problem, because the identity error messages mention the URL and would
+ * mislead if the URL were the thing actually missing.
  */
 import { AbloError } from '../errors.js';
 /**
- * Minimal subset of `AbloOptions` the validator actually inspects.
- * Defined here as its own interface so the validator doesn't pull
- * the whole 200+-line `AbloOptions` type — and to avoid a circular
- * import with `Ablo.ts`. Fields are kept structurally identical to
- * `AbloOptions` so a real options object satisfies this shape.
+ * The subset of client options this validator reads. It is declared as its own
+ * interface, structurally compatible with the full options type, so a real
+ * options object satisfies it without the validator having to depend on the
+ * complete type.
  */
 export interface ValidatableAbloOptions {
     readonly schema?: {

package/dist/client/validateAbloOptions.js

@@ -1,16 +1,15 @@
 /**
- * Up-front validation of `AbloOptions`. Returns the first error
- * encountered or null if all checks pass — caller writes the error
- * into `store.syncStatus` so consumers see it through the existing
- * status surface rather than catching it at the call site.
+ * Validates the options passed when constructing a client, before any
+ * connection is attempted. Returns the first problem it finds as an
+ * {@link AbloError}, or null when every check passes. The caller records that
+ * error on the client's sync status, so a misconfiguration surfaces through the
+ * normal status channel rather than throwing at the call site.
  *
- * Extracted from `Ablo.ts` (which was ~2300 LOC of constructor wiring)
- * so the validation rules are readable in isolation. The order of
- * checks matters: missing `url` is checked before identity options
- * because the error messages reference URLs and would mislead if a
- * URL was actually present.
+ * The order of checks matters: a missing `url` is reported before any identity
+ * problem, because the identity error messages mention the URL and would
+ * mislead if the URL were the thing actually missing.
  */
-import { AbloValidationError } from '../errors.js';
+import { AbloError, AbloValidationError } from '../errors.js';
 export function validateAbloOptions(input) {
     const { options, url, configuredApiKey, configuredAuthToken } = input;
     const kind = options.kind ?? 'user';

package/dist/client/writeOptionsSchema.d.ts

@@ -1,18 +1,19 @@
 /**
- * THE write-options schema — one Zod schema for the write dialect every
- * door speaks (`ablo.<model>.create/update/delete`, `commits.create`, the
- * HTTP model routes). Validated once at each public boundary so a plain-JS
- * caller passing `onStale: 'rejct'` fails loudly at the call site with a
- * typed `AbloValidationError`, not silently (or 400) at the server.
+ * The Zod schema for write options — the settings accepted by every write
+ * entry point, including `ablo.<model>.create/update/delete`, `commits.create`,
+ * and the HTTP write routes. Each of those boundaries validates against this
+ * one schema, so a caller who passes, say, `onStale: 'rejct'` fails right away
+ * with a typed {@link AbloValidationError} at the call site instead of silently
+ * or with a 400 from the server.
  *
- * Mirrors `source/contract.ts`: the schema is the runtime twin of the
- * `MutationOptions` interface, with a compile-time drift guard at the
- * bottom so the two can never silently diverge.
+ * The schema is the runtime counterpart of the {@link MutationOptions}
+ * interface. A compile-time check at the bottom of this file asserts that the
+ * two describe the same shape, so they cannot drift apart.
  *
- * Validation-only by design: callers keep their ORIGINAL options object.
- * Zod's parse output strips unknown keys, and the `claim` slot legally
- * carries live handles (`ClaimHandle` / claim leases) whose
- * `release`/`revoke` functions must survive — so we assert, never replace.
+ * Validation only inspects; it never transforms. Callers keep the exact options
+ * object they passed in. This matters because the `claim` field can hold a live
+ * claim handle whose `release` and `revoke` functions must survive, so the code
+ * asserts the shape rather than replacing the value with a parsed copy.
  */
 import { z } from 'zod';
 export declare const onStaleModeSchema: z.ZodEnum<{
@@ -40,9 +41,10 @@ export declare const writeOptionsSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type WriteOptionsInput = z.infer<typeof writeOptionsSchema>;
 /**
- * Assert a write-options bag against THE schema. Throws a typed
- * `AbloValidationError` (`code: 'write_options_invalid'`, Stripe-style
- * `param` pointing at the offending field) and returns nothing — the
- * caller keeps its original object.
+ * Validates a write-options object against {@link writeOptionsSchema}. On
+ * failure it throws a typed {@link AbloValidationError} — with
+ * `code: 'write_options_invalid'` and a `param` pointing at the offending
+ * field — and on success returns nothing, leaving the caller's original object
+ * untouched. A `null` or `undefined` value passes.
  */
 export declare function assertWriteOptions(value: unknown, context?: string): void;

package/dist/client/writeOptionsSchema.js

@@ -1,24 +1,26 @@
 /**
- * THE write-options schema — one Zod schema for the write dialect every
- * door speaks (`ablo.<model>.create/update/delete`, `commits.create`, the
- * HTTP model routes). Validated once at each public boundary so a plain-JS
- * caller passing `onStale: 'rejct'` fails loudly at the call site with a
- * typed `AbloValidationError`, not silently (or 400) at the server.
+ * The Zod schema for write options — the settings accepted by every write
+ * entry point, including `ablo.<model>.create/update/delete`, `commits.create`,
+ * and the HTTP write routes. Each of those boundaries validates against this
+ * one schema, so a caller who passes, say, `onStale: 'rejct'` fails right away
+ * with a typed {@link AbloValidationError} at the call site instead of silently
+ * or with a 400 from the server.
  *
- * Mirrors `source/contract.ts`: the schema is the runtime twin of the
- * `MutationOptions` interface, with a compile-time drift guard at the
- * bottom so the two can never silently diverge.
+ * The schema is the runtime counterpart of the {@link MutationOptions}
+ * interface. A compile-time check at the bottom of this file asserts that the
+ * two describe the same shape, so they cannot drift apart.
  *
- * Validation-only by design: callers keep their ORIGINAL options object.
- * Zod's parse output strips unknown keys, and the `claim` slot legally
- * carries live handles (`ClaimHandle` / claim leases) whose
- * `release`/`revoke` functions must survive — so we assert, never replace.
+ * Validation only inspects; it never transforms. Callers keep the exact options
+ * object they passed in. This matters because the `claim` field can hold a live
+ * claim handle whose `release` and `revoke` functions must survive, so the code
+ * asserts the shape rather than replacing the value with a parsed copy.
  */
 import { z } from 'zod';
 import { AbloValidationError } from '../errors.js';
 export const onStaleModeSchema = z.enum(['reject', 'overwrite', 'notify']);
 export const writeOptionsSchema = z.object({
-    /** Server-side mutation_log cache key; `null` opts out of retry-safety. */
+    /** Idempotency key the server records in `mutation_log` to make retries
+     *  safe; `null` opts out of that protection. */
     idempotencyKey: z.string().min(1).max(255).nullish(),
     /** Human-readable audit tag, persisted to `mutation_log.label`. */
     label: z.string().max(255).optional(),
@@ -28,17 +30,18 @@ export const writeOptionsSchema = z.object({
     readAt: z.number().int().nonnegative().nullish(),
     /** What the server does when the target moved past `readAt`. */
     onStale: onStaleModeSchema.nullish(),
-    /** Claim/claim attribution — an id, or a live lease handle (loose: the
-     *  handle's `release`/`revoke` functions ride along untouched). */
+    /** The claim this write belongs to — either a claim id, or a live claim
+     *  handle whose `release`/`revoke` functions are preserved untouched. */
     claim: z.union([z.string(), z.looseObject({ id: z.string() })]).nullish(),
-    /** Dormant wire-compat field; always `null` from current clients. */
+    /** Reserved wire-compatibility field; current clients always send `null`. */
     causedByTaskId: z.string().nullish(),
 });
 /**
- * Assert a write-options bag against THE schema. Throws a typed
- * `AbloValidationError` (`code: 'write_options_invalid'`, Stripe-style
- * `param` pointing at the offending field) and returns nothing — the
- * caller keeps its original object.
+ * Validates a write-options object against {@link writeOptionsSchema}. On
+ * failure it throws a typed {@link AbloValidationError} — with
+ * `code: 'write_options_invalid'` and a `param` pointing at the offending
+ * field — and on success returns nothing, leaving the caller's original object
+ * untouched. A `null` or `undefined` value passes.
  */
 export function assertWriteOptions(value, context) {
     if (value == null)

package/dist/client/wsMutationExecutor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The default {@link MutationExecutor}. It sends each change as a `commit`
+ * frame over the sync engine's own WebSocket, resolving that socket lazily at
+ * commit time because it does not exist yet when the executor is created. A
+ * client wires this up automatically unless you supply your own executor.
+ */
+import type { StaleNotification, ReadDependency } from '../coordination/schema.js';
+import type { MutationExecutor, MutationOperation } from '../interfaces/index.js';
+/**
+ * Creates the default mutation executor, which sends each change as a `commit`
+ * frame over the sync engine's own WebSocket. The engine owns its socket, so
+ * you pass a URL and credentials rather than transport callbacks.
+ *
+ * The factory takes a `getWs` accessor instead of a socket directly because the
+ * socket is created later during client startup and does not exist yet when
+ * this executor is constructed. The accessor is called at commit time to reach
+ * the ready socket.
+ *
+ * When set, `options.idempotencyKey` is sent as the wire-level `clientTxId`, so
+ * retrying a call with the same key is safe; otherwise the executor generates
+ * one.
+ */
+export declare function createDefaultMutationExecutor(getWs: () => {
+    sendCommit?: (operations: readonly MutationOperation[], clientTxId: string, timeoutMs?: number, causedByTaskId?: string | null, reads?: readonly ReadDependency[] | null) => Promise<{
+        lastSyncId: number;
+        notifications?: StaleNotification[];
+    }>;
+} | null): MutationExecutor;

package/dist/client/wsMutationExecutor.js

@@ -0,0 +1,71 @@
+/**
+ * The default {@link MutationExecutor}. It sends each change as a `commit`
+ * frame over the sync engine's own WebSocket, resolving that socket lazily at
+ * commit time because it does not exist yet when the executor is created. A
+ * client wires this up automatically unless you supply your own executor.
+ */
+import { AbloError, AbloConnectionError } from '../errors.js';
+// ── Default mutation executor (wire: `commit` frame over WebSocket) ──────
+/**
+ * Creates the default mutation executor, which sends each change as a `commit`
+ * frame over the sync engine's own WebSocket. The engine owns its socket, so
+ * you pass a URL and credentials rather than transport callbacks.
+ *
+ * The factory takes a `getWs` accessor instead of a socket directly because the
+ * socket is created later during client startup and does not exist yet when
+ * this executor is constructed. The accessor is called at commit time to reach
+ * the ready socket.
+ *
+ * When set, `options.idempotencyKey` is sent as the wire-level `clientTxId`, so
+ * retrying a call with the same key is safe; otherwise the executor generates
+ * one.
+ */
+export function createDefaultMutationExecutor(getWs) {
+    async function commit(operations, options) {
+        const ws = getWs();
+        if (!ws?.sendCommit) {
+            throw new AbloConnectionError('SyncWebSocket not ready for commit. The engine must finish bootstrap ' +
+                'before mutations can be sent.', { code: 'ws_not_ready' });
+        }
+        const clientTxId = options?.idempotencyKey ??
+            (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+                ? crypto.randomUUID()
+                : `tx_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`);
+        try {
+            return await ws.sendCommit(operations, clientTxId, undefined, // use sendCommit's built-in 15s default; no per-call override
+            options?.causedByTaskId, options?.reads);
+        }
+        catch (err) {
+            // Wrap transport-level failures as connection errors so the transaction
+            // queue's retry classifier treats them as transient and retries them.
+            if (err instanceof AbloError)
+                throw err;
+            if (err instanceof Error) {
+                if (/not connected|timed out|connection|ECONN/i.test(err.message)) {
+                    const wrapped = new AbloConnectionError(err.message, { cause: err });
+                    // Preserve any `diagnostics` snapshot the underlying SyncWebSocket
+                    // attached to the rejection. Without this, the wrapped error
+                    // bottoms out at "AbloConnectionError: not connected" with no
+                    // attribution to which close code / heartbeat trip / session
+                    // error caused it. See SyncWebSocket.notConnectedError().
+                    if (err &&
+                        typeof err === 'object' &&
+                        'diagnostics' in err &&
+                        err.diagnostics) {
+                        wrapped.diagnostics = err.diagnostics;
+                    }
+                    throw wrapped;
+                }
+            }
+            throw err;
+        }
+    }
+    return {
+        commit,
+        executeCreate: (model, id, input, _txId, options) => commit([{ type: 'CREATE', model: model.toLowerCase(), id, input }], options).then(() => { }),
+        executeUpdate: (model, id, data, _txId, options) => commit([{ type: 'UPDATE', model: model.toLowerCase(), id, input: data }], options),
+        executeDelete: (model, id, _txId, options) => commit([{ type: 'DELETE', model: model.toLowerCase(), id }], options).then(() => { }),
+        executeArchive: (model, id, _txId, options) => commit([{ type: 'ARCHIVE', model: model.toLowerCase(), id }], options).then(() => { }),
+        executeUnarchive: (model, id, _txId, options) => commit([{ type: 'UNARCHIVE', model: model.toLowerCase(), id }], options).then(() => { }),
+    };
+}

package/dist/context.d.ts

@@ -1,9 +1,11 @@
 /**
- * Module-level context accessor
+ * Module-level accessor for the sync engine's shared context.
  *
- * Set once during SDK initialization via `initSyncEngine(context)`.
- * All internal SDK files access dependencies through `getContext()`.
- * This avoids threading context through every constructor.
+ * The context is set once, during initialization, by {@link initSyncEngine}.
+ * Code throughout the package reaches its shared dependencies — logger,
+ * observability, online-status detector, configuration, and the mutation
+ * executor — through {@link getContext} instead of receiving them through every
+ * constructor.
  */
 import type { SyncEngineContext } from './SyncEngineContext.js';
 /**

package/dist/context.js

@@ -1,9 +1,11 @@
 /**
- * Module-level context accessor
+ * Module-level accessor for the sync engine's shared context.
  *
- * Set once during SDK initialization via `initSyncEngine(context)`.
- * All internal SDK files access dependencies through `getContext()`.
- * This avoids threading context through every constructor.
+ * The context is set once, during initialization, by {@link initSyncEngine}.
+ * Code throughout the package reaches its shared dependencies — logger,
+ * observability, online-status detector, configuration, and the mutation
+ * executor — through {@link getContext} instead of receiving them through every
+ * constructor.
  */
 import { noopLogger, noopObservability, browserOnlineStatus, defaultSessionErrorDetector, emptyConfig, } from './SyncEngineContext.js';
 let _context = null;
@@ -52,7 +54,4 @@ const _fallback = {
         executeArchive: () => Promise.resolve(),
         executeUnarchive: () => Promise.resolve(),
     },
-    mutationDispatcher: {
-        dispatch: () => Promise.resolve(),
-    },
 };

package/dist/coordination/index.d.ts

@@ -1,6 +1,15 @@
 /**
- * `@abloatai/ablo/coordination` — the canonical wire schema for the three
- * coordination layers (presence, pessimistic claims, optimistic stale-context).
- * See `./schema.ts` for the model and the per-layer schemas.
+ * The `@abloatai/ablo/coordination` entry point. It re-exports the wire
+ * schemas and inferred types for the three coordination layers: presence (who
+ * is currently active), claims (taking exclusive hold of a target before
+ * writing it), and stale-context guards (rejecting a write that was based on an
+ * out-of-date read). The definitions themselves live in the sibling schema
+ * module.
+ *
+ * Exports are listed by name rather than re-exported wholesale, so every symbol
+ * that becomes part of this package's public API is a deliberate choice.
  */
-export * from './schema.js';
+export { targetRangeSchema, participantKindSchema, wireParticipantKindSchema, participantKindFromWire, descriptionFromMeta, targetRefSchema, onStaleModeSchema, writeGuardSchema, staleNotificationSchema, readDependencySchema, claimStatusSchema, wireClaimSummarySchema, claimErrorSchema, wireClaimSchema, claimRejectionSchema, modelTargetSchema, modelClaimSchema, claimBeginPayloadSchema, claimAbandonPayloadSchema, claimReorderPayloadSchema, claimHeartbeatPayloadSchema, claimHeartbeatAckPayloadSchema, claimHeartbeatBatchPayloadSchema, claimHeartbeatBatchAckPayloadSchema, updateSubscriptionPayloadSchema, subscriptionAckPayloadSchema, commitOperationTypeSchema, commitOperationSchema, presenceKindSchema, presenceActivitySchema, presenceUpdateFrameSchema, } from './schema.js';
+export { defaultPolicy, capabilityPreemptPolicy, interpretConflictAxis } from '../policy/types.js';
+export type { Conflict, ConflictAxis, ConflictDecision, ConflictKind, ConflictOperation, ConflictPolicy, StaleContextConflict, ClaimHeldConflict, } from '../policy/types.js';
+export type { TargetRange, ParticipantKind, TargetRef, OnStaleMode, WriteGuard, StaleNotification, ReadDependency, ClaimStatus, WireClaimSummary, ClaimError, WireClaim, ClaimRejection, ModelTarget, ModelClaim, ClaimBeginPayload, ClaimAbandonPayload, ClaimReorderPayload, ClaimHeartbeatPayload, ClaimHeartbeatAckPayload, ClaimHeartbeatBatchPayload, ClaimHeartbeatBatchAckPayload, UpdateSubscriptionPayload, SubscriptionAckPayload, CommitOperationType, CommitOperation, AnyCommitOperation, PresenceKind, PresenceActivity, PresenceUpdateFrame, } from './schema.js';

package/dist/coordination/index.js

@@ -1,6 +1,31 @@
 /**
- * `@abloatai/ablo/coordination` — the canonical wire schema for the three
- * coordination layers (presence, pessimistic claims, optimistic stale-context).
- * See `./schema.ts` for the model and the per-layer schemas.
+ * The `@abloatai/ablo/coordination` entry point. It re-exports the wire
+ * schemas and inferred types for the three coordination layers: presence (who
+ * is currently active), claims (taking exclusive hold of a target before
+ * writing it), and stale-context guards (rejecting a write that was based on an
+ * out-of-date read). The definitions themselves live in the sibling schema
+ * module.
+ *
+ * Exports are listed by name rather than re-exported wholesale, so every symbol
+ * that becomes part of this package's public API is a deliberate choice.
  */
-export * from './schema.js';
+// Runtime schemas + helpers.
+export { 
+// Shared primitives
+targetRangeSchema, participantKindSchema, wireParticipantKindSchema, participantKindFromWire, descriptionFromMeta, targetRefSchema, 
+// Layer 3 — optimistic stale-context
+onStaleModeSchema, writeGuardSchema, staleNotificationSchema, readDependencySchema, 
+// Layer 2 — pessimistic claim / claim-lease
+claimStatusSchema, wireClaimSummarySchema, claimErrorSchema, wireClaimSchema, claimRejectionSchema, modelTargetSchema, modelClaimSchema, claimBeginPayloadSchema, claimAbandonPayloadSchema, claimReorderPayloadSchema, claimHeartbeatPayloadSchema, claimHeartbeatAckPayloadSchema, claimHeartbeatBatchPayloadSchema, claimHeartbeatBatchAckPayloadSchema, 
+// Read interest — area-of-interest navigation
+updateSubscriptionPayloadSchema, subscriptionAckPayloadSchema, 
+// Commit operation — carries the optimistic write-guard
+commitOperationTypeSchema, commitOperationSchema, 
+// Layer 1 — presence
+presenceKindSchema, presenceActivitySchema, presenceUpdateFrameSchema, } from './schema.js';
+// Conflict-policy runtime — the engine detects a conflict, and the policy
+// decides what to do about it. These are re-exported here so that server-side
+// code can reach both the coordination vocabulary and its default conflict
+// resolution from this one subpath, without importing the full client from the
+// package root.
+export { defaultPolicy, capabilityPreemptPolicy, interpretConflictAxis } from '../policy/types.js';