@creatornader/agent-bridge 0.2.0 → 0.3.1

package/dist/dr.d.ts

@@ -0,0 +1,324 @@
+import { DatabaseSync } from 'node:sqlite';
+
+declare const NATIVE_DR_MAX_BUNDLE_BYTES: number;
+declare const NATIVE_DR_FORMAT = "agent-bridge-native-dr";
+declare const NATIVE_DR_VERSION = 1;
+interface NativeDrManifest {
+    backupId: string;
+    createdAt: string;
+    entries: Array<{
+        length: number;
+        name: string;
+        sha256: string;
+    }>;
+    format: typeof NATIVE_DR_FORMAT;
+    kind: "sqlite" | "postgres";
+    schema: Record<string, unknown>;
+    version: typeof NATIVE_DR_VERSION;
+}
+interface NativeDrBundleMetadata {
+    manifest: NativeDrManifest;
+    bundleSha256: string;
+    bundleBytes: number;
+}
+declare class NativeDrBundleError extends Error {
+}
+interface NativeDrInputEntry {
+    name: string;
+    path: string;
+}
+interface NativeDrBundleInput {
+    backupId: string;
+    createdAt: string;
+    entries: readonly NativeDrInputEntry[];
+    kind: "sqlite" | "postgres";
+    schema: Record<string, unknown>;
+}
+interface NativeDrBundleWriteHooks {
+    afterHash?(): void;
+}
+declare function validateNativeDrAggregateSize(entryBytes: readonly number[], framingBytes?: number): number;
+declare function writeNativeDrBundle(outputDescriptor: number, input: NativeDrBundleInput, outputPath: string, hooks?: NativeDrBundleWriteHooks): NativeDrManifest;
+declare class NativeDrBundleReader {
+    readonly path: string;
+    private readonly descriptor;
+    private readonly identity;
+    private closed;
+    constructor(path: string);
+    private readExact;
+    inspect(output?: (entry: NativeDrManifest["entries"][number]) => number | undefined): NativeDrBundleMetadata;
+    close(): void;
+}
+
+declare const LOCAL_SQLITE_APPLICATION_ID = 1094862642;
+declare const EDGE_SQLITE_APPLICATION_ID = 1094862661;
+declare const SQLITE_DATABASE_SCHEMA_VERSION = 1;
+declare const SQLITE_METADATA_TABLE = "agent_bridge_metadata";
+declare const LOCAL_SQLITE_SCHEMA_CONTRACTS: readonly [Readonly<{
+    id: "current-created-schema";
+    sha256: "e2f978c27ea5d151a4b4b3ec349166833441e42401fedfe60dc3ba20f3d713aa";
+}>, Readonly<{
+    id: "current-upgraded-project-column";
+    sha256: "cb0975bbc1ccc7a2a66d8f4d76df619804449cf81119972337afad6cdab64451";
+}>, Readonly<{
+    id: "current-upgraded-delivery-policy";
+    sha256: "d4fd8905ea73057b27662454c16c038834f5a1bf017db9cfc041792104aa2e6d";
+}>, Readonly<{
+    id: "current-upgraded-delivery-events";
+    sha256: "35bdab0cbdf4ce619ba1c7d36032379ae4d9692bd7509e49bb90b409bbbcf632";
+}>];
+declare const EDGE_SQLITE_SCHEMA_CONTRACTS: readonly [Readonly<{
+    id: "current-created-schema";
+    sha256: "27f22b2f4024585c87e8d6f76f8999a8df92bb1f585d46594a7a1e852fd53c4c";
+}>, Readonly<{
+    id: "current-upgraded-project-column";
+    sha256: "171ae11f520b4963f517d3102de64cb8a5f45c080078ff02e20aeb17891b585c";
+}>];
+declare const isSupportedLocalSqliteSchemaContract: (hash: string) => boolean;
+declare const isSupportedEdgeSqliteSchemaContract: (hash: string) => boolean;
+declare class SQLiteDatabaseContractError extends Error {
+}
+declare function sqliteSchemaContractHash(db: DatabaseSync): string;
+declare function assertLocalUpgradeCandidate(db: DatabaseSync): void;
+declare function assertEdgeUpgradeCandidate(db: DatabaseSync): void;
+declare function installLocalAuthorityMarkers(db: DatabaseSync): void;
+declare function installEdgeMarkers(db: DatabaseSync): void;
+declare function identifySqliteDatabase(db: DatabaseSync): "local-authority" | "edge-cache" | "legacy-local" | "legacy-edge" | "unknown";
+declare function assertEdgeDatabase(db: DatabaseSync): void;
+declare function assertLocalAuthorityDatabase(db: DatabaseSync): void;
+declare function verifySqliteHealth(db: DatabaseSync): void;
+
+declare class NativeDrCommandError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, details?: Record<string, unknown> | undefined);
+}
+interface NativeDrFileOperations {
+    link(source: string, target: string): void;
+    unlink(path: string): void;
+    syncDirectory(path: string): void;
+    afterPublish?(target: string): void;
+}
+interface SQLiteNativeDrOptions {
+    timeoutMs?: number;
+    fileOperations?: Partial<NativeDrFileOperations>;
+    runBackupWorker?: typeof runSqliteBackupWorker;
+    now?: () => Date;
+}
+declare function validateNativeDrId(value: string): string;
+declare function validateNativeDrTimeout(value: number | undefined): number;
+declare function runSqliteBackupWorker(source: string, destination: string, timeoutMs: number): Promise<number>;
+declare function backupLocalSqlite(sourcePath: string, outputPath: string, backupIdInput?: string, options?: SQLiteNativeDrOptions): Promise<NativeDrBundleMetadata>;
+declare function verifyNativeDrBundle(path: string): NativeDrBundleMetadata;
+declare function restoreLocalSqlite(bundlePath: string, targetPath: string, requestIdInput?: string, options?: SQLiteNativeDrOptions): Promise<NativeDrBundleMetadata & {
+    requestId: string;
+}>;
+declare const SQLITE_EDGE_APPLICATION_ID = 1094862661;
+
+declare const POSTGRES_NATIVE_DR_ROLE_SCHEMA = "agent-bridge.postgres-native-dr-roles";
+declare const POSTGRES_NATIVE_DR_ROLE_VERSION = 1;
+declare const POSTGRES_NATIVE_DR_SERVICE = "agent_bridge_dr";
+declare const POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES: readonly ["agent_bridge.agent_instances", "agent_bridge.rate_limit_buckets", "agent_bridge.request_authorities", "agent_bridge.archive_transaction_authorizations"];
+type PostgresDrRoleKind = "derived" | "schema-owner" | "object-role" | "external-principal";
+interface PostgresDrRole {
+    name: string;
+    kind: PostgresDrRoleKind;
+}
+interface PostgresDrMembership {
+    role: string;
+    member: string;
+    adminOption: boolean;
+    inheritOption: boolean;
+    setOption: boolean;
+}
+interface PostgresDrDefaultAclGrantBase {
+    grantor: string;
+    privilege: string;
+    grantable: boolean;
+}
+type PostgresDrDefaultAclGrant = PostgresDrDefaultAclGrantBase & ({
+    granteeKind: "public";
+} | {
+    granteeKind: "role";
+    grantee: string;
+});
+interface PostgresDrDefaultAcl {
+    owner: string;
+    schema: "agent_bridge" | null;
+    objectType: "r" | "S" | "f" | "T" | "n";
+    grants: PostgresDrDefaultAclGrant[];
+}
+interface PostgresDrRoleInventory {
+    schema: typeof POSTGRES_NATIVE_DR_ROLE_SCHEMA;
+    version: typeof POSTGRES_NATIVE_DR_ROLE_VERSION;
+    databaseName: string;
+    roles: PostgresDrRole[];
+    memberships: PostgresDrMembership[];
+    defaultAcls: PostgresDrDefaultAcl[];
+}
+interface PostgresDrLibpqFiles {
+    serviceName: typeof POSTGRES_NATIVE_DR_SERVICE;
+    serviceFile: string;
+    passFile: string;
+    environment: Record<"LC_ALL" | "PGAPPNAME" | "PGPASSFILE" | "PGSERVICE" | "PGSERVICEFILE", string>;
+}
+interface PostgresNativeDrMigration {
+    version: number;
+    name: string;
+    checksum: string;
+}
+interface PostgresNativeDrSchema {
+    databaseName: string;
+    serverVersionNum: number;
+    serverMajor: number;
+    schemaVersion: number;
+    migrations: PostgresNativeDrMigration[];
+    tableCounts: Record<string, string>;
+    excludedDataTables: string[];
+    claimedDeliveryCount: string;
+    pgDumpVersion: string;
+    roleInventorySha256: string;
+    readinessAttestations: {
+        securitySchemaSha256: string;
+        rowIsolationSha256: string;
+        ownerControlSha256: string;
+        portableArchiveSha256: string;
+    };
+}
+interface PostgresNativeDrBundleInput {
+    backupId: string;
+    createdAt: string;
+    kind: "postgres";
+    schema: PostgresNativeDrSchema;
+    entries: readonly [
+        {
+            name: "postgres/database.dump";
+            path: string;
+        },
+        {
+            name: "postgres/roles.json";
+            path: string;
+        }
+    ];
+}
+interface PostgresDrQueryResult<T> {
+    rows: T[];
+    rowCount: number | null;
+}
+interface PostgresDrClient {
+    connect(): Promise<void>;
+    query<T = Record<string, unknown>>(sql: string, values?: unknown[]): Promise<PostgresDrQueryResult<T>>;
+    end(): Promise<void>;
+}
+interface PostgresDrToolResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut?: boolean;
+    stdoutTruncated?: boolean;
+    stderrTruncated?: boolean;
+}
+interface PostgresNativeDrDependencies {
+    createClient(connectionUrl: string): PostgresDrClient;
+    resolveTool(tool: "pg_dump" | "pg_restore", toolDirectory?: string): string;
+    runTool(command: string, args: string[], environment: Record<string, string>, inputFileDescriptor?: number): Promise<PostgresDrToolResult>;
+    now(): Date;
+    randomId(): string;
+    checkRowIsolationReady(client: PostgresDrClient): Promise<boolean>;
+    removePath(path: string): void;
+}
+interface BackupPostgresNativeDrOptions {
+    stagingDirectory: string;
+    backupId?: string;
+    environment?: NodeJS.ProcessEnv;
+    toolDirectory?: string;
+    dependencies?: Partial<PostgresNativeDrDependencies>;
+}
+interface RestorePostgresNativeDrOptions {
+    dumpPath: string;
+    rolesPath: string;
+    schema: PostgresNativeDrSchema;
+    artifactAnchors: PostgresNativeDrArtifactAnchors;
+    acceptSourceSqlRisk: boolean;
+    environment?: NodeJS.ProcessEnv;
+    toolDirectory?: string;
+    dependencies?: Partial<PostgresNativeDrDependencies>;
+}
+interface PostgresNativeDrArtifactAnchor {
+    descriptor: number;
+    device: string;
+    inode: string;
+    size: string;
+    ctimeNanoseconds: string;
+    mtimeNanoseconds: string;
+    sha256: string;
+}
+interface PostgresNativeDrArtifactAnchors {
+    dump: PostgresNativeDrArtifactAnchor;
+    roles: PostgresNativeDrArtifactAnchor;
+}
+interface VerifyPostgresNativeDrArtifactsOptions {
+    dumpPath: string;
+    rolesPath: string;
+    schema: PostgresNativeDrSchema;
+    artifactAnchors: PostgresNativeDrArtifactAnchors;
+    toolDirectory?: string;
+    dependencies?: Partial<PostgresNativeDrDependencies>;
+}
+interface VerifyPostgresNativeDrArtifactsResult {
+    schema: PostgresNativeDrSchema;
+    roleInventory: PostgresDrRoleInventory;
+    artifactAnchors: PostgresNativeDrArtifactAnchors;
+    dumpTocVerified: true;
+    dumpToc: string;
+}
+interface RestorePostgresNativeDrResult {
+    databaseName: string;
+    normalizedClaimedDeliveries: string;
+    tableCounts: Record<string, string>;
+    readiness: {
+        security: true;
+        rowIsolation: true;
+        ownerControl: true;
+        portableArchive: true;
+    };
+}
+declare class PostgresNativeDrError extends Error {
+    readonly code: string;
+    readonly details: {
+        residualRoleShells?: string[];
+        targetOffline?: boolean;
+        targetMutated?: boolean;
+        restoreCompleted?: boolean;
+        recoveryPaths?: string[];
+        causeCode?: string;
+    };
+    constructor(code: string, message: string, details?: {
+        residualRoleShells?: string[];
+        targetOffline?: boolean;
+        targetMutated?: boolean;
+        restoreCompleted?: boolean;
+        recoveryPaths?: string[];
+        causeCode?: string;
+    });
+}
+declare function createPostgresDrLibpqFiles(connectionUrl: string, directory: string): PostgresDrLibpqFiles;
+declare function buildPgDumpArgs(outputPath: string, snapshot: string, serviceName?: string): string[];
+declare function buildPgRestoreArgs(inputPath: string | undefined, serviceName?: string): string[];
+declare function buildPgRestoreListArgs(inputPath?: string): string[];
+declare function buildPgRestoreSchemaAclArgs(inputPath: string | undefined, listPath: string, serviceName?: string): string[];
+declare function validatePostgresDumpToc(text: string): void;
+declare function schemaAclRestoreList(text: string): string;
+declare function parsePostgresToolMajor(output: string): number;
+declare function validatePostgresRoleInventory(value: unknown): PostgresDrRoleInventory;
+declare function canonicalPostgresRoleInventory(inventory: PostgresDrRoleInventory): string;
+declare function buildPostgresRoleShellStatements(inventory: PostgresDrRoleInventory): string[];
+declare function buildPostgresMembershipStatements(inventory: PostgresDrRoleInventory, serverMajor: number): string[];
+declare function buildPostgresDefaultPrivilegeStatements(inventory: PostgresDrRoleInventory): string[];
+declare function collectPostgresRoleInventory(client: PostgresDrClient, databaseName: string): Promise<PostgresDrRoleInventory>;
+declare function backupPostgresNativeDr(options: BackupPostgresNativeDrOptions): Promise<PostgresNativeDrBundleInput>;
+declare function verifyPostgresNativeDrArtifacts(options: VerifyPostgresNativeDrArtifactsOptions): Promise<VerifyPostgresNativeDrArtifactsResult>;
+declare function assertPostgresRestoreAuthority(client: PostgresDrClient): Promise<void>;
+declare function restorePostgresNativeDr(options: RestorePostgresNativeDrOptions): Promise<RestorePostgresNativeDrResult>;
+
+export { type BackupPostgresNativeDrOptions, EDGE_SQLITE_APPLICATION_ID, EDGE_SQLITE_SCHEMA_CONTRACTS, LOCAL_SQLITE_APPLICATION_ID, LOCAL_SQLITE_SCHEMA_CONTRACTS, NATIVE_DR_FORMAT, NATIVE_DR_MAX_BUNDLE_BYTES, NATIVE_DR_VERSION, NativeDrBundleError, type NativeDrBundleInput, type NativeDrBundleMetadata, NativeDrBundleReader, type NativeDrBundleWriteHooks, NativeDrCommandError, type NativeDrFileOperations, type NativeDrInputEntry, type NativeDrManifest, POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES, POSTGRES_NATIVE_DR_ROLE_SCHEMA, POSTGRES_NATIVE_DR_ROLE_VERSION, POSTGRES_NATIVE_DR_SERVICE, type PostgresDrClient, type PostgresDrDefaultAcl, type PostgresDrDefaultAclGrant, type PostgresDrLibpqFiles, type PostgresDrMembership, type PostgresDrRole, type PostgresDrRoleInventory, type PostgresDrRoleKind, type PostgresDrToolResult, type PostgresNativeDrArtifactAnchor, type PostgresNativeDrArtifactAnchors, type PostgresNativeDrBundleInput, type PostgresNativeDrDependencies, PostgresNativeDrError, type PostgresNativeDrMigration, type PostgresNativeDrSchema, type RestorePostgresNativeDrOptions, type RestorePostgresNativeDrResult, SQLITE_DATABASE_SCHEMA_VERSION, SQLITE_EDGE_APPLICATION_ID, SQLITE_METADATA_TABLE, SQLiteDatabaseContractError, type SQLiteNativeDrOptions, type VerifyPostgresNativeDrArtifactsOptions, type VerifyPostgresNativeDrArtifactsResult, assertEdgeDatabase, assertEdgeUpgradeCandidate, assertLocalAuthorityDatabase, assertLocalUpgradeCandidate, assertPostgresRestoreAuthority, backupLocalSqlite, backupPostgresNativeDr, buildPgDumpArgs, buildPgRestoreArgs, buildPgRestoreListArgs, buildPgRestoreSchemaAclArgs, buildPostgresDefaultPrivilegeStatements, buildPostgresMembershipStatements, buildPostgresRoleShellStatements, canonicalPostgresRoleInventory, collectPostgresRoleInventory, createPostgresDrLibpqFiles, identifySqliteDatabase, installEdgeMarkers, installLocalAuthorityMarkers, isSupportedEdgeSqliteSchemaContract, isSupportedLocalSqliteSchemaContract, parsePostgresToolMajor, restoreLocalSqlite, restorePostgresNativeDr, runSqliteBackupWorker, schemaAclRestoreList, sqliteSchemaContractHash, validateNativeDrAggregateSize, validateNativeDrId, validateNativeDrTimeout, validatePostgresDumpToc, validatePostgresRoleInventory, verifyNativeDrBundle, verifyPostgresNativeDrArtifacts, verifySqliteHealth, writeNativeDrBundle };

package/dist/dr.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import {
+  NATIVE_DR_FORMAT,
+  NATIVE_DR_MAX_BUNDLE_BYTES,
+  NATIVE_DR_VERSION,
+  NativeDrBundleError,
+  NativeDrBundleReader,
+  NativeDrCommandError,
+  POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES,
+  POSTGRES_NATIVE_DR_ROLE_SCHEMA,
+  POSTGRES_NATIVE_DR_ROLE_VERSION,
+  POSTGRES_NATIVE_DR_SERVICE,
+  PostgresNativeDrError,
+  SQLITE_EDGE_APPLICATION_ID,
+  assertPostgresRestoreAuthority,
+  backupLocalSqlite,
+  backupPostgresNativeDr,
+  buildPgDumpArgs,
+  buildPgRestoreArgs,
+  buildPgRestoreListArgs,
+  buildPgRestoreSchemaAclArgs,
+  buildPostgresDefaultPrivilegeStatements,
+  buildPostgresMembershipStatements,
+  buildPostgresRoleShellStatements,
+  canonicalPostgresRoleInventory,
+  collectPostgresRoleInventory,
+  createPostgresDrLibpqFiles,
+  parsePostgresToolMajor,
+  restoreLocalSqlite,
+  restorePostgresNativeDr,
+  runSqliteBackupWorker,
+  schemaAclRestoreList,
+  validateNativeDrAggregateSize,
+  validateNativeDrId,
+  validateNativeDrTimeout,
+  validatePostgresDumpToc,
+  validatePostgresRoleInventory,
+  verifyNativeDrBundle,
+  verifyPostgresNativeDrArtifacts,
+  writeNativeDrBundle
+} from "./chunk-MBPZXTJA.js";
+import {
+  EDGE_SQLITE_APPLICATION_ID,
+  EDGE_SQLITE_SCHEMA_CONTRACTS,
+  LOCAL_SQLITE_APPLICATION_ID,
+  LOCAL_SQLITE_SCHEMA_CONTRACTS,
+  SQLITE_DATABASE_SCHEMA_VERSION,
+  SQLITE_METADATA_TABLE,
+  SQLiteDatabaseContractError,
+  assertEdgeDatabase,
+  assertEdgeUpgradeCandidate,
+  assertLocalAuthorityDatabase,
+  assertLocalUpgradeCandidate,
+  identifySqliteDatabase,
+  installEdgeMarkers,
+  installLocalAuthorityMarkers,
+  isSupportedEdgeSqliteSchemaContract,
+  isSupportedLocalSqliteSchemaContract,
+  sqliteSchemaContractHash,
+  verifySqliteHealth
+} from "./chunk-5GMB3A77.js";
+import "./chunk-NCO7RLBM.js";
+import "./chunk-45BZGB77.js";
+import "./chunk-VOQIDTCJ.js";
+import "./chunk-BZLMF5O5.js";
+export {
+  EDGE_SQLITE_APPLICATION_ID,
+  EDGE_SQLITE_SCHEMA_CONTRACTS,
+  LOCAL_SQLITE_APPLICATION_ID,
+  LOCAL_SQLITE_SCHEMA_CONTRACTS,
+  NATIVE_DR_FORMAT,
+  NATIVE_DR_MAX_BUNDLE_BYTES,
+  NATIVE_DR_VERSION,
+  NativeDrBundleError,
+  NativeDrBundleReader,
+  NativeDrCommandError,
+  POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES,
+  POSTGRES_NATIVE_DR_ROLE_SCHEMA,
+  POSTGRES_NATIVE_DR_ROLE_VERSION,
+  POSTGRES_NATIVE_DR_SERVICE,
+  PostgresNativeDrError,
+  SQLITE_DATABASE_SCHEMA_VERSION,
+  SQLITE_EDGE_APPLICATION_ID,
+  SQLITE_METADATA_TABLE,
+  SQLiteDatabaseContractError,
+  assertEdgeDatabase,
+  assertEdgeUpgradeCandidate,
+  assertLocalAuthorityDatabase,
+  assertLocalUpgradeCandidate,
+  assertPostgresRestoreAuthority,
+  backupLocalSqlite,
+  backupPostgresNativeDr,
+  buildPgDumpArgs,
+  buildPgRestoreArgs,
+  buildPgRestoreListArgs,
+  buildPgRestoreSchemaAclArgs,
+  buildPostgresDefaultPrivilegeStatements,
+  buildPostgresMembershipStatements,
+  buildPostgresRoleShellStatements,
+  canonicalPostgresRoleInventory,
+  collectPostgresRoleInventory,
+  createPostgresDrLibpqFiles,
+  identifySqliteDatabase,
+  installEdgeMarkers,
+  installLocalAuthorityMarkers,
+  isSupportedEdgeSqliteSchemaContract,
+  isSupportedLocalSqliteSchemaContract,
+  parsePostgresToolMajor,
+  restoreLocalSqlite,
+  restorePostgresNativeDr,
+  runSqliteBackupWorker,
+  schemaAclRestoreList,
+  sqliteSchemaContractHash,
+  validateNativeDrAggregateSize,
+  validateNativeDrId,
+  validateNativeDrTimeout,
+  validatePostgresDumpToc,
+  validatePostgresRoleInventory,
+  verifyNativeDrBundle,
+  verifyPostgresNativeDrArtifacts,
+  verifySqliteHealth,
+  writeNativeDrBundle
+};
+//# sourceMappingURL=dr.js.map

package/dist/dr.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/gateway-CggQ8vTC.d.ts

@@ -0,0 +1,78 @@
+import * as node_http from 'node:http';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as BridgeStore } from './bridge-store-DPVSCwfs.js';
+import { c as BridgePrincipal } from './bridge-domain-CBX3IVqC.js';
+import { P as PgQueryable, b as PostgresBridgeStore } from './postgres-bridge-store-Bfd3hRId.js';
+
+declare const AUTHORIZATION_SCOPES: readonly ["deliveries:claim", "deliveries:manage", "deliveries:read", "deliveries:settle", "gateway:metrics", "messages:read", "messages:write", "presence:read", "presence:write", "receipts:write", "status:read"];
+type AuthorizationScope = typeof AUTHORIZATION_SCOPES[number];
+type OperationId = "capabilities" | "status" | "client_status" | "gateway_metrics" | "publish_message" | "history" | "record_receipt" | "claim_delivery" | "list_deliveries" | "list_delivery_events" | "cancel_delivery" | "requeue_delivery" | "extend_delivery" | "acknowledge_delivery" | "negative_acknowledge_delivery" | "heartbeat" | "presence" | "sync";
+
+interface AuthenticatedCredential {
+    id: string;
+    principal: BridgePrincipal;
+    /** Canonical authorization scopes granted to this credential. */
+    scopes: readonly AuthorizationScope[];
+}
+interface CredentialResolver {
+    resolve(token: string, signal?: AbortSignal): Promise<AuthenticatedCredential | null>;
+}
+declare function hashCredential(token: string): string;
+declare class PostgresCredentialResolver implements CredentialResolver {
+    private readonly db;
+    constructor(db: PgQueryable);
+    resolve(token: string, signal?: AbortSignal): Promise<AuthenticatedCredential | null>;
+}
+declare function bearerToken(value: string | undefined): string | null;
+declare function safeTokenHashEqual(token: string, expectedHash: string): boolean;
+
+interface RateLimitDecision {
+    allowed: boolean;
+    policyId: string | null;
+    limit: number;
+    remaining: number;
+    retryAfterSeconds: number;
+}
+interface GatewaySecurity {
+    recordScopeDenial(credentialId: string, operationId: OperationId, requestId: string, signal?: AbortSignal): Promise<void>;
+    consume(credentialId: string, operationId: OperationId, requestId: string, signal?: AbortSignal): Promise<RateLimitDecision>;
+}
+declare class PostgresGatewaySecurity implements GatewaySecurity {
+    private readonly db;
+    constructor(db: PgQueryable);
+    private functionName;
+    recordScopeDenial(credentialId: string, operationId: OperationId, requestId: string, signal?: AbortSignal): Promise<void>;
+    consume(credentialId: string, operationId: OperationId, requestId: string, signal?: AbortSignal): Promise<RateLimitDecision>;
+}
+
+interface RequestAuthorityContext {
+    credential: {
+        id: string;
+        principal: BridgePrincipal;
+        scopes: readonly AuthorizationScope[];
+    };
+    store: PostgresBridgeStore;
+    security: PostgresGatewaySecurity;
+    /** Establishes the savepoint separating durable security accounting from domain work. */
+    beginDomainWork(): Promise<void>;
+}
+interface RequestAuthority {
+    run<T>(credentialId: string, credentialHash: string, requestId: string, signal: AbortSignal, work: (context: RequestAuthorityContext) => Promise<T>): Promise<T>;
+}
+
+interface GatewayOptions {
+    store: BridgeStore;
+    credentials: CredentialResolver;
+    security: GatewaySecurity;
+    allowedOrigins?: string[];
+    bodyLimitBytes?: number;
+    requestDeadlineMs?: number;
+    ready?: () => Promise<boolean>;
+    /** Reports whether the configured database has verified row isolation. */
+    rowIsolationReady?: () => Promise<boolean>;
+    /** Production PostgreSQL request authority. Other providers omit this. */
+    requestAuthority?: RequestAuthority;
+}
+declare function createGateway(options: GatewayOptions): node_http.Server<typeof IncomingMessage, typeof ServerResponse>;
+
+export { type AuthenticatedCredential as A, type CredentialResolver as C, type GatewayOptions as G, PostgresCredentialResolver as P, bearerToken as b, createGateway as c, hashCredential as h, safeTokenHashEqual as s };