@supalive/core 1.8.0 → 1.9.0

package/dist/index-DKlWIC3k.d.ts

@@ -0,0 +1,2200 @@
+import { r as ObjectStorage } from "./object-storage-354KU6Mj.js";
+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";
+  in: "in";
+  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";
+    in: "in";
+    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.ZodArray<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.ZodArray<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.ZodArray<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.ZodArray<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>>;
+  version: z.ZodString;
+  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.ZodArray<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;
+  version: z.ZodString;
+}, 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.ZodArray<z.ZodString>>>;
+    limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  }, z.core.$strip>]>>;
+  version: z.ZodOptional<z.ZodString>;
+}, 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.ZodArray<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;
+  /** Cached EVALSHA digests keyed by Lua source (see evalScript). */
+  private readonly scriptShaCache;
+  constructor(upstash: Redis$1 | Redis$2, ttlSeconds?: number);
+  /**
+   * Run a Lua script via EVALSHA using the script's SHA1 (computed locally — the
+   * same digest Redis keys scripts by, so no SCRIPT LOAD round-trip is needed on
+   * the hot path). On NOSCRIPT (the script isn't in Redis's cache yet, e.g. first
+   * use or after a Redis restart/failover) load it explicitly via SCRIPT LOAD and
+   * re-run via EVALSHA — so the script ends up cached server-side and subsequent
+   * EVALSHA calls hit. The runtime client is always ioredis (see initCacheLayer).
+   */
+  private evalScript;
+  /** One-shot recompute: atomically write data + metadata (CAS on version). */
+  setQueryCacheAndMetadataFor(cacheKey: string, data: unknown, metaData: QueryCacheMetadata, ttlSeconds?: number): Promise<void>;
+  /** Subscribe path: write the data blob only (CAS against the metadata's
+   *  version). The metadata is written separately by the sub-worker; the
+   *  `version` links the two so a divergent pair is detected on read. */
+  setQueryCacheFor(cacheKey: string, data: unknown, version: string, ttlSeconds?: number): Promise<void>;
+  getQueryCacheFor(cacheKey: string): Promise<QueryCacheEntry | null>;
+  /** Subscription recompute: replace the whole metadata (CAS on version). */
+  replaceQueryCacheMetadata(cacheKey: string, metaData: QueryCacheMetadata, ttlSeconds?: number): Promise<void>;
+  /** Still-fresh subscription: advance `lastSnapshotTs` only, preserving the
+   *  data's `version` + `readSet` (no recompute). Monotonic and non-clobbering
+   *  — see ADVANCE_META. `metaData` carries the new horizon plus the version +
+   *  readSet the caller read, which the script keeps unless a newer computation
+   *  has since landed. */
+  advanceQueryCacheMetadata(cacheKey: string, metaData: QueryCacheMetadata, ttlSeconds?: number): Promise<void>;
+  getQueryCacheMetaData(cacheKey: string): Promise<QueryCacheMetadata | null>;
+  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[];
+}
+/**
+ * Bound to a single dedicated connection that holds the core-init lock. Passed
+ * to the callback of {@link Database.withCoreInitLock} so version reads/writes
+ * and migration statements all run under the same lock.
+ */
+interface CoreInitLockCtx {
+  exec(sql: string, params?: unknown[]): Promise<DbQueryResult>;
+  getVersion(): Promise<bigint>;
+  setVersion(version: bigint): Promise<void>;
+}
+interface Database {
+  readonly dbType: DbType;
+  readonly sqlBuilder: SqlBuilder;
+  columnTypes: Map<string, Map<string, string>>;
+  /**
+   * Current core schema version stored in `metadata.core_version`, or `0n`
+   * when unset. Read on a pooled connection for the lock-free fast path of
+   * {@link initCore}.
+   */
+  getCoreVersion(): Promise<bigint>;
+  /**
+   * Runtime bootstrap statements to apply when migrating core TO `toVersion`
+   * (i.e. the `toVersion - 1` → `toVersion` step): data seeds, backfills, or a
+   * schema change that must be applied directly at runtime. Dialect-specific;
+   * the core schema (tables, indexes, the `global_commit_ts` sequence/counter)
+   * lives in the generated schema instead — see `coreTablesSql`.
+   */
+  coreMigrationStatements(toVersion: bigint): string[];
+  /**
+   * Run `fn` while holding the cross-process core-init lock (PG
+   * `pg_advisory_xact_lock`, MySQL `GET_LOCK`) on a single dedicated
+   * connection, so concurrent servers can't race the core migration. All of
+   * `fn`'s work runs on that locked connection via {@link CoreInitLockCtx}.
+   */
+  withCoreInitLock(fn: (ctx: CoreInitLockCtx) => Promise<void>): Promise<void>;
+  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>;
+  /**
+   * The retention watermark: the boundary `ts` below which commit_logs have
+   * been pruned, so any cache entry whose `lastSnapshotTs` is below it can no
+   * longer be freshness-checked (its scan window would miss deleted rows) and
+   * must be recomputed. Persisted in the `metadata` table (survives restarts)
+   * as a cheap PK read — callers load it into an in-memory variable at startup
+   * and keep it fresh via pub/sub rather than reading it per query. Returns the
+   * -1n genesis when nothing has been pruned yet (matching the empty-DB snapshot
+   * ts), so every entry is scannable.
+   */
+  getMinSnapshotTimestamp(): Promise<bigint>;
+  /**
+   * Advance the retention watermark. Monotonic: only ever moves forward (a
+   * stale writer can never lower it). Called by the sub-manager right before it
+   * prunes commit_logs below `ts`.
+   */
+  updateMinSnapshotTimestamp(ts: 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>;
+  /**
+   * Oldest `ts` still present in commit_logs (i.e. the retention watermark
+   * after the last prune), or `null` when the table is empty. A cache entry
+   * whose `lastSnapshotTs` is below it can no longer be freshness-checked via
+   * {@link getCommitLogsBetweenTs} (the logs it would need were pruned), so the
+   * one-shot/register cache paths recompute instead of trusting it.
+   */
+  getMinCommitLogTs(): Promise<bigint | null>;
+  /**
+   * 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>;
+type OrderDirection = "ASC" | "DESC";
+interface OrderByOptions {
+  direction?: OrderDirection;
+  nulls?: "first" | "last";
+  collate?: string;
+}
+/**
+ * Cursor-based pagination using a timestamp column and a unique ID column.
+ *
+ * Generates a stable cursor predicate:
+ *
+ * DESC (default):
+ * ```sql
+ * WHERE (timeCol < ? OR (timeCol = ? AND idCol < ?))
+ * ORDER BY timeCol DESC, idCol DESC
+ * ```
+ *
+ * ASC:
+ * ```sql
+ * WHERE (timeCol > ? OR (timeCol = ? AND idCol > ?))
+ * ORDER BY timeCol ASC, idCol ASC
+ * ```
+ */
+interface PaginationClause<S extends SchemaDefinition<string, ZodRawShape>, Time extends OrderableFieldKeys<S>, Id extends OrderableFieldKeys<S>> {
+  /** Timestamp column used for cursor pagination. */
+  timeCol: Time;
+  /**
+   * Unique tie-breaker column.
+   *
+   * @default "id"
+   */
+  idCol?: Id;
+  /**
+   * Pagination direction.
+   *
+   * - `"desc"` (default): Newest → oldest.
+   * - `"asc"`: Oldest → newest.
+   *
+   * @default "desc"
+   */
+  direction?: OrderDirection;
+  /**
+   * Maximum number of rows to return.
+   */
+  limit?: number;
+  /**
+   * Cursor returned from the previous page.
+   *
+   * Omit or set to `null` to fetch the first page.
+   */
+  cursor?: {
+    time: FieldValue<S, Time>;
+    id: FieldValue<S, Id>;
+  } | null;
+}
+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 paginationClause;
+  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>;
+  paginate<Time extends OrderableFieldKeys<S>, Id extends OrderableFieldKeys<S>>(clause: PaginationClause<S, Time, Id>): SelectQueryBuilder<S, K, C>;
+  orderBy(column: keyof InferSchema<S> | keyof C, direction?: OrderDirection): SelectQueryBuilder<S, K, C>;
+  orderBy(column: keyof InferSchema<S> | keyof C, options?: OrderByOptions): SelectQueryBuilder<S, K, C>;
+  private buildOrderBySql;
+  orderByRaw(sql: string): 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>;
+  /**
+   * Set membership: `key` equals any of `values` (SQL `IN`). Each value is
+   * codec-encoded like `eq`. An empty `values` matches no rows. Bound as one
+   * parameter per element, so keep the list within the driver's parameter
+   * limit (chunk very large sets at the call site).
+   */
+  in<K extends keyof InferSchema<S>>(key: K, values: readonly 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[];
+  /**
+   * Merge a parent procedure's reads into this context's readSet. Used when a
+   * `runMutation` sub-transaction inherits the reads of the procedure that
+   * invoked it, so the sub-tx's OCC validation also fences on those rows.
+   * Entries are shallow-cloned so the two readSets don't alias.
+   */
+  appendInternalReadSet(parentEntries: ReadEntry[]): void;
+  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;
+  /**
+   * Register a hook fired once after every successful `mutation()` commit
+   * (never on an OCC conflict/rollback), with the committed writeSet and its
+   * commitTs. The server uses this to drive subscription invalidation for ALL
+   * mutation sources — client WS calls, actions, jobs, and the internal caller —
+   * so a server-side write pushes live updates just like a client write does.
+   * Non-server consumers (migration tooling, tests) leave it unset (no-op).
+   */
+  setOnAfterCommit(cb: (writeSet: WriteEntry[], commitTs: CommitTs) => void): void;
+  query<T>(fn: (ctx: DbReader) => Promise<T>): Promise<T>;
+  /**
+   * Compute a query once at the latest snapshot, returning the result together
+   * with the snapshot `ts` and the tracked `readSet`. This is a plain one-shot
+   * evaluation — it registers NO live subscription; the `readSet`/`ts` are
+   * returned purely so the caller (e.g. the one-shot query cache) can store
+   * freshness metadata. Use this for cached one-shot query calls (WS `call`,
+   * HTTP RPC). `liveQuery` is the same computation under the subscription path's
+   * name and simply delegates here.
+   */
+  queryInternal<T>(fn: (ctx: DbReader) => Promise<T>): Promise<LiveResult<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/jobs/scheduler.d.ts
+/** A recurring job to keep synced on the scheduler side. */
+interface ScheduledJobDef {
+  /** Job procedure name (also the last path segment of its endpoint). */
+  name: string;
+  /** Cron expression, e.g. `"0 3 * * *"`. */
+  cron: string;
+}
+/** Options for a precise, one-shot job run. */
+interface EnqueueOptions {
+  /** Run after this many seconds from now. */
+  delaySeconds?: number;
+  /** Run at this absolute time. Overrides `delaySeconds`. */
+  runAt?: Date;
+  /**
+   * Idempotency key. If two enqueues share the same id within the provider's
+   * dedup window, only the first is delivered. Use it to make "schedule the
+   * expiry of X" safe to call more than once.
+   */
+  dedupeId?: string;
+}
+/** Handle returned by {@link JobScheduler.enqueue}; pass its `id` to `cancel`. */
+interface ScheduleHandle {
+  id: string;
+}
+/** The pieces of an inbound webhook the scheduler needs to authenticate it. */
+interface IncomingJobRequest {
+  /** Job name parsed from the request path. */
+  name: string;
+  /** Raw (unparsed) request body — signatures are computed over these bytes. */
+  rawBody: string;
+  /** Request headers, keys lowercased. */
+  headers: Record<string, string | undefined>;
+  /** Full request URL the webhook was delivered to. */
+  url: string;
+}
+/**
+ * Pluggable scheduler. The server owns exactly one instance and uses it for
+ * both directions:
+ *   • inbound  — `verify` authenticates a webhook before the job runs.
+ *   • outbound — `syncSchedules` (recurring, at startup) and `enqueue`/`cancel`
+ *                (precise one-shots, at runtime) drive the provider.
+ *
+ * Both dev and production implementations POST to the same HTTP job endpoint,
+ * so the server's dispatch path is exercised identically in every environment.
+ */
+interface JobScheduler {
+  /** Authenticate an inbound webhook. Return false (or throw) to reject. */
+  verify(req: IncomingJobRequest): Promise<boolean>;
+  /**
+   * Make the provider's recurring schedules match `jobs` exactly (create,
+   * update, and remove stale ones). Called once at server startup.
+   * `endpointFor(name)` yields the absolute URL the provider should POST to.
+   */
+  syncSchedules(jobs: ScheduledJobDef[], endpointFor: (name: string) => string): Promise<void>;
+  /** Enqueue a precise one-shot run of `name` with `body` at `endpoint`. */
+  enqueue(name: string, body: unknown, endpoint: string, opts?: EnqueueOptions): Promise<ScheduleHandle>;
+  /** Cancel a previously enqueued one-shot by its handle id. */
+  cancel(handleId: string): Promise<void>;
+}
+interface DevSchedulerOptions {
+  /**
+   * How often, in ms, to fire each recurring job in dev. Dev intentionally
+   * ignores exact cron timing (that is the production scheduler's job); it
+   * just fires often enough to exercise the handler. Default 60_000.
+   */
+  recurringIntervalMs?: number;
+  /**
+   * Override the HTTP client (for tests). Defaults to the global `fetch`.
+   */
+  fetchImpl?: typeof fetch;
+}
+/**
+ * In-process scheduler for local development and tests. Recurring jobs fire on
+ * a fixed interval; one-shots fire on an exact `setTimeout` (so precise timing
+ * is faithfully testable). Every fire POSTs to the real HTTP job endpoint, and
+ * `verify` accepts everything — there is no signing in dev.
+ */
+declare class DevScheduler implements JobScheduler {
+  private readonly intervalMs;
+  private readonly fetchImpl;
+  private intervals;
+  private timeouts;
+  constructor(opts?: DevSchedulerOptions);
+  verify(_req: IncomingJobRequest): Promise<boolean>;
+  syncSchedules(jobs: ScheduledJobDef[], endpointFor: (name: string) => string): Promise<void>;
+  enqueue(name: string, body: unknown, endpoint: string, opts?: EnqueueOptions): Promise<ScheduleHandle>;
+  cancel(handleId: string): Promise<void>;
+  /** Stop every dev timer (call on server shutdown / in test teardown). */
+  stop(): void;
+  private post;
+}
+interface QStashSchedulerOptions {
+  /** QStash Base url (`QSTASH_BASE_URL`). */
+  baseUrl: string;
+  /** QStash REST token (`QSTASH_TOKEN`). */
+  token: string;
+  /** Current signing key for webhook verification (`QSTASH_CURRENT_SIGNING_KEY`). */
+  currentSigningKey: string;
+  /** Next signing key, for zero-downtime key rotation (`QSTASH_NEXT_SIGNING_KEY`). */
+  nextSigningKey: string;
+  devMode: boolean;
+}
+/**
+ * Production scheduler backed by Upstash QStash. Externalizes the timer so a
+ * horizontally-scaled deployment fires each cron tick exactly once (QStash
+ * calls one HTTP endpoint), with at-least-once retries and signed webhooks.
+ */
+declare class QStashScheduler implements JobScheduler {
+  private readonly client;
+  private readonly receiver;
+  constructor(opts: QStashSchedulerOptions);
+  verify(req: IncomingJobRequest): Promise<boolean>;
+  syncSchedules(jobs: ScheduledJobDef[], endpointFor: (name: string) => string): Promise<void>;
+  enqueue(name: string, body: unknown, endpoint: string, opts?: EnqueueOptions): Promise<ScheduleHandle>;
+  cancel(handleId: string): Promise<void>;
+}
+/**
+ * Thin app-facing handle for scheduling precise one-shots from inside
+ * procedures. The server builds one (via `getJobClient()`) that already knows
+ * how to turn a job name into its endpoint, so callers just say
+ * `jobs.enqueue("expireSpendAuth", { id }, { runAt })`.
+ */
+declare class JobClient {
+  private readonly scheduler;
+  private readonly endpointFor;
+  constructor(scheduler: JobScheduler, endpointFor: (name: string) => string);
+  enqueue(name: string, body: unknown, opts?: EnqueueOptions): Promise<ScheduleHandle>;
+  cancel(handleId: string): 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.
+ *
+ * Actions are the "external I/O" tier: they hold the full {@link SupaliveDb}
+ * (queries + mutations) and are the ONLY context that also carries side-effect
+ * services — {@link ObjectStorage} for uploads/downloads and a {@link JobClient}
+ * for scheduling precise one-shots. Queries/mutations stay pure (db only) so
+ * they remain cacheable and transaction-scoped.
+ */
+interface ActionCtx<TContext = unknown> {
+  /** Full database interface for queries and mutations */
+  db: SupaliveDb;
+  /** Object storage, when the server was configured with one (see
+  * `SupaliveServerConfig.storage`); `undefined` otherwise. The usual home
+  * for upload/download presigning. */
+  storage: ObjectStorage;
+  /** Job scheduler client for enqueueing precise one-shots, when the server
+   * was configured with a `scheduler`; `undefined` otherwise. Scheduling is
+   * network I/O, so it belongs in actions, never inside a DB transaction. */
+  scheduler: JobClient;
+  /** User-defined server context (auth, requestId, etc.) */
+  serverCtx?: TContext;
+}
+/**
+ * Job context passed to job handlers. Structurally identical to
+ * {@link ActionCtx}: a job is a server-only procedure that runs
+ * non-transactionally against the full {@link SupaliveDb} and may perform
+ * external work, but it is triggered by the scheduler over HTTP (a cron tick
+ * or a precise one-shot) rather than by a connected client. `serverCtx` is
+ * the system context built by the server's `jobContext` factory.
+ */
+interface JobCtx<TContext = unknown> {
+  /** Full database interface for queries and mutations */
+  db: SupaliveDb;
+  /** System server context built by the server for scheduler-triggered runs */
+  serverCtx?: TContext;
+}
+/**
+ * Context handed to `caller.<proc>.runQuery` / `.runMutation` when invoking one
+ * procedure from inside another. Pass the caller handler's own `ctx` — its `db`
+ * carries the parent's live transaction (a {@link DbReader}/{@link DbWriter}) or,
+ * inside an action, the full {@link SupaliveDb}. The caller uses this to decide
+ * whether the nested call joins the parent's snapshot (queries) or runs as an
+ * independent sub-transaction (mutations).
+ */
+interface ParentCtx<TContext = unknown> {
+  db: DbReader | DbWriter | SupaliveDb;
+  serverCtx?: TContext | undefined;
+}
+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>;
+type JobFn<TInput, TResult, TContext = unknown> = (ctx: JobCtx<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" | "job", TContext = unknown, TInternal extends boolean = boolean> {
+  readonly _type: "procedure";
+  readonly procedureType: TType;
+  readonly inputSchema: ZodType<TInput>;
+  readonly outputSchema?: ZodType<any>;
+  readonly fn: QueryFn<TInput, TResult, TContext> | MutationFn<TInput, TResult, TContext> | ActionFn<TInput, TResult, TContext> | JobFn<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>;
+}
+/**
+ * A scheduler-triggered, server-only procedure. Runs like an action (full
+ * db, non-transactional, may do external work) but is dispatched by the
+ * server's HTTP job endpoint on a cron tick or a precise one-shot rather
+ * than over the client WebSocket. Always {@link internal}: true, so it is
+ * never reachable via `call`/`subscribe`.
+ */
+interface JobProcedure<TInput, TResult, TContext = unknown> extends BaseProcedure<TInput, TResult, "job", TContext, true> {
+  readonly procedureType: "job";
+  readonly fn: JobFn<TInput, TResult, TContext>;
+  /**
+   * Cron expression for a recurring job (e.g. `"0 3 * * *"`). Declared crons
+   * are synced to the scheduler at server startup. Omit for a job that is
+   * only ever invoked as a precise one-shot via the scheduler API.
+   */
+  readonly cron?: string;
+}
+type AnyProcedure<TContext = unknown> = QueryProcedure<any, any, TContext> | MutationProcedure<any, any, TContext> | ActionProcedure<any, any, TContext> | JobProcedure<any, any, TContext>;
+/**
+ * Mark a Zod schema as a **partial codegen hint** for the procedure's return
+ * type. Only the fields you specify are used; everything else is inferred from
+ * the handler's TypeScript return type.
+ *
+ * Purely for codegen — the returned schema is the same Zod type you passed in.
+ *
+ * @example
+ * returns: partial(z.object({
+ *   total: z.number().int(),  // only 'total' overridden, rest inferred from TS
+ * })),
+ */
+declare function partial<T extends ZodType<any>>(schema: T): T;
+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;
+  /**
+   * Partial Zod schema describing return-type overrides for codegen.
+   * Only the fields you specify are used; everything else is inferred
+   * from the handler's TypeScript return type. Wrap with `partial()`
+   * for explicit partial semantics. Use `.meta({ __genType: "Name" })`
+   * on a Zod object to rename the generated model.
+   */
+  returns?: ZodType<any>;
+  /**
+   * 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;
+  /**
+   * Partial Zod schema describing return-type overrides for codegen.
+   * Only the fields you specify are used; everything else is inferred
+   * from the handler's TypeScript return type.
+   */
+  returns?: ZodType<any>;
+}
+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;
+  /**
+   * Partial Zod schema describing return-type overrides for codegen.
+   * Only the fields you specify are used; everything else is inferred
+   * from the handler's TypeScript return type.
+   */
+  returns?: ZodType<any>;
+}
+interface JobConfig<TInput, TResult, TContext = unknown> {
+  /** Zod schema for the job payload */
+  args: ZodType<TInput>;
+  /** The job handler function */
+  handler: JobFn<TInput, TResult, TContext>;
+  /**
+   * Cron expression for a recurring schedule (e.g. `"0 3 * * *"`). Omit for a
+   * job that is only invoked as a precise one-shot.
+   */
+  cron?: string;
+}
+/** 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>;
+/**
+ * Create a job builder with a pre-defined context type. A job is a
+ * server-only procedure invoked by the scheduler over HTTP — either on its
+ * declared `cron` schedule or as a precise one-shot enqueued via the
+ * server's job API. Jobs run like actions (full db, non-transactional) and
+ * are always internal, so they are never reachable from a client.
+ *
+ * @example
+ * const job = createJobBuilder<ServerContext>();
+ *
+ * export const cleanupOtps = job({
+ *   cron: "0 * * * *", // hourly
+ *   args: z.object({}),
+ *   handler: async (ctx) => {
+ *     await ctx.db.mutation(async (db) => { ... });
+ *     return { ok: true };
+ *   },
+ * });
+ */
+declare function createJobBuilder<TContext = unknown>(): <TInput, TResult>(config: JobConfig<TInput, TResult, TContext>) => JobProcedure<TInput, TResult, TContext>;
+//#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 job procedures only from a router */
+type JobProcedures<T extends Record<string, AnyProcedure>> = { [K in keyof T as T[K] extends {
+  procedureType: "job";
+} ? 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" | "job";
+  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);
+  /** Only present for `type === "job"`. Cron expression for recurring jobs. */
+  cron?: string;
+}
+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>;
+  /** Get all registered job procedures (server-only, scheduler-triggered). */
+  getJobProcedures(): 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]>>>;
+  runQuery: (input: InputOf<TProcedures[K]>, ctx: ParentCtx<TContext>) => Promise<OutputOf<TProcedures[K]>>;
+} : TProcedures[K] extends {
+  procedureType: "mutation";
+} ? {
+  mutate: (input: InputOf<TProcedures[K]>, serverCtx: TContext) => Promise<OutputOf<TProcedures[K]>>;
+  runMutation: (input: InputOf<TProcedures[K]>, ctx: ParentCtx<TContext>) => Promise<OutputOf<TProcedures[K]>>;
+} : TProcedures[K] extends {
+  procedureType: "action";
+} ? {
+  action: (input: InputOf<TProcedures[K]>, serverCtx: TContext) => Promise<OutputOf<TProcedures[K]>>;
+} : TProcedures[K] extends {
+  procedureType: "job";
+} ? {
+  run: (input: InputOf<TProcedures[K]>, serverCtx: TContext) => Promise<OutputOf<TProcedures[K]>>;
+} : never } & {
+  init: (config: {
+    db: SupaliveDb;
+    storage: ObjectStorage;
+    scheduler: JobClient;
+  }) => Promise<void>;
+};
+/**
+ * Caller type from router.
+ */
+type CallerFromRouter<TRouter extends Router<any, any>> = CallerFromProcedures<TRouter["procedures"]>;
+//#endregion
+export { ProcedureNames as $, InvalidateWritesetParams as $n, WriteEntrySchema as $r, IdAndCommitTs as $t, ResponseMessageSchema as A, SchemaCodecs as An, OrPredicate as Ar, partial as At, SubscriptionUpdateMessageSchema as B, trackSchema as Bn, QuerySpec as Br, ScheduledJobDef as Bt, ClientMessageSchema as C, Model as Cn, LeafPredicate as Cr, QueryFn as Ct, ErrorMessage as D, QueryArgs as Dn, NO_RETRY as Dr, createJobBuilder as Dt, Context as E, Prettify as En, MutationResult as Er, createActionBuilder as Et, SubscribeMessage as F, defineComputedField as Fn, PredicateSchema as Fr, JobClient as Ft, RPCError as G, LazyCommitTsParam as Gn, RawRangeRead as Gr, ParamsOf as Gt, UnsubscribeMessageSchema as H, Database as Hn, RangeReadSchema as Hr, sleep as Ht, SubscribeMessageSchema as I, defineSchema as In, QueryCacheEntry as Ir, JobScheduler as It, ActionProcedures as J, RawClient as Jn, RawReadEntrySchema as Jr, _resetGlobalDefs as Jt, WSClientOptions as K, PooledClient as Kn, RawRangeReadSchema as Kr, QueryDefinition as Kt, SubscriptionGoneMessage as L, schemaRegistry as Ln, QueryCacheEntrySchema as Lr, QStashScheduler as Lt, ServerMessageSchema as M, SchemaColumnsOptions as Mn, PointRead as Mr, DevSchedulerOptions as Mt, ServerPingMessage as N, SchemaDefinition as Nn, PointReadSchema as Nr, EnqueueOptions as Nt, IsInternal as O, ReturnLiveQuery as On, OccAbortError as Or, createMutationBuilder as Ot, ServerPingMessageSchema as P, StoredSchemaColumnsOptions as Pn, Predicate as Pr, IncomingJobRequest as Pt, MutationProcedures as Q, AffectedSubscription as Qn, WriteEntry as Qr, TxContext as Qt, SubscriptionGoneMessageSchema as R, shouldTrackSchema as Rn, QueryCacheMetadata as Rr, QStashSchedulerOptions as Rt, ClientMessage as S, InsertData as Sn, DEFAULT_RETRY as Sr, QueryCtx as St, ConnectedMessageSchema as T, OverrideField as Tn, LiveResult as Tr, TypeOf as Tt, ClientPublicState as U, DbQueryResult as Un, RawPointRead as Ur, AnyQueryDef as Ut, UnsubscribeMessage as V, CoreInitLockCtx as Vn, RangeRead as Vr, SupaliveDb as Vt, HeartbeatOptions as W, DbType as Wn, RawPointReadSchema as Wr, DefsToMap as Wt, ContextRegistry as X, TxDatabase as Xn, ReadEntrySchema as Xr, DbReader as Xt, AppRouter as Y, SqlBuilder as Yn, ReadEntry as Yr, defineQuery as Yt, JobProcedures as Z, CacheLayer as Zn, RetryConfig as Zr, DbWriter as Zt, AuthSuccessMessage as _, ComputedFieldConfig as _n, CachedPgMetadataSchema as _r, MutationCtx as _t, CallOptions as a, PaginationClause as an, UnregisterSubscriptionParams as ar, router as at, CallMessage as b, IndexDefinition as bn, CompareOperator as br, OutputOf as bt, LiveQueryHandle as c, jsonContains as cn, UnregisterSubscriptionsParams as cr, ActionFn as ct, WSClientMethods as d, matchesPredicate as dn, UpdateSubscriptionReadSetParamsSchema as dr, ContextOf as dt, WriteOp as ei, JsonContainsOptions as en, InvalidateWritesetParamsSchema as er, PublicProcedures as et, createClient as f, ActionArgs as fn, UpdateSubscriptionReadSetResult as fr, JobConfig as ft, AuthMessageSchema as g, ComputedField as gn, CachedPgMetadata as gr, MutationConfig as gt, AuthMessage as h, ComputedDataType as hn, BigIntSchema as hr, JobProcedure as ht, createCaller as i, normalizeToBytes as ii, OrderDirection as in, RegisterSubscriptionResult as ir, getContextRegistry as it, ServerMessage as j, SchemaColumnMapping as jn, OrPredicateSchema as jr, DevScheduler as jt, ResponseMessage as k, ReturnQuery as kn, OccConflictError as kr, createQueryBuilder as kt, LiveQueryState as l, jsonPathExists as ln, UnregisterSubscriptionsResult as lr, ActionProcedure as lt, AuthFailedMessageSchema as m, ComputedCodec as mn, AndPredicateSchema as mr, JobFn as mt, CallerFromRouter as n, bytesFromJson as ni, JsonOpOptions as nn, RegisterSubscriptionParams as nr, RegisteredProcedure as nt, ClientFromProcedures as o, QueryBuilder as on, UnregisterSubscriptionParamsSchema as or, ActionConfig as ot, AuthFailedMessage as p, ColumnCodec as pn, AndPredicate as pr, JobCtx as pt, WsClientManager as q, PreparedQueries as qn, RawReadEntry as qr, ResultOf as qt, CallerOptions as r, normalizeIdToBytes as ri, OrderByOptions as rn, RegisterSubscriptionParamsSchema as rr, Router as rt, ClientOptions as s, buildPredicateSql as sn, UnregisterSubscriptionResult as sr, ActionCtx as st, CallerFromProcedures as t, WriteOpSchema as ti, JsonHasKeyMultiOptions as tn, InvalidateWritesetResult as tr, QueryProcedures as tt, LiveQueryStatus as u, jsonPathExtract as un, UpdateSubscriptionReadSetParams as ur, AnyProcedure as ut, AuthSuccessMessageSchema as v, DeclarativeIndex as vn, CommitLogEntry as vr, MutationFn as vt, ConnectedMessage as w, MutationArgs as wn, LeafPredicateSchema as wr, QueryProcedure as wt, CallMessageSchema as x, InferSchema as xn, CompareOperatorSchema as xr, QueryConfig as xt, AuthenticationError as y, DefineSchemaConfig as yn, CommitTs as yr, MutationProcedure as yt, SubscriptionUpdateMessage as z, tableNameToId as zn, QueryCacheMetadataSchema as zr, ScheduleHandle as zt };
+//# sourceMappingURL=index-DKlWIC3k.d.ts.map