@abloatai/ablo 0.34.1 → 0.36.0

package/dist/client/storeLifecycle.js

@@ -0,0 +1,231 @@
+/**
+ * The materialiser's lifecycle: the first credential mint, identity
+ * resolution, the credential-refresh machinery, and the idempotent `ready()`
+ * that drives the store's initialize generator to completion. Extracted from
+ * the composition root along the humans() seam (docs/plans/package-split.md):
+ * the engine wires it with the prelude's credential slice and consumes
+ * `ready`; resolved identity flows back through one callback, so the
+ * engine-side state it seeds (the self locals, the streams) stays with the
+ * engine.
+ */
+import { resolveParticipantIdentity } from '../transaction/auth/identity.js';
+import { AbloAuthenticationError, AbloConnectionError, toAbloError, } from '../transaction/errors.js';
+/**
+ * Wires the credential machinery onto the cluster and returns the `ready`
+ * the client exposes. Wiring happens now — the refresh lifecycle, the
+ * lazy-query auth recovery, the executor binding, and the opt-in auto-start;
+ * the first mint waits for `ready()` so the first connection carries a
+ * token.
+ */
+export function startStoreLifecycle(deps) {
+    const { cluster, schema, internalOptions, authCredentials, credentialResolver, configuredApiKey, configuredAuthToken, url, kind, logger, validationError, onIdentityResolved, } = deps;
+    const { store, components, runtime } = cluster;
+    const { bootstrapHelper, hydration, syncClient } = components;
+    // Hand the credential lifecycle to the client (refresher + proactive refresh
+    // timer + wake/online/focus re-mint). Installed once here so refresh works for
+    // any consumer of `Ablo({ auth })`, not only those who render `<AbloProvider>`.
+    // The first mint happens in `ready()` so the first connection carries a token.
+    //
+    // Long-lived server clients also get the pre-roll timer on windowless hosts
+    // (`proactiveInNode`): their socket must renew its `rk_` or `ek_` before the
+    // server's keepalive reaper closes it (4001 `credential_expired`). Two signals
+    // qualify — an agent or system participant, and an absolute endpoint-string
+    // `apiKey` (a relative one can't be fetched in Node, so an absolute URL is
+    // unambiguously a deliberate server client). User-kind clients in Node (an
+    // SSR/RSC module evaluating scaffolded browser code) stay reactive-only.
+    if (credentialResolver) {
+        const rawEndpoint = internalOptions.authEndpoint ?? internalOptions.apiKey;
+        const absoluteEndpoint = typeof rawEndpoint === 'string' && /^https?:\/\//i.test(rawEndpoint);
+        store.startCredentialLifecycle(credentialResolver, {
+            /* eslint-disable @typescript-eslint/no-deprecated -- `kind` gates the self-hosted proactive pre-roll; hosted path derives it from the apiKey scope */
+            proactiveInNode: internalOptions.kind === 'agent' ||
+                internalOptions.kind === 'system' ||
+                absoluteEndpoint,
+            /* eslint-enable @typescript-eslint/no-deprecated */
+        });
+    }
+    // Put the lazy-query lane on the same auth-recovery path as the WebSocket probe
+    // and the proactive pre-roll: a 401 on `/sync/query` re-mints via the store's
+    // single-flight lifecycle and replays once, instead of silently returning empty
+    // rows against an expired `ek_` until the next proactive tick. Late-bound
+    // because the coordinator is constructed before the store exists.
+    hydration.setCredentialRecovery((recovery) => store.recoverFromAuthRejection(recovery));
+    // Bind this client's executor to its MutationQueue explicitly. The queue
+    // already resolves it through this client's own `runtime`, so this is the
+    // same executor either way; the explicit binding also covers a queue that
+    // was constructed without the instance runtime (subclass and test paths).
+    syncClient.getMutationQueue().setMutationExecutor(runtime.mutationExecutor);
+    // Status is tracked in store.syncStatus (MobX observable) — the single
+    // source of truth. No duplicate closure variables.
+    let _readyPromise = null;
+    let _refreshScheduler = null;
+    async function ready() {
+        if (_readyPromise)
+            return _readyPromise;
+        if (validationError) {
+            _readyPromise = Promise.reject(validationError);
+            return _readyPromise;
+        }
+        _readyPromise = (async () => {
+            try {
+                // Mint the first access credential before we connect, so the initial
+                // WebSocket upgrade and bootstrap carry a valid bearer (no tokenless first
+                // connect that has to self-heal). Only when a refreshing resolver is wired
+                // and no static credential is already present. Follows the `apiKey`
+                // resolver contract: `null` means the login is gone (terminal — fail ready
+                // so the app shows sign-in); a throw means transient (rethrown; autoStart
+                // swallows it and the lifecycle's online/wake triggers retry).
+                if (credentialResolver && !authCredentials.getAuthToken()) {
+                    const token = await credentialResolver();
+                    if (!token) {
+                        throw new AbloAuthenticationError('Auth resolver returned null before connect — the user is not signed in.', { code: 'auth_no_credentials' });
+                    }
+                    authCredentials.setAuthToken(token);
+                }
+                // Resolve participant identity + scope. Three branches —
+                // hosted-cloud apiKey exchange, self-derived from capability
+                // token, or legacy explicit options. See `./identity.ts`.
+                const resolved = await resolveParticipantIdentity({
+                    options: internalOptions,
+                    internalOptions,
+                    url,
+                    kind,
+                    configuredApiKey,
+                    // Resolve identity against the live token, not the construction-time
+                    // `configuredAuthToken`. Consumers using a function `apiKey` never pass
+                    // `authToken` at construction — the lifecycle mints the first `ek_` or
+                    // `rk_` and calls `setAuthToken()` before `ready()`, which updates the
+                    // shared credential source. Reading the frozen `configuredAuthToken`
+                    // here made `/auth/identity` fire with no bearer (returning
+                    // `no_matching_provider` / `session_expired`) even though the token was
+                    // present. This reads the shared credential source, like every other
+                    // transport.
+                    configuredAuthToken: authCredentials.getAuthToken() ?? configuredAuthToken,
+                    bootstrapHelper,
+                    auth: authCredentials,
+                    logger,
+                });
+                const { userId, accountScope, teamIds, capabilityToken, syncGroups, participantKind, } = resolved;
+                // Fail-loud guard: detect the degenerate "no real sync groups
+                // resolved" state before opening the socket. It is the same class of bug as
+                // a sensible-looking default that's functionally broken: the
+                // SDK ends up subscribing only to the server-side
+                // `['default']` fallback, no
+                // delta has that tag, live fan-out silently never delivers.
+                // For human users (kind:'user') this is almost certainly a
+                // misconfiguration upstream — either the caller didn't pass
+                // `syncGroups`, or auth resolution didn't derive them, or
+                // both. Warn loudly so the next debugging session starts here
+                // instead of with "live updates don't work, hard reload fixes
+                // it."
+                const resolvedSyncGroups = syncGroups ?? [];
+                if (participantKind === 'user' &&
+                    (resolvedSyncGroups.length === 0 ||
+                        (resolvedSyncGroups.length === 1 && resolvedSyncGroups[0] === 'default'))) {
+                    // Actionable and not self-healing (no live updates until fixed):
+                    // kept at warn level for consumers; the low-level diagnostic
+                    // fields ride the debug log below.
+                    logger.warn('This client was started without sync groups, so it will not receive ' +
+                        'live updates. Pass `syncGroups` (for example ' +
+                        '`["org:<id>", "user:<id>"]`) or check that your auth provider supplies them.');
+                    logger.debug('degenerate syncGroups — details', { participantKind, resolvedSyncGroups });
+                }
+                // Seed the resolved identity into everything that filters or stamps
+                // by participant — the engine's self locals and its streams, through
+                // the one callback. This runs before the store connects, so no frame
+                // is ever filtered against the construction-time guess.
+                onIdentityResolved({
+                    userId,
+                    participantKind,
+                    accountScope,
+                    syncGroups: resolvedSyncGroups,
+                });
+                if (resolved.refreshScheduler) {
+                    _refreshScheduler = resolved.refreshScheduler;
+                }
+                // Drive the generator to completion. Each yielded promise is awaited
+                // then fed back — this is standard generator consumption.
+                //
+                // The store.initialize() generator updates store.syncStatus as it
+                // progresses (syncing → idle on success, error on failure), so the
+                // consumer's `sync.syncStatus` observable reflects real-time state.
+                // Resolve bootstrap mode: explicit option wins; otherwise
+                // agents default to 'none' (transactional participant — see
+                // option doc) and everyone else defaults to 'full'.
+                const resolvedBootstrapMode = internalOptions.bootstrapMode ?? (participantKind === 'agent' ? 'none' : 'full');
+                const gen = store.initialize({
+                    userId,
+                    organizationId: accountScope,
+                    teamIds,
+                    kind: participantKind,
+                    capabilityToken,
+                    syncGroups,
+                    bootstrapMode: resolvedBootstrapMode,
+                });
+                let current = gen.next();
+                while (!current.done) {
+                    const yielded = current.value;
+                    const settled = yielded instanceof Promise ? await yielded : yielded;
+                    current = gen.next(settled);
+                }
+                const result = current.value;
+                if (!result.success) {
+                    throw result.error
+                        ? toAbloError(result.error)
+                        : new AbloConnectionError('Sync engine initialization failed', {
+                            code: 'bootstrap_fetch_timeout',
+                        });
+                }
+                logger.info('Sync engine ready', { models: Object.keys(schema.models).length });
+            }
+            catch (err) {
+                // Coerce so the rejection a consumer awaiting `ready()` catches is
+                // always an AbloError — connection setup is held to the same
+                // never-leak-untagged contract as the model operations.
+                const error = toAbloError(err);
+                // Make sure syncStatus reflects the failure for observer() components
+                store.syncStatus.state = 'error';
+                store.syncStatus.error = error;
+                // Log the typed envelope (type + code + status), not just the bare
+                // message — so the console line names it as an Ablo error and carries
+                // the code (e.g. AbloAuthenticationError/identity_resolve_failed on a
+                // 401) instead of reading like an untagged failure.
+                logger.error('Sync engine failed to initialize', {
+                    type: error.type,
+                    code: error.code,
+                    httpStatus: error.httpStatus,
+                    error: error.message,
+                });
+                // Clear the memo so a future `ready()` re-attempts bootstrap instead of
+                // replaying this rejection forever. Bootstrap failures here are transient
+                // by nature — offline, an IndexedDB open timeout, a bootstrap fetch
+                // hiccup — and the early `if (_readyPromise) return _readyPromise` guard
+                // would otherwise hand every later caller this same dead promise, bricking
+                // the engine until a full page reload. Nulling it lets the provider's
+                // online/wake/retry triggers drive a clean re-bootstrap. (The terminal
+                // `validationError` branch above intentionally stays cached — config
+                // can't change without recreating the engine.)
+                _readyPromise = null;
+                throw error;
+            }
+        })();
+        return _readyPromise;
+    }
+    // Optional auto-start for convenience. Opt-in because silent background
+    // init has historically been the #1 source of "why isn't my data loading"
+    // bug reports. Explicit `await sync.ready()` is the default — errors
+    // surface immediately instead of being swallowed.
+    if (!validationError && internalOptions.autoStart) {
+        void ready().catch(() => {
+            // Error is captured in store.syncStatus; consumers should check
+            // `sync.syncStatus.state === 'error'` to detect failures.
+        });
+    }
+    return {
+        ready,
+        dispose() {
+            _refreshScheduler?.dispose();
+            _refreshScheduler = null;
+        },
+    };
+}

package/dist/client/validateAbloOptions.d.ts

@@ -9,7 +9,8 @@
  * 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';
+import { AbloError } from '../transaction/errors.js';
+import type { ParticipantKind } from '../transaction/types/participant.js';
 /**
  * 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
@@ -20,7 +21,7 @@ export interface ValidatableAbloOptions {
     readonly schema?: {
         readonly models?: Record<string, unknown>;
     } | null;
-    readonly kind?: 'user' | 'agent' | 'system';
+    readonly kind?: ParticipantKind;
     readonly user?: {
         readonly id?: string;
     } | undefined;

package/dist/client/validateAbloOptions.js

@@ -9,7 +9,7 @@
  * problem, because the identity error messages mention the URL and would
  * mislead if the URL were the thing actually missing.
  */
-import { AbloError, AbloValidationError } from '../errors.js';
+import { AbloError, AbloValidationError } from '../transaction/errors.js';
 export function validateAbloOptions(input) {
     const { options, url, configuredApiKey, configuredAuthToken } = input;
     const kind = options.kind ?? 'user';

package/dist/client/wsMutationExecutor.d.ts

@@ -4,7 +4,7 @@
  * 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 { ReadDependency, TrackDependency } from '../coordination/schema.js';
+import type { ReadDependency, TrackDependency } from '../transaction/coordination/schema.js';
 import type { MutationExecutor, MutationOperation } from '../interfaces/index.js';
 import type { CommitAck } from '../sync/commitFrames.js';
 /**
@@ -18,10 +18,10 @@ import type { CommitAck } from '../sync/commitFrames.js';
  * the ready socket.
  *
  * When set, `options.idempotencyKey` is sent as the wire-level `clientTxId`, so
- * retrying a call with the same key is safe. TransactionQueue always supplies
+ * retrying a call with the same key is safe. MutationQueue always supplies
  * this key before its first attempt and owns reuse across retries. The fallback
  * generation below exists only for direct, one-shot executor consumers.
  */
 export declare function createDefaultMutationExecutor(getWs: () => {
-    sendCommit?: (operations: readonly MutationOperation[], clientTxId: string, timeoutMs?: number, causedByTaskId?: string | null, reads?: readonly ReadDependency[] | null, track?: readonly TrackDependency[] | null) => Promise<CommitAck>;
+    sendCommit?: (operations: readonly MutationOperation[], clientTxId: string, timeoutMs?: number, reads?: readonly ReadDependency[] | null, track?: readonly TrackDependency[] | null) => Promise<CommitAck>;
 } | null): MutationExecutor;

package/dist/client/wsMutationExecutor.js

@@ -4,7 +4,7 @@
  * 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';
+import { AbloError, AbloConnectionError } from '../transaction/errors.js';
 // ── Default mutation executor (wire: `commit` frame over WebSocket) ──────
 /**
  * Creates the default mutation executor, which sends each change as a `commit`
@@ -17,7 +17,7 @@ import { AbloError, AbloConnectionError } from '../errors.js';
  * the ready socket.
  *
  * When set, `options.idempotencyKey` is sent as the wire-level `clientTxId`, so
- * retrying a call with the same key is safe. TransactionQueue always supplies
+ * retrying a call with the same key is safe. MutationQueue always supplies
  * this key before its first attempt and owns reuse across retries. The fallback
  * generation below exists only for direct, one-shot executor consumers.
  */
@@ -34,7 +34,7 @@ export function createDefaultMutationExecutor(getWs) {
                 : `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, options?.track);
+            options?.reads, options?.track);
         }
         catch (err) {
             // Wrap transport-level failures as connection errors so the transaction

package/dist/context.d.ts

@@ -1,29 +1,42 @@
 /**
- * Module-level accessor for the sync engine's shared context.
+ * Module-level accessor for the sync engine's runtime context.
  *
- * The context is set once, during initialization, by {@link initSyncEngine}.
+ * The context is set once, during initialization, by {@link initRuntime}.
  * 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';
+import type { RuntimeContext } from './RuntimeContext.js';
 /**
- * Initialize the sync engine with application-provided dependencies.
- * Must be called before any sync engine operations.
+ * Install the caller-provided runtime dependencies. Must be called before any
+ * operation that reaches {@link getContext}.
  */
-export declare function initSyncEngine(context: SyncEngineContext): void;
+export declare function initRuntime(context: RuntimeContext): void;
 /**
  * Get the current sync engine context.
  * Returns a safe fallback with no-op implementations if not yet initialized,
  * so SDK files can import at module load time without crashing.
  */
-export declare function getContext(): SyncEngineContext;
+export declare function getContext(): RuntimeContext;
+/**
+ * The module-global runtime as an instance-shaped value — the bridge for code
+ * that is not yet constructed with its client's own `RuntimeContext`.
+ *
+ * Every member reads {@link getContext} at call time, so a context installed
+ * after construction is still picked up (tests construct first and
+ * `initRuntime` later). Classes take `runtime` as a constructor option with
+ * this as the default; a client that threads its own instance is isolated
+ * from other clients in the same process, a construction that doesn't is
+ * last-writer-wins exactly as before. Retired reference by reference as
+ * construction moves behind `humans()` (docs/plans/package-split.md).
+ */
+export declare const globalRuntime: RuntimeContext;
 /**
  * Check if the sync engine has been initialized.
  */
-export declare function isSyncEngineInitialized(): boolean;
+export declare function isRuntimeInitialized(): boolean;
 /**
  * Reset context (for testing or cleanup).
  */
-export declare function resetSyncEngine(): void;
+export declare function resetRuntime(): void;

package/dist/context.js

@@ -1,19 +1,19 @@
 /**
- * Module-level accessor for the sync engine's shared context.
+ * Module-level accessor for the sync engine's runtime context.
  *
- * The context is set once, during initialization, by {@link initSyncEngine}.
+ * The context is set once, during initialization, by {@link initRuntime}.
  * 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';
+import { noopLogger, noopObservability, browserOnlineStatus, defaultSessionErrorDetector, emptyConfig, } from './RuntimeContext.js';
 let _context = null;
 /**
- * Initialize the sync engine with application-provided dependencies.
- * Must be called before any sync engine operations.
+ * Install the caller-provided runtime dependencies. Must be called before any
+ * operation that reaches {@link getContext}.
  */
-export function initSyncEngine(context) {
+export function initRuntime(context) {
     _context = context;
 }
 /**
@@ -27,16 +27,39 @@ export function getContext() {
     }
     return _context;
 }
+/**
+ * The module-global runtime as an instance-shaped value — the bridge for code
+ * that is not yet constructed with its client's own `RuntimeContext`.
+ *
+ * Every member reads {@link getContext} at call time, so a context installed
+ * after construction is still picked up (tests construct first and
+ * `initRuntime` later). Classes take `runtime` as a constructor option with
+ * this as the default; a client that threads its own instance is isolated
+ * from other clients in the same process, a construction that doesn't is
+ * last-writer-wins exactly as before. Retired reference by reference as
+ * construction moves behind `humans()` (docs/plans/package-split.md).
+ */
+export const globalRuntime = {
+    get logger() { return getContext().logger; },
+    get observability() { return getContext().observability; },
+    get analytics() { return getContext().analytics; },
+    get sessionErrorDetector() { return getContext().sessionErrorDetector; },
+    get onlineStatus() { return getContext().onlineStatus; },
+    get modelDebugLogger() { return getContext().modelDebugLogger; },
+    get mutationExecutor() { return getContext().mutationExecutor; },
+    get config() { return getContext().config; },
+    getModelMetadata: (name) => getContext().getModelMetadata(name),
+};
 /**
  * Check if the sync engine has been initialized.
  */
-export function isSyncEngineInitialized() {
+export function isRuntimeInitialized() {
     return _context !== null;
 }
 /**
  * Reset context (for testing or cleanup).
  */
-export function resetSyncEngine() {
+export function resetRuntime() {
     _context = null;
 }
 /** Fallback context with no-op implementations */
@@ -46,8 +69,9 @@ const _fallback = {
     onlineStatus: browserOnlineStatus,
     sessionErrorDetector: defaultSessionErrorDetector,
     config: emptyConfig,
+    getModelMetadata: () => undefined,
     mutationExecutor: {
-        commit: () => Promise.resolve({ lastSyncId: 0 }),
+        commit: () => Promise.resolve({ lastSyncId: 0, status: 'confirmed' }),
         executeCreate: () => Promise.resolve(),
         executeUpdate: () => Promise.resolve(null),
         executeDelete: () => Promise.resolve(),

package/dist/coordination/ClaimLog.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Sync-engine compatibility adapter for the transaction layer's narrow claim
+ * log. The core log knows only claim/conflict events; this subclass supplies
+ * inert implementations for the client lifecycle hooks required by
+ * `ObservabilityProvider`, preserving `Ablo({ observability: new ClaimLog() })`
+ * without leaking bootstrap, storage, or WebSocket vocabulary into the core.
+ */
+import { ClaimLog as CoordinationClaimLog } from '../transaction/coordination/trace.js';
+import type { ObservabilityProvider } from '../interfaces/index.js';
+export { formatClaim, formatConflict } from '../transaction/coordination/trace.js';
+export type { ClaimLogEntry } from '../transaction/coordination/trace.js';
+export declare class ClaimLog extends CoordinationClaimLog implements ObservabilityProvider {
+    setContext(): void;
+    setConnectionState(): void;
+    breadcrumb(): void;
+    captureRollback(): void;
+    captureMutationFailure(): void;
+    captureBootstrapFailure(): void;
+    captureReconciliation(): void;
+    captureDeltaRetryExhausted(): void;
+    captureWebSocketError(): void;
+    captureSelfHealing(): void;
+    captureCommitZeroSyncId(): void;
+    startSpan<T>(_name: string, _op: string, fn: () => T): T;
+    startSpanAsync<T>(_name: string, _op: string, fn: () => Promise<T>): Promise<T>;
+}

package/dist/coordination/ClaimLog.js

@@ -0,0 +1,32 @@
+/**
+ * Sync-engine compatibility adapter for the transaction layer's narrow claim
+ * log. The core log knows only claim/conflict events; this subclass supplies
+ * inert implementations for the client lifecycle hooks required by
+ * `ObservabilityProvider`, preserving `Ablo({ observability: new ClaimLog() })`
+ * without leaking bootstrap, storage, or WebSocket vocabulary into the core.
+ */
+import { ClaimLog as CoordinationClaimLog } from '../transaction/coordination/trace.js';
+export { formatClaim, formatConflict } from '../transaction/coordination/trace.js';
+export class ClaimLog extends CoordinationClaimLog {
+    // Client-lifecycle hooks the claim log has no notion of. Every body below is
+    // deliberately inert: the log records claims and conflicts, nothing else.
+    setContext() { }
+    setConnectionState() { }
+    breadcrumb() { }
+    captureRollback() { }
+    captureMutationFailure() { }
+    captureBootstrapFailure() { }
+    captureReconciliation() { }
+    captureDeltaRetryExhausted() { }
+    captureWebSocketError() { }
+    captureSelfHealing() { }
+    captureCommitZeroSyncId() { }
+    // Spans run their body untimed; the trailing `attributes` argument callers
+    // pass has nowhere to go here, so it is left off the signature.
+    startSpan(_name, _op, fn) {
+        return fn();
+    }
+    startSpanAsync(_name, _op, fn) {
+        return fn();
+    }
+}

package/dist/coordination/index.d.ts

@@ -1,15 +1 @@
-/**
- * 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 { targetRangeSchema, participantKindSchema, wireParticipantKindSchema, participantKindFromWire, descriptionFromMeta, targetRefSchema, onStaleModeSchema, writeGuardSchema, staleNotificationSchema, readDependencySchema, trackDependencySchema, 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, TrackDependency, 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';
+export * from '../transaction/coordination/index.js';

package/dist/coordination/index.js

@@ -1,31 +1,8 @@
-/**
- * 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.
- */
-// Runtime schemas + helpers.
-export { 
-// Shared primitives
-targetRangeSchema, participantKindSchema, wireParticipantKindSchema, participantKindFromWire, descriptionFromMeta, targetRefSchema, 
-// Layer 3 — optimistic stale-context
-onStaleModeSchema, writeGuardSchema, staleNotificationSchema, readDependencySchema, trackDependencySchema, 
-// 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';
+// Moved to @ablo/transaction (ADR 0013 — the settlement core extraction).
+// This shim re-exports it at the original path so in-package importers of
+// `coordination/index.js` keep working; rewire to `@ablo/transaction/coordination`
+// and delete this shim once the core package is fully wired.
+//
+// Line comments on purpose: tsc copies a leading JSDoc block into the
+// published `.d.ts`, and this note names a package npm has never heard of.
+export * from '../transaction/coordination/index.js';

package/dist/core/index.d.ts

@@ -21,8 +21,8 @@ export { Model } from '../Model.js';
 export { LazyReferenceCollection, type LazyCollectionOptions, } from '../LazyReferenceCollection.js';
 export { ModelRegistry, getActiveRegistry, } from '../ModelRegistry.js';
 export { postQuery, type PostQueryOptions } from '../query/client.js';
-export { computeFKDepthPriority } from '../client/Ablo.js';
-export type { SyncLogger, SyncObservabilityProvider, MutationExecutor, SessionErrorDetector, OnlineStatusProvider, CommitResult, MutationOperation, } from '../interfaces/index.js';
+export { computeFKDepthPriority } from '../client/schemaConfig.js';
+export type { SyncLogger, SyncObservabilityProvider, MutationExecutor, SessionErrorDetector, OnlineStatusProvider, CommitResult, MutationOperation, MutationOptions, } from '../interfaces/index.js';
 export { SyncWebSocket, type SyncDelta, type SyncWebSocketOptions, } from '../sync/SyncWebSocket.js';
 export { BootstrapFetcher } from '../sync/BootstrapFetcher.js';
 /** @deprecated `BootstrapHelper` was renamed to {@link BootstrapFetcher}. This alias keeps
@@ -30,4 +30,4 @@ export { BootstrapFetcher } from '../sync/BootstrapFetcher.js';
 export { BootstrapFetcher as BootstrapHelper } from '../sync/BootstrapFetcher.js';
 export { createClaimStream, type AttachableClaimStream, type ClaimStreamConfig, } from '../sync/createClaimStream.js';
 export { awaitClaimGrant, type GrantTransport, } from '../sync/awaitClaimGrant.js';
-export { LoadStrategy } from '../types/index.js';
+export { LoadStrategy } from '../transaction/types/index.js';

package/dist/core/index.js

@@ -28,7 +28,7 @@ export { postQuery } from '../query/client.js';
 // Computes a dependency-safe ordering for a set of models by walking their
 // foreign-key relationships, so writes commit parents before children. Used by
 // schema-aware test fixtures and scaffolding tools.
-export { computeFKDepthPriority } from '../client/Ablo.js';
+export { computeFKDepthPriority } from '../client/schemaConfig.js';
 // The sync layer: the WebSocket wrapper and the delta shape it carries. Needed
 // when writing a sync adapter or a multi-participant test harness.
 export { SyncWebSocket, } from '../sync/SyncWebSocket.js';
@@ -45,4 +45,4 @@ export { createClaimStream, } from '../sync/createClaimStream.js';
 export { awaitClaimGrant, } from '../sync/awaitClaimGrant.js';
 // An enum naming the strategies for loading a model's data. Referenced when
 // registering models in extension code.
-export { LoadStrategy } from '../types/index.js';
+export { LoadStrategy } from '../transaction/types/index.js';