@lunora/shard-engine 0.0.0 → 1.0.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,1905 @@
+import { LunoraError } from '@lunora/errors';
+import { SQL, Name } from 'drizzle-orm';
+import { ShardHost, SocketHost, SocketHandle } from '@lunora/platform';
+type SystemTableName = "_scheduled_functions" | "_storage";
+interface ScheduledFunctionDoc {
+  args: Record<string, unknown>;
+  attempts?: number;
+  enqueuedAt: number;
+  functionPath: string;
+  id: string;
+  scheduledFor: number;
+  shardKey?: string;
+}
+interface StorageMetadata {
+  contentType?: string;
+  customMetadata?: Record<string, string>;
+  key: string;
+  sha256?: string;
+  size: number;
+  uploaded?: number;
+}
+interface SystemDocMap {
+  _scheduled_functions: ScheduledFunctionDoc;
+  _storage: StorageMetadata;
+}
+type SystemDoc<T extends SystemTableName> = SystemDocMap[T];
+interface SystemQuery<T extends SystemTableName> {
+  collect: () => Promise<SystemDoc<T>[]>;
+}
+interface SystemDatabaseReader {
+  get: <T extends SystemTableName>(table: T, id: string) => Promise<SystemDoc<T> | null>;
+  query: <T extends SystemTableName>(table: T) => SystemQuery<T>;
+}
+interface SystemReaderSchedulerLike {
+  get: (id: string) => Promise<Record<string, unknown> | null>;
+  list: () => Promise<ReadonlyArray<Record<string, unknown>>>;
+}
+interface SystemReaderStorageLike {
+  getMetadata: (key: string) => Promise<StorageMetadata | null>;
+  list: (prefix?: string, options?: Record<string, unknown>) => Promise<{
+    objects: ReadonlyArray<Record<string, unknown>>;
+  }>;
+}
+interface SystemReaderOptions {
+  scheduler?: SystemReaderSchedulerLike;
+  storage?: SystemReaderStorageLike;
+}
+declare const createSystemReader: (options?: SystemReaderOptions) => SystemDatabaseReader;
+interface FieldOperators {
+  contains?: string;
+  eq?: unknown;
+  gt?: unknown;
+  gte?: unknown;
+  in?: unknown[];
+  isNull?: boolean;
+  lt?: unknown;
+  lte?: unknown;
+  ne?: unknown;
+  notIn?: unknown[];
+}
+interface WhereInput {
+  [field: string]: unknown;
+  AND?: WhereInput[];
+  NOT?: WhereInput;
+  OR?: WhereInput[];
+}
+declare const RELATION_EXISTS_KEY = "__relationExists";
+type AggregateOp = "avg" | "count" | "max" | "min" | "sum";
+interface AggregateIndexDefinitionLike {
+  readonly by?: ReadonlyArray<string>;
+  readonly field?: string;
+  readonly name: string;
+  readonly on: string;
+  readonly op: AggregateOp;
+  readonly where?: Record<string, unknown>;
+}
+interface GeoIndexDefinitionLike {
+  readonly field: string;
+  readonly name: string;
+  readonly precision?: number;
+}
+interface IndexDefinitionLike {
+  readonly fields: ReadonlyArray<string>;
+  readonly name: string;
+  readonly unique?: boolean;
+}
+interface RankIndexDefinitionLike {
+  readonly name: string;
+  readonly on: string;
+  readonly partitionBy?: ReadonlyArray<string>;
+  readonly sortBy: ReadonlyArray<RankSortKeyLike>;
+  readonly where?: Record<string, unknown>;
+}
+interface SearchIndexDefinitionLike {
+  readonly field: string;
+  readonly filterFields?: ReadonlyArray<string>;
+  readonly language?: string;
+  readonly name: string;
+  readonly staged?: boolean;
+  readonly strategy?: string;
+}
+interface ServerDefaultContextLike {
+  readonly auth: {
+    readonly identity: Record<string, unknown> | null;
+    readonly userId: null | string;
+  };
+}
+interface ColumnMetaLike {
+  readonly defaultFn?: () => unknown;
+  readonly defaultValue?: unknown;
+  readonly notNull?: boolean;
+  readonly onUpdateFn?: () => unknown;
+  readonly serverDefault?: (context: ServerDefaultContextLike) => unknown;
+  readonly unique?: boolean;
+}
+interface ValidatorLike {
+  readonly _meta?: {
+    readonly column?: ColumnMetaLike;
+  };
+  readonly kind?: string;
+  readonly parse?: (value: unknown) => unknown;
+}
+type TriggerTimingLike = "after" | "before";
+type TriggerOpLike = "delete" | "insert" | "update";
+interface SchedulableWorkflowReferenceLike {
+  readonly binding?: string;
+  readonly isLunoraWorkflow: true;
+  readonly name?: string;
+}
+interface SchedulerLike {
+  runAfter: (delayMs: number, target: SchedulableWorkflowReferenceLike | string, args?: Record<string, unknown>) => Promise<string>;
+  runAt: (timestampMs: number, target: SchedulableWorkflowReferenceLike | string, args?: Record<string, unknown>) => Promise<string>;
+}
+interface TriggerEventLike {
+  doc?: Record<string, unknown>;
+  id: string;
+  op: TriggerOpLike;
+  previous?: Record<string, unknown>;
+  table: string;
+}
+interface TriggerContextLike {
+  db: DatabaseWriterLike;
+  scheduler: SchedulerLike;
+}
+interface TriggerDefinitionLike {
+  readonly handler: (context: TriggerContextLike, event: TriggerEventLike) => Promise<void> | void;
+  readonly op: TriggerOpLike;
+  readonly timing: TriggerTimingLike;
+}
+interface GuardableSchema$1 {
+  readonly rlsMode?: "required";
+  readonly tables: Record<string, {
+    readonly isPublic?: boolean;
+  }>;
+}
+interface SchemaLike {
+  readonly rlsMode?: "required";
+  readonly tables: Record<string, TableDefinitionLike>;
+}
+interface TableDefinitionLike {
+  readonly aggregateIndexes?: ReadonlyArray<AggregateIndexDefinitionLike>;
+  readonly geoIndexes?: ReadonlyArray<GeoIndexDefinitionLike>;
+  readonly indexes: ReadonlyArray<IndexDefinitionLike>;
+  readonly isPublic?: boolean;
+  readonly rankIndexes?: ReadonlyArray<RankIndexDefinitionLike>;
+  readonly relationMap?: Record<string, RelationDefinitionLike>;
+  readonly searchIndexes?: ReadonlyArray<SearchIndexDefinitionLike>;
+  readonly shape: Record<string, ValidatorLike>;
+  readonly shardMode?: {
+    field?: string;
+    kind: "global" | "root" | "shardBy";
+  };
+  readonly softDeleteMode?: {
+    field: string;
+  };
+  readonly triggerMap?: Record<string, TriggerDefinitionLike>;
+  readonly ttlPolicy?: {
+    after?: number;
+    field: string;
+  };
+}
+interface RelationDefinitionLike {
+  readonly field: string;
+  readonly kind: "many" | "one";
+  readonly onDelete?: OnDeleteActionLike;
+  readonly references: string;
+  readonly table: string;
+}
+type OnDeleteActionLike = "cascade" | "restrict" | "set null";
+interface NestedWith {
+  limit?: number;
+  orderBy?: OrderByInput[];
+  select?: ReadonlyArray<string>;
+  where?: WhereInput;
+  with?: WithInput;
+}
+interface WithInput {
+  [relationName: string]: NestedWith | Record<string, true> | boolean | undefined;
+  _count?: Record<string, true>;
+}
+interface ApplyOnDeleteOptions$1 {
+  database: DatabaseWriterLike;
+  relation: RelationDefinitionLike;
+  row: Record<string, unknown>;
+  tableName: string;
+}
+interface ResolveWithOptions {
+  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;
+  schema: {
+    readonly tables: Record<string, TableDefinitionLike>;
+  };
+  tableName: string;
+  with: WithInput;
+}
+interface ResolveWithResult {
+  parent: Record<string, unknown>;
+  relationName: string;
+  rows: Record<string, unknown>[];
+}
+type SortDirection = "asc" | "desc";
+type OrderByInput = Record<string, SortDirection>;
+interface QueryArgs {
+  baseWhere?: WhereInput;
+  cursor?: null | string;
+  includeDeleted?: boolean;
+  limit?: number;
+  orderBy?: OrderByInput[];
+  relationBaseWhere?: (table: string) => undefined | WhereInput;
+  restrictsCounts?: boolean;
+  select?: ReadonlyArray<string>;
+  where?: WhereInput;
+  with?: WithInput;
+}
+interface QueryPage {
+  continueCursor: null | string;
+  isDone: boolean;
+  page: Record<string, unknown>[];
+  splitCursor?: null | string;
+}
+interface OrderKey {
+  direction: SortDirection;
+  field: string;
+}
+interface RestrictableQueryOptions {
+  baseWhere?: WhereInput;
+  relationBaseWhere?: (table: string) => undefined | WhereInput;
+  restrictsCounts?: boolean;
+  where?: WhereInput;
+}
+interface AggregateOptions extends RestrictableQueryOptions {
+  field?: string;
+  op: AggregateOp;
+}
+type AggregateResult = null | number;
+interface GroupByOptions extends RestrictableQueryOptions {
+  agg?: {
+    field?: string;
+    op: AggregateOp;
+  };
+  by: ReadonlyArray<string>;
+}
+interface GroupByEntry {
+  key: Record<string, unknown>;
+  value: AggregateResult;
+}
+type RankDirection = "asc" | "desc";
+interface RankSortKeyLike {
+  readonly direction: RankDirection;
+  readonly field: string;
+}
+interface RankResult {
+  position: number;
+  total: number;
+}
+interface RankOptions extends RestrictableQueryOptions {
+  row: Record<string, unknown> | string;
+}
+interface RankBeforeOptions {
+  partitionKey: string;
+  restrictsCounts?: boolean;
+  rowId: string;
+  sortValues: ReadonlyArray<unknown>;
+}
+interface RankBeforeResult {
+  before: number;
+  total: number;
+}
+interface RankPageOptions extends RestrictableQueryOptions {
+  after?: RankPageRowKey;
+  cursor?: null | string;
+  partitionKey?: string;
+  take?: number;
+}
+interface RankPage {
+  continueCursor: null | string;
+  isDone: boolean;
+  page: Record<string, unknown>[];
+}
+interface RankPageRowKey {
+  partitionKey: string;
+  rowId: string;
+  sortValues: ReadonlyArray<unknown>;
+}
+interface RankPageRow {
+  doc: Record<string, unknown>;
+  key: RankPageRowKey;
+}
+interface ShardRankPageResult {
+  directions: ReadonlyArray<RankDirection>;
+  hasMore: boolean;
+  rows: ReadonlyArray<RankPageRow>;
+}
+interface PaginationOptions {
+  cursor?: null | string;
+  endCursor?: null | string;
+  numItems: number;
+}
+interface SearchFilterBuilderLike {
+  eq: (field: string, value: unknown) => SearchFilterBuilderLike;
+  search: (field: string, query: string) => SearchFilterBuilderLike;
+}
+interface GeoFilterBuilderLike {
+  near: (point: {
+    lat: number;
+    lng: number;
+  }, radiusMeters: number) => GeoFilterBuilderLike;
+  within: (box: {
+    ne: {
+      lat: number;
+      lng: number;
+    };
+    sw: {
+      lat: number;
+      lng: number;
+    };
+  }) => GeoFilterBuilderLike;
+}
+interface TableReaderLike {
+  collect: () => Promise<Record<string, unknown>[]>;
+  filter: (predicate: (document: Record<string, unknown>) => boolean) => TableReaderLike;
+  first: () => Promise<Record<string, unknown> | null>;
+  order: (direction: "asc" | "desc") => TableReaderLike;
+  paginate: (options: PaginationOptions) => Promise<QueryPage>;
+  take: (limit: number) => Promise<Record<string, unknown>[]>;
+  unique: () => Promise<Record<string, unknown> | null>;
+  withGeoIndex: (indexName: string, build: (q: GeoFilterBuilderLike) => GeoFilterBuilderLike) => TableReaderLike;
+  withIndex: (indexName: string, range?: (q: IndexRangeBuilderLike) => IndexRangeBuilderLike) => TableReaderLike;
+  withSearchIndex: (indexName: string, search: (q: SearchFilterBuilderLike) => SearchFilterBuilderLike) => TableReaderLike;
+}
+interface IndexRangeBuilderLike {
+  eq: (field: string, value: unknown) => IndexRangeBuilderLike;
+  gt: (field: string, value: unknown) => IndexRangeBuilderLike;
+  gte: (field: string, value: unknown) => IndexRangeBuilderLike;
+  lt: (field: string, value: unknown) => IndexRangeBuilderLike;
+  lte: (field: string, value: unknown) => IndexRangeBuilderLike;
+}
+type BroadcastDelta = (delta: MutationDelta) => void;
+type ReadHook = (table: string, idOrScan?: string) => void;
+interface LifecycleEvent {
+  connectionId: string;
+  context?: Record<string, unknown>;
+  shardKey: string;
+  userId: string | null;
+}
+interface LifecycleDispatchInfo {
+  event: LifecycleEvent;
+  identity: Record<string, unknown> | undefined;
+  userId: string | undefined;
+}
+interface MutationDelta {
+  key: string;
+  op: "insert" | "update" | "delete";
+  row?: Record<string, unknown>;
+  table: string;
+}
+interface DatabaseWriterLike {
+  aggregate: (tableName: string, options: AggregateOptions) => Promise<AggregateResult>;
+  asId?: (tableName: string, id: string) => string;
+  count: (tableName: string, where?: RestrictableQueryOptions | WhereInput) => Promise<number>;
+  delete: (id: string, expectedTable?: string, options?: {
+    hard?: boolean;
+  }) => Promise<void>;
+  deleteAll?: (tableName: string, options?: {
+    chunkSize?: number;
+    hard?: boolean;
+  }) => Promise<{
+    deleted: number;
+  }>;
+  deleteMany?: (ids: ReadonlyArray<string>, options?: {
+    limit?: number;
+  }, expectedTable?: string) => Promise<{
+    deleted: number;
+  }>;
+  deleteWhere?: (tableName: string, where: WhereInput, options?: {
+    limit?: number;
+  }) => Promise<{
+    deleted: number;
+  }>;
+  findFirst: (tableName: string, args?: QueryArgs) => Promise<Record<string, unknown> | null>;
+  findFirstOrThrow: (tableName: string, args?: QueryArgs) => Promise<Record<string, unknown>>;
+  findMany: (tableName: string, args?: QueryArgs) => Promise<QueryPage>;
+  get: (id: string, expectedTable?: string) => Promise<Record<string, unknown> | null>;
+  groupBy: (tableName: string, options: GroupByOptions) => Promise<ReadonlyArray<GroupByEntry>>;
+  insert: (tableName: string, document: Record<string, unknown>, options?: {
+    allowExplicitId?: boolean;
+    clientId?: string;
+  }) => Promise<string>;
+  insertMany?: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
+    limit?: number;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
+  insertManyUnsafe?: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
+    allowExplicitId?: boolean;
+    limit?: number;
+  }) => Promise<string[]>;
+  lookupById?: (id: string, expectedTable?: string) => Promise<null | {
+    row: Record<string, unknown>;
+    tableName: string;
+  }>;
+  normalizeId: (tableName: string, id: string) => null | string;
+  patch: (id: string, patch: Record<string, unknown>, expectedTable?: string) => Promise<void>;
+  patchMany?: (patches: ReadonlyArray<{
+    id: string;
+    patch: Record<string, unknown>;
+  }>, options?: {
+    limit?: number;
+  }, expectedTable?: string) => Promise<{
+    patched: number;
+  }>;
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: WhereInput;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
+  query: (tableName: string) => TableReaderLike;
+  rank: (tableName: string, indexName: string, options: RankOptions) => Promise<null | RankResult>;
+  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>;
+  replace: (id: string, document: Record<string, unknown>, expectedTable?: string, options?: {
+    allowExplicitId?: boolean;
+  }) => Promise<void>;
+  restore?: (id: string, expectedTable?: string) => Promise<void>;
+  system?: SystemDatabaseReader;
+  wipeShard?: (options?: {
+    chunkSize?: number;
+    exclude?: ReadonlyArray<string>;
+    tables?: ReadonlyArray<string>;
+  }) => Promise<{
+    deleted: number;
+    tables: Record<string, number>;
+  }>;
+}
+interface ExportRow {
+  doc: Record<string, unknown>;
+  table: string;
+}
+interface ImportError {
+  code: string;
+  line: number;
+  message: string;
+  table: string;
+}
+interface ExportShardArgs {
+  batchSize?: number;
+  tables?: ReadonlyArray<string>;
+}
+interface ImportShardArgs {
+  rows: ReadonlyArray<ExportRow>;
+  startLine?: number;
+}
+interface ImportShardResult {
+  conflicts: number;
+  errors: ImportError[];
+  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>;
+interface ExportShardAdminArgs {
+  batchSize?: number;
+  tables?: ReadonlyArray<string>;
+}
+interface ImportShardAdminArgs {
+  rows: ReadonlyArray<ExportRow>;
+  startLine?: number;
+}
+declare const parseExportShardArgs: (args: Record<string, unknown>) => ExportShardAdminArgs;
+declare const parseImportShardArgs: (args: Record<string, unknown>) => ImportShardAdminArgs;
+declare const matchesStaticWhere: (document: Record<string, unknown>, predicate: Record<string, unknown>) => boolean;
+declare const normalizeCountArgument: (argument: RestrictableQueryOptions | undefined | WhereInput) => RestrictableQueryOptions;
+declare const AGGREGATE_SQL_FUNCTION: Record<string, string>;
+declare const aggregateSqlFunction: (op: string) => string;
+declare const throwingScheduler: SchedulerLike;
+declare const aggregateTableName: (table: string, indexName: string) => string;
+declare const coerceAggregateNumber: (value: unknown) => number | undefined;
+interface AggregateTally {
+  count: number;
+  value: null | number;
+}
+declare const foldAggregateTally: (tallies: Map<string, AggregateTally>, encoded: string, index: AggregateIndexDefinitionLike, record: Record<string, unknown>) => void;
+declare const readAggregateValue: (op: string, row: {
+  count: number;
+  value: null | number;
+} | undefined) => null | number;
+declare const encodeAggregateKey: (by: ReadonlyArray<string>, source: Record<string, unknown>) => string;
+declare class CountRlsUnsupportedError extends LunoraError {
+  constructor(table?: string);
+}
+declare const mergeWhere: (left: undefined | WhereInput, right: undefined | WhereInput) => undefined | WhereInput;
+declare const planAggregateLookup: (index: AggregateIndexDefinitionLike, requestedWhere: Record<string, unknown> | undefined) => Record<string, unknown> | undefined;
+declare const selectIndexForCount: (indexes: ReadonlyArray<AggregateIndexDefinitionLike>, requestedWhere: Record<string, unknown> | undefined) => undefined | {
+  index: AggregateIndexDefinitionLike;
+  key: Record<string, unknown>;
+};
+declare const selectIndexForAggregate: (indexes: ReadonlyArray<AggregateIndexDefinitionLike>, op: AggregateOp, field: string, requestedWhere: Record<string, unknown> | undefined) => undefined | {
+  index: AggregateIndexDefinitionLike;
+  key: Record<string, unknown>;
+};
+declare const selectIndexForGroupBy: (indexes: ReadonlyArray<AggregateIndexDefinitionLike>, op: AggregateOp, field: string | undefined, by: ReadonlyArray<string>, requestedWhere: Record<string, unknown> | undefined) => undefined | {
+  index: AggregateIndexDefinitionLike;
+  partial: Record<string, unknown>;
+};
+declare const stableStringify: (value: unknown) => string;
+declare const stableWireKey: (value: unknown) => string;
+interface CacheEntry {
+  bytes: number;
+  deps: Set<string>;
+  lastUsed: number;
+  result: unknown;
+  subscribers: Set<string>;
+}
+interface ReactiveCacheOptions {
+  maxBytes?: number;
+  maxEntries?: number;
+  now?: () => number;
+}
+declare class ReactiveCache {
+  private readonly entries;
+  private readonly tableIndex;
+  private totalBytes;
+  private hits;
+  private misses;
+  private evictions;
+  private readonly maxEntries;
+  private readonly maxBytes;
+  private readonly now;
+  private monotonic;
+  constructor(options?: ReactiveCacheOptions);
+  run<R>(key: string, deps: Set<string>, run: () => Promise<R>): Promise<R>;
+  invalidate(table: string, id: string): string[];
+  invalidateTable(table: string): string[];
+  subscribe(key: string, subscriberId: string): void;
+  unsubscribe(key: string, subscriberId: string): void;
+  size(): {
+    bytes: number;
+    entries: number;
+  };
+  clear(): void;
+  subscribers(key: string): string[];
+  stats(): {
+    bytes: number;
+    entries: number;
+    evictions: number;
+    hits: number;
+    misses: number;
+  };
+  private collectAndDrop;
+  private dropEntry;
+  private evict;
+}
+declare const reactiveCacheKey: (functionPath: string, args: Record<string, unknown>, identity: null | string) => string;
+interface RunTriggersOptions {
+  ctx: TriggerContextLike;
+  event: TriggerEventLike;
+  op: TriggerOpLike;
+  schema: SchemaLike;
+  tableName: string;
+  timing: TriggerTimingLike;
+}
+declare const runTriggers: (options: RunTriggersOptions) => Promise<void>;
+declare const hasTrigger: (schema: SchemaLike, tableName: string, op: TriggerOpLike) => boolean;
+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 CDC_LOG_TABLE = "__cdc_log";
+interface CdcChange {
+  doc?: Record<string, unknown>;
+  id: string;
+  op: "delete" | "insert" | "update";
+  seq: number;
+  table: string;
+  ts: number;
+}
+declare const migrateCdcLog: (sql: SqlExec) => 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 readCdcCursor: (sql: SqlExec) => number;
+declare const minCdcSeq: (sql: SqlExec) => number | undefined;
+declare const CDC_META_TABLE = "__cdc_meta";
+declare const migrateCdcMeta: (sql: SqlExec) => void;
+declare const readCdcEpoch: (sql: SqlExec) => string;
+declare const bumpCdcEpoch: (sql: SqlExec) => string;
+declare const applyCdcChanges: (writer: DatabaseWriterLike, changes: ReadonlyArray<CdcChange>) => Promise<void>;
+declare const CLIENT_WATERMARK_TABLE = "__client_watermark";
+declare const migrateClientWatermark: (sql: SqlExec) => void;
+declare const readClientWatermark: (sql: SqlExec, identity: string, clientId: string) => number;
+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 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;
+declare const IDEMPOTENCY_TABLE = "__idempotency";
+interface IdempotentRecord {
+  resultJson: string;
+  ts: number;
+}
+declare const migrateIdempotency: (sql: SqlExec) => void;
+declare const readIdempotent: (sql: SqlExec, identity: string, mutationId: string) => IdempotentRecord | undefined;
+declare const writeIdempotent: (sql: SqlExec, identity: string, mutationId: string, resultJson: string, ts: number) => void;
+declare const trimIdempotent: (sql: SqlExec, olderThanTs: number) => void;
+declare const runShardMigrations: (sql: SqlExec, schema: SchemaLike, options?: {
+  cdc?: boolean;
+  schemaSnapshot?: {
+    hash: string;
+    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 {
+  /** 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. */
+  done: boolean;
+  /** Analyzer profile the stored rows were built with; `undefined` predates profile tracking. */
+  profile: string | undefined;
+}
+declare const SEARCH_STATE_TABLE = "__lunora_search_state";
+declare const migrateSearchState: (sql: SqlExec) => void;
+declare const readSearchBackfillState: (sql: SqlExec, companion: string) => SearchBackfillState;
+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>;
+interface SqlExec {
+  exec: <Row = Record<string, unknown>>(sql: string, ...params: unknown[]) => SqlCursor<Row>;
+}
+interface SqlCursor<Row> extends Iterable<Row> {
+  one: () => Row;
+  toArray: () => Row[];
+}
+type IndexUseHook = (table: string, indexName: string, kind: "geo" | "index" | "rank" | "search") => void;
+type Clock = () => number;
+type IdGenerator = () => string;
+declare const assertValidClientId: (clientId: string) => void;
+interface WriteEvent {
+  doc?: Record<string, unknown>;
+  id: string;
+  op: "delete" | "insert" | "update";
+  table: string;
+}
+type WriteHook = (event: WriteEvent) => Promise<void> | void;
+interface CtxDbOptions {
+  auth?: ServerDefaultContextLike["auth"];
+  broadcast?: BroadcastDelta;
+  cache?: ReactiveCache;
+  cdc?: boolean;
+  clock?: Clock;
+  enforceRls?: boolean;
+  globalDb?: DatabaseWriterLike;
+  idGenerator?: IdGenerator;
+  maxRelationKeys?: number;
+  onIndexUse?: IndexUseHook;
+  onRead?: ReadHook;
+  onWrite?: WriteHook;
+  relationExistsPushDown?: "always" | "auto" | "never";
+  scheduler?: SchedulerLike;
+  schema: SchemaLike;
+  sql: SqlExec;
+  storage?: SystemReaderStorageLike;
+}
+type CountArgs = RestrictableQueryOptions;
+declare class NotUniqueError extends LunoraError {
+  constructor(message?: string);
+}
+declare const normalizeIdStructurally: (schema: SchemaLike, tableName: string, id: string) => null | string;
+declare const createShardCtxDb: (options: CtxDbOptions) => DatabaseWriterLike;
+declare const AUDIT_LOG_TABLE = "__lunora_audit__";
+interface AuditEntry {
+  detail?: Record<string, unknown>;
+  id?: string;
+  op: string;
+  seq: number;
+  table?: string;
+  ts: number;
+}
+interface AppendAuditEntry {
+  detail?: Record<string, unknown>;
+  id?: string;
+  op: string;
+  table?: string;
+  ts: number;
+}
+declare const ensureAuditTable: (sql: SqlExec) => void;
+declare const appendAuditEntry: (sql: SqlExec, entry: AppendAuditEntry) => void;
+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 CompanionSyncDeps {
+  broadcast: (delta: MutationDelta) => void;
+  invalidateCache: (table: string, id: string) => void;
+  recordCdc: (table: string, id: string, op: "delete" | "insert" | "update", doc?: Record<string, unknown>) => void;
+  schema: SchemaLike;
+  sql: SqlExec;
+}
+interface CompanionSync {
+  ensureBackfilledForTable: (tableName: string) => void;
+  ensureBackfilledIndex: (tableName: string, index: AggregateIndexDefinitionLike) => void;
+  ensureRankBackfilled: (tableName: string, index: RankIndexDefinitionLike) => void;
+  ensureRankBackfilledForTable: (tableName: string) => void;
+  syncAggregates: (tableName: string, previous: Record<string, unknown> | undefined, next: Record<string, unknown> | undefined) => void;
+  syncCompanionsForInsert: (tableName: string, id: string, document: Record<string, unknown>) => void;
+  syncGeo: (tableName: string, id: string, document: Record<string, unknown> | undefined) => void;
+  syncRanks: (tableName: string, id: string, previous: Record<string, unknown> | undefined, next: Record<string, unknown> | undefined) => void;
+  syncSearch: (tableName: string, id: string, document: Record<string, unknown> | undefined, previous?: Record<string, unknown>) => void;
+}
+declare const createCompanionSync: (deps: CompanionSyncDeps) => CompanionSync;
+interface RankPageDeps {
+  assertRankPartitionLocal: (tableName: string, definition: TableDefinitionLike, index: RankIndexDefinitionLike) => void;
+  ensureRankBackfilled: (tableName: string, index: RankIndexDefinitionLike) => void;
+  onRead: (table: string, idOrScan?: string) => void;
+  rowToDocument: (row: Record<string, unknown> | undefined) => Record<string, unknown> | undefined;
+  schema: SchemaLike;
+  sql: SqlExec;
+}
+interface RankPageComputation {
+  continueCursor: null | string;
+  directions: ReadonlyArray<RankDirection>;
+  hasMore: boolean;
+  rows: {
+    doc: Record<string, unknown>;
+    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 DATA_MIGRATION_STATE_TABLE = "__lunora_migrations";
+type MigrationDirection = "down" | "up";
+type MigrationStatus = "completed" | "failed" | "in_progress";
+type DataMigrationDocument = Record<string, unknown>;
+type DataMigrationTransform = (document: DataMigrationDocument) => DataMigrationDocument | undefined;
+interface DataMigrationLike {
+  readonly batchSize?: number;
+  readonly down?: DataMigrationTransform;
+  readonly id: string;
+  readonly table: string;
+  readonly up: DataMigrationTransform;
+}
+interface RunDataMigrationOptions {
+  batchSize?: number;
+  clock?: () => number;
+  direction?: MigrationDirection;
+  dryRun?: boolean;
+  maxBatches?: number;
+  migration: DataMigrationLike;
+  onBatch?: (progress: {
+    batches: number;
+    changed: number;
+    processed: number;
+  }) => Promise<void> | void;
+  sql: SqlExec;
+  writer: DatabaseWriterLike;
+}
+interface MigrationRunResult {
+  changed: number;
+  cursor: null | string;
+  direction: MigrationDirection;
+  dryRun: boolean;
+  id: string;
+  processed: number;
+  status: MigrationStatus;
+}
+interface MigrationStatusRow {
+  changed: number;
+  cursor: null | string;
+  direction: MigrationDirection;
+  error: null | string;
+  id: string;
+  processed: number;
+  startedAt: null | number;
+  status: MigrationStatus;
+  updatedAt: null | number;
+}
+declare const readMigrationStatus: (sql: SqlExec, id?: string) => MigrationStatusRow[];
+declare const runDataMigration: (options: RunDataMigrationOptions) => Promise<MigrationRunResult>;
+declare const SCAN_DEP = "*scan";
+declare const depKey: (table: string, idOrScan: string) => string;
+declare const tableFromDepKey: (dep: string) => string;
+interface DependencyTracker {
+  collect: () => Set<string>;
+  recordRead: (table: string, idOrScan: string) => void;
+}
+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 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;
+declare const qualifiedJsonPathSql: (table: string, field: string) => SQL;
+declare const createIndexSql: (name: string, table: string, columns: SQL, unique: boolean) => SQL;
+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 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;
+type SqlEngine = "mysql" | "postgres" | "sqlite";
+interface RenderedSql {
+  params: unknown[];
+  sql: string;
+}
+declare const renderSql: (engine: SqlEngine, query: SQL) => RenderedSql;
+declare const param: (value: unknown) => SQL;
+interface ExternalSourceDiffResult {
+  changes: CdcChange[];
+  nextBaseline: Map<string, string>;
+}
+declare const diffExternalSource: (pulled: ReadonlyArray<Record<string, unknown>>, baseline: ReadonlyMap<string, string>, options: {
+  columns?: ReadonlyArray<string>;
+  table: string;
+}) => ExternalSourceDiffResult;
+declare const normalizeSourceValue: (value: unknown) => unknown;
+declare const normalizeSourceDocument: (document: Record<string, unknown>) => Record<string, unknown>;
+declare const liftSourceId: (row: Record<string, unknown>, options?: {
+  idColumn?: string;
+  map?: (row: Record<string, unknown>) => Record<string, unknown>;
+}) => Record<string, unknown>;
+interface MaterializeResult {
+  applied: number;
+  nextBaseline: Map<string, string>;
+}
+interface IncrementalMaterializeResult {
+  applied: number;
+}
+declare const materializeExternalRows: (writer: DatabaseWriterLike, pulled: ReadonlyArray<Record<string, unknown>>, baseline: ReadonlyMap<string, string>, options: {
+  columns?: ReadonlyArray<string>;
+  table: string;
+}) => Promise<MaterializeResult>;
+declare const materializeExternalRowsIncremental: (writer: DatabaseWriterLike, pulled: ReadonlyArray<Record<string, unknown>>, options: {
+  columns?: ReadonlyArray<string>;
+  deletedIds?: ReadonlySet<string>;
+  table: string;
+}) => Promise<IncrementalMaterializeResult>;
+declare const readExternalSourceBaseline: (sql: SqlExec, table: string, columns?: ReadonlyArray<string>) => Map<string, string>;
+declare const runExternalSourceTick: (sql: SqlExec, writer: DatabaseWriterLike, pulled: ReadonlyArray<Record<string, unknown>>, options: {
+  columns?: ReadonlyArray<string>;
+  table: string;
+}) => Promise<MaterializeResult>;
+interface SourceClientLike {
+  query: <Row = Record<string, unknown>>(text: string, parameters?: ReadonlyArray<unknown>) => Promise<Row[]>;
+}
+type SourceRefresh = "manual" | {
+  everyMs: number;
+};
+interface SourceCursorLike {
+  column: string;
+  query: string;
+}
+interface ExternalSourceLike {
+  binding: string;
+  columns?: ReadonlyArray<string>;
+  cursor?: SourceCursorLike;
+  idColumn?: string;
+  map?: (row: Record<string, unknown>) => Record<string, unknown>;
+  mode?: string;
+  query: string;
+  reconcileEveryMs?: number;
+  refresh?: SourceRefresh;
+  softDeleteColumn?: string;
+  tenantBy?: (shardKey: string) => ReadonlyArray<unknown>;
+}
+declare const isSourceDue: (refresh: SourceRefresh | undefined, lastPolledMs: number | undefined, nowMs: number) => boolean;
+declare const pullExternalSourceTick: (sql: SqlExec, writer: DatabaseWriterLike, client: SourceClientLike, table: string, source: ExternalSourceLike, shardKey: string) => Promise<MaterializeResult>;
+declare const isSoftDeleted: (row: Record<string, unknown>, column: string) => boolean;
+declare const pullExternalSourceIncrementalTick: (sql: SqlExec, writer: DatabaseWriterLike, client: SourceClientLike, table: string, source: ExternalSourceLike, shardKey: string, nowMs: number) => Promise<{
+  applied: number;
+}>;
+declare const GEO_DEFAULT_PRECISION = 9;
+interface GeoPoint {
+  lat: number;
+  lng: number;
+}
+interface GeoBoundingBox {
+  ne: GeoPoint;
+  sw: GeoPoint;
+}
+declare const encodeGeohash: (point: GeoPoint, precision: number) => string;
+declare const haversineMeters: (a: GeoPoint, b: GeoPoint) => number;
+declare const coveringGeohashes: (center: GeoPoint, radiusMeters: number) => string[];
+declare const pointInBoundingBox: (point: GeoPoint, box: GeoBoundingBox) => boolean;
+declare const boundingBoxCenter: (box: GeoBoundingBox) => GeoPoint;
+declare const boundingBoxGeohashes: (box: GeoBoundingBox) => string[];
+declare const ADMIN_FUNCTION_PREFIX = "__lunora_admin__:";
+declare const RELATION_FUNCTION_PREFIX = "__lunora_relation__:";
+declare const FLAGS_FUNCTION_PREFIX = "__lunora_flags__:";
+declare const ADMIN_FUNCTIONS: {
+  readonly applyCdc: "__lunora_admin__:applyCdc";
+  readonly aiAvailable: "__lunora_admin__:aiAvailable";
+  readonly aiChartConfig: "__lunora_admin__:aiChartConfig";
+  readonly aiGenerateSql: "__lunora_admin__:aiGenerateSql";
+  readonly aiTableFilter: "__lunora_admin__:aiTableFilter";
+  readonly assignIssue: "__lunora_admin__:assignIssue";
+  readonly backRelationCounts: "__lunora_admin__:backRelationCounts";
+  readonly cdcSync: "__lunora_admin__:cdcSync";
+  readonly clearCapturedMail: "__lunora_admin__:clearCapturedMail";
+  readonly clearQueueMessages: "__lunora_admin__:clearQueueMessages";
+  readonly clearTable: "__lunora_admin__:clearTable";
+  readonly createWorkflowInstance: "__lunora_admin__:createWorkflowInstance";
+  readonly deleteRows: "__lunora_admin__:deleteRows";
+  readonly describeTable: "__lunora_admin__:describeTable";
+  readonly describeTables: "__lunora_admin__:describeTables";
+  readonly explainIssue: "__lunora_admin__:explainIssue";
+  readonly exportShard: "__lunora_admin__:exportShard";
+  readonly facetColumn: "__lunora_admin__:facetColumn";
+  readonly getAdvisories: "__lunora_admin__:getAdvisories";
+  readonly getAdvisorProcedures: "__lunora_admin__:getAdvisorProcedures";
+  readonly getAuditLog: "__lunora_admin__:getAuditLog";
+  readonly getAuthMetrics: "__lunora_admin__:getAuthMetrics";
+  readonly getCapturedMail: "__lunora_admin__:getCapturedMail";
+  readonly getFanoutMetrics: "__lunora_admin__:getFanoutMetrics";
+  readonly getFunctionStats: "__lunora_admin__:getFunctionStats";
+  readonly getIssues: "__lunora_admin__:getIssues";
+  readonly getMetricHistory: "__lunora_admin__:getMetricHistory";
+  readonly getMetricSeries: "__lunora_admin__:getMetricSeries";
+  readonly listSubscriptions: "__lunora_admin__:listSubscriptions";
+  readonly listTableIndexes: "__lunora_admin__:listTableIndexes";
+  readonly getLogs: "__lunora_admin__:getLogs";
+  readonly getMetrics: "__lunora_admin__:getMetrics";
+  readonly getPitrBookmark: "__lunora_admin__:getPitrBookmark";
+  readonly getQueryInsights: "__lunora_admin__:getQueryInsights";
+  readonly getQueueMessages: "__lunora_admin__:getQueueMessages";
+  readonly getRequestLog: "__lunora_admin__:getRequestLog";
+  readonly getSecurityAudit: "__lunora_admin__:getSecurityAudit";
+  readonly getSettings: "__lunora_admin__:getSettings";
+  readonly getTraces: "__lunora_admin__:getTraces";
+  readonly getWorkflowInstanceStatus: "__lunora_admin__:getWorkflowInstanceStatus";
+  readonly ignoreIssue: "__lunora_admin__:ignoreIssue";
+  readonly importShard: "__lunora_admin__:importShard";
+  readonly listFlags: "__lunora_admin__:listFlags";
+  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 pitrRestore: "__lunora_admin__:pitrRestore";
+  readonly rankBefore: "__lunora_admin__:rankBefore";
+  readonly rankPage: "__lunora_admin__:rankPage";
+  readonly readTablePage: "__lunora_admin__:readTablePage";
+  readonly recordAuthEvent: "__lunora_admin__:recordAuthEvent";
+  readonly recordContainerEvent: "__lunora_admin__:recordContainerEvent";
+  readonly recordMail: "__lunora_admin__:recordMail";
+  readonly recordQueueMessage: "__lunora_admin__:recordQueueMessage";
+  readonly replayQueueMessage: "__lunora_admin__:replayQueueMessage";
+  readonly resolveIssue: "__lunora_admin__:resolveIssue";
+  readonly rlsPolicies: "__lunora_admin__:rlsPolicies";
+  readonly schemaHistory: "__lunora_admin__:schemaHistory";
+  readonly schemaVersion: "__lunora_admin__:schemaVersion";
+  readonly runAs: "__lunora_admin__:runAs";
+  readonly runMigration: "__lunora_admin__:runMigration";
+  readonly runSql: "__lunora_admin__:runSql";
+  readonly sendQueueMessage: "__lunora_admin__:sendQueueMessage";
+  readonly sendTestMail: "__lunora_admin__:sendTestMail";
+  readonly setIssueSeverity: "__lunora_admin__:setIssueSeverity";
+  readonly storageOrphans: "__lunora_admin__:storageOrphans";
+  readonly storageReferences: "__lunora_admin__:storageReferences";
+  readonly storageRules: "__lunora_admin__:storageRules";
+  readonly studioFeatures: "__lunora_admin__:studioFeatures";
+  readonly writeRow: "__lunora_admin__:writeRow";
+};
+interface TableInfo {
+  name: string;
+  rowCount: number;
+}
+interface AuditLogResult {
+  entries: AuditEntry[];
+}
+interface SubscriptionInfo {
+  args?: Record<string, unknown>;
+  functionPath?: string;
+  table?: string;
+}
+interface SubscriptionConnection {
+  admin: boolean;
+  id: number;
+  subscriptions: SubscriptionInfo[];
+}
+interface SubscriptionsResult {
+  connections: SubscriptionConnection[];
+  totalConnections: number;
+  totalSubscriptions: number;
+}
+interface FunctionScanAttribution {
+  scans: number;
+  table: string;
+}
+interface FunctionCallStat {
+  calls: number;
+  conflicts: number;
+  errors: number;
+  lastCalledAt: number;
+  lastErrorAt: null | number;
+  lastErrorMessage: null | string;
+  maxDurationMs: number;
+  path: string;
+  scannedTables: FunctionScanAttribution[];
+  scans: number;
+  totalDurationMs: number;
+}
+interface TableIndexInfo {
+  fields: string[];
+  name: string;
+  type: "geo" | "index" | "rank" | "search" | "vector";
+  unique?: boolean;
+}
+interface TableIndexesResult {
+  indexes: TableIndexInfo[];
+}
+interface ColumnMeta {
+  isStorage?: boolean;
+  name: string;
+  optional: boolean;
+  pk?: boolean;
+  ref?: string;
+  type: string;
+}
+interface TableColumnsResult {
+  columns: ColumnMeta[];
+}
+interface TablesColumnsResult {
+  columnsByTable: Record<string, ColumnMeta[]>;
+}
+interface AdvisoryFinding {
+  cacheKey: string;
+  categories: string[];
+  description: string;
+  detail: string;
+  facing: "EXTERNAL" | "INTERNAL";
+  level: "ERROR" | "INFO" | "WARN";
+  metadata: Record<string, unknown>;
+  name: string;
+  remediation: string;
+  title: string;
+}
+interface AdvisoriesResult {
+  advisories: AdvisoryFinding[];
+}
+interface AdvisorProcedure {
+  callsMail: boolean;
+  emitsEvent?: boolean;
+  exempt?: boolean;
+  exemptReason?: string;
+  exportName: string;
+  fanOut: boolean;
+  file: string;
+  handlesErrors?: boolean;
+  hasEmailArg?: boolean;
+  kind: "action" | "mutation" | "query";
+  reachesOutbound?: boolean;
+  runsAiGeneration?: boolean;
+  throwsBareError?: boolean;
+  unboundedAiGeneration: boolean;
+  usesCaptcha: boolean;
+  usesEmailGate: boolean;
+  usesInsertManyUnsafe: boolean;
+  usesMask: boolean;
+  usesRateLimit: boolean;
+  usesRls: boolean;
+  visibility: "internal" | "public";
+  writesUserTable: boolean;
+}
+interface AdvisorProceduresResult {
+  procedures: AdvisorProcedure[];
+}
+interface RlsPolicyMetadata {
+  file: string;
+  on: "delete" | "insert" | "read" | "update";
+  procedure: string;
+  table: string;
+}
+interface RlsRoleMetadata {
+  description?: string;
+  name: string;
+  permissions: string[];
+}
+interface RlsPoliciesResult {
+  policies: RlsPolicyMetadata[];
+  roles: RlsRoleMetadata[];
+}
+interface MaskColumnMetadata {
+  column: string;
+  strategy: "custom" | "hash" | "redact";
+  table: string;
+}
+interface MaskPoliciesResult {
+  columns: MaskColumnMetadata[];
+}
+interface StorageRuleMetadata {
+  bucket: string;
+  file: string;
+  on: "delete" | "list" | "read" | "write";
+  prefix?: string;
+  procedure: string;
+}
+interface StorageRulesResult {
+  rules: StorageRuleMetadata[];
+}
+interface StudioFeaturesResult {
+  analytics: boolean;
+  auth: boolean;
+  containers: boolean;
+  flags: boolean;
+  kv: boolean;
+  mail: boolean;
+  notifications: boolean;
+  payments: boolean;
+  queues: boolean;
+  scheduler: boolean;
+  storage: boolean;
+  vectors: boolean;
+  workflows: boolean;
+}
+interface FlagEvaluation {
+  errorCode?: string;
+  key: string;
+  reason?: string;
+  type: "boolean" | "number" | "object" | "string";
+  value: unknown;
+  variant?: string;
+}
+interface FlagsResult {
+  configured: boolean;
+  flags: FlagEvaluation[];
+}
+interface WorkflowMetadata {
+  binding: string;
+  className: string;
+  exportName: string;
+  name: string;
+}
+interface WorkflowsResult {
+  workflows: WorkflowMetadata[];
+}
+interface QueueMetadata {
+  binding: string;
+  deadLetterQueue?: string;
+  exportName: string;
+  mode: "pull" | "push";
+  name: string;
+}
+interface QueuesResult {
+  queues: QueueMetadata[];
+}
+type WorkflowInstanceState = "complete" | "errored" | "paused" | "queued" | "running" | "terminated" | "unknown" | "waiting" | "waitingForPause";
+interface CreateWorkflowInstanceResult {
+  id: string;
+  status: WorkflowInstanceState;
+}
+interface WorkflowInstanceStatusResult {
+  error?: {
+    message: string;
+    name: string;
+  };
+  id: string;
+  output?: unknown;
+  status: WorkflowInstanceState;
+}
+interface FunctionStatsResult {
+  functions: FunctionCallStat[];
+  sinceMs: number;
+}
+type SettingKind = "binding" | "secret" | "var";
+interface SettingEntry {
+  bindingType?: string;
+  kind: SettingKind;
+  name: string;
+  value: null | string;
+}
+interface DeployInfo {
+  deploymentId?: string;
+  environment?: string;
+  versionTag?: string;
+  workerUrl?: string;
+}
+interface SettingsResult {
+  deploy: DeployInfo;
+  settings: SettingEntry[];
+}
+interface TablePage {
+  columns: string[];
+  refs?: Record<string, string>;
+  rows: Record<string, unknown>[];
+  total?: number;
+}
+type FilterOperator = "contains" | "eq" | "gt" | "gte" | "lt" | "lte" | "ne";
+interface FilterClause {
+  column: string;
+  operator: FilterOperator;
+  value?: unknown;
+}
+interface OrderByClause {
+  column: string;
+  direction: SortDirection;
+}
+interface ReadTablePageOptions {
+  filters?: FilterClause[];
+  limit?: number;
+  offset?: number;
+  orderBy?: OrderByClause;
+  refs?: Record<string, string>;
+  search?: string;
+  skipCount?: boolean;
+  table: string;
+}
+interface SelectMatchingIdsOptions {
+  filters?: FilterClause[];
+  limit?: number;
+  search?: string;
+  table: string;
+}
+interface FacetColumnOptions {
+  column: string;
+  filters?: FilterClause[];
+  limit?: number;
+  search?: string;
+  table: string;
+}
+interface FacetValue {
+  count: number;
+  value: unknown;
+}
+interface FacetColumnResult {
+  truncated: boolean;
+  values: FacetValue[];
+}
+declare const MAX_PAGE_SIZE = 500;
+declare const listTables: (sql: SqlExec) => TableInfo[];
+declare const readTablePage: (sql: SqlExec, options: ReadTablePageOptions) => TablePage;
+declare const selectMatchingIds: (sql: SqlExec, options: SelectMatchingIdsOptions) => {
+  hasMore: boolean;
+  ids: string[];
+};
+declare const facetColumn: (sql: SqlExec, options: FacetColumnOptions) => FacetColumnResult;
+interface StorageReference {
+  column: string;
+  id: string;
+  table: string;
+}
+interface StorageReferenceResult {
+  references: Record<string, StorageReference[]>;
+  storageColumns: Record<string, string[]>;
+}
+declare const findStorageReferences: (sql: SqlExec, storageColumns: Record<string, string[]>, keys: string[]) => StorageReferenceResult;
+interface SocketAttachmentLike {
+  admin?: boolean;
+  subs?: Record<string, SubscriptionInfo>;
+}
+declare const summarizeSubscriptions: (attachments: SocketAttachmentLike[]) => SubscriptionsResult;
+interface FanoutTopicStat {
+  kind: "shape" | "whisper";
+  subscribers: number;
+  topic: string;
+}
+interface FanoutPathCounters {
+  maxMs: number;
+  passes: number;
+  peakSocketsIterated: number;
+  socketsDelivered: number;
+  socketsIterated: number;
+  totalMs: number;
+}
+interface FanoutMetricsResult {
+  maxRelays: number;
+  peakSubscribers: number;
+  promoted: boolean;
+  relayCount: number;
+  shapePoke: FanoutPathCounters;
+  sinceMs: number;
+  topics: FanoutTopicStat[];
+  totalConnections: number;
+  whisper: FanoutPathCounters;
+}
+interface FanoutAttachmentLike {
+  shapes?: Record<string, {
+    name?: string;
+  }>;
+  whispers?: string[];
+}
+declare const DEFAULT_FANOUT_TOPIC_LIMIT = 20;
+declare const createFanoutCounters: () => FanoutPathCounters;
+declare const recordFanoutPass: (counters: FanoutPathCounters, iterated: number, delivered: number, ms: number) => FanoutPathCounters;
+declare const summarizeFanoutTopics: (attachments: FanoutAttachmentLike[], limit?: number) => {
+  peakSubscribers: number;
+  topics: FanoutTopicStat[];
+  totalConnections: number;
+};
+declare const MAIL_TABLE = "__lunora_mail";
+declare const MAIL_RETENTION = 500;
+interface RecordMailInput {
+  bcc?: string[];
+  cc?: string[];
+  from?: string;
+  headers?: Record<string, string>;
+  html?: string;
+  replyTo?: string;
+  subject: string;
+  text?: string;
+  to: string | string[];
+}
+interface CapturedMailRow {
+  bcc?: string[];
+  capturedAt: number;
+  cc?: string[];
+  from?: string;
+  headers?: Record<string, string>;
+  html?: string;
+  id: string;
+  replyTo?: string;
+  subject: string;
+  text?: string;
+  to: string | string[];
+}
+declare const ensureMailTable: (sql: SqlExec) => void;
+declare const recordCapturedMail: (sql: SqlExec, input: RecordMailInput, capturedAt: number) => {
+  id: string;
+};
+declare const readCapturedMail: (sql: SqlExec, options?: {
+  limit?: number;
+}) => {
+  entries: CapturedMailRow[];
+};
+declare const clearCapturedMail: (sql: SqlExec) => {
+  cleared: true;
+};
+declare class NotFoundError extends LunoraError {
+  constructor(message?: string);
+}
+interface PitrStorage {
+  getBookmarkForTime?: (time: Date | number) => Promise<string>;
+  getCurrentBookmark?: () => Promise<string>;
+  onNextSessionRestoreBookmark?: (bookmark: string) => Promise<string>;
+}
+interface PitrBookmarkResult {
+  current: string;
+  forTime?: string;
+}
+interface PitrRestoreResult {
+  restarted: boolean;
+  restoredTo: string;
+  undoBookmark: string;
+}
+interface PitrRestoreArgs {
+  bookmark?: string;
+  restart?: boolean;
+  time?: number | string;
+}
+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 encodeCursor: (record: Record<string, unknown>, keys: OrderKey[]) => string;
+declare const decodeCursor: (cursor: string) => unknown[];
+declare const buildSeekWhere: (keys: OrderKey[], cursorValues: unknown[]) => WhereInput;
+declare const buildSeekBeforeWhere: (keys: OrderKey[], cursorValues: unknown[]) => WhereInput;
+declare const applySelect: (page: Record<string, unknown>[], select: ReadonlyArray<string> | undefined, withInput?: Record<string, unknown>) => Record<string, unknown>[];
+declare const softDeleteScope: (softDeleteMode: {
+  field: string;
+} | undefined, includeDeleted: boolean | undefined) => undefined | WhereInput;
+declare const QUEUE_TABLE = "__lunora_queue_messages";
+type QueueMessageOutcome = "ack" | "error" | "retry";
+interface RecordQueueMessageInput {
+  attempts: number;
+  body: unknown;
+  deadLettered?: boolean;
+  error?: string;
+  exportName?: string;
+  messageId: string;
+  outcome: QueueMessageOutcome;
+  queue: string;
+  timestamp: number;
+}
+interface QueueMessageRow {
+  attempts: number;
+  body: unknown;
+  capturedAt: number;
+  deadLettered: boolean;
+  error?: string;
+  exportName?: string;
+  id: string;
+  messageId: string;
+  outcome: QueueMessageOutcome;
+  queue: string;
+  timestamp: number;
+}
+declare const isLossyBody: (body: unknown) => boolean;
+declare const recordQueueMessages: (sql: SqlExec, inputs: ReadonlyArray<RecordQueueMessageInput>, capturedAt: number) => {
+  recorded: number;
+};
+interface ReadQueueMessagesOptions {
+  limit?: number;
+  queue?: string;
+}
+declare const readQueueMessages: (sql: SqlExec, options?: ReadQueueMessagesOptions) => {
+  entries: QueueMessageRow[];
+};
+declare const readQueueMessageById: (sql: SqlExec, id: string) => QueueMessageRow | undefined;
+declare const clearQueueMessages: (sql: SqlExec) => {
+  cleared: true;
+};
+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>) => {
+  partitionKey: string;
+  rowId: string;
+  sortValues: unknown[];
+};
+declare const DEFAULT_MAX_RELATION_KEYS = 5000;
+interface RelationExistsMarker {
+  childWhere: WhereInput;
+  negated: boolean;
+  parentTable: string;
+  relation: RelationDefinitionLike;
+}
+type ExistsPushMode = "always" | "auto";
+interface ResolveRelationPredicatesOptions {
+  canPushExists?: (relation: RelationDefinitionLike) => boolean;
+  existsPushMode?: ExistsPushMode;
+  fetcher: (tableName: string, args: QueryArgs) => Promise<QueryPage>;
+  maxRelationKeys?: number;
+  relationBaseWhere?: (table: string) => undefined | WhereInput;
+  schema: {
+    readonly tables: Record<string, TableDefinitionLike>;
+  };
+  tableName: string;
+}
+interface ResolveContext {
+  canPushExists?: (relation: RelationDefinitionLike) => boolean;
+  existsPushMode: ExistsPushMode;
+  fetcher: (tableName: string, args: QueryArgs) => Promise<QueryPage>;
+  maxRelationKeys: number;
+  relationBaseWhere?: (table: string) => undefined | WhereInput;
+  schema: {
+    readonly tables: Record<string, TableDefinitionLike>;
+  };
+}
+declare const isRelationPredicate: (value: unknown) => value is Record<string, WhereInput>;
+declare const containsRelationPredicate: (where: WhereInput, schema: ResolveContext["schema"], tableName: string) => boolean;
+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 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>;
+interface ApplyOnDeleteOptions {
+  deletedId: string;
+  deletedReference: (references: string) => unknown;
+  findHolders: (holderTable: string, field: string, value: unknown) => Promise<Record<string, unknown>[]>;
+  onCascade: (holderTable: string, id: string) => Promise<void>;
+  onRestrict: (message: string) => never;
+  onSetNull: (holderTable: string, id: string, field: string) => Promise<void>;
+  schema: {
+    readonly tables: Record<string, TableDefinitionLike>;
+  };
+  tableName: string;
+}
+declare const applyOnDelete: (options: ApplyOnDeleteOptions) => Promise<void>;
+declare const runRowValidators: (definition: TableDefinitionLike, document: Record<string, unknown>, tolerateStoredNull?: boolean) => void;
+interface ShapeRowOp {
+  key: string;
+  op: "delete" | "insert" | "update";
+  table: string;
+  value?: Record<string, unknown>;
+}
+interface ShapePokePart {
+  rowsPatch: ShapeRowOp[];
+  shapeId: string;
+}
+interface PokeFrameMeta {
+  baseCheckpoint: number | undefined;
+  checkpoint: number;
+  epoch: string | undefined;
+  lastMutationId: number | undefined;
+  pokeId: string;
+}
+declare const projectColumns: (document_: Record<string, unknown>, columns: ReadonlyArray<string> | undefined) => Record<string, unknown>;
+declare const diffGlobalMembership: (rows: ReadonlyArray<ShapeRow>, previous: ReadonlyMap<string, string>, options: {
+  columns?: ReadonlyArray<string>;
+  table: string;
+}) => {
+  next: Map<string, string>;
+  rowsPatch: ShapeRowOp[];
+};
+declare const encodeRowsPatch: (rowsPatch: ReadonlyArray<ShapeRowOp>) => ShapeRowOp[];
+declare const buildPokeFrames: (parts: ReadonlyArray<ShapePokePart>, meta: PokeFrameMeta, options?: {
+  preEncoded?: boolean;
+}) => string[];
+declare const shapeRoutingKey: (name: string, args?: Record<string, unknown>) => string;
+type PromotionState = "owned" | "promoted";
+interface PromotionThresholds {
+  tDown: number;
+  tUp: number;
+}
+declare const DEFAULT_PROMOTION_THRESHOLDS: PromotionThresholds;
+declare const nextPromotionState: (current: PromotionState, subscribers: number, thresholds?: PromotionThresholds) => PromotionState;
+declare const clampPromotionThresholds: (tUp: number, tDownRaw: number) => PromotionThresholds;
+declare const relayCountFor: (subscribers: number, perRelayCapacity: number, maxRelays: number) => number;
+interface RelayAttach {
+  relayIndex: number;
+  type: "relay_attach";
+}
+interface RelayDetach {
+  relayIndex: number;
+  type: "relay_detach";
+}
+interface RelayFrame {
+  cursor?: number;
+  epoch?: string;
+  frame: string;
+  originRelay?: number;
+  topic: string;
+  type: "relay_frame";
+}
+interface RelayShapeSubscribe {
+  args: Record<string, unknown>;
+  connectionId?: string;
+  identity?: Record<string, unknown>;
+  name: string;
+  relayIndex?: number;
+  sinceEpoch?: string;
+  sinceSeq?: number;
+  subId: string;
+  type: "relay_shape_subscribe";
+  userId?: string;
+}
+interface RelayShapeSeed {
+  cursor?: number;
+  epoch?: string;
+  error?: {
+    code: string;
+    message: string;
+  };
+  frames?: string[];
+}
+interface RelayShapePoke {
+  args: Record<string, unknown>;
+  checkpoint: number;
+  epoch?: string;
+  fromCursor: number;
+  name: string;
+  rowsPatch: ShapeRowOp[];
+  targetConnectionId?: string;
+  type: "relay_shape_poke";
+}
+type OwnerRelayFrame = RelayAttach | RelayDetach | RelayFrame | RelayShapePoke | RelayShapeSubscribe;
+declare const DEFAULT_MAX_RELAYS = 8;
+interface RelayStub {
+  fetch: (url: string, init?: RequestInit) => Promise<Response>;
+}
+interface RelayNamespaceLike {
+  get: (id: unknown) => RelayStub;
+  getByName?: (name: string) => RelayStub;
+  idFromName: (name: string) => unknown;
+}
+interface RelayHost {
+  buildShapeDiff: (resolved: ResolvedShape, fromCursor: number, toCursor: number) => ShapeRowOp[];
+  computeOpLogShapeSeed: (shape: ShapeSubscriptionQuery, resolved: ResolvedShape) => {
+    baseCheckpoint: number | undefined;
+    cursor: number;
+    epoch: string | undefined;
+    rowsPatch: ShapeRowOp[];
+  };
+  currentCdcEpoch: () => string | undefined;
+  deliverWhisperLocal: (topic: string, frame: string, exclude: undefined | ShardSocketLike) => number;
+  doName: () => string | undefined;
+  env: () => unknown;
+  getWebSockets: () => ShardSocketLike[];
+  maskMetadata: () => MaskPoliciesResult;
+  nextPokeId: () => string;
+  readAttachment: (ws: ShardSocketLike) => SocketAttachment;
+  recordShapePokeFanout: (iterated: number, delivered: number, elapsedMs: number) => void;
+  resolveShape: (name: string, args: Record<string, unknown>, identity?: SubscriptionIdentity) => ResolvedShape | undefined;
+  rlsMetadata: () => RlsPoliciesResult;
+  shardBinding: () => string | undefined;
+  sql: () => SqlExec;
+}
+declare abstract class RelayLink {
+  protected readonly host: RelayHost;
+  protected readonly roleId: {
+    ownerKey: string;
+    relayIndex?: number;
+  };
+  protected constructor(host: RelayHost, roleId: {
+    ownerKey: string;
+    relayIndex?: number;
+  });
+  handleControl(request: Request): Promise<Response>;
+  maxRelays(): number;
+  protected canAddressSiblings(): boolean;
+  protected relayNamespace(): RelayNamespaceLike | 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>;
+  abstract onFlush(changed: Set<string>, frameCursor: number): Promise<void>;
+  abstract seedRelayShape(ws: ShardSocketLike, subId: string, shape: ShapeSubscriptionQuery, identity: SubscriptionIdentity): Promise<"ok" | undefined | {
+    code: string;
+    message: string;
+  }>;
+  abstract announce(): Promise<void>;
+  abstract announceDrain(closing: ShardSocketLike): Promise<void>;
+  abstract relayCount(): number;
+  abstract isShapeRelayUniform(name: string, args: Record<string, unknown>): boolean;
+  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;
+}
+declare class OwnerRelay extends RelayLink {
+  private readonly shapeUniformCache;
+  private relaySetCache;
+  private readonly relayShapeRegistry;
+  private readonly relayShapeProxies;
+  private promotionState;
+  constructor(host: RelayHost, ownerKey: string);
+  forwardWhisper(topic: string, frame: string): Promise<void>;
+  onFlush(changed: Set<string>, frameCursor: number): Promise<void>;
+  seedRelayShape(): Promise<"ok" | undefined | {
+    code: string;
+    message: string;
+  }>;
+  announce(): Promise<void>;
+  announceDrain(): Promise<void>;
+  relayCount(): number;
+  isShapeRelayUniform(name: string, args: Record<string, unknown>): boolean;
+  protected onAttach(index: number): void;
+  protected onDetach(index: number): void;
+  protected onWhisperFrame(message: RelayFrame): Promise<void>;
+  protected onShapeSubscribe(message: RelayShapeSubscribe): RelayShapeSeed;
+  protected onShapePoke(): number;
+  private multicastShapePokes;
+  private proxyShapePokes;
+  private buildShapeSeedFrames;
+  private ensureRelayTable;
+  private ownerRelaySet;
+  private addRelayToSet;
+  private removeRelayFromSet;
+  private probeShapeRelayUniform;
+  private tableHasAnyMask;
+}
+declare class RelayMember extends RelayLink {
+  private relayAnnounced;
+  private readonly shapeRelayMemos;
+  constructor(host: RelayHost, ownerKey: string, relayIndex: number);
+  forwardWhisper(topic: string, frame: string): Promise<void>;
+  onFlush(): Promise<void>;
+  seedRelayShape(ws: ShardSocketLike, subId: string, shape: ShapeSubscriptionQuery, identity: SubscriptionIdentity): Promise<"ok" | {
+    code: string;
+    message: string;
+  }>;
+  announce(): Promise<void>;
+  announceDrain(closing: ShardSocketLike): Promise<void>;
+  relayCount(): number;
+  isShapeRelayUniform(): boolean;
+  protected onAttach(): void;
+  protected onDetach(): void;
+  protected onWhisperFrame(): Promise<void>;
+  protected onShapeSubscribe(): RelayShapeSeed;
+  protected onShapePoke(poke: RelayShapePoke): number;
+  private recordRelayShapeMemo;
+  private deliverShapePoke;
+}
+declare const createRelayLink: (host: RelayHost) => OwnerRelay | RelayMember | undefined;
+declare const RLS_UNWRAP_SYMBOL: symbol;
+declare class RlsRequiredError extends LunoraError {
+  readonly table: string;
+  constructor(table: string);
+}
+interface GuardableSchema {
+  readonly rlsMode?: "required";
+  readonly tables: Record<string, {
+    readonly isPublic?: boolean;
+    readonly shardMode?: {
+      readonly kind?: string;
+    };
+  }>;
+}
+type TableOfId = (id: string, expectedTable?: string) => Promise<string | undefined> | string | undefined;
+declare const guardWriter: <W>(raw: W, schema: GuardableSchema, tableOfId: TableOfId) => W;
+declare const SCHEMA_HISTORY_MAX_VERSIONS = 50;
+interface SchemaVersionRow {
+  appliedAt: number;
+  hash: string;
+  seq: number;
+  snapshotJson?: string;
+}
+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 isDevEnvironment: (rawEnv: unknown) => boolean;
+declare const buildSettings: (rawEnv: unknown) => SettingsResult;
+interface ShardRunnerOptions {
+  handlers?: {
+    handleAlarm?: () => Promise<void>;
+    handleFetch?: (request: Request) => Promise<Response>;
+  };
+}
+declare class ShardRunner {
+  readonly shardHost: ShardHost;
+  readonly socketHost: SocketHost;
+  readonly options: ShardRunnerOptions;
+  constructor(shardHost: ShardHost, socketHost: SocketHost, options?: ShardRunnerOptions);
+  get shardKey(): string | undefined;
+  socketFor(raw: unknown): ShardSocketLike;
+  sockets(tag?: string): SocketHandle[];
+  background(work: Promise<unknown>): boolean;
+  runInTransaction<T>(work: () => Promise<T>): Promise<T>;
+  handleFetch(request: Request): Promise<Response>;
+  handleAlarm(): Promise<void>;
+}
+declare const runSocketPool: <T>(items: ReadonlyArray<T>, processOne: (item: T) => Promise<void>, concurrency?: number) => Promise<void>;
+interface SqlConsoleResult {
+  columns: string[];
+  rowCount: number;
+  rows: Record<string, unknown>[];
+  truncated: boolean;
+}
+declare const MAX_SQL_ROWS = 1000;
+declare const assertReadonly: (query: string) => void;
+declare const runReadonlySql: (sql: SqlExec, query: string) => SqlConsoleResult;
+interface SqlLintResult {
+  diagnostics: SqlDiagnostic[];
+  plan: string[];
+}
+interface SqlDiagnostic {
+  length?: number;
+  message: string;
+  offset?: number;
+  severity: "error" | "warning";
+  source: "gate" | "plan" | "syntax";
+}
+declare const lintReadonlySql: (sql: SqlExec, query: string) => SqlLintResult;
+declare const subscriptionListDeltas: (previousJson: string, nextResult: unknown, table: string, frames?: string[]) => MutationDelta[] | undefined;
+interface FrameSink {
+  send: (data: string) => void;
+}
+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) => boolean;
+declare const awaitWsDrain: (ws: DrainableSink) => Promise<void>;
+type ConflictKind = "conflict" | "occ" | "restrict" | "trigger" | "unique";
+declare class ConflictError extends LunoraError {
+  readonly kind: ConflictKind;
+  constructor(message?: string, kind?: ConflictKind);
+}
+interface TransactionSqlLike {
+  exec: (query: string) => unknown;
+}
+interface TtlSweepSpec {
+  after?: number;
+  field: string;
+  softDeleteField?: string;
+  table: string;
+}
+declare const selectExpiredIds: (sql: SqlExec, spec: TtlSweepSpec, now: number, limit: 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;
+  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 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, 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 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 IndexRangeBuilderLike, 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 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 SearchFilterBuilderLike, type SearchIndexDefinitionLike, 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 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 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, buildPokeFrames, buildSeekBeforeWhere, buildSeekWhere, buildSettings, bumpCdcEpoch, clampPromotionThresholds, clearCapturedMail, clearQueueMessages, coerceAggregateNumber, compileWhereSql, computeRankPage, containsRelationPredicate, coveringGeohashes, createCompanionSync, createDependencyTracker, createFanoutCounters, createIndexSql, 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, isDevEnvironment, isFtsAvailable, isLossyBody, isRelationPredicate, isSoftDeleted, isSourceDue, jsonPath, jsonPathSql, liftSourceId, lintReadonlySql, listTables, matchesRankStaticWhere, matchesStaticWhere, materializeExternalRows, materializeExternalRowsIncremental, 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, 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 };