@creatornader/agent-bridge 0.2.0 → 0.3.1

package/dist/bridge-domain-CBX3IVqC.d.ts

@@ -0,0 +1,153 @@
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type DeliveryState = "pending" | "claimed" | "acked" | "retrying" | "dead" | "cancelled";
+type MessagePriority = "info" | "high" | "urgent";
+interface LeasedDeliveryPolicy {
+    mode: "leased";
+    maxAttempts: number;
+    retryBaseDelayMs: number;
+    retryMaxDelayMs: number;
+    retryJitterRatio: number;
+    notBefore?: string;
+}
+type DeliveryPolicy = {
+    mode: "mailbox";
+} | LeasedDeliveryPolicy;
+/** @deprecated Consumer retry policy is validated and ignored for one compatibility release. */
+interface RetryPolicy {
+    maxAttempts: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    jitterRatio: number;
+}
+type DeliveryAction = "created" | "claim" | "ack" | "nack_retry" | "nack_dead" | "lease_expired" | "attempts_exhausted" | "message_expired" | "cancel" | "requeue";
+interface BridgePrincipal {
+    workspace: string;
+    agent: string;
+    instance?: string;
+}
+interface MessageDraft {
+    id?: string;
+    project?: string;
+    type: string;
+    content: string;
+    contentType?: string;
+    data?: JsonValue;
+    targets?: string[];
+    threadId?: string;
+    replyToId?: string;
+    correlationId?: string;
+    causationId?: string;
+    priority?: MessagePriority;
+    expiresAt?: string;
+    idempotencyKey?: string;
+    atribReceiptId?: string;
+    informedBy?: string[];
+    metadata?: JsonValue;
+    deliveryPolicy?: DeliveryPolicy | Record<string, unknown>;
+}
+interface BridgeMessage extends Required<Pick<MessageDraft, "id" | "type" | "content" | "contentType" | "targets" | "priority">> {
+    workspace: string;
+    project?: string;
+    source: string;
+    sequence: string;
+    createdAt: string;
+    data?: JsonValue;
+    threadId?: string;
+    replyToId?: string;
+    correlationId?: string;
+    causationId?: string;
+    expiresAt?: string;
+    idempotencyKey?: string;
+    atribReceiptId?: string;
+    informedBy?: string[];
+    metadata?: JsonValue;
+    deliveryPolicy: DeliveryPolicy;
+}
+interface BridgeDelivery {
+    id: string;
+    messageId: string;
+    workspace: string;
+    recipient: string;
+    state: DeliveryState;
+    attempt: number;
+    cycleAttempt: number;
+    requeueCount: number;
+    createdAt: string;
+    priorityRank: number;
+    availableAt: string;
+    leaseToken?: string;
+    leaseOwner?: string;
+    leaseExpiresAt?: string;
+    lastError?: string;
+    lastActor?: string;
+    lastAction: DeliveryAction;
+}
+interface BridgeDeliveryEvent {
+    sequence: string;
+    deliveryId: string;
+    messageId: string;
+    workspace: string;
+    recipient: string;
+    fromState?: DeliveryState;
+    toState: DeliveryState;
+    attempt: number;
+    cycleAttempt: number;
+    requeueCount: number;
+    leaseOwner?: string;
+    error?: string;
+    actor: string;
+    action: DeliveryAction;
+    createdAt: string;
+}
+interface AgentPresence {
+    workspace: string;
+    agent: string;
+    instance: string;
+    runtimeType?: string;
+    capabilities: string[];
+    leaseExpiresAt: string;
+    lastSeenAt: string;
+}
+declare class BridgeValidationError extends Error {
+    readonly code = "invalid_input";
+}
+declare class BridgePrincipalMismatchError extends Error {
+    readonly code = "principal_mismatch";
+    readonly status = 403;
+}
+declare class DeliveryStateConflictError extends Error {
+    readonly code = "delivery_state_conflict";
+    readonly status = 409;
+}
+declare function validateProject(value: unknown): string | undefined;
+declare function uuidv7(now?: number): string;
+declare function validatePrincipal(value: BridgePrincipal): BridgePrincipal;
+declare function validateUuid(value: unknown, field: string): string;
+declare function validateLeasedDeliveryPolicy(input?: Record<string, unknown>): LeasedDeliveryPolicy;
+declare function validateDeliveryPolicy(input: Record<string, unknown> | null | undefined, targeted: boolean): DeliveryPolicy;
+declare function validateMessageDraft(input: MessageDraft): Omit<BridgeMessage, "workspace" | "source" | "sequence" | "createdAt">;
+interface CursorScopeQuery {
+    mailbox?: "inbox" | "sent" | "all";
+    receiptState?: "any" | "unread" | "read";
+    project?: string;
+    types?: string[];
+    includeExpired?: boolean;
+    source?: string;
+    since?: string;
+    threadId?: string;
+}
+declare function cursorScope(principal: BridgePrincipal, query: CursorScopeQuery): string;
+declare function encodeCursor(sequence: string, scope?: string): string;
+declare function decodeCursor(cursor: string | undefined, scope?: string): string | undefined;
+declare function scopedCursorScope(kind: string, principal: BridgePrincipal, filters: JsonValue): string;
+declare function encodeScopedCursor(scope: string, position: JsonValue): string;
+declare function decodeScopedCursor(cursor: string | undefined, scope: string): JsonValue | undefined;
+declare function validateDeliveryCursorPosition(position: JsonValue | undefined): {
+    createdAt: string;
+    id: string;
+} | undefined;
+declare function validateEventCursorPosition(position: JsonValue | undefined): string | undefined;
+
+export { type AgentPresence as A, type BridgeDelivery as B, type DeliveryAction as D, type JsonValue as J, type LeasedDeliveryPolicy as L, type MessageDraft as M, type RetryPolicy as R, type BridgeDeliveryEvent as a, type BridgeMessage as b, type BridgePrincipal as c, BridgePrincipalMismatchError as d, BridgeValidationError as e, type DeliveryPolicy as f, type DeliveryState as g, DeliveryStateConflictError as h, type MessagePriority as i, cursorScope as j, decodeCursor as k, decodeScopedCursor as l, encodeCursor as m, encodeScopedCursor as n, validateDeliveryPolicy as o, validateEventCursorPosition as p, validateLeasedDeliveryPolicy as q, validateMessageDraft as r, scopedCursorScope as s, validatePrincipal as t, uuidv7 as u, validateDeliveryCursorPosition as v, validateProject as w, validateUuid as x };

package/dist/{bridge-service-CfqMcMAn.d.ts → bridge-service-hX1ZQp4W.d.ts}

@@ -1,11 +1,14 @@
-import { c as BridgePrincipal, M as MessageDraft, B as BridgeDelivery, R as RetryPolicy, A as AgentPresence } from './bridge-domain-BcnBeHOn.js';
-import { a as BridgeStore, I as InsertMessageResult, b as MessageQuery, M as MessagePage } from './bridge-store-BuGjxTn4.js';
+import { a as BridgeStore, I as InsertMessageResult, d as MessageQuery, M as MessagePage, c as DeliveryQuery, b as DeliveryPage, D as DeliveryEventPage } from './bridge-store-DPVSCwfs.js';
+import { c as BridgePrincipal, M as MessageDraft, B as BridgeDelivery, A as AgentPresence } from './bridge-domain-CBX3IVqC.js';
 
+type PublicMessageQuery = MessageQuery & {
+    unacknowledgedBy?: string;
+};
 declare class BridgeService {
     private readonly store;
     constructor(store: BridgeStore);
     publish(principalInput: BridgePrincipal, draftInput: MessageDraft): Promise<InsertMessageResult>;
-    history(principalInput: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
+    history(principalInput: BridgePrincipal, query?: PublicMessageQuery): Promise<MessagePage>;
     acknowledge(principalInput: BridgePrincipal, messageIds: string[]): Promise<number>;
     claim(principalInput: BridgePrincipal, options?: {
         leaseMs?: number;
@@ -16,7 +19,14 @@ declare class BridgeService {
     } | null>;
     extend(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string, leaseMs?: number): Promise<BridgeDelivery | null>;
     ack(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string): Promise<BridgeDelivery | null>;
-    nack(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string, error: string, dead?: boolean, retryPolicy?: Partial<RetryPolicy>): Promise<BridgeDelivery | null>;
+    nack(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string, error: string, disposition?: "retry" | "dead" | boolean, deprecatedRetryPolicy?: unknown): Promise<BridgeDelivery | null>;
+    deliveries(principalInput: BridgePrincipal, query?: DeliveryQuery): Promise<DeliveryPage>;
+    deliveryEvents(principalInput: BridgePrincipal, deliveryId: string, query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<DeliveryEventPage>;
+    cancel(principalInput: BridgePrincipal, deliveryId: string): Promise<BridgeDelivery | null>;
+    requeue(principalInput: BridgePrincipal, deliveryId: string): Promise<BridgeDelivery | null>;
     heartbeat(principalInput: BridgePrincipal, options?: {
         leaseMs?: number;
         runtimeType?: string;
@@ -25,4 +35,4 @@ declare class BridgeService {
     presence(principalInput: BridgePrincipal): Promise<AgentPresence[]>;
 }
 
-export { BridgeService as B };
+export { BridgeService as B, type PublicMessageQuery as P };

package/dist/bridge-store-DPVSCwfs.d.ts

@@ -0,0 +1,102 @@
+import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, g as DeliveryState, R as RetryPolicy, a as BridgeDeliveryEvent, A as AgentPresence } from './bridge-domain-CBX3IVqC.js';
+
+interface InsertMessageResult {
+    message: BridgeMessage;
+    created: boolean;
+}
+interface MessageQuery {
+    mailbox?: "inbox" | "sent" | "all";
+    receiptState?: "any" | "unread" | "read";
+    project?: string;
+    cursor?: string;
+    limit?: number;
+    types?: string[];
+    includeExpired?: boolean;
+    source?: string;
+    since?: string;
+    threadId?: string;
+    latest?: boolean;
+}
+interface MessagePage {
+    messages: BridgeMessage[];
+    cursor?: string;
+}
+interface BridgeDiagnostics {
+    schemaVersion: "local-v2" | "postgres-v2" | "legacy-v1";
+    deliverySupported: boolean;
+    pending: number | null;
+    claimed: number | null;
+    retrying: number | null;
+    dead: number | null;
+    cancelled?: number | null;
+    oldestAvailableAt?: string;
+    due?: number | null;
+    scheduled?: number | null;
+    expiredLeases?: number | null;
+    oldestDueAt?: string;
+    queueLagMs?: number | null;
+    principal?: {
+        workspace: string;
+        agent: string;
+    };
+}
+interface ClaimOptions {
+    leaseMs: number;
+    now?: Date;
+    maxAttempts?: number;
+}
+interface DeliveryQuery {
+    role?: "recipient" | "publisher" | "all";
+    states?: DeliveryState[];
+    messageId?: string;
+    recipient?: string;
+    cursor?: string;
+    limit?: number;
+}
+interface DeliveryPage {
+    deliveries: BridgeDelivery[];
+    cursor?: string;
+}
+interface DeliveryEventPage {
+    events: BridgeDeliveryEvent[];
+    cursor?: string;
+}
+interface BridgeStore {
+    initialize(options?: {
+        signal?: AbortSignal;
+        mode?: "active" | "passive";
+    }): Promise<void>;
+    insertMessage(message: Omit<BridgeMessage, "sequence" | "createdAt">, options?: {
+        signal?: AbortSignal;
+    }): Promise<InsertMessageResult>;
+    listMessages(principal: BridgePrincipal, query?: MessageQuery, options?: {
+        signal?: AbortSignal;
+    }): Promise<MessagePage>;
+    recordReceipt(principal: BridgePrincipal, messageIds: string[], readAt?: Date): Promise<number>;
+    recordLegacyReceipt?(legacyIds: string[], principal: string): Promise<number>;
+    claimDelivery(principal: BridgePrincipal, options: ClaimOptions): Promise<BridgeDelivery | null>;
+    renewDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, leaseMs: number): Promise<BridgeDelivery | null>;
+    settleDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, state: Extract<DeliveryState, "acked" | "retrying" | "dead">, error?: string, retryPolicy?: RetryPolicy): Promise<BridgeDelivery | null>;
+    listDeliveries?(principal: BridgePrincipal, query?: DeliveryQuery): Promise<DeliveryPage>;
+    listDeliveryEvents?(principal: BridgePrincipal, deliveryId: string, query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<DeliveryEventPage>;
+    cancelDelivery?(principal: BridgePrincipal, deliveryId: string): Promise<BridgeDelivery | null>;
+    requeueDelivery?(principal: BridgePrincipal, deliveryId: string): Promise<BridgeDelivery | null>;
+    diagnostics?(principal: BridgePrincipal, options?: {
+        mode?: "snapshot" | "probe";
+    }): Promise<BridgeDiagnostics>;
+    heartbeat?(principal: BridgePrincipal, leaseMs: number, runtimeType?: string, capabilities?: string[]): Promise<AgentPresence>;
+    listPresence?(principal: BridgePrincipal): Promise<AgentPresence[]>;
+    sync?(options?: {
+        maxPush?: number;
+        maxPages?: number;
+        signal?: AbortSignal;
+    }): Promise<unknown>;
+    verifyRemote?(): Promise<void>;
+    capabilities?(): Promise<unknown>;
+    close?(): Promise<void>;
+}
+
+export type { BridgeDiagnostics as B, ClaimOptions as C, DeliveryEventPage as D, InsertMessageResult as I, MessagePage as M, BridgeStore as a, DeliveryPage as b, DeliveryQuery as c, MessageQuery as d };

package/dist/bridge.d.ts

@@ -1,9 +1,11 @@
-import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, R as RetryPolicy, A as AgentPresence } from './bridge-domain-BcnBeHOn.js';
-export { a as BridgeDeliveryEvent, d as BridgeValidationError, D as DeliveryState, J as JsonValue, M as MessageDraft, e as MessagePriority, f as decodeCursor, g as encodeCursor, u as uuidv7, v as validateMessageDraft, h as validatePrincipal, i as validateRetryPolicy, j as validateUuid } from './bridge-domain-BcnBeHOn.js';
-import { a as BridgeStore, I as InsertMessageResult, b as MessageQuery, M as MessagePage, C as ClaimOptions, B as BridgeDiagnostics } from './bridge-store-BuGjxTn4.js';
-export { B as BridgeService } from './bridge-service-CfqMcMAn.js';
-import { P as PgQueryable } from './gateway-BULozv3K.js';
-export { A as AuthenticatedCredential, C as CredentialResolver, G as GatewayOptions, a as PostgresBridgeStore, b as PostgresCredentialResolver, c as bearerToken, d as createGateway, h as hashCredential, s as safeTokenHashEqual } from './gateway-BULozv3K.js';
+import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, R as RetryPolicy, A as AgentPresence } from './bridge-domain-CBX3IVqC.js';
+export { a as BridgeDeliveryEvent, d as BridgePrincipalMismatchError, e as BridgeValidationError, D as DeliveryAction, f as DeliveryPolicy, g as DeliveryState, h as DeliveryStateConflictError, J as JsonValue, L as LeasedDeliveryPolicy, M as MessageDraft, i as MessagePriority, j as cursorScope, k as decodeCursor, l as decodeScopedCursor, m as encodeCursor, n as encodeScopedCursor, s as scopedCursorScope, u as uuidv7, v as validateDeliveryCursorPosition, o as validateDeliveryPolicy, p as validateEventCursorPosition, q as validateLeasedDeliveryPolicy, r as validateMessageDraft, t as validatePrincipal, w as validateProject, x as validateUuid } from './bridge-domain-CBX3IVqC.js';
+import { a as BridgeStore, I as InsertMessageResult, d as MessageQuery, M as MessagePage, C as ClaimOptions, B as BridgeDiagnostics, c as DeliveryQuery } from './bridge-store-DPVSCwfs.js';
+export { D as DeliveryEventPage, b as DeliveryPage } from './bridge-store-DPVSCwfs.js';
+export { B as BridgeService, P as PublicMessageQuery } from './bridge-service-hX1ZQp4W.js';
+import { P as PgQueryable } from './postgres-bridge-store-Bfd3hRId.js';
+export { a as PgTransactionClient, b as PostgresBridgeStore } from './postgres-bridge-store-Bfd3hRId.js';
+export { A as AuthenticatedCredential, C as CredentialResolver, G as GatewayOptions, P as PostgresCredentialResolver, b as bearerToken, c as createGateway, h as hashCredential, s as safeTokenHashEqual } from './gateway-CggQ8vTC.js';
 export { CachedMessagePage, EdgeConflictError, EdgeEnqueueResult, EdgeOutboxRecord, EdgeScope, EdgeStats, PendingMessage, SQLiteBridgeStore, SQLiteEdgeStore, SyncDiagnostics, SyncInsertResult, SyncReport, SyncingBridgeStore, SyncingBridgeStoreOptions, edgeMessageFingerprint, edgeScopeKey, isRetryableSyncError, stableIdempotency } from './sqlite.js';
 import 'node:http';
 
@@ -20,15 +22,18 @@ declare class LegacySupabaseRestStore implements BridgeStore {
     private readonly legacyIds;
     private initialized;
     constructor(url: string, key: string, fetchImpl?: typeof fetch, timeoutMs?: number);
-    initialize(): Promise<void>;
+    initialize(options?: {
+        mode?: "active" | "passive";
+    }): Promise<void>;
     private request;
+    private visibleReceiptIds;
     insertMessage(input: Omit<BridgeMessage, "sequence" | "createdAt">): Promise<InsertMessageResult>;
     listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
-    recordReceipt(_workspace: string, ids: string[], principal: string): Promise<number>;
+    recordReceipt(principal: BridgePrincipal, ids: string[]): Promise<number>;
     recordLegacyReceipt(ids: string[], principal: string): Promise<number>;
     claimDelivery(_principal: BridgePrincipal, _options: ClaimOptions): Promise<BridgeDelivery | null>;
     renewDelivery(_principal: BridgePrincipal, _deliveryId: string, _leaseToken: string, _leaseMs: number): Promise<BridgeDelivery | null>;
-    settleDelivery(_principal: BridgePrincipal, _deliveryId: string, _leaseToken: string, _state: "acked" | "retrying" | "dead", _error: string | undefined, _retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
+    settleDelivery(_principal: BridgePrincipal, _deliveryId: string, _leaseToken: string, _state: "acked" | "retrying" | "dead", _error?: string, _retryPolicy?: RetryPolicy): Promise<BridgeDelivery | null>;
     diagnostics(_principal: BridgePrincipal): Promise<BridgeDiagnostics>;
 }
 
@@ -43,27 +48,51 @@ interface HttpBridgeStoreOptions {
 declare class BridgeHttpError extends Error {
     readonly status: number;
     readonly code: string;
-    constructor(status: number, code: string);
+    readonly requestId?: string | undefined;
+    readonly details?: unknown | undefined;
+    constructor(status: number, code: string, requestId?: string | undefined, details?: unknown | undefined, message?: string);
 }
 declare class HttpBridgeStore implements BridgeStore {
     private readonly options;
     private readonly fetchImpl;
+    private readonly closeController;
+    private closed;
+    private selectedProtocolVersion?;
+    private protocolProbe?;
     constructor(options: HttpBridgeStoreOptions);
-    initialize(): Promise<void>;
+    initialize(options?: {
+        signal?: AbortSignal;
+        mode?: "active" | "passive";
+    }): Promise<void>;
     private assertBoundPrincipal;
     private request;
+    private ensureProtocol;
+    capabilities(): Promise<unknown>;
     private assertPrincipal;
-    insertMessage(message: Omit<BridgeMessage, "sequence" | "createdAt">): Promise<InsertMessageResult>;
-    listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
-    recordReceipt(workspace: string, ids: string[], principal: string): Promise<number>;
+    insertMessage(message: Omit<BridgeMessage, "sequence" | "createdAt">, options?: {
+        signal?: AbortSignal;
+    }): Promise<InsertMessageResult>;
+    listMessages(principal: BridgePrincipal, query?: MessageQuery, options?: {
+        signal?: AbortSignal;
+    }): Promise<MessagePage>;
+    recordReceipt(principal: BridgePrincipal, ids: string[]): Promise<number>;
     diagnostics(principal: BridgePrincipal): Promise<BridgeDiagnostics>;
     claimDelivery(principal: BridgePrincipal, options: ClaimOptions): Promise<BridgeDelivery | null>;
+    listDeliveries(principal: BridgePrincipal, query?: DeliveryQuery): Promise<any>;
+    listDeliveryEvents(principal: BridgePrincipal, id: string, query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<any>;
+    cancelDelivery(principal: BridgePrincipal, id: string): Promise<any>;
+    requeueDelivery(principal: BridgePrincipal, id: string): Promise<any>;
     renewDelivery(principal: BridgePrincipal, id: string, token: string, leaseMs: number): Promise<BridgeDelivery | null>;
-    settleDelivery(principal: BridgePrincipal, id: string, token: string, state: "acked" | "retrying" | "dead", error: string | undefined, retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
+    settleDelivery(principal: BridgePrincipal, id: string, token: string, state: "acked" | "retrying" | "dead", error?: string, _retryPolicy?: RetryPolicy): Promise<BridgeDelivery | null>;
     heartbeat(principal: BridgePrincipal, leaseMs: number, runtimeType?: string, capabilities?: string[]): Promise<AgentPresence>;
     listPresence(principal: BridgePrincipal): Promise<AgentPresence[]>;
+    close(): Promise<void>;
 }
 
+declare const NATIVE_DR_ADVISORY_LOCK_KEY = 1646705664;
 interface AppliedMigration {
     version: number;
     name: string;
@@ -93,10 +122,40 @@ declare const REQUIRED_MIGRATIONS: readonly [{
 }, {
     readonly version: 7;
     readonly name: "runtime_role";
+}, {
+    readonly version: 8;
+    readonly name: "message_projects";
+}, {
+    readonly version: 9;
+    readonly name: "mailbox_query_indexes";
+}, {
+    readonly version: 10;
+    readonly name: "publisher_delivery_policy";
+}, {
+    readonly version: 11;
+    readonly name: "credential_security";
+}, {
+    readonly version: 12;
+    readonly name: "request_authority";
+}, {
+    readonly version: 13;
+    readonly name: "row_isolation";
+}, {
+    readonly version: 14;
+    readonly name: "owner_control_plane";
+}, {
+    readonly version: 15;
+    readonly name: "portable_archives";
+}, {
+    readonly version: 16;
+    readonly name: "native_dr_fence";
 }];
 declare function loadMigrationPlan(directory: string): Promise<MigrationPlanEntry[]>;
 declare function migrationsReady(db: PgQueryable, expected: ReadonlyArray<Pick<MigrationPlanEntry, "version" | "name" | "checksum">>): Promise<boolean>;
-declare function runtimeSchemaReady(db: PgQueryable): Promise<boolean>;
+declare function rowIsolationReady(db: PgQueryable, allowPrivilegedCaller: boolean): Promise<boolean>;
+declare function runtimeSchemaReady(db: PgQueryable, options?: {
+    allowPrivilegedCaller?: boolean;
+}): Promise<boolean>;
 declare function runMigrations(db: PgQueryable, directory: string): Promise<AppliedMigration[]>;
 
-export { AgentPresence, type AppliedMigration, BridgeDelivery, BridgeDiagnostics, BridgeHttpError, BridgeMessage, BridgePrincipal, BridgeStore, ClaimOptions, HttpBridgeStore, type HttpBridgeStoreOptions, InsertMessageResult, LegacySupabaseError, LegacySupabaseRestStore, MessagePage, MessageQuery, type MigrationPlanEntry, PgQueryable, REQUIRED_MIGRATIONS, RetryPolicy, loadMigrationPlan, migrationsReady, runMigrations, runtimeSchemaReady };
+export { AgentPresence, type AppliedMigration, BridgeDelivery, BridgeDiagnostics, BridgeHttpError, BridgeMessage, BridgePrincipal, BridgeStore, ClaimOptions, DeliveryQuery, HttpBridgeStore, type HttpBridgeStoreOptions, InsertMessageResult, LegacySupabaseError, LegacySupabaseRestStore, MessagePage, MessageQuery, type MigrationPlanEntry, NATIVE_DR_ADVISORY_LOCK_KEY, PgQueryable, REQUIRED_MIGRATIONS, RetryPolicy, loadMigrationPlan, migrationsReady, rowIsolationReady, runMigrations, runtimeSchemaReady };

package/dist/bridge.js

@@ -1,59 +1,78 @@
 #!/usr/bin/env node
+import {
+  BridgeHttpError,
+  HttpBridgeStore,
+  LegacySupabaseError,
+  LegacySupabaseRestStore
+} from "./chunk-CEXBMOI5.js";
+import {
+  EdgeConflictError,
+  SQLiteEdgeStore,
+  SyncingBridgeStore,
+  edgeMessageFingerprint,
+  edgeScopeKey,
+  isRetryableSyncError,
+  stableIdempotency
+} from "./chunk-Q6PPMXJC.js";
+import {
+  SQLiteBridgeStore
+} from "./chunk-5GMB3A77.js";
+import "./chunk-NCO7RLBM.js";
 import {
   PostgresBridgeStore
-} from "./chunk-O26W5QHS.js";
+} from "./chunk-2DFNOLMO.js";
 import {
+  NATIVE_DR_ADVISORY_LOCK_KEY,
   REQUIRED_MIGRATIONS,
   loadMigrationPlan,
   migrationsReady,
+  rowIsolationReady,
   runMigrations,
   runtimeSchemaReady
-} from "./chunk-6MAZ6YLZ.js";
+} from "./chunk-45BZGB77.js";
+import "./chunk-VOQIDTCJ.js";
 import {
   PostgresCredentialResolver,
   bearerToken,
   createGateway,
   hashCredential,
   safeTokenHashEqual
-} from "./chunk-JOUBDRYX.js";
-import {
-  BridgeHttpError,
-  HttpBridgeStore,
-  LegacySupabaseError,
-  LegacySupabaseRestStore
-} from "./chunk-AXL2I7FH.js";
-import {
-  EdgeConflictError,
-  SQLiteBridgeStore,
-  SQLiteEdgeStore,
-  SyncingBridgeStore,
-  edgeMessageFingerprint,
-  edgeScopeKey,
-  isRetryableSyncError,
-  stableIdempotency
-} from "./chunk-WEULPMUY.js";
-import "./chunk-YD6YJATN.js";
+} from "./chunk-WAI2IYIQ.js";
 import {
   BridgeService
-} from "./chunk-CKSKUBDQ.js";
+} from "./chunk-4VB44KJU.js";
+import "./chunk-GADH244D.js";
 import {
+  BridgePrincipalMismatchError,
   BridgeValidationError,
+  DeliveryStateConflictError,
+  cursorScope,
   decodeCursor,
+  decodeScopedCursor,
   encodeCursor,
+  encodeScopedCursor,
+  scopedCursorScope,
   uuidv7,
+  validateDeliveryCursorPosition,
+  validateDeliveryPolicy,
+  validateEventCursorPosition,
+  validateLeasedDeliveryPolicy,
   validateMessageDraft,
   validatePrincipal,
-  validateRetryPolicy,
+  validateProject,
   validateUuid
-} from "./chunk-BV6W4AJK.js";
+} from "./chunk-BZLMF5O5.js";
 export {
   BridgeHttpError,
+  BridgePrincipalMismatchError,
   BridgeService,
   BridgeValidationError,
+  DeliveryStateConflictError,
   EdgeConflictError,
   HttpBridgeStore,
   LegacySupabaseError,
   LegacySupabaseRestStore,
+  NATIVE_DR_ADVISORY_LOCK_KEY,
   PostgresBridgeStore,
   PostgresCredentialResolver,
   REQUIRED_MIGRATIONS,
@@ -62,22 +81,31 @@ export {
   SyncingBridgeStore,
   bearerToken,
   createGateway,
+  cursorScope,
   decodeCursor,
+  decodeScopedCursor,
   edgeMessageFingerprint,
   edgeScopeKey,
   encodeCursor,
+  encodeScopedCursor,
   hashCredential,
   isRetryableSyncError,
   loadMigrationPlan,
   migrationsReady,
+  rowIsolationReady,
   runMigrations,
   runtimeSchemaReady,
   safeTokenHashEqual,
+  scopedCursorScope,
   stableIdempotency,
   uuidv7,
+  validateDeliveryCursorPosition,
+  validateDeliveryPolicy,
+  validateEventCursorPosition,
+  validateLeasedDeliveryPolicy,
   validateMessageDraft,
   validatePrincipal,
-  validateRetryPolicy,
+  validateProject,
   validateUuid
 };
 //# sourceMappingURL=bridge.js.map