@lancedb/lancedb 0.29.0 → 0.29.1-beta.0

package/AGENTS.md

@@ -3,11 +3,11 @@ The core Rust library is in the `../rust/lancedb` directory, the rust binding
 code is in the `src/` directory and the typescript bindings are in
 the `lancedb/` directory.
 
-Whenever you change the Rust code, you will need to recompile: `npm run build`.
+Whenever you change the Rust code, you will need to recompile: `pnpm build`.
 
 Common commands:
-* Build: `npm run build`
-* Lint: `npm run lint`
-* Fix lints: `npm run lint-fix`
-* Test: `npm test`
-* Run single test file: `npm test __test__/arrow.test.ts`
+* Build: `pnpm build`
+* Lint: `pnpm lint`
+* Fix lints: `pnpm lint-fix`
+* Test: `pnpm test`
+* Run single test file: `pnpm test __test__/arrow.test.ts`

package/CONTRIBUTING.md

@@ -12,20 +12,22 @@ Typescript.
 * `src/`: Rust bindings source code
 * `lancedb/`: Typescript package source code
 * `__test__/`: Unit tests
-* `examples/`: An npm package with the examples shown in the documentation
+* `examples/`: A pnpm package with the examples shown in the documentation
 
 ## Development environment
 
 To set up your development environment, you will need to install the following:
 
-1. Node.js 14 or later
-2. Rust's package manager, Cargo. Use [rustup](https://rustup.rs/) to install.
-3. [protoc](https://grpc.io/docs/protoc-installation/) (Protocol Buffers compiler)
+1. Node.js 22 or later (required by pnpm 11)
+2. [pnpm](https://pnpm.io/installation) 11 or later (or run via `corepack enable`,
+   which uses the `packageManager` field in `package.json`)
+3. Rust's package manager, Cargo. Use [rustup](https://rustup.rs/) to install.
+4. [protoc](https://grpc.io/docs/protoc-installation/) (Protocol Buffers compiler)
 
 Initial setup:
 
 ```shell
-npm install
+pnpm install
 ```
 
 ### Commit Hooks
@@ -39,38 +41,38 @@ pre-commit install
 
 ## Development
 
-Most common development commands can be run using the npm scripts.
+Most common development commands can be run using the pnpm scripts.
 
 Build the package
 
 ```shell
-npm install
-npm run build
+pnpm install
+pnpm build
 ```
 
 Lint:
 
 ```shell
-npm run lint
+pnpm lint
 ```
 
 Format and fix lints:
 
 ```shell
-npm run lint-fix
+pnpm lint-fix
 ```
 
 Run tests:
 
 ```shell
-npm test
+pnpm test
 ```
 
 To run a single test:
 
 ```shell
 # Single file: table.test.ts
-npm test -- table.test.ts
+pnpm test -- table.test.ts
 # Single test: 'merge insert' in table.test.ts
-npm test -- table.test.ts --testNamePattern=merge\ insert
+pnpm test -- table.test.ts --testNamePattern=merge\ insert
 ```

package/dist/arrow.d.ts

@@ -255,6 +255,12 @@ export declare function fromBufferToRecordBatch(data: Buffer): Promise<RecordBat
  * Create a buffer containing a single record batch
  */
 export declare function fromRecordBatchToBuffer(batch: RecordBatch): Promise<Buffer>;
+/**
+ * Create a buffer containing a single record batch using the Arrow IPC Stream
+ * serialization. Each call produces a self-contained Stream message (schema +
+ * batch + EOS) suitable for incremental decode by `arrow_ipc::reader::StreamReader`.
+ */
+export declare function fromRecordBatchToStreamBuffer(batch: RecordBatch): Promise<Buffer>;
 /**
  * Serialize an Arrow Table into a buffer using the Arrow IPC Stream serialization
  *

package/dist/arrow.js

@@ -50,6 +50,7 @@ exports.fromTableToBuffer = fromTableToBuffer;
 exports.fromDataToBuffer = fromDataToBuffer;
 exports.fromBufferToRecordBatch = fromBufferToRecordBatch;
 exports.fromRecordBatchToBuffer = fromRecordBatchToBuffer;
+exports.fromRecordBatchToStreamBuffer = fromRecordBatchToStreamBuffer;
 exports.fromTableToStreamBuffer = fromTableToStreamBuffer;
 exports.createEmptyTable = createEmptyTable;
 exports.ensureNestedFieldsExist = ensureNestedFieldsExist;
@@ -1056,6 +1057,15 @@ async function fromRecordBatchToBuffer(batch) {
     const writer = new apache_arrow_1.RecordBatchFileWriter().writeAll([batch]);
     return Buffer.from(await writer.toUint8Array());
 }
+/**
+ * Create a buffer containing a single record batch using the Arrow IPC Stream
+ * serialization. Each call produces a self-contained Stream message (schema +
+ * batch + EOS) suitable for incremental decode by `arrow_ipc::reader::StreamReader`.
+ */
+async function fromRecordBatchToStreamBuffer(batch) {
+    const writer = apache_arrow_1.RecordBatchStreamWriter.writeAll([batch]);
+    return Buffer.from(await writer.toUint8Array());
+}
 /**
  * Serialize an Arrow Table into a buffer using the Arrow IPC Stream serialization
  *

package/dist/connection.d.ts

@@ -1,6 +1,8 @@
 import { Data, SchemaLike, TableLike } from "./arrow";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
 import { Connection as LanceDbConnection } from "./native";
+import type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, ListNamespacesResponse } from "./native";
+export type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, ListNamespacesResponse, };
 import { Table } from "./table";
 export interface CreateTableOptions {
     /**
@@ -87,6 +89,24 @@ export interface TableNamesOptions {
     /** An optional limit to the number of results to return. */
     limit?: number;
 }
+export interface ListNamespacesOptions {
+    /** Token from a previous response for pagination. */
+    pageToken?: string;
+    /** An optional limit to the number of results to return. */
+    limit?: number;
+}
+export interface CreateNamespaceOptions {
+    /** Creation mode. */
+    mode?: "create" | "exist_ok" | "overwrite";
+    /** Properties to set on the new namespace. */
+    properties?: Record<string, string>;
+}
+export interface DropNamespaceOptions {
+    /** Whether to skip if the namespace doesn't exist, or fail. */
+    mode?: "skip" | "fail";
+    /** Refuse to drop if non-empty (restrict) or drop recursively (cascade). */
+    behavior?: "restrict" | "cascade";
+}
 /**
  * A LanceDB Connection that allows you to open tables and create new ones.
  *
@@ -199,11 +219,60 @@ export declare abstract class Connection {
      * @param {string[]} namespacePath The namespace path of the table (defaults to root namespace).
      */
     abstract dropTable(name: string, namespacePath?: string[]): Promise<void>;
+    abstract renameTable(oldName: string, newName: string, namespacePath?: string[]): Promise<void>;
     /**
      * Drop all tables in the database.
      * @param {string[]} namespacePath The namespace path to drop tables from (defaults to root namespace).
      */
     abstract dropAllTables(namespacePath?: string[]): Promise<void>;
+    /**
+     * Describe a namespace, returning its properties.
+     *
+     * @param {string[]} namespacePath - The namespace path to describe, in
+     *   parent → child order, e.g. `["analytics", "sales"]`.
+     * @returns {Promise<DescribeNamespaceResponse>} The namespace's properties
+     *   (may be undefined if the namespace has none).
+     */
+    abstract describeNamespace(namespacePath: string[]): Promise<DescribeNamespaceResponse>;
+    /**
+     * List the immediate child namespaces under the given parent.
+     *
+     * Results may be paginated. To retrieve subsequent pages, pass the
+     * `pageToken` returned by a previous call.
+     *
+     * @param {string[]} namespacePath - The parent namespace path. Defaults
+     *   to the root namespace if omitted.
+     * @param {Partial<ListNamespacesOptions>} options - Pagination options
+     *   (`pageToken`, `limit`).
+     * @returns {Promise<ListNamespacesResponse>} Child namespace names and
+     *   an optional token for fetching the next page.
+     */
+    abstract listNamespaces(namespacePath?: string[], options?: Partial<ListNamespacesOptions>): Promise<ListNamespacesResponse>;
+    /**
+     * Create a new namespace at the given path.
+     *
+     * @param {string[]} namespacePath - The namespace path to create.
+     * @param {Partial<CreateNamespaceOptions>} options - Creation `mode`
+     *   ("create" | "exist_ok" | "overwrite") and optional `properties`
+     *   to attach to the namespace.
+     * @returns {Promise<CreateNamespaceResponse>} The properties of the
+     *   created namespace and an optional transaction id.
+     */
+    abstract createNamespace(namespacePath: string[], options?: Partial<CreateNamespaceOptions>): Promise<CreateNamespaceResponse>;
+    /**
+     * Drop a namespace.
+     *
+     * Use `behavior: "cascade"` to also drop everything contained in the
+     * namespace (sub-namespaces and tables). The default `"restrict"`
+     * behavior refuses to drop a non-empty namespace.
+     *
+     * @param {string[]} namespacePath - The namespace path to drop.
+     * @param {Partial<DropNamespaceOptions>} options - `mode` ("skip" | "fail"
+     *   for missing-namespace handling) and `behavior` ("restrict" | "cascade").
+     * @returns {Promise<DropNamespaceResponse>} Any properties returned by
+     *   the server and an optional transaction id.
+     */
+    abstract dropNamespace(namespacePath: string[], options?: Partial<DropNamespaceOptions>): Promise<DropNamespaceResponse>;
     /**
      * Clone a table from a source table.
      *
@@ -251,7 +320,12 @@ export declare class LocalConnection extends Connection {
     private _createTableImpl;
     createEmptyTable(name: string, schema: import("./arrow").SchemaLike, namespacePathOrOptions?: string[] | Partial<CreateTableOptions>, options?: Partial<CreateTableOptions>): Promise<Table>;
     dropTable(name: string, namespacePath?: string[]): Promise<void>;
+    renameTable(oldName: string, newName: string, namespacePath?: string[]): Promise<void>;
     dropAllTables(namespacePath?: string[]): Promise<void>;
+    describeNamespace(namespacePath: string[]): Promise<DescribeNamespaceResponse>;
+    listNamespaces(namespacePath?: string[], options?: Partial<ListNamespacesOptions>): Promise<ListNamespacesResponse>;
+    createNamespace(namespacePath: string[], options?: Partial<CreateNamespaceOptions>): Promise<CreateNamespaceResponse>;
+    dropNamespace(namespacePath: string[], options?: Partial<DropNamespaceOptions>): Promise<DropNamespaceResponse>;
 }
 /**
  * Takes storage options and makes all the keys snake case.

package/dist/connection.js

@@ -160,9 +160,24 @@ class LocalConnection extends Connection {
     async dropTable(name, namespacePath) {
         return this.inner.dropTable(name, namespacePath ?? []);
     }
+    async renameTable(oldName, newName, namespacePath) {
+        return this.inner.renameTable(oldName, newName, namespacePath ?? []);
+    }
     async dropAllTables(namespacePath) {
         return this.inner.dropAllTables(namespacePath ?? []);
     }
+    describeNamespace(namespacePath) {
+        return this.inner.describeNamespace(namespacePath);
+    }
+    listNamespaces(namespacePath, options) {
+        return this.inner.listNamespaces(namespacePath ?? [], options?.pageToken, options?.limit);
+    }
+    createNamespace(namespacePath, options) {
+        return this.inner.createNamespace(namespacePath, options?.mode, options?.properties);
+    }
+    dropNamespace(namespacePath, options) {
+        return this.inner.dropNamespace(namespacePath, options?.mode, options?.behavior);
+    }
 }
 exports.LocalConnection = LocalConnection;
 /**

package/dist/index.d.ts

@@ -1,18 +1,19 @@
 import { Connection } from "./connection";
-import { ConnectionOptions, Session } from "./native.js";
+import { ConnectNamespaceOptions, ConnectionOptions, Session } from "./native.js";
 import { HeaderProvider } from "./header";
 export { JsHeaderProvider as NativeJsHeaderProvider } from "./native.js";
-export { AddColumnsSql, ConnectionOptions, IndexStatistics, IndexConfig, ClientConfig, TimeoutConfig, RetryConfig, TlsConfig, OptimizeStats, CompactionStats, RemovalStats, TableStatistics, FragmentStatistics, FragmentSummaryStats, Tags, TagContents, MergeResult, AddResult, AddColumnsResult, AlterColumnsResult, DeleteResult, DropColumnsResult, UpdateResult, SplitCalculatedOptions, SplitRandomOptions, SplitHashOptions, SplitSequentialOptions, ShuffleOptions, } from "./native.js";
+export { AddColumnsSql, ConnectionOptions, ConnectNamespaceOptions, IndexStatistics, IndexConfig, ClientConfig, TimeoutConfig, RetryConfig, TlsConfig, OptimizeStats, CompactionStats, RemovalStats, TableStatistics, FragmentStatistics, FragmentSummaryStats, Tags, TagContents, MergeResult, AddResult, AddColumnsResult, AlterColumnsResult, DeleteResult, DropColumnsResult, UpdateResult, SplitCalculatedOptions, SplitRandomOptions, SplitHashOptions, SplitSequentialOptions, ShuffleOptions, } from "./native.js";
 export { makeArrowTable, MakeArrowTableOptions, Data, VectorColumnOptions, } from "./arrow";
-export { Connection, CreateTableOptions, TableNamesOptions, OpenTableOptions, } from "./connection";
+export { Connection, CreateTableOptions, TableNamesOptions, OpenTableOptions, ListNamespacesOptions, CreateNamespaceOptions, DropNamespaceOptions, ListNamespacesResponse, CreateNamespaceResponse, DropNamespaceResponse, DescribeNamespaceResponse, } from "./connection";
 export { Session } from "./native.js";
-export { ExecutableQuery, Query, QueryBase, VectorQuery, TakeQuery, QueryExecutionOptions, FullTextSearchOptions, RecordBatchIterator, FullTextQuery, MatchQuery, PhraseQuery, BoostQuery, MultiMatchQuery, BooleanQuery, FullTextQueryType, Operator, Occur, } from "./query";
+export { ExecutableQuery, Query, QueryBase, VectorQuery, TakeQuery, QueryExecutionOptions, ColumnOrdering, FullTextSearchOptions, RecordBatchIterator, FullTextQuery, MatchQuery, PhraseQuery, BoostQuery, MultiMatchQuery, BooleanQuery, FullTextQueryType, Operator, Occur, } from "./query";
 export { Index, IndexOptions, IvfPqOptions, IvfRqOptions, IvfFlatOptions, HnswPqOptions, HnswSqOptions, FtsOptions, } from "./indices";
-export { Table, AddDataOptions, UpdateOptions, OptimizeOptions, Version, ColumnAlteration, } from "./table";
+export { Table, AddDataOptions, UpdateOptions, OptimizeOptions, Version, LsmWriteSpec, ColumnAlteration, } from "./table";
 export { HeaderProvider, StaticHeaderProvider, OAuthHeaderProvider, TokenResponse, } from "./header";
 export { MergeInsertBuilder, WriteExecutionOptions } from "./merge";
 export * as embedding from "./embedding";
 export { permutationBuilder, PermutationBuilder } from "./permutation";
+export { Scannable, ScannableOptions } from "./scannable";
 export * as rerankers from "./rerankers";
 export { SchemaLike, TableLike, FieldLike, RecordBatchLike, DataLike, IntoVector, MultiVector, } from "./arrow";
 export { IntoSql, packBits } from "./util";
@@ -83,3 +84,115 @@ export declare function connect(uri: string, options?: Partial<ConnectionOptions
 export declare function connect(options: Partial<ConnectionOptions> & {
     uri: string;
 }): Promise<Connection>;
+/**
+ * Configuration for the built-in directory namespace (`"dir"`).
+ *
+ * The directory namespace stores tables under a single root path (local
+ * filesystem or object storage URI). See
+ * {@link https://docs.lancedb.com/namespaces} for the documented surface;
+ * less-common knobs live under {@link DirNamespaceConfig.extraProperties}.
+ */
+export interface DirNamespaceConfig {
+    /** Root path or URI containing the LanceDB tables. */
+    root: string;
+    /**
+     * Whether to maintain a namespace manifest at the root. Required for
+     * child namespaces. Defaults to true on the impl side.
+     */
+    manifestEnabled?: boolean;
+    /**
+     * Additional raw properties passed verbatim to the namespace
+     * implementation (e.g. `storage.*`, `credential_vendor.*`). Typed
+     * fields above take precedence on key collision.
+     */
+    extraProperties?: Record<string, string>;
+}
+/**
+ * Configuration for the built-in REST namespace (`"rest"`).
+ *
+ * The REST namespace talks to a remote catalog server over HTTP. See
+ * {@link https://docs.lancedb.com/namespaces} for the documented surface;
+ * less-common knobs (TLS, metrics) live under
+ * {@link RestNamespaceConfig.extraProperties}.
+ */
+export interface RestNamespaceConfig {
+    /** Catalog endpoint URL. */
+    uri: string;
+    /**
+     * HTTP headers forwarded with each request. Keys are passed through
+     * as-is (e.g. `"x-api-key"`, `"Authorization"`).
+     */
+    headers?: Record<string, string>;
+    /**
+     * Additional raw properties passed verbatim to the namespace
+     * implementation (e.g. `tls.*`, `ops_metrics_enabled`, `delimiter`).
+     * Typed fields above take precedence on key collision.
+     */
+    extraProperties?: Record<string, string>;
+}
+/**
+ * Connect to a LanceDB database through a namespace.
+ *
+ * Unlike {@link connect}, which routes by URI scheme (local path vs.
+ * `db://` cloud), `connectNamespace` always returns a namespace-backed
+ * connection. The `implName` selects the namespace implementation:
+ *
+ * - `"dir"` — directory namespace, configured with {@link DirNamespaceConfig}.
+ * - `"rest"` — remote REST catalog, configured with {@link RestNamespaceConfig}.
+ * - Any other string — full module path for a custom implementation,
+ *   configured with a free-form string-keyed `properties` map.
+ *
+ * @example Typed dir namespace
+ * ```ts
+ * const db = await connectNamespace("dir", { root: "/path/to/db" });
+ * await db.createTable("users", [{ id: 1 }]);
+ * ```
+ *
+ * @example Typed REST namespace with auth headers
+ * ```ts
+ * const db = await connectNamespace("rest", {
+ *   uri: "https://catalog.example.com",
+ *   headers: { "x-api-key": process.env.CATALOG_KEY ?? "" },
+ * });
+ * ```
+ *
+ * @example Custom implementation with raw properties
+ * ```ts
+ * const db = await connectNamespace("my.custom.Namespace", {
+ *   endpoint: "...",
+ * });
+ * ```
+ */
+export declare function connectNamespace(implName: "dir", config: DirNamespaceConfig, options?: Partial<ConnectNamespaceOptions>): Promise<Connection>;
+/**
+ * Connect through the built-in REST namespace.
+ *
+ * Configured with {@link RestNamespaceConfig}. See the function-level
+ * documentation above for the full surface, examples, and how this
+ * relates to {@link connect}.
+ *
+ * @example
+ * ```ts
+ * const db = await connectNamespace("rest", {
+ *   uri: "https://catalog.example.com",
+ *   headers: { "x-api-key": process.env.CATALOG_KEY ?? "" },
+ * });
+ * ```
+ */
+export declare function connectNamespace(implName: "rest", config: RestNamespaceConfig, options?: Partial<ConnectNamespaceOptions>): Promise<Connection>;
+/**
+ * Connect through a custom namespace implementation by full module path,
+ * configured with a free-form string-keyed `properties` map. Use the
+ * typed overloads above for the built-in `"dir"` and `"rest"` impls.
+ *
+ * See the function-level documentation above for examples and how this
+ * relates to {@link connect}.
+ *
+ * @example
+ * ```ts
+ * const db = await connectNamespace("my.custom.Namespace", {
+ *   endpoint: "...",
+ * });
+ * ```
+ */
+export declare function connectNamespace(implName: string, properties: Record<string, string>, options?: Partial<ConnectNamespaceOptions>): Promise<Connection>;

package/dist/index.js

@@ -2,8 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright The LanceDB Authors
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.packBits = exports.rerankers = exports.PermutationBuilder = exports.permutationBuilder = exports.embedding = exports.MergeInsertBuilder = exports.OAuthHeaderProvider = exports.StaticHeaderProvider = exports.HeaderProvider = exports.Table = exports.Index = exports.Occur = exports.Operator = exports.FullTextQueryType = exports.BooleanQuery = exports.MultiMatchQuery = exports.BoostQuery = exports.PhraseQuery = exports.MatchQuery = exports.RecordBatchIterator = exports.TakeQuery = exports.VectorQuery = exports.QueryBase = exports.Query = exports.Session = exports.Connection = exports.VectorColumnOptions = exports.MakeArrowTableOptions = exports.makeArrowTable = exports.TagContents = exports.Tags = exports.NativeJsHeaderProvider = void 0;
+exports.packBits = exports.rerankers = exports.Scannable = exports.PermutationBuilder = exports.permutationBuilder = exports.embedding = exports.MergeInsertBuilder = exports.OAuthHeaderProvider = exports.StaticHeaderProvider = exports.HeaderProvider = exports.Table = exports.Index = exports.Occur = exports.Operator = exports.FullTextQueryType = exports.BooleanQuery = exports.MultiMatchQuery = exports.BoostQuery = exports.PhraseQuery = exports.MatchQuery = exports.RecordBatchIterator = exports.TakeQuery = exports.VectorQuery = exports.QueryBase = exports.Query = exports.Session = exports.Connection = exports.VectorColumnOptions = exports.MakeArrowTableOptions = exports.makeArrowTable = exports.TagContents = exports.Tags = exports.NativeJsHeaderProvider = void 0;
 exports.connect = connect;
+exports.connectNamespace = connectNamespace;
 const connection_1 = require("./connection");
 const native_js_1 = require("./native.js");
 // Re-export native header provider for use with connectWithHeaderProvider
@@ -48,6 +49,8 @@ exports.embedding = require("./embedding");
 var permutation_1 = require("./permutation");
 Object.defineProperty(exports, "permutationBuilder", { enumerable: true, get: function () { return permutation_1.permutationBuilder; } });
 Object.defineProperty(exports, "PermutationBuilder", { enumerable: true, get: function () { return permutation_1.PermutationBuilder; } });
+var scannable_1 = require("./scannable");
+Object.defineProperty(exports, "Scannable", { enumerable: true, get: function () { return scannable_1.Scannable; } });
 exports.rerankers = require("./rerankers");
 var util_1 = require("./util");
 Object.defineProperty(exports, "packBits", { enumerable: true, get: function () { return util_1.packBits; } });
@@ -104,3 +107,47 @@ async function connect(uriOrOptions, optionsOrSession, sessionOrHeaderProvider,
     const nativeConn = await native_js_1.Connection.new(uri, finalOptions, nativeProvider);
     return new connection_1.LocalConnection(nativeConn);
 }
+function dirConfigToProperties(config) {
+    // Spread the whole input so that unknown keys (e.g. a raw `manifest_enabled`
+    // passed via the dynamic-impl path) flow through instead of being dropped.
+    // Typed transformations layer on top.
+    const { manifestEnabled, extraProperties, ...rest } = config;
+    const properties = {
+        ...(extraProperties ?? {}),
+        ...rest,
+    };
+    if (manifestEnabled !== undefined) {
+        properties.manifest_enabled = String(manifestEnabled);
+    }
+    return properties;
+}
+function restConfigToProperties(config) {
+    const { headers, extraProperties, ...rest } = config;
+    const properties = {
+        ...(extraProperties ?? {}),
+        ...rest,
+    };
+    if (headers) {
+        for (const [name, value] of Object.entries(headers)) {
+            properties[`headers.${name}`] = value;
+        }
+    }
+    return properties;
+}
+async function connectNamespace(implName, configOrProperties, options) {
+    let properties;
+    if (implName === "dir") {
+        properties = dirConfigToProperties(configOrProperties);
+    }
+    else if (implName === "rest") {
+        properties = restConfigToProperties(configOrProperties);
+    }
+    else {
+        properties = configOrProperties;
+    }
+    const finalOptions = (options ??
+        {});
+    finalOptions.storageOptions = (0, connection_1.cleanseStorageOptions)(finalOptions.storageOptions);
+    const nativeConn = await native_js_1.Connection.newWithNamespace(implName, properties, finalOptions);
+    return new connection_1.LocalConnection(nativeConn);
+}

package/dist/native.d.ts

@@ -3,6 +3,8 @@
 export declare class Connection {
   /** Create a new Connection instance from the given URI. */
   static new(uri: string, options: ConnectionOptions, headerProvider?: JsHeaderProvider | undefined | null): Promise<Connection>
+  /** Create a new Connection instance backed by a namespace implementation. */
+  static newWithNamespace(implName: string, properties: Record<string, string>, options: ConnectNamespaceOptions): Promise<Connection>
   display(): string
   isOpen(): boolean
   close(): void
@@ -21,7 +23,16 @@ export declare class Connection {
   cloneTable(targetTableName: string, sourceUri: string, targetNamespacePath: Array<string> | undefined | null, sourceVersion: number | undefined | null, sourceTag: string | undefined | null, isShallow: boolean): Promise<Table>
   /** Drop table with the name. Or raise an error if the table does not exist. */
   dropTable(name: string, namespacePath?: Array<string> | undefined | null): Promise<void>
+  renameTable(oldName: string, newName: string, namespacePath?: Array<string> | undefined | null): Promise<void>
   dropAllTables(namespacePath?: Array<string> | undefined | null): Promise<void>
+  /** Describe a namespace and return its properties. */
+  describeNamespace(namespacePath: Array<string>): Promise<DescribeNamespaceResponse>
+  /** List child namespaces under the given namespace path */
+  listNamespaces(namespacePath?: Array<string> | undefined | null, pageToken?: string | undefined | null, limit?: number | undefined | null): Promise<ListNamespacesResponse>
+  /** Create a new namespace with optional properties. */
+  createNamespace(namespacePath: Array<string>, mode?: string | undefined | null, properties?: Record<string, string> | undefined | null): Promise<CreateNamespaceResponse>
+  /** Drop a namespace. */
+  dropNamespace(namespacePath: Array<string>, mode?: string | undefined | null, behavior?: string | undefined | null): Promise<DropNamespaceResponse>
 }
 
 export declare class Index {
@@ -55,6 +66,30 @@ export declare class JsHeaderProvider {
   constructor(getHeadersCallback: () => Promise<Record<string, string>>)
 }
 
+/**
+ * A Rust-side view of a JS-constructed `Scannable`.
+ *
+ * Held in JS as the return value of the `Scannable` class constructor. When
+ * passed to a consumer that accepts `impl lancedb::data::scannable::Scannable`,
+ * the consumer invokes `scan_as_stream()` to pull batches through the JS
+ * callback.
+ */
+export declare class NapiScannable {
+  /**
+   * Construct a new `NapiScannable`.
+   *
+   * - `schema_buf` — Arrow IPC File buffer carrying only the schema (no batches).
+   * - `num_rows` — optional row count hint; not validated against the stream.
+   * - `rescannable` — whether `get_next_batch` may be re-driven after the
+   *   scan completes.
+   * - `get_next_batch` -- JS callback that yields the next batch as an Arrow
+   *   IPC Stream message wrapped in a `Buffer`, or `null` at EOF. The
+   *   `isStart` argument is `true` on the first call of each new scan;
+   *   JS uses it to discard any cached iterator before pulling.
+   */
+  constructor(schemaBuf: Buffer, numRows: number | undefined | null, rescannable: boolean, getNextBatch: (arg: boolean) => Promise<Buffer | undefined | null>)
+}
+
 /** A builder used to create and run a merge insert operation */
 export declare class NativeMergeInsertBuilder {
   whenMatchedUpdateAll(condition?: string | undefined | null): NativeMergeInsertBuilder
@@ -94,6 +129,7 @@ export declare class Query {
   nearestToRaw(data: Uint8Array, dtype: string): VectorQuery
   fastSearch(): void
   withRowId(): void
+  orderBy(ordering?: Array<ColumnOrdering> | undefined | null): void
   outputSchema(): Promise<Buffer>
   execute(maxBatchLength?: number | undefined | null, timeoutMs?: number | undefined | null): Promise<RecordBatchIterator>
   explainPlan(verbose: boolean): Promise<string>
@@ -174,6 +210,9 @@ export declare class Table {
   addColumnsWithSchema(schemaBuf: Buffer): Promise<AddColumnsResult>
   alterColumns(alterations: Array<ColumnAlteration>): Promise<AlterColumnsResult>
   dropColumns(columns: Array<string>): Promise<DropColumnsResult>
+  setUnenforcedPrimaryKey(columns: Array<string>): Promise<void>
+  setLsmWriteSpec(spec: LsmWriteSpec): Promise<void>
+  unsetLsmWriteSpec(): Promise<void>
   version(): Promise<number>
   checkout(version: number): Promise<void>
   checkoutTag(tag: string): Promise<void>
@@ -234,6 +273,7 @@ export declare class VectorQuery {
   fastSearch(): void
   withRowId(): void
   rerank(rerankHybrid: (arg: RerankHybridCallbackArgs) => Promise<Buffer>): void
+  orderBy(ordering?: Array<ColumnOrdering> | undefined | null): void
   outputSchema(): Promise<Buffer>
   execute(maxBatchLength?: number | undefined | null, timeoutMs?: number | undefined | null): Promise<RecordBatchIterator>
   explainPlan(verbose: boolean): Promise<string>
@@ -316,6 +356,12 @@ export interface ColumnAlteration {
   nullable?: boolean
 }
 
+export interface ColumnOrdering {
+  ascending: boolean
+  nullsFirst: boolean
+  columnName: string
+}
+
 /** Statistics about a compaction operation. */
 export interface CompactionStats {
   /** The number of fragments removed */
@@ -383,15 +429,53 @@ export interface ConnectionOptions {
   hostOverride?: string
 }
 
+export interface ConnectNamespaceOptions {
+  /**
+   * The interval, in seconds, at which to check for updates to the table
+   * from other processes. If None, then consistency is not checked. For
+   * performance reasons, this is the default. For strong consistency, set
+   * this to zero seconds. Then every read will check for updates from other
+   * processes. As a compromise, you can set this to a non-zero value for
+   * eventual consistency.
+   */
+  readConsistencyInterval?: number
+  /**
+   * Configuration for object storage. The available options are described
+   * at https://docs.lancedb.com/storage/
+   */
+  storageOptions?: Record<string, string>
+  /** Extra properties for the backing namespace client. */
+  namespaceClientProperties?: Record<string, string>
+  /**
+   * The session to use for this connection. Holds shared caches and other
+   * session-specific state.
+   */
+  session?: Session
+}
+
+export interface CreateNamespaceResponse {
+  properties?: Record<string, string>
+  transactionId?: string
+}
+
 export interface DeleteResult {
   numDeletedRows: number
   version: number
 }
 
+export interface DescribeNamespaceResponse {
+  properties?: Record<string, string>
+}
+
 export interface DropColumnsResult {
   version: number
 }
 
+export interface DropNamespaceResponse {
+  properties?: Record<string, string>
+  transactionId?: Array<string>
+}
+
 export interface FragmentStatistics {
   /** The number of fragments in the table */
   numFragments: number
@@ -455,6 +539,32 @@ export interface IndexStatistics {
   loss?: number
 }
 
+export interface ListNamespacesResponse {
+  namespaces: Array<string>
+  pageToken?: string
+}
+
+/**
+ * Specification selecting Lance's MemWAL LSM-style write path for
+ * `mergeInsert`.
+ *
+ * `specType` must be `"bucket"`, `"identity"`, or `"unsharded"`. For
+ * `"bucket"`, `column` and `numBuckets` are required; for `"identity"`,
+ * `column` is required.
+ */
+export interface LsmWriteSpec {
+  /** One of `"bucket"`, `"identity"`, or `"unsharded"`. */
+  specType: string
+  /** Bucket and identity variants: the sharding column. */
+  column?: string
+  /** Bucket variant: the number of buckets, in `[1, 1024]`. */
+  numBuckets?: number
+  /** Names of indexes the MemWAL should keep up to date during writes. */
+  maintainedIndexes?: Array<string>
+  /** Default `ShardWriter` configuration recorded in the MemWAL index. */
+  writerConfigDefaults?: Record<string, string>
+}
+
 export interface MergeResult {
   version: number
   numInsertedRows: number