@abloatai/ablo 0.35.0 → 0.37.0

package/dist/client/resourceTypes.d.ts

@@ -1,12 +0,0 @@
-/**
- * The public resource-type surface.
- *
- * The transport-facing half of these types moved down into the settlement core
- * (ADR 0016). This module keeps the
- * consumer-facing import path intact and rejoins it with the model-proxy types
- * that stay here — `ModelOperations` chief among them, because it returns the
- * live participant handle.
- */
-export * from '../transaction/resources/httpResources.js';
-export type { LocalCountOptions, LocalReadOptions, ModelListScope, ServerReadOptions, ModelRetrieveParams, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, ClaimOptions, ClaimParams, ClaimLookupParams, ClaimReorderParams, Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim, HeldLease, } from '../transaction/resources/modelOperations.js';
-export type { ModelOperations } from './createModelProxy.js';

package/dist/client/resourceTypes.js

@@ -1,10 +0,0 @@
-/**
- * The public resource-type surface.
- *
- * The transport-facing half of these types moved down into the settlement core
- * (ADR 0016). This module keeps the
- * consumer-facing import path intact and rejoins it with the model-proxy types
- * that stay here — `ModelOperations` chief among them, because it returns the
- * live participant handle.
- */
-export * from '../transaction/resources/httpResources.js';

package/dist/client/schemaConfig.d.ts

@@ -1,44 +0,0 @@
-/**
- * Derives engine configuration from a schema. This module holds two pure
- * functions: {@link computeFKDepthPriority} works out a safe row-insertion
- * order from the schema's foreign-key relations, and
- * {@link deriveConfigFromSchema} packages that ordering, together with a few
- * defaults, into the {@link RuntimeConfig} a client uses at startup. Both
- * are deterministic transforms of the schema and hold no engine state.
- */
-import type { Schema } from '../transaction/schema/schema.js';
-import type { RuntimeConfig } from '../interfaces/index.js';
-/**
- * Computes a create-priority map that gives the engine a safe order for
- * inserting rows, so a child row is never written before the parent its
- * foreign key references.
- *
- * Every `belongsTo` relation is an edge from a child model to its parent. This
- * function runs Tarjan's strongly-connected-components algorithm over that
- * graph, which does two things at once: it groups any models that reference
- * each other in a cycle into a single component, and it produces those
- * components in an order where parents come before children. Each model then
- * gets a numeric priority from that order, where a lower number means "insert
- * earlier". Top-level models with no parent — an organization or a theme, say —
- * come first, and the deepest descendants come last.
- *
- * Models in the same cycle share a priority, so within a cycle the order rows
- * were queued in breaks the tie. To break a cycle deterministically instead,
- * mark one side of it with `belongsTo(target, fk, { defer: true })`. A deferred
- * edge is left out of the graph, which turns the cycle into a chain and gives
- * the deferred child a strictly higher priority than its parent. Pair it with a
- * Postgres `DEFERRABLE INITIALLY DEFERRED` constraint if you also want the
- * database to relax its check. See {@link BelongsToOptions.defer}.
- *
- * The returned map is keyed by each model's wire type name
- * ({@link ModelDef.typename}, falling back to the schema key), because that is
- * the name the engine looks up at commit time. Keying by the schema key would
- * miss that lookup, and every model would fall back to the default priority.
- *
- * The result does not depend on which model the walk starts from, and the
- * algorithm runs in time linear in the number of models plus relations.
- * Reference: Tarjan, R. (1972), "Depth-first search and linear graph
- * algorithms."
- */
-export declare function computeFKDepthPriority(schema: Schema): ReadonlyMap<string, number>;
-export declare function deriveConfigFromSchema(schema: Schema): RuntimeConfig;

package/dist/client/schemaConfig.js

@@ -1,185 +0,0 @@
-/**
- * Derives engine configuration from a schema. This module holds two pure
- * functions: {@link computeFKDepthPriority} works out a safe row-insertion
- * order from the schema's foreign-key relations, and
- * {@link deriveConfigFromSchema} packages that ordering, together with a few
- * defaults, into the {@link RuntimeConfig} a client uses at startup. Both
- * are deterministic transforms of the schema and hold no engine state.
- */
-import { schemaHash, modelHash, toSchemaJSON } from '../schema/serialize.js';
-// ── Config derivation from schema ─────────────────────────────────────────
-/**
- * Computes a create-priority map that gives the engine a safe order for
- * inserting rows, so a child row is never written before the parent its
- * foreign key references.
- *
- * Every `belongsTo` relation is an edge from a child model to its parent. This
- * function runs Tarjan's strongly-connected-components algorithm over that
- * graph, which does two things at once: it groups any models that reference
- * each other in a cycle into a single component, and it produces those
- * components in an order where parents come before children. Each model then
- * gets a numeric priority from that order, where a lower number means "insert
- * earlier". Top-level models with no parent — an organization or a theme, say —
- * come first, and the deepest descendants come last.
- *
- * Models in the same cycle share a priority, so within a cycle the order rows
- * were queued in breaks the tie. To break a cycle deterministically instead,
- * mark one side of it with `belongsTo(target, fk, { defer: true })`. A deferred
- * edge is left out of the graph, which turns the cycle into a chain and gives
- * the deferred child a strictly higher priority than its parent. Pair it with a
- * Postgres `DEFERRABLE INITIALLY DEFERRED` constraint if you also want the
- * database to relax its check. See {@link BelongsToOptions.defer}.
- *
- * The returned map is keyed by each model's wire type name
- * ({@link ModelDef.typename}, falling back to the schema key), because that is
- * the name the engine looks up at commit time. Keying by the schema key would
- * miss that lookup, and every model would fall back to the default priority.
- *
- * The result does not depend on which model the walk starts from, and the
- * algorithm runs in time linear in the number of models plus relations.
- * Reference: Tarjan, R. (1972), "Depth-first search and linear graph
- * algorithms."
- */
-export function computeFKDepthPriority(schema) {
-    // schemaKey → typename (wire name used at transaction time)
-    const keyToTypename = new Map();
-    for (const [key, def] of Object.entries(schema.models)) {
-        keyToTypename.set(key, def.typename ?? key);
-    }
-    // Adjacency: schemaKey → parent schema keys pulled from `belongsTo`.
-    // Parents not in the schema (e.g. external types) are dropped so the
-    // graph stays closed. Edges marked `{ defer: true }` are also
-    // dropped — the schema author has declared this side of a cycle to
-    // be the "soft" one (insert with null FK, patch later), so the
-    // dependency-graph walker treats it as if the edge weren't there.
-    // That breaks the cycle deterministically and lets the other side
-    // become a strict topological predecessor.
-    const parentsOf = new Map();
-    for (const [key, def] of Object.entries(schema.models)) {
-        const out = [];
-        for (const rel of Object.values(def.relations)) {
-            if (rel.type !== 'belongsTo')
-                continue;
-            if (!keyToTypename.has(rel.target))
-                continue;
-            if (rel.options?.defer === true)
-                continue;
-            out.push(rel.target);
-        }
-        parentsOf.set(key, out);
-    }
-    // Tarjan SCC bookkeeping
-    const dfsIndex = new Map();
-    const lowlink = new Map();
-    const onStack = new Set();
-    const stack = [];
-    const sccs = [];
-    let counter = 0;
-    function strongconnect(v) {
-        dfsIndex.set(v, counter);
-        lowlink.set(v, counter);
-        counter++;
-        stack.push(v);
-        onStack.add(v);
-        for (const w of parentsOf.get(v) ?? []) {
-            if (!dfsIndex.has(w)) {
-                strongconnect(w);
-                lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
-            }
-            else if (onStack.has(w)) {
-                // Back-edge into the active DFS path — w is in the same SCC as v.
-                lowlink.set(v, Math.min(lowlink.get(v), dfsIndex.get(w)));
-            }
-        }
-        // v is the root of an SCC: pop everything down to v inclusive.
-        if (lowlink.get(v) === dfsIndex.get(v)) {
-            const component = [];
-            let w;
-            do {
-                w = stack.pop();
-                onStack.delete(w);
-                component.push(w);
-            } while (w !== v);
-            sccs.push(component);
-        }
-    }
-    for (const key of keyToTypename.keys()) {
-        if (!dfsIndex.has(key))
-            strongconnect(key);
-    }
-    // Tarjan emits SCCs in reverse topological order of the condensation.
-    // In our edge convention (child→parent), reverse-topo of the
-    // condensation means root-SCCs (no outgoing edges = no parents)
-    // first, leaf-SCCs (deepest descendants) last. We could just use
-    // emit-order as the priority — but that gives independent sibling
-    // SCCs different priorities, which is semantically wrong: siblings
-    // don't depend on each other and shouldn't be ordered relative to
-    // each other.
-    //
-    // Instead, do one more pass to compute *longest-path depth* on the
-    // condensation DAG: depth(SCC) = max(depth(parent SCC)) + 1, or 0
-    // for SCCs with no in-schema parents. SCCs at the same depth get
-    // the same priority — siblings stay tied, insertion order in the
-    // queue breaks the tie. Priority = (depth + 1) * 10.
-    //
-    // We can compute this in a single pass over the SCCs because
-    // Tarjan's emit-order *is* a valid topological order of the
-    // condensation: when we process sccs[i], every parent SCC has
-    // already been assigned a depth.
-    const nodeToSccIdx = new Map();
-    sccs.forEach((scc, i) => {
-        for (const node of scc)
-            nodeToSccIdx.set(node, i);
-    });
-    const sccDepth = new Map();
-    sccs.forEach((scc, i) => {
-        let maxParentDepth = -1;
-        for (const node of scc) {
-            for (const parent of parentsOf.get(node) ?? []) {
-                const parentSccIdx = nodeToSccIdx.get(parent);
-                if (parentSccIdx === undefined)
-                    continue;
-                if (parentSccIdx === i)
-                    continue; // intra-SCC edge — not a dep
-                const d = sccDepth.get(parentSccIdx);
-                if (d !== undefined && d > maxParentDepth)
-                    maxParentDepth = d;
-            }
-        }
-        sccDepth.set(i, maxParentDepth + 1);
-    });
-    const out = new Map();
-    sccs.forEach((scc, i) => {
-        const priority = (sccDepth.get(i) + 1) * 10;
-        for (const key of scc) {
-            out.set(keyToTypename.get(key), priority);
-        }
-    });
-    return out;
-}
-export function deriveConfigFromSchema(schema) {
-    // Field-level serialization for commits happens in the transaction queue,
-    // which reads each model's declared fields from the model registry at commit
-    // time. There is no per-field metadata to configure here, so these maps stay
-    // empty.
-    return {
-        modelCreatePriority: computeFKDepthPriority(schema),
-        defaultCreatePriority: 40,
-        defaultNonCreatePriority: 50,
-        essentialFields: {},
-        classNameFallbackMap: {},
-        // Hash this schema once, so startup can detect when it has drifted from the
-        // schema the server currently has active. The server and the `ablo push`
-        // command compute this same hash.
-        expectedSchemaHash: schemaHash(schema),
-        // Per-model hashes for the SEMANTIC drift check: on a whole-hash mismatch
-        // the client compares only the models it declares, so an additive server
-        // change stays silent and a real divergence names the exact models.
-        expectedModelHashes: Object.fromEntries(Object.entries(toSchemaJSON(schema).models).map(([key, model]) => [key, modelHash(model)])),
-        // For a projection (`selectModels`/`omitModels`), also carry the full source
-        // schema's hash. The drift check accepts a server match on either hash, so a
-        // subset client stays quiet against a server running its full source schema.
-        // Undefined for a directly-authored schema — plain equality applies there.
-        expectedSourceSchemaHash: schema.sourceSchemaHash,
-    };
-}

package/dist/client/validateAbloOptions.d.ts

@@ -1,42 +0,0 @@
-/**
- * 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.
- *
- * 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 '../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
- * options object satisfies it without the validator having to depend on the
- * complete type.
- */
-export interface ValidatableAbloOptions {
-    readonly schema?: {
-        readonly models?: Record<string, unknown>;
-    } | null;
-    readonly kind?: ParticipantKind;
-    readonly user?: {
-        readonly id?: string;
-    } | undefined;
-    readonly agentId?: string | undefined;
-    readonly capabilityToken?: string | undefined;
-}
-export interface ValidateAbloOptionsInput {
-    readonly options: ValidatableAbloOptions;
-    readonly url: string;
-    /**
-     * Truthy when an API key was supplied (string or callable). The
-     * validator only inspects presence, never the value, so the input
-     * shape stays loose to accept whatever the caller resolved.
-     */
-    readonly configuredApiKey: unknown;
-    readonly configuredAuthToken: unknown;
-}
-export declare function validateAbloOptions(input: ValidateAbloOptionsInput): AbloError | null;

package/dist/client/validateAbloOptions.js

@@ -1,43 +0,0 @@
-/**
- * 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.
- *
- * 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, AbloValidationError } from '../transaction/errors.js';
-export function validateAbloOptions(input) {
-    const { options, url, configuredApiKey, configuredAuthToken } = input;
-    const kind = options.kind ?? 'user';
-    if (!url) {
-        return new AbloValidationError('Ablo: `url` is required. Pass the sync server URL, e.g. ' +
-            `Ablo({ baseURL: 'wss://api.abloatai.com', schema, user })`, { code: 'base_url_missing' });
-    }
-    if (!options.schema?.models) {
-        return new AbloValidationError('Ablo: `schema` is required. Define it once and access models as `ablo.<model>`.', { code: 'invalid_options', param: 'schema' });
-    }
-    if (!configuredApiKey &&
-        !configuredAuthToken &&
-        !options.capabilityToken &&
-        kind === 'user' &&
-        options.user &&
-        !options.user.id) {
-        return new AbloValidationError('Ablo: `user.id` must be a non-empty string when `user` is provided.', { code: 'invalid_options', param: 'user.id' });
-    }
-    if (!configuredApiKey && !configuredAuthToken && kind === 'agent' && !options.agentId) {
-        return new AbloValidationError('Ablo: provide either `apiKey` or `agentId` for `kind: "agent"`. ' +
-            'Hosted-cloud consumers pass `apiKey` and the server derives the ' +
-            'agent identity from its scope; self-hosted passes `agentId` + ' +
-            '`capabilityToken` directly.', { code: 'invalid_options', param: 'agentId' });
-    }
-    if (!configuredApiKey && !configuredAuthToken && kind === 'agent' && !options.capabilityToken) {
-        return new AbloValidationError('Ablo: provide either `apiKey` (hosted cloud — SDK exchanges internally) ' +
-            'or `capabilityToken` (self-hosted — your auth layer mints + hands in). ' +
-            'See https://abloatai.com/docs/api-keys for the full pattern.', { code: 'invalid_options', param: 'capabilityToken' });
-    }
-    return null;
-}

package/dist/client/wsMutationExecutor.d.ts

@@ -1,27 +0,0 @@
-/**
- * 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 { ReadDependency, TrackDependency } from '../transaction/coordination/schema.js';
-import type { MutationExecutor, MutationOperation } from '../interfaces/index.js';
-import type { CommitAck } from '../sync/commitFrames.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. 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, reads?: readonly ReadDependency[] | null, track?: readonly TrackDependency[] | null) => Promise<CommitAck>;
-} | null): MutationExecutor;

package/dist/client/wsMutationExecutor.js

@@ -1,72 +0,0 @@
-/**
- * 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 '../transaction/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. 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 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?.reads, options?.track);
-        }
-        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,29 +0,0 @@
-/**
- * Module-level accessor for the sync engine's runtime context.
- *
- * 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 { RuntimeContext } from './RuntimeContext.js';
-/**
- * Install the caller-provided runtime dependencies. Must be called before any
- * operation that reaches {@link getContext}.
- */
-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(): RuntimeContext;
-/**
- * Check if the sync engine has been initialized.
- */
-export declare function isRuntimeInitialized(): boolean;
-/**
- * Reset context (for testing or cleanup).
- */
-export declare function resetRuntime(): void;

package/dist/context.js

@@ -1,58 +0,0 @@
-/**
- * Module-level accessor for the sync engine's runtime context.
- *
- * 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 './RuntimeContext.js';
-let _context = null;
-/**
- * Install the caller-provided runtime dependencies. Must be called before any
- * operation that reaches {@link getContext}.
- */
-export function initRuntime(context) {
-    _context = context;
-}
-/**
- * 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 function getContext() {
-    if (!_context) {
-        return _fallback;
-    }
-    return _context;
-}
-/**
- * Check if the sync engine has been initialized.
- */
-export function isRuntimeInitialized() {
-    return _context !== null;
-}
-/**
- * Reset context (for testing or cleanup).
- */
-export function resetRuntime() {
-    _context = null;
-}
-/** Fallback context with no-op implementations */
-const _fallback = {
-    logger: noopLogger,
-    observability: noopObservability,
-    onlineStatus: browserOnlineStatus,
-    sessionErrorDetector: defaultSessionErrorDetector,
-    config: emptyConfig,
-    getModelMetadata: () => undefined,
-    mutationExecutor: {
-        commit: () => Promise.resolve({ lastSyncId: 0, status: 'confirmed' }),
-        executeCreate: () => Promise.resolve(),
-        executeUpdate: () => Promise.resolve(null),
-        executeDelete: () => Promise.resolve(),
-        executeArchive: () => Promise.resolve(),
-        executeUnarchive: () => Promise.resolve(),
-    },
-};

package/dist/coordination/ClaimLog.d.ts

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,32 +0,0 @@
-/**
- * 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 +0,0 @@
-export * from '../transaction/coordination/index.js';

package/dist/coordination/index.js

@@ -1,8 +0,0 @@
-// 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';