@jarenjs/db 0.49.2 → 0.66.1

package/dist/types/capture.d.ts

@@ -1,85 +0,0 @@
-/**
- * @file Change capture (D13): committed writes become an observable,
- * ordered stream of RFC 6902 patches — derived from SQLite's own
- * session changesets where the binding has them, from a write-path
- * journal where it does not (`bun:sqlite` has no `createSession`), or
- * off entirely. One diff format then runs end to end: store → patch →
- * live query → patch → O(k) render.
- *
- * The pointer contract (LIVE-FORMAT §2): `/<table>/<key>/<path…>`,
- * every token escaped per RFC 6901. A single key renders as its
- * scalar text (integers in decimal); a composite key renders as the
- * JSON text of its parts array. Join-table rows are tiny documents
- * under the join table's name — membership changes are part of the
- * stream, not a blind spot.
- *
- * Session facts this file is built on (probed, 3.51.2):
- * - a changeset carries ONE NET OP PER ROW (insert+update coalesce;
- *   insert+delete vanish; a no-op update is absent), and within-table
- *   order is NOT statement order — every row op targets a distinct
- *   pointer, so application order across rows cannot matter;
- * - `ROLLBACK TO` a savepoint removes the undone rows from the
- *   session (pinned by test — the classic caveat does NOT hold here);
- * - a rolled-back transaction yields an empty changeset;
- * - virtual generated columns are invisible;
- * - an UPDATE's old record carries the primary key and the CHANGED
- *   columns only — which is exactly enough for property-level ops,
- *   and why the doc column's old/new blobs make a minimal nested
- *   diff possible (`SELECT json(?)` turns JSONB back into text).
- */
-/** The persisted change log (LIVE-FORMAT §5). */
-export declare const CHANGES_TABLE = "_jaren_changes";
-export declare const DEFAULT_RETENTION = 1000;
-/**
- * Decode a binary changeset into row operations.
- * @param {Uint8Array} bytes
- * @returns {{ table: string, pk: boolean[], op: 'insert'|'update'|'delete',
- *   indirect: boolean, oldValues: any[] | null, newValues: any[] | null }[]}
- */
-export declare function parseChangeset(bytes: Uint8Array): {
-    table: string;
-    pk: boolean[];
-    op: 'insert' | 'update' | 'delete';
-    indirect: boolean;
-    oldValues: any[] | null;
-    newValues: any[] | null;
-}[];
-/**
- * The key token (LIVE-FORMAT §2): a single key is its scalar text;
- * a composite key is the JSON text of its parts array.
- * @param {any[]} parts
- * @returns {string}
- */
-export declare function keyToken(parts: any[]): string;
-export type TableShape = {
-    kind: 'collection' | 'entity' | 'join';
-    columns: {
-        name: string;
-        role: 'key' | 'doc' | 'scalar' | 'fk' | 'epoch';
-        storage?: string;
-    }[];
-    keyIndexes: number[];
-    docIndex: number;
-};
-/**
- * Translate parsed row operations into RFC 6902 ops, resolving JSONB
- * blobs through the connection (`SELECT json(?)`).
- * @param {any} connection
- * @param {Map<string, TableShape>} shapes
- * @param {any[]} operations
- * @returns {any} value-or-promise of RFC 6902 ops
- */
-export declare function translateOperations(connection: any, shapes: Map<string, TableShape>, operations: any[]): any;
-/**
- * @param {{ connection: any, shapes: Map<string, TableShape>,
- *   mode: 'session' | 'journal',
- *   log: boolean, retention: number }} options
- * @returns {any}
- */
-export declare function createCaptureEngine(options: {
-    connection: any;
-    shapes: Map<string, TableShape>;
-    mode: 'session' | 'journal';
-    log: boolean;
-    retention: number;
-}): any;

package/dist/types/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/types/dag-job.d.ts

@@ -1,40 +0,0 @@
-/**
- * @file The composition (JOBS-FORMAT §7): a persisted `@jarenjs/flow`
- * DAG run wired to a queue job. THE FLOW ENGINE IS INJECTED, NEVER
- * IMPORTED — the shared invariant forbids `@jarenjs/db` importing
- * `@jarenjs/flow`, so `compileDag` arrives as a capability (the D10
- * shape applied to flow) and a test asserts the manifest and import
- * graph name flow nowhere.
- *
- * Each kind's document compiles ONCE against a delegating checkpoint
- * store; per claimed job, the delegate binds the engine's guarded
- * per-job store (`checkpointsFor`) — `save` refuses once the lease is
- * lost and `complete` records the DAG result, marks the job done and
- * prunes the checkpoint rows in ONE transaction, so a failure leaves
- * neither and a crash resumes instead of restarting.
- */
-/**
- * Build a worker whose handlers run checkpointed DAG documents.
- * @param {any} store - an open store with `{ jobs: true }`
- * @param {{ compileDag: Function,
- *   documents: Record<string, any>,
- *   tasks?: Record<string, Function>,
- *   concurrency?: number, pollInterval?: number, leaseMs?: number,
- *   owner?: string, backoffBase?: number, backoffCap?: number }} options
- * @returns {{ start: () => any, stop: () => Promise<void>, stats: () => any }}
- */
-export declare function createDagJobRunner(store: any, options: {
-    compileDag: Function;
-    documents: Record<string, any>;
-    tasks?: Record<string, Function>;
-    concurrency?: number;
-    pollInterval?: number;
-    leaseMs?: number;
-    owner?: string;
-    backoffBase?: number;
-    backoffCap?: number;
-}): {
-    start: () => any;
-    stop: () => Promise<void>;
-    stats: () => any;
-};

package/dist/types/ddl.d.ts

@@ -1,229 +0,0 @@
-/**
- * @file DDL planning: a normalized collection becomes one physical
- * table — a key column, a JSON document column, a virtual generated
- * column per indexed path, and the declared indexes — with every byte
- * of SQL rendered by the dialect.
- *
- * Index paths are JSONPath expressions analyzed through the engine's
- * PUBLISHED AST (`analyzeQuery`): a path is indexable exactly when the
- * analysis says it is singular and every segment is a plain member or
- * index selection. That reuses the one grammar authority instead of
- * re-parsing, and it fails loudly (`JD0004`) on everything else —
- * wildcards, slices, filters, descendants, functions — rather than
- * silently indexing the wrong thing.
- */
-/** The fixed physical column names of the 0.1 mapping. */
-export declare const KEY_COLUMN = "key";
-export declare const DOC_COLUMN = "doc";
-/**
- * Analyze one index path expression down to typed segments.
- * @param {string} expression - A JSONPath expression (`$.email`)
- * @param {string} docPath - Model-document pointer for diagnostics
- * @returns {{ segments: import('./dialect.js').JsonPathSegment[],
- *   canonical: string }}
- */
-export declare function compileIndexPath(expression: string, docPath: string): {
-    segments: import('./dialect.js').JsonPathSegment[];
-    canonical: string;
-};
-/**
- * The schema subschema at a segment path, walked structurally through
- * `properties` / `items` / `prefixItems`. The collection's schema is
- * the type source — that is why the physical mapping needs no
- * engine-side inference. `undefined` where the walk leaves the schema.
- * @param {any} schema
- * @param {import('./dialect.js').JsonPathSegment[]} segments
- * @returns {any}
- */
-export declare function schemaNodeAt(schema: any, segments: import('./dialect.js').JsonPathSegment[]): any;
-/**
- * The declared schema type at a segment path: the first non-`null`
- * member of a union, which is the type a COLUMN takes its storage
- * from. A caller that must know the whole union (a promotion refusing
- * a member that may also be `null`) reads {@link schemaNodeAt}.
- * @param {any} schema
- * @param {import('./dialect.js').JsonPathSegment[]} segments
- * @returns {string | undefined}
- */
-export declare function schemaTypeAt(schema: any, segments: import('./dialect.js').JsonPathSegment[]): string | undefined;
-/**
- * Plan one collection's physical shape: the DDL statements to create
- * it and the structural facts an existing table must match (the
- * `JD0002` comparison set).
- * A derived index (`derive: 'geohash' | 'bbox'`) maps to the same
- * shape through a registered deterministic function, EXCEPT where the
- * driver cannot index one (`capabilities.deterministicIndexableFunctions`
- * is false): there the columns are ordinary ones the store writes. The
- * two mappings produce different declared text on purpose — a database
- * built under one and opened under the other really does disagree, and
- * `verifyShape` says so rather than papering over it. A
- * `derive: 'vector'` column is the stored shape under BOTH mappings
- * (`derivedMappingFor`), so for it the two agree.
- * @param {string} name - The collection name (also the table name)
- * @param {{ schema: any, keySegments: { name: string }[] | null,
- *   identity: string, indexes: { name: string, paths: string[],
- *   unique: boolean, derive?: string | null, precision?: number,
- *   dims?: number, docPath: string }[] }} collection - normalized
- * @param {any} dialect
- * @param {{ derived?: 'virtual' | 'stored', rtree?: boolean }} [options]
- *   - `derived` is the physical mapping for derived columns:
- *   `'virtual'` (a generated column over a registered function) unless
- *   the driver says it cannot index one. `rtree` is whether the driver
- *   carries the R\*Tree module; when it does not, a column set that
- *   declared `physical: 'rtree'` falls back to the B-tree over its
- *   columns and `explain().prefilters[].via` reports which shape ran
- *   (MODEL-FORMAT §4) — a report, not a silent degradation
- * @returns {{
- *   table: string, keyColumn: string, docColumn: string,
- *   keyType: string,
- *   generated: { name: string, type: string, pathText: string,
- *     canonical: string }[],
- *   derived: { name: string, derive: string, precision?: number,
- *     component?: string, dims?: number, segments: any[] }[],
- *   columnByCanonical: Map<string, string>,
- *   createSql: string[],
- *   virtualTables: { stem: string, name: string, columns: string[],
- *     edges: string[], createSql: string, fillSql: string,
- *     triggers: { name: string, sql: string }[] }[],
- *   expected: { columns: { name: string, type: string,
- *     generated: boolean }[], indexes: { name: string, unique: boolean,
- *     columns: string[] }[] },
- * }}
- */
-export declare function planCollection(name: string, collection: {
-    schema: any;
-    keySegments: {
-        name: string;
-    }[] | null;
-    identity: string;
-    indexes: {
-        name: string;
-        paths: string[];
-        unique: boolean;
-        derive?: string | null;
-        precision?: number;
-        dims?: number;
-        docPath: string;
-    }[];
-}, dialect: any, options?: {
-    derived?: 'virtual' | 'stored';
-    rtree?: boolean;
-}): {
-    table: string;
-    keyColumn: string;
-    docColumn: string;
-    keyType: string;
-    generated: {
-        name: string;
-        type: string;
-        pathText: string;
-        canonical: string;
-    }[];
-    derived: {
-        name: string;
-        derive: string;
-        precision?: number;
-        component?: string;
-        dims?: number;
-        segments: any[];
-    }[];
-    columnByCanonical: Map<string, string>;
-    createSql: string[];
-    virtualTables: {
-        stem: string;
-        name: string;
-        columns: string[];
-        edges: string[];
-        createSql: string;
-        fillSql: string;
-        triggers: {
-            name: string;
-            sql: string;
-        }[];
-    }[];
-    expected: {
-        columns: {
-            name: string;
-            type: string;
-            generated: boolean;
-        }[];
-        indexes: {
-            name: string;
-            unique: boolean;
-            columns: string[];
-        }[];
-    };
-};
-/**
- * Normalize a stored `CREATE` statement for comparison: collapse runs of
- * whitespace, drop whitespace around punctuation, and strip the
- * `IF NOT EXISTS` SQLite does not keep. What survives is every token that
- * carries meaning, so two statements compare equal exactly when they
- * declare the same physical object.
- * @param {string} sql
- * @returns {string}
- */
-export declare function normalizeDeclaredSql(sql: string): string;
-/**
- * A comparable form of one `CREATE` statement.
- *
- * For a TABLE the column definitions compare as a SET, because
- * `ALTER TABLE … ADD COLUMN` can only append — so a migrated table and a
- * freshly built one legitimately differ in column order, and this store
- * never reads a column positionally. Everything else is exact: each
- * column's full definition (type, `PRIMARY KEY`, `NOT NULL`, `DEFAULT`,
- * `CHECK`, `GENERATED … AS`, `REFERENCES … ON DELETE …`), the table
- * constraints, and the trailing table options (`STRICT`,
- * `WITHOUT ROWID`).
- *
- * For an INDEX the text compares whole, because an index IS its order —
- * `(a,b)` and `(b,a)` serve different lookups — as are its partial
- * predicate and each term's collation and direction.
- * @param {string} sql
- * @returns {string}
- */
-export declare function comparableDeclaredSql(sql: string): string;
-/**
- * Verify an existing table against the planned shape; any difference
- * is `JD0002` and nothing is altered. Shared by the store's open path
- * and the migration engine's shadow validation.
- * @param {any} connection
- * @param {any} plan
- * @param {string} collection
- * @param {string} docPath
- * @returns {any} value-or-promise
- */
-export declare function verifyShape(connection: any, plan: any, collection: string, docPath: string): any;
-/**
- * Plan one ENTITY's physical shape from the mapping data
- * `explainMapping` derived: the relational table (typed columns,
- * checks, foreign keys, the JSONB document column), its indexes, and
- * the structural facts an existing table must match. One verify path
- * serves both document kinds.
- * @param {string} name
- * @param {any} entityMapping - `explainMapping(model).entities[name]`
- * @param {any} entities - the full `explainMapping` result (key types
- *   come from the referenced entity's columns)
- * @param {any} dialect
- * @returns {{ table: string, createSql: string[], expected: any,
- *   columnNames: Set<string> }}
- */
-export declare function planEntity(name: string, entityMapping: any, entities: any, dialect: any): {
-    table: string;
-    createSql: string[];
-    expected: any;
-    columnNames: Set<string>;
-};
-/**
- * Plan a many-to-many join table.
- * @param {string} tableName
- * @param {any} join - `explainMapping(model).joinTables[tableName]`
- * @param {any} entities - the full mapping
- * @param {any} dialect
- * @returns {{ table: string, createSql: string[], expected: any }}
- */
-export declare function planJoinTable(tableName: string, join: any, entities: any, dialect: any): {
-    table: string;
-    createSql: string[];
-    expected: any;
-};

package/dist/types/derive.d.ts

@@ -1,250 +0,0 @@
-/**
- * @file Derived index columns: the one place a declared
- * `indexes[].derive` becomes a value. A spatial member is an array of
- * numbers or an object, and a generated column must be a scalar, so a
- * geohash cell or a bounding-box edge is what actually gets indexed;
- * an embedding is an array of hundreds of numbers, and what gets
- * stored is its packed, l2-normalized Float32 form.
- *
- * Every cell and every box comes from `@jarenjs/core/geo`, and every
- * normalization and packing from `@jarenjs/core/vector`; nothing here
- * computes arithmetic of its own. The spatial functions serve BOTH
- * physical mappings — registered as deterministic SQL functions inside
- * a virtual generated column's expression where the driver can index
- * them, and called directly on the write path where it cannot — so
- * the two branches cannot drift into different answers. The vector
- * kind has ONE mapping, stored everywhere (`DERIVE_MAPPING`), and
- * registers no function at all: a whole array re-derived per row as a
- * host call is the cost the spatial work measured at 150×, a stored
- * column is readable without any registration, and bun has no
- * function API — one mapping is the only way every driver agrees.
- *
- * It is also this package's ONLY seam onto `@jarenjs/core/geo` (D1 —
- * one home for spatial arithmetic, grep-proven by test) and onto
- * `@jarenjs/core/vector` (the same rule, one home for vector
- * arithmetic): the planner's probe geometry — the box of a literal or
- * bound region, the box of a bounded-distance circle, a cell's
- * neighbourhood — and the k-nearest plan's probe vector and column
- * score are computed by the helpers below rather than by an import of
- * their own.
- *
- * The switches over the kind are EXHAUSTIVE: a kind with no rule
- * throws, here and in the dialect, so that adding a kind without
- * teaching both is a failure at the first call rather than a bbox
- * edge of the first two floats and `jaren_bbox_undefined(...)` SQL.
- *
- * Determinism is the contract, not a convenience: a value here is a
- * pure function of the document bytes. Nothing reads the clock, a
- * random source or store state, because an INDEX over a function that
- * did would make the database unreadable from a connection whose
- * function answered differently — and unreadable, not merely wrong:
- * a connection that has not registered the function at all cannot even
- * SELECT the table (probed). That hazard is why the mapping is
- * capability-gated rather than always-on.
- */
-/** The closed set of derive kinds. */
-export declare const DERIVE_KINDS: Set<string>;
-/**
- * The per-kind PHYSICAL MAPPING override. A spatial kind takes the
- * mapping the driver's capability selects (`null` here); the vector
- * kind is `'stored'` on every driver, for the three reasons in the
- * file header, and never joins `registerDeriveFunctions`.
- * @type {Readonly<Record<string, 'stored' | null>>}
- */
-export declare const DERIVE_MAPPING: Readonly<Record<string, 'stored' | null>>;
-/**
- * The physical mapping one derived column takes: the kind's override
- * where it has one, the driver's mapping otherwise.
- * @param {string} kind
- * @param {'virtual' | 'stored'} driverMapping
- * @returns {'virtual' | 'stored'}
- */
-export declare function derivedMappingFor(kind: string, driverMapping: 'virtual' | 'stored'): 'virtual' | 'stored';
-/**
- * The closed set of PHYSICAL realizations a `derive: 'bbox'` index may
- * ask for. `'columns'` is the default and what an absent member means:
- * four generated columns under one B-tree. `'rtree'` is the same four
- * columns (they stay the box's one definition) beside a SQLite R\*Tree
- * virtual table kept in sync by declared triggers, with no B-tree over
- * them. The LOGICAL meaning of `derive: 'bbox'` is identical either
- * way — same rows, same answers — which is the whole point of naming
- * the shape separately from the derivation.
- */
-export declare const PHYSICAL_KINDS: Set<string>;
-/** A bbox index's four columns, in the order they are declared —
- * `[west, south, east, north]`, the order the kernel's boxes carry. */
-export declare const BBOX_COMPONENTS: readonly string[];
-/**
- * The order a bbox index COVERS its four columns, which is not the
- * order they are declared in: an intersection test reads
- * `w <= ? AND e >= ? AND s <= ? AND n >= ?`, so the two longitude
- * bounds sit together at the front of the index where a leading-column
- * range can use them. `(a,b)` and `(b,a)` are different indexes.
- */
-export declare const BBOX_INDEX_ORDER: readonly string[];
-/** The declared geohash precision range (characters). */
-export declare const PRECISION_MIN = 1;
-export declare const PRECISION_MAX = 12;
-/** The declared vector width range (components). */
-export declare const DIMS_MIN = 1;
-export declare const DIMS_MAX = 8192;
-/**
- * The geohash cell of a value at a precision, or null when the value
- * carries no bounded position.
- * @param {any} value
- * @param {number} precision
- * @returns {string | null}
- */
-export declare function deriveGeohash(value: any, precision: number): string | null;
-/**
- * One edge of a value's bounding box, or null when it has none —
- * including the D6 case where a non-finite coordinate refuses the box
- * rather than producing one that does not bound its input.
- * @param {any} value
- * @param {string} component - `'w'`, `'s'`, `'e'` or `'n'`
- * @returns {number | null}
- */
-export declare function deriveBboxEdge(value: any, component: string): number | null;
-/**
- * The value of a `derive: 'vector'` column for a document member — the
- * ONE seam from this package onto `@jarenjs/core/vector`. The member
- * round-trips through its stored form first, exactly as the spatial
- * kinds do: a `Float32Array` in the document is held as an object and
- * a `NaN` as `null`, and the column must be a function of what is
- * held, so that a write, a migration backfill and a second open can
- * never disagree about one row.
- * @param {any} member - the value at the index path, or `undefined`
- * @param {number} dims - the declared width
- * @returns {Uint8Array | null} `4·dims` bytes, or `null` when the
- *   member is not a vector of that width
- */
-export declare function deriveVector(member: any, dims: number): Uint8Array | null;
-/**
- * A member as the database will hold it. A derived value must be a
- * function of the STORED document, not of the object handed to the
- * write: JSON has no `NaN` and no `Infinity`, so a non-finite
- * coordinate becomes `null` on the way in and is no longer a position
- * at all. Computing from the in-memory value would make the two
- * physical mappings answer differently for the same document, which is
- * the one thing they may never do.
- *
- * Only the indexed MEMBER round-trips, not the whole document — it is
- * the only part a derived column reads.
- * @param {any} member
- * @returns {any} the member as stored, or `undefined` when there is none
- */
-export declare function storedMemberForm(member: any): any;
-/**
- * The value of one derived column for a document member, which the
- * caller hands over in its STORED form (`storedMemberForm`): the write
- * path round-trips it, and a migration backfill reads it from the row.
- * Exhaustive over the kind — see the file header.
- * @param {{ derive: string, precision?: number, component?: string,
- *   dims?: number }} column
- * @param {any} member - the stored value at the index path, or `undefined`
- * @returns {string | number | Uint8Array | null}
- */
-export declare function derivedValue(column: {
-    derive: string;
-    precision?: number;
-    component?: string;
-    dims?: number;
-}, member: any): string | number | Uint8Array | null;
-/**
- * Read the member one derived column is computed from, walking the
- * same typed segments the physical mapping was planned over.
- * @param {any} doc
- * @param {import('./dialect.js').JsonPathSegment[]} segments
- * @returns {any} the member, or `undefined`
- */
-export declare function memberAt(doc: any, segments: import('./dialect.js').JsonPathSegment[]): any;
-/**
- * Register the deterministic functions the virtual generated columns
- * call. Idempotent per connection by SQLite's own semantics (a second
- * registration replaces the first with the identical implementation),
- * and a no-op where the driver cannot index a registered function —
- * that branch stores the columns instead.
- *
- * The four bbox edges share a one-entry memo of the last text they
- * were asked about, because they are called back to back with the same
- * argument for one row and the box costs a full walk of the geometry.
- * The memo is keyed on the argument itself, so it changes no answer.
- * @param {any} connection
- * @returns {any} value-or-promise
- */
-export declare function registerDeriveFunctions(connection: any): any;
-/**
- * The bounding box of a probe value, or `null` when it has none — the
- * D6 refusal included, which is what makes an unbounded probe divert to
- * the full scan instead of narrowing with a box that does not bound it.
- * @param {any} value - a GeoJSON value or a `[lon, lat]` position
- * @returns {number[] | null} `[west, south, east, north]`
- */
-export declare function probeBox(value: any): number[] | null;
-/**
- * The representative position §8.14 measures a probe value by — the
- * same rule the derived columns use, so the pushed filter and the
- * engine cannot disagree about where a value IS. `null` when it has no
- * bounded position.
- * @param {any} value
- * @returns {number[] | null}
- */
-export declare function probePosition(value: any): number[] | null;
-/**
- * The bounding box of the circle of `metres` around a position — the
- * box a `$distance <= r` predicate narrows with, on the same sphere and
- * the same radius constant the engine measures with. `null` when the
- * radius is not a finite non-negative number, or when the circle
- * reaches a pole, where there is no longitude bound to give.
- * @param {number[]} position
- * @param {number} metres
- * @returns {number[] | null} `[west, south, east, north]`, NOT wrapped
- *   into `[-180, 180]`: a circle spanning the antimeridian answers a
- *   west below -180, which is how the planner detects it
- */
-export declare function probeCircleBox(position: number[], metres: number): number[] | null;
-/**
- * A cell and its neighbours, the nine-cell probe D7 requires — a single
- * prefix is bucketing, never proximity.
- * @param {string} cell
- * @returns {string[]} up to nine cells (fewer past a pole)
- */
-export declare function cellNeighbourhood(cell: string): string[];
-/**
- * The value one DERIVED parameter slot binds: an axis of a bound
- * external's bounding box, computed at bind time because a GeoJSON
- * object is not a value any database can bind. `null` when the value
- * has no box, which is what tells the caller to divert.
- * @param {{ kind: string, external: string, axis: string }} derived
- * @param {any} value - the bound external
- * @returns {number | null}
- */
-export declare function derivedSlotValue(derived: {
-    kind: string;
-    external: string;
-    axis: string;
-}, value: any): number | null;
-/**
- * The probe a k-nearest plan scores the column against: a literal or
- * bound vector, l2-normalized once, so that its dot product with the
- * column's normalized form IS the cosine of the raw vectors. `null`
- * when the value is not a vector of exactly `dims` finite numbers —
- * the binder's signal to divert the call to the residual, where the
- * engine answers what it answers everywhere for such a probe (empty
- * keys for another width, its own refusal for a non-array).
- * @param {unknown} value
- * @param {number} dims - the column's declared width
- * @returns {Float32Array | null}
- */
-export declare function probeVector(value: unknown, dims: number): Float32Array | null;
-/**
- * One row's column score against a prepared probe: the packed column
- * unpacked at the declared width and dotted with the probe. `null` for
- * a row whose column holds no vector — SQL `NULL`, or bytes of another
- * length — because such a row is unrankable and 0 is a real score.
- * @param {unknown} bytes - the column value as the driver returns it
- * @param {number} dims
- * @param {Float32Array} probe - from {@link probeVector}
- * @returns {number | null}
- */
-export declare function columnScore(bytes: unknown, dims: number, probe: Float32Array): number | null;