@abloatai/humans 0.37.0

package/dist/local/transactions/mutations/commitLane.d.ts

@@ -0,0 +1,70 @@
+import type { RuntimeContext } from '../../RuntimeContext.js';
+import type { ReadDependency, TrackDependency, OnStaleMode, StaleNotification } from '@abloatai/transaction/coordination/schema';
+import type { MutationCommitResult } from '@abloatai/transaction/wire/commit';
+import type { DurableCommitEnvelope, DurableCommitOperation } from '@abloatai/transaction/transactions/settlement/commitEnvelope';
+import type { SealDurableCommitInput } from './commitTransport.js';
+export interface CommitTransaction {
+    id: string;
+    kind: 'commit';
+    operations: {
+        type: DurableCommitOperation['type'];
+        model: string;
+        id: string;
+        input?: Record<string, unknown>;
+        transactionId?: string;
+        readAt?: number | null;
+        onStale?: OnStaleMode | null;
+    }[];
+    reads?: ReadDependency[] | null;
+    track?: TrackDependency[] | null;
+    status: 'pending' | 'executing' | 'awaiting_delta' | 'completed' | 'failed';
+    createdAt: number;
+    attempts: number;
+    transientAttempts?: number;
+    lastSyncId?: number;
+    correlationId?: string;
+    error?: Error;
+    sealedAt: number;
+    sequence: number;
+    sealPromise?: Promise<void>;
+    durableEnvelope?: DurableCommitEnvelope;
+    sourceMutationIds?: string[];
+}
+export interface CommitLaneContext {
+    readonly runtime: RuntimeContext;
+    readonly config: {
+        maxRetries: number;
+    };
+    readonly commitLane: CommitTransaction[];
+    readonly commitNotifications: Map<string, StaleNotification[]>;
+    readonly commitMissingIds: Map<string, string[]>;
+    readonly commitProcessing: boolean;
+    readonly setCommitProcessing: (value: boolean) => void;
+    readonly durableReplayBlock: object | null;
+    readonly sealDurableCommit: (input: SealDurableCommitInput) => Promise<DurableCommitEnvelope>;
+    readonly assertEnvelopeInsideReplayWindow: (envelope: DurableCommitEnvelope) => void;
+    readonly dispatchCommit: (envelope: DurableCommitEnvelope) => Promise<MutationCommitResult>;
+    readonly persistDurableCommitAcceptance: (envelope: DurableCommitEnvelope, result: MutationCommitResult) => Promise<DurableCommitEnvelope>;
+    readonly removeDurableCommit: (idempotencyKey: string) => Promise<void>;
+    readonly queuedCommitEchoSyncId: (transaction: CommitTransaction) => number | undefined;
+    readonly completeQueuedCommit: (transaction: CommitTransaction, syncId: number) => void;
+    readonly scheduleReplicationLagTimeout: (transactionId: string, clientTxId: string, correlationId?: string) => void;
+    readonly noteAck: (syncId: number | undefined) => void;
+    readonly isDefinitiveRejection: (error: Error) => boolean;
+    readonly isPermanentError: (error: Error) => boolean;
+    readonly emitCommitLifecycle: (event: string, payload: object) => void;
+}
+export interface CommitReceiptContext {
+    readonly commitStore: Map<string, CommitTransaction>;
+    readonly commitNotifications: Map<string, StaleNotification[]>;
+    readonly commitMissingIds: Map<string, string[]>;
+    readonly replicationLagErrors: Map<string, Error>;
+    readonly on: (event: string, listener: (payload: object) => void) => void;
+    readonly off: (event: string, listener: (payload: object) => void) => void;
+}
+export declare function waitForCommitReceipt(ctx: CommitReceiptContext, clientTxId: string): Promise<{
+    lastSyncId: number;
+    notifications?: StaleNotification[];
+    missingIds?: string[];
+}>;
+export declare function processCommitLane(ctx: CommitLaneContext): Promise<void>;

package/dist/local/transactions/mutations/commitLane.js

@@ -0,0 +1,140 @@
+import { AbloConnectionError } from '@abloatai/transaction/errors';
+export function waitForCommitReceipt(ctx, clientTxId) {
+    const drainNotifications = () => {
+        const notifications = ctx.commitNotifications.get(clientTxId);
+        if (!notifications)
+            return undefined;
+        ctx.commitNotifications.delete(clientTxId);
+        return notifications.length > 0 ? notifications : undefined;
+    };
+    const drainMissingIds = () => {
+        const ids = ctx.commitMissingIds.get(clientTxId);
+        if (!ids)
+            return undefined;
+        ctx.commitMissingIds.delete(clientTxId);
+        return ids.length > 0 ? ids : undefined;
+    };
+    const receipt = (lastSyncId) => {
+        const missingIds = drainMissingIds();
+        return {
+            lastSyncId,
+            notifications: drainNotifications(),
+            ...(missingIds ? { missingIds } : {}),
+        };
+    };
+    return new Promise((resolve, reject) => {
+        const existing = ctx.commitStore.get(clientTxId);
+        if (existing?.status === 'completed') {
+            resolve(receipt(existing.lastSyncId ?? 0));
+            return;
+        }
+        if (existing?.status === 'failed' && existing.error) {
+            reject(existing.error);
+            return;
+        }
+        const lagError = ctx.replicationLagErrors.get(clientTxId);
+        if (lagError) {
+            reject(lagError);
+            return;
+        }
+        const onCompleted = (tx) => { cleanup(); resolve(receipt(tx.lastSyncId ?? 0)); };
+        const onFailed = (payload) => { cleanup(); reject(payload.error); };
+        const onLagged = (payload) => { cleanup(); reject(payload.error); };
+        const cleanup = () => {
+            ctx.off(`transaction:completed:${clientTxId}`, onCompleted);
+            ctx.off(`transaction:failed:${clientTxId}`, onFailed);
+            ctx.off(`transaction:confirmation_lagged:${clientTxId}`, onLagged);
+        };
+        ctx.on(`transaction:completed:${clientTxId}`, onCompleted);
+        ctx.on(`transaction:failed:${clientTxId}`, onFailed);
+        ctx.on(`transaction:confirmation_lagged:${clientTxId}`, onLagged);
+    });
+}
+export async function processCommitLane(ctx) {
+    if (ctx.commitProcessing || ctx.durableReplayBlock)
+        return;
+    ctx.setCommitProcessing(true);
+    try {
+        while (ctx.commitLane.length > 0) {
+            const tx = ctx.commitLane[0];
+            if (!tx)
+                break;
+            if (tx.status !== 'pending') {
+                ctx.commitLane.shift();
+                continue;
+            }
+            tx.status = 'executing';
+            tx.attempts += 1;
+            let dispatchStarted = false;
+            try {
+                const durableEnvelope = tx.durableEnvelope ?? await ctx.sealDurableCommit({
+                    idempotencyKey: tx.id,
+                    origin: 'atomic_commit',
+                    operations: tx.operations,
+                    sourceMutationIds: tx.sourceMutationIds,
+                    commitOptions: {
+                        ...(tx.reads ? { reads: tx.reads } : {}),
+                        ...(tx.track ? { track: tx.track } : {}),
+                    },
+                    createdAt: tx.createdAt,
+                    sealedAt: tx.sealedAt,
+                    sequence: tx.sequence,
+                });
+                tx.durableEnvelope = durableEnvelope;
+                ctx.assertEnvelopeInsideReplayWindow(durableEnvelope);
+                dispatchStarted = true;
+                const result = await ctx.dispatchCommit(durableEnvelope);
+                tx.durableEnvelope = await ctx.persistDurableCommitAcceptance(durableEnvelope, result);
+                tx.lastSyncId = result.lastSyncId;
+                if (result.notifications?.length)
+                    ctx.commitNotifications.set(tx.id, result.notifications);
+                if (result.missingIds?.length)
+                    ctx.commitMissingIds.set(tx.id, result.missingIds);
+                ctx.commitLane.shift();
+                if (result.status === 'queued') {
+                    tx.correlationId = result.correlationId;
+                    tx.status = 'awaiting_delta';
+                    const echoSyncId = ctx.queuedCommitEchoSyncId(tx);
+                    if (echoSyncId !== undefined)
+                        ctx.completeQueuedCommit(tx, echoSyncId);
+                    else
+                        ctx.scheduleReplicationLagTimeout(tx.id, tx.id, result.correlationId);
+                }
+                else {
+                    await ctx.removeDurableCommit(tx.id);
+                    ctx.noteAck(tx.lastSyncId);
+                    tx.status = 'completed';
+                    ctx.emitCommitLifecycle('transaction:completed', tx);
+                    ctx.emitCommitLifecycle(`transaction:completed:${tx.id}`, tx);
+                }
+            }
+            catch (cause) {
+                const error = cause instanceof Error ? cause : new Error(String(cause));
+                if (dispatchStarted && ctx.isDefinitiveRejection(error))
+                    await ctx.removeDurableCommit(tx.id);
+                if (!(error instanceof AbloConnectionError))
+                    tx.transientAttempts = (tx.transientAttempts ?? 0) + 1;
+                const exhausted = (tx.transientAttempts ?? 0) > ctx.config.maxRetries;
+                if (!ctx.isPermanentError(error) && !exhausted) {
+                    tx.status = 'pending';
+                    ctx.runtime.logger.debug('[MutationQueue] commit lane transient', {
+                        txId: tx.id.slice(0, 12), attempts: tx.attempts,
+                        transientAttempts: tx.transientAttempts ?? 0, message: error.message,
+                    });
+                    break;
+                }
+                tx.status = 'failed';
+                tx.error = error;
+                ctx.commitLane.shift();
+                ctx.runtime.logger.debug('[MutationQueue] commit lane permanent error', {
+                    txId: tx.id.slice(0, 12), attempts: tx.attempts, message: error.message,
+                });
+                ctx.emitCommitLifecycle('transaction:failed', { transaction: tx, error, permanent: true });
+                ctx.emitCommitLifecycle(`transaction:failed:${tx.id}`, { error });
+            }
+        }
+    }
+    finally {
+        ctx.setCommitProcessing(false);
+    }
+}

package/dist/local/transactions/mutations/commitLatency.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Commit latency — how long a user's edit actually takes to land.
+ *
+ * The engine has never measured this. HUDs and dashboards reach for
+ * `window.fetch` timings, which the sync engine's WebSocket never touches, so
+ * the latency a user sees reported while editing has had nothing to do with
+ * the writes they are making. This module closes that gap without adding a
+ * single timestamp to the hot path: `MutationQueue` already emits the commit
+ * lifecycle, and the events already carry the correlation key.
+ *
+ * Three events, two intervals:
+ *
+ *   commit:staging ──sealMs──▶ commit:created ──ackMs──▶ transaction:completed
+ *
+ *  - `sealMs` is **local** — writing the durable envelope before the commit is
+ *    allowed onto the wire. Slow here means durable storage, not network.
+ *  - `ackMs` is **remote** — dispatch, round-trip, and server work. For a
+ *    commit routed at a connected source this also spans the wait for the
+ *    correlated echo that promotes `queued` to `confirmed`, so it answers
+ *    "when did my edit become real" rather than raw socket round-trip. Read a
+ *    large `ackMs` against a small `sealMs` as a network or replication cost.
+ *
+ * Correlation is by `clientTxId`: `MutationQueue` uses it as the transaction
+ * id verbatim, so the staging event and the completion event share one key.
+ */
+/**
+ * The slice of an event emitter this module needs. Declared structurally so a
+ * plain object can stand in under test — `MutationQueue` satisfies it by
+ * extending `EventEmitter`.
+ */
+export interface CommitEventSource {
+    on(event: string, listener: (payload: unknown) => void): unknown;
+    off(event: string, listener: (payload: unknown) => void): unknown;
+}
+/** One completed commit, broken into its local and remote halves. */
+export interface CommitLatencySample {
+    /** The commit's `clientTxId`, identical to its transaction id. */
+    clientTxId: string;
+    /** Milliseconds sealing the durable envelope locally. */
+    sealMs: number;
+    /** Milliseconds from sealed envelope to acknowledgement. */
+    ackMs: number;
+    /** Milliseconds from staging to acknowledgement — `sealMs + ackMs`. */
+    totalMs: number;
+}
+/**
+ * Pair commit lifecycle events into latency samples. Returns an unsubscribe
+ * function that also drops any still-pending timings.
+ *
+ * `onSample` fires once per commit that completes, in completion order.
+ */
+export declare function observeCommitLatency(source: CommitEventSource, onSample: (sample: CommitLatencySample) => void): () => void;

package/dist/local/transactions/mutations/commitLatency.js

@@ -0,0 +1,130 @@
+/**
+ * Commit latency — how long a user's edit actually takes to land.
+ *
+ * The engine has never measured this. HUDs and dashboards reach for
+ * `window.fetch` timings, which the sync engine's WebSocket never touches, so
+ * the latency a user sees reported while editing has had nothing to do with
+ * the writes they are making. This module closes that gap without adding a
+ * single timestamp to the hot path: `MutationQueue` already emits the commit
+ * lifecycle, and the events already carry the correlation key.
+ *
+ * Three events, two intervals:
+ *
+ *   commit:staging ──sealMs──▶ commit:created ──ackMs──▶ transaction:completed
+ *
+ *  - `sealMs` is **local** — writing the durable envelope before the commit is
+ *    allowed onto the wire. Slow here means durable storage, not network.
+ *  - `ackMs` is **remote** — dispatch, round-trip, and server work. For a
+ *    commit routed at a connected source this also spans the wait for the
+ *    correlated echo that promotes `queued` to `confirmed`, so it answers
+ *    "when did my edit become real" rather than raw socket round-trip. Read a
+ *    large `ackMs` against a small `sealMs` as a network or replication cost.
+ *
+ * Correlation is by `clientTxId`: `MutationQueue` uses it as the transaction
+ * id verbatim, so the staging event and the completion event share one key.
+ */
+/**
+ * Cap on commits awaiting completion. A commit whose completion never arrives
+ * (connection dropped mid-flight, retry abandoned) would otherwise pin its
+ * entry forever, so the map is bounded rather than trusted to drain.
+ */
+const MAX_PENDING_COMMITS = 256;
+function nowMs() {
+    return typeof performance !== 'undefined' ? performance.now() : Date.now();
+}
+/** Read `clientTxId` off a `commit:*` payload, or null if it isn't shaped so. */
+function readClientTxId(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        return null;
+    const { clientTxId } = payload;
+    return typeof clientTxId === 'string' ? clientTxId : null;
+}
+/** Read `id` off a transaction payload (`transaction:completed` sends the tx). */
+function readTransactionId(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        return null;
+    const { id } = payload;
+    return typeof id === 'string' ? id : null;
+}
+/** `transaction:failed` wraps the transaction rather than sending it bare. */
+function readFailedTransactionId(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        return null;
+    return readTransactionId(payload.transaction);
+}
+/**
+ * Pair commit lifecycle events into latency samples. Returns an unsubscribe
+ * function that also drops any still-pending timings.
+ *
+ * `onSample` fires once per commit that completes, in completion order.
+ */
+export function observeCommitLatency(source, onSample) {
+    const pending = new Map();
+    const handleStaging = (payload) => {
+        const id = readClientTxId(payload);
+        if (id === null)
+            return;
+        // Map preserves insertion order, so the first key is the stalest entry.
+        if (pending.size >= MAX_PENDING_COMMITS) {
+            const oldest = pending.keys().next();
+            if (!oldest.done)
+                pending.delete(oldest.value);
+        }
+        pending.set(id, { stagedAt: nowMs(), sealedAt: null });
+    };
+    const handleCreated = (payload) => {
+        const id = readClientTxId(payload);
+        if (id === null)
+            return;
+        const timing = pending.get(id);
+        if (timing === undefined)
+            return;
+        timing.sealedAt = nowMs();
+    };
+    const handleCompleted = (payload) => {
+        const id = readTransactionId(payload);
+        if (id === null)
+            return;
+        const timing = pending.get(id);
+        // `transaction:completed` also fires for local (non-commit) transactions
+        // and for mutation-log replay. Only ids we staged are commits, so an
+        // absent entry is the normal way those are filtered out.
+        if (timing === undefined)
+            return;
+        pending.delete(id);
+        const completedAt = nowMs();
+        // A commit can complete without an observed seal only if the listener was
+        // attached mid-flight; attributing the whole span to `ackMs` keeps
+        // `sealMs + ackMs === totalMs` true rather than reporting a bogus seal.
+        const sealedAt = timing.sealedAt ?? timing.stagedAt;
+        onSample({
+            clientTxId: id,
+            sealMs: sealedAt - timing.stagedAt,
+            ackMs: completedAt - sealedAt,
+            totalMs: completedAt - timing.stagedAt,
+        });
+    };
+    const handleSealFailed = (payload) => {
+        const id = readClientTxId(payload);
+        if (id !== null)
+            pending.delete(id);
+    };
+    const handleFailed = (payload) => {
+        const id = readFailedTransactionId(payload);
+        if (id !== null)
+            pending.delete(id);
+    };
+    source.on('commit:staging', handleStaging);
+    source.on('commit:created', handleCreated);
+    source.on('commit:seal_failed', handleSealFailed);
+    source.on('transaction:completed', handleCompleted);
+    source.on('transaction:failed', handleFailed);
+    return () => {
+        source.off('commit:staging', handleStaging);
+        source.off('commit:created', handleCreated);
+        source.off('commit:seal_failed', handleSealFailed);
+        source.off('transaction:completed', handleCompleted);
+        source.off('transaction:failed', handleFailed);
+        pending.clear();
+    };
+}

package/dist/local/transactions/mutations/commitPayload.d.ts

@@ -0,0 +1,165 @@
+/**
+ * The vocabulary a local transaction uses on the wire. This module defines the
+ * {@link QueuedMutation} record and the helpers that turn a transaction into a
+ * wire-safe commit operation: schema-field projection
+ * ({@link projectCommitPayload}), write-option projection
+ * ({@link applyWriteOptions}), foreign-key-aware priority scoring
+ * ({@link computePriorityScore}), and the structural checks used to classify
+ * transport errors. Nothing here holds queue state or timers, so the batched
+ * queue path and the HTTP commit path share the same projection.
+ */
+import type { RuntimeContext } from '../../RuntimeContext.js';
+import { MutationOperationType } from '@abloatai/transaction/types';
+import type { OnStaleMode } from '@abloatai/transaction/coordination/schema';
+import type { MutationOptions, WriteOptions } from '../../interfaces/index.js';
+import type { CommitEnvelopeMember } from '@abloatai/transaction/transactions/settlement/commitEnvelope';
+export interface UserContext {
+    userId: string;
+    organizationId: string;
+    role?: string;
+    teamIds?: string[];
+}
+/** Wire-format mutation payload (post-projection). */
+export type MutationInput = Record<string, unknown>;
+/**
+ * Projects a model's serialized data onto the fields declared in its schema and
+ * returns a wire-safe commit payload. It does two things:
+ *
+ *   1. Drops framework-internal keys (`__class`, `__typename`, `clientId`,
+ *      `syncStatus`) and anything not declared on the model's schema.
+ *   2. Takes a fresh plain JSON snapshot of the projected values. JSON-typed
+ *      fields stay objects rather than pre-serialized strings, while reactive
+ *      proxies cannot leak into persistence or the wire payload.
+ *
+ * For updates (`dropUndefined: true`), `undefined` values are also removed so
+ * they are not written as `SET column = NULL` on the server.
+ *
+ * Field metadata comes from the model registry, populated when the schema is
+ * registered at initialization. If a model has no registered field metadata —
+ * for example a manually registered model — projection snapshots all serialized
+ * data apart from the framework keys.
+ */
+export declare function projectCommitPayload(modelName: string, source: Record<string, unknown>, opts: {
+    dropUndefined: boolean;
+}, runtime?: RuntimeContext): MutationInput;
+export interface QueuedMutation {
+    id: string;
+    type: 'create' | 'update' | 'delete' | 'archive' | 'unarchive';
+    modelName: string;
+    modelId: string;
+    modelKey: string;
+    data?: MutationInput;
+    previousData?: MutationInput | null;
+    context: UserContext;
+    status: 'pending' | 'executing' | 'awaiting_delta' | 'completed' | 'failed' | 'rolled_back';
+    createdAt: number;
+    attempts: number;
+    priority: 'normal' | 'high';
+    priorityScore: number;
+    writeOptions?: WriteOptions;
+    batchId?: string;
+    /**
+     * Stable identity of the wire commit that currently owns this operation.
+     *
+     * A transport failure is ambiguous: the server may have committed the
+     * batch even though the acknowledgement never reached this client. Keeping
+     * this envelope on every member lets the queue replay the exact same ordered
+     * batch with the exact same idempotency key instead of accidentally
+     * re-batching its operations under a fresh key.
+     */
+    commitEnvelope?: CommitEnvelopeMember;
+    /** Pending-mutation journal entries atomically consumed by this envelope. */
+    sourceMutationIds?: string[];
+    /** Completed locally without a server operation; no sync echo will arrive. */
+    localOnly?: boolean;
+    /** Sync-id threshold: the transaction confirms once a delta with an id at least this value arrives. */
+    syncIdNeededForCompletion?: number;
+    /**
+     * Opaque customer-side batch identity returned with a queued source receipt.
+     * It is retained durably and is the only identity a live WAL delta may use
+     * to settle this pending commit. Server-side replay additionally proves the
+     * complete stored operation-id set before returning `confirmed`.
+     */
+    correlationId?: string;
+    /**
+     * A queued forward has no authoritative sync-id watermark yet. It may only
+     * confirm when a WAL delta carries its opaque server-derived correlation;
+     * unrelated deltas must never satisfy it by advancing the global watermark.
+     */
+    requiresCorrelatedDelta?: boolean;
+    /**
+     * Resolves once the server has confirmed this transaction, whether by a delta
+     * or an HTTP acknowledgement. It rejects with the originating error if the
+     * transaction is permanently rolled back; for a source-forwarded write it
+     * also rejects with `replication_lag_timeout` when the accepted write's WAL
+     * echo misses the confirmation deadline. That timeout does not roll back or
+     * fail the transaction: it remains pending and may confirm when replication
+     * recovers. This gives a caller one place to await the answer to "did my write
+     * land?", matching the
+     * `commits.create({ wait: 'confirmed' })` and
+     * {@link MutationQueue.waitForConfirmation} vocabulary, so a failure
+     * surfaces at the call site instead of only as a silent local rollback. The
+     * permanent-rejection value is the same {@link AbloError} carried on the
+     * queue's `transaction:failed` event.
+     */
+    confirmation?: Promise<void>;
+}
+export declare const normalizeModelKey: (modelName: string) => string;
+export declare const stripModelSuffix: (modelName: string) => string;
+/**
+ * Returns the priority score used to order create operations by foreign-key
+ * depth, so a parent row commits before its children.
+ *
+ * The score comes from a priority map on the runtime configuration, built once
+ * at initialization by walking the schema's `belongsTo` graph. No model names
+ * are hard-coded here, and an application can override specific priorities
+ * through `configOverrides.modelCreatePriority`.
+ *
+ * Non-create operations (update, delete, archive, unarchive) need no
+ * foreign-key ordering because the row already exists, so they all share the
+ * configured default non-create priority.
+ */
+export declare const computePriorityScore: (type: QueuedMutation["type"], modelName: string, runtime?: RuntimeContext) => number;
+export declare const TX_TYPE_TO_MUTATION_OP: Record<QueuedMutation['type'], MutationOperationType>;
+export declare function hasStaleWriteOptions(options?: WriteOptions): boolean;
+/** Options whose identity/audit semantics forbid merging two caller writes. */
+export declare function hasCommitCoalescingBarrier(options?: WriteOptions): boolean;
+export interface WriteOperationFields {
+    readAt?: number | null;
+    onStale?: OnStaleMode | null;
+    fenceToken?: number | null;
+    options?: Pick<MutationOptions, 'idempotencyKey' | 'label'>;
+}
+/**
+ * Copies a transaction's `writeOptions` onto the wire operation. The
+ * stale-context guards (`readAt` and `onStale`) sit at the operation's root,
+ * while `idempotencyKey` and `label` go in its `options` slot — the
+ * `mutation_log` cache key and audit tag. This is the one place caller-supplied
+ * write options cross onto the wire.
+ */
+export declare function applyWriteOptions<T extends object>(op: T, transaction: QueuedMutation): T & WriteOperationFields;
+/**
+ * The structural shape used to inspect transport-layer errors. It covers the
+ * GraphQL-style and HTTP-style error shapes the mutation executor can surface,
+ * and is kept intentionally narrow so it does not claim fields the runtime may
+ * not supply.
+ */
+export interface TransportError {
+    message?: string;
+    code?: string | number;
+    extensions?: Record<string, unknown>;
+    locations?: readonly unknown[];
+    path?: readonly (string | number)[];
+    response?: {
+        status?: number;
+        errors?: readonly {
+            extensions?: {
+                code?: string;
+            };
+            message?: string;
+        }[];
+    };
+    error?: string;
+}
+export declare function asTransportError(value: unknown): TransportError;
+export declare function extractStatusCode(error: unknown): number | undefined;