@infino-ai/infino 0.1.0

package/infino/index.d.ts

@@ -0,0 +1,146 @@
+import * as arrow from "apache-arrow";
+import { IndexSpec } from "./native.js";
+export { IndexSpec };
+/** Infino's build identifier (version + build hash). */
+export declare const BUILDER_ID: string;
+/** Vector distance metric. */
+export type Metric = "cosine" | "l2sq" | "negdot";
+/** Boolean mode for multi-term FTS queries. */
+export type BoolMode = "or" | "and";
+/** A row from a query/search when not materializing to Arrow. */
+export type RowRecord = Record<string, unknown>;
+/** A plain `{ column: type }` schema descriptor for `createTable`. */
+export type SchemaDescriptor = Record<string, string | {
+    vector: number;
+}>;
+/** Accepted shapes for `Table.append`. */
+export type AppendData = RowRecord[] | arrow.Table | arrow.RecordBatch | Buffer | Uint8Array;
+/** Storage and cache config the `connect` URI can't carry. All optional. */
+export interface ConnectOptions {
+    /** S3-compatible endpoint; requires `region`, `accessKey`, `secretKey`. */
+    endpoint?: string;
+    region?: string;
+    accessKey?: string;
+    secretKey?: string;
+    /** Local disk-cache directory for remote-backed tables. */
+    cacheDir?: string;
+    /** Disk-cache budget in bytes. */
+    cacheBudgetBytes?: number;
+    /** How cold misses are serviced. */
+    coldFetchMode?: "hybrid_with_prefetch" | "range_only" | "lazy_foreground_with_background_fill";
+}
+/** Row counts returned by `update` / `delete`. */
+export interface MutationStats {
+    /** Rows the predicate matched. */
+    matched: number;
+    /** Rows tombstoned (removed from the live set). */
+    nTombstoned: number;
+    /** Matched rows not found in any live segment. */
+    nNotFound: number;
+}
+/** Tuning for `optimize`; all fields optional (omitted ⇒ engine default). */
+export interface OptimizeOptions {
+    /** Build-time memory budget, in MB. */
+    maxMemoryMb?: number;
+    /** Only compact superfiles below this fill percent (0–100). */
+    minFillPercent?: number;
+    /** Target merged-superfile size, in MB. */
+    targetSuperfileSizeMb?: number;
+}
+export interface Bm25SearchOptions {
+    mode?: BoolMode;
+    /** Columns to return, e.g. `["_id", "score"]`; omit for full rows. */
+    projection?: string[];
+    arrow?: boolean;
+}
+/** Text-predicate filter for `vectorSearch` (a pushdown pre-filter, not a
+ * post-filter): kNN ranks only among rows whose FTS-indexed `column` matches
+ * `query`. */
+export interface VectorFilter {
+    /** FTS-indexed column the predicate applies to. */
+    column: string;
+    /** Query terms, tokenized by the index tokenizer. */
+    query: string;
+    /** `"or"` (default) or `"and"`. */
+    mode?: BoolMode;
+}
+export interface VectorSearchOptions {
+    /** IVF partitions to probe (higher = better recall, more work). */
+    nprobe?: number;
+    /** Over-fetch multiplier for the exact-rerank stage (higher = better recall). */
+    rerankMult?: number;
+    projection?: string[];
+    arrow?: boolean;
+    /** Restrict the kNN to rows matching a text predicate (pushdown pre-filter). */
+    filter?: VectorFilter;
+}
+export interface TokenMatchOptions {
+    mode?: BoolMode;
+    projection?: string[];
+    arrow?: boolean;
+}
+export interface MatchOptions {
+    projection?: string[];
+    arrow?: boolean;
+}
+export interface QueryOptions {
+    arrow?: boolean;
+}
+export declare class Table {
+    private inner;
+    constructor(inner: any);
+    /** The table's Arrow schema. */
+    schema(): arrow.Schema;
+    /**
+     * Append rows. Accepts an array of objects, an apache-arrow
+     * Table/RecordBatch, or raw Arrow IPC bytes. Durable on return; one
+     * append == one commit.
+     */
+    append(data: AppendData): void;
+    /** Ranked BM25 search; rows as records (or an Arrow `Table`). */
+    bm25Search(column: string, query: string, k: number, opts: Bm25SearchOptions & {
+        arrow: true;
+    }): arrow.Table;
+    bm25Search(column: string, query: string, k: number, opts?: Bm25SearchOptions): RowRecord[];
+    /** Vector kNN; rows as records (or an Arrow `Table`). */
+    vectorSearch(column: string, query: number[] | Float32Array, k: number, opts: VectorSearchOptions & {
+        arrow: true;
+    }): arrow.Table;
+    vectorSearch(column: string, query: number[] | Float32Array, k: number, opts?: VectorSearchOptions): RowRecord[];
+    /** Unranked token match; matching rows as records (or an Arrow `Table`). */
+    tokenMatch(column: string, query: string, opts: TokenMatchOptions & {
+        arrow: true;
+    }): arrow.Table;
+    tokenMatch(column: string, query: string, opts?: TokenMatchOptions): RowRecord[];
+    /** Unranked exact match; matching rows as records (or an Arrow `Table`). */
+    exactMatch(column: string, value: string, opts: MatchOptions & {
+        arrow: true;
+    }): arrow.Table;
+    exactMatch(column: string, value: string, opts?: MatchOptions): RowRecord[];
+    /** Replace rows matching a SQL predicate (e.g. `"status = 'spam'"`) with
+     * `data` (same shapes as `append`), 1:1 — the matched count must equal the
+     * replacement-row count. Requires durable storage (not `memory://`). */
+    update(predicate: string, data: AppendData): MutationStats;
+    /** Delete rows matching a SQL predicate (e.g. `"status = 'spam'"`).
+     * Requires durable storage (not `memory://`). */
+    delete(predicate: string): MutationStats;
+    /** Merge small / underfilled superfiles into larger ones (omit `settings`
+     * for engine defaults). */
+    optimize(settings?: OptimizeOptions): void;
+}
+export declare class Connection {
+    private inner;
+    constructor(inner: any);
+    /** Create a table from an apache-arrow `Schema` or `{ column: type }`. */
+    createTable(name: string, schema: arrow.Schema | SchemaDescriptor | Buffer, indexes: IndexSpec): Table;
+    openTable(name: string): Table;
+    dropTable(name: string, purge?: boolean): void;
+    listTables(): string[];
+    /** SQL across the catalog; rows as records (or an Arrow `Table`). */
+    querySql(sql: string, opts: QueryOptions & {
+        arrow: true;
+    }): arrow.Table;
+    querySql(sql: string, opts?: QueryOptions): RowRecord[];
+}
+/** Open (or create) a catalog rooted at `uri`. */
+export declare function connect(uri: string, options?: ConnectOptions): Connection;

package/infino/index.js

@@ -0,0 +1,271 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The Infino Authors
+//
+// Public Node.js API for infino. Pass arrays of objects (or apache-arrow
+// Tables) in; get plain records out. `{ arrow: true }` on a search or
+// query returns an apache-arrow `Table` instead of records.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = exports.Table = exports.BUILDER_ID = exports.IndexSpec = void 0;
+exports.connect = connect;
+const arrow = __importStar(require("apache-arrow"));
+const native_js_1 = require("./native.js");
+Object.defineProperty(exports, "IndexSpec", { enumerable: true, get: function () { return native_js_1.IndexSpec; } });
+/** Infino's build identifier (version + build hash). */
+exports.BUILDER_ID = (0, native_js_1.builderId)();
+const STREAM = "stream";
+// --- Arrow <-> IPC helpers (the boundary this layer hides) ---
+// Rebuild an arrow type in our instance from the consumer's type. When
+// apache-arrow is loaded as two module instances, our `makeData` can't
+// dispatch on the consumer's type object, but its numeric `typeId` reads
+// across instances.
+function nativeTypeFromForeign(t) {
+    switch (t.typeId) {
+        case arrow.Type.Utf8: return new arrow.Utf8();
+        case arrow.Type.LargeUtf8: return new arrow.LargeUtf8();
+        case arrow.Type.Bool: return new arrow.Bool();
+        case arrow.Type.Int: return new arrow.Int(t.isSigned, t.bitWidth);
+        case arrow.Type.Float: return new arrow.Float(t.precision);
+        case arrow.Type.FixedSizeList:
+            return new arrow.FixedSizeList(t.listSize, new arrow.Field("item", nativeTypeFromForeign(t.children[0].type), true));
+        default:
+            throw new TypeError(`createTable: unsupported column type (typeId ${t.typeId})`);
+    }
+}
+// Build an arrow type from a descriptor value: a type-name string, or
+// `{ vector: dim }` for a FixedSizeList<Float32, dim> column.
+function nativeTypeFromSpec(spec) {
+    if (spec && typeof spec === "object" && typeof spec.vector === "number") {
+        return new arrow.FixedSizeList(spec.vector, new arrow.Field("item", new arrow.Float32(), true));
+    }
+    switch (String(spec).toLowerCase()) {
+        case "utf8":
+        case "string": return new arrow.Utf8();
+        case "large_utf8":
+        case "largeutf8": return new arrow.LargeUtf8();
+        case "bool":
+        case "boolean": return new arrow.Bool();
+        case "int32": return new arrow.Int32();
+        case "int64": return new arrow.Int64();
+        case "float32": return new arrow.Float32();
+        case "float64":
+        case "double": return new arrow.Float64();
+        default:
+            throw new TypeError(`createTable: unknown column type ${JSON.stringify(spec)}`);
+    }
+}
+// An apache-arrow `Schema`, a plain `{ column: type }` descriptor, or raw
+// IPC bytes -> the IPC the addon's createTable wants (an empty table that
+// carries just the schema). Types are rebuilt in OUR arrow instance.
+function schemaToIpc(schema) {
+    if (Buffer.isBuffer(schema))
+        return schema;
+    if (schema instanceof Uint8Array)
+        return Buffer.from(schema);
+    let fields;
+    if (schema && Array.isArray(schema.fields)) {
+        fields = schema.fields.map((f) => new arrow.Field(f.name, nativeTypeFromForeign(f.type), f.nullable));
+    }
+    else if (schema && typeof schema === "object") {
+        fields = Object.entries(schema).map(([name, spec]) => new arrow.Field(name, nativeTypeFromSpec(spec), false));
+    }
+    else {
+        throw new TypeError("createTable: schema must be an apache-arrow Schema or a { column: type } descriptor");
+    }
+    const nativeSchema = new arrow.Schema(fields);
+    const children = fields.map((f) => arrow.makeData({ type: f.type, length: 0 }));
+    const structData = arrow.makeData({
+        type: new arrow.Struct(fields),
+        length: 0,
+        nullCount: 0,
+        children,
+    });
+    const empty = new arrow.Table(new arrow.RecordBatch(nativeSchema, structData));
+    return Buffer.from(arrow.tableToIPC(empty, STREAM));
+}
+// Build one typed Arrow column from row objects. `vectorFromArray` handles
+// scalars; FixedSizeList<Float32> (vector columns) need the nested Data
+// built by hand. The schema here is ours (from the addon), so its types
+// are same-instance.
+function buildColumn(field, rows) {
+    const values = rows.map((r) => r[field.name]);
+    const t = field.type;
+    if (t && typeof t.listSize === "number") {
+        const flat = Float32Array.from(values.flat());
+        const child = arrow.makeData({ type: t.children[0].type, length: flat.length, data: flat });
+        const data = arrow.makeData({ type: t, length: rows.length, nullCount: 0, child });
+        return arrow.makeVector(data);
+    }
+    return arrow.vectorFromArray(values, field.type);
+}
+// Normalize append input -> IPC bytes. An array of objects, or an
+// apache-arrow Table / RecordBatch (normalized to rows via its own
+// `toArray()`/`toJSON()`); either way the columns are rebuilt in our arrow
+// instance from the declared schema. (We can't feed the consumer's Table
+// straight into our `tableToIPC` — a different module instance isn't
+// recognized.)
+function dataToIpc(data, getSchema) {
+    if (Buffer.isBuffer(data))
+        return data;
+    if (data instanceof Uint8Array)
+        return Buffer.from(data);
+    let rows;
+    const d = data;
+    if (Array.isArray(data)) {
+        rows = data;
+    }
+    else if (d && (Array.isArray(d.batches) || (d.schema && typeof d.numRows === "number"))) {
+        rows = Array.from(d).map((r) => r.toJSON());
+    }
+    else {
+        throw new TypeError("append: expected an array of objects, an apache-arrow Table / RecordBatch, or an Arrow IPC Buffer");
+    }
+    const schema = getSchema();
+    const cols = {};
+    for (const field of schema.fields)
+        cols[field.name] = buildColumn(field, rows);
+    return Buffer.from(arrow.tableToIPC(new arrow.Table(cols), STREAM));
+}
+// A Decimal128 value renders as a 4×u32 little-endian array in records.
+// Convert (scale-0 -> integer) to a `bigint`, matching token/exact match.
+function decimalToBigInt(words) {
+    let v = 0n;
+    for (let i = words.length - 1; i >= 0; i--)
+        v = (v << 32n) | BigInt(words[i] >>> 0);
+    const bits = BigInt(words.length * 32);
+    if (v >= 1n << (bits - 1n))
+        v -= 1n << bits; // two's-complement sign
+    return v;
+}
+// IPC result bytes -> records (default) or an apache-arrow Table. In record
+// form, scale-0 Decimal columns (notably `_id`) become `bigint`.
+function decode(buf, asArrow) {
+    const table = arrow.tableFromIPC(buf);
+    if (asArrow)
+        return table;
+    const intCols = table.schema.fields
+        .filter((f) => f.type.typeId === arrow.Type.Decimal && f.type.scale === 0)
+        .map((f) => f.name);
+    return table.toArray().map((row) => {
+        const obj = row.toJSON();
+        for (const name of intCols) {
+            const cell = obj[name];
+            if (cell != null && typeof cell !== "bigint")
+                obj[name] = decimalToBigInt(cell);
+        }
+        return obj;
+    });
+}
+// --- friendly handles ---
+class Table {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    /** The table's Arrow schema. */
+    schema() {
+        return arrow.tableFromIPC(this.inner.schema()).schema;
+    }
+    /**
+     * Append rows. Accepts an array of objects, an apache-arrow
+     * Table/RecordBatch, or raw Arrow IPC bytes. Durable on return; one
+     * append == one commit.
+     */
+    append(data) {
+        this.inner.append(dataToIpc(data, () => this.schema()));
+    }
+    bm25Search(column, query, k, opts = {}) {
+        const buf = this.inner.bm25Search(column, query, k, opts.mode, opts.projection);
+        return decode(buf, opts.arrow);
+    }
+    vectorSearch(column, query, k, opts = {}) {
+        const q = query instanceof Float32Array ? query : Float32Array.from(query);
+        const buf = this.inner.vectorSearch(column, q, k, opts.nprobe, opts.rerankMult, opts.projection, opts.filter);
+        return decode(buf, opts.arrow);
+    }
+    tokenMatch(column, query, opts = {}) {
+        const buf = this.inner.tokenMatch(column, query, opts.mode, opts.projection);
+        return decode(buf, opts.arrow);
+    }
+    exactMatch(column, value, opts = {}) {
+        const buf = this.inner.exactMatch(column, value, opts.projection);
+        return decode(buf, opts.arrow);
+    }
+    /** Replace rows matching a SQL predicate (e.g. `"status = 'spam'"`) with
+     * `data` (same shapes as `append`), 1:1 — the matched count must equal the
+     * replacement-row count. Requires durable storage (not `memory://`). */
+    update(predicate, data) {
+        return this.inner.update(predicate, dataToIpc(data, () => this.schema()));
+    }
+    /** Delete rows matching a SQL predicate (e.g. `"status = 'spam'"`).
+     * Requires durable storage (not `memory://`). */
+    delete(predicate) {
+        return this.inner.delete(predicate);
+    }
+    /** Merge small / underfilled superfiles into larger ones (omit `settings`
+     * for engine defaults). */
+    optimize(settings) {
+        this.inner.optimize(settings);
+    }
+}
+exports.Table = Table;
+class Connection {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    /** Create a table from an apache-arrow `Schema` or `{ column: type }`. */
+    createTable(name, schema, indexes) {
+        return new Table(this.inner.createTable(name, schemaToIpc(schema), indexes));
+    }
+    openTable(name) {
+        return new Table(this.inner.openTable(name));
+    }
+    dropTable(name, purge) {
+        this.inner.dropTable(name, purge);
+    }
+    listTables() {
+        return this.inner.listTables();
+    }
+    querySql(sql, opts = {}) {
+        return decode(this.inner.querySql(sql), opts.arrow);
+    }
+}
+exports.Connection = Connection;
+/** Open (or create) a catalog rooted at `uri`. */
+function connect(uri, options) {
+    return new Connection((0, native_js_1.connect)(uri, options));
+}

package/infino/native.d.ts

@@ -0,0 +1,167 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+/**
+ * Storage and cache config the `connect` URI can't carry. All fields are
+ * optional; omit for local / `memory://` / ambient-credential S3 with no
+ * disk cache.
+ */
+export interface ConnectOptions {
+  /** S3-compatible endpoint; requires `region`, `accessKey`, `secretKey`. */
+  endpoint?: string
+  region?: string
+  accessKey?: string
+  secretKey?: string
+  /** Local disk-cache directory for remote-backed tables. */
+  cacheDir?: string
+  /** Disk-cache budget in bytes (a JS number; up to 2^53). */
+  cacheBudgetBytes?: number
+  /**
+   * Cold-miss strategy: `"hybrid_with_prefetch"` | `"range_only"` |
+   * `"lazy_foreground_with_background_fill"`.
+   */
+  coldFetchMode?: string
+}
+/** Tuning for `optimize`; all fields optional (omitted ⇒ engine default). */
+export interface OptimizeOptions {
+  /** Build-time memory budget, in MB. */
+  maxMemoryMb?: number
+  /** Only compact superfiles below this fill percent (0–100). */
+  minFillPercent?: number
+  /** Target merged-superfile size, in MB. */
+  targetSuperfileSizeMb?: number
+}
+/** Row counts from an `update` / `delete`. */
+export interface MutationStats {
+  /** Rows the predicate matched. */
+  matched: number
+  /** Rows tombstoned (removed from the live set). */
+  nTombstoned: number
+  /** Matched rows that were not found in any live segment. */
+  nNotFound: number
+}
+/**
+ * Text-predicate filter for `vectorSearch` — a pushdown pre-filter, not a
+ * post-filter: kNN ranks only among rows whose FTS-indexed `column` matches
+ * `query`. `mode` is `"or"` (default) or `"and"`.
+ */
+export interface VectorFilter {
+  /** FTS-indexed column the predicate applies to. */
+  column: string
+  /** Query terms, tokenized by the index tokenizer. */
+  query: string
+  /** Token matching mode: `"or"` (default) or `"and"`. */
+  mode?: string
+}
+/**
+ * Open (or create) a catalog rooted at `uri` (local dir, `memory://`, or
+ * object-store prefix). S3-compatible static credentials are passed via
+ * `options` (the JS-idiomatic form of the Rust `ConnectOptions`).
+ */
+export declare function connect(uri: string, options?: ConnectOptions | undefined | null): Connection
+/**
+ * Infino's build identifier (version + build hash) from the core crate.
+ * Re-exported on the JS side as the `BUILDER_ID` string constant.
+ */
+export declare function builderId(): string
+/**
+ * Declares which columns are full-text (BM25) and which are vector (IVF
+ * kNN) indexed. Built fluently:
+ * `new IndexSpec().fts("body").vector("emb", 384, 256, "cosine")`.
+ */
+export declare class IndexSpec {
+  constructor()
+  /** Mark `column` (a UTF-8 string column) as full-text indexed. */
+  fts(column: string): IndexSpec
+  /**
+   * Mark `column` (a `fixed_size_list<float32, dim>`) as vector
+   * indexed. `nCent` is the IVF centroid count (size it to the table's
+   * scale); `metric` is `"cosine"` / `"l2sq"` / `"negdot"`.
+   */
+  vector(column: string, dim: number, nCent: number, metric: string): IndexSpec
+}
+/** A catalog connection. `const db = connect(uri)`. */
+export declare class Connection {
+  /**
+   * Create a table from an Arrow `Schema` (sent as an IPC `Buffer` —
+   * an empty `apache-arrow` table built with the schema) and an
+   * `IndexSpec`.
+   */
+  createTable(name: string, schema: Buffer, indexes: IndexSpec): Table
+  /** Open an existing table by name. */
+  openTable(name: string): Table
+  /** Drop (unregister) a table. */
+  dropTable(name: string, purge?: boolean | undefined | null): void
+  /** List the catalog's table names. */
+  listTables(): Array<string>
+  /**
+   * Run SQL across the catalog's tables; returns an Arrow IPC `Buffer`
+   * the JS side reads with `tableFromIPC`. Search is available in SQL
+   * via the TVFs, e.g.
+   * `SELECT _id, score FROM bm25_search('docs', 'body', 'q', 10)`.
+   */
+  querySql(sql: string): Buffer
+}
+/** A single-table handle. */
+export declare class Table {
+  /**
+   * Append data, sent as an Arrow IPC `Buffer` (`tableToIPC` on the JS
+   * side). Durable when this returns — one `append` == one commit ==
+   * one sealed segment, so batch rows per call. Multi-batch streams are
+   * concatenated into one commit; an empty stream is a no-op.
+   */
+  append(data: Buffer): void
+  /**
+   * BM25 search over one FTS column. Returns matching rows as an Arrow
+   * IPC `Buffer` (read with `tableFromIPC`). `mode` is `"or"` (default)
+   * or `"and"`. `projection` selects the returned columns — pass
+   * `["_id", "score"]` for just id + score, or omit for full rows.
+   */
+  bm25Search(column: string, query: string, k: number, mode?: string | undefined | null, projection?: Array<string> | undefined | null): Buffer
+  /**
+   * Vector kNN over one vector column. `query` is a `Float32Array`
+   * (crosses by reference — no copy). Returns matching rows as an Arrow
+   * IPC `Buffer` (read with `tableFromIPC`). `projection` selects the
+   * returned columns (`["_id", "score"]` for just id + score, or omit
+   * for full rows).
+   */
+  vectorSearch(column: string, query: Float32Array, k: number, nprobe?: number | undefined | null, rerankMult?: number | undefined | null, projection?: Array<string> | undefined | null, filter?: VectorFilter | undefined | null): Buffer
+  /**
+   * Unranked token match over one FTS column — every row whose `column`
+   * matches the query's tokens under `mode` (`"or"` default, `"and"`).
+   * Returns Arrow rows like [`Table::bm25_search`], with `score` = 0.0.
+   * `projection` selects columns (omit for full rows).
+   */
+  tokenMatch(column: string, query: string, mode?: string | undefined | null, projection?: Array<string> | undefined | null): Buffer
+  /**
+   * Unranked exact match of `value` against `column`. Returns Arrow rows
+   * like [`Table::bm25_search`], with `score` = 0.0. `projection` selects
+   * columns (omit for full rows).
+   */
+  exactMatch(column: string, value: string, projection?: Array<string> | undefined | null): Buffer
+  /**
+   * Delete every row matching a SQL `predicate` (e.g. `"status = 'spam'"`),
+   * returning the mutation counts. Requires durable storage — a `memory://`
+   * table surfaces a clear error.
+   */
+  delete(predicate: string): MutationStats
+  /**
+   * Replace every row matching a SQL `predicate` with `rows` (an Arrow IPC
+   * `Buffer`, like `append`), 1:1 — the matched count must equal the
+   * replacement-row count or the engine errors. Requires durable storage.
+   */
+  update(predicate: string, rows: Buffer): MutationStats
+  /**
+   * Merge small / underfilled superfiles into larger ones. `settings` tunes
+   * the memory budget, fill threshold, and target size (omit for engine
+   * defaults).
+   */
+  optimize(settings?: OptimizeOptions | undefined | null): void
+  /**
+   * The user-facing Arrow schema, as an Arrow IPC `Buffer` (an empty
+   * table carrying the schema; read with `tableFromIPC`).
+   */
+  schema(): Buffer
+}