{"version":3,"sources":["../../src/rpc/index.ts","../../src/types.ts","../../src/rpc/rpc-promise.ts","../../src/transport/rpc.ts","../../src/rpc/client.ts","../../src/rpc/shared-types.ts"],"sourcesContent":["/**\n * Capnweb RPC client for postgres.do\n *\n * This module provides a capnweb-enabled PostgreSQL client with:\n * - Magic map support for N+1 query elimination\n * - Promise pipelining for batched operations\n * - RPC transport with automatic batching\n *\n * @example\n * ```typescript\n * import { createClient } from 'postgres.do/rpc'\n *\n * const db = createClient('postgres.do/my-database')\n *\n * // Magic map - N+1 solved in single round trip\n * const usersWithOrders = await db.query('SELECT * FROM users')\n *   .map(users => Promise.all(\n *     users.map(u => db.query('SELECT * FROM orders WHERE user_id = $1', [u.id]))\n *   ))\n *\n * // Promise pipelining - chain without await\n * const user = db.query('SELECT * FROM users WHERE id = $1', [id])\n * const posts = user.map(u => db.query('SELECT * FROM posts WHERE author = $1', [u.id]))\n * const comments = posts.map(p => db.query('SELECT * FROM comments WHERE post_id = ANY($1)', [p.map(x => x.id)]))\n * const result = await comments // Single round trip!\n * ```\n *\n * @module postgres.do/rpc\n */\n\n// Client exports\nexport {\n  RpcClient,\n  createClient,\n  type RpcClientConfig,\n  type TransactionOptions,\n  type TransactionClient,\n} from './client'\n\n// RpcPromise exports\nexport {\n  RpcPromise,\n  createRpcPromise,\n  createRowsPromise,\n  batchExecute,\n  magicMap,\n  type RpcExecutionContext,\n  type BatchResult,\n  type MapFn,\n  type RpcQueryResult,\n} from './rpc-promise'\n\n// Re-export transport\nexport { RpcTransport, createRpcTransport, type RpcTransportConfig } from '../transport/rpc'\n\n// Default export\nexport { createClient as default } from './client'\n\n// ============================================================================\n// Shared RPC Types (for use by both client and server)\n// ============================================================================\n\n/**\n * Shared RPC types for the capnweb contract\n *\n * These types are the single source of truth for the RPC protocol.\n * Import these in @dotdo/postgres to ensure type-safe RPC communication.\n *\n * @example Server-side usage in @dotdo/postgres:\n * ```typescript\n * import type {\n *   RpcQueryResult,\n *   RpcBatchQuery,\n *   RpcBatchResult,\n *   RpcTransactionOptions,\n *   IPostgresRpcApi,\n * } from 'postgres.do/rpc'\n * ```\n */\nexport {\n  // Base types\n  type RpcRow,\n  type RpcField,\n\n  // Query types\n  type RpcQueryResult as SharedRpcQueryResult,\n  type RpcBatchQuery,\n  type RpcBatchResult,\n\n  // Transaction types\n  type RpcIsolationLevel,\n  type RpcTransactionOptions,\n  type RpcTransactionState,\n\n  // Error types\n  type RpcError,\n\n  // Wire protocol types\n  RpcMessageType,\n  type RpcQueryRequest,\n  type RpcBatchRequest,\n  type RpcBatchTransactionRequest,\n  type RpcAuthRequest,\n  type RpcPingRequest,\n  type RpcQueryResultMessage,\n  type RpcBatchResultMessage,\n  type RpcErrorMessage,\n  type RpcAuthResultMessage,\n  type RpcPongMessage,\n  type RpcRequestMessage,\n  type RpcResponseMessage,\n  type RpcMessage,\n\n  // Server API interfaces\n  type IPostgresRpcApi,\n  type ITransactionRpcApi,\n} from './shared-types'\n","/**\n * PostgreSQL client types for postgres.do\n * Compatible with Drizzle ORM and direct usage\n */\n\nimport {\n  PostgresError as SharedPostgresError,\n  ConnectionError as SharedConnectionError,\n  ConnectionTimeoutError as SharedConnectionTimeoutError,\n  type ErrorContext,\n} from '@dotdo/postgres-shared/errors'\n\n/** A single row returned from a query */\nexport type Row = Record<string, unknown>\n\n/** Result of a query execution */\nexport interface QueryResult<T extends Row = Row> {\n  /** Rows returned by the query */\n  rows: T[]\n  /** Number of rows affected (for INSERT/UPDATE/DELETE) */\n  rowCount: number\n  /** Column metadata */\n  fields: FieldInfo[]\n  /** Command type (SELECT, INSERT, etc.) */\n  command: string\n}\n\n/** Column/field metadata */\nexport interface FieldInfo {\n  /** Column name */\n  name: string\n  /** PostgreSQL OID for the column type */\n  dataTypeID: number\n  /** Table OID (0 if not from a table) */\n  tableID: number\n  /** Column position in table */\n  columnID: number\n  /** Data type size in bytes (-1 for variable) */\n  dataTypeSize: number\n  /** Type modifier */\n  dataTypeModifier: number\n  /** Format code (0 = text, 1 = binary) */\n  format: number\n}\n\n/** Type parser function */\nexport type TypeParser = (value: string) => unknown\n\n/** Configuration options for the postgres client */\nexport interface PostgresConfig {\n  /** Database connection URL (postgres://...) */\n  url?: string\n\n  /** API key for postgres.do authentication */\n  apiKey?: string\n\n  /** Transport type: 'http' (default) or 'ws' */\n  transport?: 'http' | 'ws'\n\n  /** Custom type parsers by OID */\n  parsers?: Record<number, TypeParser>\n\n  /** Connection timeout in milliseconds */\n  connectTimeout?: number\n\n  /** Query timeout in milliseconds */\n  queryTimeout?: number\n\n  /** Maximum number of retry attempts */\n  maxRetries?: number\n\n  /** Whether to use SSL/TLS */\n  ssl?: boolean | 'require' | 'prefer' | 'allow' | 'disable'\n\n  /** Custom fetch implementation (for Cloudflare Workers) */\n  fetch?: typeof fetch\n\n  /** Custom WebSocket implementation */\n  WebSocket?: typeof WebSocket\n\n  /** Enable debug logging */\n  debug?: boolean\n\n  /** Transform column names (e.g., snake_case to camelCase) */\n  transform?: {\n    column?: (name: string) => string\n    value?: (value: unknown, column: string) => unknown\n  }\n\n  /**\n   * Default transaction retry configuration.\n   * These settings are used as defaults for all transactions initiated with begin().\n   * Transaction-level options can override these defaults.\n   */\n  transactionRetry?: {\n    /** Automatically retry on serialization failure (error code 40001) */\n    retryOnSerializationFailure?: boolean\n    /** Automatically retry on deadlock (error code 40P01) */\n    retryOnDeadlock?: boolean\n    /** Maximum retry attempts (default: 3) */\n    maxRetries?: number\n    /** Base delay in milliseconds for exponential backoff (default: 10) */\n    backoffMs?: number\n  }\n}\n\n/** Pending query that can be executed */\nexport interface PendingQuery<T extends Row = Row> extends Promise<T[]> {\n  /** Execute the query and return rows */\n  execute(): Promise<T[]>\n\n  /** Get the parameterized SQL string */\n  toString(): string\n\n  /** Get query values/parameters */\n  values: unknown[]\n\n  /** Get the SQL template string */\n  strings: TemplateStringsArray\n}\n\n/** Transaction isolation levels */\nexport type IsolationLevel =\n  | 'read uncommitted'\n  | 'read committed'\n  | 'repeatable read'\n  | 'serializable'\n\n/** Lock mode types */\nexport type LockMode =\n  | 'access share'\n  | 'row share'\n  | 'row exclusive'\n  | 'share update exclusive'\n  | 'share'\n  | 'share row exclusive'\n  | 'exclusive'\n  | 'access exclusive'\n\n/** Transaction options */\nexport interface TransactionOptions {\n  /** Isolation level */\n  isolationLevel?: IsolationLevel\n  /** Read only transaction */\n  readOnly?: boolean\n  /** Deferrable (only with serializable + read only) */\n  deferrable?: boolean\n  /** Named transaction (for debugging/logging) */\n  name?: string\n  /**\n   * Transaction timeout in milliseconds.\n   * This is the total timeout across all retry attempts.\n   * When retries are enabled, the timeout counts from the start of the first attempt.\n   */\n  timeout?: number\n  /**\n   * Per-retry timeout in milliseconds.\n   * When set, each retry attempt gets a fresh timeout of this duration.\n   * This is useful when you want to allow each attempt to take up to N ms,\n   * but the total time can exceed that due to retries.\n   * If both `timeout` and `perRetryTimeout` are set, `timeout` takes precedence\n   * (the total timeout will be enforced).\n   */\n  perRetryTimeout?: number\n  /** Lock mode for explicit table locking */\n  lockMode?: LockMode\n  /** Automatically retry on serialization failure (error code 40001) */\n  retryOnSerializationFailure?: boolean\n  /** Automatically retry on deadlock (error code 40P01) */\n  retryOnDeadlock?: boolean\n  /** Maximum retry attempts (default: 3) */\n  maxRetries?: number\n  /** Base delay in milliseconds for exponential backoff (default: 10) */\n  backoffMs?: number\n  /** Callback called before each retry attempt */\n  onRetry?: (attempt: number, error: Error) => void | Promise<void>\n}\n\n/**\n * Options for streaming queries\n */\nexport interface StreamOptions {\n  /** Batch size for fetching rows (default: 100) */\n  batchSize?: number\n  /** Custom cursor name (auto-generated if not provided) */\n  cursorName?: string\n  /** Transaction isolation level for the cursor */\n  isolationLevel?: IsolationLevel\n  /** Whether the cursor should be read-only (default: true) */\n  readOnly?: boolean\n}\n\n/**\n * Result of a cursor fetch operation\n */\nexport interface CursorFetchResult<T extends Row = Row> {\n  /** Rows fetched in this batch */\n  rows: T[]\n  /** Whether there are more rows to fetch */\n  hasMore: boolean\n  /** Total number of rows fetched so far */\n  totalFetched: number\n}\n\n/**\n * Cursor interface for manual control over streaming\n */\nexport interface Cursor<T extends Row = Row> extends AsyncIterable<T> {\n  /** Whether the cursor is still open */\n  readonly isOpen: boolean\n  /** Total number of rows fetched so far */\n  readonly totalFetched: number\n  /** Column metadata from the query */\n  readonly fields: FieldInfo[]\n\n  /**\n   * Fetch the next batch of rows\n   * @param count - Number of rows to fetch (default: batch size)\n   * @returns Array of rows (empty array if no more rows)\n   */\n  fetch(count?: number): Promise<T[]>\n\n  /**\n   * Fetch the next batch of rows with additional metadata\n   * @param count - Number of rows to fetch (default: batch size)\n   * @returns Result object with rows, hasMore flag, and total fetched count\n   */\n  fetchWithInfo(count?: number): Promise<CursorFetchResult<T>>\n\n  /**\n   * Close the cursor and release resources\n   * Always call this when done, or use for-await-of which closes automatically\n   */\n  close(): Promise<void>\n}\n\n/**\n * Stream result interface for fluent streaming API\n */\nexport interface StreamResult<T extends Row = Row> extends AsyncIterable<T> {\n  /** The SQL query being streamed */\n  readonly sql: string\n  /** The query parameters */\n  readonly params: unknown[]\n\n  /**\n   * Stream rows in batches\n   * @param size - Number of rows per batch\n   * @returns AsyncIterable of row arrays\n   * @example\n   * for await (const batch of sql.stream`SELECT * FROM users`.batch(1000)) {\n   *   processBatch(batch)\n   * }\n   */\n  batch(size: number): AsyncIterable<T[]>\n\n  /**\n   * Get a cursor for manual control\n   * @returns A cursor that can be used to fetch rows manually\n   * @example\n   * const cursor = await sql.stream`SELECT * FROM users`.cursor()\n   * while (const rows = await cursor.fetch(100)) {\n   *   process(rows)\n   * }\n   * await cursor.close()\n   */\n  cursor(): Promise<Cursor<T>>\n}\n\n/**\n * Query middleware function signature (forward declaration for types)\n * Full implementation is in middleware.ts\n */\nexport type QueryMiddlewareFn<T extends Row = Row> = (\n  request: { sql: string; params: unknown[]; timestamp: number; queryId: string; context?: Record<string, unknown> },\n  next: () => Promise<{ result: QueryResult<T>; durationMs: number; success: boolean; error?: Error; metadata?: Record<string, unknown> }>\n) => Promise<{ result: QueryResult<T>; durationMs: number; success: boolean; error?: Error; metadata?: Record<string, unknown> }>\n\n/**\n * Main SQL client interface\n * Compatible with Drizzle ORM integration\n */\nexport interface Sql {\n  /**\n   * Execute a SQL query using tagged template literal\n   * @example\n   * const users = await sql`SELECT * FROM users WHERE id = ${userId}`\n   */\n  <T extends Row = Row>(\n    strings: TemplateStringsArray,\n    ...values: unknown[]\n  ): PendingQuery<T>\n\n  /**\n   * Execute raw SQL (use with caution - no parameterization)\n   * This is used by Drizzle ORM for generated queries\n   * @param query - Raw SQL query string\n   * @param params - Optional query parameters\n   */\n  unsafe<T extends Row = Row>(\n    query: string,\n    params?: unknown[]\n  ): Promise<T[]>\n\n  /**\n   * Begin a transaction\n   * Compatible with Drizzle ORM transaction interface\n   * @param fn - Transaction callback function\n   * @param options - Transaction options\n   */\n  begin<T>(\n    fn: (sql: TransactionSql) => Promise<T>,\n    options?: TransactionOptions\n  ): Promise<T>\n\n  /**\n   * Create a savepoint within a transaction\n   * For nested transaction support\n   * @param fn - Savepoint callback function\n   */\n  savepoint<T>(\n    fn: (sql: TransactionSql) => Promise<T>\n  ): Promise<T>\n\n  /**\n   * End the connection/session\n   */\n  end(): Promise<void>\n\n  /**\n   * Stream large result sets using PostgreSQL cursors\n   * Keeps memory usage constant regardless of result size\n   * @example\n   * // Stream rows one at a time\n   * for await (const row of sql.stream`SELECT * FROM huge_table`) {\n   *   process(row)\n   * }\n   *\n   * // Stream in batches\n   * for await (const batch of sql.stream`SELECT * FROM huge_table`.batch(1000)) {\n   *   processBatch(batch)\n   * }\n   *\n   * // Manual cursor control\n   * const cursor = await sql.stream`SELECT * FROM huge_table`.cursor()\n   * while (const rows = await cursor.fetch(100)) {\n   *   process(rows)\n   * }\n   * await cursor.close()\n   */\n  stream<T extends Row = Row>(\n    strings: TemplateStringsArray,\n    ...values: unknown[]\n  ): StreamResult<T>\n\n  /**\n   * Add a query middleware to the chain\n   * Middlewares are executed in the order they are added\n   * @param middleware - The middleware function to add\n   * @returns The same Sql instance for chaining\n   * @example\n   * const sql = postgres()\n   *   .use(loggingMiddleware({ level: 'info' }))\n   *   .use(metricsMiddleware({ onMetric: console.log }))\n   */\n  use(middleware: QueryMiddlewareFn): this\n\n  /**\n   * Client configuration options\n   * Includes type parsers and serializers for Drizzle compatibility\n   */\n  options: {\n    parsers: Record<number, TypeParser>\n    serializers: Record<number, (value: unknown) => string>\n    [key: string]: unknown\n  }\n\n  /**\n   * Reserve a connection from the pool\n   * Returns a client with exclusive connection\n   */\n  reserve(): Promise<ReservedSql>\n\n  /**\n   * Commit a prepared transaction (two-phase commit)\n   * @param transactionId - The ID returned from prepare()\n   */\n  commitPrepared(transactionId: string): Promise<void>\n\n  /**\n   * Rollback a prepared transaction (two-phase commit)\n   * @param transactionId - The ID returned from prepare()\n   */\n  rollbackPrepared(transactionId: string): Promise<void>\n\n  /**\n   * Subscribe to changes on a table\n   * @param table - Table name (optionally with schema: \"schema.table\")\n   * @param options - Subscription options\n   * @returns A subscription that can be iterated over or used with callbacks\n   * @example\n   * // Using async iteration\n   * const sub = await sql.subscribe('users')\n   * for await (const event of sub) {\n   *   console.log(event.operation, event.newRow)\n   * }\n   *\n   * // Using callbacks\n   * const sub = await sql.subscribe('users', {\n   *   onInsert: (row) => console.log('New user:', row),\n   *   onUpdate: (newRow, oldRow) => console.log('Updated:', newRow),\n   *   onDelete: (oldRow) => console.log('Deleted:', oldRow)\n   * })\n   */\n  subscribe<T extends Row = Row>(\n    table: string,\n    options?: CDCClientSubscribeOptions<T>\n  ): Promise<CDCClientSubscription<T>>\n\n  /**\n   * Unsubscribe from a subscription by ID\n   * @param subscriptionId - The subscription ID to unsubscribe from\n   */\n  unsubscribe(subscriptionId: string): Promise<void>\n\n  /**\n   * Get all active subscriptions\n   * @returns Array of active subscriptions\n   */\n  subscriptions(): CDCClientSubscriptionInfo[]\n}\n\n/** Transaction-specific SQL interface */\nexport interface TransactionSql extends Omit<Sql, 'begin' | 'end' | 'reserve' | 'commitPrepared' | 'rollbackPrepared'> {\n  /**\n   * Create a savepoint within the transaction\n   */\n  savepoint<T>(\n    fn: (sql: TransactionSql) => Promise<T>\n  ): Promise<T>\n\n  /**\n   * Acquire an exclusive advisory lock that is released when the transaction ends (blocking).\n   * @param lockId - Lock identifier (number or bigint for single-key)\n   * @example await tx.advisoryLock(12345)\n   */\n  advisoryLock(lockId: number | bigint): Promise<void>\n  /**\n   * Acquire an exclusive advisory lock with namespace (blocking).\n   * @param classId - Lock class/namespace identifier (int4)\n   * @param objId - Object identifier within the namespace (int4)\n   * @example await tx.advisoryLock(1, 42) // namespace 1, object 42\n   */\n  advisoryLock(classId: number, objId: number): Promise<void>\n\n  /**\n   * Try to acquire an exclusive advisory lock without blocking.\n   * @param lockId - Lock identifier (number or bigint for single-key)\n   * @returns true if lock was acquired, false otherwise\n   * @example const acquired = await tx.tryAdvisoryLock(12345)\n   */\n  tryAdvisoryLock(lockId: number | bigint): Promise<boolean>\n  /**\n   * Try to acquire an exclusive advisory lock with namespace without blocking.\n   * @param classId - Lock class/namespace identifier (int4)\n   * @param objId - Object identifier within the namespace (int4)\n   * @returns true if lock was acquired, false otherwise\n   * @example const acquired = await tx.tryAdvisoryLock(1, 42)\n   */\n  tryAdvisoryLock(classId: number, objId: number): Promise<boolean>\n\n  /**\n   * Acquire a shared advisory lock that is released when the transaction ends (blocking).\n   * Multiple sessions can hold a shared lock simultaneously; blocks only if exclusive lock is held.\n   * @param lockId - Lock identifier (number or bigint for single-key)\n   * @example await tx.advisoryLockShared(12345)\n   */\n  advisoryLockShared(lockId: number | bigint): Promise<void>\n  /**\n   * Acquire a shared advisory lock with namespace (blocking).\n   * @param classId - Lock class/namespace identifier (int4)\n   * @param objId - Object identifier within the namespace (int4)\n   * @example await tx.advisoryLockShared(1, 42)\n   */\n  advisoryLockShared(classId: number, objId: number): Promise<void>\n\n  /**\n   * Try to acquire a shared advisory lock without blocking.\n   * @param lockId - Lock identifier (number or bigint for single-key)\n   * @returns true if lock was acquired, false if exclusive lock is held\n   * @example const acquired = await tx.tryAdvisoryLockShared(12345)\n   */\n  tryAdvisoryLockShared(lockId: number | bigint): Promise<boolean>\n  /**\n   * Try to acquire a shared advisory lock with namespace without blocking.\n   * @param classId - Lock class/namespace identifier (int4)\n   * @param objId - Object identifier within the namespace (int4)\n   * @returns true if lock was acquired, false if exclusive lock is held\n   * @example const acquired = await tx.tryAdvisoryLockShared(1, 42)\n   */\n  tryAdvisoryLockShared(classId: number, objId: number): Promise<boolean>\n\n  /**\n   * Prepare transaction for two-phase commit\n   * After calling this, the transaction must be committed with commitPrepared()\n   * @param transactionId - Unique identifier for the prepared transaction\n   * @returns The transaction ID\n   */\n  prepare(transactionId: string): Promise<string>\n\n  /**\n   * Register a callback to run after transaction commits\n   * @param fn - Callback function\n   */\n  onCommit(fn: () => void | Promise<void>): void\n\n  /**\n   * Register a callback to run after transaction rolls back\n   * @param fn - Callback function\n   */\n  onRollback(fn: () => void | Promise<void>): void\n\n  /**\n   * Current transaction ID (xid)\n   * Lazily fetched from the database\n   */\n  readonly txid: string | undefined\n\n  /**\n   * Transaction name (if provided in options)\n   */\n  readonly name: string | undefined\n\n  /**\n   * Current retry attempt number (0 for first attempt, 1 for first retry, etc.)\n   * Only set when retryOnSerializationFailure or retryOnDeadlock is enabled.\n   */\n  readonly retryCount: number\n}\n\n/** Reserved connection SQL interface */\nexport interface ReservedSql extends Sql {\n  /**\n   * Release the reserved connection back to the pool\n   */\n  release(): Promise<void>\n}\n\n/** Transport interface for sending queries */\nexport interface Transport {\n  /** Send a query and receive results */\n  query<T extends Row = Row>(\n    sql: string,\n    params?: unknown[]\n  ): Promise<QueryResult<T>>\n\n  /** Execute multiple queries in a transaction */\n  transaction<T>(\n    queries: Array<{ sql: string; params?: unknown[] }>,\n    options?: TransactionOptions\n  ): Promise<T>\n\n  /** Close the transport connection */\n  close(): Promise<void>\n\n  /** Check if transport is connected */\n  isConnected(): boolean\n}\n\n/** HTTP transport configuration */\nexport interface HttpTransportConfig {\n  /** Base URL for the postgres.do API */\n  baseUrl: string\n  /** API key for authentication */\n  apiKey?: string | undefined\n  /** Custom fetch implementation */\n  fetch?: typeof fetch | undefined\n  /** Request timeout in milliseconds */\n  timeout?: number | undefined\n  /** Custom headers */\n  headers?: Record<string, string> | undefined\n}\n\n/** WebSocket transport configuration */\nexport interface WsTransportConfig {\n  /** WebSocket URL for postgres.do */\n  url: string\n  /** API key for authentication */\n  apiKey?: string | undefined\n  /** Custom WebSocket implementation */\n  WebSocket?: typeof WebSocket | undefined\n  /** Connection timeout in milliseconds */\n  connectTimeout?: number | undefined\n  /** Ping interval in milliseconds */\n  pingInterval?: number | undefined\n}\n\n// =============================================================================\n// CDC (Change Data Capture) Types\n// =============================================================================\n\n/**\n * CDC operation types for PostgreSQL change notifications\n */\nexport type CDCOperation = 'INSERT' | 'UPDATE' | 'DELETE' | 'TRUNCATE'\n\n/**\n * CDC change event representing a single database change\n */\nexport interface CDCChangeEvent {\n  /** Unique event ID (typically LSN-based) */\n  id: string\n  /** PostgreSQL Log Sequence Number for this change */\n  lsn: string\n  /** Type of operation that caused this change */\n  operation: CDCOperation\n  /** Table name where the change occurred */\n  table: string\n  /** Schema name */\n  schema: string\n  /** Timestamp when the change occurred */\n  timestamp: Date\n  /** New row data (for INSERT and UPDATE) */\n  newRow?: Row | undefined\n  /** Old row data (for UPDATE and DELETE) */\n  oldRow?: Row | undefined\n  /** Columns that were changed (for UPDATE) */\n  changedColumns?: string[] | undefined\n  /** Transaction ID */\n  xid: number\n  /** Whether this is the last change in the transaction */\n  isLastInTransaction: boolean\n}\n\n/**\n * Options for CDC subscriptions\n */\nexport interface CDCSubscriptionOptions {\n  /** Event types to subscribe to (default: all) */\n  events?: CDCOperation[] | undefined\n  /** SQL filter expression for row-level filtering */\n  filter?: string | undefined\n  /** Resume from this LSN (for exactly-once delivery) */\n  resumeFrom?: string | undefined\n  /** Include old row data for UPDATE/DELETE events */\n  includeOldRow?: boolean | undefined\n  /** Track which columns changed for UPDATE events */\n  trackChangedColumns?: boolean | undefined\n  /** Batch size for event delivery */\n  batchSize?: number | undefined\n  /** Heartbeat interval in milliseconds */\n  heartbeatInterval?: number | undefined\n}\n\n/**\n * CDC Transport interface for streaming database changes\n */\nexport interface CDCTransport {\n  /** Connect to the CDC stream */\n  connect(): Promise<void>\n  /** Disconnect from the CDC stream */\n  disconnect(): Promise<void>\n  /** Check if connected */\n  isConnected(): boolean\n  /** Get the last event ID received */\n  getLastEventId(): string | null\n  /** Subscribe to a table */\n  subscribe(\n    subscriptionId: string,\n    table: string,\n    schema: string,\n    options: CDCSubscriptionOptions\n  ): Promise<void>\n  /** Unsubscribe from a subscription */\n  unsubscribe(subscriptionId: string): Promise<void>\n  /** Set the event handler */\n  onEvent(handler: (subscriptionId: string, event: CDCChangeEvent) => void): void\n  /** Set the error handler */\n  onError(handler: (subscriptionId: string, error: Error) => void): void\n  /** Set the reconnect handler */\n  onReconnect(handler: (attempt: number, lastLsn: string | undefined) => void): void\n  /** Set the close handler */\n  onClose(handler: () => void): void\n}\n\n/**\n * CDC WebSocket transport configuration\n */\nexport interface CDCWsTransportConfig {\n  /** WebSocket URL for the CDC endpoint */\n  url: string\n  /** API key for authentication */\n  apiKey?: string | undefined\n  /** Custom WebSocket implementation */\n  WebSocket?: typeof WebSocket | undefined\n  /** Connection timeout in milliseconds */\n  connectTimeout?: number | undefined\n  /** Ping interval for keepalive in milliseconds */\n  pingInterval?: number | undefined\n}\n\n/**\n * CDC SSE (Server-Sent Events) transport configuration\n */\nexport interface CDCSseTransportConfig {\n  /** URL for the CDC SSE endpoint */\n  url: string\n  /** API key for authentication */\n  apiKey?: string\n  /** Resume from this event ID (Last-Event-ID) */\n  resumeFrom?: string\n  /** Reconnection delay in milliseconds */\n  retryMs?: number\n  /** Custom fetch implementation */\n  fetch?: typeof fetch\n  /** Custom headers */\n  headers?: Record<string, string>\n}\n\n/** PostgreSQL error fields specific to postgres.do */\nexport interface PostgresErrorFields {\n  /** PostgreSQL error code (e.g., '23505' for unique violation) */\n  code?: string | undefined\n  /** Error severity */\n  severity?: string | undefined\n  /** Detailed error message */\n  detail?: string | undefined\n  /** Hint for fixing the error */\n  hint?: string | undefined\n  /** Position in query where error occurred */\n  position?: number | undefined\n  /** Schema name if relevant */\n  schema?: string | undefined\n  /** Table name if relevant */\n  table?: string | undefined\n  /** Column name if relevant */\n  column?: string | undefined\n  /** Constraint name if relevant */\n  constraint?: string | undefined\n}\n\n/**\n * Error thrown by postgres.do client.\n * Extends the shared PostgresError with postgres.do-specific properties.\n */\nexport class PostgresError extends SharedPostgresError {\n  /** Error severity */\n  readonly severity: string\n  /** Detailed error message */\n  readonly detail: string | undefined\n  /** Hint for fixing the error */\n  readonly hint: string | undefined\n  /** Position in query where error occurred */\n  readonly position: number | undefined\n  /** PostgreSQL error code (e.g., '23505' for unique violation) */\n  readonly pgCode: string\n\n  constructor(message: string, fields: PostgresErrorFields = {}) {\n    // Build context object only with defined values to satisfy exactOptionalPropertyTypes\n    const context: ErrorContext = { pgCode: fields.code ?? 'UNKNOWN' }\n    if (fields.schema !== undefined) context.schema = fields.schema\n    if (fields.table !== undefined) context.table = fields.table\n    if (fields.column !== undefined) context.column = fields.column\n    if (fields.constraint !== undefined) context.constraint = fields.constraint\n\n    super(message, {\n      code: 'QUERY_ERROR',\n      context,\n    })\n    // Override name property\n    Object.defineProperty(this, 'name', { value: 'PostgresError', writable: true, configurable: true })\n    // Override code property to return the PostgreSQL error code instead of internal code\n    Object.defineProperty(this, 'code', { value: fields.code ?? 'UNKNOWN', writable: false, configurable: true })\n\n    this.severity = fields.severity ?? 'ERROR'\n    this.detail = fields.detail\n    this.hint = fields.hint\n    this.position = fields.position\n    this.pgCode = fields.code ?? 'UNKNOWN'\n  }\n\n  /** Schema name if relevant */\n  get schema(): string | undefined {\n    return this.context.schema\n  }\n\n  /** Table name if relevant */\n  get table(): string | undefined {\n    return this.context.table\n  }\n\n  /** Column name if relevant */\n  get column(): string | undefined {\n    return this.context.column\n  }\n\n  /** Constraint name if relevant */\n  get constraint(): string | undefined {\n    return this.context.constraint\n  }\n}\n\n/**\n * Connection error.\n * Extends the shared ConnectionError.\n */\nexport class ConnectionError extends SharedConnectionError {\n  constructor(message: string) {\n    super(message)\n    // Override name property\n    Object.defineProperty(this, 'name', { value: 'ConnectionError', writable: true, configurable: true })\n  }\n}\n\n/**\n * Query timeout error.\n * Extends the shared ConnectionTimeoutError.\n */\nexport class TimeoutError extends SharedConnectionTimeoutError {\n  constructor(message: string = 'Query timed out') {\n    // Extract timeout from message if possible, default to 0\n    const timeoutMatch = message.match(/(\\d+)\\s*ms/)\n    const matchedMs = timeoutMatch?.[1]\n    const timeoutMs = matchedMs ? parseInt(matchedMs, 10) : 0\n    super(timeoutMs)\n    // Override name property\n    Object.defineProperty(this, 'name', { value: 'TimeoutError', writable: true, configurable: true })\n    // Override the message if a custom one was provided\n    if (message !== 'Query timed out' && message !== `Connection timed out after ${timeoutMs}ms`) {\n      Object.defineProperty(this, 'message', { value: message, writable: true, configurable: true })\n    }\n  }\n}\n\n// =============================================================================\n// CDC Client Types (High-Level API)\n// =============================================================================\n\n/**\n * Options for CDC client subscription\n */\nexport interface CDCClientSubscribeOptions<T extends Row = Row> extends CDCSubscriptionOptions {\n  /** Called for every change event */\n  onChange?: (event: CDCChangeEvent & { newRow?: T; oldRow?: T }) => void | Promise<void>\n  /** Called for INSERT events */\n  onInsert?: (row: T) => void | Promise<void>\n  /** Called for UPDATE events */\n  onUpdate?: (newRow: T, oldRow?: T) => void | Promise<void>\n  /** Called for DELETE events */\n  onDelete?: (oldRow: T) => void | Promise<void>\n  /** Called when an error occurs */\n  onError?: (error: Error) => void\n}\n\n/**\n * Client subscription interface for CDC streaming\n */\nexport interface CDCClientSubscription<T extends Row = Row> extends AsyncIterable<CDCChangeEvent & { newRow?: T; oldRow?: T }> {\n  /** Unique subscription ID */\n  readonly id: string\n  /** Table name */\n  readonly table: string\n  /** Schema name */\n  readonly schema: string\n  /** Whether the subscription is currently active */\n  readonly isActive: boolean\n  /** Last processed LSN for resumption */\n  readonly lastLsn: string | null\n\n  /** Unsubscribe and stop receiving events */\n  unsubscribe(): Promise<void>\n\n  /** Register a handler for all change events */\n  onChange(handler: (event: CDCChangeEvent & { newRow?: T; oldRow?: T }) => void | Promise<void>): this\n\n  /** Register a handler for INSERT events */\n  onInsert(handler: (row: T) => void | Promise<void>): this\n\n  /** Register a handler for UPDATE events */\n  onUpdate(handler: (newRow: T, oldRow?: T) => void | Promise<void>): this\n\n  /** Register a handler for DELETE events */\n  onDelete(handler: (oldRow: T) => void | Promise<void>): this\n}\n\n/**\n * Information about an active subscription\n */\nexport interface CDCClientSubscriptionInfo {\n  /** Unique subscription ID */\n  id: string\n  /** Table name */\n  table: string\n  /** Schema name */\n  schema: string\n  /** Whether the subscription is currently active */\n  isActive: boolean\n}\n","/**\n * RpcPromise - A promise wrapper that supports capnweb magic map and pipelining\n *\n * This class enables:\n * - Magic map support for N+1 query elimination\n * - Promise pipelining for batched operations\n * - Lazy execution (queries don't execute until awaited or .map()'d)\n *\n * @example Magic Map\n * ```typescript\n * const usersWithOrders = await db.query('SELECT * FROM users')\n *   .map(users => Promise.all(\n *     users.map(u => db.query('SELECT * FROM orders WHERE user_id = $1', [u.id]))\n *   ))\n * ```\n *\n * @example Promise Pipelining\n * ```typescript\n * const user = db.query('SELECT * FROM users WHERE id = $1', [id])\n * const posts = user.map(u => db.query('SELECT * FROM posts WHERE author = $1', [u.id]))\n * const comments = posts.map(p => db.query('SELECT * FROM comments WHERE post_id = ANY($1)', [p.map(x => x.id)]))\n * const result = await comments // Single round trip!\n * ```\n */\n\nimport type { Row } from '../types'\n\n/**\n * Execution context for RPC pipelining\n * Accumulates queries that can be batched together\n */\nexport interface RpcExecutionContext {\n  /** Add a query to the batch */\n  addQuery(sql: string, params?: unknown[]): number\n  /** Execute all batched queries */\n  executeBatch(): Promise<BatchResult[]>\n  /** Get a pending result by query ID */\n  getResult(queryId: number): Promise<unknown>\n  /** Check if the context is currently collecting queries */\n  isCollecting(): boolean\n  /** Start collecting queries for batching */\n  startCollecting(): void\n  /** Stop collecting and execute batch */\n  stopCollecting(): Promise<void>\n}\n\n/**\n * Result from a batched query\n */\nexport interface BatchResult<T = unknown> {\n  queryId: number\n  rows: T[]\n  fields: Array<{ name: string; dataTypeID: number }>\n  rowCount: number\n  durationMs: number\n}\n\n/**\n * Map function signature for RpcPromise\n */\nexport type MapFn<T, U> = (value: T) => U | Promise<U>\n\n/**\n * RpcPromise implementation\n * Wraps a query operation with magic map and pipelining support\n */\nexport class RpcPromise<T> implements PromiseLike<T> {\n  private executor: () => Promise<T>\n  private cachedResult: T | undefined\n  private executed = false\n  private executing: Promise<T> | null = null\n  private context: RpcExecutionContext | null\n\n  constructor(executor: () => Promise<T>, context?: RpcExecutionContext | null) {\n    this.executor = executor\n    this.context = context ?? null\n  }\n\n  /**\n   * Map over the result with magic map support\n   *\n   * The map function receives the resolved value and can return:\n   * - A plain value\n   * - A Promise\n   * - Another RpcPromise (for pipelining)\n   *\n   * When the callback returns RpcPromises, they are batched together\n   * with the original query for efficient execution.\n   *\n   * @example\n   * ```typescript\n   * const usersWithPosts = db.query('SELECT * FROM users')\n   *   .map(users => Promise.all(\n   *     users.map(u => db.query('SELECT * FROM posts WHERE user_id = $1', [u.id]))\n   *   ))\n   * ```\n   */\n  map<U>(fn: MapFn<T, U>): RpcPromise<U> {\n    return new RpcPromise<U>(async () => {\n      // If we have a context and it's collecting, use batched execution\n      if (this.context?.isCollecting()) {\n        const result = await this.execute()\n        const mapped = fn(result)\n\n        // If the mapped result is also collecting queries, batch them together\n        if (mapped instanceof RpcPromise) {\n          return mapped.execute()\n        }\n\n        return mapped\n      }\n\n      // Standard execution path\n      const result = await this.execute()\n      const mapped = fn(result)\n\n      if (mapped instanceof Promise || mapped instanceof RpcPromise) {\n        return mapped as Promise<U>\n      }\n\n      return mapped\n    }, this.context)\n  }\n\n  /**\n   * FlatMap for when the map function returns an RpcPromise\n   */\n  flatMap<U>(fn: (value: T) => RpcPromise<U>): RpcPromise<U> {\n    return new RpcPromise<U>(async () => {\n      const result = await this.execute()\n      const mapped = fn(result)\n      return mapped.execute()\n    }, this.context)\n  }\n\n  /**\n   * Execute the query and return the result\n   */\n  async execute(): Promise<T> {\n    // Return cached result if already executed\n    if (this.executed && this.cachedResult !== undefined) {\n      return this.cachedResult\n    }\n\n    // If already executing, wait for that execution\n    if (this.executing) {\n      return this.executing\n    }\n\n    // Start execution\n    this.executing = this.executor()\n\n    try {\n      this.cachedResult = await this.executing\n      this.executed = true\n      return this.cachedResult\n    } finally {\n      this.executing = null\n    }\n  }\n\n  /**\n   * Reset the execution state to allow re-execution\n   */\n  reset(): void {\n    this.executed = false\n    this.cachedResult = undefined\n    this.executing = null\n  }\n\n  /**\n   * Check if the promise has been executed\n   */\n  isExecuted(): boolean {\n    return this.executed\n  }\n\n  /**\n   * PromiseLike implementation - makes this thenable\n   */\n  then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null\n  ): Promise<TResult1 | TResult2> {\n    return this.execute().then(onfulfilled, onrejected)\n  }\n\n  /**\n   * Catch handler\n   */\n  catch<TResult = never>(\n    onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null\n  ): Promise<T | TResult> {\n    return this.execute().catch(onrejected)\n  }\n\n  /**\n   * Finally handler\n   */\n  finally(onfinally?: (() => void) | null): Promise<T> {\n    return this.execute().finally(onfinally)\n  }\n}\n\n/**\n * Create an RpcPromise from a query function\n */\nexport function createRpcPromise<T>(\n  executor: () => Promise<T>,\n  context?: RpcExecutionContext | null\n): RpcPromise<T> {\n  return new RpcPromise(executor, context)\n}\n\n/**\n * Query result type for typed queries\n */\nexport interface RpcQueryResult<T extends Row = Row> {\n  rows: T[]\n  fields: Array<{ name: string; dataTypeID: number }>\n  rowCount: number\n  durationMs: number\n}\n\n/**\n * Create an RpcPromise that extracts rows from a query result\n */\nexport function createRowsPromise<T extends Row = Row>(\n  executor: () => Promise<RpcQueryResult<T>>,\n  context?: RpcExecutionContext | null\n): RpcPromise<T[]> {\n  return new RpcPromise(async () => {\n    const result = await executor()\n    return result.rows\n  }, context)\n}\n\n/**\n * Batch multiple RpcPromises for efficient execution\n *\n * This collects all queries from the provided promises and executes\n * them in a single batch, then distributes the results.\n *\n * @example\n * ```typescript\n * const [users, orders, products] = await batchExecute([\n *   db.query('SELECT * FROM users'),\n *   db.query('SELECT * FROM orders'),\n *   db.query('SELECT * FROM products'),\n * ])\n * ```\n */\nexport async function batchExecute<T extends readonly RpcPromise<unknown>[]>(\n  promises: T\n): Promise<{ [K in keyof T]: T[K] extends RpcPromise<infer U> ? U : never }> {\n  // Execute all promises in parallel\n  const results = await Promise.all(promises.map(p => p.execute()))\n  return results as { [K in keyof T]: T[K] extends RpcPromise<infer U> ? U : never }\n}\n\n/**\n * Create a magic map wrapper that batches nested queries\n *\n * This enables the N+1 query elimination pattern:\n * ```typescript\n * const usersWithOrders = await magicMap(\n *   db.query('SELECT * FROM users'),\n *   users => users.map(u => db.query('SELECT * FROM orders WHERE user_id = $1', [u.id]))\n * )\n * ```\n */\nexport async function magicMap<T, U>(\n  source: RpcPromise<T[]>,\n  mapFn: (items: T[]) => RpcPromise<U>[]\n): Promise<U[]> {\n  const items = await source.execute()\n  const promises = mapFn(items)\n  return Promise.all(promises.map(p => p.execute()))\n}\n","/**\n * RPC Transport for postgres.do\n *\n * Connects to PostgresDO via capnweb RPC for:\n * - Direct Worker-to-DO communication without HTTP overhead\n * - Promise pipelining for efficient batched operations\n * - Magic map support for N+1 query elimination\n *\n * @see packages/postgres/src/worker/rpc.ts for the server-side RPC API\n * @see packages/postgres/src/worker/proxy.ts for the proxy session pool\n */\n\nimport type {\n  Transport,\n  QueryResult,\n  Row,\n  TransactionOptions,\n  FieldInfo,\n} from '../types'\nimport { PostgresError, ConnectionError, TimeoutError } from '../types'\nimport { RpcPromise, createRpcPromise, type RpcExecutionContext, type BatchResult } from '../rpc/rpc-promise'\n\n/**\n * RPC Transport configuration\n */\nexport interface RpcTransportConfig {\n  /** WebSocket URL for the capnweb RPC endpoint */\n  url: string\n  /** API key for authentication */\n  apiKey?: string | undefined\n  /** Custom WebSocket implementation */\n  WebSocket?: typeof WebSocket | undefined\n  /** Connection timeout in milliseconds */\n  connectTimeout?: number | undefined\n  /** Request timeout in milliseconds */\n  requestTimeout?: number | undefined\n  /** Enable automatic batching */\n  autoBatch?: boolean | undefined\n  /** Batch delay in milliseconds (how long to wait for more queries) */\n  batchDelayMs?: number | undefined\n}\n\n/** Default configuration values */\nconst DEFAULTS = {\n  url: 'wss://db.postgres.do/rpc',\n  connectTimeout: 10000,\n  requestTimeout: 30000,\n  autoBatch: true,\n  batchDelayMs: 0, // No delay by default - use microtask batching\n}\n\n/** RPC message types */\nenum RpcMessageType {\n  // Requests\n  Query = 'query',\n  Batch = 'batch',\n  BatchTransaction = 'batch_tx',\n  Transaction = 'transaction',\n  TransactionQuery = 'tx_query',\n  TransactionCommit = 'tx_commit',\n  TransactionRollback = 'tx_rollback',\n  Ping = 'ping',\n  Auth = 'auth',\n\n  // Responses\n  QueryResult = 'query_result',\n  BatchResult = 'batch_result',\n  TransactionResult = 'tx_result',\n  Error = 'error',\n  Pong = 'pong',\n  AuthResult = 'auth_result',\n}\n\n/** Pending request waiting for a response */\ninterface PendingRequest<T = unknown> {\n  resolve: (value: T) => void\n  reject: (error: Error) => void\n  timeout: ReturnType<typeof setTimeout>\n}\n\n/** Pending batch of queries */\ninterface PendingBatch {\n  queries: Array<{ sql: string; params?: unknown[] }>\n  resolvers: Array<{\n    resolve: (value: BatchResult) => void\n    reject: (error: Error) => void\n  }>\n  timer: ReturnType<typeof setTimeout> | null\n}\n\n/** Resolved config with optional properties handled */\ninterface ResolvedConfig {\n  url: string\n  apiKey: string | undefined\n  WebSocket: typeof WebSocket | undefined\n  connectTimeout: number\n  requestTimeout: number\n  autoBatch: boolean\n  batchDelayMs: number\n}\n\n/**\n * RPC Transport implementation\n *\n * Provides capnweb-style RPC communication with PostgresDO:\n * - Automatic query batching for N+1 elimination\n * - Promise pipelining support\n * - WebSocket-based persistent connection\n */\nexport class RpcTransport implements Transport, RpcExecutionContext {\n  private readonly config: ResolvedConfig\n  private readonly WebSocketImpl: typeof WebSocket\n  private ws: WebSocket | null = null\n  private connected = false\n  private authenticated = false\n  private connecting: Promise<void> | null = null\n  private requestId = 0\n  private pendingRequests = new Map<number, PendingRequest>()\n  private pendingBatch: PendingBatch | null = null\n  private collecting = false\n\n  constructor(config: RpcTransportConfig) {\n    this.config = {\n      url: config.url ?? DEFAULTS.url,\n      apiKey: config.apiKey,\n      WebSocket: config.WebSocket,\n      connectTimeout: config.connectTimeout ?? DEFAULTS.connectTimeout,\n      requestTimeout: config.requestTimeout ?? DEFAULTS.requestTimeout,\n      autoBatch: config.autoBatch ?? DEFAULTS.autoBatch,\n      batchDelayMs: config.batchDelayMs ?? DEFAULTS.batchDelayMs,\n    }\n    this.WebSocketImpl = config.WebSocket || globalThis.WebSocket\n  }\n\n  // ========== RpcExecutionContext implementation ==========\n\n  /**\n   * Add a query to the current batch\n   */\n  addQuery(sql: string, params?: unknown[]): number {\n    if (!this.pendingBatch) {\n      this.pendingBatch = {\n        queries: [],\n        resolvers: [],\n        timer: null,\n      }\n\n      // Schedule batch execution on next microtask\n      if (this.config.batchDelayMs === 0) {\n        queueMicrotask(() => this.flushBatch())\n      } else {\n        this.pendingBatch.timer = setTimeout(\n          () => this.flushBatch(),\n          this.config.batchDelayMs\n        )\n      }\n    }\n\n    const queryId = this.pendingBatch.queries.length\n    this.pendingBatch.queries.push({ sql, params: params ?? [] })\n\n    return queryId\n  }\n\n  /**\n   * Execute all batched queries\n   */\n  async executeBatch(): Promise<BatchResult[]> {\n    if (!this.pendingBatch || this.pendingBatch.queries.length === 0) {\n      return []\n    }\n\n    await this.ensureConnected()\n\n    const batch = this.pendingBatch\n    this.pendingBatch = null\n\n    if (batch.timer) {\n      clearTimeout(batch.timer)\n    }\n\n    const id = this.nextRequestId()\n    const response = await this.sendRequest<RpcBatchResponse>(id, {\n      type: RpcMessageType.Batch,\n      id,\n      queries: batch.queries,\n    })\n\n    return response.results.map((r, i) => ({\n      queryId: i,\n      rows: r.rows,\n      fields: r.fields,\n      rowCount: r.rowCount,\n      durationMs: r.durationMs,\n    }))\n  }\n\n  /**\n   * Get a pending result by query ID\n   */\n  async getResult(_queryId: number): Promise<unknown> {\n    // Results are returned in order from executeBatch\n    // This method is for future optimization where results\n    // can be streamed as they complete\n    throw new Error('getResult is not yet implemented for streaming results')\n  }\n\n  /**\n   * Check if the context is currently collecting queries\n   */\n  isCollecting(): boolean {\n    return this.collecting\n  }\n\n  /**\n   * Start collecting queries for batching\n   */\n  startCollecting(): void {\n    this.collecting = true\n  }\n\n  /**\n   * Stop collecting and execute batch\n   */\n  async stopCollecting(): Promise<void> {\n    this.collecting = false\n    await this.flushBatch()\n  }\n\n  /**\n   * Flush the pending batch immediately\n   */\n  private async flushBatch(): Promise<void> {\n    if (!this.pendingBatch || this.pendingBatch.queries.length === 0) {\n      return\n    }\n\n    const batch = this.pendingBatch\n    this.pendingBatch = null\n\n    if (batch.timer) {\n      clearTimeout(batch.timer)\n    }\n\n    try {\n      await this.ensureConnected()\n\n      const id = this.nextRequestId()\n      const response = await this.sendRequest<RpcBatchResponse>(id, {\n        type: RpcMessageType.Batch,\n        id,\n        queries: batch.queries,\n      })\n\n      // Resolve all pending queries with their results\n      for (let i = 0; i < batch.resolvers.length; i++) {\n        const resolver = batch.resolvers[i]\n        const result = response.results[i]\n        if (resolver && result) {\n          resolver.resolve({\n            queryId: i,\n            rows: result.rows,\n            fields: result.fields,\n            rowCount: result.rowCount,\n            durationMs: result.durationMs,\n          })\n        } else if (resolver) {\n          resolver.reject(new Error(`No result for query ${i}`))\n        }\n      }\n    } catch (error) {\n      // Reject all pending queries with the error\n      for (const resolver of batch.resolvers) {\n        if (resolver) {\n          resolver.reject(error instanceof Error ? error : new Error(String(error)))\n        }\n      }\n    }\n  }\n\n  // ========== Transport interface implementation ==========\n\n  /**\n   * Execute a SQL query with RpcPromise support\n   */\n  queryRpc<T extends Row = Row>(\n    sql: string,\n    params?: unknown[]\n  ): RpcPromise<T[]> {\n    return createRpcPromise(async () => {\n      const result = await this.query<T>(sql, params)\n      return result.rows\n    }, this)\n  }\n\n  /**\n   * Execute a SQL query and return full result\n   */\n  async query<T extends Row = Row>(\n    sql: string,\n    params?: unknown[]\n  ): Promise<QueryResult<T>> {\n    // If autoBatch is enabled and we're in a batching context\n    if (this.config.autoBatch && this.collecting) {\n      return new Promise((resolve, reject) => {\n        const queryId = this.addQuery(sql, params)\n\n        if (!this.pendingBatch) {\n          reject(new Error('Batch was flushed before query could be added'))\n          return\n        }\n\n        this.pendingBatch.resolvers[queryId] = {\n          resolve: (result) => {\n            resolve({\n              rows: result.rows as T[],\n              fields: result.fields as FieldInfo[],\n              rowCount: result.rowCount,\n              command: 'SELECT',\n            })\n          },\n          reject,\n        }\n      })\n    }\n\n    await this.ensureConnected()\n\n    const id = this.nextRequestId()\n    const response = await this.sendRequest<RpcQueryResponse<T>>(id, {\n      type: RpcMessageType.Query,\n      id,\n      sql,\n      params: params || [],\n    })\n\n    return {\n      rows: response.rows || [],\n      fields: (response.fields || []) as FieldInfo[],\n      rowCount: response.rowCount ?? response.rows?.length ?? 0,\n      command: response.command || 'SELECT',\n    }\n  }\n\n  /**\n   * Execute a batch of queries\n   */\n  async batch<T extends Row = Row>(\n    queries: Array<{ sql: string; params?: unknown[] }>\n  ): Promise<Array<QueryResult<T>>> {\n    await this.ensureConnected()\n\n    const id = this.nextRequestId()\n    const response = await this.sendRequest<RpcBatchResponse>(id, {\n      type: RpcMessageType.Batch,\n      id,\n      queries,\n    })\n\n    return response.results.map(r => ({\n      rows: r.rows as T[],\n      fields: r.fields as FieldInfo[],\n      rowCount: r.rowCount,\n      command: 'SELECT',\n    }))\n  }\n\n  /**\n   * Execute a batch of queries within a transaction\n   */\n  async batchTransaction<T extends Row = Row>(\n    queries: Array<{ sql: string; params?: unknown[] }>,\n    options?: TransactionOptions\n  ): Promise<Array<QueryResult<T>>> {\n    await this.ensureConnected()\n\n    const id = this.nextRequestId()\n    const response = await this.sendRequest<RpcBatchResponse>(id, {\n      type: RpcMessageType.BatchTransaction,\n      id,\n      queries,\n      options: options ? this.serializeTransactionOptions(options) : undefined,\n    })\n\n    return response.results.map(r => ({\n      rows: r.rows as T[],\n      fields: r.fields as FieldInfo[],\n      rowCount: r.rowCount,\n      command: 'SELECT',\n    }))\n  }\n\n  /**\n   * Execute multiple queries in a transaction (Transport interface)\n   */\n  async transaction<T>(\n    queries: Array<{ sql: string; params?: unknown[] }>,\n    options?: TransactionOptions\n  ): Promise<T> {\n    const results = await this.batchTransaction(queries, options)\n    return results as T\n  }\n\n  /**\n   * Close the WebSocket connection\n   */\n  async close(): Promise<void> {\n    // Flush any pending batch\n    if (this.pendingBatch) {\n      await this.flushBatch()\n    }\n\n    this.rejectAllPending(new ConnectionError('Connection closed'))\n\n    if (this.ws) {\n      this.ws.close(1000, 'Client closing connection')\n      this.ws = null\n    }\n\n    this.connected = false\n    this.authenticated = false\n    this.connecting = null\n  }\n\n  /**\n   * Check if transport is connected\n   */\n  isConnected(): boolean {\n    return this.connected && this.authenticated\n  }\n\n  // ========== Private methods ==========\n\n  /**\n   * Ensure the WebSocket is connected and authenticated\n   */\n  private async ensureConnected(): Promise<void> {\n    if (this.isConnected()) {\n      return\n    }\n\n    if (this.connecting) {\n      return this.connecting\n    }\n\n    this.connecting = this.connect()\n    try {\n      await this.connecting\n    } finally {\n      this.connecting = null\n    }\n  }\n\n  /**\n   * Establish WebSocket connection\n   */\n  private async connect(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const timeoutId = setTimeout(() => {\n        reject(new TimeoutError(`WebSocket connection timed out after ${this.config.connectTimeout}ms`))\n        if (this.ws) {\n          this.ws.close()\n          this.ws = null\n        }\n      }, this.config.connectTimeout)\n\n      try {\n        this.ws = new this.WebSocketImpl(this.config.url)\n      } catch (error) {\n        clearTimeout(timeoutId)\n        reject(new ConnectionError(`Failed to create WebSocket: ${error instanceof Error ? error.message : String(error)}`))\n        return\n      }\n\n      this.ws.onopen = async () => {\n        this.connected = true\n\n        // Authenticate if API key is provided\n        if (this.config.apiKey) {\n          try {\n            await this.authenticate()\n            clearTimeout(timeoutId)\n            resolve()\n          } catch (error) {\n            clearTimeout(timeoutId)\n            reject(error)\n          }\n        } else {\n          this.authenticated = true\n          clearTimeout(timeoutId)\n          resolve()\n        }\n      }\n\n      this.ws.onmessage = (event) => {\n        this.handleMessage(event.data)\n      }\n\n      this.ws.onerror = () => {\n        clearTimeout(timeoutId)\n        const error = new ConnectionError('WebSocket error occurred')\n        this.rejectAllPending(error)\n        reject(error)\n      }\n\n      this.ws.onclose = (event) => {\n        clearTimeout(timeoutId)\n        this.connected = false\n        this.authenticated = false\n\n        if (!event.wasClean) {\n          const error = new ConnectionError(`WebSocket closed unexpectedly: ${event.code} ${event.reason}`)\n          this.rejectAllPending(error)\n          reject(error)\n        }\n      }\n    })\n  }\n\n  /**\n   * Authenticate with the API key\n   */\n  private async authenticate(): Promise<void> {\n    const id = this.nextRequestId()\n    const response = await this.sendRequest<RpcAuthResponse>(id, {\n      type: RpcMessageType.Auth,\n      id,\n      apiKey: this.config.apiKey,\n    })\n\n    if (!response.success) {\n      throw new ConnectionError('Authentication failed')\n    }\n\n    this.authenticated = true\n  }\n\n  /**\n   * Send a request and wait for response\n   */\n  private sendRequest<T>(id: number, message: unknown): Promise<T> {\n    return new Promise((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        this.pendingRequests.delete(id)\n        reject(new TimeoutError('Request timed out'))\n      }, this.config.requestTimeout)\n\n      this.pendingRequests.set(id, {\n        resolve: resolve as (value: unknown) => void,\n        reject,\n        timeout,\n      })\n\n      if (this.ws && this.ws.readyState === WebSocket.OPEN) {\n        this.ws.send(JSON.stringify(message))\n      } else {\n        clearTimeout(timeout)\n        this.pendingRequests.delete(id)\n        reject(new ConnectionError('WebSocket is not connected'))\n      }\n    })\n  }\n\n  /**\n   * Handle incoming WebSocket message\n   */\n  private handleMessage(data: string): void {\n    let message: RpcIncomingMessage\n\n    try {\n      message = JSON.parse(data)\n    } catch {\n      console.error('Failed to parse RPC message:', data)\n      return\n    }\n\n    // Handle pong messages\n    if (message.type === RpcMessageType.Pong) {\n      return\n    }\n\n    // Handle responses to pending requests\n    if ('id' in message && typeof message.id === 'number') {\n      const pending = this.pendingRequests.get(message.id)\n      if (pending) {\n        clearTimeout(pending.timeout)\n        this.pendingRequests.delete(message.id)\n\n        if (message.type === RpcMessageType.Error) {\n          const errorMessage = message as RpcErrorMessage\n          pending.reject(new PostgresError(errorMessage.error.message || 'Database error', {\n            code: errorMessage.error.code,\n            severity: errorMessage.error.severity || 'ERROR',\n            detail: errorMessage.error.detail,\n            hint: errorMessage.error.hint,\n            position: errorMessage.error.position,\n            schema: errorMessage.error.schema,\n            table: errorMessage.error.table,\n            column: errorMessage.error.column,\n            constraint: errorMessage.error.constraint,\n          }))\n        } else {\n          pending.resolve(message)\n        }\n      }\n    }\n  }\n\n  /**\n   * Reject all pending requests\n   */\n  private rejectAllPending(error: Error): void {\n    for (const [, pending] of this.pendingRequests) {\n      clearTimeout(pending.timeout)\n      pending.reject(error)\n    }\n    this.pendingRequests.clear()\n\n    // Also reject pending batch\n    if (this.pendingBatch) {\n      for (const resolver of this.pendingBatch.resolvers) {\n        resolver.reject(error)\n      }\n      if (this.pendingBatch.timer) {\n        clearTimeout(this.pendingBatch.timer)\n      }\n      this.pendingBatch = null\n    }\n  }\n\n  /**\n   * Get next request ID\n   */\n  private nextRequestId(): number {\n    return ++this.requestId\n  }\n\n  /**\n   * Serialize transaction options\n   */\n  private serializeTransactionOptions(options: TransactionOptions): Record<string, unknown> {\n    return {\n      isolationLevel: options.isolationLevel,\n      readOnly: options.readOnly,\n      deferrable: options.deferrable,\n    }\n  }\n}\n\n/** RPC message type definitions */\ninterface RpcQueryResponse<T extends Row = Row> {\n  type: RpcMessageType.QueryResult\n  id: number\n  rows?: T[]\n  rowCount?: number\n  fields?: Array<{ name: string; dataTypeID: number }>\n  command?: string\n}\n\ninterface RpcBatchResponse {\n  type: RpcMessageType.BatchResult\n  id: number\n  results: Array<{\n    rows: Row[]\n    fields: Array<{ name: string; dataTypeID: number }>\n    rowCount: number\n    durationMs: number\n  }>\n  durationMs: number\n}\n\ninterface RpcAuthResponse {\n  type: RpcMessageType.AuthResult\n  id: number\n  success: boolean\n}\n\ninterface RpcErrorMessage {\n  type: RpcMessageType.Error\n  id: number\n  error: {\n    message?: string\n    code?: string\n    severity?: string\n    detail?: string\n    hint?: string\n    position?: number\n    schema?: string\n    table?: string\n    column?: string\n    constraint?: string\n  }\n}\n\ntype RpcIncomingMessage =\n  | RpcQueryResponse\n  | RpcBatchResponse\n  | RpcAuthResponse\n  | RpcErrorMessage\n  | { type: RpcMessageType.Pong }\n\n/**\n * Create an RPC transport instance\n */\nexport function createRpcTransport(config: RpcTransportConfig): RpcTransport {\n  return new RpcTransport(config)\n}\n","/**\n * Capnweb-enabled PostgreSQL client for postgres.do\n *\n * This client provides:\n * - Magic map support for N+1 query elimination\n * - Promise pipelining for batched operations\n * - RPC transport with automatic batching\n *\n * @example\n * ```typescript\n * import { createClient } from 'postgres.do/rpc'\n *\n * const db = createClient('postgres.do/my-database')\n *\n * // Magic map - N+1 solved in single round trip\n * const usersWithOrders = await db.query('SELECT * FROM users')\n *   .map(users => Promise.all(\n *     users.map(u => db.query('SELECT * FROM orders WHERE user_id = $1', [u.id]))\n *   ))\n *\n * // Promise pipelining - chain without await\n * const user = db.query('SELECT * FROM users WHERE id = $1', [id])\n * const posts = user.map(u => db.query('SELECT * FROM posts WHERE author = $1', [u.id]))\n * const comments = posts.map(p => db.query('SELECT * FROM comments WHERE post_id = ANY($1)', [p.map(x => x.id)]))\n * const result = await comments // Single round trip!\n *\n * // Transactions with pipelining\n * await db.transaction(tx => {\n *   const balance = tx.query('SELECT balance FROM accounts WHERE id = $1', [fromId])\n *   const updated = balance.map(b => {\n *     if (b.balance < amount) throw new Error('Insufficient funds')\n *     return tx.query('UPDATE accounts SET balance = balance - $1 WHERE id = $2', [amount, fromId])\n *   })\n *   return updated.map(() =>\n *     tx.query('UPDATE accounts SET balance = balance + $1 WHERE id = $2', [amount, toId])\n *   )\n * })\n * ```\n */\n\nimport type { Row, IsolationLevel } from '../types'\nimport { RpcTransport, createRpcTransport, type RpcTransportConfig } from '../transport/rpc'\nimport {\n  RpcPromise,\n  createRpcPromise,\n  magicMap,\n  batchExecute,\n  type RpcQueryResult,\n} from './rpc-promise'\n\n/**\n * Client configuration options\n */\nexport interface RpcClientConfig {\n  /** Database URL (postgres.do/database-name or wss://...) */\n  url?: string\n  /** API key for authentication */\n  apiKey?: string\n  /** Custom WebSocket implementation */\n  WebSocket?: typeof WebSocket\n  /** Connection timeout in milliseconds */\n  connectTimeout?: number\n  /** Request timeout in milliseconds */\n  requestTimeout?: number\n  /** Enable automatic batching (default: true) */\n  autoBatch?: boolean\n  /** Custom transport configuration */\n  transport?: Partial<RpcTransportConfig>\n}\n\n/**\n * Transaction options\n */\nexport interface TransactionOptions {\n  /** Isolation level for the transaction */\n  isolationLevel?: IsolationLevel\n  /** Read-only transaction hint */\n  readOnly?: boolean\n}\n\n/**\n * Transaction client interface\n */\nexport interface TransactionClient {\n  /** Execute a query within the transaction */\n  query<T extends Row = Row>(sql: string, params?: unknown[]): RpcPromise<T[]>\n  /** Execute a query and return only the first row */\n  queryOne<T extends Row = Row>(sql: string, params?: unknown[]): RpcPromise<T | null>\n  /** Execute a query and return a scalar value */\n  queryScalar<T = unknown>(sql: string, params?: unknown[]): RpcPromise<T | null>\n  /** Execute a statement that doesn't return rows */\n  execute(sql: string, params?: unknown[]): RpcPromise<{ rowCount: number }>\n}\n\n/**\n * Capnweb-enabled PostgreSQL client\n */\nexport class RpcClient {\n  private transport: RpcTransport\n\n  constructor(config: RpcClientConfig = {}) {\n    const baseUrl = this.resolveUrl(config.url)\n\n    const transportConfig: RpcTransportConfig = {\n      url: baseUrl,\n      autoBatch: config.autoBatch ?? true,\n    }\n    if (config.apiKey) transportConfig.apiKey = config.apiKey\n    if (config.WebSocket) transportConfig.WebSocket = config.WebSocket\n    if (config.connectTimeout) transportConfig.connectTimeout = config.connectTimeout\n    if (config.requestTimeout) transportConfig.requestTimeout = config.requestTimeout\n    if (config.transport?.batchDelayMs !== undefined) transportConfig.batchDelayMs = config.transport.batchDelayMs\n\n    this.transport = createRpcTransport(transportConfig)\n  }\n\n  /**\n   * Resolve the database URL\n   */\n  private resolveUrl(url?: string): string {\n    if (!url) {\n      return 'wss://db.postgres.do/rpc'\n    }\n\n    // Handle postgres.do/database-name format\n    if (url.startsWith('postgres.do/')) {\n      const dbName = url.slice('postgres.do/'.length)\n      return `wss://db.postgres.do/${dbName}/rpc`\n    }\n\n    // Handle full URLs\n    if (url.startsWith('wss://') || url.startsWith('ws://')) {\n      return url\n    }\n\n    // Handle postgres:// URLs\n    if (url.startsWith('postgres://') || url.startsWith('postgresql://')) {\n      const parsed = new URL(url)\n      const protocol = parsed.protocol === 'postgres:' || parsed.protocol === 'postgresql:' ? 'wss' : 'ws'\n      return `${protocol}://${parsed.host}${parsed.pathname}/rpc`\n    }\n\n    // Default: treat as database name\n    return `wss://db.postgres.do/${url}/rpc`\n  }\n\n  /**\n   * Execute a SQL query\n   *\n   * Returns an RpcPromise that supports .map() for magic map functionality.\n   *\n   * @example\n   * ```typescript\n   * // Simple query\n   * const users = await db.query('SELECT * FROM users')\n   *\n   * // With magic map (N+1 elimination)\n   * const usersWithOrders = await db.query('SELECT id FROM users')\n   *   .map(users => Promise.all(users.map(u =>\n   *     db.query('SELECT * FROM orders WHERE user_id = $1', [u.id])\n   *   )))\n   * ```\n   */\n  query<T extends Row = Row>(sql: string, params?: unknown[]): RpcPromise<T[]> {\n    return this.transport.queryRpc<T>(sql, params)\n  }\n\n  /**\n   * Execute a query and return only the first row\n   *\n   * @example\n   * ```typescript\n   * const user = await db.queryOne('SELECT * FROM users WHERE id = $1', [id])\n   * if (user) {\n   *   console.log(user.name)\n   * }\n   * ```\n   */\n  queryOne<T extends Row = Row>(sql: string, params?: unknown[]): RpcPromise<T | null> {\n    return createRpcPromise(async () => {\n      const rows = await this.query<T>(sql, params)\n      return rows[0] ?? null\n    })\n  }\n\n  /**\n   * Execute a query and return a scalar value (first column of first row)\n   *\n   * @example\n   * ```typescript\n   * const count = await db.queryScalar<number>('SELECT COUNT(*) FROM users')\n   * ```\n   */\n  queryScalar<T = unknown>(sql: string, params?: unknown[]): RpcPromise<T | null> {\n    return createRpcPromise(async () => {\n      const rows = await this.query(sql, params)\n      if (!rows[0]) return null\n      const firstKey = Object.keys(rows[0])[0]\n      return (firstKey ? rows[0][firstKey] : null) as T\n    })\n  }\n\n  /**\n   * Execute a SQL statement that doesn't return rows\n   *\n   * @example\n   * ```typescript\n   * const { rowCount } = await db.execute('DELETE FROM users WHERE id = $1', [id])\n   * console.log(`Deleted ${rowCount} rows`)\n   * ```\n   */\n  execute(sql: string, params?: unknown[]): RpcPromise<{ rowCount: number }> {\n    return createRpcPromise(async () => {\n      const result = await this.transport.query(sql, params)\n      return { rowCount: result.rowCount }\n    })\n  }\n\n  /**\n   * Execute a batch of queries in a single round trip\n   *\n   * @example\n   * ```typescript\n   * const [users, orders, products] = await db.batch([\n   *   { sql: 'SELECT * FROM users' },\n   *   { sql: 'SELECT * FROM orders' },\n   *   { sql: 'SELECT * FROM products' },\n   * ])\n   * ```\n   */\n  async batch<T extends Row = Row>(\n    queries: Array<{ sql: string; params?: unknown[] }>\n  ): Promise<T[][]> {\n    const results = await this.transport.batch<T>(queries)\n    return results.map(r => r.rows)\n  }\n\n  /**\n   * Execute queries within a transaction\n   *\n   * The transaction callback receives a transaction client that supports\n   * the same query methods with promise pipelining.\n   *\n   * @example\n   * ```typescript\n   * await db.transaction(async tx => {\n   *   await tx.execute('INSERT INTO users (name) VALUES ($1)', ['Alice'])\n   *   await tx.execute('INSERT INTO audit_log (action) VALUES ($1)', ['user_created'])\n   * })\n   * ```\n   *\n   * @example Promise pipelining in transactions\n   * ```typescript\n   * await db.transaction(tx => {\n   *   const balance = tx.query('SELECT balance FROM accounts WHERE id = $1', [fromId])\n   *   return balance.map(async rows => {\n   *     if (rows[0].balance < amount) throw new Error('Insufficient funds')\n   *     await tx.execute('UPDATE accounts SET balance = balance - $1 WHERE id = $2', [amount, fromId])\n   *     await tx.execute('UPDATE accounts SET balance = balance + $1 WHERE id = $2', [amount, toId])\n   *   })\n   * })\n   * ```\n   */\n  async transaction<T>(\n    fn: (tx: TransactionClient) => Promise<T> | RpcPromise<T>,\n    options?: TransactionOptions\n  ): Promise<T> {\n    // Start collecting queries for batching\n    this.transport.startCollecting()\n\n    // Build BEGIN statement\n    const beginParts = ['BEGIN']\n    if (options?.isolationLevel) {\n      // Validate isolation level to prevent SQL injection\n      const validLevels = ['read uncommitted', 'read committed', 'repeatable read', 'serializable']\n      const normalized = options.isolationLevel.toLowerCase()\n      if (!validLevels.includes(normalized)) {\n        throw new Error(`Invalid isolation level: \"${options.isolationLevel}\"`)\n      }\n      beginParts.push(`ISOLATION LEVEL ${normalized.toUpperCase()}`)\n    }\n    if (options?.readOnly) {\n      beginParts.push('READ ONLY')\n    }\n\n    try {\n      // Execute BEGIN\n      await this.transport.query(beginParts.join(' '))\n\n      // Create transaction client\n      const txClient: TransactionClient = {\n        query: <T extends Row = Row>(sql: string, params?: unknown[]) =>\n          this.query<T>(sql, params),\n        queryOne: <T extends Row = Row>(sql: string, params?: unknown[]) =>\n          this.queryOne<T>(sql, params),\n        queryScalar: <T = unknown>(sql: string, params?: unknown[]) =>\n          this.queryScalar<T>(sql, params),\n        execute: (sql: string, params?: unknown[]) =>\n          this.execute(sql, params),\n      }\n\n      // Execute transaction callback\n      const result = fn(txClient)\n      const finalResult = result instanceof RpcPromise ? await result.execute() : await result\n\n      // Stop collecting and execute any remaining batched queries\n      await this.transport.stopCollecting()\n\n      // Commit\n      await this.transport.query('COMMIT')\n\n      return finalResult\n    } catch (error) {\n      // Stop collecting\n      this.transport.stopCollecting().catch(() => {})\n\n      // Rollback\n      await this.transport.query('ROLLBACK').catch(() => {})\n\n      throw error\n    }\n  }\n\n  /**\n   * Execute queries within a batched transaction\n   *\n   * All queries are collected and executed in a single round trip,\n   * wrapped in BEGIN/COMMIT.\n   *\n   * @example\n   * ```typescript\n   * const results = await db.batchTransaction([\n   *   { sql: 'INSERT INTO users (name) VALUES ($1)', params: ['Alice'] },\n   *   { sql: 'INSERT INTO audit_log (action) VALUES ($1)', params: ['user_created'] },\n   * ])\n   * ```\n   */\n  async batchTransaction<T extends Row = Row>(\n    queries: Array<{ sql: string; params?: unknown[] }>,\n    options?: TransactionOptions\n  ): Promise<T[][]> {\n    const results = await this.transport.batchTransaction<T>(queries, options)\n    return results.map(r => r.rows)\n  }\n\n  /**\n   * Health check - verify database is responsive\n   */\n  ping(): RpcPromise<{ ok: true; durationMs: number }> {\n    return createRpcPromise(async () => {\n      const start = performance.now()\n      await this.transport.query('SELECT 1')\n      return { ok: true as const, durationMs: performance.now() - start }\n    })\n  }\n\n  /**\n   * Get database version\n   */\n  version(): RpcPromise<string> {\n    return createRpcPromise(async () => {\n      const rows = await this.query<{ version: string }>('SELECT version()')\n      return rows[0]?.version ?? 'unknown'\n    })\n  }\n\n  /**\n   * List all tables in the public schema\n   */\n  listTables(): RpcPromise<string[]> {\n    return createRpcPromise(async () => {\n      const rows = await this.query<{ tablename: string }>(\n        `SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`\n      )\n      return rows.map(r => r.tablename)\n    })\n  }\n\n  /**\n   * Get table schema information\n   */\n  describeTable(tableName: string): RpcPromise<Array<{\n    column_name: string\n    data_type: string\n    is_nullable: boolean\n    column_default: string | null\n  }>> {\n    return createRpcPromise(async () => {\n      const rows = await this.query<{\n        column_name: string\n        data_type: string\n        is_nullable: string\n        column_default: string | null\n      }>(\n        `SELECT column_name, data_type, is_nullable, column_default\n         FROM information_schema.columns\n         WHERE table_schema = 'public' AND table_name = $1\n         ORDER BY ordinal_position`,\n        [tableName]\n      )\n\n      return rows.map(r => ({\n        column_name: r.column_name,\n        data_type: r.data_type,\n        is_nullable: r.is_nullable === 'YES',\n        column_default: r.column_default,\n      }))\n    })\n  }\n\n  /**\n   * Close the connection\n   */\n  async close(): Promise<void> {\n    await this.transport.close()\n  }\n\n  /**\n   * Check if connected\n   */\n  isConnected(): boolean {\n    return this.transport.isConnected()\n  }\n}\n\n/**\n * Create a capnweb-enabled PostgreSQL client\n *\n * @example\n * ```typescript\n * import { createClient } from 'postgres.do/rpc'\n *\n * const db = createClient('postgres.do/my-database')\n *\n * // Query with magic map\n * const usersWithOrders = await db.query('SELECT * FROM users')\n *   .map(users => Promise.all(\n *     users.map(u => db.query('SELECT * FROM orders WHERE user_id = $1', [u.id]))\n *   ))\n * ```\n */\nexport function createClient(urlOrConfig?: string | RpcClientConfig): RpcClient {\n  if (typeof urlOrConfig === 'string') {\n    return new RpcClient({ url: urlOrConfig })\n  }\n  return new RpcClient(urlOrConfig)\n}\n\n/**\n * Re-export utilities\n */\nexport { RpcPromise, createRpcPromise, magicMap, batchExecute }\nexport type { RpcQueryResult }\n","/**\n * Shared RPC Types for postgres.do\n *\n * These types define the capnweb RPC contract between:\n * - Client: postgres.do (this package)\n * - Server: @dotdo/postgres Worker\n *\n * IMPORTANT: This file is the single source of truth for RPC types.\n * Both client and server MUST use these types to ensure type safety.\n *\n * @see packages/postgres/src/worker/rpc.ts - Server-side RPC implementation\n * @see packages/postgres.do/src/transport/rpc.ts - Client-side RPC transport\n */\n\n// ============================================================================\n// Base Types\n// ============================================================================\n\n/**\n * Generic row type for query results\n * Used as a constraint for typed query results\n */\nexport type RpcRow = Record<string, unknown>\n\n/**\n * Field metadata from query results\n * Maps to PostgreSQL's column metadata\n */\nexport interface RpcField {\n  /** Column name */\n  name: string\n  /** PostgreSQL OID for the column type */\n  dataTypeID: number\n  /** Table OID (0 if not from a table) */\n  tableID?: number\n  /** Column position in table */\n  columnID?: number\n  /** Data type size in bytes (-1 for variable) */\n  dataTypeSize?: number\n  /** Type modifier */\n  dataTypeModifier?: number\n  /** Format code (0 = text, 1 = binary) */\n  format?: string\n}\n\n// ============================================================================\n// Query Types\n// ============================================================================\n\n/**\n * RPC query result\n *\n * Returned from all query operations (query, queryOne, execute, etc.)\n */\nexport interface RpcQueryResult<T extends RpcRow = RpcRow> {\n  /** Query result rows */\n  rows: T[]\n  /** Field metadata */\n  fields: RpcField[]\n  /** Number of affected rows (for INSERT/UPDATE/DELETE) or returned rows */\n  rowCount: number\n  /** Query execution time in milliseconds */\n  durationMs: number\n}\n\n/**\n * RPC batch query item\n *\n * Single query within a batch operation\n */\nexport interface RpcBatchQuery {\n  /** SQL query string */\n  sql: string\n  /** Query parameters (positional: $1, $2, etc.) */\n  params?: unknown[]\n}\n\n/**\n * RPC batch result\n *\n * Returned from batch and batchTransaction operations\n */\nexport interface RpcBatchResult<T extends RpcRow = RpcRow> {\n  /** Results for each query in order */\n  results: RpcQueryResult<T>[]\n  /** Total execution time in milliseconds */\n  durationMs: number\n}\n\n// ============================================================================\n// Transaction Types\n// ============================================================================\n\n/**\n * Transaction isolation levels\n *\n * Follows PostgreSQL's isolation level semantics\n */\nexport type RpcIsolationLevel =\n  | 'READ UNCOMMITTED'\n  | 'READ COMMITTED'\n  | 'REPEATABLE READ'\n  | 'SERIALIZABLE'\n\n/**\n * Transaction options\n *\n * Passed to transaction() and batchTransaction() operations\n */\nexport interface RpcTransactionOptions {\n  /** Isolation level for the transaction */\n  isolationLevel?: RpcIsolationLevel\n  /** Read-only transaction hint (enables optimizations) */\n  readOnly?: boolean\n  /** Deferrable (only valid with SERIALIZABLE + READ ONLY) */\n  deferrable?: boolean\n}\n\n/**\n * Transaction state\n */\nexport type RpcTransactionState = 'active' | 'committed' | 'rolled_back'\n\n// ============================================================================\n// Error Types\n// ============================================================================\n\n/**\n * RPC error response structure\n *\n * Follows PostgreSQL error format with additional fields\n */\nexport interface RpcError {\n  /** Error message */\n  message: string\n  /** PostgreSQL error code (e.g., '23505' for unique violation) */\n  code?: string\n  /** Error severity (ERROR, WARNING, etc.) */\n  severity?: string\n  /** Detailed error message */\n  detail?: string\n  /** Hint for fixing the error */\n  hint?: string\n  /** Position in query where error occurred */\n  position?: number\n  /** Schema name if relevant */\n  schema?: string\n  /** Table name if relevant */\n  table?: string\n  /** Column name if relevant */\n  column?: string\n  /** Constraint name if relevant */\n  constraint?: string\n}\n\n// ============================================================================\n// RPC Message Types (Wire Protocol)\n// ============================================================================\n\n/**\n * RPC message types for the WebSocket protocol\n *\n * These define the request/response types used over the wire\n */\nexport enum RpcMessageType {\n  // === Requests ===\n  /** Single query request */\n  Query = 'query',\n  /** Batch query request */\n  Batch = 'batch',\n  /** Batch transaction request */\n  BatchTransaction = 'batch_tx',\n  /** Start transaction request */\n  Transaction = 'transaction',\n  /** Query within transaction */\n  TransactionQuery = 'tx_query',\n  /** Commit transaction */\n  TransactionCommit = 'tx_commit',\n  /** Rollback transaction */\n  TransactionRollback = 'tx_rollback',\n  /** Ping for keepalive */\n  Ping = 'ping',\n  /** Authentication request */\n  Auth = 'auth',\n\n  // === Responses ===\n  /** Query result response */\n  QueryResult = 'query_result',\n  /** Batch result response */\n  BatchResult = 'batch_result',\n  /** Transaction result response */\n  TransactionResult = 'tx_result',\n  /** Error response */\n  Error = 'error',\n  /** Pong response */\n  Pong = 'pong',\n  /** Auth result response */\n  AuthResult = 'auth_result',\n}\n\n// ============================================================================\n// RPC Request Messages\n// ============================================================================\n\n/**\n * Base RPC message\n */\ninterface RpcMessageBase {\n  /** Message type */\n  type: RpcMessageType\n  /** Request ID for correlation */\n  id: number\n}\n\n/**\n * Query request message\n */\nexport interface RpcQueryRequest extends RpcMessageBase {\n  type: RpcMessageType.Query\n  /** SQL query string */\n  sql: string\n  /** Query parameters */\n  params?: unknown[]\n}\n\n/**\n * Batch query request message\n */\nexport interface RpcBatchRequest extends RpcMessageBase {\n  type: RpcMessageType.Batch\n  /** Queries to execute */\n  queries: RpcBatchQuery[]\n}\n\n/**\n * Batch transaction request message\n */\nexport interface RpcBatchTransactionRequest extends RpcMessageBase {\n  type: RpcMessageType.BatchTransaction\n  /** Queries to execute */\n  queries: RpcBatchQuery[]\n  /** Transaction options */\n  options?: RpcTransactionOptions\n}\n\n/**\n * Authentication request message\n */\nexport interface RpcAuthRequest extends RpcMessageBase {\n  type: RpcMessageType.Auth\n  /** API key for authentication */\n  apiKey?: string\n}\n\n/**\n * Ping request message\n */\nexport interface RpcPingRequest extends RpcMessageBase {\n  type: RpcMessageType.Ping\n}\n\n// ============================================================================\n// RPC Response Messages\n// ============================================================================\n\n/**\n * Query result response message\n */\nexport interface RpcQueryResultMessage<T extends RpcRow = RpcRow> extends RpcMessageBase {\n  type: RpcMessageType.QueryResult\n  /** Result rows */\n  rows: T[]\n  /** Field metadata */\n  fields: RpcField[]\n  /** Number of affected/returned rows */\n  rowCount: number\n  /** Query execution time */\n  durationMs: number\n  /** Command type (SELECT, INSERT, etc.) */\n  command?: string\n}\n\n/**\n * Batch result response message\n */\nexport interface RpcBatchResultMessage extends RpcMessageBase {\n  type: RpcMessageType.BatchResult\n  /** Results for each query */\n  results: RpcQueryResult[]\n  /** Total execution time */\n  durationMs: number\n}\n\n/**\n * Error response message\n */\nexport interface RpcErrorMessage extends RpcMessageBase {\n  type: RpcMessageType.Error\n  /** Error details */\n  error: RpcError\n}\n\n/**\n * Auth result response message\n */\nexport interface RpcAuthResultMessage extends RpcMessageBase {\n  type: RpcMessageType.AuthResult\n  /** Whether authentication succeeded */\n  success: boolean\n  /** Error message if failed */\n  error?: string\n}\n\n/**\n * Pong response message\n */\nexport interface RpcPongMessage extends RpcMessageBase {\n  type: RpcMessageType.Pong\n}\n\n// ============================================================================\n// Union Types\n// ============================================================================\n\n/**\n * All possible RPC request message types\n */\nexport type RpcRequestMessage =\n  | RpcQueryRequest\n  | RpcBatchRequest\n  | RpcBatchTransactionRequest\n  | RpcAuthRequest\n  | RpcPingRequest\n\n/**\n * All possible RPC response message types\n */\nexport type RpcResponseMessage =\n  | RpcQueryResultMessage\n  | RpcBatchResultMessage\n  | RpcErrorMessage\n  | RpcAuthResultMessage\n  | RpcPongMessage\n\n/**\n * All RPC message types\n */\nexport type RpcMessage = RpcRequestMessage | RpcResponseMessage\n\n// ============================================================================\n// Server API Interface\n// ============================================================================\n\n/**\n * PostgresRpcApi interface\n *\n * This interface defines the RPC API that the server exposes.\n * Clients use this interface (via capnweb RPC stubs) to call server methods.\n *\n * @example Server-side implementation in @dotdo/postgres:\n * ```typescript\n * import type { IPostgresRpcApi } from 'postgres.do/rpc'\n *\n * export class PostgresRpcApi extends RpcTarget implements IPostgresRpcApi {\n *   async query<T>(sql: string, params?: unknown[]): Promise<RpcQueryResult<T>> {\n *     // ...implementation\n *   }\n * }\n * ```\n *\n * @example Client-side usage:\n * ```typescript\n * import { createClient } from 'postgres.do/rpc'\n *\n * const db = createClient('postgres.do/my-database')\n * const result = await db.query('SELECT * FROM users')\n * ```\n */\nexport interface IPostgresRpcApi {\n  /**\n   * Execute a SQL query\n   */\n  query<T extends RpcRow = RpcRow>(\n    sql: string,\n    params?: unknown[]\n  ): Promise<RpcQueryResult<T>>\n\n  /**\n   * Execute a query and return only the first row\n   */\n  queryOne<T extends RpcRow = RpcRow>(\n    sql: string,\n    params?: unknown[]\n  ): Promise<T | null>\n\n  /**\n   * Execute a query and return the scalar value (first column of first row)\n   */\n  queryScalar<T = unknown>(\n    sql: string,\n    params?: unknown[]\n  ): Promise<T | null>\n\n  /**\n   * Execute a SQL statement that doesn't return rows\n   */\n  execute(\n    sql: string,\n    params?: unknown[]\n  ): Promise<{ rowCount: number; durationMs: number }>\n\n  /**\n   * Execute a batch of queries\n   */\n  batch(queries: RpcBatchQuery[]): Promise<RpcBatchResult>\n\n  /**\n   * Execute a batch of queries within a transaction\n   */\n  batchTransaction(\n    queries: RpcBatchQuery[],\n    options?: RpcTransactionOptions\n  ): Promise<RpcBatchResult>\n\n  /**\n   * Health check\n   */\n  ping(): Promise<{ ok: true; durationMs: number }>\n\n  /**\n   * Get database version\n   */\n  version(): Promise<string>\n\n  /**\n   * List all tables in the public schema\n   */\n  listTables(): Promise<string[]>\n\n  /**\n   * Get table schema information\n   */\n  describeTable(tableName: string): Promise<Array<{\n    column_name: string\n    data_type: string\n    is_nullable: boolean\n    column_default: string | null\n  }>>\n\n  /**\n   * Get database name\n   */\n  getDatabase(): string\n}\n\n/**\n * Transaction RPC API interface\n */\nexport interface ITransactionRpcApi {\n  /**\n   * Execute a query within this transaction\n   */\n  query<T extends RpcRow = RpcRow>(\n    sql: string,\n    params?: unknown[]\n  ): Promise<RpcQueryResult<T>>\n\n  /**\n   * Commit the transaction\n   */\n  commit(): Promise<{ success: true; durationMs: number }>\n\n  /**\n   * Rollback the transaction\n   */\n  rollback(): Promise<{ success: true; durationMs: number }>\n\n  /**\n   * Get transaction state\n   */\n  getState(): RpcTransactionState\n\n  /**\n   * Get number of queries executed in this transaction\n   */\n  getQueryCount(): number\n}\n"],"mappings":"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","names":["SharedPostgresError","SharedConnectionError","SharedConnectionTimeoutError","result","mapped","RpcMessageType"]}