@lancedb/lancedb 0.15.1-beta.3 → 0.16.0

package/dist/arrow.d.ts

@@ -91,8 +91,6 @@ export declare class MakeArrowTableOptions {
  * This function converts an array of Record<String, any> (row-major JS objects)
  * to an Arrow Table (a columnar structure)
  *
- * Note that it currently does not support nulls.
- *
  * If a schema is provided then it will be used to determine the resulting array
  * types.  Fields will also be reordered to fit the order defined by the schema.
  *
@@ -100,6 +98,9 @@ export declare class MakeArrowTableOptions {
  * will be controlled by the order of properties in the first record.  If a type
  * is inferred it will always be nullable.
  *
+ * If not all fields are found in the data, then a subset of the schema will be
+ * returned.
+ *
  * If the input is empty then a schema must be provided to create an empty table.
  *
  * When a schema is not specified then data types will be inferred.  The inference
@@ -107,6 +108,7 @@ export declare class MakeArrowTableOptions {
  *
  *  - boolean => Bool
  *  - number => Float64
+ *  - bigint => Int64
  *  - String => Utf8
  *  - Buffer => Binary
  *  - Record<String, any> => Struct

package/dist/arrow.js

@@ -186,8 +186,6 @@ exports.MakeArrowTableOptions = MakeArrowTableOptions;
  * This function converts an array of Record<String, any> (row-major JS objects)
  * to an Arrow Table (a columnar structure)
  *
- * Note that it currently does not support nulls.
- *
  * If a schema is provided then it will be used to determine the resulting array
  * types.  Fields will also be reordered to fit the order defined by the schema.
  *
@@ -195,6 +193,9 @@ exports.MakeArrowTableOptions = MakeArrowTableOptions;
  * will be controlled by the order of properties in the first record.  If a type
  * is inferred it will always be nullable.
  *
+ * If not all fields are found in the data, then a subset of the schema will be
+ * returned.
+ *
  * If the input is empty then a schema must be provided to create an empty table.
  *
  * When a schema is not specified then data types will be inferred.  The inference
@@ -202,6 +203,7 @@ exports.MakeArrowTableOptions = MakeArrowTableOptions;
  *
  *  - boolean => Bool
  *  - number => Float64
+ *  - bigint => Int64
  *  - String => Utf8
  *  - Buffer => Binary
  *  - Record<String, any> => Struct
@@ -268,108 +270,286 @@ exports.MakeArrowTableOptions = MakeArrowTableOptions;
  * ```
  */
 function makeArrowTable(data, options, metadata) {
+    const opt = new MakeArrowTableOptions(options !== undefined ? options : {});
+    let schema = undefined;
+    if (opt.schema !== undefined && opt.schema !== null) {
+        schema = (0, sanitize_1.sanitizeSchema)(opt.schema);
+        schema = validateSchemaEmbeddings(schema, data, options?.embeddingFunction);
+    }
+    let schemaMetadata = schema?.metadata || new Map();
+    if (metadata !== undefined) {
+        schemaMetadata = new Map([...schemaMetadata, ...metadata]);
+    }
     if (data.length === 0 &&
         (options?.schema === undefined || options?.schema === null)) {
         throw new Error("At least one record or a schema needs to be provided");
     }
-    const opt = new MakeArrowTableOptions(options !== undefined ? options : {});
-    if (opt.schema !== undefined && opt.schema !== null) {
-        opt.schema = (0, sanitize_1.sanitizeSchema)(opt.schema);
-        opt.schema = validateSchemaEmbeddings(opt.schema, data, options?.embeddingFunction);
-    }
-    const columns = {};
-    // TODO: sample dataset to find missing columns
-    // Prefer the field ordering of the schema, if present
-    const columnNames = opt.schema != null ? opt.schema.names : Object.keys(data[0]);
-    for (const colName of columnNames) {
-        if (data.length !== 0 &&
-            !Object.prototype.hasOwnProperty.call(data[0], colName)) {
-            // The field is present in the schema, but not in the data, skip it
-            continue;
-        }
-        // Extract a single column from the records (transpose from row-major to col-major)
-        let values = data.map((datum) => datum[colName]);
-        // By default (type === undefined) arrow will infer the type from the JS type
-        let type;
-        if (opt.schema !== undefined) {
-            // If there is a schema provided, then use that for the type instead
-            type = opt.schema?.fields.filter((f) => f.name === colName)[0]?.type;
-            if (apache_arrow_1.DataType.isInt(type) && type.bitWidth === 64) {
-                // wrap in BigInt to avoid bug: https://github.com/apache/arrow/issues/40051
-                values = values.map((v) => {
-                    if (v === null) {
-                        return v;
+    else if (data.length === 0) {
+        if (schema === undefined) {
+            throw new Error("A schema must be provided if data is empty");
+        }
+        else {
+            schema = new apache_arrow_1.Schema(schema.fields, schemaMetadata);
+            return new apache_arrow_1.Table(schema);
+        }
+    }
+    let inferredSchema = inferSchema(data, schema, opt);
+    inferredSchema = new apache_arrow_1.Schema(inferredSchema.fields, schemaMetadata);
+    const finalColumns = {};
+    for (const field of inferredSchema.fields) {
+        finalColumns[field.name] = transposeData(data, field);
+    }
+    return new apache_arrow_1.Table(inferredSchema, finalColumns);
+}
+function inferSchema(data, schema, opts) {
+    // We will collect all fields we see in the data.
+    const pathTree = new PathTree();
+    for (const [rowI, row] of data.entries()) {
+        for (const [path, value] of rowPathsAndValues(row)) {
+            if (!pathTree.has(path)) {
+                // First time seeing this field.
+                if (schema !== undefined) {
+                    const field = getFieldForPath(schema, path);
+                    if (field === undefined) {
+                        throw new Error(`Found field not in schema: ${path.join(".")} at row ${rowI}`);
                     }
-                    if (typeof v === "bigint") {
-                        return v;
+                    else {
+                        pathTree.set(path, field.type);
                     }
-                    if (typeof v === "number") {
-                        return BigInt(v);
+                }
+                else {
+                    const inferredType = inferType(value, path, opts);
+                    if (inferredType === undefined) {
+                        throw new Error(`Failed to infer data type for field ${path.join(".")} at row ${rowI}. \
+                             Consider providing an explicit schema.`);
                     }
-                    throw new Error(`Expected BigInt or number for column ${colName}, got ${typeof v}`);
-                });
+                    pathTree.set(path, inferredType);
+                }
+            }
+            else if (schema === undefined) {
+                const currentType = pathTree.get(path);
+                const newType = inferType(value, path, opts);
+                if (currentType !== newType) {
+                    new Error(`Failed to infer schema for data. Previously inferred type \
+                     ${currentType} but found ${newType} at row ${rowI}. Consider \
+                     providing an explicit schema.`);
+                }
             }
         }
-        else {
-            // Otherwise, check to see if this column is one of the vector columns
-            // defined by opt.vectorColumns and, if so, use the fixed size list type
-            const vectorColumnOptions = opt.vectorColumns[colName];
-            if (vectorColumnOptions !== undefined) {
-                const firstNonNullValue = values.find((v) => v !== null);
-                if (Array.isArray(firstNonNullValue)) {
-                    type = newVectorType(firstNonNullValue.length, vectorColumnOptions.type);
+    }
+    if (schema === undefined) {
+        function fieldsFromPathTree(pathTree) {
+            const fields = [];
+            for (const [name, value] of pathTree.map.entries()) {
+                if (value instanceof PathTree) {
+                    const children = fieldsFromPathTree(value);
+                    fields.push(new apache_arrow_1.Field(name, new apache_arrow_1.Struct(children), true));
                 }
                 else {
-                    throw new Error(`Column ${colName} is expected to be a vector column but first non-null value is not an array.  Could not determine size of vector column`);
+                    fields.push(new apache_arrow_1.Field(name, value, true));
                 }
             }
+            return fields;
         }
-        try {
-            // Convert an Array of JS values to an arrow vector
-            columns[colName] = makeVector(values, type, opt.dictionaryEncodeStrings);
-        }
-        catch (error) {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-            throw Error(`Could not convert column "${colName}" to Arrow: ${error}`);
-        }
-    }
-    if (opt.schema != null) {
-        // `new ArrowTable(columns)` infers a schema which may sometimes have
-        // incorrect nullability (it assumes nullable=true always)
-        //
-        // `new ArrowTable(schema, columns)` will also fail because it will create a
-        // batch with an inferred schema and then complain that the batch schema
-        // does not match the provided schema.
-        //
-        // To work around this we first create a table with the wrong schema and
-        // then patch the schema of the batches so we can use
-        // `new ArrowTable(schema, batches)` which does not do any schema inference
-        const firstTable = new apache_arrow_1.Table(columns);
-        const batchesFixed = firstTable.batches.map((batch) => new apache_arrow_1.RecordBatch(opt.schema, batch.data));
-        let schema;
-        if (metadata !== undefined) {
-            let schemaMetadata = opt.schema.metadata;
-            if (schemaMetadata.size === 0) {
-                schemaMetadata = metadata;
-            }
-            else {
-                for (const [key, entry] of schemaMetadata.entries()) {
-                    schemaMetadata.set(key, entry);
+        const fields = fieldsFromPathTree(pathTree);
+        return new apache_arrow_1.Schema(fields);
+    }
+    else {
+        function takeMatchingFields(fields, pathTree) {
+            const outFields = [];
+            for (const field of fields) {
+                if (pathTree.map.has(field.name)) {
+                    const value = pathTree.get([field.name]);
+                    if (value instanceof PathTree) {
+                        const struct = field.type;
+                        const children = takeMatchingFields(struct.children, value);
+                        outFields.push(new apache_arrow_1.Field(field.name, new apache_arrow_1.Struct(children), field.nullable));
+                    }
+                    else {
+                        outFields.push(new apache_arrow_1.Field(field.name, value, field.nullable));
+                    }
                 }
             }
-            schema = new apache_arrow_1.Schema(opt.schema.fields, schemaMetadata);
+            return outFields;
+        }
+        const fields = takeMatchingFields(schema.fields, pathTree);
+        return new apache_arrow_1.Schema(fields);
+    }
+}
+function* rowPathsAndValues(row, basePath = []) {
+    for (const [key, value] of Object.entries(row)) {
+        if (isObject(value)) {
+            yield* rowPathsAndValues(value, [...basePath, key]);
         }
         else {
-            schema = opt.schema;
+            yield [[...basePath, key], value];
         }
-        return new apache_arrow_1.Table(schema, batchesFixed);
     }
-    const tbl = new apache_arrow_1.Table(columns);
-    if (metadata !== undefined) {
-        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-        tbl.schema.metadata = metadata;
+}
+function isObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof RegExp) &&
+        !(value instanceof Date) &&
+        !(value instanceof Set) &&
+        !(value instanceof Map) &&
+        !(value instanceof Buffer));
+}
+function getFieldForPath(schema, path) {
+    let current = schema;
+    for (const key of path) {
+        if (current instanceof apache_arrow_1.Schema) {
+            const field = current.fields.find((f) => f.name === key);
+            if (field === undefined) {
+                return undefined;
+            }
+            current = field;
+        }
+        else if (current instanceof apache_arrow_1.Field && apache_arrow_1.DataType.isStruct(current.type)) {
+            const struct = current.type;
+            const field = struct.children.find((f) => f.name === key);
+            if (field === undefined) {
+                return undefined;
+            }
+            current = field;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (current instanceof apache_arrow_1.Field) {
+        return current;
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * Try to infer which Arrow type to use for a given value.
+ *
+ * May return undefined if the type cannot be inferred.
+ */
+function inferType(value, path, opts) {
+    if (typeof value === "bigint") {
+        return new apache_arrow_1.Int64();
+    }
+    else if (typeof value === "number") {
+        // Even if it's an integer, it's safer to assume Float64. Users can
+        // always provide an explicit schema or use BigInt if they mean integer.
+        return new apache_arrow_1.Float64();
+    }
+    else if (typeof value === "string") {
+        if (opts.dictionaryEncodeStrings) {
+            return new apache_arrow_1.Dictionary(new apache_arrow_1.Utf8(), new apache_arrow_1.Int32());
+        }
+        else {
+            return new apache_arrow_1.Utf8();
+        }
+    }
+    else if (typeof value === "boolean") {
+        return new apache_arrow_1.Bool();
+    }
+    else if (value instanceof Buffer) {
+        return new apache_arrow_1.Binary();
+    }
+    else if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return undefined; // Without any values we can't infer the type
+        }
+        if (path.length === 1 && Object.hasOwn(opts.vectorColumns, path[0])) {
+            const floatType = (0, sanitize_1.sanitizeType)(opts.vectorColumns[path[0]].type);
+            return new apache_arrow_1.FixedSizeList(value.length, new apache_arrow_1.Field("item", floatType, true));
+        }
+        const valueType = inferType(value[0], path, opts);
+        if (valueType === undefined) {
+            return undefined;
+        }
+        // Try to automatically detect embedding columns.
+        if (valueType instanceof apache_arrow_1.Float && path[path.length - 1] === "vector") {
+            // We default to Float32 for vectors.
+            const child = new apache_arrow_1.Field("item", new apache_arrow_1.Float32(), true);
+            return new apache_arrow_1.FixedSizeList(value.length, child);
+        }
+        else {
+            const child = new apache_arrow_1.Field("item", valueType, true);
+            return new apache_arrow_1.List(child);
+        }
+    }
+    else {
+        // TODO: timestamp
+        return undefined;
+    }
+}
+class PathTree {
+    map;
+    constructor(entries) {
+        this.map = new Map();
+        if (entries !== undefined) {
+            for (const [path, value] of entries) {
+                this.set(path, value);
+            }
+        }
+    }
+    has(path) {
+        let ref = this;
+        for (const part of path) {
+            if (!(ref instanceof PathTree) || !ref.map.has(part)) {
+                return false;
+            }
+            ref = ref.map.get(part);
+        }
+        return true;
+    }
+    get(path) {
+        let ref = this;
+        for (const part of path) {
+            if (!(ref instanceof PathTree) || !ref.map.has(part)) {
+                return undefined;
+            }
+            ref = ref.map.get(part);
+        }
+        return ref;
+    }
+    set(path, value) {
+        let ref = this;
+        for (const part of path.slice(0, path.length - 1)) {
+            if (!ref.map.has(part)) {
+                ref.map.set(part, new PathTree());
+            }
+            ref = ref.map.get(part);
+        }
+        ref.map.set(path[path.length - 1], value);
+    }
+}
+function transposeData(data, field, path = []) {
+    if (field.type instanceof apache_arrow_1.Struct) {
+        const childFields = field.type.children;
+        const childVectors = childFields.map((child) => {
+            return transposeData(data, child, [...path, child.name]);
+        });
+        const structData = (0, apache_arrow_1.makeData)({
+            type: field.type,
+            children: childVectors,
+        });
+        return (0, apache_arrow_1.makeVector)(structData);
+    }
+    else {
+        const valuesPath = [...path, field.name];
+        const values = data.map((datum) => {
+            let current = datum;
+            for (const key of valuesPath) {
+                if (isObject(current) && Object.hasOwn(current, key)) {
+                    current = current[key];
+                }
+                else {
+                    return null;
+                }
+            }
+            return current;
+        });
+        return makeVector(values, field.type);
     }
-    return tbl;
 }
 /**
  * Create an empty Arrow table with the provided schema
@@ -408,6 +588,36 @@ function makeListVector(lists) {
 function makeVector(values, type, stringAsDictionary) {
     if (type !== undefined) {
         // No need for inference, let Arrow create it
+        if (type instanceof apache_arrow_1.Int) {
+            if (apache_arrow_1.DataType.isInt(type) && type.bitWidth === 64) {
+                // wrap in BigInt to avoid bug: https://github.com/apache/arrow/issues/40051
+                values = values.map((v) => {
+                    if (v === null) {
+                        return v;
+                    }
+                    else if (typeof v === "bigint") {
+                        return v;
+                    }
+                    else if (typeof v === "number") {
+                        return BigInt(v);
+                    }
+                    else {
+                        return v;
+                    }
+                });
+            }
+            else {
+                // Similarly, bigint isn't supported for 16 or 32-bit ints.
+                values = values.map((v) => {
+                    if (typeof v == "bigint") {
+                        return Number(v);
+                    }
+                    else {
+                        return v;
+                    }
+                });
+            }
+        }
         return (0, apache_arrow_1.vectorFromArray)(values, type);
     }
     if (values.length === 0) {

package/dist/connection.d.ts

@@ -32,6 +32,8 @@ export interface CreateTableOptions {
      *
      * The default is `stable`.
      * Set to "legacy" to use the old format.
+     *
+     * @deprecated Pass `new_table_data_storage_version` to storageOptions instead.
      */
     dataStorageVersion?: string;
     /**
@@ -40,16 +42,10 @@ export interface CreateTableOptions {
      * turning this on will make the dataset unreadable for older versions
      * of LanceDB (prior to 0.10.0). To migrate an existing dataset, instead
      * use the {@link LocalTable#migrateManifestPathsV2} method.
-     */
-    enableV2ManifestPaths?: boolean;
-    /**
-     * If true then data files will be written with the legacy format
      *
-     * The default is false.
-     *
-     * Deprecated. Use data storage version instead.
+     * @deprecated Pass `new_table_enable_v2_manifest_paths` to storageOptions instead.
      */
-    useLegacyFormat?: boolean;
+    enableV2ManifestPaths?: boolean;
     schema?: SchemaLike;
     embeddingFunction?: EmbeddingFunctionConfig;
 }
@@ -167,6 +163,10 @@ export declare abstract class Connection {
      * @param {string} name The name of the table to drop.
      */
     abstract dropTable(name: string): Promise<void>;
+    /**
+     * Drop all tables in the database.
+     */
+    abstract dropAllTables(): Promise<void>;
 }
 /** @hideconstructor */
 export declare class LocalConnection extends Connection {
@@ -178,12 +178,14 @@ export declare class LocalConnection extends Connection {
     display(): string;
     tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
     openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    private getStorageOptions;
     createTable(nameOrOptions: string | ({
         name: string;
         data: Data;
     } & Partial<CreateTableOptions>), data?: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     createEmptyTable(name: string, schema: import("./arrow").SchemaLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     dropTable(name: string): Promise<void>;
+    dropAllTables(): Promise<void>;
 }
 /**
  * Takes storage options and makes all the keys snake case.

package/dist/connection.js

@@ -58,6 +58,23 @@ class LocalConnection extends Connection {
         const innerTable = await this.inner.openTable(name, cleanseStorageOptions(options?.storageOptions), options?.indexCacheSize);
         return new table_1.LocalTable(innerTable);
     }
+    getStorageOptions(options) {
+        if (options?.dataStorageVersion !== undefined) {
+            if (options.storageOptions === undefined) {
+                options.storageOptions = {};
+            }
+            options.storageOptions["newTableDataStorageVersion"] =
+                options.dataStorageVersion;
+        }
+        if (options?.enableV2ManifestPaths !== undefined) {
+            if (options.storageOptions === undefined) {
+                options.storageOptions = {};
+            }
+            options.storageOptions["newTableEnableV2ManifestPaths"] =
+                options.enableV2ManifestPaths ? "true" : "false";
+        }
+        return cleanseStorageOptions(options?.storageOptions);
+    }
     async createTable(nameOrOptions, data, options) {
         if (typeof nameOrOptions !== "string" && "name" in nameOrOptions) {
             const { name, data, ...options } = nameOrOptions;
@@ -67,14 +84,8 @@ class LocalConnection extends Connection {
             throw new Error("data is required");
         }
         const { buf, mode } = await parseTableData(data, options);
-        let dataStorageVersion = "stable";
-        if (options?.dataStorageVersion !== undefined) {
-            dataStorageVersion = options.dataStorageVersion;
-        }
-        else if (options?.useLegacyFormat !== undefined) {
-            dataStorageVersion = options.useLegacyFormat ? "legacy" : "stable";
-        }
-        const innerTable = await this.inner.createTable(nameOrOptions, buf, mode, cleanseStorageOptions(options?.storageOptions), dataStorageVersion, options?.enableV2ManifestPaths);
+        const storageOptions = this.getStorageOptions(options);
+        const innerTable = await this.inner.createTable(nameOrOptions, buf, mode, storageOptions);
         return new table_1.LocalTable(innerTable);
     }
     async createEmptyTable(name, schema, options) {
@@ -89,21 +100,18 @@ class LocalConnection extends Connection {
             const registry = (0, registry_1.getRegistry)();
             metadata = registry.getTableMetadata([embeddingFunction]);
         }
-        let dataStorageVersion = "stable";
-        if (options?.dataStorageVersion !== undefined) {
-            dataStorageVersion = options.dataStorageVersion;
-        }
-        else if (options?.useLegacyFormat !== undefined) {
-            dataStorageVersion = options.useLegacyFormat ? "legacy" : "stable";
-        }
+        const storageOptions = this.getStorageOptions(options);
         const table = (0, arrow_2.makeEmptyTable)(schema, metadata);
         const buf = await (0, arrow_2.fromTableToBuffer)(table);
-        const innerTable = await this.inner.createEmptyTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions), dataStorageVersion, options?.enableV2ManifestPaths);
+        const innerTable = await this.inner.createEmptyTable(name, buf, mode, storageOptions);
         return new table_1.LocalTable(innerTable);
     }
     async dropTable(name) {
         return this.inner.dropTable(name);
     }
+    async dropAllTables() {
+        return this.inner.dropAllTables();
+    }
 }
 exports.LocalConnection = LocalConnection;
 /**

package/dist/native.d.ts

@@ -77,6 +77,7 @@ export interface ClientConfig {
   userAgent?: string
   retryConfig?: RetryConfig
   timeoutConfig?: TimeoutConfig
+  extraHeaders?: Record<string, string>
 }
 export interface RerankerCallbacks {
   rerankHybrid: (...args: any[]) => any
@@ -247,11 +248,12 @@ export class Connection {
    * - buf: The buffer containing the IPC file.
    *
    */
-  createTable(name: string, buf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null, dataStorageOptions?: string | undefined | null, enableV2ManifestPaths?: boolean | undefined | null): Promise<Table>
-  createEmptyTable(name: string, schemaBuf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null, dataStorageOptions?: string | undefined | null, enableV2ManifestPaths?: boolean | undefined | null): Promise<Table>
+  createTable(name: string, buf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null): Promise<Table>
+  createEmptyTable(name: string, schemaBuf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null): Promise<Table>
   openTable(name: string, storageOptions?: Record<string, string> | undefined | null, indexCacheSize?: number | undefined | null): Promise<Table>
   /** Drop table with the name. Or raise an error if the table does not exist. */
   dropTable(name: string): Promise<void>
+  dropAllTables(): Promise<void>
 }
 export class Index {
   static ivfPq(distanceType?: string | undefined | null, numPartitions?: number | undefined | null, numSubVectors?: number | undefined | null, numBits?: number | undefined | null, maxIterations?: number | undefined | null, sampleRate?: number | undefined | null): Index

package/package.json

@@ -11,7 +11,7 @@
     "ann"
   ],
   "private": false,
-  "version": "0.15.1-beta.3",
+  "version": "0.16.0",
   "main": "dist/index.js",
   "exports": {
     ".": "./dist/index.js",
@@ -98,14 +98,14 @@
     "reflect-metadata": "^0.2.2"
   },
   "optionalDependencies": {
-    "@lancedb/lancedb-darwin-x64": "0.15.1-beta.3",
-    "@lancedb/lancedb-darwin-arm64": "0.15.1-beta.3",
-    "@lancedb/lancedb-linux-x64-gnu": "0.15.1-beta.3",
-    "@lancedb/lancedb-linux-arm64-gnu": "0.15.1-beta.3",
-    "@lancedb/lancedb-linux-x64-musl": "0.15.1-beta.3",
-    "@lancedb/lancedb-linux-arm64-musl": "0.15.1-beta.3",
-    "@lancedb/lancedb-win32-x64-msvc": "0.15.1-beta.3",
-    "@lancedb/lancedb-win32-arm64-msvc": "0.15.1-beta.3"
+    "@lancedb/lancedb-darwin-x64": "0.16.0",
+    "@lancedb/lancedb-darwin-arm64": "0.16.0",
+    "@lancedb/lancedb-linux-x64-gnu": "0.16.0",
+    "@lancedb/lancedb-linux-arm64-gnu": "0.16.0",
+    "@lancedb/lancedb-linux-x64-musl": "0.16.0",
+    "@lancedb/lancedb-linux-arm64-musl": "0.16.0",
+    "@lancedb/lancedb-win32-x64-msvc": "0.16.0",
+    "@lancedb/lancedb-win32-arm64-msvc": "0.16.0"
   },
   "peerDependencies": {
     "apache-arrow": ">=15.0.0 <=18.1.0"