@supalive/core 0.1.6 → 1.0.0

package/dist/index-DouKwYL6.d.ts

@@ -0,0 +1,1754 @@
+import z, { ZodRawShape, ZodType, z as z$1 } from "zod";
+import { RetryPolicy } from "cockatiel";
+import Redis$1 from "ioredis";
+import { Redis as Redis$2 } from "@upstash/redis";
+
+//#region src/db/types_db.d.ts
+/** Monotonically increasing integer from global_commit_ts sequence in Postgres */
+type CommitTs = bigint;
+declare const BigIntSchema: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+declare const CompareOperatorSchema: z.ZodEnum<{
+  "=": "=";
+  "!=": "!=";
+  ">": ">";
+  ">=": ">=";
+  "<": "<";
+  "<=": "<=";
+  like: "like";
+  ilike: "ilike";
+  contains: "contains";
+  icontains: "icontains";
+  between: "between";
+  jsonContains: "jsonContains";
+  jsonContainedBy: "jsonContainedBy";
+  jsonHasKey: "jsonHasKey";
+  jsonArrayContains: "jsonArrayContains";
+  isNull: "isNull";
+  isNotNull: "isNotNull";
+}>;
+type CompareOperator = z.infer<typeof CompareOperatorSchema>;
+type Predicate = LeafPredicate | {
+  kind: "and";
+  children: Predicate[];
+} | {
+  kind: "or";
+  children: Predicate[];
+};
+declare const PredicateSchema: z.ZodType<Predicate>;
+declare const LeafPredicateSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"leaf">;
+  column: z.ZodString;
+  operator: z.ZodEnum<{
+    "=": "=";
+    "!=": "!=";
+    ">": ">";
+    ">=": ">=";
+    "<": "<";
+    "<=": "<=";
+    like: "like";
+    ilike: "ilike";
+    contains: "contains";
+    icontains: "icontains";
+    between: "between";
+    jsonContains: "jsonContains";
+    jsonContainedBy: "jsonContainedBy";
+    jsonHasKey: "jsonHasKey";
+    jsonArrayContains: "jsonArrayContains";
+    isNull: "isNull";
+    isNotNull: "isNotNull";
+  }>;
+  value: z.ZodUnknown;
+  value2: z.ZodOptional<z.ZodUnknown>;
+  raw: z.ZodOptional<z.ZodBoolean>;
+  path: z.ZodOptional<z.ZodString>;
+  mode: z.ZodOptional<z.ZodEnum<{
+    one: "one";
+    all: "all";
+  }>>;
+}, z.core.$strip>;
+type LeafPredicate = z.infer<typeof LeafPredicateSchema>;
+declare const AndPredicateSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"and">;
+  children: z.ZodArray<z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>>;
+}, z.core.$strip>;
+type AndPredicate = z.infer<typeof AndPredicateSchema>;
+declare const OrPredicateSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"or">;
+  children: z.ZodArray<z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>>;
+}, z.core.$strip>;
+type OrPredicate = z.infer<typeof OrPredicateSchema>;
+/** Query specification - what was queried (used for cache key generation) */
+type QuerySpec = ReadEntry;
+declare function normalizeIdToBytes(id: string | number, fromHex?: boolean): Uint8Array;
+declare function normalizeToBytes(value: Uint8Array | unknown): Uint8Array;
+declare function bytesFromJson(value: Uint8Array | unknown): Uint8Array;
+declare const PointReadSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"point">;
+  table: z.ZodString;
+  id: z.ZodString;
+  tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  expectedCommitTs: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>>>;
+}, z.core.$strip>;
+type PointRead = z.infer<typeof PointReadSchema>;
+declare const RawPointReadSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"point">;
+  tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  id: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  table: z.ZodString;
+  expectedCommitTs: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>>>;
+}, z.core.$strip>;
+type RawPointRead = z.infer<typeof RawPointReadSchema>;
+/**
+ * Query specification for a range read (get with filters).
+ * This is the query definition, not the result.
+ */
+declare const RangeReadSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"range">;
+  table: z.ZodString;
+  tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  predicate: z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>;
+  columns: z.ZodArray<z.ZodString>;
+  orderBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+type RangeRead = z.infer<typeof RangeReadSchema>;
+declare const RawRangeReadSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"range">;
+  table: z.ZodString;
+  tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  predicate: z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>;
+  columns: z.ZodArray<z.ZodString>;
+  orderBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+type RawRangeRead = z.infer<typeof RawRangeReadSchema>;
+declare const ReadEntrySchema: z.ZodUnion<readonly [z.ZodObject<{
+  kind: z.ZodLiteral<"point">;
+  table: z.ZodString;
+  id: z.ZodString;
+  tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  expectedCommitTs: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"range">;
+  table: z.ZodString;
+  tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  predicate: z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>;
+  columns: z.ZodArray<z.ZodString>;
+  orderBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>]>;
+type ReadEntry = z.infer<typeof ReadEntrySchema>;
+declare const RawReadEntrySchema: z.ZodUnion<readonly [z.ZodObject<{
+  kind: z.ZodLiteral<"point">;
+  tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  id: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  table: z.ZodString;
+  expectedCommitTs: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"range">;
+  table: z.ZodString;
+  tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  predicate: z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>;
+  columns: z.ZodArray<z.ZodString>;
+  orderBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>]>;
+type RawReadEntry = z.infer<typeof RawReadEntrySchema>;
+declare const WriteOpSchema: z.ZodEnum<{
+  insert: "insert";
+  update: "update";
+  delete: "delete";
+}>;
+type WriteOp = z.infer<typeof WriteOpSchema>;
+declare const WriteEntrySchema: z.ZodObject<{
+  table: z.ZodString;
+  tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+  id: z.ZodString;
+  op: z.ZodEnum<{
+    insert: "insert";
+    update: "update";
+    delete: "delete";
+  }>;
+  data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  prevData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  expectedCommitTs: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>>>;
+}, z.core.$strip>;
+type WriteEntry = z.infer<typeof WriteEntrySchema>;
+interface CommitLogEntry {
+  id: Uint8Array;
+  ts: bigint;
+  tableId: Uint8Array;
+  data: Uint8Array;
+  _parsedData?: Record<string, unknown> | null;
+}
+interface MutationResult<T> {
+  result: T;
+  writeSet: WriteEntry[];
+  commitTs: CommitTs;
+}
+interface LiveResult<T> {
+  ts: bigint;
+  data: T;
+  readSet: ReadEntry[];
+}
+declare const QueryCacheMetadataSchema: z.ZodObject<{
+  lastSnapshotTs: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  readSet: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    table: z.ZodString;
+    id: z.ZodString;
+    tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+    expectedCommitTs: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>>>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"range">;
+    table: z.ZodString;
+    tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+    predicate: z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>;
+    columns: z.ZodArray<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  }, z.core.$strip>]>>;
+}, z.core.$strip>;
+type QueryCacheMetadata = z.infer<typeof QueryCacheMetadataSchema>;
+declare const QueryCacheEntrySchema: z.ZodObject<{
+  data: z.ZodUnknown;
+}, z.core.$strip>;
+type QueryCacheEntry = z.infer<typeof QueryCacheEntrySchema>;
+declare const CachedPgMetadataSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>;
+type CachedPgMetadata = z.infer<typeof CachedPgMetadataSchema>;
+interface RetryConfig {
+  maxAttempts: number;
+  backoff: "none" | "linear" | "exponential";
+  delayMs?: number;
+  onConflict?: (attempt: number, error: OccConflictError) => void;
+}
+declare const NO_RETRY: RetryConfig;
+declare const DEFAULT_RETRY: RetryConfig;
+declare class OccConflictError extends Error {
+  readonly reason: string;
+  readonly conflictDetail?: unknown | undefined;
+  constructor(reason: string, conflictDetail?: unknown | undefined);
+  static isOccConflictError(err: unknown): boolean;
+}
+declare class OccAbortError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/server/subscription-manager-types.d.ts
+declare const RegisterSubscriptionParamsSchema: z.ZodObject<{
+  subId: z.ZodString;
+  cacheKey: z.ZodString;
+  queryName: z.ZodString;
+  args: z.ZodUnknown;
+  queryIdentity: z.ZodString;
+  instanceName: z.ZodString;
+  lastSnapshotTs: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+}, z.core.$strip>;
+type RegisterSubscriptionParams = z.infer<typeof RegisterSubscriptionParamsSchema>;
+declare const RegisterSubscriptionResultSchema: z.ZodObject<{
+  cacheKey: z.ZodString;
+  recompute: z.ZodBoolean;
+  readSet: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    table: z.ZodString;
+    id: z.ZodString;
+    tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+    expectedCommitTs: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>>>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"range">;
+    table: z.ZodString;
+    tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+    predicate: z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>;
+    columns: z.ZodArray<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  }, z.core.$strip>]>>;
+}, z.core.$strip>;
+type RegisterSubscriptionResult = z.infer<typeof RegisterSubscriptionResultSchema>;
+declare const UpdateSubscriptionReadSetParamsSchema: z.ZodObject<{
+  cacheKey: z.ZodString;
+  subId: z.ZodString;
+  instanceName: z.ZodString;
+  lastSnapshotTs: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  readSet: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    table: z.ZodString;
+    id: z.ZodString;
+    tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+    expectedCommitTs: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>>>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"range">;
+    table: z.ZodString;
+    tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+    predicate: z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>;
+    columns: z.ZodArray<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  }, z.core.$strip>]>>;
+}, z.core.$strip>;
+type UpdateSubscriptionReadSetParams = z.infer<typeof UpdateSubscriptionReadSetParamsSchema>;
+/**
+ * `tracked: false` means the sub-manager has no record of this subId (e.g.
+ * a restart wiped state and the caller hasn't re-registered yet). The app
+ * server should treat this as a signal to register the sub before retrying.
+ */
+declare const UpdateSubscriptionReadSetResultSchema: z.ZodObject<{
+  tracked: z.ZodBoolean;
+}, z.core.$strip>;
+type UpdateSubscriptionReadSetResult = z.infer<typeof UpdateSubscriptionReadSetResultSchema>;
+declare const UnregisterSubscriptionParamsSchema: z.ZodObject<{
+  subId: z.ZodString;
+  instanceName: z.ZodString;
+}, z.core.$strip>;
+type UnregisterSubscriptionParams = z.infer<typeof UnregisterSubscriptionParamsSchema>;
+declare const UnregisterSubscriptionsParamsSchema: z.ZodArray<z.ZodObject<{
+  subId: z.ZodString;
+  instanceName: z.ZodString;
+}, z.core.$strip>>;
+type UnregisterSubscriptionsParams = z.infer<typeof UnregisterSubscriptionsParamsSchema>;
+declare const UnregisterSubscriptionResultSchema: z.ZodObject<{
+  ok: z.ZodBoolean;
+}, z.core.$strip>;
+type UnregisterSubscriptionResult = z.infer<typeof UnregisterSubscriptionResultSchema>;
+declare const UnregisterSubscriptionsResultSchema: z.ZodArray<z.ZodObject<{
+  ok: z.ZodBoolean;
+}, z.core.$strip>>;
+type UnregisterSubscriptionsResult = z.infer<typeof UnregisterSubscriptionsResultSchema>;
+declare const InvalidateWritesetParamsSchema: z.ZodObject<{
+  writeSet: z.ZodArray<z.ZodObject<{
+    table: z.ZodString;
+    tableId: z.ZodPipe<z.ZodAny, z.ZodTransform<Uint8Array<ArrayBufferLike>, any>>;
+    id: z.ZodString;
+    op: z.ZodEnum<{
+      insert: "insert";
+      update: "update";
+      delete: "delete";
+    }>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    prevData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    expectedCommitTs: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type InvalidateWritesetParams = z.infer<typeof InvalidateWritesetParamsSchema>;
+declare const AffectedSubscriptionSchema: z.ZodObject<{
+  subId: z.ZodString;
+  queryName: z.ZodString;
+  args: z.ZodUnknown;
+  cacheKey: z.ZodString;
+  notifyInstances: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type AffectedSubscription = z.infer<typeof AffectedSubscriptionSchema>;
+declare const InvalidateWritesetResultSchema: z.ZodObject<{
+  affected: z.ZodArray<z.ZodObject<{
+    subId: z.ZodString;
+    queryName: z.ZodString;
+    args: z.ZodUnknown;
+    cacheKey: z.ZodString;
+    notifyInstances: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type InvalidateWritesetResult = z.infer<typeof InvalidateWritesetResultSchema>;
+declare const RegistrationRecordSchema: z.ZodObject<{
+  queryName: z.ZodString;
+  args: z.ZodUnknown;
+  queryIdentity: z.ZodString;
+  cacheKey: z.ZodString;
+}, z.core.$strip>;
+type RegistrationRecord = z.infer<typeof RegistrationRecordSchema>;
+//#endregion
+//#region src/db/cache.d.ts
+declare class CacheLayer {
+  redis: Redis$1 | Redis$2;
+  private readonly ttlSeconds;
+  constructor(upstash: Redis$1 | Redis$2, ttlSeconds?: number);
+  setQueryCacheFor(cacheKey: string, data: unknown, ttlSeconds?: number): Promise<void>;
+  getQueryCacheFor(cacheKey: string): Promise<QueryCacheEntry | null>;
+  getQueryCacheMetaData(cacheKey: string): Promise<QueryCacheMetadata | null>;
+  setQueryCacheMetadata(cacheKey: string, metaData: QueryCacheMetadata): Promise<void>;
+  persistRegistrationRecord(subId: string, record: RegistrationRecord): Promise<void>;
+  deleteRegistrationRecord(subId: string): Promise<void>;
+  deleteRegistrationsRecord(subIds: string[]): Promise<void>;
+  fetchRegistrationRecordsBatch(subIds: string[]): Promise<Map<string, RegistrationRecord | null>>;
+  getCachedTableColumnTypes(key: string): Promise<CachedPgMetadata | null>;
+  setCachedTableColumnsTypes(key: string, value: CachedPgMetadata): Promise<void>;
+  /**
+   * Race participant: try to claim `lock:recompute:<subId>:<commitTs>`
+   * with `SET NX EX`. The single Redis round-trip both arbitrates and
+   * sets a TTL fallback in case the winner crashes mid-recompute.
+   */
+  tryAcquireRecomputeLock(instanceId: string, subId: string, commitTs: string, ttl: number): Promise<boolean>;
+  private getRegistrationKey;
+  private getQueryCacheDataKey;
+  private getQeruyCacheMetaKey;
+}
+//#endregion
+//#region src/db/db.d.ts
+interface DbQueryResult<T = any> {
+  rows: T[];
+  rowCount?: number | null;
+}
+interface RawClient {
+  query<T = any>(sql: string, params?: unknown[]): Promise<DbQueryResult<T>>;
+}
+interface PooledClient extends RawClient {
+  release(): void;
+}
+type DbType = "postgres" | "mysql";
+interface PendingPointEntry {
+  entry: PointRead;
+  key: string;
+}
+interface PreparedQuery {
+  sql: string;
+  params: unknown[] | unknown[][];
+  operation: "insertSingle" | "insertBatch" | "updateSingle" | "updateBatch" | "deleteSingle" | "deleteBatch" | "pointReadValidation" | "commit_logs";
+  table: string;
+  entryId?: unknown;
+  expectedTs?: bigint;
+  entries?: WriteEntry[];
+  pendingsEntry?: PendingPointEntry[];
+}
+interface PreparedQueries {
+  commits: PreparedQuery[];
+  validateReadPoints?: PreparedQuery[];
+  hasRangeRead: boolean;
+  tableIds?: Uint8Array[];
+  rawReadSet?: RawReadEntry[];
+}
+interface Database {
+  readonly dbType: DbType;
+  readonly sqlBuilder: SqlBuilder;
+  columnTypes: Map<string, Map<string, string>>;
+  migrationSql: string[];
+  bootstrapColumnTypes(opts: {
+    redis?: CacheLayer;
+    cacheKey: string;
+    tables?: string[];
+  }): Promise<void>;
+  query<T = any>(sql: string, params?: unknown[]): Promise<DbQueryResult<T>>;
+  getClient(): Promise<PooledClient>;
+  getTransactionClient(): Promise<TxDatabase>;
+  getLatestSnapshotTimestamp(): Promise<bigint>;
+  updateLatestSnapshotTimestamp(commitTs: bigint): Promise<void>;
+  getNextTimestamp(): Promise<bigint>;
+  prepareCommitWrites(readSet: ReadEntry[], writeSet: WriteEntry[], commitTs: LazyCommitTsParam): Promise<PreparedQueries>;
+  commitWrites(beginTs: bigint, queries: PreparedQueries, commitTs: bigint): Promise<{
+    success: boolean;
+  }>;
+  close(): Promise<void>;
+  /**
+   * Delete commit_logs older than `ts` (exclusive). Used by the periodic
+   * retention sweep in SubscriptionManager so the table doesn't grow
+   * unbounded.
+   */
+  pruneCommitLogsBefore(ts: bigint): Promise<bigint>;
+  /**
+   * Half-open range scan: ts >= beginTs AND ts < endTs. Used by the
+   * subscription-recovery path to replay logs in a specific time window.
+   */
+  getCommitLogsBetweenTs(beginTs: bigint, endTs: bigint, tableIds: Uint8Array[]): Promise<CommitLogEntry[]>;
+  /**
+   * Conflict-check scan for OCC: ts >= sinceTs AND ts <> excludeTs. The
+   * exclude is our own commitTs so we don't conflict with ourselves; the
+   * lack of an upper bound is intentional, so a concurrent peer that
+   * happens to have a higher commitTs but committed before us is still
+   * visible. (MVCC keeps in-flight peers invisible until they commit.)
+   */
+  getCommitLogsSinceTs(sinceTs: bigint, excludeTs: bigint, tableIds: Uint8Array[]): Promise<CommitLogEntry[]>;
+  /**
+   * For each `update`/`delete` entry, attach `prevData` (consumed by the
+   * invalidator) and `expectedCommitTs` (the CAS fence).
+   *
+   * `expectedCommitTs` is preferentially copied from a prior point-read of
+   * the same row in `readSet` — that's the value the handler's logic
+   * actually depended on, so the CAS check enforces beginTs-level isolation
+   * for read-then-update patterns. If no prior read exists ("blind"
+   * write), we fall back to the value observed in this batch fetch (weak
+   * OCC, sufficient for writes that don't depend on prior state).
+   *
+   * `prevData` always comes from this batch fetch (SELECT * per table) so
+   * the invalidator has the full row regardless of which columns the
+   * handler's read selected.
+   *
+   * If the target row no longer exists at fetch time, `expectedCommitTs`
+   * is left undefined and the per-row CAS will match nothing — surfaced
+   * as OccConflictError.
+   */
+  attachPrevDataToWriteSet(writeSet: WriteEntry[], readSet: ReadEntry[]): Promise<void>;
+}
+interface TxDatabase extends Database {
+  begin(): Promise<void>;
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+  release(): void;
+}
+interface JsonOpOptions$1 {
+  /**
+   * When true, the bound `value` parameter is treated as already prepared
+   * for the underlying SQL (e.g. a literal JSON path string for
+   * jsonHasKey, a JSON-encoded literal for the contains family). When
+   * false/omitted, the value was prepared client-side from a JS value.
+   */
+  raw?: boolean;
+  /**
+   * 1-based positional index of an extra bound parameter holding a
+   * jsonpath that scopes the contains-family check to a sub-document of
+   * the target column. When omitted, the check runs against the whole
+   * column value.
+   */
+  pathIndex?: number;
+  /**
+   * jsonHasKey only: when set, multiple path parameters are bound starting
+   * at `paramIndex`, and the predicate evaluates whether any (`one`) or
+   * every (`all`) path exists in the column.
+   */
+  mode?: "one" | "all";
+  /** Number of bound path parameters in multi-path mode. */
+  pathCount?: number;
+}
+interface SqlBuilder {
+  placeholder(index: number): string;
+  like(col: string, paramIndex: number): string;
+  ilike(col: string, paramIndex: number): string;
+  icontains(col: string, paramIndex: number): string;
+  /** PG @> ; MySQL JSON_CONTAINS */
+  jsonContains(col: string, paramIndex: number, opts?: JsonOpOptions$1): string;
+  /** PG <@ ; MySQL JSON_CONTAINS(candidate, target) */
+  jsonContainedBy(col: string, paramIndex: number, opts?: JsonOpOptions$1): string;
+  /**
+   * Key/path existence. With `opts.raw === true`, the bound param is a JSON
+   * path expression (PG `jsonb_path_exists`, MySQL `JSON_CONTAINS_PATH`).
+   * Otherwise the bound param is a literal top-level key (PG `?`, MySQL
+   * `JSON_CONTAINS_PATH($."<key>")` with server-side quoting).
+   * With `opts.pathCount` set, emits the multi-path form keyed by `mode`.
+   */
+  jsonHasKey(col: string, paramIndex: number, opts?: JsonOpOptions$1): string;
+  /** Array membership: target array contains the given element. */
+  jsonArrayContains(col: string, paramIndex: number, opts?: JsonOpOptions$1): string;
+}
+declare class LazyCommitTsParam {
+  value: unknown;
+  constructor(value: unknown);
+  toPostgres(prepareValue: (value: any) => any): any;
+  toString(): any;
+  validate(): void;
+}
+//#endregion
+//#region src/db/schema.d.ts
+interface ColumnCodec<TData = unknown, TDriver = unknown> {
+  encode?: (value: TData) => TDriver;
+  decode?: (value: TDriver) => TData;
+}
+type SchemaCodecField<TSchema extends ZodRawShape, K extends PropertyKey> = K extends keyof TSchema ? TSchema[K] extends z$1.ZodTypeAny ? z$1.infer<TSchema[K]> : unknown : K extends keyof BaseSchema ? BaseSchema[K] extends z$1.ZodTypeAny ? z$1.infer<BaseSchema[K]> : unknown : unknown;
+type SchemaCodecs<TSchema extends ZodRawShape> = Partial<{ [K in keyof (TSchema & BaseSchema)]: ColumnCodec<SchemaCodecField<TSchema, K>, any> }>;
+interface SchemaColumnsOptions<TSchema extends ZodRawShape = ZodRawShape> {
+  codecs?: SchemaCodecs<TSchema>;
+}
+interface SchemaColumnMapping {
+  [key: string]: string;
+}
+interface DeclarativeIndex {
+  name: string;
+  columns: string[];
+  unique?: boolean;
+  type?: "btree" | "hash" | "gin" | "gist" | "spgist" | "brin";
+  where?: string;
+  using?: string;
+  options?: string;
+  tablespace?: string;
+}
+type IndexDefinition = string | DeclarativeIndex;
+interface DefineSchemaConfig<TSchema extends ZodRawShape> {
+  name: string;
+  schema: TSchema;
+  options?: SchemaColumnsOptions<TSchema>;
+  columns?: SchemaColumnMapping;
+  indexes?: IndexDefinition[];
+}
+type CodecDataType<TCodec, TFallback> = [TCodec] extends [undefined] ? TFallback : TCodec extends {
+  decode: (...args: any[]) => infer TDecoded;
+} ? TDecoded : TCodec extends ColumnCodec<infer TData, unknown> ? TData : TFallback;
+type ZodOutput<TZod> = [TZod] extends [undefined] ? unknown : TZod extends z$1.ZodTypeAny ? z$1.infer<TZod> : unknown;
+type ComputedDataType<TCodec, TZod> = CodecDataType<TCodec, ZodOutput<TZod>>;
+type ComputedCodec<TData, TDriver> = ColumnCodec<TData, TDriver>;
+type OverrideField<TObj, TKey extends PropertyKey, TValue> = Omit<TObj, TKey> & { [K in TKey]: TValue };
+interface ComputedFieldConfig<TField extends string, TDecoded = unknown, TDriver = unknown, TZodType extends z$1.ZodTypeAny | undefined = undefined> {
+  field: TField;
+  sql: string;
+  alias?: string;
+  type?: TZodType;
+  codec?: {
+    decode: (value: TDriver) => TDecoded;
+    encode?: (value: TDecoded) => TDriver;
+  };
+}
+type ComputedField = {
+  field: string;
+  sql: string;
+  alias: string;
+  codec?: ColumnCodec<any, any>;
+};
+declare function defineComputedField<TField extends string, TDecoded = unknown, TDriver = unknown, TZodType extends z$1.ZodTypeAny | undefined = undefined>(config: ComputedFieldConfig<TField, TDecoded, TDriver, TZodType>): ComputedFieldConfig<TField, TDecoded, TDriver, TZodType>;
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type ApplySchemaCodecs<TBase, TCodecs> = { [K in keyof TBase]: K extends keyof TCodecs ? CodecDataType<TCodecs[K], TBase[K]> : TBase[K] };
+type ResolveSchemaType<TSchema extends ZodRawShape, TOptions extends SchemaColumnsOptions<TSchema>> = TOptions extends {
+  codecs: infer TCodecs;
+} ? Prettify<ApplySchemaCodecs<z$1.infer<z$1.ZodObject<TSchema & BaseSchema>>, TCodecs>> : Prettify<z$1.infer<z$1.ZodObject<TSchema & BaseSchema>>>;
+type IsOptionalField<T> = T extends z$1.ZodOptional<any> ? true : T extends z$1.ZodNullable<any> ? true : T extends z$1.ZodDefault<any> ? true : false;
+type OptionalKeys<TZod extends ZodRawShape> = { [K in keyof TZod]: IsOptionalField<TZod[K]> extends true ? K : never }[keyof TZod];
+type RequiredKeys<TZod extends ZodRawShape> = { [K in keyof TZod]: IsOptionalField<TZod[K]> extends true ? never : K }[keyof TZod];
+type BaseSchema = {
+  id: z$1.ZodString;
+  commitTs: z$1.ZodCoercedBigInt;
+};
+declare const schemaRegistry: Map<string, SchemaDefinition<string, any, any>>;
+declare let shouldTrackSchema: boolean;
+declare function trackSchema(): void;
+declare function defineSchema<TSchema extends ZodRawShape, TName extends string, TOptions extends SchemaColumnsOptions<TSchema> = SchemaColumnsOptions<TSchema>>(config: DefineSchemaConfig<TSchema> & {
+  name: TName;
+  options?: TOptions;
+}): SchemaDefinition<TName, Prettify<TSchema & BaseSchema>, ResolveSchemaType<TSchema, TOptions>>;
+declare function tableNameToId(tableName: string): Uint8Array;
+interface StoredSchemaColumnsOptions {
+  codecs?: Record<string, ColumnCodec<any, any>>;
+}
+interface SchemaDefinition<TTable extends string, TZod extends ZodRawShape, TData = z$1.infer<z$1.ZodObject<TZod>>> {
+  tableId: Uint8Array;
+  table: TTable;
+  schema: z$1.ZodObject<TZod>;
+  columnsOptions: StoredSchemaColumnsOptions;
+  columns: Record<string, string>;
+  indexes: IndexDefinition[];
+  _dataType?: TData;
+}
+type InferSchema<T extends SchemaDefinition<string, ZodRawShape, any>> = T extends SchemaDefinition<string, ZodRawShape, infer TData> ? TData : never;
+type InsertData<T extends SchemaDefinition<string, ZodRawShape, any>> = T extends SchemaDefinition<string, infer TZod, infer TData> ? { [K in RequiredKeys<TZod> as K extends "id" | "commitTs" ? never : K]: Extract<K, string> extends keyof TData ? TData[Extract<K, string>] : never } & { [K in OptionalKeys<TZod> as K extends "id" | "commitTs" ? never : K]?: Extract<K, string> extends keyof TData ? TData[Extract<K, string>] : never } : never;
+interface Model {
+  table: string;
+  tableId: Uint8Array;
+  columns: Record<string, string>;
+  reverseColumns: Record<string, string>;
+  types: Record<string, string>;
+  codecs: Record<string, ColumnCodec<any, any>>;
+}
+type MaybePromise<T> = T | Promise<T>;
+type ReturnLiveQuery<TLiveQueryFn extends (...args: any[]) => MaybePromise<LiveQueryHandle<any>>> = Awaited<ReturnType<TLiveQueryFn>> extends LiveQueryHandle<infer T> ? T : never;
+type ReturnQuery<TQueryFn extends (...args: any[]) => any> = Awaited<ReturnType<TQueryFn>>;
+type QueryArgs<TQueryFn extends (...args: any[]) => any> = Parameters<TQueryFn>[0];
+type MutationArgs<TMutationFn extends (...args: any[]) => any> = Parameters<TMutationFn>[0];
+type ActionArgs<TActionFn extends (...args: any[]) => any> = Parameters<TActionFn>[0];
+//#endregion
+//#region src/db/query.d.ts
+type FieldValue<S extends SchemaDefinition<string, ZodRawShape>, K> = K extends keyof InferSchema<S> ? InferSchema<S>[K] : never;
+type OrderableValue = number | bigint | string | Date;
+type StringFieldKeys<S extends SchemaDefinition<string, ZodRawShape>> = { [K in keyof InferSchema<S>]: NonNullable<InferSchema<S>[K]> extends string ? K : never }[keyof InferSchema<S>];
+type OrderableFieldKeys<S extends SchemaDefinition<string, ZodRawShape>> = { [K in keyof InferSchema<S>]: NonNullable<InferSchema<S>[K]> extends OrderableValue ? K : never }[keyof InferSchema<S>];
+type JsonFieldKeys<S extends SchemaDefinition<string, ZodRawShape>> = { [K in keyof InferSchema<S>]: NonNullable<InferSchema<S>[K]> extends OrderableValue ? never : NonNullable<InferSchema<S>[K]> extends boolean ? never : NonNullable<InferSchema<S>[K]> extends (object | unknown[]) ? K : unknown extends NonNullable<InferSchema<S>[K]> ? K : never }[keyof InferSchema<S>];
+interface JsonOpOptions {
+  /**
+   * Skip client-side preparation of the value (no JSON-stringify, no key
+   * escaping). The caller is responsible for the exact form the dialect
+   * expects: a JSON path string for jsonHasKey, a JSON-encoded string for
+   * the contains family.
+   */
+  raw?: true;
+}
+interface JsonContainsOptions extends JsonOpOptions {
+  /**
+   * Sub-path into the target JSON to scope the check to. `string` is a
+   * single literal top-level key; `string[]` is a nested literal-key path
+   * compiled to `$."a"."b"`. Mutually exclusive with `pathRaw`.
+   */
+  path?: string | string[];
+  /**
+   * Raw jsonpath expression used verbatim by the dialect (PG `jsonpath`,
+   * MySQL JSON path). Mutually exclusive with `path`.
+   */
+  pathRaw?: string;
+}
+interface JsonHasKeyMultiOptions extends JsonOpOptions {
+  /** Required for the multi-path overload — chooses any vs every. */
+  mode: "one" | "all";
+}
+declare class QueryBuilder<S extends SchemaDefinition<string, ZodRawShape>> {
+  protected ctx: TxContext;
+  protected model: Model;
+  constructor(ctx: TxContext, model: Model);
+  protected getColumnName(key: string): string;
+  select(): SelectQueryBuilder<S, keyof InferSchema<S>>;
+  select<K extends keyof InferSchema<S>>(...columns: K[]): SelectQueryBuilder<S, K>;
+}
+type IdAndCommitTs = {
+  id: string;
+  commitTs: bigint;
+};
+type SelectRow<S extends SchemaDefinition<string, ZodRawShape>, K extends keyof InferSchema<S>, C extends Record<string, unknown>> = Prettify<Pick<InferSchema<S>, Extract<K | "id" | "commitTs", keyof InferSchema<S>>> & C>;
+declare class SelectQueryBuilder<S extends SchemaDefinition<string, ZodRawShape>, K extends keyof InferSchema<S> = never, C extends Record<string, unknown> = {}> {
+  private ctx;
+  private model;
+  private filters;
+  private orderByClause;
+  private limitVal;
+  private offsetVal;
+  private selectedProps;
+  private computedFields;
+  private commentStr;
+  constructor(ctx: TxContext, model: Model, filters?: ((fb: FilterBuilder<S>) => void)[], orderByClause?: string | null, limitVal?: number | null, offsetVal?: number | null, selectedProps?: (keyof InferSchema<S>)[], computedFields?: ComputedField[], commentStr?: string);
+  private getColumnName;
+  private getPropertyName;
+  private mapRowToSchema;
+  where(filterFn: (fb: FilterBuilder<S>) => void): SelectQueryBuilder<S, K, C>;
+  orderBy(column: keyof InferSchema<S> | keyof C, direction?: "asc" | "desc"): SelectQueryBuilder<S, K, C>;
+  limit(n: number): SelectQueryBuilder<S, K, C>;
+  offset(n: number): SelectQueryBuilder<S, K, C>;
+  computed<TField extends string, TZodType extends z$1.ZodTypeAny | undefined = undefined, TDecode extends (value: any) => any = (value: unknown) => unknown>(config: ComputedFieldConfig<TField, ReturnType<TDecode>, Parameters<TDecode>[0], TZodType> & {
+    codec: {
+      decode: TDecode;
+      encode?: (value: ReturnType<TDecode>) => Parameters<TDecode>[0];
+    };
+  }): SelectQueryBuilder<S, K | TField, OverrideField<C, TField, ComputedDataType<ComputedCodec<ReturnType<TDecode>, Parameters<TDecode>[0]>, TZodType>>>;
+  computed<TField extends string, TZodType extends z$1.ZodTypeAny | undefined = undefined>(config: ComputedFieldConfig<TField, unknown, unknown, TZodType> & {
+    codec?: undefined;
+  }): SelectQueryBuilder<S, K | TField, OverrideField<C, TField, ComputedDataType<undefined, TZodType>>>;
+  comment(input: string | Record<string, string>): SelectQueryBuilder<S, K, C>;
+  first(): Promise<SelectRow<S, K, C> | null>;
+  exists(): Promise<boolean>;
+  private static defaultCountType;
+  count(): Promise<number>;
+  count<T extends z$1.ZodType>(parser: T): Promise<z$1.output<T>>;
+  find(id: string): Promise<SelectRow<S, K, C> | null>;
+  get(): Promise<SelectRow<S, K, C>[]>;
+  private buildPredicate;
+}
+declare class FilterBuilder<S extends SchemaDefinition<string, ZodRawShape>> {
+  private columns;
+  private codecs;
+  predicates: Predicate[];
+  constructor(columns: Record<string, string>, codecs: Record<string, ColumnCodec<unknown, unknown>>);
+  private add;
+  private addJsonContains;
+  private getColumnName;
+  private encode;
+  private encodeJson;
+  eq<K extends keyof InferSchema<S>>(key: K, value: FieldValue<S, K>): FilterBuilder<S>;
+  neq<K extends keyof InferSchema<S>>(key: K, value: FieldValue<S, K>): FilterBuilder<S>;
+  gt<K extends OrderableFieldKeys<S>>(key: K, value: FieldValue<S, K>): FilterBuilder<S>;
+  gte<K extends OrderableFieldKeys<S>>(key: K, value: FieldValue<S, K>): FilterBuilder<S>;
+  lt<K extends OrderableFieldKeys<S>>(key: K, value: FieldValue<S, K>): FilterBuilder<S>;
+  lte<K extends OrderableFieldKeys<S>>(key: K, value: FieldValue<S, K>): FilterBuilder<S>;
+  like<K extends StringFieldKeys<S>>(key: K, pattern: string): FilterBuilder<S>;
+  ilike<K extends StringFieldKeys<S>>(key: K, pattern: string): FilterBuilder<S>;
+  contains<K extends StringFieldKeys<S>>(key: K, value: string): FilterBuilder<S>;
+  icontains<K extends StringFieldKeys<S>>(key: K, value: string): FilterBuilder<S>;
+  /**
+   * JSON containment. Targets a JSON/JSONB column and asserts the document
+   * contains the given candidate (object-key subset for objects,
+   * element-subset for arrays — see dialect-specific docs for edge cases).
+   * Pass `{ raw: true }` if `value` is already a JSON-encoded string.
+   * Pass `{ path: ... }` to scope the check to a sub-document of the
+   * target (jsonb_path_query_first on PG, JSON_CONTAINS path arg on MySQL).
+   */
+  jsonContains<K extends JsonFieldKeys<S>>(key: K, value: unknown, opts?: JsonContainsOptions): FilterBuilder<S>;
+  /** Inverse of {@link jsonContains}: column is contained in the given value. */
+  jsonContainedBy<K extends JsonFieldKeys<S>>(key: K, value: unknown, opts?: JsonContainsOptions): FilterBuilder<S>;
+  /**
+   * Key/path existence check on a JSON column.
+   *
+   * - String form (top-level key): `jsonHasKey("meta", "color")`. On PG
+   *   also matches when the column is a string array and `value` is one of
+   *   its elements (PG `?` semantics); MySQL stays strict to object keys.
+   * - Array form (nested path): `jsonHasKey("meta", ["a", "b"])` compiles
+   *   to a path expression `$."a"."b"` on both dialects.
+   * - Raw form: `jsonHasKey("meta", "$.foo[*]", { raw: true })` passes the
+   *   string through as a dialect path expression (PG `jsonb_path_exists`
+   *   jsonpath, MySQL `JSON_CONTAINS_PATH`). Caller owns the syntax.
+   * - Multi-path form: `jsonHasKey("meta", [["a","b"], "color"], { mode: "all" })`
+   *   compiles each entry to a jsonpath and emits PG OR/AND of
+   *   `jsonb_path_exists` or MySQL `JSON_CONTAINS_PATH('all', ...)`.
+   */
+  jsonHasKey<K extends JsonFieldKeys<S>>(key: K, value: string): FilterBuilder<S>;
+  jsonHasKey<K extends JsonFieldKeys<S>>(key: K, value: string[]): FilterBuilder<S>;
+  jsonHasKey<K extends JsonFieldKeys<S>>(key: K, value: string, opts: {
+    raw: true;
+  }): FilterBuilder<S>;
+  jsonHasKey<K extends JsonFieldKeys<S>>(key: K, paths: (string | string[])[], opts: JsonHasKeyMultiOptions): FilterBuilder<S>;
+  jsonHasKey<K extends JsonFieldKeys<S>>(key: K, paths: string[], opts: JsonHasKeyMultiOptions & {
+    raw: true;
+  }): FilterBuilder<S>;
+  /**
+   * Array element containment: target column is a JSON array; the given
+   * `value` (any JSON-encodable type) must appear as one of its elements.
+   * Pass `{ raw: true }` if `value` is already a JSON-encoded string.
+   * Pass `{ path: ... }` to scope the check to a sub-array of the column.
+   */
+  jsonArrayContains<K extends JsonFieldKeys<S>>(key: K, value: unknown, opts?: JsonContainsOptions): FilterBuilder<S>;
+  between<K extends OrderableFieldKeys<S>>(key: K, lo: FieldValue<S, K>, hi: FieldValue<S, K>): FilterBuilder<S>;
+  isNull<K extends keyof InferSchema<S>>(key: K): FilterBuilder<S>;
+  notNull<K extends keyof InferSchema<S>>(key: K): FilterBuilder<S>;
+  /**
+   * Compose an OR clause. Each callback fills a fresh sub-FilterBuilder
+   * with predicates that are AND-ed together within that branch; the
+   * branches themselves are OR-ed. Example:
+   *   f.or([
+   *     b => b.eq("tag", "a"),
+   *     b => b.eq("tag", "b").gt("qty", 3),  // (tag=b AND qty>3)
+   *   ])
+   * produces  (tag=a) OR (tag=b AND qty>3).
+   */
+  or(branches: ((fb: FilterBuilder<S>) => void)[]): FilterBuilder<S>;
+}
+declare function buildPredicateSql(predicate: Predicate, params: unknown[], sql: SqlBuilder): string;
+declare function matchesPredicate(row: Record<string, unknown>, predicate: Predicate): boolean;
+declare function jsonContains(target: unknown, candidate: unknown): boolean;
+declare function jsonPathExtract(val: unknown, path: string): unknown;
+declare function jsonPathExists(val: unknown, path: string): boolean;
+//#endregion
+//#region src/db/context.d.ts
+declare class TxContext {
+  readonly beginTs: bigint;
+  readonly db: Database;
+  protected readSet: ReadEntry[];
+  protected writeSet: WriteEntry[];
+  private models;
+  protected getOrCreateModel(schema: SchemaDefinition<string, ZodRawShape>): Model;
+  constructor(db: Database, beginTs: bigint);
+  internalGetReadSet(): ReadEntry[];
+  internalGetWriteSet(): WriteEntry[];
+  protected findPendingWrite(table: string, id: string): WriteEntry | undefined;
+  protected findPendingInsert(table: string, id: string): WriteEntry | undefined;
+  protected encodeWithCodec(model: Model, property: string, value: unknown): unknown;
+}
+declare class DbReader extends TxContext {
+  query<S extends SchemaDefinition<string, ZodRawShape>>(schema: S): QueryBuilder<S>;
+}
+declare class DbWriter extends DbReader {
+  insert<S extends SchemaDefinition<string, ZodRawShape>, ID extends string>(schema: S, id: ID, data: InsertData<S>): Promise<void>;
+  update<S extends SchemaDefinition<string, ZodRawShape>, ID extends string>(schema: S, id: ID, data: Partial<Omit<InferSchema<S>, "id" | "commitTs">>): Promise<void>;
+  delete<S extends SchemaDefinition<string, ZodRawShape>, ID extends string>(schema: S, id: ID): Promise<void>;
+}
+//#endregion
+//#region src/db/query_definition.d.ts
+/**
+ * A named, typed query definition produced by defineQuery().
+ * Carries the query function at runtime and the name/params/result types
+ * at compile time — making it the single source of truth for both the
+ * server-side registry and the client-side RPC.
+ */
+interface QueryDefinition<TName extends string, TParams, TResult> {
+  readonly _type: "QueryDefinition";
+  readonly name: TName;
+  readonly fn: (ctx: DbReader, params: TParams) => Promise<TResult>;
+}
+type AnyQueryDef = QueryDefinition<string, any, any>;
+/** Extract the params type from a QueryDefinition. */
+type ParamsOf<D extends AnyQueryDef> = D extends QueryDefinition<any, infer P, any> ? P : never;
+/** Extract the result type from a QueryDefinition. */
+type ResultOf<D extends AnyQueryDef> = D extends QueryDefinition<any, any, infer R> ? R : never;
+/**
+ * Convert a readonly tuple of QueryDefinitions into a Record keyed by their
+ * name literals. This is what makes ClientRpc fully type-safe: each key in
+ * the map carries its own TParams and TResult rather than collapsing to `any`.
+ *
+ * Example:
+ *   const defs = [projectBoardQuery, teamMembersQuery] as const;
+ *   type Map = DefsToMap<typeof defs>;
+ *   // → { projectBoard: typeof projectBoardQuery; teamMembers: typeof teamMembersQuery }
+ */
+type DefsToMap<T extends readonly AnyQueryDef[]> = { [D in T[number] as D["name"]]: D };
+/** For test teardown only — clears the global map between suites. */
+declare function _resetGlobalDefs(): void;
+/**
+ * Create a named, typed query definition.
+ *
+ * The definition is automatically registered in a module-level global so
+ * the server can call registry.defineAll() instead of listing every query
+ * explicitly. On the client, pass the definition to createClientRpc() to
+ * get a fully typed subscribe() call.
+ *
+ * Usage:
+ *   export const projectBoardQuery = defineQuery(
+ *     "projectBoard",
+ *     async (ctx, params: { projectId: string }) => {
+ *       return ctx.query(Tasks)
+ *         .select()
+ *         .where(f => f.eq("projectId", params.projectId))
+ *         .get();
+ *     }
+ *   );
+ */
+declare function defineQuery<TName extends string, TParams, TResult>(name: TName, fn: (ctx: DbReader, params: TParams) => Promise<TResult>): QueryDefinition<TName, TParams, TResult>;
+//#endregion
+//#region src/db/realtime_db.d.ts
+declare class SupaliveDb {
+  readonly impl: Database;
+  constructor(impl: Database);
+  static create(config: {
+    db: Database;
+  }): SupaliveDb;
+  protected onAfterCommit?: (writeSet: WriteEntry[], commitTs: CommitTs) => void;
+  query<T>(fn: (ctx: DbReader) => Promise<T>): Promise<T>;
+  liveQuery<T>(fn: (ctx: DbReader) => Promise<T>): Promise<LiveResult<T>>;
+  mutation<T>(fn: (ctx: DbWriter) => Promise<T>, retryPolicy?: RetryPolicy): Promise<MutationResult<T>>;
+}
+declare const sleep: (ms: number) => Promise<void>;
+//#endregion
+//#region src/router/procedure.d.ts
+/**
+ * Query context passed to query handlers.
+ * Contains database reader and user-defined server context.
+ */
+interface QueryCtx<TContext = unknown> {
+  /** Database reader for queries */
+  db: DbReader;
+  /** User-defined server context (auth, requestId, etc.) */
+  serverCtx?: TContext;
+}
+/**
+ * Mutation context passed to mutation handlers.
+ * Contains database writer and user-defined server context.
+ */
+interface MutationCtx<TContext = unknown> {
+  /** Database writer for mutations (includes insert/update/delete) */
+  db: DbWriter;
+  /** User-defined server context (auth, requestId, etc.) */
+  serverCtx?: TContext;
+}
+/**
+ * Action context passed to action handlers.
+ * Contains the full SupaliveDb for both queries and mutations, plus user-defined server context.
+ */
+interface ActionCtx<TContext = unknown> {
+  /** Full database interface for queries and mutations */
+  db: SupaliveDb;
+  /** User-defined server context (auth, requestId, etc.) */
+  serverCtx?: TContext;
+}
+type QueryFn<TInput, TResult, TContext = unknown> = (ctx: QueryCtx<TContext>, input: TInput) => Promise<TResult>;
+type MutationFn<TInput, TResult, TContext = unknown> = (ctx: MutationCtx<TContext>, input: TInput) => Promise<TResult>;
+type ActionFn<TInput, TResult, TContext = unknown> = (ctx: ActionCtx<TContext>, input: TInput) => Promise<TResult>;
+/**
+ * Per-procedure override for the cache/subscription segmentation key.
+ *
+ *   omitted | undefined  → fall back to `config.getUserId(serverCtx)` (default)
+ *   false               → no identity in hash; cache/sub shared across all users
+ *   string              → a static identity literal (e.g. "public" or a tenant id)
+ *   function            → compute from serverCtx + input (sync)
+ *
+ * When the result of a query is identical regardless of who calls it, set
+ * this to a literal (or `false`) so a single cache entry serves everyone.
+ *
+ * The function form intentionally takes `serverCtx` (not the full `QueryCtx`)
+ * because identity is resolved before any DB read is issued.
+ */
+type QueryIdentitySpec<TInput, TContext> = false | string | ((serverCtx: TContext, input: TInput) => string | null | undefined);
+interface BaseProcedure<TInput, TResult, TType extends "query" | "mutation" | "action", TContext = unknown, TInternal extends boolean = boolean> {
+  readonly _type: "procedure";
+  readonly procedureType: TType;
+  readonly inputSchema: ZodType<TInput>;
+  readonly fn: QueryFn<TInput, TResult, TContext> | MutationFn<TInput, TResult, TContext> | ActionFn<TInput, TResult, TContext>;
+  readonly internal: TInternal;
+}
+interface QueryProcedure<TInput, TResult, TContext = unknown, TInternal extends boolean = boolean> extends BaseProcedure<TInput, TResult, "query", TContext, TInternal> {
+  readonly procedureType: "query";
+  readonly fn: QueryFn<TInput, TResult, TContext>;
+  readonly queryIdentity?: QueryIdentitySpec<TInput, TContext>;
+}
+interface MutationProcedure<TInput, TResult, TContext = unknown, TInternal extends boolean = boolean> extends BaseProcedure<TInput, TResult, "mutation", TContext, TInternal> {
+  readonly procedureType: "mutation";
+  readonly fn: MutationFn<TInput, TResult, TContext>;
+}
+interface ActionProcedure<TInput, TResult, TContext = unknown, TInternal extends boolean = boolean> extends BaseProcedure<TInput, TResult, "action", TContext, TInternal> {
+  readonly procedureType: "action";
+  readonly fn: ActionFn<TInput, TResult, TContext>;
+}
+type AnyProcedure<TContext = unknown> = QueryProcedure<any, any, TContext> | MutationProcedure<any, any, TContext> | ActionProcedure<any, any, TContext>;
+interface QueryConfig<TInput, TResult, TContext = unknown> {
+  /** Zod schema for input validation */
+  args: ZodType<TInput>;
+  /** The query handler function */
+  handler: QueryFn<TInput, TResult, TContext>;
+  /** Mark as internal (server-only). Default: false */
+  internal?: boolean;
+  /**
+   * Override the cache/subscription segmentation key for this procedure.
+   * See {@link QueryIdentitySpec}. Omit to keep the default (per-user) behavior.
+   */
+  queryIdentity?: QueryIdentitySpec<TInput, TContext>;
+}
+interface MutationConfig<TInput, TResult, TContext = unknown> {
+  /** Zod schema for input validation */
+  args: ZodType<TInput>;
+  /** The mutation handler function */
+  handler: MutationFn<TInput, TResult, TContext>;
+  /** Mark as internal (server-only). Default: false */
+  internal?: boolean;
+}
+interface ActionConfig<TInput, TResult, TContext = unknown> {
+  /** Zod schema for input validation */
+  args: ZodType<TInput>;
+  /** The action handler function */
+  handler: ActionFn<TInput, TResult, TContext>;
+  /** Mark as internal (server-only). Default: false */
+  internal?: boolean;
+}
+/** Extract input type from a procedure */
+type InputOf<T> = T extends BaseProcedure<infer I, any, any, any> ? I : never;
+/** Extract output type from a procedure */
+type OutputOf<T> = T extends BaseProcedure<any, infer O, any, any> ? O : never;
+/** Extract procedure type (query/mutation) */
+type TypeOf<T> = T extends BaseProcedure<any, any, infer Type, any> ? Type : never;
+/** Extract server context type from a procedure */
+type ContextOf<T> = T extends BaseProcedure<any, any, any, infer C> ? C : never;
+/**
+ * Create a query builder with a pre-defined context type.
+ * This allows you to define the context type once and have it inferred
+ * automatically in all your query handlers.
+ *
+ * @example
+ * // Define your server context
+ * interface ServerContext {
+ *   auth: { userId: string };
+ *   requestId: string;
+ * }
+ *
+ * // Create a typed query builder
+ * const query = createQueryBuilder<ServerContext>();
+ *
+ * // Use it - context type is automatically inferred!
+ * const getUser = query({
+ *   args: z.object({ id: z.string() }),
+ *   handler: async (ctx, { id }) => {
+ *     // ctx.db for database queries
+ *     const user = await ctx.db.query(UsersSchema).find(id);
+ *     // ctx.context for server context
+ *     console.log(ctx.context.requestId);
+ *     return user;
+ *   }
+ * });
+ */
+declare function createQueryBuilder<TContext = unknown>(): <TInput, TResult, const TInternal extends boolean = false>(config: QueryConfig<TInput, TResult, TContext> & {
+  internal?: TInternal;
+}) => QueryProcedure<TInput, TResult, TContext, TInternal>;
+/**
+ * Create a mutation builder with a pre-defined context type.
+ * This allows you to define the context type once and have it inferred
+ * automatically in all your mutation handlers.
+ *
+ * @example
+ * // Define your server context
+ * interface ServerContext {
+ *   auth: { userId: string };
+ *   requestId: string;
+ * }
+ *
+ * // Create a typed mutation builder
+ * const mutation = createMutationBuilder<ServerContext>();
+ *
+ * // Use it - context type is automatically inferred!
+ * const createUser = mutation({
+ *   args: z.object({ name: z.string() }),
+ *   handler: async (ctx, { name }) => {
+ *     // ctx.db for mutations
+ *     await ctx.db.insert(UsersSchema, id, { name });
+ *     // ctx.context for server context
+ *     console.log(ctx.context.requestId);
+ *     return { success: true };
+ *   }
+ * });
+ */
+declare function createMutationBuilder<TContext = unknown>(): <TInput, TResult, const TInternal extends boolean = false>(config: MutationConfig<TInput, TResult, TContext> & {
+  internal?: TInternal;
+}) => MutationProcedure<TInput, TResult, TContext, TInternal>;
+/**
+ * Create an action builder with a pre-defined context type.
+ * Actions have access to the full SupaliveDb for both queries and mutations.
+ *
+ * @example
+ * // Define your server context
+ * interface ServerContext {
+ *   auth: { userId: string };
+ *   requestId: string;
+ * }
+ *
+ * // Create a typed action builder
+ * const action = createActionBuilder<ServerContext>();
+ *
+ * // Use it - context type is automatically inferred!
+ * const processOrder = action({
+ *   args: z.object({ orderId: z.string() }),
+ *   handler: async (ctx, { orderId }) => {
+ *     // ctx.db for full database access
+ *     const order = await ctx.db.query(async (db) => {
+ *       return db.query(OrdersSchema).find(orderId);
+ *     });
+ *     await ctx.db.mutation(async (db) => {
+ *       await db.update(OrdersSchema, orderId, { status: "processed" });
+ *     });
+ *     // ctx.context for server context
+ *     console.log(ctx.context.requestId);
+ *     return { success: true };
+ *   }
+ * });
+ */
+declare function createActionBuilder<TContext = unknown>(): <TInput, TResult, const TInternal extends boolean = false>(config: ActionConfig<TInput, TResult, TContext> & {
+  internal?: TInternal;
+}) => ActionProcedure<TInput, TResult, TContext, TInternal>;
+//#endregion
+//#region src/router/router.d.ts
+/**
+ * A router maps procedure names (keys) to their definitions.
+ * This is the type that's exported from your app and used by the client.
+ */
+type Router<TProcedures extends Record<string, AnyProcedure<TContext>>, TContext = unknown> = {
+  _type: "router";
+  procedures: TProcedures;
+  contextName: string;
+};
+/**
+ * Inferred AppRouter type from router() call.
+ * Captures the full procedure map for client type inference.
+ */
+type AppRouter<TProcedures extends Record<string, AnyProcedure<TContext>> = Record<string, AnyProcedure>, TContext = unknown> = Router<TProcedures, TContext>;
+/** Get query procedures only from a router */
+type QueryProcedures<T extends Record<string, AnyProcedure>> = { [K in keyof T as T[K] extends {
+  procedureType: "query";
+} ? K : never]: T[K] };
+/** Get mutation procedures only from a router */
+type MutationProcedures<T extends Record<string, AnyProcedure>> = { [K in keyof T as T[K] extends {
+  procedureType: "mutation";
+} ? K : never]: T[K] };
+/** Get action procedures only from a router */
+type ActionProcedures<T extends Record<string, AnyProcedure>> = { [K in keyof T as T[K] extends {
+  procedureType: "action";
+} ? K : never]: T[K] };
+/** Get public (non-internal) procedures - for client type safety */
+type PublicProcedures<T extends Record<string, AnyProcedure>> = Pick<T, { [K in keyof T]: T[K] extends {
+  internal: true;
+} ? never : K }[keyof T]>;
+/** Extract procedure names from a router */
+type ProcedureNames<T extends Router<any>> = T extends Router<infer P> ? keyof P : never;
+type RouterConfig<T> = {
+  procedures: T;
+  contextName?: string;
+};
+/**
+* Create a router from procedure definitions.
+* Procedure names are inferred from the object keys.
+*
+* @example
+* const appRouter = router({
+*   procedures: {
+*     getUser,
+*     createUser,
+*     internalGetAll,
+*   },
+* });
+*
+* export type AppRouter = typeof appRouter;
+*/
+declare function router<TProcedures extends Record<string, AnyProcedure<any>>, TContext = unknown>(config: RouterConfig<TProcedures>): Router<TProcedures, TContext>;
+interface RegisteredProcedure<TContext = unknown> {
+  name: string;
+  type: "query" | "mutation" | "action";
+  internal: boolean;
+  inputSchema: AnyProcedure<TContext>["inputSchema"];
+  fn: AnyProcedure<TContext>["fn"];
+  /** Only present for `type === "query"`. See `QueryIdentitySpec`. */
+  queryIdentity?: false | string | ((serverCtx: TContext | undefined, input: unknown) => string | null | undefined);
+}
+declare function getContextRegistry(inContext: string): ContextRegistry;
+declare class ContextRegistry {
+  procedureRegistry: Map<string, RegisteredProcedure<any>>;
+  internalProcedureNames: Set<string>;
+  registerProcedure<TContext>(name: string, proc: AnyProcedure<TContext>): void;
+  /** Get a registered procedure by name (runtime lookup) */
+  getProcedure<TContext = unknown>(name: string): RegisteredProcedure<TContext> | undefined;
+  /** Get all registered procedure names */
+  getProcedureNames(): string[];
+  /** Get all registered procedures */
+  getAllProcedures(): Map<string, RegisteredProcedure>;
+  /** Clear the registry (for testing only) */
+  clearRegistry(): void;
+  markInternalProcedure(name: string): void;
+  isInternalProcedure(name: string): boolean;
+  clearInternalProcedures(): void;
+}
+//#endregion
+//#region src/client/ws_client_manager.d.ts
+declare class RPCError extends Error {
+  code?: string;
+  constructor(message: string, code?: string);
+}
+interface HeartbeatOptions {
+  /**
+   * Close + reconnect when no server message arrives for this long. The
+   * server emits `{type:"ping"}` every ~15s of channel idle, so anything
+   * larger than ~30s leaves comfortable headroom. Default 60_000.
+   */
+  serverInactivityMs?: number;
+}
+interface SendThrottleOptions {
+  /** Yield the event loop every N `call()` invocations. 0 disables. Default 100. */
+  everyN?: number;
+  /** Length of the yield in ms. Default 10. */
+  delayMs?: number;
+}
+interface WSClientOptions {
+  /** WebSocket URL (e.g. ws://localhost:3000/ws) */
+  url: string;
+  /** Auth token to send after connection */
+  token?: () => Promise<string | undefined>;
+  /** Optional: reconnection timeout in ms (default: 180000 = 3 minutes) */
+  reconnectionTimeout?: number;
+  /** Reconnection options */
+  reconnect?: {
+    /** Enable automatic reconnection (default: true) */enabled?: boolean; /** Max reconnection attempts (default: 5) */
+    maxAttempts?: number; /** Delay between attempts in ms (default: 1000) */
+    delay?: number; /** Exponential backoff multiplier (default: 1.5) */
+    backoff?: number;
+  };
+  /** Server-inactivity watchdog. See {@link HeartbeatOptions.serverInactivityMs}. */
+  heartbeat?: HeartbeatOptions;
+  /**
+   * Yields the event loop for `delayMs` ms after every `everyN`
+   * `call()` invocations. Useful for keeping React renders / GC tasks
+   * scheduled during long synchronous bursts of mutations/actions; the
+   * heartbeat does not depend on this (the server drives it).
+   * Default `{ everyN: 100, delayMs: 10 }`. Set `everyN: 0` to disable.
+   */
+  throttle?: SendThrottleOptions;
+  /** Called when connection is established */
+  onConnect?: () => void;
+  /** Called when connection is lost */
+  onDisconnect?: () => void;
+  /** Called on connection error */
+  onError?: (error: Error) => void;
+}
+/**
+ * Public state of the client, surfaced to consumers (React provider, etc.).
+ * - "connecting" — initial connect or reconnect handshake in flight
+ * - "authenticating" — connected, waiting for auth result
+ * - "ready" — connected and auth resolved (authenticated, anonymous, or
+ *   explicitly failed — i.e. ready to send calls)
+ * - "disconnected" — currently offline (may auto-retry)
+ */
+type ClientPublicState = "disconnected" | "connecting" | "authenticating" | "ready";
+declare class WsClientManager {
+  private ws;
+  private options;
+  private lastSuccessfulConnectionTime;
+  private reconnectionTimeout;
+  private requestId;
+  private pendingRequests;
+  /**
+   * Single source of truth for live subscriptions.
+   *
+   * Keying:
+   *   - In-flight subscribe (no subId yet): `_pending:<requestId>`.
+   *   - Established: the server-returned canonical `subId`.
+   *
+   * Routing `sub:update` / `sub:gone` is O(1) (`get(subId)`). Subscribe-time
+   * dedup scans `values()` for a matching `localKey` (O(N)), which is cheap
+   * since subscribes happen on component mounts, not in the hot path.
+   */
+  private subscriptions;
+  private queuedCalls;
+  private reconnectAttempts;
+  private reconnectTimer;
+  private connectionState;
+  private authState;
+  /**
+   * Authenticated user id from `auth:success`. Distinct from `queryIdentity`
+   * (server-side cache/sub segmentation key); this is just "who am I logged
+   * in as" for app display purposes. Null while unauthenticated / anonymous.
+   */
+  private authUserId;
+  private explicitlyClosed;
+  private stateListeners;
+  private lastPublicState;
+  private serverInactivityMs;
+  private lastServerMessageAt;
+  private inactivityTimer;
+  private pendingConnectResolve;
+  private pendingConnectReject;
+  private throttleEveryN;
+  private throttleDelayMs;
+  private throttleCounter;
+  private throttling;
+  private visibilityListener;
+  private onlineListener;
+  constructor(options: WSClientOptions);
+  /**
+   * Subscribe to client state transitions. Returns an unsubscribe fn.
+   * The listener is called immediately with the current state.
+   */
+  onState(listener: (s: ClientPublicState) => void): () => void;
+  /** Current public state. */
+  getPublicState(): ClientPublicState;
+  /**
+   * Connect to the WebSocket server.
+   * Returns a promise that resolves when connected and authenticated.
+   */
+  connect(): Promise<void>;
+  /**
+   * Disconnect from the server.
+   */
+  disconnect(): void;
+  /**
+   * Check if connected and authenticated.
+   */
+  isReady(): boolean;
+  /**
+   * Check if authenticated.
+   */
+  isAuthenticated(): boolean;
+  /**
+   * Check if anonymouse.
+   */
+  isAnonymouse(): boolean;
+  /**
+   * The authenticated user's id (from `auth:success`), or null when
+   * unauthenticated / anonymous. Useful for "Logged in as …" display.
+   *
+   * Not to be confused with server-side `queryIdentity`, which is the
+   * cache/subscription segmentation key (resolved entirely on the server).
+   */
+  getAuthUserId(): string | null;
+  /**
+   * Call a procedure (query, mutation, or action).
+   *
+   * If the client is not ready (disconnected or still authenticating), the
+   * call is FIFO-queued and dispatched on the next ready state. The promise
+   * still resolves with the eventual server response.
+   *
+   * Pass `onSend` to be notified when the call actually leaves the queue
+   * (used by `useMutation` to flip `state` from "queued" → "loading").
+   */
+  call(procedure: string, input: unknown, options?: {
+    onSend?: () => void;
+  }): Promise<unknown>;
+  /**
+   * Throttle drain loop. Each iteration: sleep `throttleDelayMs`, then
+   * dispatch up to `throttleEveryN` queued items. Exits as soon as the
+   * queue drains inside a single batch (burst over, back to direct
+   * dispatch on the next `call()`) or the connection goes away
+   * (reconnect path will restart us via `flushQueuedCalls`).
+   */
+  private runThrottleLoop;
+  /**
+   * Issue the call against an established connection. Caller must ensure
+   * `isReady()` before invoking.
+   */
+  private dispatchCall;
+  /**
+   * Flush queued calls in FIFO order. Called once `isReady()` becomes
+   * true. With the throttle enabled, dispatch the first batch
+   * synchronously then hand off to the drain loop so a large
+   * post-reconnect flush respects backpressure instead of dumping 10k
+   * frames in one tick.
+   */
+  private flushQueuedCalls;
+  /**
+   * Re-send `subscribe` for every existing subscription. The subId for each
+   * may legitimately change (e.g. `queryIdentity` was a function of user
+   * identity and the user changed during the disconnect), so we re-key the
+   * unified `subscriptions` Map: snapshot every record, drop them from the
+   * Map, then reinsert under a fresh `_pending:<reqId>` key. Each pending
+   * request's `resolve` rekeys the parked record under the new server-issued
+   * subId so subsequent `sub:update` frames route to the existing
+   * `onUpdate` callback (which the React handle is still holding).
+   */
+  private resubscribeAll;
+  /**
+   * Subscribe to a live query.
+   *
+   * The client does not compute the subId locally — it sends the
+   * (procedure, input) pair and receives the canonical subId on the
+   * subscribe response. This lets the server's per-procedure
+   * `queryIdentity` override be authoritative without forcing the client
+   * to mirror any of the resolution logic.
+   *
+   * Returns the server-assigned subId and an unsubscribe function.
+   */
+  subscribe(procedure: string, input: unknown, serializedInput: string, onUpdate: (data: unknown) => void, onGone?: (reason: string | undefined) => void): Promise<{
+    subId: string;
+    unsubscribe: () => void;
+  }>;
+  private findSubByLocalKey;
+  /** Resolve every joiner waiting on this Subscription with the canonical subId. */
+  private resolveJoiners;
+  /** Reject every joiner waiting on this Subscription with the given error. */
+  private rejectJoiners;
+  private unsubscribeByLocalKey;
+  private handleMessage;
+  /**
+   * Called once the client transitions to a "ready" state on a fresh
+   * connection. Replays live-query subscriptions and flushes any queued
+   * calls in FIFO order.
+   */
+  private afterReady;
+  private handleResponse;
+  private handleSubscriptionUpdate;
+  /**
+   * Handles a `sub:gone` message: the server no longer tracks this
+   * subscription (e.g. it was fully unregistered while we were disconnected
+   * from the sub-manager). Notify the handle and drop the local entry so a
+   * re-subscribe is required to receive further updates.
+   */
+  private handleSubscriptionGone;
+  private handleClose;
+  private handleError;
+  private startInactivityWatchdog;
+  private stopInactivityWatchdog;
+  /**
+   * Close the current WebSocket and schedule a reconnect via `handleClose`.
+   *
+   * Atomically swaps the old socket's event handlers to no-ops BEFORE
+   * `close()` so a frame in flight at the moment of close cannot fire
+   * `handleMessage` into a half-cleaned state — that was the source of
+   * the "browser says socket is alive but client says disconnected" race.
+   */
+  private closeAndReconnect;
+  private installEnvironmentListeners;
+  private removeEnvironmentListeners;
+  private scheduleReconnect;
+  private computePublicState;
+  private emitState;
+  private ensureConnected;
+  private send;
+  private cleanup;
+  private generateRequestId;
+}
+//#endregion
+//#region src/db/types_client_rpc.d.ts
+interface ErrorMessage {
+  type: "error";
+  id?: string;
+  error: string;
+  code?: string;
+}
+declare const AuthMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"auth">;
+  data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+declare const CallMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"call">;
+  id: z.ZodString;
+  procedure: z.ZodString;
+  input: z.ZodUnknown;
+}, z.core.$strip>;
+declare const SubscribeMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"subscribe">;
+  id: z.ZodString;
+  procedure: z.ZodString;
+  input: z.ZodUnknown;
+}, z.core.$strip>;
+declare const UnsubscribeMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"unsubscribe">;
+  subId: z.ZodString;
+}, z.core.$strip>;
+declare const ClientMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
+  type: z.ZodLiteral<"auth">;
+  data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"call">;
+  id: z.ZodString;
+  procedure: z.ZodString;
+  input: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"subscribe">;
+  id: z.ZodString;
+  procedure: z.ZodString;
+  input: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"unsubscribe">;
+  subId: z.ZodString;
+}, z.core.$strip>]>;
+type AuthMessage = z.infer<typeof AuthMessageSchema>;
+type CallMessage = z.infer<typeof CallMessageSchema>;
+type SubscribeMessage = z.infer<typeof SubscribeMessageSchema>;
+type UnsubscribeMessage = z.infer<typeof UnsubscribeMessageSchema>;
+type ClientMessage = z.infer<typeof ClientMessageSchema>;
+declare const ConnectedMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"connected">;
+  sessionId: z.ZodString;
+}, z.core.$strip>;
+declare const AuthSuccessMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"auth:success">;
+  userId: z.ZodString;
+  extra: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strip>;
+declare const AuthFailedMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"auth:failed">;
+  message: z.ZodString;
+  extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const ResponseMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"response">;
+  id: z.ZodString;
+  success: z.ZodBoolean;
+  data: z.ZodOptional<z.ZodUnknown>;
+  error: z.ZodOptional<z.ZodString>;
+  code: z.ZodOptional<z.ZodString>;
+  subId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const SubscriptionUpdateMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"sub:update">;
+  subId: z.ZodString;
+  data: z.ZodUnknown;
+  dataHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Notifies a client that a subscription is no longer tracked on the server
+ * and will not receive further updates. Sent when, during a sub-manager
+ * recovery cycle, the registration record could not be found (e.g. another
+ * app-server instance fully unregistered the sub while we were disconnected).
+ * The client may choose to re-subscribe or surface the state to the user.
+ */
+declare const SubscriptionGoneMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"sub:gone">;
+  subId: z.ZodString;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Server-driven liveness signal. Sent when the channel has been idle for
+ * the configured app-ping interval (default 15s) and again after every
+ * outbound message. Pure no-op for the client: receiving any message
+ * (including this one) resets the client's inactivity watchdog. The client
+ * does NOT reply.
+ */
+declare const ServerPingMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"ping">;
+}, z.core.$strip>;
+declare const ServerMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
+  type: z.ZodLiteral<"connected">;
+  sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"auth:success">;
+  userId: z.ZodString;
+  extra: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"auth:failed">;
+  message: z.ZodString;
+  extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"response">;
+  id: z.ZodString;
+  success: z.ZodBoolean;
+  data: z.ZodOptional<z.ZodUnknown>;
+  error: z.ZodOptional<z.ZodString>;
+  code: z.ZodOptional<z.ZodString>;
+  subId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"sub:update">;
+  subId: z.ZodString;
+  data: z.ZodUnknown;
+  dataHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"sub:gone">;
+  subId: z.ZodString;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"ping">;
+}, z.core.$strip>]>;
+type ConnectedMessage = z.infer<typeof ConnectedMessageSchema>;
+type AuthSuccessMessage = z.infer<typeof AuthSuccessMessageSchema>;
+type AuthFailedMessage = z.infer<typeof AuthFailedMessageSchema>;
+type ResponseMessage = z.infer<typeof ResponseMessageSchema>;
+type SubscriptionUpdateMessage = z.infer<typeof SubscriptionUpdateMessageSchema>;
+type SubscriptionGoneMessage = z.infer<typeof SubscriptionGoneMessageSchema>;
+type ServerPingMessage = z.infer<typeof ServerPingMessageSchema>;
+type ServerMessage = z.infer<typeof ServerMessageSchema>;
+declare class AuthenticationError extends Error {
+  extra: Record<string, unknown>;
+  constructor(message: string, extra?: Record<string, unknown>);
+}
+/**
+ * Helper type to check if a procedure is internal.
+ */
+type IsInternal<T> = T extends {
+  internal: infer I;
+} ? (I extends true ? true : false) : false;
+interface Context {
+  requestId: string;
+  /** Authenticated user info */
+  user: {
+    userId: string;
+  };
+}
+//#endregion
+//#region src/client/client.d.ts
+interface ClientOptions {
+  /** WebSocket URL (e.g. ws://localhost:3000/ws) */
+  url: string;
+  /** Auth Info callback */
+  token?: () => Promise<string>;
+  /** Optional: reconnection timeout in ms (default: 180000 = 3 minutes) */
+  reconnectionTimeout?: number;
+  /** Reconnection options */
+  reconnect?: WSClientOptions["reconnect"];
+  /**
+   * Inactivity watchdog. The client never sends a ping itself; the server
+   * emits `{type:"ping"}` while idle and we close+reconnect if no inbound
+   * message arrives within `serverInactivityMs` (default 60s).
+   */
+  heartbeat?: WSClientOptions["heartbeat"];
+  /**
+   * Yields the event loop for `delayMs` after every `everyN` `call()`
+   * invocations. Useful for keeping React renders / GC tasks scheduled
+   * during long synchronous bursts; not load-bearing for the heartbeat.
+   * Default `{ everyN: 100, delayMs: 10 }`. Set `everyN: 0` to disable.
+   */
+  throttle?: WSClientOptions["throttle"];
+  onConnect?: () => void;
+  onDisConnect?: () => void;
+}
+/**
+ * Public state of a live query subscription, exposed via `getState()` and
+ * `onState()` on the handle so React (or any UI) can render a consistent
+ * snapshot via `useSyncExternalStore`.
+ *
+ * - "connecting" — initial subscribe in flight
+ * - "success"    — subscribed, last server data is in `data`
+ * - "stale"      — was successful, transport dropped; keeping last `data`
+ *                  until the resubscribe completes
+ * - "loading"    — `refetch()` triggered an explicit re-subscribe
+ * - "error"      — subscribe failed or server sent `sub:gone`
+ */
+type LiveQueryStatus = "connecting" | "success" | "stale" | "loading" | "error";
+interface LiveQueryState<T> {
+  data: T | undefined;
+  status: LiveQueryStatus;
+  error: Error | null;
+}
+interface LiveQueryHandle<T> {
+  /** Get current cached data (legacy convenience getter). */
+  get(): T | undefined;
+  /** Snapshot of `{ data, status, error }`. Stable between updates. */
+  getState(): LiveQueryState<T>;
+  /**
+   * Listen for state changes (data, status or error). Returns an
+   * unsubscribe function that removes only this listener — the underlying
+   * server subscription stays alive as long as any listener is attached.
+   *
+   * Suitable for `useSyncExternalStore`.
+   */
+  onState(listener: () => void): () => void;
+  /** Listen for data-only changes. Returns listener-removal fn. */
+  onData(callback: (data: T) => void): () => void;
+  /** Force a re-subscribe round-trip. */
+  refetch(): void;
+  /** Unsubscribe from the server (drops listeners too). */
+  unsubscribe(): void;
+}
+/**
+ * Create a fully typed RPC client with WebSocket transport.
+ */
+declare function createClient<AppRouter extends Router<Record<string, AnyProcedure<TContext>>, TContext>, TContext = unknown, TProcedures extends Record<string, AnyProcedure<TContext>> = AppRouter["procedures"]>(options: ClientOptions): ClientFromProcedures<TProcedures, TContext> & WSClientMethods;
+/**
+ * WebSocket client methods.
+ */
+interface WSClientMethods {
+  /** Connect to the WebSocket server */
+  connect(): Promise<void>;
+  /** Disconnect from the server */
+  disconnect(): void;
+  /** Check if connected and authenticated */
+  isReady(): boolean;
+  /** Check if authenticated */
+  isAuthenticated(): boolean;
+  /** Check if anonymouse */
+  isAnonymouse(): boolean;
+  /**
+   * The authenticated user id reported by the server on `auth:success`, or
+   * null when anonymous/unauthenticated. This is the auth-tier identity,
+   * NOT the server-side `queryIdentity` (which is the cache/subscription
+   * segmentation key and is not exposed to the client).
+   */
+  getAuthUserId(): string | null;
+  /** Subscribe to client connection state transitions. Returns unsubscribe fn. */
+  onState(listener: (s: ClientPublicState) => void): () => void;
+  /** Snapshot of the current public state. */
+  getPublicState(): ClientPublicState;
+}
+/**
+ * Client type from procedures.
+ * Filters internal procedures and creates appropriate methods.
+ * Query procedures get an additional liveQuery() method for real-time subscriptions.
+ */
+type ClientFromProcedures<TProcedures extends Record<string, AnyProcedure<TContext>>, TContext = unknown> = { [K in keyof TProcedures as IsInternal<TProcedures[K]> extends true ? never : K]: TProcedures[K] extends {
+  procedureType: "query";
+} ? {
+  query: (input: InputOf<TProcedures[K]>) => Promise<OutputOf<TProcedures[K]>>;
+  liveQuery: (input: InputOf<TProcedures[K]>) => LiveQueryHandle<OutputOf<TProcedures[K]>>;
+} : TProcedures[K] extends {
+  procedureType: "mutation";
+} ? {
+  mutate: (input: InputOf<TProcedures[K]>, opts?: CallOptions) => Promise<OutputOf<TProcedures[K]>>;
+} : TProcedures[K] extends {
+  procedureType: "action";
+} ? {
+  action: (input: InputOf<TProcedures[K]>, opts?: CallOptions) => Promise<OutputOf<TProcedures[K]>>;
+} : never };
+/**
+ * Optional call options forwarded to the transport layer.
+ */
+interface CallOptions {
+  /**
+   * Fired the first time the request leaves the queue and is actually
+   * sent on the wire. If the call was already sent immediately (client
+   * was ready at call time), this is invoked synchronously.
+   *
+   * Used by `useMutation` to flip `state` from "queued" → "loading".
+   */
+  onSend?: () => void;
+}
+//#endregion
+//#region src/client/caller_client.d.ts
+interface CallerOptions<TContext = unknown> {
+  isInternal?: boolean;
+  inContext: string;
+}
+/**
+ * Create a server-side caller that bypasses HTTP/WebSocket.
+ *
+ * For in-memory calls, input validation is skipped (data is already a JS object).
+ * Query procedures also get a liveQuery() method for server-side use.
+ */
+declare function createCaller<AppRouter extends Router<Record<string, AnyProcedure<TContext>>, TContext>, TContext = unknown, TProcedures extends Record<string, AnyProcedure<TContext>> = AppRouter["procedures"]>(options: CallerOptions<any>): CallerFromProcedures<TProcedures, TContext>;
+/**
+ * Caller type from procedures (includes internal procedures).
+ * Query procedures also have liveQuery() for server-side use.
+ */
+type CallerFromProcedures<TProcedures extends Record<string, AnyProcedure<TContext>>, TContext = unknown> = { [K in keyof TProcedures]: TProcedures[K] extends {
+  procedureType: "query";
+} ? {
+  query: (input: InputOf<TProcedures[K]>, serverCtx: TContext) => Promise<OutputOf<TProcedures[K]>>;
+  liveQuery: (input: InputOf<TProcedures[K]>, serverCtx: TContext) => Promise<LiveResult<OutputOf<TProcedures[K]>>>;
+} : TProcedures[K] extends {
+  procedureType: "mutation";
+} ? {
+  mutate: (input: InputOf<TProcedures[K]>, serverCtx: TContext) => Promise<OutputOf<TProcedures[K]>>;
+} : TProcedures[K] extends {
+  procedureType: "action";
+} ? {
+  action: (input: InputOf<TProcedures[K]>, serverCtx: TContext) => Promise<OutputOf<TProcedures[K]>>;
+} : never } & {
+  init: (config: {
+    db: SupaliveDb;
+  }) => Promise<void>;
+};
+/**
+ * Caller type from router.
+ */
+type CallerFromRouter<TRouter extends Router<any, any>> = CallerFromProcedures<TRouter["procedures"]>;
+//#endregion
+export { PublicProcedures as $, CompareOperator as $n, DefineSchemaConfig as $t, ResponseMessageSchema as A, CacheLayer as An, RetryConfig as Ar, ResultOf as At, SubscriptionUpdateMessageSchema as B, UnregisterSubscriptionResult as Bn, QueryBuilder as Bt, ClientMessageSchema as C, DbType as Cn, RawPointReadSchema as Cr, createQueryBuilder as Ct, ErrorMessage as D, RawClient as Dn, RawReadEntrySchema as Dr, DefsToMap as Dt, Context as E, PreparedQueries as En, RawReadEntry as Er, AnyQueryDef as Et, SubscribeMessage as F, RegisterSubscriptionParams as Fn, bytesFromJson as Fr, TxContext as Ft, RPCError as G, UpdateSubscriptionReadSetResult as Gn, matchesPredicate as Gt, UnsubscribeMessageSchema as H, UnregisterSubscriptionsResult as Hn, jsonContains as Ht, SubscribeMessageSchema as I, RegisterSubscriptionParamsSchema as In, normalizeIdToBytes as Ir, IdAndCommitTs as It, ActionProcedures as J, BigIntSchema as Jn, ComputedCodec as Jt, WSClientOptions as K, AndPredicate as Kn, ActionArgs as Kt, SubscriptionGoneMessage as L, RegisterSubscriptionResult as Ln, normalizeToBytes as Lr, JsonContainsOptions as Lt, ServerMessageSchema as M, InvalidateWritesetParams as Mn, WriteEntrySchema as Mr, defineQuery as Mt, ServerPingMessage as N, InvalidateWritesetParamsSchema as Nn, WriteOp as Nr, DbReader as Nt, IsInternal as O, SqlBuilder as On, ReadEntry as Or, ParamsOf as Ot, ServerPingMessageSchema as P, InvalidateWritesetResult as Pn, WriteOpSchema as Pr, DbWriter as Pt, ProcedureNames as Q, CommitTs as Qn, DeclarativeIndex as Qt, SubscriptionGoneMessageSchema as R, UnregisterSubscriptionParams as Rn, JsonHasKeyMultiOptions as Rt, ClientMessage as S, DbQueryResult as Sn, RawPointRead as Sr, createMutationBuilder as St, ConnectedMessageSchema as T, PooledClient as Tn, RawRangeReadSchema as Tr, sleep as Tt, ClientPublicState as U, UpdateSubscriptionReadSetParams as Un, jsonPathExists as Ut, UnsubscribeMessage as V, UnregisterSubscriptionsParams as Vn, buildPredicateSql as Vt, HeartbeatOptions as W, UpdateSubscriptionReadSetParamsSchema as Wn, jsonPathExtract as Wt, ContextRegistry as X, CachedPgMetadataSchema as Xn, ComputedField as Xt, AppRouter as Y, CachedPgMetadata as Yn, ComputedDataType as Yt, MutationProcedures as Z, CommitLogEntry as Zn, ComputedFieldConfig as Zt, AuthSuccessMessage as _, schemaRegistry as _n, QueryCacheMetadata as _r, QueryCtx as _t, CallOptions as a, OverrideField as an, MutationResult as ar, ActionConfig as at, CallMessage as b, trackSchema as bn, RangeRead as br, TypeOf as bt, LiveQueryHandle as c, ReturnLiveQuery as cn, OccConflictError as cr, ActionProcedure as ct, WSClientMethods as d, SchemaColumnMapping as dn, PointRead as dr, MutationConfig as dt, IndexDefinition as en, CompareOperatorSchema as er, QueryProcedures as et, createClient as f, SchemaColumnsOptions as fn, PointReadSchema as fr, MutationCtx as ft, AuthMessageSchema as g, defineSchema as gn, QueryCacheEntrySchema as gr, QueryConfig as gt, AuthMessage as h, defineComputedField as hn, QueryCacheEntry as hr, OutputOf as ht, createCaller as i, MutationArgs as in, LiveResult as ir, router as it, ServerMessage as j, AffectedSubscription as jn, WriteEntry as jr, _resetGlobalDefs as jt, ResponseMessage as k, TxDatabase as kn, ReadEntrySchema as kr, QueryDefinition as kt, LiveQueryState as l, ReturnQuery as ln, OrPredicate as lr, AnyProcedure as lt, AuthFailedMessageSchema as m, StoredSchemaColumnsOptions as mn, PredicateSchema as mr, MutationProcedure as mt, CallerFromRouter as n, InsertData as nn, LeafPredicate as nr, Router as nt, ClientFromProcedures as o, Prettify as on, NO_RETRY as or, ActionCtx as ot, AuthFailedMessage as p, SchemaDefinition as pn, Predicate as pr, MutationFn as pt, WsClientManager as q, AndPredicateSchema as qn, ColumnCodec as qt, CallerOptions as r, Model as rn, LeafPredicateSchema as rr, getContextRegistry as rt, ClientOptions as s, QueryArgs as sn, OccAbortError as sr, ActionFn as st, CallerFromProcedures as t, InferSchema as tn, DEFAULT_RETRY as tr, RegisteredProcedure as tt, LiveQueryStatus as u, SchemaCodecs as un, OrPredicateSchema as ur, ContextOf as ut, AuthSuccessMessageSchema as v, shouldTrackSchema as vn, QueryCacheMetadataSchema as vr, QueryFn as vt, ConnectedMessage as w, LazyCommitTsParam as wn, RawRangeRead as wr, SupaliveDb as wt, CallMessageSchema as x, Database as xn, RangeReadSchema as xr, createActionBuilder as xt, AuthenticationError as y, tableNameToId as yn, QuerySpec as yr, QueryProcedure as yt, SubscriptionUpdateMessage as z, UnregisterSubscriptionParamsSchema as zn, JsonOpOptions as zt };
+//# sourceMappingURL=index-DouKwYL6.d.ts.map