@crvouga/mockingbird-service-postgres 0.1.0

package/dist/transactions/manager.d.ts

@@ -0,0 +1,25 @@
+import type { DatabaseState } from "../storage/database-state.js";
+/**
+ * Single-session transaction manager with copy-on-write snapshots: BEGIN /
+ * SAVEPOINT freeze shared catalog objects and capture a shallow clone; writes
+ * copy-on-write via ensureWritableTable. ROLLBACK restores the snapshot.
+ */
+export declare class TransactionManager {
+    private readonly state;
+    private base;
+    private savepoints;
+    private freezeDepth;
+    constructor(state: DatabaseState);
+    get inTransaction(): boolean;
+    private takeSnapshot;
+    private restore;
+    private thawOnce;
+    begin(): void;
+    commit(): void;
+    rollback(): void;
+    savepoint(name: string): void;
+    releaseSavepoint(name: string): void;
+    rollbackToSavepoint(name: string): void;
+    private findSavepoint;
+    reset(): void;
+}

package/dist/tsearch/stem.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Porter2 (Snowball English) stemmer — the algorithm behind PostgreSQL's
+ * `english` text search dictionary.
+ */
+export declare function stemEnglish(input: string): string;

package/dist/tsearch/tsearch.d.ts

@@ -0,0 +1,59 @@
+export interface Lexeme {
+    word: string;
+    positions: Array<{
+        pos: number;
+        weight: string;
+    }>;
+}
+/** Build canonical tsvector text: lexemes sorted, with positions. */
+export declare function toTsvector(config: string, text: string): string;
+/** Parse tsvector text (typinput): `'a':1,2 'b':3A b` */
+export declare function parseTsvector(text: string): string;
+/** tsvector || tsvector: shift right-side positions by the left's max position, merge lexemes. */
+export declare function tsvectorConcat(a: string, b: string): string;
+export declare function tsvectorLexemes(vec: string): Lexeme[];
+export type TsQueryNode = {
+    kind: "lexeme";
+    word: string;
+    prefix: boolean;
+    weights: string | null;
+} | {
+    kind: "and";
+    left: TsQueryNode;
+    right: TsQueryNode;
+} | {
+    kind: "or";
+    left: TsQueryNode;
+    right: TsQueryNode;
+} | {
+    kind: "not";
+    operand: TsQueryNode;
+} | {
+    kind: "phrase";
+    left: TsQueryNode;
+    right: TsQueryNode;
+    distance: number;
+};
+export declare function toTsquery(config: string, text: string): string;
+export declare function plaintoTsquery(config: string, text: string): string;
+export declare function phrasetoTsquery(config: string, text: string): string;
+export declare function websearchToTsquery(_config: string, _text: string): string;
+export declare function tsqueryText(node: TsQueryNode | null): string;
+export declare function parseTsqueryText(text: string): TsQueryNode | null;
+/** tsquery || tsquery / tsquery && tsquery */
+export declare function tsqueryCombine(op: "and" | "or", a: string, b: string): string;
+/**
+ * ts_headline (minimal): wraps query-matching words of the document in
+ * StartSel/StopSel. Fragment selection (MaxWords/MinWords windows) is not
+ * implemented — short documents match PG output exactly.
+ */
+export declare function tsHeadline(config: string, document: string, query: string, options?: string): string;
+/** !! tsquery */
+export declare function tsqueryNegate(a: string): string;
+export declare function tsvectorMatches(vec: string, query: string): boolean;
+export declare const DEFAULT_RANK_WEIGHTS: number[];
+/** calc_rank + normalization flags (RANK_NORM_*). */
+export declare function tsRank(vec: string, query: string, weights?: number[], method?: number): number;
+export declare function tsvectorLength(vec: string): number;
+export declare function tsvectorStrip(vec: string): string;
+export declare function tsvectorSetweight(vec: string, weight: string): string;

package/dist/types/cast.d.ts

@@ -0,0 +1,26 @@
+import { unsupported } from "../errors/error.js";
+import { type Datum, type InputCtx, type OutputCtx, type TypedValue, type TypeId, type TypeMod } from "./value.js";
+export interface CastEnv extends OutputCtx, InputCtx {
+    enumLabels(enumType: TypeId): string[] | null;
+}
+export declare const UTC_CAST_ENV: CastEnv;
+export declare function isTextType(t: TypeId): boolean;
+export declare function isNumericType(t: TypeId): boolean;
+export declare function isDatetimeType(t: TypeId): boolean;
+/** implicit-cast reachability (subset of pg_cast castcontext = 'i') */
+export declare function canImplicitCast(from: TypeId, to: TypeId): boolean;
+export declare function canAssignCast(from: TypeId, to: TypeId): boolean;
+export interface CastOptions {
+    explicit?: boolean;
+    mod?: TypeMod | null;
+    /** true for INSERT/UPDATE assignment (allows assignment casts + typmod coercion with truncation errors) */
+    assignment?: boolean;
+}
+/** Cast a typed value to `target`. */
+export declare function castTo(env: CastEnv, value: TypedValue, target: TypeId, opts?: CastOptions): TypedValue;
+export declare function numericFamilyCast(from: TypeId, to: TypeId, v: Datum): Datum;
+/** Apply typmod (varchar(n) truncation checks, numeric(p,s), bpchar padding, time precision). */
+export declare function applyTypmod(_env: CastEnv, t: TypeId, v: Datum, opts: CastOptions): Datum;
+/** unify two types for comparison/set operations (simplified union type resolution) */
+export declare function unifyTypes(a: TypeId, b: TypeId): TypeId | null;
+export { unsupported };

package/dist/types/compare.d.ts

@@ -0,0 +1,18 @@
+import { type Datum, type TypeId } from "./value.js";
+/**
+ * Total order for non-null datums of the same type. Text uses C-locale
+ * (code point) ordering — the engine's pinned collation.
+ *
+ * Enum ordering needs label positions; callers pass `enumOrder`.
+ */
+export interface CompareCtx {
+    enumOrder?(enumType: TypeId, label: string): number;
+}
+export declare const DEFAULT_COMPARE_CTX: CompareCtx;
+export declare function datumCompare(t: TypeId, a: Datum, b: Datum, ctx?: CompareCtx): number;
+export declare function datumEquals(t: TypeId, a: Datum, b: Datum, ctx?: CompareCtx): boolean;
+/**
+ * Canonical grouping/uniqueness key. Equal values (2.50 = 2.5, +0 = -0)
+ * must map to the same key.
+ */
+export declare function datumKey(t: TypeId, v: Datum): string;

package/dist/types/datetime.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Internal representations (mirroring PostgreSQL):
+ * - date: integer days since 2000-01-01 (PG epoch); ±Infinity as special
+ * - time: bigint microseconds since midnight (0 .. 86_400_000_000 inclusive)
+ * - timestamp / timestamptz: bigint microseconds since 2000-01-01 00:00:00 (UTC for tz)
+ * - interval: { months, days, micros }
+ */
+export declare const PG_EPOCH_JDATE = 2451545;
+export declare const UNIX_EPOCH_MICROS_FROM_PG = -946684800000000n;
+export declare const DATE_POS_INF = 2147483647;
+export declare const DATE_NEG_INF = -2147483648;
+export declare const TS_POS_INF = 9223372036854775807n;
+export declare const TS_NEG_INF = -9223372036854775808n;
+export interface Interval {
+    readonly kind: "interval";
+    readonly months: number;
+    readonly days: number;
+    readonly micros: bigint;
+}
+export declare function makeInterval(months: number, days: number, micros: bigint): Interval;
+export declare function isInterval(v: unknown): v is Interval;
+export declare const USECS_PER_DAY = 86400000000n;
+export declare const USECS_PER_HOUR = 3600000000n;
+export declare const USECS_PER_MIN = 60000000n;
+export declare const USECS_PER_SEC = 1000000n;
+export declare function civilToDays(y: number, m: number, d: number): number;
+export declare function daysToCivil(days: number): {
+    y: number;
+    m: number;
+    d: number;
+};
+export declare function isLeapYear(y: number): boolean;
+export declare function daysInMonth(y: number, m: number): number;
+export declare function isValidCivil(y: number, m: number, d: number): boolean;
+/** day of week, 0=Sunday (2000-01-01 was a Saturday = 6) */
+export declare function dayOfWeek(days: number): number;
+/** Parse a date string -> days since 2000-01-01. DateStyle ISO, MDY. */
+export declare function parseDate(text: string): number;
+/** Parse time -> micros since midnight. */
+export declare function parseTime(text: string): bigint;
+/** Parse timestamp (no tz interpretation) -> PG micros. */
+export declare function parseTimestamp(text: string): bigint;
+/**
+ * Parse timestamptz -> UTC micros. `sessionOffsetSec` applies when the input
+ * has no explicit zone (session TimeZone; we default to UTC).
+ */
+export declare function parseTimestampTz(text: string, zoneOffsetForNaive: (naiveMicros: bigint) => number): bigint;
+export declare function formatDate(days: number): string;
+export declare function formatTimeOfDay(micros: bigint): string;
+/** floor-divide micros into (days, timeOfDay) */
+export declare function splitTs(micros: bigint): {
+    days: number;
+    tod: bigint;
+};
+export declare function formatTimestamp(micros: bigint): string;
+/** Format a UTC timestamptz in a fixed zone offset (seconds east of UTC). */
+export declare function formatTimestampTz(micros: bigint, offsetSec: number): string;
+export declare function parseInterval(text: string): Interval;
+/** Render interval in DateStyle 'postgres' (the default). */
+export declare function formatInterval(v: Interval): string;
+export declare function intervalCmp(a: Interval, b: Interval): number;
+export declare function intervalTotalMicros(v: Interval): bigint;
+export declare function intervalAdd(a: Interval, b: Interval): Interval;
+export declare function intervalNeg(a: Interval): Interval;
+export declare function intervalJustifyHours(v: Interval): Interval;
+export declare function intervalJustifyDays(v: Interval): Interval;
+/** date + interval => timestamp micros arithmetic (add months honoring month-end clamping) */
+export declare function timestampAddInterval(ts: bigint, iv: Interval): bigint;

package/dist/types/jsonb.d.ts

@@ -0,0 +1,47 @@
+import { type Numeric } from "./numeric.js";
+/**
+ * jsonb value tree. Numbers are kept as `numeric` (PG stores jsonb numbers
+ * as numeric — `1.50::jsonb` keeps its scale). Object keys are unique;
+ * output order is (length, byte order), matching PG jsonb.
+ */
+export type JsonbValue = {
+    j: "null";
+} | {
+    j: "bool";
+    v: boolean;
+} | {
+    j: "num";
+    v: Numeric;
+} | {
+    j: "str";
+    v: string;
+} | {
+    j: "arr";
+    v: JsonbValue[];
+} | {
+    j: "obj";
+    v: Map<string, JsonbValue>;
+};
+export declare const JSONB_NULL: JsonbValue;
+export declare function jsonbBool(v: boolean): JsonbValue;
+export declare function jsonbNum(v: Numeric): JsonbValue;
+export declare function jsonbStr(v: string): JsonbValue;
+export declare function jsonbArr(v: JsonbValue[]): JsonbValue;
+export declare function jsonbObj(entries: Iterable<[string, JsonbValue]>): JsonbValue;
+export declare function parseJsonText(text: string): JsonbValue;
+/** Validate json text without canonicalizing (for `json` type input). */
+export declare function validateJsonText(text: string): void;
+/** jsonb key sort: length first, then byte order (PG lexCompareJsonbStringValue). */
+export declare function jsonbKeyCompare(a: string, b: string): number;
+/** Render jsonb in PG's canonical text form: `{"a": 1, "b": [1, 2]}` */
+export declare function jsonbText(v: JsonbValue): string;
+/** Render as compact json text with insertion order (row_to_json / to_json / composite_to_json). */
+export declare function jsonbCompactText(v: JsonbValue): string;
+/** Structural equality (jsonb = jsonb). */
+export declare function jsonbEquals(a: JsonbValue, b: JsonbValue): boolean;
+/** Total order over jsonb (matches jsonb btree comparison semantics). */
+export declare function jsonbCompare(a: JsonbValue, b: JsonbValue): number;
+/** jsonb containment (@>). */
+export declare function jsonbContains(a: JsonbValue, b: JsonbValue, opts?: {
+    allowScalarInArray?: boolean;
+}): boolean;

package/dist/types/jsonpath.d.ts

@@ -0,0 +1,16 @@
+import type { JsonbValue } from "./jsonb.js";
+type PathStep = {
+    kind: "member";
+    name: string;
+} | {
+    kind: "index";
+    index: number;
+};
+/** Parse a SQL/JSON path subset: `$`, `.key`, `."key"`, `[n]`. */
+export declare function parseJsonpath(text: string): PathStep[];
+/**
+ * First match of a jsonpath against a jsonb document.
+ * Missing path → SQL NULL (`null` return). JSON null is `{ j: "null" }`.
+ */
+export declare function jsonpathQueryFirst(doc: JsonbValue, pathText: string): JsonbValue | null;
+export {};

package/dist/types/numeric.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Arbitrary-precision decimal mirroring PostgreSQL's `numeric`.
+ *
+ * Value = (nan/inf special) or coefficient * 10^-dscale where `coef` is a
+ * signed bigint and `dscale` (display scale) is the number of digits after
+ * the decimal point. Display scale is significant: `2.50` renders as "2.50".
+ */
+export interface Numeric {
+    readonly kind: "numeric";
+    /** signed coefficient; value = coef * 10^-dscale */
+    readonly coef: bigint;
+    /** display scale (digits after decimal point), >= 0 */
+    readonly dscale: number;
+    readonly special: "nan" | "inf" | "-inf" | null;
+}
+export declare function makeNumeric(coef: bigint, dscale: number): Numeric;
+export declare const NUMERIC_NAN: Numeric;
+export declare const NUMERIC_PINF: Numeric;
+export declare const NUMERIC_NINF: Numeric;
+export declare function isNumeric(v: unknown): v is Numeric;
+export declare function numericFromBigInt(v: bigint): Numeric;
+export declare function numericFromNumber(v: number): Numeric;
+/** Parse text into numeric. Throws 22P02 on bad syntax (like numeric_in). */
+export declare function parseNumeric(text: string): Numeric;
+export declare function numericRescale(v: Numeric, dscale: number): Numeric;
+export declare function numericText(v: Numeric): string;
+export declare function numericIsZero(v: Numeric): boolean;
+export declare function numericSign(v: Numeric): number;
+/** Compare (NaN sorts greater than everything, like PG). Returns -1|0|1. */
+export declare function numericCmp(a: Numeric, b: Numeric): number;
+export declare function numericAdd(a: Numeric, b: Numeric): Numeric;
+export declare function numericNeg(a: Numeric): Numeric;
+export declare function numericSub(a: Numeric, b: Numeric): Numeric;
+export declare function numericMul(a: Numeric, b: Numeric): Numeric;
+/** Result scale for division, mirroring numeric.c select_div_scale. */
+export declare function selectDivScale(a: Numeric, b: Numeric): number;
+/** Divide with explicit result scale, rounding half away from zero. */
+export declare function numericDivScaled(a: Numeric, b: Numeric, rscale: number): Numeric;
+export declare function numericDiv(a: Numeric, b: Numeric): Numeric;
+/** Truncated integer division (div(a,b) function semantics). */
+export declare function numericDivTrunc(a: Numeric, b: Numeric): Numeric;
+/** Modulo like numeric_mod: result has scale max(s1, s2), sign of dividend. */
+export declare function numericMod(a: Numeric, b: Numeric): Numeric;
+export declare function numericAbs(a: Numeric): Numeric;
+/** round(v, s): round half away from zero; result dscale = max(s, 0). */
+export declare function numericRound(a: Numeric, s: number): Numeric;
+/** trunc(v, s): truncate toward zero. */
+export declare function numericTrunc(a: Numeric, s: number): Numeric;
+export declare function numericFloor(a: Numeric): Numeric;
+export declare function numericCeil(a: Numeric): Numeric;
+export declare function numericToNumber(a: Numeric): number;
+/** Exact bigint if integral after rounding to scale 0 (half away from zero). */
+export declare function numericToBigInt(a: Numeric): bigint;
+/** sqrt via integer Newton iteration at extended scale. */
+export declare function numericSqrt(a: Numeric): Numeric;
+/** power for numeric with numeric result: ports PG's power_var/power_var_int in fixed point. */
+export declare function numericPower(a: Numeric, b: Numeric): Numeric;
+/** exp(numeric) in fixed point with PG's exp_var display-scale rule. */
+export declare function numericExp(a: Numeric): Numeric;
+/** ln(numeric) in fixed point with PG's numeric_ln display-scale rule. */
+export declare function numericLn(a: Numeric): Numeric;
+/** log(base, x) = ln(x)/ln(base) in fixed point with PG's log_var scale rule. */
+export declare function numericLogBase(base: Numeric, x: Numeric): Numeric;
+/** log10(numeric) in fixed point. */
+export declare function numericLog10(a: Numeric): Numeric;
+/** Apply numeric(precision, scale) typmod constraint. */
+export declare function applyNumericTypmod(v: Numeric, precision: number, scale: number): Numeric;
+/** Strip trailing fractional zeros (used by jsonb number canonicalization is NOT this; PG keeps scale). */
+export declare function numericStripTrailingZeros(v: Numeric): Numeric;

package/dist/types/range.d.ts

@@ -0,0 +1,17 @@
+/** Canonical int4range datum (PG range type). */
+export interface Int4Range {
+    readonly kind: "int4range";
+    readonly empty: boolean;
+    readonly lower: number | null;
+    readonly upper: number | null;
+    readonly lowerInc: boolean;
+    readonly upperInc: boolean;
+}
+export declare function emptyInt4Range(): Int4Range;
+export declare function makeInt4Range(lower: number | null, upper: number | null, lowerInc: boolean, upperInc: boolean): Int4Range;
+/** typinput for int4range: `[1,10)`, `empty`, `(,)` unbounded. */
+export declare function parseInt4RangeText(text: string): Int4Range;
+export declare function int4RangeText(r: Int4Range): string;
+export declare function isInt4Range(v: unknown): v is Int4Range;
+export declare function int4RangeContains(outer: Int4Range, inner: Int4Range | number): boolean;
+export declare function int4RangeOverlaps(a: Int4Range, b: Int4Range): boolean;

package/dist/types/resolve.d.ts

@@ -0,0 +1,15 @@
+import type { TypeName } from "../ast/nodes.js";
+import type { DatabaseState } from "../storage/database-state.js";
+import type { ColumnType } from "./value.js";
+export interface ResolvedType {
+    readonly column: ColumnType;
+    /** "schema.name" when the name resolved to a domain */
+    readonly domain: string | null;
+    /** serial pseudo-types need sequence creation in DDL */
+    readonly serial: "int2" | "int4" | "int8" | null;
+}
+/**
+ * Resolve a parsed type name against the catalog: builtin alias, enum, or
+ * domain (searched along search_path). Throws 42704 when nothing matches.
+ */
+export declare function resolveTypeName(state: DatabaseState, tn: TypeName): ResolvedType;

package/dist/types/timezone.d.ts

@@ -0,0 +1,9 @@
+/** Offset (seconds east of UTC) of `zone` at the given UTC instant. */
+export declare function zoneOffsetAtUtc(zone: string, utcMicros: bigint): number;
+/**
+ * Offset for interpreting a naive local timestamp in `zone`
+ * (two-pass refinement over {@link zoneOffsetAtUtc}).
+ */
+export declare function zoneOffsetForNaive(zone: string, naiveMicros: bigint): number;
+/** Validate a zone string (throws when unrecognized). */
+export declare function validateZone(zone: string): void;

package/dist/types/value.d.ts

@@ -0,0 +1,99 @@
+import { type Interval } from "./datetime.js";
+import { type JsonbValue } from "./jsonb.js";
+import { type Numeric } from "./numeric.js";
+/**
+ * Canonical type ids are lowercase PG internal names: "int4", "text",
+ * "timestamptz", … Arrays are `elem + "[]"`. Enums are `"enum:" + qualified
+ * name`. "unknown" is the type of untyped string literals; "null" never
+ * appears (null datums carry whatever type context provides).
+ */
+export type TypeId = string;
+export type Datum = null | boolean | number | bigint | string | Uint8Array | Numeric | Interval | PgArray | PgRecord | JsonbWrap;
+export interface PgArray {
+    readonly kind: "pgarray";
+    readonly elem: TypeId;
+    /** dimension lengths, outermost first; empty array => [] */
+    readonly dims: number[];
+    /** lower bounds per dimension (default 1) */
+    readonly lbs: number[];
+    /** row-major flattened items */
+    readonly items: Datum[];
+}
+export interface PgRecord {
+    readonly kind: "pgrecord";
+    readonly types: TypeId[];
+    readonly values: Datum[];
+    readonly names?: string[];
+}
+/** jsonb datums are wrapped so `typeof` dispatch stays unambiguous. */
+export interface JsonbWrap {
+    readonly kind: "jsonb";
+    readonly value: JsonbValue;
+}
+export declare function wrapJsonb(value: JsonbValue): JsonbWrap;
+export declare function isJsonbWrap(v: unknown): v is JsonbWrap;
+export declare function isPgArray(v: unknown): v is PgArray;
+export declare function isPgRecord(v: unknown): v is PgRecord;
+export declare function makeArray(elem: TypeId, items: Datum[], dims?: number[], lbs?: number[]): PgArray;
+export interface TypedValue {
+    readonly t: TypeId;
+    readonly v: Datum;
+}
+export declare function tv(t: TypeId, v: Datum): TypedValue;
+export declare const UNKNOWN = "unknown";
+export interface TypeMod {
+    /** varchar(n)/bpchar(n): max chars; numeric: precision; time/timestamp: fractional digits */
+    readonly a?: number;
+    /** numeric scale */
+    readonly b?: number;
+}
+export interface ColumnType {
+    readonly id: TypeId;
+    readonly mod: TypeMod | null;
+}
+export declare function normalizeTypeName(name: string): TypeId | null;
+export declare function isArrayType(t: TypeId): boolean;
+export declare function arrayElemType(t: TypeId): TypeId;
+export declare function arrayTypeOf(elem: TypeId): TypeId;
+export declare function isEnumType(t: TypeId): boolean;
+export declare function enumTypeName(t: TypeId): string;
+/** SQL-facing type name (format_type / pg_typeof style). */
+export declare function typeDisplayName(t: TypeId): string;
+export declare const TYPE_OIDS: Record<string, number>;
+export declare function typeOid(t: TypeId): number;
+export declare function float8Text(v: number): string;
+export declare function float4Text(v: number): string;
+export declare function parseFloatText(text: string, type: "float4" | "float8"): number;
+export declare const INT2_MIN = -32768;
+export declare const INT2_MAX = 32767;
+export declare const INT4_MIN = -2147483648;
+export declare const INT4_MAX = 2147483647;
+export declare const INT8_MIN = -9223372036854775808n;
+export declare const INT8_MAX = 9223372036854775807n;
+export declare function checkInt2(v: number): number;
+export declare function checkInt4(v: number): number;
+export declare function checkInt8(v: bigint): bigint;
+export declare function parseBoolText(text: string): boolean;
+export declare function parseByteaText(text: string): Uint8Array;
+export declare function byteaText(v: Uint8Array): string;
+export declare function parseUuidText(text: string): string;
+export declare function parseMoneyText(text: string): bigint;
+export declare function moneyText(cents: bigint): string;
+export interface OutputCtx {
+    /** offset seconds east of UTC for rendering timestamptz at given UTC micros */
+    zoneOffsetAt(utcMicros: bigint): number;
+}
+export declare const UTC_OUTPUT: OutputCtx;
+export declare function arrayText(arr: PgArray, ctx: OutputCtx): string;
+export declare function recordText(rec: PgRecord, ctx: OutputCtx): string;
+/** Render a non-null datum of type `t` to PG wire text. */
+export declare function datumText(t: TypeId, v: Datum, ctx: OutputCtx): string;
+export interface InputCtx {
+    /** session zone offset lookup for naive timestamptz input */
+    zoneOffsetForNaive(naiveMicros: bigint): number;
+    /** enum label validation: returns true when label is valid for the enum type */
+    enumHasLabel?(enumType: TypeId, label: string): boolean;
+}
+export declare const UTC_INPUT: InputCtx;
+/** Parse PG wire text into a datum of type `t` (typinput). */
+export declare function datumFromText(t: TypeId, text: string, ctx: InputCtx): Datum;

package/dist/unstable.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @packageDocumentation
+ * Unstable internals of `@crvouga/mockingbird-service-postgres`. Everything exported here is
+ * exempt from semver — pin an exact version if you import from this module.
+ *
+ * @module
+ */
+export { executeStatement, makeEnv } from "./executor/execute.js";
+export { EngineCtx } from "./expressions/context.js";
+export { tokenize } from "./lexer/tokenize.js";
+export { parse, parseSingle } from "./parser/index.js";
+export { type Clock, DEFAULT_NOW, fixedClock, systemClock } from "./runtime/clock.js";
+export { deriveSeed, OsEntropy, Prng } from "./runtime/prng.js";
+export { DatabaseState } from "./storage/database-state.js";
+export { type Datum, datumText, type TypedValue, type TypeId } from "./types/value.js";