@lunora/shard-engine 1.0.0-alpha.9 → 1.0.0-alpha.90

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { LunoraError } from '@lunora/errors';
+import { R2BucketLike, ShardHost, SocketHost, SocketHandle } from '@lunora/platform';
 import { SQL, Name } from 'drizzle-orm';
-import { ShardHost, SocketHost, SocketHandle } from '@lunora/platform';
 interface KeyRange {
   hi: string;
   index: string;
@@ -27,10 +27,12 @@ interface ScheduledFunctionDoc {
   args: Record<string, unknown>;
   attempts?: number;
   enqueuedAt: number;
-  functionPath: string;
+  functionPath?: string;
   id: string;
+  pool?: string;
   scheduledFor: number;
   shardKey?: string;
+  workflow?: string;
 }
 interface StorageMetadata {
   contentType?: string;
@@ -86,6 +88,75 @@ interface WhereInput {
   OR?: WhereInput[];
 }
 declare const RELATION_EXISTS_KEY = "__relationExists";
+interface SubscriptionQuery {
+  args?: Record<string, unknown>;
+  functionPath?: string;
+  sinceEpoch?: string;
+  sinceSeq?: number;
+  table?: string;
+}
+interface ShapeSubscriptionQuery {
+  args?: Record<string, unknown>;
+  name: string;
+  sinceEpoch?: string;
+  sinceSeq?: number;
+}
+interface SubscriptionEnvelope {
+  caps?: string[];
+  clientId?: string;
+  context?: Record<string, unknown>;
+  data?: unknown;
+  generation?: number;
+  id: string;
+  query?: SubscriptionQuery;
+  shape?: {
+    args?: Record<string, unknown>;
+    name: string;
+  };
+  sinceCheckpoint?: number;
+  sinceChunk?: number;
+  sinceEpoch?: string;
+  topic?: string;
+  type: "ack" | "connect" | "shape_subscribe" | "shape_unsubscribe" | "stream" | "subscribe" | "unsubscribe" | "whisper" | "whisper_subscribe" | "whisper_unsubscribe";
+}
+interface RpcRequest {
+  args?: Record<string, unknown>;
+  functionPath: string;
+}
+interface SocketAttachment {
+  admin?: boolean;
+  adminBinding?: string;
+  clientId?: string;
+  connected?: boolean;
+  connectionId?: string;
+  context?: Record<string, unknown>;
+  expiresAt?: number;
+  identity?: Record<string, unknown>;
+  ip?: string;
+  pageDeltas?: boolean;
+  shapes?: Record<string, ShapeSubscriptionQuery>;
+  subs: Record<string, SubscriptionQuery>;
+  userId?: string;
+  whispers?: string[];
+}
+interface ResolvedShape {
+  columns?: ReadonlyArray<string>;
+  effectiveWhere?: WhereInput;
+  global?: boolean;
+  table: string;
+}
+interface SubscriptionIdentity {
+  identity?: Record<string, unknown>;
+  ip?: string;
+  userId?: string;
+}
+interface ShardSocketLike {
+  readonly bufferedAmount?: number;
+  close?: (code?: number, reason?: string) => void;
+  deserializeAttachment?: () => unknown;
+  send: (data: string) => void;
+  serializeAttachment?: (value: unknown) => void;
+}
 type AggregateOp = "avg" | "count" | "max" | "min" | "sum";
 interface AggregateIndexDefinitionLike {
   readonly by?: ReadonlyArray<string>;
@@ -137,6 +208,10 @@ interface ColumnMetaLike {
 interface ValidatorLike {
   readonly _meta?: {
     readonly column?: ColumnMetaLike;
+    readonly inner?: ValidatorLike;
+    readonly members?: ReadonlyArray<ValidatorLike>;
+    readonly tableName?: string;
+    readonly value?: unknown;
   };
   readonly kind?: string;
   readonly parse?: (value: unknown) => unknown;
@@ -180,9 +255,12 @@ interface SchemaLike {
 }
 interface TableDefinitionLike {
   readonly aggregateIndexes?: ReadonlyArray<AggregateIndexDefinitionLike>;
+  readonly commitOrderedMode?: boolean;
+  readonly dropStalePatchesMode?: boolean;
   readonly geoIndexes?: ReadonlyArray<GeoIndexDefinitionLike>;
   readonly indexes: ReadonlyArray<IndexDefinitionLike>;
   readonly isPublic?: boolean;
+  readonly memoryMode?: boolean;
   readonly rankIndexes?: ReadonlyArray<RankIndexDefinitionLike>;
   readonly relationMap?: Record<string, RelationDefinitionLike>;
   readonly searchIndexes?: ReadonlyArray<SearchIndexDefinitionLike>;
@@ -225,11 +303,16 @@ interface ApplyOnDeleteOptions$1 {
   row: Record<string, unknown>;
   tableName: string;
 }
+interface FanOutBudget {
+  remaining: number;
+}
 interface ResolveWithOptions {
+  fanOutBudget?: FanOutBudget;
   fetcher: (tableName: string, args: QueryArgs) => Promise<QueryPage>;
   groupedCounter: (tableName: string, whereField: string, values: unknown[], policyWhere?: WhereInput) => Promise<Map<unknown, number>>;
   parents: Record<string, unknown>[];
   relationBaseWhere?: (table: string) => undefined | WhereInput;
+  relationMask?: RelationMask;
   schema: {
     readonly tables: Record<string, TableDefinitionLike>;
   };
@@ -248,22 +331,69 @@ interface QueryArgs {
   cursor?: null | string;
   includeDeleted?: boolean;
   limit?: number;
+  omitContinueCursor?: boolean;
   orderBy?: OrderByInput[];
   relationBaseWhere?: (table: string) => undefined | WhereInput;
+  relationMask?: RelationMask;
   restrictsCounts?: boolean;
   select?: ReadonlyArray<string>;
   where?: WhereInput;
   with?: WithInput;
 }
+interface CrossShardReadArgs {
+  orderBy?: OrderByInput[];
+  relationPolicies?: Record<string, WhereInput>;
+  where?: WhereInput;
+  with?: WithInput;
+}
+type RelationMask = (table: string, rows: Record<string, unknown>[]) => Record<string, unknown>[];
 interface QueryPage {
   continueCursor: null | string;
   isDone: boolean;
   page: Record<string, unknown>[];
   splitCursor?: null | string;
 }
+interface RelationEdge {
+  readonly array: boolean;
+  readonly column: string;
+  readonly name: string;
+  readonly sourceTable: string;
+  readonly targetTable: string;
+}
+interface RelatedStartReference {
+  id: string;
+  table: string;
+}
+type RelatedStart = (Record<string, unknown> & {
+  _id: string;
+}) | RelatedStartReference;
+type RelatedDirection = "both" | "in" | "out";
+interface RelatedOptions {
+  cursor?: null | string;
+  depth?: number;
+  direction?: RelatedDirection;
+  edges?: ReadonlyArray<string>;
+  limit?: number;
+  relationBaseWhere?: (table: string) => undefined | WhereInput;
+  relationMask?: RelationMask;
+}
+interface RelatedNode {
+  depth: number;
+  document: Record<string, unknown>;
+  path: ReadonlyArray<string>;
+  pathIds: ReadonlyArray<string>;
+  score: number;
+  table: string;
+}
+interface RelatedPage {
+  continueCursor: null | string;
+  isDone: boolean;
+  nodes: RelatedNode[];
+}
 interface OrderKey {
   direction: SortDirection;
   field: string;
+  nullable: boolean;
 }
 interface RestrictableQueryOptions {
   baseWhere?: WhereInput;
@@ -399,10 +529,8 @@ interface LifecycleEvent {
   shardKey: string;
   userId: string | null;
 }
-interface LifecycleDispatchInfo {
+interface LifecycleDispatchInfo extends SubscriptionIdentity {
   event: LifecycleEvent;
-  identity: Record<string, unknown> | undefined;
-  userId: string | undefined;
 }
 interface MutationDelta {
   indexKeys?: ReadonlyArray<IndexKeyEntry>;
@@ -414,6 +542,13 @@ interface MutationDelta {
 interface DatabaseWriterLike {
   aggregate: (tableName: string, options: AggregateOptions) => Promise<AggregateResult>;
   asId?: (tableName: string, id: string) => string;
+  cdcChangedTables?: (sinceSeq: number, options?: {
+    cursorOnly?: boolean;
+  }) => Promise<{
+    cursor: number;
+    floor?: number;
+    tables: string[];
+  } | undefined>;
   count: (tableName: string, where?: RestrictableQueryOptions | WhereInput) => Promise<number>;
   delete: (id: string, expectedTable?: string, options?: {
     hard?: boolean;
@@ -478,6 +613,8 @@ interface DatabaseWriterLike {
   rankBefore?: (tableName: string, indexName: string, options: RankBeforeOptions) => Promise<RankBeforeResult>;
   rankPage: (tableName: string, indexName: string, options?: RankPageOptions) => Promise<RankPage>;
   rankPageRows?: (tableName: string, indexName: string, options?: RankPageOptions) => Promise<ShardRankPageResult>;
+  related?: (start: RelatedStart, options?: RelatedOptions) => Promise<RelatedPage>;
+  relationEdges?: ReadonlyArray<RelationEdge>;
   replace: (id: string, document: Record<string, unknown>, expectedTable?: string, options?: {
     allowExplicitId?: boolean;
   }) => Promise<void>;
@@ -516,7 +653,6 @@ interface ImportShardResult {
   inserted: Record<string, number>;
 }
 declare const selectExportTables: (schema: SchemaLike, requested?: ReadonlyArray<string>) => string[];
-declare const exportShardTable: (writer: DatabaseWriterLike, table: string, batchSize?: number) => AsyncGenerator<ExportRow, void, undefined>;
 declare const exportShardRows: (writer: DatabaseWriterLike, schema: SchemaLike, args: ExportShardArgs) => AsyncGenerator<ExportRow, void, undefined>;
 declare const validateImportRow: (schema: SchemaLike, table: string, record: Record<string, unknown>) => string | undefined;
 declare const importShardRows: (writer: DatabaseWriterLike, schema: SchemaLike, args: ImportShardArgs) => Promise<ImportShardResult>;
@@ -591,6 +727,7 @@ declare class ReactiveCache {
   private readonly maxBytes;
   private readonly now;
   private monotonic;
+  private generation;
   constructor(options?: ReactiveCacheOptions);
   run<R>(key: string, deps: Set<string>, run: () => Promise<R>, ranges?: () => ReadonlyArray<KeyRange>): Promise<R>;
   invalidate(table: string, id: string, indexKeys?: ReadonlyArray<IndexKeyEntry>): string[];
@@ -612,6 +749,7 @@ declare class ReactiveCache {
   };
   private dropRangeDeps;
   private collectAndDrop;
+  private dropKeys;
   private dropEntry;
   private evict;
 }
@@ -650,12 +788,18 @@ interface RunTriggersOptions {
 }
 declare const runTriggers: (options: RunTriggersOptions) => Promise<void>;
 declare const hasTrigger: (schema: SchemaLike, tableName: string, op: TriggerOpLike) => boolean;
+interface SearchBackfillProgress {
+  done: boolean;
+  pages: number;
+}
 declare const backfillAggregateIndexes: (sql: SqlExec, schema: SchemaLike) => void;
 declare const backfillRankIndexes: (sql: SqlExec, schema: SchemaLike) => void;
 declare const backfillSearchIndexesForTable: (sql: SqlExec, tableName: string, definition: {
   searchIndexes?: ReadonlyArray<SearchIndexDefinitionLike>;
 }) => void;
-declare const backfillSearchIndexes: (sql: SqlExec, schema: SchemaLike) => void;
+declare const backfillSearchIndexes: (sql: SqlExec, schema: SchemaLike, options?: {
+  maxPages?: number;
+}) => SearchBackfillProgress;
 declare const CDC_LOG_TABLE = "__cdc_log";
 interface CdcChange {
   doc?: Record<string, unknown>;
@@ -665,19 +809,35 @@ interface CdcChange {
   table: string;
   ts: number;
 }
-declare const migrateCdcLog: (sql: SqlExec) => void;
+declare const CDC_LOG_TABLE_SEQ_INDEX = "__cdc_log_table_seq";
+declare const migrateCdcLog: (sql: SqlExec, options?: {
+  rowHistoryIndex?: boolean;
+}) => void;
 declare const appendCdcChange: (sql: SqlExec, ts: number, table: string, id: string, op: CdcChange["op"], doc: Record<string, unknown> | undefined) => void;
 declare const readCdcChanges: (sql: SqlExec, options?: {
   limit?: number;
   sinceSeq?: number;
-  tables?: ReadonlySet<string>;
 }) => {
   changes: CdcChange[];
   cursor: number;
 };
-declare const trimCdcChanges: (sql: SqlExec, throughSeq: number) => void;
+declare const cdcTouchesTables: (sql: SqlExec, sinceSeq: number, tables: ReadonlySet<string>) => boolean;
+declare const cdcCanVouchFor: (sql: SqlExec, deps: ReadonlySet<string>) => boolean;
+interface CdcChangeKey {
+  id: string;
+  op: CdcChange["op"];
+  seq: number;
+}
+declare const readCdcChangeKeys: (sql: SqlExec, table: string, sinceSeq: number, upTo: number) => CdcChangeKey[];
+declare const trimCdcChanges: (sql: SqlExec, throughSeq: number, maxRows: number) => void;
+declare const compactCdcDocs: (sql: SqlExec, throughSeq: number, maxRows: number) => void;
+declare const cdcSeqLeavingRows: (sql: SqlExec, keep: number) => number | undefined;
 declare const readCdcCursor: (sql: SqlExec) => number;
+declare const cursorBelowRetainedFloor: (floor: number | undefined, sinceSeq: number) => boolean;
+declare const cdcTrimmedError: (floor: number, sinceSeq: number, scope: "global" | "shard") => LunoraError;
+declare const cdcForkedError: (cursor: number, sinceSeq: number, scope: "global" | "shard", epoch?: string) => LunoraError;
 declare const minCdcSeq: (sql: SqlExec) => number | undefined;
+declare const minCdcReplayableSeq: (sql: SqlExec) => number | undefined;
 declare const CDC_META_TABLE = "__cdc_meta";
 declare const migrateCdcMeta: (sql: SqlExec) => void;
 declare const readCdcEpoch: (sql: SqlExec) => string;
@@ -689,7 +849,7 @@ declare const readClientWatermark: (sql: SqlExec, identity: string, clientId: st
 declare const advanceClientWatermark: (sql: SqlExec, identity: string, clientId: string, mutationId: number) => void;
 declare const GLOBAL_SHAPE_SNAPSHOT_TABLE = "__global_shape_snapshot";
 declare const migrateGlobalShapeSnapshot: (sql: SqlExec) => void;
-declare const readGlobalShapeSnapshot: (sql: SqlExec, connectionId: string, subId: string) => Map<string, string>;
+declare const readGlobalShapeSnapshot: (sql: SqlExec, connectionId: string, subId: string) => Map<string, string> | undefined;
 declare const writeGlobalShapeSnapshot: (sql: SqlExec, connectionId: string, subId: string, snapshot: Map<string, string>) => void;
 declare const deleteGlobalShapeSnapshot: (sql: SqlExec, connectionId: string, subId: string) => void;
 declare const deleteGlobalShapeSnapshotsForConnection: (sql: SqlExec, connectionId: string) => void;
@@ -709,28 +869,13 @@ declare const runShardMigrations: (sql: SqlExec, schema: SchemaLike, options?: {
     json: string;
   };
 }) => void;
-/**
- * How far a search companion's backfill has progressed, and what the next pass
- * should do about it.
- *
- * Neither stored analysis nor query policy, which is why it is its own module
- * rather than a third responsibility bolted onto one of them: it is *progress*,
- * the one piece of search state that is written as the index is built rather
- * than decided when it is read.
- *
- * The policy below is shared because when each engine owned a copy they
- * immediately disagreed about exactly the two cases that matter — whether a row
- * with no recorded profile may be resumed (it may not; nothing says what
- * analyzed it) and whether a never-started index is worth wiping (it is not;
- * there is nothing in it).
- */
 /**
  * How far a companion's backfill has progressed, and under which analysis.
  * Declared here rather than beside either engine's state table: both record the
  * same three facts, and the decisions made from them are the shared policy
  * below.
  */
-interface SearchBackfillState {
+interface BackfillState {
   /** Last `id` indexed, or `undefined` when no page has run yet. */
   cursor: string | undefined;
   /** True once a page came back short — the table is fully indexed. */
@@ -740,19 +885,21 @@ interface SearchBackfillState {
 }
 declare const SEARCH_STATE_TABLE = "__lunora_search_state";
 declare const migrateSearchState: (sql: SqlExec) => void;
-declare const readSearchBackfillState: (sql: SqlExec, companion: string) => SearchBackfillState;
+declare const readSearchBackfillState: (sql: SqlExec, companion: string) => BackfillState;
 declare const writeSearchBackfillState: (sql: SqlExec, companion: string, cursor: string | undefined, done: boolean, profile: string) => void;
 interface ShapeRow {
   doc: Record<string, unknown>;
   id: string;
 }
 declare const selectShapeRows: (sql: SqlExec, table: string, effectiveWhere: WhereInput | undefined) => ShapeRow[];
-declare const selectShapeMemberIds: (sql: SqlExec, table: string, effectiveWhere: WhereInput | undefined, ids: ReadonlyArray<string>) => Set<string>;
+declare const selectShapeMembers: (sql: SqlExec, table: string, effectiveWhere: WhereInput | undefined, ids: ReadonlyArray<string>) => Map<string, Record<string, unknown>>;
 interface SqlExec {
   exec: <Row = Record<string, unknown>>(sql: string, ...params: unknown[]) => SqlCursor<Row>;
 }
 interface SqlCursor<Row> extends Iterable<Row> {
+  readonly columnNames?: string[];
   one: () => Row;
+  raw?: () => IterableIterator<unknown[]>;
   toArray: () => Row[];
 }
 type IndexUseHook = (table: string, indexName: string, kind: "geo" | "index" | "rank" | "search") => void;
@@ -768,6 +915,7 @@ interface WriteEvent {
 type WriteHook = (event: WriteEvent) => Promise<void> | void;
 interface CtxDbOptions {
   auth?: ServerDefaultContextLike["auth"];
+  baselineSeq?: () => number | undefined;
   broadcast?: BroadcastDelta;
   cache?: ReactiveCache;
   cdc?: boolean;
@@ -776,10 +924,16 @@ interface CtxDbOptions {
   globalDb?: DatabaseWriterLike;
   headroom?: TransactionHeadroomTracker;
   idGenerator?: IdGenerator;
+  inTransaction?: () => boolean;
   maxRelationKeys?: number;
   onIndexUse?: IndexUseHook;
   onRead?: ReadHook;
   onReadRange?: (range: KeyRange) => void;
+  onStalePatchDropped?: (event: {
+    fields: string[];
+    id: string;
+    table: string;
+  }) => void;
   onWrite?: WriteHook;
   relationExistsPushDown?: "always" | "auto" | "never";
   scheduler?: SchedulerLike;
@@ -792,6 +946,8 @@ declare class NotUniqueError extends LunoraError {
   constructor(message?: string);
 }
 declare const normalizeIdStructurally: (schema: SchemaLike, tableName: string, id: string) => null | string;
+declare const assertNoExplicitUndefined: (op: "patch" | "replace", document: Record<string, unknown>) => void;
+declare const stripReservedPatchFields: (patch: Record<string, unknown>) => Record<string, unknown>;
 declare const createShardCtxDb: (options: CtxDbOptions) => DatabaseWriterLike;
 declare const AUDIT_LOG_TABLE = "__lunora_audit__";
 interface AuditEntry {
@@ -815,68 +971,23 @@ declare const readAuditLog: (sql: SqlExec, options?: {
   limit?: number;
   sinceSeq?: number;
 }) => AuditEntry[];
-interface SubscriptionQuery {
-  args?: Record<string, unknown>;
-  functionPath?: string;
-  sinceEpoch?: string;
-  sinceSeq?: number;
-  table?: string;
-}
-interface ShapeSubscriptionQuery {
-  args?: Record<string, unknown>;
-  name: string;
-  sinceEpoch?: string;
-  sinceSeq?: number;
-}
-interface SubscriptionEnvelope {
-  clientId?: string;
-  context?: Record<string, unknown>;
-  data?: unknown;
-  id: string;
-  query?: SubscriptionQuery;
-  shape?: {
-    args?: Record<string, unknown>;
-    name: string;
-  };
-  sinceCheckpoint?: number;
-  sinceEpoch?: string;
-  topic?: string;
-  type: "ack" | "connect" | "shape_subscribe" | "shape_unsubscribe" | "stream" | "subscribe" | "unsubscribe" | "whisper" | "whisper_subscribe" | "whisper_unsubscribe";
-}
-interface RpcRequest {
-  args?: Record<string, unknown>;
-  functionPath: string;
-}
-interface SocketAttachment {
-  admin?: boolean;
-  clientId?: string;
-  connected?: boolean;
-  connectionId?: string;
-  context?: Record<string, unknown>;
-  expiresAt?: number;
-  identity?: Record<string, unknown>;
-  shapes?: Record<string, ShapeSubscriptionQuery>;
-  subs: Record<string, SubscriptionQuery>;
-  userId?: string;
-  whispers?: string[];
-}
-interface ResolvedShape {
-  columns?: ReadonlyArray<string>;
-  effectiveWhere?: WhereInput;
-  global?: boolean;
-  table: string;
-}
-interface SubscriptionIdentity {
-  identity?: Record<string, unknown>;
-  userId?: string;
-}
-interface ShardSocketLike {
-  readonly bufferedAmount?: number;
-  close?: (code?: number, reason?: string) => void;
-  deserializeAttachment?: () => unknown;
-  send: (data: string) => void;
-  serializeAttachment?: (value: unknown) => void;
-}
+interface CdcArchiveScope {
+  epoch: string;
+  shard: string;
+}
+declare const readCdcArchivedThrough: (sql: SqlExec) => number;
+declare const writeCdcArchivedThrough: (sql: SqlExec, seq: number) => void;
+declare const archiveCdcSegment: (bucket: R2BucketLike, scope: CdcArchiveScope, changes: CdcChange[]) => Promise<void>;
+declare const cdcArchiveRewound: (bucket: R2BucketLike, scope: CdcArchiveScope, archivedThrough: number) => Promise<boolean>;
+declare const readArchivedCdcChanges: (bucket: R2BucketLike, scope: CdcArchiveScope, sinceSeq: number, limit: number | undefined) => Promise<{
+  changes: CdcChange[];
+  cursor: number;
+} | undefined>;
+declare const COMMIT_SEQ_TABLE = "__commit_seq";
+declare const COMMIT_SEQ_FIELD = "_commitSeq";
+declare const migrateCommitSeq: (sql: SqlExec) => void;
+declare const readCommitSeq: (sql: SqlExec) => number;
+declare const allocateCommitSeq: (sql: SqlExec) => number;
 interface CompanionSyncDeps {
   broadcast: (delta: MutationDelta) => void;
   indexKeysFor: (table: string, document?: Record<string, unknown>) => ReadonlyArray<{
@@ -900,6 +1011,13 @@ interface CompanionSync {
   syncSearch: (tableName: string, id: string, document: Record<string, unknown> | undefined, previous?: Record<string, unknown>) => void;
 }
 declare const createCompanionSync: (deps: CompanionSyncDeps) => CompanionSync;
+declare const isMemoryTable: (definition: TableDefinitionLike | undefined) => boolean;
+declare const memoryTableNames: (schema: SchemaLike) => string[];
+declare const clearMemoryTables: (sql: SqlExec, schema: SchemaLike) => number;
+declare const resolveRankSeekTuple: (options: {
+  after?: RankPageRowKey;
+  cursor?: null | string;
+}) => unknown[] | undefined;
 interface RankPageDeps {
   assertRankPartitionLocal: (tableName: string, definition: TableDefinitionLike, index: RankIndexDefinitionLike) => void;
   ensureRankBackfilled: (tableName: string, index: RankIndexDefinitionLike) => void;
@@ -917,8 +1035,49 @@ interface RankPageComputation {
     key: RankPageRowKey;
   }[];
 }
-declare const hydrateDocsById: (deps: RankPageDeps, tableName: string, ids: ReadonlyArray<string>) => Map<string, Record<string, unknown>>;
 declare const computeRankPage: (deps: RankPageDeps, tableName: string, indexName: string, rankPageOptions: RankPageOptions) => RankPageComputation;
+declare const SCHEDULE_OUTBOX_TABLE = "__schedule_outbox";
+interface ScheduleOutboxRow {
+  attempts: number;
+  envelopeJson: string;
+  id: string;
+  nextAttemptAt: number;
+}
+interface ScheduleOutboxEnvelope {
+  args: unknown;
+  options: Record<string, unknown> | undefined;
+  target: unknown;
+  when: number;
+}
+interface ScheduleOutbox {
+  forget: (id: string) => void;
+  record: (id: string, envelope: ScheduleOutboxEnvelope) => void;
+  wake: () => void;
+}
+declare const migrateScheduleOutbox: (sql: SqlExec) => void;
+declare const recordScheduleOutbox: (sql: SqlExec, id: string, envelopeJson: string, now: number) => void;
+declare const forgetScheduleOutbox: (sql: SqlExec, id: string) => void;
+declare const readDueScheduleOutbox: (sql: SqlExec, nowMs: number, limit: number) => ScheduleOutboxRow[];
+declare const deferScheduleOutbox: (sql: SqlExec, id: string, attempts: number, nextAttemptAt: number) => void;
+declare const parkScheduleOutbox: (sql: SqlExec, id: string, attempts: number) => void;
+declare const probeScheduleOutbox: (sql: SqlExec) => {
+  dueAt: number | undefined;
+  populated: boolean;
+};
+declare const trimScheduleOutbox: (sql: SqlExec, olderThanTs: number) => void;
+declare const SHAPE_POKE_CURSOR_TABLE = "__shape_poke_cursor";
+declare const migrateShapePokeCursor: (sql: SqlExec) => void;
+declare const readShapePokeCursor: (sql: SqlExec, connectionId: string, subId: string) => number | undefined;
+declare const writeShapePokeCursor: (sql: SqlExec, connectionId: string, subId: string, cursor: number) => void;
+interface ShapePokeCursorRow {
+  connectionId: string;
+  cursor: number;
+  subId: string;
+}
+declare const writeShapePokeCursors: (sql: SqlExec, rows: ReadonlyArray<ShapePokeCursorRow>) => void;
+declare const minShapePokeCursor: (sql: SqlExec) => number | undefined;
+declare const deleteShapePokeCursor: (sql: SqlExec, connectionId: string, subId: string) => void;
+declare const deleteShapePokeCursorsForConnection: (sql: SqlExec, connectionId: string) => void;
 declare const DATA_MIGRATION_STATE_TABLE = "__lunora_migrations";
 type MigrationDirection = "down" | "up";
 type MigrationStatus = "completed" | "failed" | "in_progress";
@@ -982,10 +1141,10 @@ interface DependencyTracker {
 declare const createDependencyTracker: () => DependencyTracker;
 declare const runSql: <Row = Record<string, unknown>>(sql: SqlExec, query: string, ...params: unknown[]) => SqlCursor<Row>;
 declare const runDrizzle: <Row = Record<string, unknown>>(exec: SqlExec, query: SQL) => SqlCursor<Row>;
+declare const quoteIdentifier: (name: string) => string;
 declare const serializeSqlValue: (value: unknown) => unknown;
 declare const DOC_COLUMN = "__doc__";
 declare const geoTableName: (table: string, indexName: string) => string;
-declare const quoteIdentifier: (name: string) => string;
 declare const jsonPath: (field: string) => string;
 declare const jsonPathSql: (field: string) => SQL;
 declare const qualifiedJsonPath: (table: string, field: string) => string;
@@ -995,10 +1154,16 @@ declare const AGG_KEY: Name;
 declare const AGG_VALUE: Name;
 declare const AGG_COUNT: Name;
 declare const aggUpsertSql: (aggTable: string, key: unknown, value: unknown, count: unknown, set: SQL) => SQL;
-declare const tableColumns: (definition: TableDefinitionLike) => [string, ColumnMetaLike][];
+declare const tableColumns: (definition: TableDefinitionLike) => ReadonlyArray<readonly [string, ColumnMetaLike]>;
 declare const rowToDocument: (row: Record<string, unknown> | undefined) => Record<string, unknown> | undefined;
 declare const tryRowToDocument: (row: Record<string, unknown> | undefined) => Record<string, unknown> | undefined;
 declare const isFtsAvailable: (sql: SqlExec) => boolean;
+declare const WORKERD_SQLITE_LIMITS: {
+  readonly boundParams: 100;
+  readonly compoundSelect: 5;
+  readonly likePattern: 50;
+  readonly sqlTextLength: 100000;
+};
 type SqlEngine = "mysql" | "postgres" | "sqlite";
 interface RenderedSql {
   params: unknown[];
@@ -1006,6 +1171,79 @@ interface RenderedSql {
 }
 declare const renderSql: (engine: SqlEngine, query: SQL) => RenderedSql;
 declare const param: (value: unknown) => SQL;
+declare const unionAll: (branches: ReadonlyArray<SQL>) => SQL;
+declare const sqliteInList: (reference: SQL, items: ReadonlyArray<unknown>, negated: boolean, budget?: number) => SQL;
+type DurableStreamStatus = "complete" | "error" | "running";
+interface DurableStreamRun {
+  error?: string;
+  errorCode?: string;
+  lastSeq: number;
+  startedAt: number;
+  status: DurableStreamStatus;
+}
+interface DurableStreamChunk {
+  dataJson: string;
+  seq: number;
+}
+declare const migrateDurableStreams: (sql: SqlExec) => void;
+declare const readStreamRun: (sql: SqlExec, runKey: string) => DurableStreamRun | undefined;
+declare const claimStreamRun: (sql: SqlExec, runKey: string, startedAt: number, ttlMs: number) => boolean;
+declare const deleteStreamRun: (sql: SqlExec, runKey: string) => void;
+declare const appendStreamChunk: (sql: SqlExec, runKey: string, seq: number, dataJson: string) => void;
+declare const readStreamChunks: (sql: SqlExec, runKey: string, sinceSeq: number) => DurableStreamChunk[];
+declare const finishStreamRun: (sql: SqlExec, runKey: string, status: "complete" | "error", lastSeq: number, failure?: {
+  code: string;
+  message: string;
+}) => void;
+declare const trimStreamRuns: (sql: SqlExec, now: number) => void;
+declare const MAX_DURABLE_STREAM_CHUNKS = 50000;
+declare const MAX_DURABLE_STREAM_BYTES: number;
+interface DurableStreamSink {
+  readonly chunk: (chunk: {
+    data: unknown;
+    generation?: number;
+    seq: number;
+  }) => boolean;
+  readonly complete: () => void;
+  readonly fail: (failure: {
+    code: string;
+    message: string;
+  }) => void;
+}
+type DurableAttachDecision = "attach" | "interrupted" | "reclaim" | "replay-terminal";
+declare const decideDurableAttach: (run: DurableStreamRun | undefined, context: {
+  generation?: number;
+  live?: {
+    generation: number;
+  };
+  resuming: boolean;
+}) => DurableAttachDecision;
+interface DurableStreamAttach {
+  readonly generation?: number;
+  readonly iterator: (signal: AbortSignal) => AsyncIterable<unknown>;
+  readonly runKey: string;
+  readonly sinceChunk: number;
+  readonly sink: DurableStreamSink;
+  readonly ttlMs?: number;
+}
+declare class DurableStreamRunner {
+  private lastTrimAt;
+  private readonly runs;
+  private readonly sql;
+  private readonly waitUntil;
+  constructor(dependencies: {
+    sql: () => SqlExec;
+    waitUntil?: (promise: Promise<unknown>) => void;
+  });
+  attach(request: DurableStreamAttach): Promise<void>;
+  detach(runKey: string, sink: DurableStreamSink): void;
+  isLive(runKey: string): boolean;
+  private attachOrThrow;
+  private produce;
+  private trim;
+}
+declare const envPositiveInt: (env: unknown, key: string, fallback: number) => number;
+declare const envOptionalPositiveInt: (env: unknown, key: string) => number | undefined;
 interface ExternalSourceDiffResult {
   changes: CdcChange[];
   nextBaseline: Map<string, string>;
@@ -1070,6 +1308,16 @@ declare const isSoftDeleted: (row: Record<string, unknown>, column: string) => b
 declare const pullExternalSourceIncrementalTick: (sql: SqlExec, writer: DatabaseWriterLike, client: SourceClientLike, table: string, source: ExternalSourceLike, shardKey: string, nowMs: number) => Promise<{
   applied: number;
 }>;
+declare const ftsRowidMapName: (companion: string) => string;
+interface FtsWriteOptions {
+  guard?: SQL;
+  unmappedRowids?: ReadonlyArray<number>;
+}
+declare const ftsCompanionDdl: (companion: string) => SQL[];
+declare const ftsWriteDocument: (companion: string, id: string, text: string, options?: FtsWriteOptions) => SQL[];
+declare const ftsPurgeDocument: (companion: string, id: string, options?: FtsWriteOptions) => SQL[];
+declare const ftsUnmappedPage: (companion: string, limit: number, after?: number) => SQL;
+declare const groupUnmappedRows: (rows: ReadonlyArray<Record<string, unknown>>) => Map<string, number[]>;
 declare const GEO_DEFAULT_PRECISION = 9;
 interface GeoPoint {
   lat: number;
@@ -1085,6 +1333,19 @@ declare const coveringGeohashes: (center: GeoPoint, radiusMeters: number) => str
 declare const pointInBoundingBox: (point: GeoPoint, box: GeoBoundingBox) => boolean;
 declare const boundingBoxCenter: (box: GeoBoundingBox) => GeoPoint;
 declare const boundingBoxGeohashes: (box: GeoBoundingBox) => string[];
+declare class GlobalPollTick {
+  private readonly changedTables;
+  private readonly reads;
+  private resync;
+  private skippedCount;
+  constructor(changedTables?: Set<string>);
+  get readCount(): number;
+  get resyncRequested(): boolean;
+  get skipped(): number;
+  requestResync(): void;
+  rows(key: string | undefined, load: () => Promise<ShapeRow[]>): Promise<ShapeRow[]>;
+  shouldRead(table: string): boolean;
+}
 declare const ADMIN_FUNCTION_PREFIX = "__lunora_admin__:";
 declare const RELATION_FUNCTION_PREFIX = "__lunora_relation__:";
 declare const FLAGS_FUNCTION_PREFIX = "__lunora_flags__:";
@@ -1095,6 +1356,8 @@ declare const ADMIN_FUNCTIONS: {
   readonly aiGenerateSql: "__lunora_admin__:aiGenerateSql";
   readonly aiTableFilter: "__lunora_admin__:aiTableFilter";
   readonly assignIssue: "__lunora_admin__:assignIssue";
+  readonly backfillSearch: "__lunora_admin__:backfillSearch";
+  readonly backfillVectors: "__lunora_admin__:backfillVectors";
   readonly backRelationCounts: "__lunora_admin__:backRelationCounts";
   readonly cdcSync: "__lunora_admin__:cdcSync";
   readonly clearCapturedMail: "__lunora_admin__:clearCapturedMail";
@@ -1107,6 +1370,7 @@ declare const ADMIN_FUNCTIONS: {
   readonly explainIssue: "__lunora_admin__:explainIssue";
   readonly exportShard: "__lunora_admin__:exportShard";
   readonly facetColumn: "__lunora_admin__:facetColumn";
+  readonly findRelated: "__lunora_admin__:findRelated";
   readonly getAdvisories: "__lunora_admin__:getAdvisories";
   readonly getAdvisorProcedures: "__lunora_admin__:getAdvisorProcedures";
   readonly getAuditLog: "__lunora_admin__:getAuditLog";
@@ -1133,12 +1397,14 @@ declare const ADMIN_FUNCTIONS: {
   readonly ignoreIssue: "__lunora_admin__:ignoreIssue";
   readonly importShard: "__lunora_admin__:importShard";
   readonly listFlags: "__lunora_admin__:listFlags";
+  readonly listReactors: "__lunora_admin__:listReactors";
   readonly listQueues: "__lunora_admin__:listQueues";
   readonly lintSql: "__lunora_admin__:lintSql";
   readonly listTables: "__lunora_admin__:listTables";
   readonly listWorkflows: "__lunora_admin__:listWorkflows";
   readonly maskPolicies: "__lunora_admin__:maskPolicies";
   readonly migrationStatus: "__lunora_admin__:migrationStatus";
+  readonly patchRows: "__lunora_admin__:patchRows";
   readonly pitrRestore: "__lunora_admin__:pitrRestore";
   readonly rankBefore: "__lunora_admin__:rankBefore";
   readonly rankPage: "__lunora_admin__:rankPage";
@@ -1216,8 +1482,12 @@ interface TablesIndexesResult {
   indexesByTable: Record<string, TableIndexInfo[]>;
 }
 interface ColumnMeta {
+  bucket?: string;
+  enumValues?: string[];
   isStorage?: boolean;
   name: string;
+  nullable?: boolean;
+  onDelete?: "cascade" | "restrict" | "set null";
   optional: boolean;
   pk?: boolean;
   ref?: string;
@@ -1332,6 +1602,19 @@ interface FlagsResult {
   configured: boolean;
   flags: FlagEvaluation[];
 }
+interface ReactorMetadata {
+  errors: number;
+  lastError?: string;
+  lastRanAt?: number;
+  path: string;
+  runs: number;
+  state: "active" | "failing" | "idle";
+  suppressed: number;
+  tables?: ReadonlyArray<string>;
+}
+interface ReactorsResult {
+  reactors: ReactorMetadata[];
+}
 interface WorkflowMetadata {
   binding: string;
   className: string;
@@ -1390,8 +1673,10 @@ interface TablePage {
   columns: string[];
   refs?: Record<string, string>;
   rows: Record<string, unknown>[];
+  sqlColumns: string[];
   total?: number;
 }
+type ColumnKinds = Readonly<Record<string, string>>;
 type FilterOperator = "contains" | "eq" | "gt" | "gte" | "lt" | "lte" | "ne";
 interface FilterClause {
   column: string;
@@ -1403,6 +1688,7 @@ interface OrderByClause {
   direction: SortDirection;
 }
 interface ReadTablePageOptions {
+  columnKinds?: ColumnKinds;
   filters?: FilterClause[];
   limit?: number;
   offset?: number;
@@ -1413,6 +1699,8 @@ interface ReadTablePageOptions {
   table: string;
 }
 interface SelectMatchingIdsOptions {
+  after?: string;
+  columnKinds?: ColumnKinds;
   filters?: FilterClause[];
   limit?: number;
   search?: string;
@@ -1420,6 +1708,7 @@ interface SelectMatchingIdsOptions {
 }
 interface FacetColumnOptions {
   column: string;
+  columnKinds?: ColumnKinds;
   filters?: FilterClause[];
   limit?: number;
   search?: string;
@@ -1469,12 +1758,22 @@ interface FanoutPathCounters {
   socketsIterated: number;
   totalMs: number;
 }
+interface ShapeProbeCounters {
+  run: number;
+  served: number;
+}
+interface GlobalPollCounters {
+  drains: number;
+  pairsSkipped: number;
+}
 interface FanoutMetricsResult {
+  globalPoll: GlobalPollCounters;
   maxRelays: number;
   peakSubscribers: number;
   promoted: boolean;
   relayCount: number;
   shapePoke: FanoutPathCounters;
+  shapeProbe: ShapeProbeCounters;
   sinceMs: number;
   topics: FanoutTopicStat[];
   totalConnections: number;
@@ -1488,6 +1787,10 @@ interface FanoutAttachmentLike {
 }
 declare const DEFAULT_FANOUT_TOPIC_LIMIT = 20;
 declare const createFanoutCounters: () => FanoutPathCounters;
+declare const createShapeProbeCounters: () => ShapeProbeCounters;
+declare const createGlobalPollCounters: () => GlobalPollCounters;
+declare const recordGlobalPollPass: (counters: GlobalPollCounters, drains: number, pairsSkipped: number) => GlobalPollCounters;
+declare const recordShapeProbePass: (counters: ShapeProbeCounters, run: number, served: number) => ShapeProbeCounters;
 declare const recordFanoutPass: (counters: FanoutPathCounters, iterated: number, delivered: number, ms: number) => FanoutPathCounters;
 declare const summarizeFanoutTopics: (attachments: FanoutAttachmentLike[], limit?: number) => {
   peakSubscribers: number;
@@ -1556,7 +1859,20 @@ interface PitrRestoreArgs {
 }
 declare const readBookmark: (storage: PitrStorage, time?: number | string) => Promise<PitrBookmarkResult>;
 declare const armRestore: (storage: PitrStorage, args: PitrRestoreArgs) => Promise<Omit<PitrRestoreResult, "restarted">>;
-declare const normalizeOrderKeys: (orderBy: OrderByInput[] | undefined) => OrderKey[];
+declare const tiebreakDirectionFor: (keys: ReadonlyArray<{
+  direction?: string;
+}>) => SortDirection;
+declare const equalityPinnedFields: (where: undefined | WhereInput) => ReadonlySet<string>;
+declare const uniqueIndexFields: (indexes: ReadonlyArray<{
+  fields: ReadonlyArray<string>;
+  unique?: boolean;
+}> | undefined, shape: Record<string, ValidatorLike> | undefined) => ReadonlyArray<ReadonlyArray<string>>;
+interface OrderKeyConstraints {
+  pinned?: ReadonlySet<string>;
+  uniqueBy?: ReadonlyArray<ReadonlyArray<string>>;
+}
+declare const normalizeOrderKeys: (orderBy: OrderByInput[] | undefined, shape?: Record<string, ValidatorLike>, constraints?: OrderKeyConstraints) => OrderKey[];
+declare const CURSOR_PREFIX = "~4";
 declare const encodeCursor: (record: Record<string, unknown>, keys: OrderKey[]) => string;
 declare const decodeCursor: (cursor: string) => unknown[];
 declare const buildSeekWhere: (keys: OrderKey[], cursorValues: unknown[]) => WhereInput;
@@ -1609,7 +1925,6 @@ declare const clearQueueMessages: (sql: SqlExec) => {
 declare const encodePartitionKey: (partitionBy: ReadonlyArray<string>, source: Record<string, unknown>) => string;
 declare const RANK_TIEBREAK = "__id__";
 declare const sortColumnName: (i: number) => string;
-declare const matchesRankStaticWhere: (document: Record<string, unknown>, predicate: Record<string, unknown>) => boolean;
 declare const resolveRankPartition: (index: RankIndexDefinitionLike, where: Record<string, unknown> | undefined) => Record<string, unknown> | undefined;
 declare const rankTableName: (table: string, indexName: string) => string;
 declare const rankKeyFromDocument: (index: RankIndexDefinitionLike, document_: Record<string, unknown>) => {
@@ -1617,6 +1932,36 @@ declare const rankKeyFromDocument: (index: RankIndexDefinitionLike, document_: R
   rowId: string;
   sortValues: unknown[];
 };
+declare const rankPivotConditionSql: (column: string, value: unknown, direction: "asc" | "desc", wantLater: boolean) => SQL | undefined;
+declare const matchesRankStaticWhere: (document: Record<string, unknown>, predicate: Record<string, unknown>) => boolean;
+declare const REACTOR_STATE_TABLE = "__reactor_state";
+interface ReactorState {
+  digest: string;
+  lastError?: string;
+  lastRanAt: number;
+  stats: ReactorStats;
+  tables?: ReadonlyArray<string>;
+}
+interface ReactorStats {
+  errors: number;
+  runs: number;
+  suppressed: number;
+}
+declare const migrateReactorState: (sql: SqlExec) => void;
+declare const readReactorState: (sql: SqlExec, path: string) => ReactorState | undefined;
+declare const listReactorStates: (sql: SqlExec) => {
+  path: string;
+  state: ReactorState;
+}[];
+type ReactorDispatchResult = "error" | "ran" | "suppressed";
+declare const writeReactorState: (sql: SqlExec, path: string, outcome: {
+  digest?: string;
+  error?: string;
+  now: number;
+  result: ReactorDispatchResult;
+  tables?: ReadonlyArray<string>;
+}) => void;
+declare const reactorNeedsRun: (state: Pick<ReactorState, "tables"> | undefined, changed: ReadonlySet<string>) => boolean;
 interface ReadFootprint {
   onRead: (table: string, idOrScan?: string) => void;
   onReadRange: (range: KeyRange) => void;
@@ -1624,6 +1969,23 @@ interface ReadFootprint {
   tables: Set<string>;
 }
 declare const createReadFootprint: () => ReadFootprint;
+declare const UNVOUCHABLE_DEP = "!unvouchable";
+declare const markUnvouchableReads: <T extends object>(facade: T, onRead: ReadFootprint["onRead"] | undefined, methods: ReadonlyArray<string>) => T;
+declare const WHERE_FILTER: unique symbol;
+type RowPredicate = (document: Record<string, unknown>) => boolean;
+type WhereFilter = RowPredicate & {
+  readonly [WHERE_FILTER]: WhereInput;
+};
+declare const whereFilter: (where: WhereInput, predicate: RowPredicate) => WhereFilter;
+declare const whereOfFilter: (predicate: RowPredicate) => undefined | WhereInput;
+declare const isPushableWhere: (where: WhereInput, shape: Readonly<Record<string, ValidatorLike>>, exactText?: boolean) => boolean;
+declare const RELATED_MAX_DEPTH = 4;
+declare const RELATED_DEFAULT_LIMIT = 50;
+declare const RELATED_MAX_LIMIT = 200;
+declare const RELATED_DEPTH_DECAY = 0.5;
+declare const deriveRelationEdges: (schema: SchemaLike) => RelationEdge[];
+type RelationGraphReader = Pick<DatabaseWriterLike, "findMany"> & Pick<Partial<DatabaseWriterLike>, "lookupById">;
+declare const findRelated: (reader: RelationGraphReader, edges: ReadonlyArray<RelationEdge>, start: RelatedStart, options?: RelatedOptions) => Promise<RelatedPage>;
 declare const DEFAULT_MAX_RELATION_KEYS = 5000;
 interface RelationExistsMarker {
   childWhere: WhereInput;
@@ -1658,6 +2020,7 @@ declare const containsRelationPredicate: (where: WhereInput, schema: ResolveCont
 declare const assertFlatPredicate: (where: WhereInput | undefined, schema: ResolveContext["schema"], tableName: string, op: string) => void;
 declare const resolveRelationPredicates: (where: WhereInput | undefined, options: ResolveRelationPredicatesOptions) => Promise<WhereInput | undefined>;
 declare const assertShapeShardable: (effectiveWhere: WhereInput | undefined, schema: ResolveContext["schema"], table: string) => void;
+declare const relationHooks: (args: Pick<QueryArgs, "relationBaseWhere" | "relationMask">) => Pick<QueryArgs, "relationBaseWhere" | "relationMask"> & Pick<ResolveWithOptions, "fanOutBudget">;
 declare const fanOutScalarCounts: (counter: (tableName: string, where?: WhereInput) => Promise<number>, tableName: string, whereField: string, values: unknown[], policyWhere: WhereInput | undefined) => Promise<Map<unknown, number>>;
 declare const distinctValues: (rows: Record<string, unknown>[], field: string) => unknown[];
 declare const resolveWith: (options: ResolveWithOptions) => Promise<void>;
@@ -1682,6 +2045,8 @@ interface ShapeRowOp {
   value?: Record<string, unknown>;
 }
 interface ShapePokePart {
+  baseCheckpoint?: number;
+  reset?: boolean;
   rowsPatch: ShapeRowOp[];
   shapeId: string;
 }
@@ -1742,6 +2107,12 @@ interface RelayShapeSubscribe {
   type: "relay_shape_subscribe";
   userId?: string;
 }
+interface RelayShapeUnsubscribe {
+  connectionId: string;
+  relayIndex: number;
+  subId?: string;
+  type: "relay_shape_unsubscribe";
+}
 interface RelayShapeSeed {
   cursor?: number;
   epoch?: string;
@@ -1761,22 +2132,18 @@ interface RelayShapePoke {
   targetConnectionId?: string;
   type: "relay_shape_poke";
 }
-type OwnerRelayFrame = RelayAttach | RelayDetach | RelayFrame | RelayShapePoke | RelayShapeSubscribe;
-declare const DEFAULT_MAX_RELAYS = 8;
-interface RelayStub {
+type OwnerRelayFrame = RelayAttach | RelayDetach | RelayFrame | RelayShapePoke | RelayShapeSubscribe | RelayShapeUnsubscribe;
+interface SiblingStub {
   fetch: (url: string, init?: RequestInit) => Promise<Response>;
 }
-interface RelayNamespaceLike {
-  get: (id: unknown) => RelayStub;
-  getByName?: (name: string) => RelayStub;
-  idFromName: (name: string) => unknown;
-}
+declare const DEFAULT_MAX_RELAYS = 8;
 interface RelayHost {
   buildShapeDiff: (resolved: ResolvedShape, fromCursor: number, toCursor: number) => ShapeRowOp[];
   computeOpLogShapeSeed: (shape: ShapeSubscriptionQuery, resolved: ResolvedShape) => {
     baseCheckpoint: number | undefined;
     cursor: number;
     epoch: string | undefined;
+    reset: boolean;
     rowsPatch: ShapeRowOp[];
   };
   currentCdcEpoch: () => string | undefined;
@@ -1791,8 +2158,13 @@ interface RelayHost {
   resolveShape: (name: string, args: Record<string, unknown>, identity?: SubscriptionIdentity) => ResolvedShape | undefined;
   rlsMetadata: () => RlsPoliciesResult;
   shardBinding: () => string | undefined;
+  shardJurisdiction: () => string | undefined;
   sql: () => SqlExec;
 }
+interface RelayPokeDelivery {
+  delivered: number;
+  matched: number;
+}
 declare abstract class RelayLink {
   protected readonly host: RelayHost;
   protected readonly roleId: {
@@ -1806,7 +2178,8 @@ declare abstract class RelayLink {
   handleControl(request: Request): Promise<Response>;
   maxRelays(): number;
   protected canAddressSiblings(): boolean;
-  protected relayNamespace(): RelayNamespaceLike | undefined;
+  protected siblingStub(targetName: string): SiblingStub | undefined;
+  protected bindingName(): string | undefined;
   protected postRelayMessage(targetName: string, message: OwnerRelayFrame): Promise<void>;
   protected requestRelayMessage(targetName: string, message: OwnerRelayFrame): Promise<Response | undefined>;
   abstract forwardWhisper(topic: string, frame: string): Promise<void>;
@@ -1817,19 +2190,22 @@ declare abstract class RelayLink {
   }>;
   abstract announce(): Promise<void>;
   abstract announceDrain(closing: ShardSocketLike): Promise<void>;
+  abstract releaseRelayShapes(ws: ShardSocketLike, subId?: string): Promise<void>;
   abstract relayCount(): number;
   abstract isShapeRelayUniform(name: string, args: Record<string, unknown>): boolean;
+  abstract minShapeCursor(): number | undefined;
   protected abstract onAttach(index: number): void;
   protected abstract onDetach(index: number): void;
   protected abstract onWhisperFrame(message: RelayFrame): Promise<void>;
   protected abstract onShapeSubscribe(message: RelayShapeSubscribe): RelayShapeSeed;
-  protected abstract onShapePoke(poke: RelayShapePoke): number;
+  protected abstract onShapeUnsubscribe(message: RelayShapeUnsubscribe): void;
+  protected abstract onShapePoke(poke: RelayShapePoke): RelayPokeDelivery;
 }
 declare class OwnerRelay extends RelayLink {
   private readonly shapeUniformCache;
   private relaySetCache;
-  private readonly relayShapeRegistry;
-  private readonly relayShapeProxies;
+  private registryCache;
+  private recordedBinding;
   private promotionState;
   constructor(host: RelayHost, ownerKey: string);
   forwardWhisper(topic: string, frame: string): Promise<void>;
@@ -1840,17 +2216,26 @@ declare class OwnerRelay extends RelayLink {
   }>;
   announce(): Promise<void>;
   announceDrain(): Promise<void>;
+  releaseRelayShapes(): Promise<void>;
   relayCount(): number;
+  minShapeCursor(): number | undefined;
   isShapeRelayUniform(name: string, args: Record<string, unknown>): boolean;
+  protected onShapeUnsubscribe(message: RelayShapeUnsubscribe): void;
   protected onAttach(index: number): void;
   protected onDetach(index: number): void;
   protected onWhisperFrame(message: RelayFrame): Promise<void>;
   protected onShapeSubscribe(message: RelayShapeSubscribe): RelayShapeSeed;
-  protected onShapePoke(): number;
+  protected onShapePoke(): RelayPokeDelivery;
+  private buildShapePoke;
   private multicastShapePokes;
+  private multicastToRelays;
   private proxyShapePokes;
+  private proxyToRelay;
   private buildShapeSeedFrames;
-  private ensureRelayTable;
+  private ensureRelayTables;
+  protected bindingName(): string | undefined;
+  private relayShapes;
+  private rewindShapeCursor;
   private ownerRelaySet;
   private addRelayToSet;
   private removeRelayFromSet;
@@ -1859,7 +2244,8 @@ declare class OwnerRelay extends RelayLink {
 }
 declare class RelayMember extends RelayLink {
   private relayAnnounced;
-  private readonly shapeRelayMemos;
+  private relayMemoCache;
+  private readonly shapeControl;
   constructor(host: RelayHost, ownerKey: string, relayIndex: number);
   forwardWhisper(topic: string, frame: string): Promise<void>;
   onFlush(): Promise<void>;
@@ -1869,17 +2255,81 @@ declare class RelayMember extends RelayLink {
   }>;
   announce(): Promise<void>;
   announceDrain(closing: ShardSocketLike): Promise<void>;
+  releaseRelayShapes(ws: ShardSocketLike, subId?: string): Promise<void>;
   relayCount(): number;
   isShapeRelayUniform(): boolean;
+  minShapeCursor(): number | undefined;
   protected onAttach(): void;
   protected onDetach(): void;
   protected onWhisperFrame(): Promise<void>;
   protected onShapeSubscribe(): RelayShapeSeed;
-  protected onShapePoke(poke: RelayShapePoke): number;
+  protected onShapeUnsubscribe(): void;
+  protected onShapePoke(poke: RelayShapePoke): RelayPokeDelivery;
+  private queueShapeControl;
+  private relayMemos;
+  private connectionMemos;
   private recordRelayShapeMemo;
+  private forgetRelayShapeMemos;
   private deliverShapePoke;
+  private pokeSocketShapes;
 }
 declare const createRelayLink: (host: RelayHost) => OwnerRelay | RelayMember | undefined;
+declare const REGION_HINTS: readonly ["wnam", "enam", "sam", "weur", "eeur", "apac", "apac-ne", "apac-se", "oc", "afr", "me"];
+type RegionHint = (typeof REGION_HINTS)[number];
+type ReplicaReadiness = "fresh" | "stale" | "unavailable";
+interface ShardSiblingHost {
+  doName: () => string | undefined;
+  env: () => unknown;
+  shardBinding: () => string | undefined;
+  shardJurisdiction: () => string | undefined;
+  sql: () => SqlExec;
+}
+interface ReplicaOwnerHost extends ShardSiblingHost {
+  exportRows: () => Promise<ExportRow[]>;
+  ownerCursor: () => number | undefined;
+  ownerEpoch: () => string | undefined;
+  ownerFloor: () => number | undefined;
+  readChanges: (sinceSeq: number, limit: number) => {
+    changes: CdcChange[];
+    cursor: number;
+  };
+  rowCount: () => number;
+}
+interface ReplicaFollowerHost extends ShardSiblingHost {
+  applyChanges: (changes: ReadonlyArray<CdcChange>) => Promise<number>;
+  importRows: (rows: ReadonlyArray<ExportRow>) => Promise<{
+    errors: ReadonlyArray<unknown>;
+  }>;
+}
+declare const handleReplicaControl: (host: ReplicaOwnerHost, request: Request) => Promise<Response>;
+declare class ShardReplica {
+  private readonly host;
+  readonly ownerKey: string;
+  readonly region: RegionHint;
+  private divergent;
+  private inFlight;
+  constructor(host: ReplicaFollowerHost, ownerKey: string, region: RegionHint);
+  ensureFresh(minSeq?: number): Promise<ReplicaReadiness>;
+  appliedSeq(): number;
+  isDivergent(): boolean;
+  private advance;
+  private isCaughtUp;
+  private catchUp;
+  private applyPage;
+  private hasDiverged;
+  private bootstrap;
+  private isFreshEnough;
+  private pull;
+  private request;
+}
+declare const createReplicaLink: (host: ReplicaFollowerHost) => ShardReplica | undefined;
+declare const gateReplicaDispatch: (replica: ShardReplica, request: Request, functionPath: string) => Promise<Response | undefined>;
+declare const REPROJECTION_MIGRATION_PREFIX = "__lunora_reproject__";
+declare const reprojectionMigrationId: (table: string) => string;
+declare const reprojectableFields: (definition: TableDefinitionLike) => string[];
+declare const reprojectionTables: (schema: SchemaLike) => string[];
+declare const countLegacyRows: (sql: SqlExec, table: string, fields: ReadonlyArray<string>) => number;
+declare const buildReprojectionMigration: (id: string, schema: SchemaLike, sql: SqlExec) => DataMigrationLike | undefined;
 declare const RLS_UNWRAP_SYMBOL: symbol;
 declare class RlsRequiredError extends LunoraError {
   readonly table: string;
@@ -1896,7 +2346,7 @@ interface GuardableSchema {
 }
 type TableOfId = (id: string, expectedTable?: string) => Promise<string | undefined> | string | undefined;
 type TablesOfIds = (ids: ReadonlyArray<string>, expectedTable?: string) => Promise<ReadonlyMap<string, string>> | ReadonlyMap<string, string>;
-declare const guardWriter: <W>(raw: W, schema: GuardableSchema, tableOfId: TableOfId, tablesOfIds?: TablesOfIds) => W;
+declare const guardWriter: <W>(raw: W, schema: GuardableSchema, tableOfId: TableOfId, tablesOfIds?: TablesOfIds, relationEdges?: ReadonlyArray<RelationEdge>) => W;
 declare const SCHEMA_HISTORY_MAX_VERSIONS = 50;
 interface SchemaVersionRow {
   appliedAt: number;
@@ -1907,8 +2357,24 @@ interface SchemaVersionRow {
 declare const recordSchemaVersion: (sql: SqlExec, hash: string, snapshotJson: string, now?: number) => boolean;
 declare const readSchemaHistory: (sql: SqlExec) => SchemaVersionRow[];
 declare const readSchemaVersion: (sql: SqlExec, hash: string) => SchemaVersionRow | undefined;
+declare const readDeployInfo: (rawEnv: unknown) => DeployInfo;
 declare const isDevEnvironment: (rawEnv: unknown) => boolean;
 declare const buildSettings: (rawEnv: unknown) => SettingsResult;
+declare class ShapeDiffCache {
+  private readonly keyScans;
+  private readonly memberProbes;
+  private run;
+  private served;
+  get probesRun(): number;
+  get probesServed(): number;
+  changedKeys(rangeKey: string, load: () => CdcChangeKey[]): ReadonlyArray<CdcChangeKey>;
+  members(resolved: ResolvedShape, rangeKey: string, load: () => Map<string, Record<string, unknown>>): ReadonlyMap<string, Record<string, unknown>>;
+  private getOrLoad;
+}
+declare const createShapeDiffCache: () => ShapeDiffCache;
+declare const globalShapeReadKey: (resolved: ResolvedShape, identity: SubscriptionIdentity) => string | undefined;
+type ReadShapeCdcKeys = (sql: SqlExec, table: string, sinceSeq: number, upTo: number) => CdcChangeKey[];
+declare const buildShapeDiff: (sql: SqlExec, resolved: ResolvedShape, sinceSeq: number, upTo: number, cache: ShapeDiffCache, readKeys?: ReadShapeCdcKeys) => ShapeRowOp[];
 interface ShardRunnerOptions {
   handlers?: {
     handleAlarm?: () => Promise<void>;
@@ -1924,7 +2390,7 @@ declare class ShardRunner {
   socketFor(raw: unknown): ShardSocketLike;
   sockets(tag?: string): SocketHandle[];
   background(work: Promise<unknown>): boolean;
-  runInTransaction<T>(work: () => Promise<T>): Promise<T>;
+  runInTransaction<T>(work: () => Promise<T>, onCommitted?: () => void): Promise<T>;
   handleFetch(request: Request): Promise<Response>;
   handleAlarm(): Promise<void>;
 }
@@ -1950,6 +2416,11 @@ interface SqlDiagnostic {
   source: "gate" | "plan" | "syntax";
 }
 declare const lintReadonlySql: (sql: SqlExec, query: string) => SqlLintResult;
+declare const BIGINT_KEY_DIGITS = 39;
+declare const bigintSqlKey: (value: bigint) => string;
+declare const decodeBigintSqlKey: (raw: string) => bigint | undefined;
+declare const float64SqlKey: (value: number) => string;
+declare const decodeFloat64SqlKey: (raw: string) => number | undefined;
 declare const subscriptionListDeltas: (previousJson: string, nextResult: unknown, table: string, frames?: string[]) => MutationDelta[] | undefined;
 interface FrameSink {
   send: (data: string) => void;
@@ -1958,7 +2429,17 @@ interface DrainableSink {
   readonly bufferedAmount?: unknown;
 }
 declare const trySendFrame: (ws: FrameSink, frame: string) => boolean;
-declare const sendDeltaFrames: (ws: FrameSink, subId: string, deltaFrames: ReadonlyArray<string>, cursorSuffix: string, lastMutationId?: number) => boolean;
+interface SubscriptionFrameInput {
+  cursorSuffix: string;
+  lastMutationId?: number;
+  nextResult: unknown;
+  pageDeltas?: boolean;
+  previousJson?: string;
+  snapshotJson: string;
+  subId: string;
+  table: string;
+}
+declare const subscriptionFrames: (input: SubscriptionFrameInput) => string[];
 declare const awaitWsDrain: (ws: DrainableSink) => Promise<void>;
 interface SubscriptionReadFootprint {
   ranges?: Map<string, KeyRange[]>;
@@ -1986,13 +2467,51 @@ declare const selectExpiredIds: (sql: SqlExec, spec: TtlSweepSpec, now: number,
   hasMore: boolean;
   ids: string[];
 };
-type FieldRefSql = (field: string) => SQL;
-type SerializeValue = (value: unknown) => unknown;
-interface WhereSqlStrategy {
-  fieldRef: FieldRefSql;
-  likeContains?: (reference: SQL, term: SQL) => SQL;
-  relationExists?: (request: unknown) => SQL;
+declare const VECTOR_BACKFILL_MAX_PAGES = 20;
+interface VectorBackfillTarget {
+  profile: string;
+  table: string;
+}
+interface VectorBackfillProgress {
+  done: boolean;
+  error?: string;
+  failed: number;
+  failedIds: string[];
+  pages: number;
+  rows: number;
+}
+type VectorPageSync = (table: string, rows: ReadonlyArray<{
+  doc: Record<string, unknown>;
+  id: string;
+}>) => Promise<ReadonlyArray<{
+  error: unknown;
+  id: string;
+}>>;
+type OrderedAfterWrites = <T, U>(read: () => T, work: (value: T) => Promise<U>) => Promise<U>;
+declare const backfillVectorIndexes: (sql: SqlExec, targets: ReadonlyArray<VectorBackfillTarget>, sync: VectorPageSync, options: {
+  maxPages?: number;
+  ordered: OrderedAfterWrites;
+  restart?: boolean;
+}) => Promise<VectorBackfillProgress>;
+interface WhereFragments<T> {
+  binary: (reference: T, comparator: string, value: unknown) => T;
+  connect: (left: T, right: T, connector: "AND" | "OR") => T;
+  constant: (value: boolean) => T;
+  contains: (reference: T, term: T) => T;
+  inList: (reference: T, items: ReadonlyArray<unknown>, negated: boolean, budget: number) => T;
+  negate: (inner: T) => T;
+  nullCheck: (reference: T, negated: boolean) => T;
+  value: (value: unknown) => T;
+}
+type FieldRefSql<T> = (field: string) => T;
+type SerializeValue = (value: unknown, field: string) => unknown;
+interface WhereSqlStrategy<T = SQL> {
+  containsExpr?: (reference: T, term: T) => T;
+  fieldRef: FieldRefSql<T>;
+  inList?: (reference: T, items: ReadonlyArray<unknown>, negated: boolean, budget?: number) => T;
+  relationExists?: (request: unknown) => T;
   serialize: SerializeValue;
 }
-declare const compileWhereSql: (where: WhereInput | undefined, strategy: WhereSqlStrategy) => SQL | undefined;
-export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, AGGREGATE_SQL_FUNCTION, AGG_COUNT, AGG_KEY, AGG_VALUE, AUDIT_LOG_TABLE, type AdvisorProcedure, type AdvisorProceduresResult, type AdvisoriesResult, type AdvisoryFinding, type AggregateIndexDefinitionLike, type AggregateOp, type AggregateOptions, type AggregateResult, type AggregateTally, type AppendAuditEntry, type ApplyOnDeleteOptions$1 as ApplyOnDeleteOptions, type AuditEntry, type AuditLogResult, type BroadcastDelta, CDC_LOG_TABLE, CDC_META_TABLE, CLIENT_WATERMARK_TABLE, type CacheEntry, type CapturedMailRow, type CdcChange, type ChangedKeys, type Clock, type ColumnMeta, type ColumnMetaLike, type CompanionSync, type CompanionSyncDeps, ConflictError, type ConflictKind, type CountArgs, CountRlsUnsupportedError, type CreateWorkflowInstanceResult, type CtxDbOptions, DATA_MIGRATION_STATE_TABLE, DEFAULT_FANOUT_TOPIC_LIMIT, DEFAULT_MAX_RELATION_KEYS, DEFAULT_MAX_RELAYS, DEFAULT_PROMOTION_THRESHOLDS, DEFAULT_TRANSACTION_LIMITS, DOC_COLUMN, type DataMigrationDocument, type DataMigrationLike, type DataMigrationTransform, type DatabaseWriterLike, type DependencyTracker, type DeployInfo, type ExportRow, type ExportShardAdminArgs, type ExportShardArgs, type ExternalSourceDiffResult, type ExternalSourceLike, FLAGS_FUNCTION_PREFIX, type FacetColumnOptions, type FacetColumnResult, type FacetValue, type FanoutMetricsResult, type FanoutPathCounters, type FanoutTopicStat, type FieldOperators, type FilterClause, type FilterOperator, type FlagEvaluation, type FlagsResult, type FunctionCallStat, type FunctionScanAttribution, type FunctionStatsResult, GEO_DEFAULT_PRECISION, GLOBAL_SHAPE_SNAPSHOT_TABLE, type GeoBoundingBox, type GeoFilterBuilderLike, type GeoIndexDefinitionLike, type GeoPoint, type GeoScoredDocument, type GroupByEntry, type GroupByOptions, type GuardableSchema$1 as GuardableSchema, IDEMPOTENCY_TABLE, type IdGenerator, type IdempotentRecord, type ImportError, type ImportShardAdminArgs, type ImportShardArgs, type ImportShardResult, type IncrementalMaterializeResult, type IndexDefinitionLike, type IndexKeyEntry, type IndexRangeBuilderLike, type KeyRange, type LifecycleDispatchInfo, type LifecycleEvent, MAIL_RETENTION, MAIL_TABLE, MAX_PAGE_SIZE, MAX_SQL_ROWS, type MaskColumnMetadata, type MaskPoliciesResult, type MaterializeResult, type MigrationDirection, type MigrationRunResult, type MigrationStatus, type MigrationStatusRow, type MutationDelta, type NestedWith, NotFoundError, NotUniqueError, type OnDeleteActionLike, type OrderByClause, type OrderByInput, type OrderKey, OwnerRelay, type OwnerRelayFrame, type PaginationOptions, type PitrBookmarkResult, type PitrRestoreArgs, type PitrRestoreResult, type PitrStorage, type PokeFrameMeta, type PromotionState, type PromotionThresholds, QUEUE_TABLE, type QueryArgs, type QueryPage, type QueueMessageOutcome, type QueueMessageRow, type QueueMetadata, type QueuesResult, RANK_TIEBREAK, RELATION_EXISTS_KEY, RELATION_FUNCTION_PREFIX, RLS_UNWRAP_SYMBOL, type RankBeforeOptions, type RankBeforeResult, type RankDirection, type RankIndexDefinitionLike, type RankOptions, type RankPage, type RankPageComputation, type RankPageDeps, type RankPageOptions, type RankPageRow, type RankPageRowKey, type RankResult, type RankSortKeyLike, ReactiveCache, type ReactiveCacheOptions, type ReadFootprint, type ReadHook, type ReadTablePageOptions, type RecordMailInput, type RecordQueueMessageInput, type RelationDefinitionLike, type RelationExistsMarker, type RelayAttach, type RelayDetach, type RelayFrame, type RelayHost, RelayMember, type RelayShapePoke, type RelayShapeSeed, type RelayShapeSubscribe, type RenderedSql, type ResolveRelationPredicatesOptions, type ResolveWithOptions, type ResolveWithResult, type ResolvedShape, type RestrictableQueryOptions, type RlsPoliciesResult, type RlsPolicyMetadata, RlsRequiredError, type RlsRoleMetadata, type RpcRequest, type RunDataMigrationOptions, type RunTriggersOptions, SCAN_DEP, SCHEMA_HISTORY_MAX_VERSIONS, SEARCH_STATE_TABLE, type SchedulableWorkflowReferenceLike, type ScheduledFunctionDoc, type SchedulerLike, type SchemaLike, type ScoredDocument, type SearchFilterBuilderLike, type SearchIndexDefinitionLike, type SearchScoredDocument, type SelectMatchingIdsOptions, type ServerDefaultContextLike, type SettingEntry, type SettingKind, type SettingsResult, type ShapePokePart, type ShapeRow, type ShapeRowOp, type ShapeSubscriptionQuery, type ShardRankPageResult, ShardRunner, type ShardRunnerOptions, type ShardSocketLike, type SocketAttachment, type SortDirection, type SourceClientLike, type SourceCursorLike, type SourceRefresh, type SqlConsoleResult, type SqlCursor, type SqlEngine, type SqlExec, type SqlLintResult, type StorageMetadata, type StorageReference, type StorageReferenceResult, type StorageRuleMetadata, type StorageRulesResult, type StudioFeaturesResult, type SubscriptionConnection, type SubscriptionEnvelope, type SubscriptionIdentity, type SubscriptionInfo, type SubscriptionQuery, type SubscriptionReadFootprint, type SubscriptionsResult, type SystemDatabaseReader, type SystemDoc, type SystemQuery, type SystemReaderOptions, type SystemReaderSchedulerLike, type SystemReaderStorageLike, type SystemTableName, type TableColumnsResult, type TableDefinitionLike, type TableIndexInfo, type TableIndexesResult, type TableInfo, type TablePage, type TableReaderLike, type TablesColumnsResult, type TablesIndexesResult, type TransactionHeadroom, TransactionHeadroomTracker, type TransactionLimits, type TransactionSqlLike, type TriggerContextLike, type TriggerDefinitionLike, type TriggerEventLike, type TriggerOpLike, type TriggerTimingLike, type TtlSweepSpec, type ValidatorLike, type WhereInput, type WhereSqlStrategy, type WithInput, type WorkflowInstanceState, type WorkflowInstanceStatusResult, type WorkflowMetadata, type WorkflowsResult, type WriteEvent, type WriteHook, advanceClientWatermark, aggUpsertSql, aggregateSqlFunction, aggregateTableName, appendAuditEntry, appendCdcChange, applyCdcChanges, applyOnDelete, applySelect, armRestore, assertFlatPredicate, assertReadonly, assertShapeShardable, assertValidClientId, awaitWsDrain, backfillAggregateIndexes, backfillRankIndexes, backfillSearchIndexes, backfillSearchIndexesForTable, boundingBoxCenter, boundingBoxGeohashes, buildIndexRange, buildPokeFrames, buildSeekBeforeWhere, buildSeekWhere, buildSettings, bumpCdcEpoch, clampPromotionThresholds, clearCapturedMail, clearQueueMessages, coerceAggregateNumber, compileWhereSql, computeRankPage, containsRelationPredicate, coveringGeohashes, createCompanionSync, createDependencyTracker, createFanoutCounters, createIndexSql, createReadFootprint, createRelayLink, createShardCtxDb, createSystemReader, decodeCursor, deleteGlobalShapeSnapshot, deleteGlobalShapeSnapshotsForConnection, depKey, diffExternalSource, diffGlobalMembership, distinctValues, encodeAggregateKey, encodeCursor, encodeGeohash, encodePartitionKey, encodeRowsPatch, ensureAuditTable, ensureMailTable, exportShardRows, exportShardTable, facetColumn, fanOutScalarCounts, findStorageReferences, foldAggregateTally, geoTableName, guardWriter, hasTrigger, haversineMeters, hydrateDocsById, importShardRows, indexKeysForRow, isDevEnvironment, isFtsAvailable, isLossyBody, isRelationPredicate, isSoftDeleted, isSourceDue, jsonPath, jsonPathSql, keysTouchRanges, liftSourceId, lintReadonlySql, listTables, matchesRankStaticWhere, matchesStaticWhere, materializeExternalRows, materializeExternalRowsIncremental, mergeChangedKeys, mergeWhere, migrateCdcLog, migrateCdcMeta, migrateClientWatermark, migrateGlobalShapeSnapshot, migrateIdempotency, migrateSearchState, minCdcSeq, nextPromotionState, normalizeCountArgument, normalizeIdStructurally, normalizeOrderKeys, normalizeSourceDocument, normalizeSourceValue, param, parseExportShardArgs, parseImportShardArgs, planAggregateLookup, pointInBoundingBox, projectColumns, pullExternalSourceIncrementalTick, pullExternalSourceTick, qualifiedJsonPath, qualifiedJsonPathSql, quoteIdentifier, rankKeyFromDocument as rankKeyFromDoc, rankTableName, reactiveCacheKey, readAggregateValue, readAuditLog, readBookmark, readCapturedMail, readCdcChanges, readCdcCursor, readCdcEpoch, readClientWatermark, readExternalSourceBaseline, readGlobalShapeSnapshot, readIdempotent, readMigrationStatus, readQueueMessageById, readQueueMessages, readSchemaHistory, readSchemaVersion, readSearchBackfillState, readTablePage, recordCapturedMail, recordChangedKeys, recordFanoutPass, recordQueueMessages, recordSchemaVersion, relayCountFor, renderSql, resolveRankPartition, resolveRelationPredicates, resolveWith, rowToDocument, runDataMigration, runDrizzle, runExternalSourceTick, runReadonlySql, runRowValidators, runShardMigrations, runSocketPool, runSql, runTriggers, selectExpiredIds, selectExportTables, selectIndexForAggregate, selectIndexForCount, selectIndexForGroupBy, selectMatchingIds, selectShapeMemberIds, selectShapeRows, sendDeltaFrames, serializeSqlValue, shapeRoutingKey, softDeleteScope, sortColumnName, stableStringify, stableWireKey, subscriptionListDeltas, summarizeFanoutTopics, summarizeSubscriptions, tableColumns, tableFromDepKey, throwingScheduler, trimCdcChanges, trimIdempotent, tryRowToDocument, trySendFrame, validateImportRow, writeGlobalShapeSnapshot, writeIdempotent, writeSearchBackfillState, writeTouchesMemo };
+declare const literalInList: (reference: SQL, items: ReadonlyArray<unknown>, negated: boolean) => SQL;
+declare const compileWhereSql: <T = SQL>(where: WhereInput | undefined, strategy: WhereSqlStrategy<T>, fragments?: WhereFragments<T>, reservedParams?: number) => T | undefined;
+export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, AGGREGATE_SQL_FUNCTION, AGG_COUNT, AGG_KEY, AGG_VALUE, AUDIT_LOG_TABLE, type AdvisorProcedure, type AdvisorProceduresResult, type AdvisoriesResult, type AdvisoryFinding, type AggregateIndexDefinitionLike, type AggregateOp, type AggregateOptions, type AggregateResult, type AggregateTally, type AppendAuditEntry, type ApplyOnDeleteOptions$1 as ApplyOnDeleteOptions, type AuditEntry, type AuditLogResult, BIGINT_KEY_DIGITS, type BroadcastDelta, CDC_LOG_TABLE, CDC_LOG_TABLE_SEQ_INDEX, CDC_META_TABLE, CLIENT_WATERMARK_TABLE, COMMIT_SEQ_FIELD, COMMIT_SEQ_TABLE, CURSOR_PREFIX, type CacheEntry, type CapturedMailRow, type CdcArchiveScope, type CdcChange, type CdcChangeKey, type ChangedKeys, type Clock, type ColumnMeta, type ColumnMetaLike, type CompanionSync, type CompanionSyncDeps, ConflictError, type ConflictKind, type CountArgs, CountRlsUnsupportedError, type CreateWorkflowInstanceResult, type CrossShardReadArgs, type CtxDbOptions, DATA_MIGRATION_STATE_TABLE, DEFAULT_FANOUT_TOPIC_LIMIT, DEFAULT_MAX_RELATION_KEYS, DEFAULT_MAX_RELAYS, DEFAULT_PROMOTION_THRESHOLDS, DEFAULT_TRANSACTION_LIMITS, DOC_COLUMN, type DataMigrationDocument, type DataMigrationLike, type DataMigrationTransform, type DatabaseWriterLike, type DependencyTracker, type DeployInfo, type DurableAttachDecision, type DurableStreamAttach, type DurableStreamRun, DurableStreamRunner, type DurableStreamSink, type ExportRow, type ExportShardAdminArgs, type ExportShardArgs, type ExternalSourceDiffResult, type ExternalSourceLike, FLAGS_FUNCTION_PREFIX, type FacetColumnOptions, type FacetColumnResult, type FacetValue, type FanOutBudget, type FanoutMetricsResult, type FanoutPathCounters, type FanoutTopicStat, type FieldOperators, type FilterClause, type FilterOperator, type FlagEvaluation, type FlagsResult, type FtsWriteOptions, type FunctionCallStat, type FunctionScanAttribution, type FunctionStatsResult, GEO_DEFAULT_PRECISION, GLOBAL_SHAPE_SNAPSHOT_TABLE, type GeoBoundingBox, type GeoFilterBuilderLike, type GeoIndexDefinitionLike, type GeoPoint, type GeoScoredDocument, type GlobalPollCounters, GlobalPollTick, type GroupByEntry, type GroupByOptions, type GuardableSchema$1 as GuardableSchema, IDEMPOTENCY_TABLE, type IdGenerator, type IdempotentRecord, type ImportError, type ImportShardAdminArgs, type ImportShardArgs, type ImportShardResult, type IncrementalMaterializeResult, type IndexDefinitionLike, type IndexKeyEntry, type IndexRangeBuilderLike, type KeyRange, type LifecycleDispatchInfo, type LifecycleEvent, MAIL_RETENTION, MAIL_TABLE, MAX_DURABLE_STREAM_BYTES, MAX_DURABLE_STREAM_CHUNKS, MAX_PAGE_SIZE, MAX_SQL_ROWS, type MaskColumnMetadata, type MaskPoliciesResult, type MaterializeResult, type MigrationDirection, type MigrationRunResult, type MigrationStatus, type MigrationStatusRow, type MutationDelta, type NestedWith, NotFoundError, NotUniqueError, type OnDeleteActionLike, type OrderByClause, type OrderByInput, type OrderKey, type OrderKeyConstraints, OwnerRelay, type OwnerRelayFrame, type PaginationOptions, type PitrBookmarkResult, type PitrRestoreArgs, type PitrRestoreResult, type PitrStorage, type PokeFrameMeta, type PromotionState, type PromotionThresholds, QUEUE_TABLE, type QueryArgs, type QueryPage, type QueueMessageOutcome, type QueueMessageRow, type QueueMetadata, type QueuesResult, RANK_TIEBREAK, REACTOR_STATE_TABLE, RELATED_DEFAULT_LIMIT, RELATED_DEPTH_DECAY, RELATED_MAX_DEPTH, RELATED_MAX_LIMIT, RELATION_EXISTS_KEY, RELATION_FUNCTION_PREFIX, REPROJECTION_MIGRATION_PREFIX, RLS_UNWRAP_SYMBOL, type RankBeforeOptions, type RankBeforeResult, type RankDirection, type RankIndexDefinitionLike, type RankOptions, type RankPage, type RankPageComputation, type RankPageDeps, type RankPageOptions, type RankPageRow, type RankPageRowKey, type RankResult, type RankSortKeyLike, ReactiveCache, type ReactiveCacheOptions, type ReactorDispatchResult, type ReactorMetadata, type ReactorState, type ReactorStats, type ReactorsResult, type ReadFootprint, type ReadHook, type ReadTablePageOptions, type RecordMailInput, type RecordQueueMessageInput, type RelatedDirection, type RelatedNode, type RelatedOptions, type RelatedPage, type RelatedStart, type RelatedStartReference, type RelationDefinitionLike, type RelationEdge, type RelationExistsMarker, type RelationGraphReader, type RelayAttach, type RelayDetach, type RelayFrame, type RelayHost, RelayMember, type RelayPokeDelivery, type RelayShapePoke, type RelayShapeSeed, type RelayShapeSubscribe, type RelayShapeUnsubscribe, type RenderedSql, type ReplicaFollowerHost, type ReplicaOwnerHost, type ReplicaReadiness, type ResolveRelationPredicatesOptions, type ResolveWithOptions, type ResolveWithResult, type ResolvedShape, type RestrictableQueryOptions, type RlsPoliciesResult, type RlsPolicyMetadata, RlsRequiredError, type RlsRoleMetadata, type RpcRequest, type RunDataMigrationOptions, type RunTriggersOptions, SCAN_DEP, SCHEDULE_OUTBOX_TABLE, SCHEMA_HISTORY_MAX_VERSIONS, SEARCH_STATE_TABLE, SHAPE_POKE_CURSOR_TABLE, type SchedulableWorkflowReferenceLike, type ScheduleOutbox, type ScheduleOutboxEnvelope, type ScheduleOutboxRow, type ScheduledFunctionDoc, type SchedulerLike, type SchemaLike, type ScoredDocument, type SearchBackfillProgress, type SearchFilterBuilderLike, type SearchIndexDefinitionLike, type SearchScoredDocument, type SelectMatchingIdsOptions, type ServerDefaultContextLike, type SettingEntry, type SettingKind, type SettingsResult, ShapeDiffCache, type ShapePokeCursorRow, type ShapePokePart, type ShapeProbeCounters, type ShapeRow, type ShapeRowOp, type ShapeSubscriptionQuery, type ShardRankPageResult, ShardRunner, type ShardRunnerOptions, type ShardSiblingHost, type ShardSocketLike, type SocketAttachment, type SortDirection, type SourceClientLike, type SourceCursorLike, type SourceRefresh, type SqlConsoleResult, type SqlCursor, type SqlEngine, type SqlExec, type SqlLintResult, type StorageMetadata, type StorageReference, type StorageReferenceResult, type StorageRuleMetadata, type StorageRulesResult, type StudioFeaturesResult, type SubscriptionConnection, type SubscriptionEnvelope, type SubscriptionIdentity, type SubscriptionInfo, type SubscriptionQuery, type SubscriptionReadFootprint, type SubscriptionsResult, type SystemDatabaseReader, type SystemDoc, type SystemQuery, type SystemReaderOptions, type SystemReaderSchedulerLike, type SystemReaderStorageLike, type SystemTableName, type TableColumnsResult, type TableDefinitionLike, type TableIndexInfo, type TableIndexesResult, type TableInfo, type TablePage, type TableReaderLike, type TablesColumnsResult, type TablesIndexesResult, type TransactionHeadroom, TransactionHeadroomTracker, type TransactionLimits, type TransactionSqlLike, type TriggerContextLike, type TriggerDefinitionLike, type TriggerEventLike, type TriggerOpLike, type TriggerTimingLike, type TtlSweepSpec, UNVOUCHABLE_DEP, VECTOR_BACKFILL_MAX_PAGES, type ValidatorLike, type VectorBackfillProgress, WORKERD_SQLITE_LIMITS, type WhereFilter, type WhereInput, type WhereSqlStrategy, type WithInput, type WorkflowInstanceState, type WorkflowInstanceStatusResult, type WorkflowMetadata, type WorkflowsResult, type WriteEvent, type WriteHook, advanceClientWatermark, aggUpsertSql, aggregateSqlFunction, aggregateTableName, allocateCommitSeq, appendAuditEntry, appendCdcChange, appendStreamChunk, applyCdcChanges, applyOnDelete, applySelect, archiveCdcSegment, armRestore, assertFlatPredicate, assertNoExplicitUndefined, assertReadonly, assertShapeShardable, assertValidClientId, awaitWsDrain, backfillAggregateIndexes, backfillRankIndexes, backfillSearchIndexes, backfillSearchIndexesForTable, backfillVectorIndexes, bigintSqlKey, boundingBoxCenter, boundingBoxGeohashes, buildIndexRange, buildPokeFrames, buildReprojectionMigration, buildSeekBeforeWhere, buildSeekWhere, buildSettings, buildShapeDiff, bumpCdcEpoch, cdcArchiveRewound, cdcCanVouchFor, cdcForkedError, cdcSeqLeavingRows, cdcTouchesTables, cdcTrimmedError, claimStreamRun, clampPromotionThresholds, clearCapturedMail, clearMemoryTables, clearQueueMessages, coerceAggregateNumber, compactCdcDocs, compileWhereSql, computeRankPage, containsRelationPredicate, countLegacyRows, coveringGeohashes, createCompanionSync, createDependencyTracker, createFanoutCounters, createGlobalPollCounters, createIndexSql, createReadFootprint, createRelayLink, createReplicaLink, createShapeDiffCache, createShapeProbeCounters, createShardCtxDb, createSystemReader, cursorBelowRetainedFloor, decideDurableAttach, decodeBigintSqlKey, decodeCursor, decodeFloat64SqlKey, deferScheduleOutbox, deleteGlobalShapeSnapshot, deleteGlobalShapeSnapshotsForConnection, deleteShapePokeCursor, deleteShapePokeCursorsForConnection, deleteStreamRun, depKey, deriveRelationEdges, diffExternalSource, diffGlobalMembership, distinctValues, encodeAggregateKey, encodeCursor, encodeGeohash, encodePartitionKey, encodeRowsPatch, ensureAuditTable, ensureMailTable, envOptionalPositiveInt, envPositiveInt, equalityPinnedFields, exportShardRows, facetColumn, fanOutScalarCounts, findRelated, findStorageReferences, finishStreamRun, float64SqlKey, foldAggregateTally, forgetScheduleOutbox, ftsCompanionDdl, ftsPurgeDocument, ftsRowidMapName, ftsUnmappedPage, ftsWriteDocument, gateReplicaDispatch, geoTableName, globalShapeReadKey, groupUnmappedRows, guardWriter, handleReplicaControl, hasTrigger, haversineMeters, importShardRows, indexKeysForRow, isDevEnvironment, isFtsAvailable, isLossyBody, isMemoryTable, isPushableWhere, isRelationPredicate, isSoftDeleted, isSourceDue, jsonPath, jsonPathSql, keysTouchRanges, liftSourceId, lintReadonlySql, listReactorStates, listTables, literalInList, markUnvouchableReads, matchesRankStaticWhere, matchesStaticWhere, materializeExternalRows, materializeExternalRowsIncremental, memoryTableNames, mergeChangedKeys, mergeWhere, migrateCdcLog, migrateCdcMeta, migrateClientWatermark, migrateCommitSeq, migrateDurableStreams, migrateGlobalShapeSnapshot, migrateIdempotency, migrateReactorState, migrateScheduleOutbox, migrateSearchState, migrateShapePokeCursor, minCdcReplayableSeq, minCdcSeq, minShapePokeCursor, nextPromotionState, normalizeCountArgument, normalizeIdStructurally, normalizeOrderKeys, normalizeSourceDocument, normalizeSourceValue, param, parkScheduleOutbox, parseExportShardArgs, parseImportShardArgs, planAggregateLookup, pointInBoundingBox, probeScheduleOutbox, projectColumns, pullExternalSourceIncrementalTick, pullExternalSourceTick, qualifiedJsonPath, qualifiedJsonPathSql, quoteIdentifier, rankKeyFromDocument as rankKeyFromDoc, rankPivotConditionSql, rankTableName, reactiveCacheKey, reactorNeedsRun, readAggregateValue, readArchivedCdcChanges, readAuditLog, readBookmark, readCapturedMail, readCdcArchivedThrough, readCdcChangeKeys, readCdcChanges, readCdcCursor, readCdcEpoch, readClientWatermark, readCommitSeq, readDeployInfo, readDueScheduleOutbox, readExternalSourceBaseline, readGlobalShapeSnapshot, readIdempotent, readMigrationStatus, readQueueMessageById, readQueueMessages, readReactorState, readSchemaHistory, readSchemaVersion, readSearchBackfillState, readShapePokeCursor, readStreamChunks, readStreamRun, readTablePage, recordCapturedMail, recordChangedKeys, recordFanoutPass, recordGlobalPollPass, recordQueueMessages, recordScheduleOutbox, recordSchemaVersion, recordShapeProbePass, relationHooks, relayCountFor, renderSql, reprojectableFields, reprojectionMigrationId, reprojectionTables, resolveRankPartition, resolveRankSeekTuple, resolveRelationPredicates, resolveWith, rowToDocument, runDataMigration, runDrizzle, runExternalSourceTick, runReadonlySql, runRowValidators, runShardMigrations, runSocketPool, runSql, runTriggers, selectExpiredIds, selectExportTables, selectIndexForAggregate, selectIndexForCount, selectIndexForGroupBy, selectMatchingIds, selectShapeMembers, selectShapeRows, serializeSqlValue, shapeRoutingKey, softDeleteScope, sortColumnName, sqliteInList, stableStringify, stableWireKey, stripReservedPatchFields, subscriptionFrames, subscriptionListDeltas, summarizeFanoutTopics, summarizeSubscriptions, tableColumns, tableFromDepKey, throwingScheduler, tiebreakDirectionFor, trimCdcChanges, trimIdempotent, trimScheduleOutbox, trimStreamRuns, tryRowToDocument, trySendFrame, unionAll, uniqueIndexFields, validateImportRow, whereFilter, whereOfFilter, writeCdcArchivedThrough, writeGlobalShapeSnapshot, writeIdempotent, writeReactorState, writeSearchBackfillState, writeShapePokeCursor, writeShapePokeCursors, writeTouchesMemo };