@minnowdb/core 0.7.10 → 0.9.0

package/dist/engine/cancellation.d.ts

@@ -1,2 +0,0 @@
-/** One compact check shared by every bounded query-execution path. */
-export declare function throwIfAborted(signal: AbortSignal | undefined): void;

package/dist/engine/defaults.d.ts

@@ -1,29 +0,0 @@
-/**
- * Write-time default filling. Only an omitted property or SQL `DEFAULT` means "generate";
- * explicit NULL passes through untouched. Literal and SQL-expression defaults are filled before
- * validation. Auto-increment slots stay null until the write path atomically reserves a range.
- */
-import type { RowIdRange, TableColumnRecord, TableRecord } from "../storage/types.js";
-import type { BatchValue, ColumnarBatch } from "./batch.js";
-/** The deferred part of a fill: slots that need storage-reserved auto-increment values. */
-export interface AutoIncrementFill {
-    readonly column: TableColumnRecord;
-    /** Row indexes whose value must come from the reserved range, in row order. */
-    readonly missingIndexes: readonly number[];
-    /** One past the largest explicit value in the batch, so generated keys never collide with it. */
-    readonly atLeast: bigint;
-}
-export interface FilledBatch {
-    readonly batch: ColumnarBatch;
-    /** Full written vectors, input row order, for columns where at least one slot was generated. */
-    readonly generated: Map<string, BatchValue[]>;
-    /** Present whenever the table has an auto-increment column, even if every value is explicit —
-     * the counter still bumps past the explicit maximum in the same atomic step. */
-    readonly autoIncrement?: AutoIncrementFill;
-}
-export declare function fillColumnDefaults(table: TableRecord, input: ColumnarBatch, evaluateExpression: (sql: string, rowIndex: number) => Promise<BatchValue>, knownRowCount?: number): Promise<FilledBatch>;
-/**
- * Writes the reserved range into the batch's null slots. The vector is the fresh array
- * `fillColumnDefaults` created for this fill, never a caller-owned one.
- */
-export declare function patchAutoIncrementValues(input: ColumnarBatch, fill: AutoIncrementFill, range: RowIdRange): void;

package/dist/engine/group-index.d.ts

@@ -1,33 +0,0 @@
-import { QueryMemoryContext } from "./memory.js";
-export type GroupIndexKey = null | boolean | number | string;
-/** Byte-addressable, insertion-ordered grouping index with fully reserved typed storage. */
-export declare class ByteGroupIndex<T> {
-    #private;
-    constructor(memory: QueryMemoryContext);
-    get size(): number;
-    get(keys: readonly GroupIndexKey[]): T | undefined;
-    getEmpty(): T | undefined;
-    getOne(key: GroupIndexKey): T | undefined;
-    set(keys: readonly GroupIndexKey[], value: T): void;
-    getOrInsert(keys: readonly GroupIndexKey[], create: () => T): T;
-    getOrInsertOne(key: GroupIndexKey, create: () => T): T;
-    setEmpty(value: T): void;
-    setOne(key: GroupIndexKey, value: T): void;
-    values(): readonly T[];
-}
-/**
- * Encodes one scalar key into the shared scratch arena and returns its byte length. Exported for
- * the join index, which shares the arena and byte layout: both consume the encoding synchronously
- * before any other key operation can run, so a single arena serves every index. NaN is the one
- * excluded number — group callers canonicalize non-finite to null, join callers skip NaN keys —
- * while ±Infinity encodes as an ordinary float64 so computed join keys can overflow and still match.
- */
-export declare function encodeSingleScalarKey(key: GroupIndexKey): number;
-/** FNV-1a over the scratch arena's first `length` bytes. Exported for the join index. */
-export declare function hashScratch(length: number): number;
-/** Matches `arena[offset..offset+length)` against the scratch arena. Exported for the join index. */
-export declare function equalsScratch(arena: Uint8Array, offset: number, length: number): boolean;
-/** Copies the scratch arena's first `length` bytes into owned storage. Exported for the join index. */
-export declare function copyScratchKey(length: number): Uint8Array;
-export declare function safeDouble(value: number, label: string): number;
-export declare function safeProduct(left: number, right: number, label: string): number;

package/dist/engine/join-index.d.ts

@@ -1,10 +0,0 @@
-import { QueryMemoryContext } from "./memory.js";
-/** Collision-checked scalar-key hash index with typed duplicate row chains. */
-export declare class ByteJoinIndex {
-    #private;
-    constructor(memory: QueryMemoryContext, rowCapacity: number);
-    get unique(): boolean;
-    add(value: unknown, row: number): void;
-    firstRow(value: unknown): number;
-    nextRow(row: number): number;
-}

package/dist/engine/live-equal.d.ts

@@ -1,7 +0,0 @@
-/**
- * Structural equality over live result values: dates by instant, arrays by element, objects by
- * own keys in insertion order. Shared by the typed live store's exact suppression and the keyed
- * live window's diffing; internal on purpose — live-api re-exports its modules wholesale, and
- * this helper is not part of the live API.
- */
-export declare function sameLiveValue(left: unknown, right: unknown): boolean;

package/dist/engine/point-read.d.ts

@@ -1,59 +0,0 @@
-import type { CompiledQuery, QueryValue } from "../plan/model.js";
-type PointReadValue = boolean | number | string | Date;
-export interface PointReadEquality {
-    column: string;
-    value: PointReadValue;
-}
-export interface PointReadShape {
-    table: string;
-    /** Conjunctive equalities, in predicate order; may repeat a column. */
-    equalities: PointReadEquality[];
-    /** Plain column projections, in select order. */
-    /** Projected columns, or "*" for a bare wildcard the catalog expands at execution. */
-    select: Array<{
-        column: string;
-        alias: string;
-    }> | "*";
-}
-/** The statement-shaped half of the analysis, computed once per cached plan. */
-interface PointReadTemplate {
-    table: string;
-    equalities: Array<{
-        column: string;
-        value: PointReadValue;
-    } | {
-        column: string;
-        parameter: number;
-    }>;
-    /** Projected columns, or "*" for a bare wildcard the catalog expands at execution. */
-    select: Array<{
-        column: string;
-        alias: string;
-    }> | "*";
-}
-/**
- * Test-only escape hatch and counters. Not exported from any public entry point: in-repo
- * differential suites import this module directly to force the ordinary executor and to
- * assert the fast path actually served eligible statements.
- */
-export declare const pointReadTestHooks: {
-    disabled: boolean;
-    attempted: number;
-    served: number;
-};
-/** The template for a cached compiled plan, analyzed once per statement. */
-export declare function cachedPointReadTemplate(plan: CompiledQuery): PointReadTemplate | null;
-/**
- * Substitutes this call's parameters into the statement template. Undefined means a parameter
- * carries a value the fast path cannot compare exactly (NULL, a non-finite number, an invalid
- * Date, or a non-storage value), and the ordinary executor must decide what it means.
- */
-export declare function resolvePointReadShape(template: PointReadTemplate, params: readonly QueryValue[]): PointReadShape | undefined;
-/** Whether the array is non-strictly ascending; memoized per immutable decoded array. */
-export declare function valuesAreAscending(values: Float64Array): boolean;
-/** The [begin, end) run of slots equal to `target` over an ascending array. */
-export declare function equalRunRange(values: Float64Array, target: number): {
-    begin: number;
-    end: number;
-};
-export {};

package/dist/engine/query-cache.d.ts

@@ -1,21 +0,0 @@
-import { type QueryResult } from "./query.js";
-/** Modest per-entry cap so one giant result cannot thrash the shared artifact cache. */
-export declare const RESULT_MEMO_MAX_BYTES: number;
-/** Stable, collision-free memo-key encoding for bound SQL parameters. */
-export declare function queryResultMemoKey(sql: string, params: readonly unknown[]): string;
-/**
- * A memo key for a compiled plan: its JSON with the values JSON cannot tell apart made
- * distinct — a Date from its ISO string, -0 from 0, NaN and the infinities from null — so two
- * plans with the same key are the same query over the same literals.
- */
-export declare function planMemoKey(plan: unknown): string;
-/**
- * Defensive copy because callers own query results and may mutate both rows and Dates. Object
- * spread copies own enumerable properties with define semantics, so a column named `__proto__`
- * stays an own property; only a Date cell needs the explicit define, and only because its
- * value is replaced. This used to define every cell, which made a memo hit on a result of a
- * few thousand rows cost more than re-executing the query.
- */
-export declare function copyQueryResult(result: QueryResult): QueryResult;
-/** Modeled retained payload for one cached query result. */
-export declare function queryResultRetainedBytes(result: QueryResult): number;

package/dist/engine/result-wire.d.ts

@@ -1,70 +0,0 @@
-import type { SqlDomain } from "../storage/types.js";
-import type { QueryResult, QueryRow, QueryValue } from "./query.js";
-/**
- * The shape a query result takes on the worker channel. A result is rows of objects at the
- * public API on both sides, but row objects are the slowest thing structured clone can be
- * handed: every row is a fresh object with its own property names. Pivoted into one array per
- * column — numbers, booleans, and datetimes in typed arrays whose buffers are transferred, and
- * strings as one flat text with offsets — the same 20,000-row result crosses in a fraction of the
- * time, and the receiving side rebuilds the rows column by column in tight loops.
- *
- * Every value round-trips exactly: NaN, -0, and Infinity survive in a Float64Array, datetimes
- * travel as epoch milliseconds (an invalid Date's NaN included), nulls in a typed column live in
- * a byte mask, and a column name like `__proto__` comes back as the own property the engine
- * defined — never as a prototype assignment.
- */
-type WireResultColumn = {
-    kind: "number";
-    values: Float64Array;
-    nulls?: Uint8Array;
-} | {
-    kind: "boolean";
-    values: Uint8Array;
-    nulls?: Uint8Array;
-} | {
-    kind: "datetime";
-    values: Float64Array;
-    nulls?: Uint8Array;
-}
-/**
- * Every string in the column joined into one flat text, with `offsets[i]..offsets[i + 1]`
- * delimiting row i. Structured clone copies one string instead of walking thousands, and the
- * receiver slices rows back out of it — far cheaper on the main thread than an array of
- * separate strings, which is the form the engine's decoded values would otherwise take.
- */
- | {
-    kind: "string";
-    text: string;
-    offsets: Uint32Array;
-    nulls?: Uint8Array;
-}
-/** A column holding more than one type, which SQL allows (`SELECT CASE … END`). */
- | {
-    kind: "mixed";
-    values: QueryValue[];
-}
-/** Every value null; nothing to carry beyond the row count. */
- | {
-    kind: "null";
-};
-export interface WireQueryResult {
-    readonly kind: "columnar-result";
-    readonly columns: string[];
-    readonly columnDomains: Array<SqlDomain | null>;
-    readonly rowCount: number;
-    readonly values: WireResultColumn[];
-}
-export interface EncodedQueryResult {
-    payload: WireQueryResult;
-    /** The typed-array buffers, freshly allocated here, so postMessage may transfer them. */
-    transfer: ArrayBuffer[];
-}
-export declare function encodeQueryResult(result: QueryResult): EncodedQueryResult;
-/**
- * Encodes a bare row array (`run()` returns rows without a column list). Every row of one result
- * carries the same keys in the same order, so the first row names the columns.
- */
-export declare function encodeQueryRows(rows: readonly QueryRow[]): EncodedQueryResult;
-export declare function decodeQueryResult(payload: unknown): QueryResult;
-export declare function isWireQueryResult(value: unknown): value is WireQueryResult;
-export {};

package/dist/engine/sort-keys.d.ts

@@ -1,73 +0,0 @@
-/**
- * Order-by keys prepared for sorting, and the sort that runs over them.
- *
- * Sorting is comparison-bound: a merge over n rows performs O(n log n) of them, so what one
- * comparison costs decides what the sort costs. Reading a value out of a row by name and then
- * dispatching on its type at every step is most of that cost, and all of it is avoidable —
- * the values are known before the sort starts, and a term's type does not vary row to row.
- *
- * Each term is extracted once into its own column. A term whose values are all numbers —
- * which includes every datetime, since extraction unboxes them to epoch milliseconds — or all
- * booleans is stored in a Float64Array beside a null mask. A string term is stored the same
- * way, as the rank of each string among the sorted distinct values: the dictionary a string
- * vector already carries is exactly that set, and comparing two ranks orders the two strings.
- * Only a term that mixes types keeps its values and the generic comparison.
- *
- * With the keys unboxed, the sort itself stops comparing. `sortKeyIndexes` radix-sorts the
- * leading key's float bits, recognizes input that already arrives in order, and only falls back
- * to a comparison merge for the terms it cannot encode. Ties on one term are broken by the
- * next, so what a multi-term sort pays for its later terms is proportional to how many rows tie
- * on the earlier ones.
- */
-interface SortKeyColumn {
-    /**
-     * Ascending comparison with NULL smallest. This is the column's raw comparison, not SQL's
-     * default placement: the sorter applies PostgreSQL's NULLS LAST for ASC and NULLS FIRST for
-     * DESC. Direction and an explicit NULLS FIRST/LAST stay with the caller because a placement is
-     * absolute, while direction negates only the non-null value comparison.
-     *
-     * Specialized when the column is built, so a comparison that runs millions of times is a
-     * closure over one representation rather than a branch on which representation it holds.
-     */
-    readonly compare: (left: number, right: number) => number;
-    readonly isNull: (index: number) => boolean;
-    /**
-     * The unboxed keys, when the column has them: numbers, epoch milliseconds, 0/1 for booleans,
-     * or string ranks. Both arrays are present or neither is. Equal numbers mean equal keys and
-     * their order is the order `compare` reports, so a sort can work on these alone.
-     */
-    readonly numbers: Float64Array | undefined;
-    readonly nulls: Uint8Array | undefined;
-}
-/** One ORDER BY term as the sort sees it: its keys, its direction, and its NULL placement. */
-export interface SortKeyTerm {
-    readonly column: SortKeyColumn;
-    readonly descending: boolean;
-    readonly nulls: "first" | "last" | undefined;
-}
-/**
- * Extracts one term's values into a comparison-ready column. `valueAt` is called once per row,
- * so a caller that reads through a row object or a vector pays that cost once rather than once
- * per comparison. A term that mixes types cannot be unboxed; it is read a second time into the
- * generic column, whose comparison reports the type error the way it always has.
- *
- * Strings are always ranked, whatever their cardinality. Measured at 200k rows, ranking wins by
- * ten times when six strings repeat and still by three times when nearly every string is
- * distinct: the distinct set sorts with the engine's own string sort, the rows then sort as
- * numbers, and neither pays the per-comparison dispatch the generic path does.
- */
-export declare function buildSortKeyColumn(count: number, valueAt: (index: number) => unknown): SortKeyColumn;
-/**
- * A stable sort of `count` rows by the given terms, returned as the permutation of row indexes
- * in sorted order. Equal rows keep their input order, which is what makes ORDER BY
- * deterministic and what lets a bounded top-N decide ties by arrival.
- *
- * Each term is sorted in turn: the first over every row, then each later term only within the
- * runs of rows the earlier terms left tied. A term with unboxed keys is encoded once into
- * 64-bit integers whose unsigned order is the term's order — direction and NULL placement
- * folded in — and large ranges are radix-sorted on those bits while small ones merge. A term
- * without unboxed keys merges under the generic comparison. Both kernels check for input that
- * is already in order before doing anything else, since a scan often arrives sorted.
- */
-export declare function sortKeyIndexes(count: number, terms: readonly SortKeyTerm[]): Uint32Array;
-export {};

package/dist/engine/sql-domains.d.ts

@@ -1,93 +0,0 @@
-import type { SqlDomain } from "../storage/types.js";
-/**
- * Protects an ordinary SQL string that happens to use the internal domain namespace. Physical
- * TEXT remains unchanged on disk; this wrapper is applied at execution boundaries so a user
- * value can never be mistaken for NUMERIC, INTERVAL, enum, or another tagged logical value.
- */
-export declare function protectedSqlTextValue(value: string): string;
-/** Removes only the ordinary-TEXT wrapper, leaving real domain values tagged. */
-export declare function externalSqlTextValue(value: unknown): unknown;
-/** The fractional digits a finite number shows when written as a decimal: 1.25 has 2, 8 has 0. */
-export declare function decimalScaleOfNumber(value: number): number;
-export declare function isExactNumeric(value: unknown): value is string;
-/**
- * PostgreSQL's numeric ROUND and TRUNC at `digits` fractional places, which may be negative to
- * work left of the decimal point (`ROUND(12345.67, -1)` is 12350). ROUND is half away from
- * zero, TRUNC toward zero. The result is canonical; a caller wanting display scale reads it
- * from the inferred column domain.
- */
-export declare function exactNumericRounded(value: string, digits: number, mode: "round" | "trunc"): string;
-/** ABS, FLOOR, CEIL, and SIGN over an exact NUMERIC value, as PostgreSQL's numeric variants. */
-export declare function exactNumericUnary(name: "ABS" | "FLOOR" | "CEIL" | "SIGN", value: string): string;
-export declare function exactNumericValue(value: unknown, precision?: number, scale?: number): string | null;
-/**
- * Tags a SQL numeric constant with its exact digits, as written. Unlike `exactNumericValue`
- * this does not canonicalize: trailing fractional zeros are PostgreSQL display scale, and
- * division selects its result scale from the operands' scales, so a literal's digits are part
- * of its meaning. Scientific notation is the exception — PostgreSQL expands the exponent when
- * it parses the literal, so `1.5e2` is `150` and `1e400` is the full digit string, and the
- * display scale comes from that expansion. The text is still validated and bounded.
- */
-export declare function exactNumericLiteral(text: string): string;
-/**
- * The Float64 this exact numeric value reads back identically from — the nearest float's
- * canonical rendering re-parses to the same decimal value, so `0.1` qualifies while
- * `9007199254740993` does not — or undefined when the trip through a number would visibly
- * round. A value that survives stays an ordinary number so every number-typed path keeps
- * running; only visibly rounded values stay tagged NUMERIC.
- */
-export declare function exactNumericAsNumber(value: string): number | undefined;
-export declare function exactNumericBinary(operator: "+" | "-" | "*" | "/" | "%", left: unknown, right: unknown, minimumQuotientScale?: number, canonicalize?: boolean): string | null | undefined;
-export declare function exactNumericCompare(left: unknown, right: unknown): number | undefined;
-/**
- * Serializes a JSON value while bounding traversal, nesting, and output before concatenation.
- * Canonical mode sorts object names directly in the wire text (including integer-looking names,
- * which JavaScript object enumeration would otherwise silently reorder).
- */
-export declare function boundedJsonText(value: unknown, canonical: boolean, label?: string): string;
-export declare function jsonDomainValue(value: unknown, binary: boolean): string | null;
-/** Returns the JSON document carried by an internal JSON/JSONB scalar, if any. */
-export declare function jsonDomainDocument(value: unknown): string | undefined;
-/**
- * Tags already-constructed JSON without parsing and re-stringifying it. The validation parse
- * rejects malformed documents, while retaining duplicate object names and the constructor's
- * exact member order for embedding in an outer JSON value.
- */
-export declare function preservedJsonDomainValue(document: string, binary?: boolean): string;
-export declare function uuidDomainValue(value: unknown): string | null;
-/** Canonical, zoneless SQL DATE value. No JavaScript time zone participates in validation. */
-export declare function dateDomainValue(value: unknown): string | null;
-export declare function isDateDomainValue(value: unknown): value is string;
-export declare function timeDomainValue(value: unknown): string | null;
-export declare function intervalDomainValue(value: unknown): string | null;
-export declare function arrayDomainValue(values: readonly unknown[]): string;
-export declare function enumDomainCompare(left: unknown, right: unknown): number | undefined;
-export declare function normalizeSqlDomainValue(domain: SqlDomain, value: unknown): string | null;
-export declare function collatedDomainValue(value: unknown, collation: unknown): string | null;
-export declare function collatedDomainCompare(left: unknown, right: unknown): number | undefined;
-/**
- * Renders one result value at the JavaScript boundary using its column's logical domain.
- * A NUMERIC column with a declared scale displays PostgreSQL-style at exactly that scale:
- * the physical encoding is canonical (trailing fractional zeros stripped), so the declared
- * scale is restored by padding — never rounding — and a value carrying more fractional
- * digits than the declaration keeps every digit it has. Every other domain, and every value
- * without one, renders exactly as externalSqlDomainValue.
- */
-export declare function externalSqlDomainColumnValue(value: unknown, domain: SqlDomain | null | undefined): unknown;
-export declare function externalSqlDomainValue(value: unknown): unknown;
-/**
- * SQL `||` over internal string values, shared by both executors and constant folding so the
- * three paths cannot disagree. PostgreSQL resolves `||` to text concatenation only when one
- * side is text: its array and JSONB `||` operators are structural concatenation, which this
- * engine does not implement, and two non-text operands have no `||` operator at all. Refusing
- * those shapes keeps `||` from inventing a text concatenation PostgreSQL does not have —
- * and from ever concatenating internal domain encodings.
- */
-export declare function concatenatedSqlValue(leftValue: unknown, rightValue: unknown): string;
-/**
- * Orders two INTERVAL values the way PostgreSQL's interval comparison does: a month counts as
- * 30 days and a day as 24 hours, so INTERVAL '3 months' equals INTERVAL '90 days' and
- * INTERVAL '2 days' sorts below INTERVAL '10 days'. Undefined unless both are intervals.
- */
-export declare function intervalDomainCompare(left: unknown, right: unknown): number | undefined;
-export declare function isSqlDomainValue(value: unknown): value is string;

package/dist/engine/sql-functions.d.ts

@@ -1,11 +0,0 @@
-export type SimpleScalarResult = "string" | "number" | "boolean" | "datetime" | "date" | "interval" | "argument";
-export interface SimpleScalarFunction {
-    readonly minArgs: number;
-    readonly maxArgs: number;
-    /** The output type; "argument" carries the first argument's type through. */
-    readonly returns: SimpleScalarResult;
-    /** False for functions that read NULL arguments as data (CONCAT) instead of returning NULL. */
-    readonly nullOnNull?: false;
-    readonly evaluate: (values: readonly unknown[]) => unknown;
-}
-export declare const simpleScalarFunctions: ReadonlyMap<string, SimpleScalarFunction>;

package/dist/engine/sql-json.d.ts

@@ -1,40 +0,0 @@
-/**
- * SQL/JSON scalar support (T801 family). Documents may be ordinary JSON text or native JSON/JSONB
- * domain values carried by the string vector representation. Scalar paths take one unambiguous
- * result: `$`, member steps, and array subscripts. JSON_TABLE owns its separate `$`/`$[*]`
- * row-producing subset in the parser.
- */
-interface JsonPathStep {
-    kind: "member" | "index";
-    name: string;
-    index: number;
-}
-export declare function parseJsonPath(path: unknown, caller: string): JsonPathStep[];
-/** Walks one path over a document, reporting whether it selected anything. */
-export declare function jsonAtPath(document: unknown, path: unknown, caller: string): {
-    found: boolean;
-    value?: unknown;
-};
-/**
- * One step of PostgreSQL's `->`/`->>` access. A text key selects an object member; an integer
- * key selects an array element, counting from the end when negative. The behaviour follows
- * PostgreSQL's `json` type: a document of the wrong shape for the key selects nothing (NULL)
- * rather than jsonb's scalar-as-one-element-array reading. Unlike the SQL/JSON functions, whose
- * standard ON ERROR default swallows malformed documents, PostgreSQL's operators only exist on
- * values already parsed as json, so a document that is not JSON is an error here.
- */
-export declare function jsonArrowStep(document: unknown, key: unknown, caller: string): {
-    found: boolean;
-    value?: unknown;
-};
-/** Whether a value is JSON text of the requested shape (T825). */
-export declare function jsonIsValid(document: unknown, kind: string): boolean;
-/**
- * JSON_ARRAY(v, ...) and JSON_OBJECT(k, v, ...) (T811/T812). The omitted null-handling clause is
- * `NULL ON NULL`: SQL NULL becomes a JSON null. `ABSENT ON NULL` is a separate spelling rather
- * than the default. Constructors return JSON text at the JavaScript boundary.
- */
-export declare function jsonConstructor(name: "JSON_ARRAY" | "JSON_OBJECT", values: readonly unknown[]): string;
-/** to_json(x) / to_jsonb(x): one SQL value as a JSON document (a JSON-domain value as itself). */
-export declare function jsonDocumentOf(value: unknown): string;
-export {};

package/dist/engine/sql-semantics.d.ts

@@ -1,66 +0,0 @@
-/**
- * The standard's datetime text — `2026-01-02`, `2026-01-02 03:04:05`, `2026-01-02T03:04:05.250Z`,
- * an optional zone offset — read as an instant. A zoneless spelling is UTC, the reading every
- * datetime in a Minnow database has; `undefined` for text in any other shape.
- */
-export declare function parseSqlTimestampText(text: string): Date | undefined;
-/**
- * PostgreSQL reads an untyped string constant beside a typed value in that value's type:
- * `joined >= '2026-01-01'`, `id = '5'`, `active = 't'`. Catalog-backed plans coerce such literals
- * before execution; this runtime reading covers the schema-less row executor and anything the
- * plan rewrite could not see. Text that does not parse in the other side's type keeps the
- * comparable-types error below, so a genuine mismatch still fails.
- */
-export declare function coercedComparable(text: string, other: unknown): unknown;
-/**
- * Reads an untyped string constant in a primitive column type, the way PostgreSQL types an
- * unknown-typed literal by its context: a timestamp spelling for datetime, a finite number for
- * number, `t`/`true`/`1` and `f`/`false`/`0` for boolean. Text that does not parse is returned
- * unchanged, so the caller's own type check still reports the mismatch.
- */
-export declare function readUntypedText(type: "datetime" | "number" | "boolean" | "string", text: string): unknown;
-/**
- * Applies the untyped-literal reading to a comparison's two operands: a plain string beside a
- * typed value (datetime, DATE, number, boolean) is read in that value's type when it parses.
- * Both executors call this before their own comparisons, so the reading is one decision.
- */
-export declare function coerceComparisonOperands(left: unknown, right: unknown): [unknown, unknown];
-/**
- * Deterministic SQL ordering. Strings use Unicode codepoint order rather than host locale data,
- * and signed zero compares equal because SQL numeric equality does not distinguish it.
- */
-export declare function compareSqlValues(left: unknown, right: unknown): number;
-/** Hot-path string comparison shared by executors without locale-dependent host state. */
-export declare function compareSqlStrings(left: string, right: string): number;
-/** A JSON-safe equality token used by set operations and recursive-CTE deduplication. */
-export declare function encodeSqlEqualityValue(value: unknown): readonly unknown[];
-/**
- * SQLite-compatible ROUND behavior for Minnow's finite number type: precision truncates to an
- * integer and clamps to -30..30, with ties rounded away from zero. A negative precision rounds
- * left of the decimal point as PostgreSQL does: ROUND(1250, -2) is 1300.
- */
-export declare function roundSqlNumber(value: number, precision?: number): number;
-/** A whole-string SQL pattern matcher. Unlike RegExp, test never coerces its input. */
-interface SqlPatternMatcher {
-    test(value: string): boolean;
-}
-/** Compiles SQL LIKE without exposing input to the host regular-expression engine. */
-export declare function compileLikePattern(pattern: string, caseInsensitive?: boolean, escape?: string): SqlPatternMatcher;
-/**
- * PostgreSQL's ~ / ~* / !~ / !~* operators and REGEXP_REPLACE, compiled as JavaScript regular
- * expressions. Advanced regular expressions and JavaScript agree on the everyday syntax; the
- * `n` flag makes `.` and anchors newline-sensitive, `i` is case-insensitive, and `g` replaces
- * every match. Patterns are bounded like every other SQL pattern.
- */
-export declare function compileRegexPattern(pattern: string, flags?: string): RegExp;
-/** PostgreSQL SIMILAR TO compiled to a Thompson NFA with bounded deterministic work. */
-export declare function compileSimilarPattern(pattern: string, escape?: string): SqlPatternMatcher;
-/** Defines an own enumerable result-column property, including the special name `__proto__`. */
-export declare function defineSqlResultProperty(target: Record<string, unknown>, name: string, value: unknown): void;
-/**
- * A scalar function's string operand, or a type error naming the function. Shared because both
- * the scalar evaluator and the SQL/JSON functions insist on real strings rather than coercing:
- * a silent coercion here would make `LENGTH(42)` answer instead of failing.
- */
-export declare function stringArgument(name: string, value: unknown): string;
-export {};

package/dist/engine/worker-store-indexeddb.d.ts

@@ -1,2 +0,0 @@
-import { type WorkerStoreFactory } from "./worker-server.js";
-export declare const indexedDbWorkerStore: WorkerStoreFactory;

package/dist/engine/worker-store-memory.d.ts

@@ -1,2 +0,0 @@
-import { type WorkerStoreFactory } from "./worker-server.js";
-export declare const memoryWorkerStore: WorkerStoreFactory;

package/dist/engine/worker-store-opfs.d.ts

@@ -1,2 +0,0 @@
-import { type WorkerStoreFactory } from "./worker-server.js";
-export declare const opfsWorkerStore: WorkerStoreFactory;

package/dist/engine/write-block-planner.d.ts

@@ -1,19 +0,0 @@
-import { type LogicalType } from "../block-format/index.js";
-export interface WriteColumnValues {
-    readonly type: LogicalType;
-    readonly values: readonly unknown[];
-    readonly stringByteLengths?: readonly number[];
-}
-interface WriteBlockRange {
-    readonly start: number;
-    readonly end: number;
-}
-/**
- * Plans aligned row groups for every column in one segment. The row-wise accumulator visits each
- * string value once, plus at most one overflow recheck at a block boundary, so a late wide column
- * cannot make its siblings rescan the rest of the batch for every output block.
- */
-export declare function planAlignedWriteBlockRanges(columns: readonly WriteColumnValues[], rowCount: number, maximumRows: number, targetBytes: number, measureString?: (value: string) => number): WriteBlockRange[];
-/** Conservative first estimate used by both physical compaction planners. */
-export declare function estimateCompactionRowsPerOutput(targetBlockBytes: number, maximumEncodedBytesPerRow: number): number;
-export {};