grepmax 0.26.52 → 0.26.54

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "grepmax",
       "source": "./plugins/grepmax",
       "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
-      "version": "0.26.52",
+      "version": "0.26.54",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/NOTICE

@@ -33,7 +33,7 @@ This software depends on various open-source libraries. See package.json for
 a complete list of dependencies and their respective licenses.
 
 The distribution includes the unmodified JavaScript runtime from
-@lancedb/lancedb 0.38.0 (https://github.com/lancedb/lancedb), licensed under
+@lancedb/lancedb 0.39.0 (https://github.com/lancedb/lancedb), licensed under
 Apache-2.0. Its license and build provenance are included in dist/vendor/lancedb/.
 Its optional provider dependency manifest is not distributed. Platform native
 binaries are installed as separately pinned @lancedb packages.

package/README.md

@@ -484,7 +484,7 @@ whether you need to act.
 
 | You see | What it means |
 |---|---|
-| `Optimize panicked ... inverted/builder.rs` | The historical FTS merge defect is fixed in the shipped LanceDB 0.38.0 runtime. If it recurs on a current release, preserve the version and logs and report a regression; the rebuild guard remains a recovery tripwire. |
+| `Optimize panicked ... inverted/builder.rs` | The historical FTS merge defect is fixed in the shipped LanceDB 0.39.0 runtime. If it recurs on a current release, preserve the version and logs and report a regression; the rebuild guard remains a recovery tripwire. |
 | `disabling auto-rebuild until an optimize succeeds` | Transient, not a wedge. The next successful optimize clears it. Search stays available. |
 | `ANN: vector index not built` | Normal — exact search is the default. |
 | `cannot reach the daemon socket from this sandbox` (exit 2) | The shell is sandboxed. Add the two keys in [Running under the Claude Code sandbox](#running-under-the-claude-code-sandbox); `gmax doctor` warns about the same gap. |

package/dist/lib/output/mcp-results.js

@@ -47,6 +47,9 @@ exports.compactionSchema = zod_1.z.object({
     freeBytesBefore: zod_1.z.number().optional(),
     freeBytesAfter: zod_1.z.number().optional(),
     bytesReclaimed: zod_1.z.number().optional(),
+    netBytesReclaimed: zod_1.z.number().optional(),
+    cleanupPasses: zod_1.z.number().int().min(0).max(1).optional(),
+    cleanupReason: zod_1.z.string().optional(),
 });
 const embedding = zod_1.z.object({
     tier: zod_1.z.string(),

package/dist/lib/store/vector-db.js

@@ -1108,9 +1108,80 @@ class VectorDB {
         (0, logger_1.log)("vectordb", `Compaction result: ${JSON.stringify(result)}`);
         return Object.assign({}, result);
     }
+    /** Prune the reserve-ID snapshot without another data rewrite. Caller holds
+     * compactingPromise and has drained writes; never use this for retention > 0.
+     * Lance 12 treats one deletion-free fragment as a compaction no-op. */
+    cleanupCompactionReservation(table) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let passes = 0;
+            const deferred = (reason) => ({
+                passes: 0,
+                bytesRemoved: 0,
+                reason,
+            });
+            try {
+                const stats = yield table.stats();
+                if (((_a = stats.fragmentStats) === null || _a === void 0 ? void 0 : _a.numFragments) !== 1) {
+                    return deferred("cleanup deferred: table is not a single fragment");
+                }
+                const version = yield table.version();
+                const fresh = yield this.openExistingTableUnsafe();
+                if (!fresh || (yield fresh.version()) !== version) {
+                    return deferred("cleanup deferred: table changed after compaction");
+                }
+                const latest = (yield fresh.listVersions()).find((v) => v.version === version);
+                if ((latest === null || latest === void 0 ? void 0 : latest.metadata.total_fragments) !== "1" ||
+                    latest.metadata.total_deletion_files !== "0" ||
+                    latest.metadata.total_deletion_file_rows !== "0") {
+                    return deferred("cleanup deferred: deletion-free fragment not verified");
+                }
+                // Manifest timestamps have sub-ms precision; wait for a real later tick,
+                // never invent a future cutoff. No gmax writes can enter while gated.
+                yield new Promise((resolve) => setTimeout(resolve, 1));
+                const cutoff = new Date();
+                if (!Number.isFinite(latest.timestamp.getTime()) ||
+                    cutoff.getTime() <= latest.timestamp.getTime()) {
+                    return deferred("cleanup deferred: clock has not passed the commit");
+                }
+                const freeBytes = this.getAvailableBytes();
+                const requiredBytes = stats.totalBytes * 2 + config_1.DISK_CRITICAL_BYTES;
+                if (!Number.isFinite(stats.totalBytes) ||
+                    stats.totalBytes < 0 ||
+                    freeBytes < requiredBytes) {
+                    return deferred("cleanup deferred: insufficient rewrite headroom");
+                }
+                (0, logger_1.log)("vectordb", `Compaction cleanup attempt: ${JSON.stringify({ version, cutoff: cutoff.getTime(), freeBytes, requiredBytes })}`);
+                passes = 1;
+                const result = yield fresh.optimize({
+                    cleanupOlderThan: cutoff,
+                    deleteUnverified: true,
+                });
+                if (result.compaction.fragmentsRemoved !== 0 ||
+                    result.compaction.fragmentsAdded !== 0) {
+                    return {
+                        passes,
+                        bytesRemoved: result.prune.bytesRemoved,
+                        failed: true,
+                        reason: "cleanup unexpectedly rewrote data; no retry",
+                    };
+                }
+                return { passes, bytesRemoved: result.prune.bytesRemoved };
+            }
+            catch (error) {
+                return {
+                    passes,
+                    bytesRemoved: 0,
+                    failed: true,
+                    reason: `cleanup failed: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        });
+    }
     optimize() {
         return __awaiter(this, arguments, void 0, function* (retries = COMPACTION_MAX_ATTEMPTS, retentionMs = 0, bypassExclusiveMutation = false) {
             var _a;
+            var _b;
             if (!bypassExclusiveMutation) {
                 while (this.exclusiveMutationPromise)
                     yield this.exclusiveMutationPromise;
@@ -1120,7 +1191,7 @@ class VectorDB {
             if (this.compactingPromise) {
                 (0, logger_1.debug)("vectordb", "Optimize already in progress, skipping");
                 yield this.compactingPromise;
-                return ((_a = this.compactionStatus()) !== null && _a !== void 0 ? _a : (0, compaction_result_1.skippedCompaction)("compaction unavailable"));
+                return ((_b = this.compactionStatus()) !== null && _b !== void 0 ? _b : (0, compaction_result_1.skippedCompaction)("compaction unavailable"));
             }
             this.lastOptimizeDidWork = false;
             let resolveCompacting;
@@ -1133,7 +1204,10 @@ class VectorDB {
             let logicalBytes;
             let diskBytesBefore;
             let freeBytesBefore;
+            let cleanupPasses = 0;
+            let cleanupReason;
             const finish = (status, reason, bytesReclaimed) => {
+                const diskBytesAfter = this.getDirectorySize(this.lancedbDir);
                 const result = {
                     status,
                     at: Date.now(),
@@ -1143,9 +1217,14 @@ class VectorDB {
                     logicalBytes,
                     diskBytesBefore,
                     freeBytesBefore,
-                    diskBytesAfter: this.getDirectorySize(this.lancedbDir),
+                    diskBytesAfter,
                     freeBytesAfter: this.getAvailableBytes(),
                     bytesReclaimed,
+                    netBytesReclaimed: diskBytesBefore === undefined
+                        ? undefined
+                        : diskBytesBefore - diskBytesAfter,
+                    cleanupPasses,
+                    cleanupReason,
                 };
                 this.lastCompactionResult = result;
                 (0, logger_1.log)("vectordb", `Compaction result: ${JSON.stringify(result)}`);
@@ -1210,7 +1289,18 @@ class VectorDB {
                         else {
                             (0, logger_1.debug)("vectordb", "Optimize: nothing to compact or prune");
                         }
-                        return finish("completed", undefined, prune.bytesRemoved);
+                        let bytesReclaimed = prune.bytesRemoved;
+                        if (retentionMs === 0 && compaction.fragmentsRemoved > 0) {
+                            const cleanup = yield this.cleanupCompactionReservation(table);
+                            cleanupPasses = cleanup.passes;
+                            cleanupReason = (_a = cleanup.reason) === null || _a === void 0 ? void 0 : _a.replace(/[\r\n\t]/g, " ").slice(0, 512);
+                            bytesReclaimed += cleanup.bytesRemoved;
+                            this.lastOptimizeDidWork || (this.lastOptimizeDidWork = cleanup.bytesRemoved > 0);
+                            (0, logger_1.log)("vectordb", `Compaction cleanup result: ${JSON.stringify(Object.assign(Object.assign({}, cleanup), { reason: cleanupReason }))}`);
+                            if (cleanup.failed)
+                                return finish("failed", cleanupReason, bytesReclaimed);
+                        }
+                        return finish("completed", undefined, bytesReclaimed);
                     }
                     catch (e) {
                         const msg = e instanceof Error ? e.message : String(e);
@@ -1337,7 +1427,7 @@ class VectorDB {
                     // call, so a productive first pass followed by a barren bloat retry would
                     // otherwise read as unproductive and trigger a spurious backoff.
                     let didWork = this.lastOptimizeDidWork;
-                    if (this.lastOptimizeDidWork) {
+                    if (result.status === "completed" && this.lastOptimizeDidWork) {
                         const table = yield this.openExistingTableUnsafe();
                         if (table) {
                             // Collect abandoned scratch files before measuring. They are pure

package/dist/lib/utils/doctor-optimize.js

@@ -72,6 +72,12 @@ function formatDoctorOptimize(report, agent) {
             ...(typeof (r === null || r === void 0 ? void 0 : r.bytesReclaimed) === "number"
                 ? [`bytes_reclaimed=${r.bytesReclaimed}`]
                 : []),
+            ...(typeof (r === null || r === void 0 ? void 0 : r.netBytesReclaimed) === "number"
+                ? [`net_bytes_reclaimed=${r.netBytesReclaimed}`]
+                : []),
+            ...(typeof (r === null || r === void 0 ? void 0 : r.cleanupPasses) === "number"
+                ? [`cleanup_passes=${r.cleanupPasses}`]
+                : []),
             ...(reason ? [`reason=${reason}`] : []),
         ].join("\t");
     }

package/dist/vendor/lancedb/arrow.d.ts

@@ -208,7 +208,7 @@ export declare function makeEmptyTable(schema: SchemaLike, metadata?: Map<string
  * customized by the `embeddingDataType` property of the embedding function.
  *
  * If a schema is provided in `makeTableOptions` then it should include the
- * embedding columns.  If no schema is provded then embedding columns will
+ * embedding columns.  If no schema is provided then embedding columns will
  * be placed at the end of the table, after all of the input columns.
  */
 export declare function convertToTable(data: Array<Record<string, unknown>>, embeddings?: EmbeddingFunctionConfig, makeTableOptions?: Partial<MakeArrowTableOptions>): Promise<ArrowTable>;

package/dist/vendor/lancedb/arrow.js

@@ -57,6 +57,7 @@ exports.ensureNestedFieldsExist = ensureNestedFieldsExist;
 exports.dataTypeToJson = dataTypeToJson;
 const apache_arrow_1 = require("apache-arrow");
 const arrow_type_1 = require("./arrow_type");
+const blob_1 = require("./blob");
 const registry_1 = require("./embedding/registry");
 const sanitize_1 = require("./sanitize");
 const schema_1 = require("./schema");
@@ -348,17 +349,39 @@ function makeArrowTable(data, options, metadata) {
         }
         else {
             schema = new apache_arrow_1.Schema(schema.fields, schemaMetadata);
+            validateBlobSchema(schema);
             return new apache_arrow_1.Table(schema);
         }
     }
     let inferredSchema = (0, schema_1.inferSchema)(data, schema, opt);
     inferredSchema = new apache_arrow_1.Schema(inferredSchema.fields, schemaMetadata);
+    validateBlobSchema(inferredSchema);
     const finalColumns = {};
     for (const field of inferredSchema.fields) {
         finalColumns[field.name] = transposeData(data, field);
     }
     return new apache_arrow_1.Table(inferredSchema, finalColumns);
 }
+function validateBlobSchema(schema) {
+    for (const field of schema.fields) {
+        validateBlobField(field);
+    }
+}
+function validateBlobField(field) {
+    if (isFixedSizeList(field.type) &&
+        containsBlobField(field.type.children[0])) {
+        throw new Error("Blob fields inside FixedSizeList are not supported. Use List instead.");
+    }
+    for (const child of field.type.children ?? []) {
+        validateBlobField(child);
+    }
+}
+function containsBlobField(field) {
+    if ((0, blob_1.isBlobField)(field)) {
+        return true;
+    }
+    return (field.type.children ?? []).some((child) => containsBlobField(child));
+}
 function isObject(value) {
     return (typeof value === "object" &&
         value !== null &&
@@ -387,6 +410,27 @@ function valueAtPath(datum, path) {
 }
 function transposeData(data, field, path = []) {
     const valuesPath = [...path, field.name];
+    if ((0, blob_1.isBlobField)(field) && field.type instanceof apache_arrow_1.Struct) {
+        const blobRows = data.map((datum) => (0, blob_1.coerceBlobValue)(valueAtPath(datum, valuesPath)));
+        const childVectors = field.type.children.map((child) => {
+            const values = blobRows.map((row) => row == null ? null : (row[child.name] ?? null));
+            return makeVector(values, child.type, undefined, child.nullable);
+        });
+        const nullCount = blobRows.filter((row) => row === null).length;
+        const structData = (0, apache_arrow_1.makeData)({
+            type: field.type,
+            length: blobRows.length,
+            nullCount,
+            nullBitmap: nullCount > 0
+                ? apache_arrow_1.util.packBools(blobRows.map((row) => row !== null))
+                : undefined,
+            children: childVectors.map((v) => v.data[0]),
+        });
+        return (0, apache_arrow_1.makeVector)(structData);
+    }
+    if (isList(field.type) && containsBlobField(field.type.children[0])) {
+        return transposeListData(data, field, valuesPath);
+    }
     const values = data.map((datum) => valueAtPath(datum, valuesPath));
     if (field.type instanceof apache_arrow_1.Struct) {
         const childFields = field.type.children;
@@ -401,7 +445,7 @@ function transposeData(data, field, path = []) {
             nullBitmap: nullCount > 0
                 ? apache_arrow_1.util.packBools(values.map((value) => value !== null))
                 : undefined,
-            children: childVectors,
+            children: childVectors.map((v) => v.data[0]),
         });
         return (0, apache_arrow_1.makeVector)(structData);
     }
@@ -409,6 +453,39 @@ function transposeData(data, field, path = []) {
         return makeVector(values, field.type, undefined, field.nullable);
     }
 }
+function transposeListData(data, field, valuesPath) {
+    const listType = field.type;
+    const childField = listType.children[0];
+    const lists = data.map((datum) => valueAtPath(datum, valuesPath));
+    const flattened = [];
+    const validity = [];
+    const offsets = [0];
+    for (const list of lists) {
+        if (list == null) {
+            validity.push(false);
+            offsets.push(flattened.length);
+            continue;
+        }
+        if (!Array.isArray(list)) {
+            throw new Error(`expected an array for list field '${field.name}'`);
+        }
+        validity.push(true);
+        for (const element of list) {
+            flattened.push({ [childField.name]: element });
+        }
+        offsets.push(flattened.length);
+    }
+    const childVector = transposeData(flattened, childField, []);
+    const nullCount = validity.filter((valid) => !valid).length;
+    return (0, apache_arrow_1.makeVector)((0, apache_arrow_1.makeData)({
+        type: listType,
+        length: lists.length,
+        nullCount,
+        nullBitmap: nullCount > 0 ? apache_arrow_1.util.packBools(validity) : undefined,
+        valueOffsets: Int32Array.from(offsets),
+        child: childVector.data[0],
+    }));
+}
 /**
  * Create an empty Arrow table with the provided schema
  */
@@ -497,7 +574,7 @@ function makeVector(values, type, stringAsDictionary, nullable) {
         return vectorFromArray(values, type);
     }
     if (values.length === 0) {
-        throw Error("makeVector requires at least one value or the type must be specfied");
+        throw Error("makeVector requires at least one value or the type must be specified");
     }
     const sampleValue = values.find((val) => val !== null && val !== undefined);
     if (sampleValue === undefined) {
@@ -688,7 +765,7 @@ async function applyEmbeddings(table, embeddings, schema) {
  * customized by the `embeddingDataType` property of the embedding function.
  *
  * If a schema is provided in `makeTableOptions` then it should include the
- * embedding columns.  If no schema is provded then embedding columns will
+ * embedding columns.  If no schema is provided then embedding columns will
  * be placed at the end of the table, after all of the input columns.
  */
 async function convertToTable(data, embeddings, makeTableOptions) {
@@ -752,6 +829,7 @@ async function fromTableToBuffer(table, embeddings, schema) {
         schema = (0, sanitize_1.sanitizeSchema)(schema);
     }
     const tableWithEmbeddings = await applyEmbeddings(table, embeddings, schema);
+    validateBlobSchema(tableWithEmbeddings.schema);
     const writer = apache_arrow_1.RecordBatchFileWriter.writeAll(tableWithEmbeddings);
     return Buffer.from(await writer.toUint8Array());
 }

package/dist/vendor/lancedb/blob.d.ts

@@ -0,0 +1,92 @@
+import { Field } from "apache-arrow";
+import { BlobFile as NativeBlobFile } from "./native";
+export type BlobInput = {
+    data: Buffer | Uint8Array | null;
+    uri: string | null;
+};
+export type BlobOptions = {
+    /** Defaults to true. */
+    nullable?: boolean;
+    /**
+     * Max payload bytes kept inline in the data file. Zero is allowed. Must be a
+     * safe integer.
+     */
+    inlineSizeThreshold?: number;
+    /**
+     * Max payload bytes stored in a packed sidecar before a dedicated file. Must
+     * be a positive safe integer.
+     */
+    dedicatedSizeThreshold?: number;
+    /**
+     * Max bytes in one packed sidecar before starting another. Must be a positive
+     * safe integer.
+     */
+    packFileSizeThreshold?: number;
+};
+/**
+ * Declares a `lance.blob.v2` column.
+ *
+ * Query results are descriptors, not payload bytes. Use {@link Table.fetchBlobs}
+ * or {@link Table.fetchBlobFiles} to read bytes.
+ *
+ * @example
+ * ```ts
+ * import { readFile } from "node:fs/promises";
+ * import { Field, Int64, Schema } from "apache-arrow";
+ * import { blob, connect } from "@lancedb/lancedb";
+ *
+ * const db = await connect("./data");
+ * const video = await readFile("clip.mp4");
+ * const table = await db.createTable(
+ *   "videos",
+ *   [{ id: 1n, video }],
+ *   {
+ *     schema: new Schema([
+ *       new Field("id", new Int64()),
+ *       blob("video"),
+ *     ]),
+ *   },
+ * );
+ *
+ * const rows = await table.query().select(["id"]).withRowId().toArray();
+ * const rowIds = rows.map((row) => row._rowid as bigint);
+ * const bytes = await table.fetchBlobs("video", rowIds);
+ *
+ * const [handle] = await table.fetchBlobFiles("video", rowIds);
+ * const size = handle!.size();
+ * const header = await handle!.readRange(0n, size < 65536n ? size : 65536n);
+ * ```
+ */
+export declare function blob(name: string, options?: BlobOptions): Field;
+/**
+ * Checks for the `lance.blob.v2` extension marker. Does not validate the
+ * field's storage type.
+ */
+export declare function isBlobField(field: Field): boolean;
+/**
+ * A lazy handle to blob bytes. Create one with {@link Table.fetchBlobFiles}.
+ *
+ * @hideconstructor
+ */
+export declare class BlobFile {
+    private readonly inner;
+    private constructor();
+    /** @ignore */
+    static fromNative(inner: NativeBlobFile): BlobFile;
+    /** Returns the blob size in bytes. */
+    size(): bigint;
+    /**
+     * Reads from the cursor to the end and advances the cursor.
+     *
+     * A second call returns an empty buffer. {@link BlobFile.readRange} does
+     * not move the cursor.
+     */
+    read(): Promise<Buffer>;
+    /**
+     * Reads the half-open byte range `[start, end)`.
+     *
+     * Fails when `end` is past the blob size. Does not move the cursor.
+     */
+    readRange(start: bigint, end: bigint): Promise<Buffer>;
+}
+export declare function coerceBlobValue(value: unknown): BlobInput | null;

package/dist/vendor/lancedb/blob.js

@@ -0,0 +1,165 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlobFile = void 0;
+exports.blob = blob;
+exports.isBlobField = isBlobField;
+exports.coerceBlobValue = coerceBlobValue;
+const apache_arrow_1 = require("apache-arrow");
+const native_1 = require("./native");
+const BLOB_V2_EXTENSION_NAME = "lance.blob.v2";
+const INLINE_SIZE_THRESHOLD_KEY = "lance-encoding:blob-inline-size-threshold";
+const DEDICATED_SIZE_THRESHOLD_KEY = "lance-encoding:blob-dedicated-size-threshold";
+const PACK_FILE_SIZE_THRESHOLD_KEY = "lance-encoding:blob-pack-file-size-threshold";
+/**
+ * Declares a `lance.blob.v2` column.
+ *
+ * Query results are descriptors, not payload bytes. Use {@link Table.fetchBlobs}
+ * or {@link Table.fetchBlobFiles} to read bytes.
+ *
+ * @example
+ * ```ts
+ * import { readFile } from "node:fs/promises";
+ * import { Field, Int64, Schema } from "apache-arrow";
+ * import { blob, connect } from "@lancedb/lancedb";
+ *
+ * const db = await connect("./data");
+ * const video = await readFile("clip.mp4");
+ * const table = await db.createTable(
+ *   "videos",
+ *   [{ id: 1n, video }],
+ *   {
+ *     schema: new Schema([
+ *       new Field("id", new Int64()),
+ *       blob("video"),
+ *     ]),
+ *   },
+ * );
+ *
+ * const rows = await table.query().select(["id"]).withRowId().toArray();
+ * const rowIds = rows.map((row) => row._rowid as bigint);
+ * const bytes = await table.fetchBlobs("video", rowIds);
+ *
+ * const [handle] = await table.fetchBlobFiles("video", rowIds);
+ * const size = handle!.size();
+ * const header = await handle!.readRange(0n, size < 65536n ? size : 65536n);
+ * ```
+ */
+function blob(name, options = {}) {
+    const metadata = new Map([
+        ["ARROW:extension:name", BLOB_V2_EXTENSION_NAME],
+    ]);
+    setThreshold(metadata, INLINE_SIZE_THRESHOLD_KEY, "inlineSizeThreshold", options.inlineSizeThreshold, 0);
+    setThreshold(metadata, DEDICATED_SIZE_THRESHOLD_KEY, "dedicatedSizeThreshold", options.dedicatedSizeThreshold, 1);
+    setThreshold(metadata, PACK_FILE_SIZE_THRESHOLD_KEY, "packFileSizeThreshold", options.packFileSizeThreshold, 1);
+    return new apache_arrow_1.Field(name, new apache_arrow_1.Struct([
+        new apache_arrow_1.Field("data", new apache_arrow_1.LargeBinary(), true),
+        new apache_arrow_1.Field("uri", new apache_arrow_1.Utf8(), true),
+    ]), options.nullable ?? true, metadata);
+}
+/**
+ * Checks for the `lance.blob.v2` extension marker. Does not validate the
+ * field's storage type.
+ */
+function isBlobField(field) {
+    return field.metadata?.get("ARROW:extension:name") === BLOB_V2_EXTENSION_NAME;
+}
+/**
+ * A lazy handle to blob bytes. Create one with {@link Table.fetchBlobFiles}.
+ *
+ * @hideconstructor
+ */
+class BlobFile {
+    inner;
+    constructor(inner) {
+        if (!(inner instanceof native_1.BlobFile)) {
+            throw new Error("BlobFile handles come from Table.fetchBlobFiles");
+        }
+        this.inner = inner;
+    }
+    /** @ignore */
+    static fromNative(inner) {
+        return new BlobFile(inner);
+    }
+    /** Returns the blob size in bytes. */
+    size() {
+        return this.inner.size();
+    }
+    /**
+     * Reads from the cursor to the end and advances the cursor.
+     *
+     * A second call returns an empty buffer. {@link BlobFile.readRange} does
+     * not move the cursor.
+     */
+    read() {
+        return this.inner.read();
+    }
+    /**
+     * Reads the half-open byte range `[start, end)`.
+     *
+     * Fails when `end` is past the blob size. Does not move the cursor.
+     */
+    readRange(start, end) {
+        return this.inner.readRange(start, end);
+    }
+}
+exports.BlobFile = BlobFile;
+function coerceBlobValue(value) {
+    if (value == null) {
+        return null;
+    }
+    if (isBlobBytes(value)) {
+        return { data: value, uri: null };
+    }
+    if (ArrayBuffer.isView(value)) {
+        throw new Error("Blob data must be Buffer or Uint8Array");
+    }
+    if (typeof value === "string") {
+        if (value === "") {
+            throw new Error("Blob uri cannot be empty");
+        }
+        return { data: null, uri: value };
+    }
+    if (typeof value === "object") {
+        const record = value;
+        if (!("data" in record) && !("uri" in record)) {
+            throw new Error("Blob struct values must include a 'data' or 'uri' field");
+        }
+        const uri = record.uri;
+        if (uri === "") {
+            throw new Error("Blob uri cannot be empty");
+        }
+        if (uri != null && typeof uri !== "string") {
+            throw new Error(`Blob uri must be a string or null, got ${typeof uri}`);
+        }
+        const data = record.data;
+        if (data != null && !isBlobBytes(data)) {
+            throw new Error("Blob data must be Buffer, Uint8Array, or null");
+        }
+        const bytes = data ?? null;
+        const uriValue = uri ?? null;
+        if ((bytes == null) === (uriValue == null)) {
+            throw new Error("Blob struct values must set exactly one of 'data' or 'uri'");
+        }
+        return { data: bytes, uri: uriValue };
+    }
+    throw new Error("Blob column values must be Buffer, Uint8Array, a URI string, null, or { data?, uri? }");
+}
+function isBlobBytes(value) {
+    return Buffer.isBuffer(value) || value instanceof Uint8Array;
+}
+function setThreshold(metadata, key, optionName, value, minimum) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Number.isSafeInteger(value)) {
+        throw new Error(`${optionName} must be a safe integer`);
+    }
+    if (value < minimum) {
+        throw new Error(minimum <= 0
+            ? `${optionName} must be non-negative`
+            : `${optionName} must be positive`);
+    }
+    metadata.set(key, String(value));
+}