@crvouga/postgres-mem 0.1.0

package/dist/constraints/enforce.d.ts

@@ -0,0 +1,39 @@
+import type { ExecEnv } from "../executor/relation.js";
+import type { IndexMeta, TableData } from "../storage/database-state.js";
+import { type Datum } from "../types/value.js";
+/** NOT NULL column constraints (23502). */
+export declare function checkNotNull(env: ExecEnv, table: TableData, row: Datum[]): void;
+/** CHECK constraints (23514); NULL results pass. */
+export declare function checkChecks(env: ExecEnv, table: TableData, row: Datum[]): void;
+interface UniqueSpec {
+    name: string;
+    /** column indexes for plain column keys; -1 with expr set for expression keys */
+    keys: Array<{
+        colIdx: number;
+        expr: import("../ast/nodes.js").Expr | null;
+    }>;
+    columnNames: string[];
+    nullsNotDistinct: boolean;
+    where: import("../ast/nodes.js").Expr | null;
+    isPrimary: boolean;
+}
+export declare function uniqueSpecsFor(env: ExecEnv, table: TableData): UniqueSpec[];
+/**
+ * Unique / primary key enforcement (23505). `selfIdx` is the row's own index
+ * in table.rows (already inserted / updated in place).
+ */
+export declare function checkUnique(env: ExecEnv, table: TableData, row: Datum[], selfIdx: number): void;
+/** does `row` conflict with an existing row under `spec`? returns the row index */
+export declare function findConflict(env: ExecEnv, table: TableData, spec: UniqueSpec, row: Datum[]): number | null;
+export type { IndexMeta, UniqueSpec };
+/** referencing-side FK enforcement: every non-null key must exist in the referenced table (23503) */
+export declare function checkForeignKeys(env: ExecEnv, table: TableData, row: Datum[]): void;
+export interface ReferencingConstraint {
+    table: TableData;
+    constraint: Extract<import("../storage/database-state.js").ConstraintMeta, {
+        kind: "foreign_key";
+    }>;
+}
+/** all FK constraints in the database that reference `table` */
+export declare function referencingConstraints(env: ExecEnv, table: TableData): ReferencingConstraint[];
+export declare function fullRowCheck(env: ExecEnv, table: TableData, row: Datum[], selfIdx: number): void;

package/dist/errors/error.d.ts

@@ -0,0 +1,24 @@
+/**
+ * PostgresError mirrors the shape a real PostgreSQL server reports:
+ * a human message plus a five-character SQLSTATE code.
+ *
+ * `category` is a stable, coarse-grained enum for consumers that do not want
+ * to switch on raw SQLSTATE codes. New categories may appear in minor
+ * releases — always include a default case.
+ */
+export type ErrorCategory = "syntax" | "undefined_table" | "undefined_column" | "undefined_function" | "undefined_object" | "duplicate_object" | "duplicate_table" | "duplicate_column" | "constraint_not_null" | "constraint_unique" | "constraint_check" | "constraint_foreign_key" | "constraint_exclusion" | "restrict_violation" | "invalid_text_representation" | "numeric_value_out_of_range" | "division_by_zero" | "datatype_mismatch" | "cannot_coerce" | "invalid_parameter_value" | "invalid_datetime" | "ambiguous_column" | "ambiguous_function" | "grouping_error" | "windowing_error" | "invalid_column_reference" | "wrong_object_type" | "dependent_objects" | "transaction_state" | "misuse" | "unsupported" | "internal" | "data_exception" | "program_limit_exceeded" | "invalid_cursor" | "snapshot_format" | "snapshot_version" | "string_data_right_truncation" | "invalid_regular_expression" | "case_not_found" | "cardinality_violation" | "undefined_parameter" | "not_null_violation" | "check_violation" | "array_subscript_error" | "array_element_error" | "invalid_escape_sequence" | "feature_not_supported" | "null_value_not_allowed" | "invalid_argument_for_power_function" | "invalid_argument_for_log" | "invalid_argument_for_width_bucket_function" | "sequence_generator_limit_exceeded" | "object_not_in_prerequisite_state" | "substring_error" | "invalid_table_definition" | "duplicate_schema" | "duplicate_function" | "generated_always" | "invalid_row_count" | "duplicate_prepared_statement" | "undefined_prepared_statement" | "invalid_savepoint_specification" | "raise_exception" | "invalid_function_definition";
+export declare class PostgresError extends Error {
+    readonly category: ErrorCategory;
+    /** Five-character SQLSTATE, e.g. "42P01". Always set. */
+    readonly sqlState: string;
+    /** Alias of sqlState (node-postgres `err.code` convention). */
+    readonly code: string;
+    constructor(category: ErrorCategory, message: string, sqlState?: string);
+}
+export declare function pgError(category: ErrorCategory, message: string, sqlState?: string): PostgresError;
+/**
+ * SQL the oracle accepts but this engine has not implemented must fail loud,
+ * never silently misbehave. The compat gate keys off this.
+ */
+export declare function unsupported(what: string): PostgresError;
+export declare function isPostgresError(err: unknown): err is PostgresError;

package/dist/executor/ddl.d.ts

@@ -0,0 +1,23 @@
+import type { AlterEnumStmt, AlterIndexStmt, AlterSchemaStmt, AlterSequenceStmt, AlterTableStmt, AlterViewStmt, CreateDomainStmt, CreateEnumStmt, CreateFunctionStmt, CreateIndexStmt, CreateSchemaStmt, CreateSequenceStmt, CreateTableAsStmt, CreateTableStmt, CreateTriggerStmt, CreateViewStmt, DropStmt, RefreshMaterializedViewStmt, SequenceOptions, TruncateStmt } from "../ast/nodes.js";
+import { SchemaData, type SequenceData } from "../storage/database-state.js";
+import { type ExecEnv, type ExecResult } from "./relation.js";
+export declare function buildSequence(env: ExecEnv, schema: SchemaData, name: string, options: SequenceOptions, temp: boolean): SequenceData;
+export declare function executeCreateSequence(env: ExecEnv, stmt: CreateSequenceStmt): ExecResult;
+export declare function executeAlterSequence(env: ExecEnv, stmt: AlterSequenceStmt): ExecResult;
+export declare function executeCreateTable(env: ExecEnv, stmt: CreateTableStmt): ExecResult;
+export declare function executeCreateTableAs(env: ExecEnv, stmt: CreateTableAsStmt): ExecResult;
+export declare function executeCreateIndex(env: ExecEnv, stmt: CreateIndexStmt): ExecResult;
+export declare function executeCreateView(env: ExecEnv, stmt: CreateViewStmt): ExecResult;
+export declare function executeRefreshMatView(env: ExecEnv, stmt: RefreshMaterializedViewStmt): ExecResult;
+export declare function executeCreateSchema(env: ExecEnv, stmt: CreateSchemaStmt): ExecResult;
+export declare function executeCreateEnum(env: ExecEnv, stmt: CreateEnumStmt): ExecResult;
+export declare function executeAlterEnum(env: ExecEnv, stmt: AlterEnumStmt): ExecResult;
+export declare function executeCreateDomain(env: ExecEnv, stmt: CreateDomainStmt): ExecResult;
+export declare function executeCreateFunction(env: ExecEnv, stmt: CreateFunctionStmt): ExecResult;
+export declare function executeCreateTrigger(env: ExecEnv, stmt: CreateTriggerStmt): ExecResult;
+export declare function executeAlterTable(env: ExecEnv, stmt: AlterTableStmt): ExecResult;
+export declare function executeAlterView(env: ExecEnv, stmt: AlterViewStmt): ExecResult;
+export declare function executeAlterIndex(env: ExecEnv, stmt: AlterIndexStmt): ExecResult;
+export declare function executeAlterSchema(env: ExecEnv, stmt: AlterSchemaStmt): ExecResult;
+export declare function executeDrop(env: ExecEnv, stmt: DropStmt): ExecResult;
+export declare function executeTruncate(env: ExecEnv, stmt: TruncateStmt): ExecResult;

package/dist/executor/dml.d.ts

@@ -0,0 +1,10 @@
+import type { DeleteStmt, InsertStmt, SelectStmt, UpdateStmt } from "../ast/nodes.js";
+import type { TableData } from "../storage/database-state.js";
+import { type Datum } from "../types/value.js";
+import { type ExecEnv, type ExecResult, type Relation } from "./relation.js";
+export declare function executeInsert(env0: ExecEnv, stmt: InsertStmt): ExecResult;
+export declare function executeUpdate(env0: ExecEnv, stmt: UpdateStmt): ExecResult;
+export declare function executeDelete(env0: ExecEnv, stmt: DeleteStmt): ExecResult;
+export declare function handleReferencedDelete(env: ExecEnv, table: TableData, row: Datum[], depth: number): void;
+export declare function handleReferencedUpdate(env: ExecEnv, table: TableData, oldRows: Datum[][], newRows: Datum[][]): void;
+export type { Relation, SelectStmt };

package/dist/executor/execute.d.ts

@@ -0,0 +1,11 @@
+import type { Statement } from "../ast/nodes.js";
+import "../schema/catalog-tables.js";
+import "./triggers-exec.js";
+import type { DatabaseState } from "../storage/database-state.js";
+import type { TypedValue } from "../types/value.js";
+import { type ExecEnv, type ExecResult } from "./relation.js";
+/** Execute one parsed statement against `state`. */
+export declare function executeStatement(env: ExecEnv, stmt: Statement): ExecResult;
+/** Fresh execution environment for one top-level statement. */
+export declare function makeEnv(state: DatabaseState, params?: TypedValue[] | null): ExecEnv;
+export type { ExecEnv, ExecResult };

package/dist/executor/relation.d.ts

@@ -0,0 +1,60 @@
+import type { EngineCtx } from "../expressions/context.js";
+import type { Datum, TypedValue, TypeId } from "../types/value.js";
+/** A column of an intermediate or final result relation. */
+export interface RelColumn {
+    name: string;
+    type: TypeId;
+    /** range-variable (table alias) the column belongs to; null for computed columns */
+    table: string | null;
+    /** hidden columns (e.g. ORDER BY helpers) are excluded from final output */
+    hidden?: boolean;
+}
+export interface Relation {
+    columns: RelColumn[];
+    rows: Datum[][];
+}
+export declare function emptyRelation(): Relation;
+/**
+ * Row-level name resolution scope. Chains to an outer scope for correlated
+ * subqueries and LATERAL.
+ */
+export declare class RowScope {
+    readonly columns: RelColumn[];
+    row: Datum[];
+    readonly parent: RowScope | null;
+    /** range variables visible as whole-row references */
+    readonly rangeVars: Set<string>;
+    constructor(columns: RelColumn[], row: Datum[], parent?: RowScope | null, 
+    /** range variables visible as whole-row references */
+    rangeVars?: Set<string>);
+    /** Resolve a (possibly qualified) column reference. undefined = not found. */
+    lookup(parts: string[]): TypedValue | undefined;
+    /** Build a record value from all columns belonging to a range variable. */
+    wholeRow(rangeVar: string): TypedValue | undefined;
+    hasRangeVar(name: string): boolean;
+}
+/** Environment threaded through statement execution. */
+export interface ExecEnv {
+    ctx: EngineCtx;
+    params: TypedValue[] | null;
+    /** CTE results by name (WITH clause); shadowed inner-to-outer */
+    ctes: Map<string, Relation>;
+    outer: RowScope | null;
+}
+export declare function childEnv(env: ExecEnv, outer: RowScope | null): ExecEnv;
+export declare function withCtes(env: ExecEnv, ctes: Map<string, Relation>): ExecEnv;
+/** Final result surfaced by the API layer. */
+export interface ExecResult {
+    columns: Array<{
+        name: string;
+        type: TypeId;
+    }>;
+    rows: Datum[][];
+    command: string;
+    rowCount: number;
+}
+export declare function relationResult(rel: Relation, command: string): ExecResult;
+export declare function commandResult(command: string, rowCount: number): ExecResult;
+/** column name PG infers for an expression without an alias */
+export declare function inferColumnName(e: import("../ast/nodes.js").Expr): string;
+export type { EngineCtx };

package/dist/executor/select.d.ts

@@ -0,0 +1,41 @@
+import type { Expr, FromItem, FuncCall, OrderByItem, SelectBody, SelectCore, SelectStmt, Statement, WithClause } from "../ast/nodes.js";
+import type { EvalScope } from "../expressions/eval.js";
+import type { FunctionData } from "../storage/database-state.js";
+import { type TypedValue } from "../types/value.js";
+import { type ExecEnv, type ExecResult, type Relation, RowScope } from "./relation.js";
+export type StatementRunner = (env: ExecEnv, stmt: Statement) => ExecResult;
+export declare function setStatementRunner(r: StatementRunner): void;
+export declare function runStatement(env: ExecEnv, stmt: Statement): ExecResult;
+export declare function exprEq(a: unknown, b: unknown): boolean;
+export interface ScopeExtras {
+    aggMap?: Map<FuncCall, TypedValue> | null;
+    windowAt?: (call: FuncCall) => TypedValue | undefined;
+    exprOverride?: (e: Expr) => TypedValue | undefined;
+    groupingValue?: (e: Expr) => TypedValue | undefined;
+    /** grouped context: bare column refs that survive overrides are errors */
+    strictGrouping?: boolean;
+}
+export declare function makeEvalScope(env: ExecEnv, scope: RowScope | null, extras?: ScopeExtras): EvalScope;
+export declare function evalScalar(env: ExecEnv, scope: RowScope | null, e: Expr, extras?: ScopeExtras): TypedValue;
+/** SQL three-valued predicate: null → false */
+export declare function evalPredicate(env: ExecEnv, scope: RowScope | null, e: Expr, extras?: ScopeExtras): boolean;
+export declare function resolveUserFunction(env: ExecEnv, name: string[], argCount: number): FunctionData | null;
+export declare function callSqlFunctionScalar(env: ExecEnv, fn: FunctionData, args: TypedValue[]): TypedValue;
+export declare function callSqlFunctionSet(env: ExecEnv, fn: FunctionData, args: TypedValue[]): Relation;
+export declare function applyWith(env: ExecEnv, w: WithClause | null): ExecEnv;
+interface Source {
+    rel: Relation;
+    rangeVars: Set<string>;
+}
+export declare function buildFrom(env: ExecEnv, items: FromItem[]): Source;
+export interface SortSpec {
+    colIdx: number;
+    dir: "asc" | "desc";
+    nullsFirst: boolean;
+}
+export declare function sortRows(env: ExecEnv, rel: Relation, specs: SortSpec[]): void;
+export declare function executeBody(env: ExecEnv, body: SelectBody): Relation;
+export declare function executeCore(env0: ExecEnv, core: SelectCore, orderBy: OrderByItem[]): Relation;
+export declare function executeSelectStmt(env0: ExecEnv, stmt: SelectStmt): Relation;
+export declare function selectResult(env: ExecEnv, stmt: SelectStmt): ExecResult;
+export {};

package/dist/executor/session.d.ts

@@ -0,0 +1,21 @@
+import type { CopyStmt, DeallocateStmt, ExecuteStmt, ExplainStmt, PrepareStmt, ResetStmt, SetStmt, ShowStmt, TransactionStmt } from "../ast/nodes.js";
+import { DatabaseState } from "../storage/database-state.js";
+import { TransactionManager } from "../transactions/manager.js";
+import { type ExecEnv, type ExecResult } from "./relation.js";
+import { executeSelectStmt } from "./select.js";
+export declare function txManagerFor(state: DatabaseState): TransactionManager;
+export declare function executeTransaction(env: ExecEnv, stmt: TransactionStmt): ExecResult;
+export declare function executeSet(env: ExecEnv, stmt: SetStmt): ExecResult;
+export declare function executeShow(env: ExecEnv, stmt: ShowStmt): ExecResult;
+export declare function executeReset(env: ExecEnv, stmt: ResetStmt): ExecResult;
+export declare function executePrepare(env: ExecEnv, stmt: PrepareStmt): ExecResult;
+export declare function executeExecute(env: ExecEnv, stmt: ExecuteStmt): ExecResult;
+export declare function executeDeallocate(env: ExecEnv, stmt: DeallocateStmt): ExecResult;
+export declare function executeExplain(env: ExecEnv, stmt: ExplainStmt): ExecResult;
+export declare function executeCopy(env: ExecEnv, stmt: CopyStmt): ExecResult;
+/**
+ * Execute COPY ... FROM STDIN with api-provided text/csv data by synthesizing
+ * an INSERT (reuses defaults, identity, constraints, FK actions, triggers).
+ */
+export declare function executeCopyFromData(env: ExecEnv, stmt: CopyStmt, data: string): ExecResult;
+export { executeSelectStmt };

package/dist/executor/triggers-exec.d.ts

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

package/dist/executor/triggers.d.ts

@@ -0,0 +1,16 @@
+import type { TableData, TriggerMeta } from "../storage/database-state.js";
+import type { Datum } from "../types/value.js";
+import type { ExecEnv } from "./relation.js";
+export type TriggerEvent = "insert" | "update" | "delete";
+export interface TriggerFireResult {
+    /** null = row operation skipped (BEFORE trigger returned NULL) */
+    row: Datum[] | null;
+}
+/**
+ * Fire row-level triggers for one row. Trigger function bodies execute via
+ * the plpgsql-lite interpreter in triggers-exec.ts (registered lazily).
+ */
+export type TriggerExecutor = (env: ExecEnv, table: TableData, trigger: TriggerMeta, event: TriggerEvent, oldRow: Datum[] | null, newRow: Datum[] | null) => Datum[] | null;
+export declare function setTriggerExecutor(e: TriggerExecutor): void;
+export declare function fireRowTriggers(env: ExecEnv, table: TableData, timing: "before" | "after" | "instead_of", event: TriggerEvent, oldRow: Datum[] | null, newRow: Datum[] | null): TriggerFireResult;
+export declare function hasRowTriggers(table: TableData, timing: "before" | "after" | "instead_of", event: TriggerEvent): boolean;

package/dist/executor/window.d.ts

@@ -0,0 +1,13 @@
+import type { Expr, FuncCall, WindowSpec } from "../ast/nodes.js";
+import type { EngineCtx } from "../expressions/context.js";
+import { type TypedValue } from "../types/value.js";
+/** Evaluator callback: evaluate `e` in the context of source row `rowIdx`. */
+export type RowEval = (rowIdx: number, e: Expr) => TypedValue;
+/**
+ * Compute all window function results for one SELECT.
+ * Returns per-call arrays indexed by source row.
+ */
+export declare function computeWindowValues(ctx: EngineCtx, calls: FuncCall[], rowCount: number, evalAt: RowEval, namedWindows: ReadonlyArray<{
+    name: string;
+    spec: WindowSpec;
+}>): Map<FuncCall, TypedValue[]>;

package/dist/expressions/context.d.ts

@@ -0,0 +1,23 @@
+import type { DatabaseState } from "../storage/database-state.js";
+import type { CastEnv } from "../types/cast.js";
+import type { CompareCtx } from "../types/compare.js";
+import { type TypeId } from "../types/value.js";
+/**
+ * Engine-wide evaluation context: database state plus per-statement clock
+ * captures. One instance is created per top-level statement execution.
+ */
+export declare class EngineCtx implements CastEnv, CompareCtx {
+    readonly state: DatabaseState;
+    /** transaction timestamp (now(), current_timestamp) — UTC micros since PG epoch */
+    readonly txNow: bigint;
+    /** statement timestamp */
+    readonly stmtNow: bigint;
+    constructor(state: DatabaseState, txNow?: bigint);
+    timezone(): string;
+    zoneOffsetAt(utcMicros: bigint): number;
+    zoneOffsetForNaive(naiveMicros: bigint): number;
+    enumLabels(enumType: TypeId): string[] | null;
+    enumHasLabel(enumType: TypeId, label: string): boolean;
+    enumOrder(enumType: TypeId, label: string): number;
+    requireEnum(enumType: TypeId): string[];
+}

package/dist/expressions/eval.d.ts

@@ -0,0 +1,38 @@
+import type { Expr, FuncCall, SelectStmt } from "../ast/nodes.js";
+import { type Datum, type TypedValue, type TypeId } from "../types/value.js";
+import type { EngineCtx } from "./context.js";
+/**
+ * Environment the executor provides for expression evaluation: column
+ * resolution, parameter binding, subquery execution, aggregate / window
+ * result lookup, and user-defined function invocation.
+ */
+export interface EvalScope {
+    lookupColumn(parts: string[]): TypedValue | undefined;
+    /**
+     * Whole-expression interception (GROUP BY expression matching). Checked
+     * before normal evaluation of every node.
+     */
+    exprOverride?(node: Expr): TypedValue | undefined;
+    param?(index: number): TypedValue;
+    execScalarSubquery?(q: SelectStmt): TypedValue;
+    execExistsSubquery?(q: SelectStmt): boolean;
+    /** rows with a single projected column for IN / ANY / ALL / ARRAY(...) */
+    execColumnSubquery?(q: SelectStmt): {
+        type: TypeId;
+        values: Datum[];
+    };
+    /** precomputed aggregate results (keyed by AST node identity) */
+    aggValue?(node: FuncCall): TypedValue | undefined;
+    /** precomputed window function results */
+    windowValue?(node: FuncCall): TypedValue | undefined;
+    groupingValue?(node: Expr): TypedValue | undefined;
+    callUserFunction?(name: string[], args: TypedValue[], node: FuncCall): TypedValue | undefined;
+    /** sequence functions et al need state mutation; provided by executor */
+    callStatefulFunction?(name: string, args: TypedValue[]): TypedValue | undefined;
+}
+export declare function evalExpr(ctx: EngineCtx, scope: EvalScope, e: Expr): TypedValue;
+export declare function numberLitValue(raw: string): TypedValue;
+export declare function toBool(ctx: EngineCtx, v: TypedValue): boolean | null;
+/** Domain NOT NULL + CHECK constraints, with VALUE bound to the cast result. */
+export declare function applyDomainChecks(ctx: EngineCtx, domainKey: string, value: TypedValue): void;
+export declare function anyAllCompare(ctx: EngineCtx, op: string, left: TypedValue, rights: TypedValue[], kind: "any" | "all"): TypedValue;

package/dist/expressions/operators.d.ts

@@ -0,0 +1,8 @@
+import { isNumeric, makeNumeric, numericSqrt, parseNumeric } from "../types/numeric.js";
+import { float8Text, type TypedValue } from "../types/value.js";
+import type { EngineCtx } from "./context.js";
+export declare function evalBinary(ctx: EngineCtx, op: string, l0: TypedValue, r0: TypedValue): TypedValue;
+/** jsonb - text / jsonb - int / jsonb - text[] */
+export declare function evalJsonbDelete(_ctx: EngineCtx, l: TypedValue, r: TypedValue): TypedValue;
+export declare function evalUnary(ctx: EngineCtx, op: string, operand: TypedValue): TypedValue;
+export { float8Text, isNumeric, makeNumeric, numericSqrt, parseNumeric };

package/dist/expressions/pattern.d.ts

@@ -0,0 +1,20 @@
+/** LIKE pattern → anchored RegExp source. */
+export declare function likeToRegex(pattern: string, escape: string | null): string;
+export declare function likeMatch(text: string, pattern: string, escape: string | null, caseInsensitive: boolean): boolean;
+/** SIMILAR TO pattern → anchored RegExp source (SQL regex dialect). */
+export declare function similarToRegex(pattern: string, escape: string | null): string;
+export declare function similarToMatch(text: string, pattern: string, escape: string | null): boolean;
+/**
+ * Translate a POSIX ARE (PG regex flavor) to a JS RegExp source.
+ * Covers the common surface: classes, quantifiers, anchors, \m/\M/\y word
+ * boundaries, [[:class:]] names. Exotic ARE features (\A directors, back
+ * refs into lookahead) are passed through and may diverge (documented).
+ */
+export declare function pgRegexToJs(pattern: string): string;
+export declare function pgRegex(pattern: string, flags: string): RegExp;
+export declare function regexMatch(text: string, pattern: string, caseInsensitive: boolean): boolean;
+/**
+ * Translate PG regex option letters to JS RegExp flags. PG default is
+ * newline-insensitive (JS `s`); `n`/`m` switch to newline-sensitive (`m`).
+ */
+export declare function regexFlags(pgFlags: string, dropGlobal?: boolean): string;

package/dist/functions/aggregates.d.ts

@@ -0,0 +1,17 @@
+import type { EngineCtx } from "../expressions/context.js";
+import { type TypedValue, type TypeId } from "../types/value.js";
+/** Incremental accumulator; the executor feeds rows and reads the result. */
+export interface AggregateAcc {
+    step(args: TypedValue[]): void;
+    result(): TypedValue;
+}
+export type AggregateFactory = (ctx: EngineCtx, argTypes: TypeId[]) => AggregateAcc;
+export declare function getAggregateFactories(): Map<string, AggregateFactory>;
+export declare function isAggregateName(name: string): boolean;
+export declare function createAggregate(ctx: EngineCtx, name: string, argTypes: TypeId[]): AggregateAcc;
+/** true for aggregates whose arguments come from WITHIN GROUP (ORDER BY ...) */
+export declare function isOrderedSetAggregate(name: string): boolean;
+/** unify agg arg type across rows (executor helper) */
+export declare function unifyAggType(a: TypeId, b: TypeId): TypeId;
+/** result type helpers used by planner-ish code paths */
+export declare function aggregateResultHint(name: string, argT: TypeId): TypeId;

package/dist/functions/array-fns.d.ts

@@ -0,0 +1,2 @@
+import { type ScalarFn } from "./util.js";
+export declare function getArrayFunctions(): Map<string, ScalarFn>;

package/dist/functions/datetime-fns.d.ts

@@ -0,0 +1,26 @@
+import type { EngineCtx } from "../expressions/context.js";
+import { type Interval } from "../types/datetime.js";
+import { type Numeric } from "../types/numeric.js";
+import { type TypedValue } from "../types/value.js";
+/**
+ * EXTRACT / date_part. `asNumeric=true` → numeric result (EXTRACT, PG 14+);
+ * false → float8 (date_part).
+ */
+export declare function extractDatePart(ctx: EngineCtx, field0: string, src0: TypedValue, asNumeric: boolean): TypedValue;
+/** ISO 8601 week + iso year for a day number. */
+export declare function isoWeek(days: number): {
+    week: number;
+    year: number;
+};
+export declare function dateTruncDays(field: string, days: number): number;
+export declare function dateTruncMicros(field: string, micros: bigint): bigint;
+export declare function dateTruncInterval(field: string, v: Interval): Interval;
+export declare function makeDateDatum(y: number, m: number, d: number): number;
+export declare function makeTimeDatum(h: number, min: number, sec: number): bigint;
+export declare function justifyHours(v: Interval): Interval;
+export declare function justifyDays(v: Interval): Interval;
+export declare function justifyInterval(v: Interval): Interval;
+/** age(a, b): symbolic year/month/day difference like PG timestamp_age */
+export declare function timestampAge(a: bigint, b: bigint): Interval;
+export declare function numericSecondsToMicros(n: Numeric): bigint;
+export declare function parseNumericArg(text: string): Numeric;

package/dist/functions/datetime-registry.d.ts

@@ -0,0 +1,2 @@
+import { type ScalarFn } from "./util.js";
+export declare function getDatetimeFunctions(): Map<string, ScalarFn>;

package/dist/functions/json-fns.d.ts

@@ -0,0 +1,7 @@
+import type { EngineCtx } from "../expressions/context.js";
+import { type JsonbValue } from "../types/jsonb.js";
+import { type Datum, type TypeId } from "../types/value.js";
+import { type ScalarFn } from "./util.js";
+/** Convert an engine Datum to a JsonbValue tree (to_jsonb / jsonb_build_*). */
+export declare function datumToJsonb(ctx: EngineCtx, t: TypeId, v: Datum): JsonbValue;
+export declare function getJsonFunctions(): Map<string, ScalarFn>;

package/dist/functions/math-fns.d.ts

@@ -0,0 +1,2 @@
+import { type ScalarFn } from "./util.js";
+export declare function getMathFunctions(): Map<string, ScalarFn>;

package/dist/functions/misc-fns.d.ts

@@ -0,0 +1,8 @@
+import type { EngineCtx } from "../expressions/context.js";
+import type { SequenceData } from "../storage/database-state.js";
+import { type ScalarFn } from "./util.js";
+export declare const PG_VERSION_TEXT = "PostgreSQL 18.3 (postgres-mem) on TypeScript, in-memory engine";
+export declare const PG_SERVER_VERSION = "18.3";
+export declare const PG_SERVER_VERSION_NUM = "180003";
+export declare function sequenceNextval(ctx: EngineCtx, seq: SequenceData): bigint;
+export declare function getMiscFunctions(): Map<string, ScalarFn>;

package/dist/functions/scalar.d.ts

@@ -0,0 +1,10 @@
+import type { EngineCtx } from "../expressions/context.js";
+import type { TypedValue } from "../types/value.js";
+import type { ScalarFn } from "./util.js";
+/**
+ * All engine scalar builtins keyed by lowercase name. Built lazily once;
+ * the inventory gate walks this map against the oracle's pg_proc.
+ */
+export declare function getScalarFunctions(): Map<string, ScalarFn>;
+export declare function hasScalarFunction(name: string): boolean;
+export declare function callScalarFunction(ctx: EngineCtx, name: string, args: TypedValue[]): TypedValue;

package/dist/functions/srf.d.ts

@@ -0,0 +1,12 @@
+import type { EngineCtx } from "../expressions/context.js";
+import { type Datum, type TypedValue, type TypeId } from "../types/value.js";
+export interface SrfResult {
+    columns: Array<{
+        name: string;
+        type: TypeId;
+    }>;
+    rows: Datum[][];
+}
+export type SrfFn = (ctx: EngineCtx, args: TypedValue[], alias: string) => SrfResult;
+export declare function getSrfFunctions(): Map<string, SrfFn>;
+export declare function isSrfName(name: string): boolean;

package/dist/functions/string-fns.d.ts

@@ -0,0 +1,4 @@
+import { type ScalarFn } from "./util.js";
+/** PG substr semantics: 1-based, negative start shifts window. */
+export declare function substrImpl(s: string, start: number, len?: number): string;
+export declare function getStringFunctions(): Map<string, ScalarFn>;

package/dist/functions/tsearch-fns.d.ts

@@ -0,0 +1,2 @@
+import { type ScalarFn } from "./util.js";
+export declare function getTsearchFunctions(): Map<string, ScalarFn>;

package/dist/functions/util.d.ts

@@ -0,0 +1,14 @@
+import type { EngineCtx } from "../expressions/context.js";
+import { type Numeric } from "../types/numeric.js";
+import { type Datum, type TypedValue, type TypeId } from "../types/value.js";
+export type ScalarFn = (ctx: EngineCtx, args: TypedValue[]) => TypedValue;
+/** Wrap a function so any NULL argument short-circuits to a NULL result. */
+export declare function strict(resultType: TypeId, fn: ScalarFn): ScalarFn;
+export declare function argText(ctx: EngineCtx, v: TypedValue): string;
+export declare function argInt(ctx: EngineCtx, v: TypedValue): number;
+export declare function argBigInt(ctx: EngineCtx, v: TypedValue): bigint;
+export declare function argFloat(ctx: EngineCtx, v: TypedValue): number;
+export declare function argNumeric(ctx: EngineCtx, v: TypedValue): Numeric;
+export declare function argBool(ctx: EngineCtx, v: TypedValue): boolean;
+export declare function numericAsNumber(v: Datum): number;
+export declare function arityError(name: string, args: TypedValue[]): never;

package/dist/functions/window.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Window function surface. The executor's window module implements the
+ * evaluation; this registry only classifies names so the parser/executor can
+ * route OVER() calls, and the inventory gate can enumerate them.
+ */
+export declare const WINDOW_FUNCTION_NAMES: Set<string>;
+export declare function isWindowFunctionName(name: string): boolean;

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @packageDocumentation
+ * Pure TypeScript in-memory PostgreSQL. Import {@link Database} to get started.
+ *
+ * Deterministic by default (`random()` seed `1`, `now()` = `2000-01-01T00:00:00.000Z`).
+ * Pass `{ random: "os" }` / `{ now: "system" }` for PostgreSQL-like entropy and wall clock.
+ * Zero WASM, native bindings, or filesystem.
+ *
+ * Advanced / internal helpers live under `@crvouga/postgres-mem/unstable` and are
+ * exempt from semver.
+ *
+ * @example
+ * ```ts
+ * import { Database } from "@crvouga/postgres-mem";
+ *
+ * const db = new Database();
+ * db.exec("CREATE TABLE t (id serial PRIMARY KEY, name text)");
+ * db.prepare("INSERT INTO t (name) VALUES ($1)").run("Ada");
+ * const rows = db.query<{ id: number; name: string }>("SELECT * FROM t");
+ * ```
+ *
+ * @module
+ */
+import "./serialization/codec.js";
+export type { BindValue, JsValue, QueryRow } from "./api/bind.js";
+export { Database, type DatabaseOptions } from "./api/database.js";
+export { type ResultSet, type RunResult, Statement } from "./api/statement.js";
+export { type ErrorCategory, PostgresError } from "./errors/error.js";