@abloatai/ablo 0.34.1 → 0.36.0

package/dist/{sync/syncPosition.js → transaction/logPosition.js}

@@ -30,13 +30,13 @@
  * necessarily lands above our acknowledgement and still rejects as stale.
  *
  * The validation schema is the state shape: the class holds exactly one
- * {@link SyncPositionSnapshot} and merges monotonically into it, so snapshot
- * and restore share that shape and {@link parseSyncPosition} is the single gate
+ * {@link LogPositionSnapshot} and merges monotonically into it, so snapshot
+ * and restore share that shape and {@link parseLogPosition} is the single gate
  * for anything loaded from disk — a corrupted cursor stored "ahead of reality"
  * being a known failure mode.
  */
 import { z } from 'zod';
-export const syncPositionSchema = z.object({
+export const logPositionSchema = z.object({
     /** The resume cursor; advances only after deltas persist to durable local storage. */
     persisted: z.number().int().nonnegative(),
     /** The in-memory cursor: the last delta applied to the object pool. */
@@ -56,8 +56,8 @@ export const syncPositionSchema = z.object({
  * Validates an untrusted value, such as one loaded from disk, into a position
  * snapshot, or returns null when it does not match the schema.
  */
-export function parseSyncPosition(value) {
-    const result = syncPositionSchema.safeParse(value);
+export function parseLogPosition(value) {
+    const result = logPositionSchema.safeParse(value);
     return result.success ? result.data : null;
 }
 const ZERO = { persisted: 0, applied: 0, acked: 0 };
@@ -73,7 +73,7 @@ function advance(state, next) {
  * The live sync position: one instance per client. Three producers each
  * advance their own cursor, and consumers read the result.
  */
-export class SyncPosition {
+export class LogPosition {
     #state = ZERO;
     /** Returns a copy of the current state in the schema's shape. */
     snapshot() {
@@ -114,3 +114,12 @@ export class SyncPosition {
         this.#state = advance(this.#state, snapshot);
     }
 }
+// ── Deprecated aliases (renamed from the sync/syncPosition module, 2026-07-17) ──
+// The position is a participant's place in the transaction log; the old names
+// said the consumer. Same class, same instanceof identity. Removed in 0.36.0.
+/** @deprecated Renamed to {@link logPositionSchema}. Removed in 0.36.0. */
+export const syncPositionSchema = logPositionSchema;
+/** @deprecated Renamed to {@link parseLogPosition}. Removed in 0.36.0. */
+export const parseSyncPosition = parseLogPosition;
+/** @deprecated Renamed to {@link LogPosition}. Removed in 0.36.0. */
+export const SyncPosition = LogPosition;

package/dist/transaction/logger.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The logging port the SDK writes through.
+ *
+ * A contract with no framework and no local state: credential exchange, commit,
+ * and claim all need to log with no UI and no offline store present, so the port
+ * belongs to the settlement core (ADR 0016). The consumer supplies the
+ * implementation; the SDK ships a no-op default.
+ */
+export interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/** The no-op default — what the core logs through when no logger is wired. */
+export declare const noopLogger: Logger;

package/dist/transaction/logger.js

@@ -0,0 +1,7 @@
+/** The no-op default — what the core logs through when no logger is wired. */
+export const noopLogger = {
+    debug() { },
+    info() { },
+    warn() { },
+    error() { },
+};

package/dist/transaction/observability.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The observability the settlement core reports on its own behalf.
+ *
+ * Coordination outcomes — a claim changing state, a stale-write collision that
+ * notified instead of aborting — happen with no UI and no local store anywhere,
+ * so the core must be able to report them without depending on the consumer's
+ * full provider (ADR 0016).
+ *
+ * This is deliberately the narrow set the core actually calls today. Widening it
+ * later is non-breaking; the reactive engine's `ObservabilityProvider` extends
+ * this interface, so a single implementation still satisfies both.
+ */
+import type { ClaimEvent, ConflictEvent } from './coordination/events.js';
+export interface CoordinationObservability {
+    /** Capture a claim state change (acquired / queued / granted / lost / rejected / expired). */
+    captureClaim(event: ClaimEvent): void;
+    /** Capture a notify-instead-of-abort stale-write collision. */
+    captureConflict(event: ConflictEvent): void;
+}
+/** Breadcrumb severity levels */
+export type BreadcrumbLevel = 'debug' | 'info' | 'warning' | 'error';
+/** Breadcrumb categories for sync engine lifecycle events */
+export type BreadcrumbCategory = 'sync.bootstrap' | 'sync.transaction' | 'sync.websocket' | 'sync.offline' | 'sync.database' | 'sync.conflict' | 'sync.coordination' | 'sync.groups';
+export interface WebSocketErrorDetails {
+    context: string;
+    error?: string;
+    code?: number;
+    reason?: string;
+}
+/**
+ * The observability the duplex transport reports on its own behalf: connection
+ * lifecycle breadcrumbs and socket errors. A server-side agent holding a socket
+ * for claim push has no store and no UI, so the transport must be able to
+ * report without the consumer's full provider — the same reasoning as
+ * {@link CoordinationObservability}, one layer down. The reactive engine's
+ * `ObservabilityProvider` extends this interface, so a single implementation
+ * satisfies both.
+ */
+export interface TransportObservability {
+    /** Add a breadcrumb for sync lifecycle events */
+    breadcrumb(message: string, category: BreadcrumbCategory, level?: BreadcrumbLevel, data?: Record<string, string | number | boolean | undefined>): void;
+    /** Capture WebSocket error */
+    captureWebSocketError(details: WebSocketErrorDetails): void;
+}
+/**
+ * Everything the duplex transport reports: its own lifecycle
+ * ({@link TransportObservability}) plus the coordination outcomes that ride
+ * the socket ({@link CoordinationObservability} — claim pushes and notified
+ * collisions arrive as frames, so the transport is where they surface).
+ */
+export type SocketObservability = TransportObservability & CoordinationObservability;
+/** The no-op default — what the transport reports through when nothing is wired. */
+export declare const noopSocketObservability: SocketObservability;

package/dist/transaction/observability.js

@@ -0,0 +1,19 @@
+/**
+ * The observability the settlement core reports on its own behalf.
+ *
+ * Coordination outcomes — a claim changing state, a stale-write collision that
+ * notified instead of aborting — happen with no UI and no local store anywhere,
+ * so the core must be able to report them without depending on the consumer's
+ * full provider (ADR 0016).
+ *
+ * This is deliberately the narrow set the core actually calls today. Widening it
+ * later is non-breaking; the reactive engine's `ObservabilityProvider` extends
+ * this interface, so a single implementation still satisfies both.
+ */
+/** The no-op default — what the transport reports through when nothing is wired. */
+export const noopSocketObservability = {
+    breadcrumb() { },
+    captureWebSocketError() { },
+    captureClaim() { },
+    captureConflict() { },
+};

package/dist/transaction/plugin.d.ts

@@ -0,0 +1,285 @@
+/**
+ * The plugin contract (ADR 0016).
+ *
+ * The core is `commit` · `get`/`list` · `observe` · `claim` · auth. Everything
+ * else a caller might want — a local materialised copy, presence rendering,
+ * batching, framework bindings — is a plugin declared in one list, so a server
+ * or an agent installs only what it asked for.
+ *
+ * Every plugin has the same shape on purpose. Uniformity is what makes the list
+ * composable and the types inferable; bespoke plugins would reproduce today's
+ * nineteen export subpaths with extra ceremony.
+ *
+ * Where this shape came from, and the field-by-field reasoning behind it, is
+ * recorded in ADR 0016 — the contract itself only states what each field does.
+ */
+import type { ParticipantKind } from './types/participant.js';
+import type { ErrorCodeSpec } from './errorCodes.js';
+import type { Logger } from './logger.js';
+import type { CoordinationObservability } from './observability.js';
+import type { WsTransport } from './transport/wsTransport.js';
+import type { AuthCredentialSource } from './auth/credentialSource.js';
+import type { SyncDeltaWireCore } from './wire/delta.js';
+import type { ModelData } from './types/modelData.js';
+/**
+ * A string type that keeps literal inference alive: `id: 'humans'` stays the
+ * literal `'humans'` through object-literal inference instead of widening to
+ * `string`, which is what lets {@link InstalledSurface} key a plugin list's
+ * surface by id.
+ */
+export type LiteralString = '' | (string & Record<never, never>);
+/**
+ * The ordered stages a delta passes through on its way from the feed into
+ * whatever is watching. A plugin names the one it attaches to.
+ *
+ * The order is not a convention — it is a correctness constraint. `acknowledge`
+ * must follow `persist`, because acknowledging the input range rather than the
+ * persisted high-water mark advances the server's cursor past deltas that never
+ * committed, and the next catch-up then answers "you're up to date" for a delta
+ * that was lost. Declaring the stage keeps that ordering out of array position,
+ * where it would be load-bearing and undocumented.
+ */
+export type PipelineStage = 
+/** Deltas arrive from `observe()` and are queued. */
+'receive'
+/** Per-entity collapse of the queued batch. */
+ | 'dedupe'
+/** The batch is written to durable local storage. */
+ | 'persist'
+/** Persisted results land in the in-memory graph. */
+ | 'apply'
+/** The cursor advances — gated on `persist`, never on the input range. */
+ | 'acknowledge'
+/** Anything downstream reacts: re-render, presence, subscribers. */
+ | 'notify';
+/** Canonical order. A plugin runner must run stages in this sequence. */
+export declare const PIPELINE_STAGES: readonly PipelineStage[];
+/**
+ * A delta as stage handlers receive it — the identity slice of the wire
+ * shape, projected rather than restated so the wire schema stays the one
+ * definition.
+ */
+export type StageDelta = Pick<SyncDeltaWireCore, 'id' | 'actionType' | 'modelName' | 'modelId'>;
+/**
+ * One persisted change: what the durable write reported and the apply stage
+ * lands in the in-memory graph. `data` is absent for actions that carry
+ * none (a remove reports identity only).
+ */
+export interface AppliedChange {
+    action: 'add' | 'update' | 'remove' | 'archive' | 'verify';
+    modelName: string;
+    modelId: string;
+    data?: ModelData | null;
+    /**
+     * Server-stamped transaction id, echoing the client's own commit
+     * operation id — how a client recognizes the confirmation of a change it
+     * already applied locally. Absent for system-emitted changes, which have
+     * no client transaction behind them.
+     */
+    transactionId?: string;
+}
+/**
+ * What each stage hands its handlers. Read off the delta pipeline these
+ * stages were read off, not invented: `receive` sees the delta being
+ * queued, `dedupe` and `persist` see the batch at those boundaries,
+ * `apply` and `notify` see the persisted changes, and `acknowledge` sees
+ * the persistence-gated cursor value.
+ */
+export interface StagePayloads {
+    receive: {
+        readonly delta: StageDelta;
+    };
+    dedupe: {
+        readonly deltas: readonly StageDelta[];
+    };
+    persist: {
+        readonly deltas: readonly StageDelta[];
+    };
+    apply: {
+        readonly changes: readonly AppliedChange[];
+    };
+    acknowledge: {
+        readonly syncId: number;
+    };
+    notify: {
+        readonly changes: readonly AppliedChange[];
+    };
+}
+/** The handler a plugin attaches at one stage. The payload derives from the key. */
+export type StageHandler<K extends PipelineStage> = (payload: StagePayloads[K]) => void;
+/**
+ * What a capability needs from whatever transport was selected.
+ *
+ * Transport is a slot the caller fills, not a packaging axis, so a capability
+ * states its requirement and an incompatible pairing fails when the client is
+ * configured — with a typed error naming the plugin — rather than at runtime
+ * with a subscription that silently never delivers.
+ */
+export interface TransportCapabilities {
+    /**
+     * Requires a transport the server can initiate frames on. Live subscriptions,
+     * presence, and claim grants need this; commit and point-in-time reads do not.
+     */
+    readonly duplex?: boolean;
+}
+/**
+ * The core surface a plugin is handed at construction.
+ *
+ * Generic over the client's options type: the host instantiates it with its
+ * own options bag, so a plugin reads configuration without this package
+ * naming any consumer's types. Alongside the raw options, the context
+ * carries the values the host has already resolved (`participant`,
+ * `syncGroups`), so a plugin never re-derives identity.
+ */
+export interface PluginContext<Options = unknown> {
+    readonly logger: Logger;
+    readonly observability?: CoordinationObservability;
+    /** The client's own options bag, as the host received it. */
+    readonly options?: Options;
+    /**
+     * The live duplex connection. The host builds it during construction, so a
+     * plugin holds the thing rather than a function that fetches it: the
+     * connection object is stable for the client's lifetime — identity and
+     * read scope are seeded into it when they resolve, and reconnects replace
+     * only the socket inside it, never the object. Absent on a
+     * request-response client, which is what `requires: { duplex: true }`
+     * guards.
+     */
+    readonly transport?: WsTransport;
+    /** The participant this client runs as, when known at construction. */
+    readonly participant?: {
+        readonly id: string;
+        readonly kind: ParticipantKind;
+    };
+    /** The connection's initial read scope (sync groups). */
+    readonly syncGroups?: readonly string[];
+    /** The resolved server base URL, settled by the host before construction. */
+    readonly url?: string;
+    /**
+     * The client's single bearer-credential source, shared with every
+     * auth-aware transport the host built. A plugin that constructs its own
+     * fetching component hands this on rather than re-deriving a credential.
+     */
+    readonly auth?: AuthCredentialSource;
+    /**
+     * Whether a plugin with the given id is installed on this client. Supplied
+     * by {@link resolvePlugins} from the list it is resolving — the one place
+     * that truthfully knows the assembly — so a plugin interrogates what is
+     * installed instead of the host special-casing plugins by name.
+     */
+    readonly hasPlugin?: (id: string) => boolean;
+    /**
+     * The resolved plugin list itself, supplied by {@link resolvePlugins}
+     * alongside {@link hasPlugin} (which derives from it). A component a
+     * plugin constructs — the store and its delta pipeline — holds this list
+     * to dispatch the declared stage handlers through {@link runStage}.
+     */
+    readonly plugins?: readonly AbloPlugin[];
+}
+/**
+ * One installed capability.
+ *
+ * @typeParam Surface - what `init` contributes to the client. The plugin list's
+ * element types are what let the installed surface be inferred rather than
+ * declared.
+ */
+export interface AbloPlugin<Surface = unknown> {
+    /** Stable identity — deduplication, diagnostics, and error attribution.
+     *  Literal-typed so a list's installed surface can be keyed by it. */
+    readonly id: LiteralString;
+    /** The plugin's own version, for diagnostics. */
+    readonly version?: string;
+    /** What this plugin needs from the transport. Checked at configuration time. */
+    readonly requires?: TransportCapabilities;
+    /**
+     * Whether this plugin keeps a local copy of rows.
+     *
+     * This is ADR 0013 §4's membership test as a declared, checkable property
+     * rather than a rule someone has to remember: a stateless caller can assert
+     * that nothing in its list materialises, and CI can assert the core's own
+     * list is uniformly `false`.
+     */
+    readonly materialises: boolean;
+    /**
+     * Error codes this plugin may raise, folded into the registry.
+     *
+     * Registration is part of the contract because the error catalog is
+     * generated — a plugin that invents untyped errors would silently punch a
+     * hole in the published reference.
+     */
+    readonly errorCodes?: Readonly<Record<string, ErrorCodeSpec>>;
+    /**
+     * The pipeline stages this plugin attaches to: each key names a stage and
+     * holds the handler the runner invokes there. One field on purpose — a
+     * declared stage cannot exist without its handler, nor a handler without
+     * its stage, so the declaration can never point at nothing. The payload
+     * type derives from the key ({@link StagePayloads}).
+     */
+    readonly stages?: {
+        readonly [K in PipelineStage]?: StageHandler<K>;
+    };
+    /** Build the plugin's contribution to the client surface. */
+    init(context: PluginContext): Surface;
+}
+/** The surface a plugin list contributes, keyed by plugin id. */
+export type InstalledSurface<Plugins extends readonly AbloPlugin[]> = {
+    [P in Plugins[number] as P['id']]: P extends AbloPlugin<infer S> ? S : never;
+};
+/**
+ * The plugin with the given id in a list, or `never` when absent. Sound
+ * because ids are literal ({@link LiteralString}); a list typed only as
+ * `AbloPlugin[]` has widened ids and resolves to `never`, so write plugin
+ * lists inline for the client type to follow them.
+ */
+export type PluginById<Plugins extends readonly AbloPlugin[], Id extends string> = Extract<Plugins[number], {
+    id: Id;
+}>;
+/** Collapses a union into an intersection, member by member. */
+type UnionToIntersection<U> = (U extends unknown ? (member: U) => void : never) extends (member: infer I) => void ? I : never;
+/**
+ * Every surface in a plugin list, folded into the one shape that merges onto
+ * the client: `[a(), b()]` contributes `ASurface & BSurface`. An empty list
+ * contributes nothing (`unknown`), so intersecting it changes no type.
+ */
+export type MergedSurface<Plugins extends readonly AbloPlugin[]> = [
+    Plugins[number]
+] extends [never] ? unknown : UnionToIntersection<Plugins[number] extends AbloPlugin<infer Surface> ? Surface : never>;
+/** What the selected transport can actually do, for checking `requires`. */
+export interface TransportProfile {
+    readonly duplex: boolean;
+}
+/**
+ * Check a plugin list against the selected transport and build its surface.
+ *
+ * Both failures are configuration mistakes, so they surface here — while the
+ * client is being constructed and the stack still points at the caller's own
+ * setup — rather than later as a subscription that never delivers.
+ */
+export declare function resolvePlugins<const Plugins extends readonly AbloPlugin[], Options = unknown>(plugins: Plugins, transport: TransportProfile, context: PluginContext<Options>): InstalledSurface<Plugins>;
+/**
+ * Lays every installed plugin surface over a built client, so a plugin's
+ * contributions are reachable as client members. The base always wins — a
+ * plugin cannot shadow `dispose`, a model accessor, or any other member the
+ * client itself defines; contributions only fill what the base leaves
+ * undefined. With nothing installed the base is returned untouched.
+ *
+ * The second half of {@link resolvePlugins}: that call turns a list into a
+ * surface, this one merges the surface onto the client the host built.
+ */
+export declare function layerPluginSurface<T extends object>(base: T, installed: Record<string, unknown>): T;
+/**
+ * The plugins attached to one pipeline stage, in declaration order.
+ *
+ * Stage order across the pipeline is fixed by {@link PIPELINE_STAGES}; this
+ * returns the members of a single stage, where declaration order is the caller's
+ * to choose and carries no correctness weight.
+ */
+export declare function pluginsForStage(plugins: readonly AbloPlugin[], stage: PipelineStage): readonly AbloPlugin[];
+/**
+ * Invokes every handler declared for one stage, in declaration order, with
+ * that stage's payload. No handlers declared is a plain no-op, so a pipeline
+ * dispatches unconditionally at each boundary and pays nothing when the
+ * stage is unclaimed.
+ */
+export declare function runStage<K extends PipelineStage>(plugins: readonly AbloPlugin[], stage: K, payload: StagePayloads[K]): void;
+export {};

package/dist/transaction/plugin.js

@@ -0,0 +1,106 @@
+/**
+ * The plugin contract (ADR 0016).
+ *
+ * The core is `commit` · `get`/`list` · `observe` · `claim` · auth. Everything
+ * else a caller might want — a local materialised copy, presence rendering,
+ * batching, framework bindings — is a plugin declared in one list, so a server
+ * or an agent installs only what it asked for.
+ *
+ * Every plugin has the same shape on purpose. Uniformity is what makes the list
+ * composable and the types inferable; bespoke plugins would reproduce today's
+ * nineteen export subpaths with extra ceremony.
+ *
+ * Where this shape came from, and the field-by-field reasoning behind it, is
+ * recorded in ADR 0016 — the contract itself only states what each field does.
+ */
+import { AbloValidationError } from './errors.js';
+/** Canonical order. A plugin runner must run stages in this sequence. */
+export const PIPELINE_STAGES = [
+    'receive',
+    'dedupe',
+    'persist',
+    'apply',
+    'acknowledge',
+    'notify',
+];
+/**
+ * Check a plugin list against the selected transport and build its surface.
+ *
+ * Both failures are configuration mistakes, so they surface here — while the
+ * client is being constructed and the stack still points at the caller's own
+ * setup — rather than later as a subscription that never delivers.
+ */
+export function resolvePlugins(plugins, transport, context) {
+    const surface = {};
+    const seen = new Set();
+    // The assembly, injected from the list being resolved. Always this list's
+    // own answer — a host-supplied `plugins` or `hasPlugin` could disagree
+    // with the assembly it describes, so both are replaced, not deferred to.
+    const initContext = {
+        ...context,
+        plugins,
+        hasPlugin: (id) => plugins.some((plugin) => plugin.id === id),
+    };
+    for (const plugin of plugins) {
+        if (seen.has(plugin.id)) {
+            throw new AbloValidationError(`The ${plugin.id} plugin is listed twice. Remove the duplicate; a plugin is installed once per client.`, { code: 'invalid_options', param: 'plugins' });
+        }
+        seen.add(plugin.id);
+        if (plugin.requires?.duplex && !transport.duplex) {
+            throw new AbloValidationError(`The ${plugin.id} plugin needs a connection the server can send on, and this client is set up for request-response only. Switch the transport to 'websocket', or drop the plugin.`, { code: 'invalid_options', param: 'plugins' });
+        }
+        surface[plugin.id] = plugin.init(initContext);
+    }
+    return surface;
+}
+/**
+ * Lays every installed plugin surface over a built client, so a plugin's
+ * contributions are reachable as client members. The base always wins — a
+ * plugin cannot shadow `dispose`, a model accessor, or any other member the
+ * client itself defines; contributions only fill what the base leaves
+ * undefined. With nothing installed the base is returned untouched.
+ *
+ * The second half of {@link resolvePlugins}: that call turns a list into a
+ * surface, this one merges the surface onto the client the host built.
+ */
+export function layerPluginSurface(base, installed) {
+    const contributions = {};
+    for (const surface of Object.values(installed)) {
+        if (surface && typeof surface === 'object') {
+            Object.assign(contributions, surface);
+        }
+    }
+    if (Object.keys(contributions).length === 0)
+        return base;
+    return new Proxy(base, {
+        get(target, prop, receiver) {
+            const own = Reflect.get(target, prop, receiver);
+            if (own !== undefined)
+                return own;
+            return typeof prop === 'string' && prop in contributions
+                ? contributions[prop]
+                : own;
+        },
+    });
+}
+/**
+ * The plugins attached to one pipeline stage, in declaration order.
+ *
+ * Stage order across the pipeline is fixed by {@link PIPELINE_STAGES}; this
+ * returns the members of a single stage, where declaration order is the caller's
+ * to choose and carries no correctness weight.
+ */
+export function pluginsForStage(plugins, stage) {
+    return plugins.filter((plugin) => plugin.stages?.[stage] !== undefined);
+}
+/**
+ * Invokes every handler declared for one stage, in declaration order, with
+ * that stage's payload. No handlers declared is a plain no-op, so a pipeline
+ * dispatches unconditionally at each boundary and pays nothing when the
+ * stage is unclaimed.
+ */
+export function runStage(plugins, stage, payload) {
+    for (const plugin of plugins) {
+        plugin.stages?.[stage]?.(payload);
+    }
+}

package/dist/{policy → transaction/policy}/types.d.ts

@@ -10,7 +10,7 @@
  * the two; switch on `kind` to narrow it.
  */
 import type { ParticipantRef } from '../types/participant.js';
-import type { OnStaleMode } from '../coordination/schema.js';
+import type { CommitOperationType, OnStaleMode } from '../coordination/schema.js';
 export type ConflictKind = 'stale_context' | 'claim_held';
 /** Fields shared by every conflict shape. */
 interface ConflictBase {
@@ -23,7 +23,7 @@ interface ConflictBase {
 export interface ConflictOperation {
     readonly model: string;
     readonly id: string;
-    readonly type: 'CREATE' | 'UPDATE' | 'DELETE' | 'ARCHIVE' | 'UNARCHIVE';
+    readonly type: CommitOperationType;
     readonly input?: Readonly<Record<string, unknown>>;
 }
 export interface StaleContextConflict extends ConflictBase {
@@ -48,7 +48,7 @@ export interface StaleContextConflict extends ConflictBase {
      * else rejects. A custom policy may override this. When absent, it is treated
      * as `'reject'`, the default for an unguarded write.
      */
-    readonly requestedMode?: 'reject' | 'overwrite' | 'notify';
+    readonly requestedMode?: OnStaleMode;
 }
 export interface ClaimHeldConflict extends ConflictBase {
     readonly kind: 'claim_held';

package/dist/{policy → transaction/policy}/types.js

@@ -77,6 +77,8 @@ export const capabilityPreemptPolicy = (conflict) => {
     }
     return defaultPolicy(conflict);
 };
+const _conflictAxisPinned = [true, true];
+void _conflictAxisPinned;
 /**
  * Resolves a declared {@link ConflictAxis} into a {@link ConflictDecision} for
  * one concrete conflict. It is pure and synchronous, doing no I/O, so it can