@crvouga/mockingbird-service-postgres 0.1.0

package/dist/indexes/index.d.ts

@@ -0,0 +1,14 @@
+/** Btree / hash index over row indices. Keys are pre-serialized (datumKey tuples). */
+export declare class IndexStore {
+    readonly name: string;
+    readonly unique: boolean;
+    private entries;
+    constructor(name: string, unique?: boolean);
+    get size(): number;
+    checkUnique(key: string, rowIdx?: number): void;
+    insert(key: string, rowIdx: number): void;
+    remove(key: string, rowIdx: number): void;
+    lookup(key: string): readonly number[];
+    clear(): void;
+    clone(): IndexStore;
+}

package/dist/indexes/maintain.d.ts

@@ -0,0 +1,11 @@
+import { type UniqueSpec } from "../constraints/enforce.js";
+import type { ExecEnv } from "../executor/relation.js";
+import type { TableData } from "../storage/database-state.js";
+import type { Datum } from "../types/value.js";
+import { IndexStore } from "./index.js";
+export declare function invalidateTableIndexes(table: TableData): void;
+export declare function indexStoreFor(env: ExecEnv, table: TableData, spec: UniqueSpec): IndexStore;
+export declare function indexInsertRow(env: ExecEnv, table: TableData, rowIdx: number, row: Datum[]): void;
+export declare function indexRemoveRow(env: ExecEnv, table: TableData, rowIdx: number, row: Datum[]): void;
+export declare function indexUpdateRow(env: ExecEnv, table: TableData, rowIdx: number, oldRow: Datum[], newRow: Datum[]): void;
+export declare function rebuildTableIndexes(env: ExecEnv, table: TableData): void;

package/dist/lexer/tokenize.d.ts

@@ -0,0 +1,8 @@
+export type TokenType = "ident" | "quoted_ident" | "string" | "bitstring" | "number" | "param" | "op" | "punct" | "eof";
+export interface Token {
+    readonly type: TokenType;
+    readonly value: string;
+    /** byte offset in the source (for error positions) */
+    readonly pos: number;
+}
+export declare function tokenize(sql: string): Token[];

package/dist/parser/index.d.ts

@@ -0,0 +1 @@
+export { parse, parseSingle } from "./parser.js";

package/dist/parser/parser.d.ts

@@ -0,0 +1,98 @@
+import type { Expr, SelectStmt, Statement, TypeName, WithClause } from "../ast/nodes.js";
+export declare class Parser {
+    private tokens;
+    private pos;
+    constructor(sql: string);
+    private peek;
+    private next;
+    private atKw;
+    private eatKw;
+    private expectKw;
+    private atPunct;
+    private eatPunct;
+    private expectPunct;
+    private atOp;
+    private eatOp;
+    private errorAt;
+    /** identifier (unquoted non-reserved or quoted) */
+    private ident;
+    private qualifiedName;
+    parseStatements(): Statement[];
+    parseStatement(): Statement;
+    private skipToStatementEnd;
+    /** Consume tokens until the matching `)` after an opening `(` already eaten. */
+    private skipBalancedCloseParen;
+    private parseWithableStatement;
+    private parseWithClause;
+    parseSelectStmt(withClause?: WithClause | null): SelectStmt;
+    private parseSelectBody;
+    private parseSelectTerm;
+    private parseSelectPrimary;
+    private parseSelectCore;
+    private parseGroupItem;
+    private parseSelectTarget;
+    private parseOrderByClause;
+    private parseOrderByItem;
+    private parseLimitOffset;
+    private parseFromItem;
+    private tryParseJoin;
+    private parseFromPrimary;
+    private parseWithOrdinality;
+    private parseAliasClause;
+    private parseInsert;
+    private parseReturning;
+    private parseUpdateSets;
+    private parseSetColumn;
+    private parseUpdate;
+    private parseDelete;
+    private parseCreate;
+    private parseIfNotExists;
+    private parseIfExists;
+    private parseCreateTable;
+    private tryParseTableConstraint;
+    private skipConstraintTail;
+    private parseRefActions;
+    private parseRefAction;
+    private parseColumnDef;
+    private parseIdentityOptions;
+    private parseSequenceOptions;
+    private parseSignedBigInt;
+    private parseCreateIndex;
+    private parseCreateView;
+    private parseCreateFunction;
+    private parseCreateTrigger;
+    private parseAlter;
+    private parseAlterTableAction;
+    private parseDrop;
+    private parseTruncate;
+    private parseSet;
+    private parseExplain;
+    private parseCopy;
+    parseTypeName(): TypeName;
+    parseExpr(): Expr;
+    private parseOr;
+    private parseAnd;
+    private parseNot;
+    private parseIs;
+    private parseComparison;
+    private tryParseAnyAll;
+    private parseLikeBetweenIn;
+    /** all other binary operators: ||, &, |, #, <<, >>, @>, <@, ->, ->>, etc. */
+    private parseGenericOps;
+    private parseAdditive;
+    private parseMultiplicative;
+    private parseExponent;
+    private parseUnary;
+    private parsePostfix;
+    private parsePrimary;
+    private parseCase;
+    private maybePrecision;
+    private parseNestedArrayLiteral;
+    private parseFuncCall;
+    private parseWindowSpec;
+    private parseFrameBound;
+}
+/** Parse SQL text into a list of statements. */
+export declare function parse(sql: string): Statement[];
+/** Parse exactly one statement; throws `misuse`-style errors handled by API layer. */
+export declare function parseSingle(sql: string): Statement;

package/dist/planner/access.d.ts

@@ -0,0 +1,15 @@
+import type { Expr, FromItem } from "../ast/nodes.js";
+import { type ExecEnv } from "../executor/relation.js";
+import type { TableData } from "../storage/database-state.js";
+import { type Datum, type TypeId } from "../types/value.js";
+export interface ConstEquality {
+    column: string;
+    valueExpr: Expr;
+}
+export declare function equalityAgainstConst(expr: Expr): ConstEquality | null;
+export declare function conjunctions(expr: Expr): Expr[];
+/** Single-table PK / unique equality lookup: returns matching rows or null to scan. */
+export declare function tryIndexedTableRows(env: ExecEnv, table: TableData, alias: string, where: Expr): Datum[][] | null;
+export declare function tryIndexedFromItem(env: ExecEnv, item: FromItem, where: Expr | null): Datum[][] | null;
+export declare function joinKeyFromRow(row: Datum[], colIdxs: number[], srcTypes: TypeId[], unifiedTypes: TypeId[], ctx: import("../expressions/context.js").EngineCtx): string | null;
+export declare function rowsMatchEqKeys(ctx: import("../expressions/context.js").EngineCtx, left: Datum[], right: Datum[], leftIdxs: number[], rightIdxs: number[], leftTypes: TypeId[], rightTypes: TypeId[], unifiedTypes: TypeId[]): boolean;

package/dist/runtime/assert.d.ts

@@ -0,0 +1,5 @@
+/** Internal invariant failure — not a user SQL error. */
+export declare function assert(condition: boolean, message: string): asserts condition;
+export declare function assertDefined<T>(value: T | null | undefined, message: string): T;
+export declare function assertBounds(value: number, min: number, max: number, label: string): void;
+export declare function assertNever(value: never, message?: string): never;

package/dist/runtime/clock.d.ts

@@ -0,0 +1,14 @@
+/** Fixed reference instant used when callers do not supply a clock (`2000-01-01T00:00:00.000Z`). */
+export declare const DEFAULT_NOW: Date;
+/** Function that returns the current instant for `now()` and related builtins. */
+export type Clock = () => Date;
+/**
+ * Clock that always returns a copy of `instant` (default {@link DEFAULT_NOW}).
+ *
+ * @throws {RangeError} If `instant` is an invalid `Date`.
+ */
+export declare function fixedClock(instant?: Date): Clock;
+/** Wall-clock `now()` matching PostgreSQL (`new Date()` each call). */
+export declare function systemClock(): Clock;
+/** Normalize a `Date`, {@link Clock}, `"system"`, or `undefined` into a {@link Clock}. */
+export declare function resolveClock(now?: Date | Clock | "system"): Clock;

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export { type Clock, DEFAULT_NOW, fixedClock, resolveClock, systemClock } from "./clock.js";
+export { type DatabaseOptions, DEFAULT_DATABASE_SEED, type Int8Mode, type RandomMode } from "./options.js";
+export { deriveSeed, OsEntropy, Prng } from "./prng.js";

package/dist/runtime/options.d.ts

@@ -0,0 +1,34 @@
+import type { Clock } from "./clock.js";
+/** Entropy source for `random()` / `gen_random_uuid()`. Default is seeded xorshift64*. */
+export type RandomMode = "deterministic" | "os";
+/** How `int8` columns surface in query row objects. Default `"bigint"`. */
+export type Int8Mode = "bigint" | "number" | "string";
+/** Options for {@link Database} construction. All fields are optional. */
+export interface DatabaseOptions {
+    /**
+     * Seed for deterministic `random()` (and any other PRNG-backed builtins).
+     * Defaults to {@link DEFAULT_DATABASE_SEED} (`1`). Ignored when {@link random} is `"os"`.
+     */
+    seed?: number | bigint;
+    /**
+     * Entropy for `random()` / `gen_random_uuid()`.
+     * `"deterministic"` (default) uses {@link seed}. `"os"` uses CSPRNG like PostgreSQL
+     * (not rolled back with transactions; not restored from snapshots).
+     */
+    random?: RandomMode;
+    /**
+     * Clock for `now()` / `current_timestamp` / etc.
+     * Defaults to a fixed instant (`2000-01-01T00:00:00.000Z`).
+     * Pass a `Date`, `() => Date`, or `"system"` for wall-clock `now()` like PostgreSQL.
+     */
+    now?: Date | Clock | "system";
+    /**
+     * How `int8` / `bigint` columns surface in query row objects.
+     * Default `"bigint"` matches PostgreSQL's JS-unsafe 64-bit integers.
+     * `"number"` uses IEEE number (unsafe beyond `Number.MAX_SAFE_INTEGER`).
+     * `"string"` is JSON-safe.
+     */
+    int8?: Int8Mode;
+}
+/** Default {@link DatabaseOptions.seed} when constructing a {@link Database}. */
+export declare const DEFAULT_DATABASE_SEED = 1;

package/dist/runtime/prng.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Deterministic 64-bit PRNG (xorshift64*).
+ * Used for PostgreSQL `random()` / `gen_random_uuid()` and any other
+ * nondeterministic builtins.
+ */
+export declare class Prng {
+    private state;
+    /**
+     * @param seed - Engine seed. `0` is replaced with a non-zero constant.
+     */
+    constructor(seed?: number | bigint);
+    /** Next unsigned 64-bit value. */
+    nextU64(): bigint;
+    /** Next float in `[0, 1)` from 53 bits of {@link nextU64}. */
+    nextFloat(): number;
+    /**
+     * Next integer in `[min, max]` (inclusive).
+     *
+     * @throws {RangeError} If `max < min`.
+     */
+    nextInt(min: number, max: number): number;
+    /** Next bigint in `[min, max]` (inclusive). */
+    nextBigInt(min: bigint, max: bigint): bigint;
+    /** Random UUIDv4 string from PRNG bits. */
+    nextUuid4(): string;
+    /** Reseed from a float in [-1, 1] (SQL `setseed()`). */
+    setSeedFloat(seed: number): void;
+    /** Current unsigned 64-bit engine state (for snapshot / transaction rollback). */
+    getState(): bigint;
+    /** Restore unsigned 64-bit engine state from {@link getState}. */
+    setState(state: bigint): void;
+    /** Independent copy with the same engine state. */
+    clone(): Prng;
+}
+/**
+ * CSPRNG-backed entropy for `random()` / `gen_random_uuid()` when
+ * {@link DatabaseOptions.random} is `"os"`. `setState` is a no-op so
+ * ROLLBACK / snapshot restore do not rewind draws.
+ */
+export declare class OsEntropy extends Prng {
+    constructor();
+    nextU64(): bigint;
+    getState(): bigint;
+    setState(_state: bigint): void;
+    clone(): Prng;
+}
+/** FNV-1a hash of `parts` as a signed 32-bit seed (for tests and custom PRNGs). */
+export declare function deriveSeed(...parts: Array<number | string | bigint>): number;

package/dist/schema/catalog-tables.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema/catalog.d.ts

@@ -0,0 +1,12 @@
+import type { Relation } from "../executor/relation.js";
+import type { EngineCtx } from "../expressions/context.js";
+/**
+ * Virtual pg_catalog / information_schema relations, materialized on demand.
+ * Implemented in catalog-tables.ts; this indirection keeps the executor
+ * import graph acyclic.
+ */
+export type CatalogBuilder = (ctx: EngineCtx, schema: string, name: string) => Relation | null;
+export declare function setCatalogBuilder(b: CatalogBuilder): void;
+export declare function catalogRelation(ctx: EngineCtx, schema: string, name: string): Relation | null;
+/** Relations resolvable unqualified via the implicit pg_catalog search-path entry. */
+export declare const PG_CATALOG_RELATIONS: ReadonlySet<string>;

package/dist/serialization/codec.d.ts

@@ -0,0 +1,22 @@
+import type { Clock } from "../runtime/clock.js";
+import type { Prng } from "../runtime/prng.js";
+import { DatabaseState } from "../storage/database-state.js";
+/** PRNG + clock captured alongside catalog/rows. */
+export interface SnapshotRuntime {
+    prngState: bigint;
+    nowMs: number;
+}
+/** Result of {@link decodeDatabaseState}. */
+export interface DecodedSnapshot {
+    state: DatabaseState;
+    runtime: SnapshotRuntime | null;
+}
+/**
+ * Encode catalog, rows, and runtime into a postgres-mem `PGMM` snapshot blob
+ * (not an on-disk PostgreSQL format).
+ */
+export declare function encodeDatabaseState(state: DatabaseState, runtime: SnapshotRuntime): Uint8Array;
+/**
+ * Decode a blob from {@link encodeDatabaseState} / {@link Database.snapshot}.
+ */
+export declare function decodeDatabaseState(snapshot: Uint8Array, prng: Prng, clock: Clock): DecodedSnapshot;

package/dist/serialization/index.d.ts

@@ -0,0 +1 @@
+export { type DecodedSnapshot, decodeDatabaseState, encodeDatabaseState, type SnapshotRuntime, } from "./codec.js";

package/dist/serialization/wire.d.ts

@@ -0,0 +1,63 @@
+export declare function utf8Encode(s: string): Uint8Array;
+export declare function utf8Decode(b: Uint8Array): string;
+export declare function writeVarintU32(w: Writer, value: number): void;
+export declare function readVarintU32(r: Reader): number;
+export declare class Writer {
+    private buf;
+    private view;
+    private len;
+    constructor(capacity?: number);
+    get position(): number;
+    reserve(capacity: number): void;
+    private ensure;
+    align4(): void;
+    u8(value: number): void;
+    u32(value: number): void;
+    i32(value: number): void;
+    u64(value: bigint): void;
+    i64(value: bigint): void;
+    f64(value: number): void;
+    raw(value: Uint8Array): void;
+    /** Length-prefixed UTF-8. */
+    text(value: string): void;
+    /** Write UTF-8 at current position without length prefix (intern blob region). */
+    textBytes(value: string): void;
+    finish(): Uint8Array;
+    fail(): never;
+}
+export declare class Reader {
+    private readonly bytes;
+    private offset;
+    private readonly view;
+    constructor(bytes: Uint8Array);
+    get position(): number;
+    skipAlign4(): void;
+    u8(): number;
+    u32(): number;
+    i32(): number;
+    u64(): bigint;
+    i64(): bigint;
+    f64(): number;
+    raw(length: number): Uint8Array;
+    text(): string;
+    remaining(): number;
+    done(): boolean;
+    fail(): never;
+}
+export declare function writeBjv(w: Writer, value: unknown, forceIntern: (s: string) => number): void;
+export declare function readBjv(r: Reader, intern: readonly string[]): unknown;
+export declare class InternPool {
+    private readonly counts;
+    private readonly ids;
+    readonly list: string[];
+    constructor();
+    count(s: string): void;
+    /** Assign ids only to strings seen ≥2 times (plus empty string). */
+    finalize(): void;
+    /** Always intern (schema / catalog strings). */
+    forceId(s: string): number;
+    id(s: string): number;
+}
+/** Write intern table: count, offsets[], concatenated UTF-8 blob. */
+export declare function writeInternTable(w: Writer, strings: readonly string[]): void;
+export declare function readInternTable(r: Reader): string[];

package/dist/sql/deparse.d.ts

@@ -0,0 +1,3 @@
+import type { SelectStmt } from "../ast/nodes.js";
+/** Minimal SELECT deparsing for pg_get_viewdef / information_schema. */
+export declare function deparseSelect(stmt: SelectStmt): string;

package/dist/storage/columnar-slab.d.ts

@@ -0,0 +1,37 @@
+import type { Datum } from "../types/value.js";
+/** Column pack tags (PGMM v3). */
+export declare const PACK_NULL = 0;
+export declare const PACK_BOOL = 1;
+export declare const PACK_FLOAT = 2;
+export declare const PACK_INT = 3;
+export declare const PACK_TEXT_INTERN = 4;
+export declare const PACK_TEXT_INLINE = 5;
+export declare const PACK_BLOB = 6;
+export declare const PACK_TAGGED = 7;
+export interface SlabColumn {
+    pack: number;
+    nullBitmap: Uint8Array | null;
+    /** Prefix sum of non-null rows for O(1) null-index lookup. */
+    nonNullPrefix?: Uint32Array;
+    /** Typed payload or inline blob region inside `buffer`. */
+    payload: Uint8Array;
+    /** For PACK_TEXT_INLINE: u32 offsets into payload per row. */
+    inlineOffsets?: Uint32Array;
+    /** For PACK_TAGGED: decoded values per non-null row in order. */
+    tagged?: Datum[];
+    /** For PACK_BLOB: one entry per non-null row (zero-copy views). */
+    blobChunks?: Uint8Array[];
+}
+/** Frozen columnar row storage; zero-copy views into snapshot buffer. */
+export declare class ColumnarSlab {
+    readonly buffer: Uint8Array;
+    readonly rowCount: number;
+    readonly columns: SlabColumn[];
+    private readonly intern;
+    constructor(buffer: Uint8Array, rowCount: number, columns: SlabColumn[], intern: readonly string[]);
+    cell(rowIndex: number, col: number): Datum;
+    rowAt(rowIndex: number): Datum[];
+    scan(): Generator<Datum[]>;
+    materialize(): Datum[][];
+}
+export declare function packKindOf(value: Datum): number;

package/dist/storage/database-state.d.ts

@@ -0,0 +1,253 @@
+import type { CreateTriggerStmt, Expr, SelectStmt, Statement } from "../ast/nodes.js";
+import type { Clock } from "../runtime/clock.js";
+import type { Prng } from "../runtime/prng.js";
+import { type ColumnType, type Datum, type TypeId } from "../types/value.js";
+import type { ColumnarSlab } from "./columnar-slab.js";
+export interface ColumnMeta {
+    name: string;
+    type: ColumnType;
+    notNull: boolean;
+    defaultExpr: Expr | null;
+    identity: {
+        always: boolean;
+        sequence: string;
+    } | null;
+    generated: Expr | null;
+    collate: string | null;
+    /** resolved domain name when column type came from a domain */
+    domain: string | null;
+}
+export type ConstraintMeta = {
+    kind: "primary_key";
+    name: string;
+    columns: string[];
+} | {
+    kind: "unique";
+    name: string;
+    columns: string[];
+    nullsNotDistinct: boolean;
+} | {
+    kind: "check";
+    name: string;
+    expr: Expr;
+} | {
+    kind: "foreign_key";
+    name: string;
+    columns: string[];
+    refSchema: string;
+    refTable: string;
+    refColumns: string[];
+    onDelete: string | null;
+    onUpdate: string | null;
+    match: "full" | "simple";
+};
+export interface IndexMeta {
+    name: string;
+    schema: string;
+    table: string;
+    unique: boolean;
+    /** simple column indexes store names; expression indexes store the AST */
+    columns: Array<{
+        column: string | null;
+        expr: Expr | null;
+        dir: "asc" | "desc";
+        nulls: "first" | "last";
+    }>;
+    where: Expr | null;
+    nullsNotDistinct: boolean;
+    /** true when this index backs a constraint (pkey / unique constraint) */
+    isConstraint: boolean;
+}
+export interface TriggerMeta {
+    name: string;
+    timing: "before" | "after" | "instead_of";
+    events: CreateTriggerStmt["events"];
+    forEachRow: boolean;
+    when: Expr | null;
+    funcSchema: string;
+    funcName: string;
+    funcArgs: string[];
+}
+export declare class TableData {
+    name: string;
+    schema: string;
+    columns: ColumnMeta[];
+    rows: Datum[][];
+    /** Frozen columnar storage after snapshot hydrate; `rows` stays empty until materialized. */
+    slab: ColumnarSlab | null;
+    constraints: ConstraintMeta[];
+    triggers: TriggerMeta[];
+    temp: boolean;
+    /** monotonically increasing oid-like id for catalog output */
+    readonly oid: number;
+    /** >0 while shared with a clone or transaction snapshot. */
+    shareCount: number;
+    /** Derived unique/btree index maps; null until built or invalidated. */
+    indexStores: Map<string, import("../indexes/index.js").IndexStore> | null;
+    constructor(schema: string, name: string, columns: ColumnMeta[], oid: number, temp?: boolean);
+    rowCount(): number;
+    rowAt(index: number): Datum[];
+    /** All rows for scans; materializes slab once into `rows` when needed. */
+    allRows(): Datum[][];
+    attachSlab(slab: ColumnarSlab): void;
+    materializeSlab(): void;
+    /** Writable row storage; materializes slab if needed. */
+    mutableRows(): Datum[][];
+    get frozen(): boolean;
+    freeze(): void;
+    thaw(): void;
+    columnIndex(name: string): number;
+    clone(): TableData;
+    /** Independent writable copy (row tuples copied so ALTER COLUMN is isolated). */
+    cloneForWrite(): TableData;
+}
+export interface ViewData {
+    name: string;
+    schema: string;
+    query: SelectStmt;
+    columns: string[] | null;
+    materialized: boolean;
+    /** materialized contents; null = WITH NO DATA (not populated) */
+    matRows: Datum[][] | null;
+    matColumns: Array<{
+        name: string;
+        type: TypeId;
+    }> | null;
+    temp: boolean;
+    oid: number;
+    shareCount?: number;
+}
+export interface SequenceData {
+    name: string;
+    schema: string;
+    increment: bigint;
+    minValue: bigint;
+    maxValue: bigint;
+    startValue: bigint;
+    cache: bigint;
+    cycle: boolean;
+    lastValue: bigint;
+    isCalled: boolean;
+    ownedBy: {
+        table: string;
+        column: string;
+    } | null;
+    dataType: TypeId;
+    temp: boolean;
+    oid: number;
+    shareCount?: number;
+}
+export interface EnumData {
+    name: string;
+    schema: string;
+    labels: string[];
+    oid: number;
+    shareCount?: number;
+}
+export interface DomainData {
+    name: string;
+    schema: string;
+    baseType: ColumnType;
+    notNull: boolean;
+    defaultExpr: Expr | null;
+    checks: Array<{
+        name: string;
+        expr: Expr;
+    }>;
+    oid: number;
+    shareCount?: number;
+}
+export interface FunctionData {
+    name: string;
+    schema: string;
+    argNames: (string | null)[];
+    argTypes: TypeId[];
+    argDefaults: (Expr | null)[];
+    returns: TypeId | null;
+    returnsSet: boolean;
+    returnsTable: Array<{
+        name: string;
+        type: TypeId;
+    }> | null;
+    language: string;
+    body: Statement[] | null;
+    rawBody: string | null;
+    strict: boolean;
+    oid: number;
+    jsImpl?: (...args: Array<null | boolean | number | bigint | string | Uint8Array>) => null | boolean | number | bigint | string | Uint8Array;
+}
+export declare class SchemaData {
+    name: string;
+    tables: Map<string, TableData>;
+    views: Map<string, ViewData>;
+    sequences: Map<string, SequenceData>;
+    enums: Map<string, EnumData>;
+    domains: Map<string, DomainData>;
+    functions: Map<string, FunctionData[]>;
+    indexes: Map<string, IndexMeta>;
+    oid: number;
+    constructor(name: string, oid: number);
+    /** all relation names (tables, views, sequences, indexes share pg_class namespace) */
+    hasRelation(name: string): boolean;
+    clone(): SchemaData;
+    /** Share table/sequence objects; copy maps so CREATE/DROP is isolated. */
+    cloneShallow(): SchemaData;
+}
+export interface PreparedStatement {
+    name: string;
+    argTypes: TypeId[] | null;
+    stmt: Statement;
+}
+export declare class DatabaseState {
+    schemas: Map<string, SchemaData>;
+    settings: Map<string, string>;
+    /** SET LOCAL values, cleared on COMMIT/ROLLBACK */
+    localSettings: Map<string, string>;
+    prepared: Map<string, PreparedStatement>;
+    prng: Prng;
+    clock: Clock;
+    changes: number;
+    private oidCounter;
+    inTransaction: boolean;
+    /** most recent sequence touched by nextval/setval, for lastval() */
+    lastSequence: {
+        schema: string;
+        name: string;
+    } | null;
+    /** Session currval per sequence; absent entry means currval is undefined. */
+    sequenceCurrval: Map<string, bigint>;
+    constructor(prng: Prng, clock: Clock);
+    nextOid(): number;
+    getSetting(name: string): string | undefined;
+    /** effective search path: existing schemas from search_path setting */
+    effectiveSearchPath(): string[];
+    currentSchema(): string;
+    getSchema(name: string): SchemaData;
+    /** Resolve a possibly-qualified relation name to its schema. */
+    resolveRelationSchema(parts: string[]): {
+        schema: string;
+        name: string;
+    } | null;
+    findTable(parts: string[]): TableData | null;
+    requireTable(parts: string[]): TableData;
+    findView(parts: string[]): ViewData | null;
+    findSequence(parts: string[]): SequenceData | null;
+    findEnum(parts: string[]): EnumData | null;
+    findDomain(parts: string[]): DomainData | null;
+    findFunctions(parts: string[]): FunctionData[];
+    findEnumByKey(key: string): EnumData | null;
+    /** format_type()-style display name for a type OID (builtin or enum). */
+    typeNameForOid(oid: number): string | null;
+    /** deep clone (datums are immutable; rows copied) */
+    clone(): DatabaseState;
+    /** Share frozen catalog objects; copy maps so CREATE/DROP is isolated. */
+    cloneShallow(): DatabaseState;
+    freezeShared(): void;
+    thawShared(): void;
+    ensureWritableTable(table: TableData): TableData;
+    ensureWritableSequence(seq: SequenceData): SequenceData;
+    ensureWritableView(view: ViewData): ViewData;
+    ensureWritableEnum(en: EnumData): EnumData;
+    /** copy the contents of `other` into this state (rollback restore) */
+    restoreFrom(other: DatabaseState): void;
+}