@lancedb/lancedb 0.7.0 → 0.8.0

package/dist/arrow.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Table as ArrowTable, Binary, BufferType, DataType, Field, FixedSizeBinary, FixedSizeList, Float, Int, LargeBinary, List, Null, RecordBatch, Schema, Struct, Utf8 } from "apache-arrow";
+import { Table as ArrowTable, Binary, BufferType, Field, FixedSizeBinary, FixedSizeList, Float, Int, LargeBinary, List, Null, RecordBatch, Schema, Struct, Utf8 } from "apache-arrow";
 import { Buffers } from "apache-arrow/data";
 import { type EmbeddingFunction } from "./embedding/embedding_function";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
@@ -37,8 +37,10 @@ export type TableLike = ArrowTable | {
     batches: RecordBatchLike[];
 };
 export type IntoVector = Float32Array | Float64Array | number[] | Promise<Float32Array | Float64Array | number[]>;
+export type FloatLike = import("apache-arrow-13").Float | import("apache-arrow-14").Float | import("apache-arrow-15").Float | import("apache-arrow-16").Float | import("apache-arrow-17").Float;
+export type DataTypeLike = import("apache-arrow-13").DataType | import("apache-arrow-14").DataType | import("apache-arrow-15").DataType | import("apache-arrow-16").DataType | import("apache-arrow-17").DataType;
 export declare function isArrowTable(value: object): value is TableLike;
-export declare function isDataType(value: unknown): value is DataType;
+export declare function isDataType(value: unknown): value is DataTypeLike;
 export declare function isNull(value: unknown): value is Null;
 export declare function isInt(value: unknown): value is Int;
 export declare function isFloat(value: unknown): value is Float;
@@ -200,7 +202,7 @@ export declare function makeEmptyTable(schema: SchemaLike, metadata?: Map<string
  */
 export declare function convertToTable(data: Array<Record<string, unknown>>, embeddings?: EmbeddingFunctionConfig, makeTableOptions?: Partial<MakeArrowTableOptions>): Promise<ArrowTable>;
 /** Creates the Arrow Type for a Vector column with dimension `dim` */
-export declare function newVectorType<T extends Float>(dim: number, innerType: T): FixedSizeList<T>;
+export declare function newVectorType<T extends Float>(dim: number, innerType: unknown): FixedSizeList<T>;
 /**
  * Serialize an Array of records into a buffer using the Arrow IPC File serialization
  *

package/dist/arrow.js

@@ -466,7 +466,7 @@ function makeVector(values, type, stringAsDictionary) {
 /** Helper function to apply embeddings from metadata to an input table */
 async function applyEmbeddingsFromMetadata(table, schema) {
     const registry = (0, registry_1.getRegistry)();
-    const functions = registry.parseFunctions(schema.metadata);
+    const functions = await registry.parseFunctions(schema.metadata);
     const columns = Object.fromEntries(table.schema.fields.map((field) => [
         field.name,
         table.getChild(field.name),

package/dist/embedding/embedding_function.d.ts

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { DataType, Float, type IntoVector } from "../arrow";
+import { DataType, DataTypeLike, FloatLike, type IntoVector } from "../arrow";
 /**
  * Options for a given embedding function
  */
@@ -44,6 +44,7 @@ export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptio
      * ```
      */
     abstract toJSON(): Partial<M>;
+    init?(): Promise<void>;
     /**
      * sourceField is used in combination with `LanceSchema` to provide a declarative data model
      *
@@ -51,7 +52,7 @@ export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptio
      *
      * @see {@link lancedb.LanceSchema}
      */
-    sourceField(optionsOrDatatype: Partial<FieldOptions> | DataType): [DataType, Map<string, EmbeddingFunction>];
+    sourceField(optionsOrDatatype: Partial<FieldOptions> | DataTypeLike): [DataTypeLike, Map<string, EmbeddingFunction>];
     /**
      * vectorField is used in combination with `LanceSchema` to provide a declarative data model
      *
@@ -63,7 +64,7 @@ export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptio
     /** The number of dimensions of the embeddings */
     ndims(): number | undefined;
     /** The datatype of the embeddings */
-    abstract embeddingDataType(): Float;
+    abstract embeddingDataType(): FloatLike;
     /**
      * Creates a vector representation for the given values.
      */

package/dist/embedding/index.d.ts

@@ -2,6 +2,7 @@ import { Schema } from "../arrow";
 import { EmbeddingFunction } from "./embedding_function";
 export { EmbeddingFunction } from "./embedding_function";
 export * from "./openai";
+export * from "./transformers";
 export * from "./registry";
 /**
  * Create a schema with embedding functions.

package/dist/embedding/index.js

@@ -36,6 +36,7 @@ var embedding_function_1 = require("./embedding_function");
 Object.defineProperty(exports, "EmbeddingFunction", { enumerable: true, get: function () { return embedding_function_1.EmbeddingFunction; } });
 // We need to explicitly export '*' so that the `register` decorator actually registers the class.
 __exportStar(require("./openai"), exports);
+__exportStar(require("./transformers"), exports);
 __exportStar(require("./registry"), exports);
 /**
  * Create a schema with embedding functions.

package/dist/embedding/registry.d.ts

@@ -1,8 +1,12 @@
 import { type EmbeddingFunction, type EmbeddingFunctionConstructor } from "./embedding_function";
 import "reflect-metadata";
 import { OpenAIEmbeddingFunction } from "./openai";
+import { TransformersEmbeddingFunction } from "./transformers";
+type CreateReturnType<T> = T extends {
+    init: () => Promise<void>;
+} ? Promise<T> : T;
 interface EmbeddingFunctionCreate<T extends EmbeddingFunction> {
-    create(options?: T["TOptions"]): T;
+    create(options?: T["TOptions"]): CreateReturnType<T>;
 }
 /**
  * This is a singleton class used to register embedding functions
@@ -19,11 +23,9 @@ export declare class EmbeddingFunctionRegistry {
      * @throws Error if the function is already registered
      */
     register<T extends EmbeddingFunctionConstructor = EmbeddingFunctionConstructor>(this: EmbeddingFunctionRegistry, alias?: string): (ctor: T) => any;
-    /**
-     * Fetch an embedding function by name
-     * @param name The name of the function
-     */
-    get<T extends EmbeddingFunction<unknown>, Name extends string = "">(name: Name extends "openai" ? "openai" : string): Name extends "openai" ? EmbeddingFunctionCreate<OpenAIEmbeddingFunction> : EmbeddingFunctionCreate<T> | undefined;
+    get(name: "openai"): EmbeddingFunctionCreate<OpenAIEmbeddingFunction>;
+    get(name: "huggingface"): EmbeddingFunctionCreate<TransformersEmbeddingFunction>;
+    get<T extends EmbeddingFunction<unknown>>(name: string): EmbeddingFunctionCreate<T> | undefined;
     /**
      * reset the registry to the initial state
      */
@@ -31,7 +33,7 @@ export declare class EmbeddingFunctionRegistry {
     /**
      * @ignore
      */
-    parseFunctions(this: EmbeddingFunctionRegistry, metadata: Map<string, string>): Map<string, EmbeddingFunctionConfig>;
+    parseFunctions(this: EmbeddingFunctionRegistry, metadata: Map<string, string>): Promise<Map<string, EmbeddingFunctionConfig>>;
     functionToMetadata(conf: EmbeddingFunctionConfig): Record<string, any>;
     getTableMetadata(functions: EmbeddingFunctionConfig[]): Map<string, string>;
 }

package/dist/embedding/registry.js

@@ -50,12 +50,28 @@ class EmbeddingFunctionRegistry {
     get(name) {
         const factory = this.#functions.get(name);
         if (!factory) {
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
             return undefined;
         }
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        let create;
+        if (factory.prototype.init) {
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            create = async function (options) {
+                const instance = new factory(options);
+                await instance.init();
+                return instance;
+            };
+        }
+        else {
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            create = function (options) {
+                const instance = new factory(options);
+                return instance;
+            };
+        }
         return {
-            create: function (options) {
-                return new factory(options);
-            },
+            create,
         };
     }
     /**
@@ -67,26 +83,28 @@ class EmbeddingFunctionRegistry {
     /**
      * @ignore
      */
-    parseFunctions(metadata) {
+    async parseFunctions(metadata) {
         if (!metadata.has("embedding_functions")) {
             return new Map();
         }
         else {
             const functions = (JSON.parse(metadata.get("embedding_functions")));
-            return new Map(functions.map((f) => {
+            const items = await Promise.all(functions.map(async (f) => {
                 const fn = this.get(f.name);
                 if (!fn) {
                     throw new Error(`Function "${f.name}" not found in registry`);
                 }
+                const func = await this.get(f.name).create(f.model);
                 return [
                     f.name,
                     {
                         sourceColumn: f.sourceColumn,
                         vectorColumn: f.vectorColumn,
-                        function: this.get(f.name).create(f.model),
+                        function: func,
                     },
                 ];
             }));
+            return new Map(items);
         }
     }
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>

package/dist/embedding/transformers.d.ts

@@ -0,0 +1,37 @@
+import { Float } from "../arrow";
+import { EmbeddingFunction } from "./embedding_function";
+export type XenovaTransformerOptions = {
+    /** The wasm compatible model to use */
+    model: string;
+    /**
+     * The wasm compatible tokenizer to use
+     * If not provided, it will use the default tokenizer for the model
+     */
+    tokenizer?: string;
+    /**
+     * The number of dimensions of the embeddings
+     *
+     * We will attempt to infer this from the model config if not provided.
+     * Since there isn't a standard way to get this information from the model,
+     * you may need to manually specify this if using a model that doesn't have a 'hidden_size' in the config.
+     * */
+    ndims?: number;
+    /** Options for the tokenizer */
+    tokenizerOptions?: {
+        textPair?: string | string[];
+        padding?: boolean | "max_length";
+        addSpecialTokens?: boolean;
+        truncation?: boolean;
+        maxLength?: number;
+    };
+};
+export declare class TransformersEmbeddingFunction extends EmbeddingFunction<string, Partial<XenovaTransformerOptions>> {
+    #private;
+    constructor(options?: Partial<XenovaTransformerOptions>);
+    toJSON(): Record<string, any>;
+    init(): Promise<void>;
+    ndims(): number;
+    embeddingDataType(): Float;
+    computeSourceEmbeddings(data: string[]): Promise<number[][]>;
+    computeQueryEmbeddings(data: string): Promise<number[]>;
+}

package/dist/embedding/transformers.js

@@ -0,0 +1,147 @@
+"use strict";
+// Copyright 2023 Lance Developers.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformersEmbeddingFunction = void 0;
+const arrow_1 = require("../arrow");
+const embedding_function_1 = require("./embedding_function");
+const registry_1 = require("./registry");
+let TransformersEmbeddingFunction = class TransformersEmbeddingFunction extends embedding_function_1.EmbeddingFunction {
+    #model;
+    #tokenizer;
+    #modelName;
+    #initialized = false;
+    #tokenizerOptions;
+    #ndims;
+    constructor(options = {
+        model: "Xenova/all-MiniLM-L6-v2",
+    }) {
+        super();
+        const modelName = options?.model ?? "Xenova/all-MiniLM-L6-v2";
+        this.#tokenizerOptions = {
+            padding: true,
+            ...options.tokenizerOptions,
+        };
+        this.#ndims = options.ndims;
+        this.#modelName = modelName;
+    }
+    toJSON() {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        const obj = {
+            model: this.#modelName,
+        };
+        if (this.#ndims) {
+            obj["ndims"] = this.#ndims;
+        }
+        if (this.#tokenizerOptions) {
+            obj["tokenizerOptions"] = this.#tokenizerOptions;
+        }
+        if (this.#tokenizer) {
+            obj["tokenizer"] = this.#tokenizer.name;
+        }
+        return obj;
+    }
+    async init() {
+        let transformers;
+        try {
+            // SAFETY:
+            // since typescript transpiles `import` to `require`, we need to do this in an unsafe way
+            // We can't use `require` because `@xenova/transformers` is an ESM module
+            // and we can't use `import` directly because typescript will transpile it to `require`.
+            // and we want to remain compatible with both ESM and CJS modules
+            // so we use `eval` to bypass typescript for this specific import.
+            transformers = await eval('import("@xenova/transformers")');
+        }
+        catch (e) {
+            throw new Error(`error loading @xenova/transformers\nReason: ${e}`);
+        }
+        try {
+            this.#model = await transformers.AutoModel.from_pretrained(this.#modelName);
+        }
+        catch (e) {
+            throw new Error(`error loading model ${this.#modelName}. Make sure you are using a wasm compatible model.\nReason: ${e}`);
+        }
+        try {
+            this.#tokenizer = await transformers.AutoTokenizer.from_pretrained(this.#modelName);
+        }
+        catch (e) {
+            throw new Error(`error loading tokenizer for ${this.#modelName}. Make sure you are using a wasm compatible model:\nReason: ${e}`);
+        }
+        this.#initialized = true;
+    }
+    ndims() {
+        if (this.#ndims) {
+            return this.#ndims;
+        }
+        else {
+            const config = this.#model.config;
+            const ndims = config["hidden_size"];
+            if (!ndims) {
+                throw new Error("hidden_size not found in model config, you may need to manually specify the embedding dimensions. ");
+            }
+            return ndims;
+        }
+    }
+    embeddingDataType() {
+        return new arrow_1.Float32();
+    }
+    async computeSourceEmbeddings(data) {
+        // this should only happen if the user is trying to use the function directly.
+        // Anything going through the registry should already be initialized.
+        if (!this.#initialized) {
+            return Promise.reject(new Error("something went wrong: embedding function not initialized. Please call init()"));
+        }
+        const tokenizer = this.#tokenizer;
+        const model = this.#model;
+        const inputs = await tokenizer(data, this.#tokenizerOptions);
+        let tokens = await model.forward(inputs);
+        tokens = tokens[Object.keys(tokens)[0]];
+        const [nItems, nTokens] = tokens.dims;
+        tokens = tensorDiv(tokens.sum(1), nTokens);
+        // TODO: support other data types
+        const tokenData = tokens.data;
+        const stride = this.ndims();
+        const embeddings = [];
+        for (let i = 0; i < nItems; i++) {
+            const start = i * stride;
+            const end = start + stride;
+            const slice = tokenData.slice(start, end);
+            embeddings.push(Array.from(slice)); // TODO: Avoid copy here
+        }
+        return embeddings;
+    }
+    async computeQueryEmbeddings(data) {
+        return (await this.computeSourceEmbeddings([data]))[0];
+    }
+};
+exports.TransformersEmbeddingFunction = TransformersEmbeddingFunction;
+exports.TransformersEmbeddingFunction = TransformersEmbeddingFunction = __decorate([
+    (0, registry_1.register)("huggingface"),
+    __metadata("design:paramtypes", [Object])
+], TransformersEmbeddingFunction);
+const tensorDiv = (src, divBy) => {
+    for (let i = 0; i < src.data.length; ++i) {
+        src.data[i] /= divBy;
+    }
+    return src;
+};

package/dist/query.js

@@ -129,22 +129,28 @@ class QueryBase {
      * object insertion order is easy to get wrong and `Map` is more foolproof.
      */
     select(columns) {
-        let columnTuples;
+        const selectColumns = (columnArray) => {
+            this.doCall((inner) => {
+                inner.selectColumns(columnArray);
+            });
+        };
+        const selectMapping = (columnTuples) => {
+            this.doCall((inner) => {
+                inner.select(columnTuples);
+            });
+        };
         if (typeof columns === "string") {
-            columns = [columns];
+            selectColumns([columns]);
         }
-        if (Array.isArray(columns)) {
-            columnTuples = columns.map((c) => [c, c]);
+        else if (Array.isArray(columns)) {
+            selectColumns(columns);
         }
         else if (columns instanceof Map) {
-            columnTuples = Array.from(columns.entries());
+            selectMapping(Array.from(columns.entries()));
         }
         else {
-            columnTuples = Object.entries(columns);
+            selectMapping(Object.entries(columns));
         }
-        this.doCall((inner) => {
-            inner.select(columnTuples);
-        });
         return this;
     }
     /**

package/dist/remote/client.d.ts

@@ -4,7 +4,7 @@ import { Table as ArrowTable } from "../arrow";
 import { VectorQuery } from "../query";
 export declare class RestfulLanceDBClient {
     #private;
-    constructor(dbName: string, apiKey: string, region: string, hostOverride?: string, connectionTimeout?: number, readTimeout?: number);
+    constructor(dbName: string, apiKey: string, region: string, hostOverride?: string, timeout?: number);
     get session(): import("axios").AxiosInstance;
     get url(): string;
     get headers(): {

package/dist/remote/client.js

@@ -22,16 +22,14 @@ class RestfulLanceDBClient {
     #apiKey;
     #hostOverride;
     #closed = false;
-    #connectionTimeout = 12 * 1000; // 12 seconds;
-    #readTimeout = 30 * 1000; // 30 seconds;
+    #timeout = 12 * 1000; // 12 seconds;
     #session;
-    constructor(dbName, apiKey, region, hostOverride, connectionTimeout, readTimeout) {
+    constructor(dbName, apiKey, region, hostOverride, timeout) {
         this.#dbName = dbName;
         this.#apiKey = apiKey;
         this.#region = region;
         this.#hostOverride = hostOverride ?? this.#hostOverride;
-        this.#connectionTimeout = connectionTimeout ?? this.#connectionTimeout;
-        this.#readTimeout = readTimeout ?? this.#readTimeout;
+        this.#timeout = timeout ?? this.#timeout;
     }
     // todo: cache the session.
     get session() {
@@ -46,7 +44,7 @@ class RestfulLanceDBClient {
                     Authorization: `Bearer ${this.#apiKey}`,
                 },
                 transformResponse: decodeErrorData,
-                timeout: this.#connectionTimeout,
+                timeout: this.#timeout,
             });
         }
     }
@@ -91,7 +89,7 @@ class RestfulLanceDBClient {
             });
         }
         catch (e) {
-            if (e instanceof axios_1.AxiosError) {
+            if (e instanceof axios_1.AxiosError && e.response) {
                 response = e.response;
             }
             else {
@@ -120,7 +118,7 @@ class RestfulLanceDBClient {
             });
         }
         catch (e) {
-            if (e instanceof axios_1.AxiosError) {
+            if (e instanceof axios_1.AxiosError && e.response) {
                 response = e.response;
             }
             else {

package/dist/remote/connection.d.ts

@@ -5,12 +5,11 @@ export interface RemoteConnectionOptions {
     apiKey?: string;
     region?: string;
     hostOverride?: string;
-    connectionTimeout?: number;
-    readTimeout?: number;
+    timeout?: number;
 }
 export declare class RemoteConnection extends Connection {
     #private;
-    constructor(url: string, { apiKey, region, hostOverride, connectionTimeout, readTimeout, }: RemoteConnectionOptions);
+    constructor(url: string, { apiKey, region, hostOverride, timeout }: RemoteConnectionOptions);
     isOpen(): boolean;
     close(): void;
     display(): string;

package/dist/remote/connection.js

@@ -13,7 +13,7 @@ class RemoteConnection extends connection_1.Connection {
     #region;
     #client;
     #tableCache = new util_1.TTLCache(300000);
-    constructor(url, { apiKey, region, hostOverride, connectionTimeout, readTimeout, }) {
+    constructor(url, { apiKey, region, hostOverride, timeout }) {
         super();
         apiKey = apiKey ?? process.env.LANCEDB_API_KEY;
         region = region ?? process.env.LANCEDB_REGION;
@@ -30,7 +30,7 @@ class RemoteConnection extends connection_1.Connection {
         this.#dbName = parsed.hostname;
         this.#apiKey = apiKey;
         this.#region = region;
-        this.#client = new client_1.RestfulLanceDBClient(this.#dbName, this.#apiKey, this.#region, hostOverride, connectionTimeout, readTimeout);
+        this.#client = new client_1.RestfulLanceDBClient(this.#dbName, this.#apiKey, this.#region, hostOverride, timeout);
     }
     isOpen() {
         return this.#client.isOpen();

package/dist/table.d.ts

@@ -221,12 +221,15 @@ export declare abstract class Table {
      * of the given query vector
      * @param {string} query - the query. This will be converted to a vector using the table's provided embedding function
      * @note  If no embedding functions are defined in the table, this will error when collecting the results.
+     *
+     * This is just a convenience method for calling `.query().nearestTo(await myEmbeddingFunction(query))`
      */
     abstract search(query: string): VectorQuery;
     /**
      * Create a search query to find the nearest neighbors
      * of the given query vector
      * @param {IntoVector} query - the query vector
+     * This is just a convenience method for calling `.query().nearestTo(query)`
      */
     abstract search(query: IntoVector): VectorQuery;
     /**

package/dist/table.js

@@ -93,7 +93,7 @@ class LocalTable extends Table {
         const mode = options?.mode ?? "append";
         const schema = await this.schema();
         const registry = (0, registry_1.getRegistry)();
-        const functions = registry.parseFunctions(schema.metadata);
+        const functions = await registry.parseFunctions(schema.metadata);
         const buffer = await (0, arrow_1.fromDataToBuffer)(data, functions.values().next().value, schema);
         await this.inner.add(buffer, mode);
     }

package/package.json

@@ -10,7 +10,7 @@
     "vector database",
     "ann"
   ],
-  "version": "0.7.0",
+  "version": "0.8.0",
   "main": "dist/index.js",
   "exports": {
     ".": "./dist/index.js",
@@ -32,25 +32,29 @@
   },
   "license": "Apache 2.0",
   "devDependencies": {
+    "@aws-sdk/client-dynamodb": "^3.33.0",
     "@aws-sdk/client-kms": "^3.33.0",
     "@aws-sdk/client-s3": "^3.33.0",
-    "@aws-sdk/client-dynamodb": "^3.33.0",
     "@biomejs/biome": "^1.7.3",
     "@jest/globals": "^29.7.0",
     "@napi-rs/cli": "^2.18.3",
+    "@types/axios": "^0.14.0",
     "@types/jest": "^29.1.2",
     "@types/tmp": "^0.2.6",
-    "apache-arrow-old": "npm:apache-arrow@13.0.0",
+    "apache-arrow-13": "npm:apache-arrow@13.0.0",
+    "apache-arrow-14": "npm:apache-arrow@14.0.0",
+    "apache-arrow-15": "npm:apache-arrow@15.0.0",
+    "apache-arrow-16": "npm:apache-arrow@16.0.0",
+    "apache-arrow-17": "npm:apache-arrow@17.0.0",
     "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "shx": "^0.3.4",
     "tmp": "^0.2.3",
     "ts-jest": "^29.1.2",
-    "typedoc": "^0.25.7",
-    "typedoc-plugin-markdown": "^3.17.1",
+    "typedoc": "^0.26.4",
+    "typedoc-plugin-markdown": "^4.2.1",
     "typescript": "^5.3.3",
-    "typescript-eslint": "^7.1.0",
-    "@types/axios": "^0.14.0"
+    "typescript-eslint": "^7.1.0"
   },
   "ava": {
     "timeout": "3m"
@@ -77,7 +81,6 @@
     "docs": "typedoc --plugin typedoc-plugin-markdown --out ../docs/src/js lancedb/index.ts",
     "lint": "biome check . && biome format .",
     "lint-fix": "biome check --write . && biome format --write .",
-    "prepublishOnly": "napi prepublish -t npm",
     "test": "jest --verbose",
     "integration": "S3_TEST=1 npm run test",
     "universal": "napi universal",
@@ -88,13 +91,13 @@
     "reflect-metadata": "^0.2.2"
   },
   "optionalDependencies": {
-    "@lancedb/lancedb-darwin-arm64": "0.7.0",
-    "@lancedb/lancedb-linux-arm64-gnu": "0.7.0",
-    "@lancedb/lancedb-darwin-x64": "0.7.0",
-    "@lancedb/lancedb-linux-x64-gnu": "0.7.0",
-    "@lancedb/lancedb-win32-x64-msvc": "0.7.0"
+    "@lancedb/lancedb-darwin-arm64": "0.8.0",
+    "@lancedb/lancedb-linux-arm64-gnu": "0.8.0",
+    "@lancedb/lancedb-darwin-x64": "0.8.0",
+    "@lancedb/lancedb-linux-x64-gnu": "0.8.0",
+    "@lancedb/lancedb-win32-x64-msvc": "0.8.0"
   },
   "peerDependencies": {
-    "apache-arrow": "^15.0.0"
+    "apache-arrow": ">=13.0.0 <=17.0.0"
   }
 }

package/Cargo.toml

@@ -1,28 +0,0 @@
-[package]
-name = "lancedb-nodejs"
-edition.workspace = true
-version = "0.0.0"
-license.workspace = true
-description.workspace = true
-repository.workspace = true
-keywords.workspace = true
-categories.workspace = true
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-arrow-ipc.workspace = true
-futures.workspace = true
-lancedb = { path = "../rust/lancedb" }
-napi = { version = "2.16.8", default-features = false, features = [
-    "napi9",
-    "async",
-] }
-napi-derive = "2.16.4"
-
-# Prevent dynamic linking of lzma, which comes from datafusion
-lzma-sys = { version = "*", features = ["static"] }
-
-[build-dependencies]
-napi-build = "2.1"