python: create_index returns Job / AsyncJob (ENT-1966)

Table.create_index, create_scalar_index, create_fts_index, and the
materialized-view delegates now return a Job (AsyncJob on AsyncTable).
When the server defers the build (pending vector index), the returned
job tracks it through the platform jobs API; synchronous builds (scalar,
FTS, native tables, GPU-accelerated local paths) return a pre-completed
job whose status()/wait() report finished immediately and whose cancel()
is a no-op. AsyncTable now carries its owning connection so the async
handles can reach the jobs API. wait_timeout keeps working; docs steer
new code to job.wait().

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.agents/plugins/marketplace.json

@@ -1,20 +0,0 @@
-{
-  "name": "lancedb",
-  "interface": {
-    "displayName": "LanceDB"
-  },
-  "plugins": [
-    {
-      "name": "lancedb",
-      "source": {
-        "source": "local",
-        "path": "./plugins/lancedb"
-      },
-      "policy": {
-        "installation": "AVAILABLE",
-        "authentication": "ON_INSTALL"
-      },
-      "category": "Developer Tools"
-    }
-  ]
-}

.agents/skills/lancedb/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: lancedb
+description: Use when writing, reviewing, debugging, or documenting LanceDB pipelines in Python or TypeScript, especially code that should work across local LanceDB OSS tables and remote LanceDB Enterprise/Cloud tables. Helps avoid non-portable full-table materialization, choose idiomatic query/search patterns, and apply LanceDB performance defaults for ingestion, indexing, filtering, and diagnostics.
+---
+
+# Building LanceDB Pipelines
+
+Use this skill to produce LanceDB pipelines that are portable between local and remote tables (for LanceDB Enterprise/Cloud) and idiomatic for the selected SDK.
+
+## LanceDB Table Modes
+
+LanceDB has two common execution modes:
+
+- **Local table**: embedded, open source, in-process LanceDB. The client opens data from a local path or object storage URI and executes queries in the application process.
+- **Remote table**: LanceDB Enterprise/Cloud table opened through a `db://...` URI. The data may be very large, commonly backed by object storage, and queried through a remote service.
+
+Do NOT assume local-only table helpers exist on remote tables. If the user asks for LanceDB Enterprise, Cloud, `db://...`, production remote access, or a remote table, focus on the remote table path: use `search()` / `query()`, keep reads bounded with `select()` and `limit()`, and avoid table-level full materialization APIs.
+
+## Workflow
+
+1. Identify the SDK: Python, TypeScript, or both.
+2. Identify the table mode: local/embedded OSS, remote Enterprise/Cloud, or portable across both. If the user says "LanceDB Enterprise", choose the remote table path.
+3. Read the matching language branch before writing or changing code:
+   - Python patterns: `references/python/patterns.md`
+   - Python API quick reference: `references/python/api_reference.md`
+   - Python performance guidance: `references/python/performance.md`
+   - TypeScript patterns: `references/typescript/patterns.md`
+   - TypeScript API quick reference: `references/typescript/api_reference.md`
+   - TypeScript performance guidance: `references/typescript/performance.md`
+   - Column metadata authoring (both SDKs): `references/column_metadata.md`
+   - Branch operations (both SDKs): `references/branch_ops.md`
+4. Start with `patterns.md` for the selected SDK. Read `api_reference.md` when choosing method names or return collectors. Read `performance.md` when the task involves ingestion, indexing, filtering, query tuning, diagnostics, or large datasets. Read `column_metadata.md` when the task is documenting, tagging, classifying, or grouping table columns (field descriptions, `lancedb:tag:*` tags, logical column families). Read `branch_ops.md` when the task involves branch lifecycle (list/create/delete), writing to a non-main branch, or verifying a change stayed off main.
+5. For Python schemas, favor Pydantic models and validate records before writing. Use PyArrow schemas when Arrow-native, streaming, or highly dynamic data makes them materially better suited.
+6. Prefer `search()` or `query()` builders with explicit `select()` and `limit()` for reads.
+7. Avoid table-level full materialization in remote or portable code. This is the main local-vs-remote read pitfall.
+8. After a successful embedded OSS ingestion, call `table.optimize()`. Do not call it for Enterprise/Cloud; remote maintenance is automatic.
+9. For remote Enterprise/Cloud writes, never drop-then-reuse or `mode="overwrite"` the same table name — see "Enterprise: never drop-then-reuse the same table name" below. This is the main local-vs-remote write pitfall.
+10. If reviewing an existing file or repo, run `scripts/check_materialization.py` on the relevant paths and inspect each finding before editing.
+11. Cross-check unfamiliar or non-trivial API claims against the source tree instead of relying on memory.
+
+## Core Portability Rule
+
+Do not write code that assumes a local table API will exist on a remote table. Remote tables can be very large, so whole-table materialization helpers are intentionally unavailable or unsafe.
+
+This does **not** mean result conversion is forbidden. Bounded query/search result collection is normal:
+
+- Python: `table.search(...).select([...]).limit(10).to_pandas()`
+- TypeScript: `await table.search(...).select([...]).limit(10).toArray()`
+
+The unsafe pattern is table-level or unbounded collection, plus local-only dataset escape hatches in remote code:
+
+- Python: `table.to_pandas()`, `table.to_arrow()`, `table.to_polars()`; `table.to_lance()` is local/OSS-only dataset access, not materialization
+- TypeScript: `await table.toArrow()`, `await table.query().toArray()` without `limit()`
+
+## Enterprise: never drop-then-reuse the same table name
+
+LanceDB Enterprise/Cloud splits a **control plane** (DDL: create/drop/rename) from a **data plane** (query nodes that serve reads). Query nodes cache the resolved dataset for a table name for up to `table_cache_ttl` — **default 300 seconds (5 minutes)**. After you drop or overwrite a table, the control plane updates immediately but the data plane keeps serving the *old* dataset until that cache entry expires. During the window the two planes disagree.
+
+The failure this causes: you `drop_table("t")` then immediately `create_table("t", ...)` (or `create_table("t", ..., mode="overwrite")`). The DDL returns success, but every query against `t` returns **`500 Internal Server Error`** (the query node resolves the stale/deleted dataset), and a fresh `describe` may still show the *old* schema/version. It looks like your write silently failed; it didn't — the name is cached.
+
+**`mode="overwrite"` has the same problem** — it is a drop+create of the same name under the hood.
+
+Rules for portable Enterprise ingestion:
+
+1. **Never reuse a table name you just dropped/overwrote within the cache TTL.** Do not use `mode="overwrite"` to replace an existing Enterprise table in place.
+2. To (re)load data, **write to a fresh table name** (e.g. `<table>_v2`, or a run-stamped suffix). A brand-new name has no cached data-plane entry, so writes and reads work immediately.
+3. Before creating, `list_tables()` and **fail loudly if the name already exists** rather than overwriting — prompt for a new name.
+4. To land on a specific final name that is currently occupied by an old table: drop the old table, **wait out the TTL (~5 min), then `rename_table(fresh_name, final_name)`**. Renaming onto a name whose old dataset is still cached hits the same race, so the wait is mandatory. `rename_table` is a supported control-plane op.
+5. When you hand a table name back to a human, tell them which step still needs the propagation wait (usually: "the old `t` was dropped; run the rename in ~5 minutes").
+
+This is Enterprise/Cloud-specific. Local/OSS tables have no separate data plane, so `mode="overwrite"` and immediate same-name reuse are fine there.
+
+## Script
+
+Run the scanner when reviewing or modifying an existing codebase:
+
+```bash
+python skills/lancedb/scripts/check_materialization.py path/to/file_or_dir
+```
+
+The script reports likely unsafe full-table materialization in Python and TypeScript. Treat results as review prompts, not automatic proof of a bug.

.agents/skills/lancedb/references/branch_ops.md

@@ -0,0 +1,117 @@
+# Branch Operations
+
+Manage branches on a LanceDB table: list what exists, create new ones, delete stale ones, and direct read/write operations at a specific branch without touching main. Use for branch lifecycle tasks, experimental/isolated table versions, targeting an operation at a non-main branch, or confirming a mutation did not affect main.
+
+Works on local/OSS and remote Enterprise/Cloud tables.
+
+## The branch model (important)
+
+Branches are isolated, writable lines of history forked from another branch (or a specific version). Writes on a branch never affect `main`.
+
+There is **no global "switch branch" state** — you never repoint the whole table at a branch. Instead, **operations are scoped by which table handle you use**:
+
+- The handle you got from `open_table(name)` / `openTable(name)` targets `main`.
+- `branches.create(...)` and `branches.checkout(...)` return a **new table handle scoped to that branch**. Every read/write on that handle (add, update, `update_field_metadata`, `create_index`, search, …) lands on the branch.
+- The original main handle is unaffected — keep it around to verify isolation.
+
+`branches.list()` returns only non-main branches. Main always exists and is not listed.
+
+## Python
+
+`table.branches` is a property returning the branch manager; `table.current_branch()` tells you what a handle is scoped to (`None` = main).
+
+```python
+table = db.open_table("products")            # scoped to main
+
+# list — dict of name -> metadata (parent_branch, parent_version, ...); {} = only main
+table.branches.list()
+
+# create: forks from main by default and returns a handle scoped to the new branch
+exp = table.branches.create("experiment-reindex")
+exp = table.branches.create("exp2", from_ref="main", from_version=None)  # optional fork point
+
+# checkout an existing branch -> branch-scoped handle
+wip = table.branches.checkout("wip-branch")
+# with version= it pins to that version (read-only detached view); omit to track latest, writable
+
+# operate on the branch simply by using its handle
+wip.update_field_metadata(
+    {"path": "category", "metadata": {"lancedb:description": "Product category label."}}
+)
+wip.create_scalar_index("category")
+
+# delete: removes only the branch pointer; main and row data remain intact
+table.branches.delete("stale-2024")
+
+# alternatively, open a branch handle directly from the connection
+wip = db.open_table("products", branch="wip-branch")
+
+exp.current_branch()    # "experiment-reindex"
+table.current_branch()  # None (main)
+```
+
+Async: same shape — `table.branches` returns `AsyncBranches`; `await table.branches.create(...)` etc.
+
+## TypeScript
+
+`table.branches()` is an **async method** returning the `Branches` manager; `table.currentBranch()` returns the scoped branch or `null` for main.
+
+```typescript
+const table = await db.openTable("products"); // scoped to main
+const branches = await table.branches();
+
+// list — Record<string, BranchContents>; {} = only main
+await branches.list();
+
+// create: forks from main by default, returns a Table scoped to the new branch
+const exp = await branches.create("experiment-reindex");
+const exp2 = await branches.create("exp2", "main" /* fromRef */, undefined /* fromVersion */);
+
+// checkout an existing branch -> branch-scoped Table
+const wip = await branches.checkout("wip-branch");
+// with a version arg it pins (read-only detached view); omit to track latest, writable
+
+// operate on the branch simply by using its handle
+await wip.updateFieldMetadata([
+  { path: "category", metadata: { "lancedb:description": "Product category label." } },
+]);
+await wip.createIndex("category");
+
+// delete: removes only the branch pointer; main and row data remain intact
+await branches.delete("stale-2024");
+
+// alternatively, open a branch handle directly from the connection
+const wip2 = await db.openTable("products", { branch: "wip-branch" });
+
+exp.currentBranch();   // "experiment-reindex"
+table.currentBranch(); // null (main)
+```
+
+## Verifying isolation
+
+After writing to a branch, confirm the change did NOT land on main by reading through both handles:
+
+```python
+wip = table.branches.checkout("wip-branch")
+wip.update_field_metadata({"path": "category", "metadata": {"lancedb:description": "..."}})
+
+assert b"lancedb:description" in (wip.schema.field("category").metadata or {})
+assert b"lancedb:description" not in (table.schema.field("category").metadata or {})  # main untouched
+```
+
+Two handles on the same branch see each other's writes (e.g. `table.branches.create("exp")` and `db.open_table(name, branch="exp")`); main stays isolated.
+
+## Quick reference
+
+| Goal | Python | TypeScript |
+|------|--------|------------|
+| List branches (non-main) | `table.branches.list()` | `await (await table.branches()).list()` |
+| Create branch (off main) | `table.branches.create(name)` → branch handle | `await branches.create(name)` → branch `Table` |
+| Create from a fork point | `table.branches.create(name, from_ref=..., from_version=...)` | `await branches.create(name, fromRef, fromVersion)` |
+| Get a branch handle | `table.branches.checkout(name)` or `db.open_table(t, branch=name)` | `await branches.checkout(name)` or `await db.openTable(t, { branch: name })` |
+| Pin to a branch version (read-only) | `table.branches.checkout(name, version=v)` | `await branches.checkout(name, v)` |
+| Delete branch | `table.branches.delete(name)` | `await branches.delete(name)` |
+| Which branch is this handle on? | `table.current_branch()` (`None` = main) | `table.currentBranch()` (`null` = main) |
+| Target main | use the original (non-branch) handle | use the original (non-branch) handle |
+
+Branch names must be non-empty; empty names raise a validation error.

.agents/skills/lancedb/references/column_metadata.md

@@ -0,0 +1,183 @@
+# Column Metadata Authoring
+
+Write column-level descriptions, tags, and logical groupings onto a LanceDB table's schema. Use this when the user wants to document, annotate, tag, or classify what their table columns ARE (embeddings vs labels vs eval metrics, model provenance, version families, etc.).
+
+Works on local/OSS and remote Enterprise/Cloud tables alike — read the schema through the table handle, write through `update_field_metadata` (Python) / `updateFieldMetadata` (TypeScript).
+
+## Metadata key conventions
+
+All metadata uses namespaced keys:
+
+| Key | Purpose | Example value |
+|-----|---------|---------------|
+| `lancedb:description` | Human-readable explanation of what the column contains | `"CLIP ViT-L/14 image embedding, L2-normalized (768-dim)"` |
+| `lancedb:tag:<name>` | Flexible key-value tag; the suffix names the tag category | `lancedb:tag:field_type: "embedding"`, `lancedb:tag:model: "clip"`, `lancedb:tag:project_id: "foo"` |
+| `lancedb:logical-column` | Logical group/family this column belongs to | `"clip_features"` |
+
+Tags are open-ended — use whatever key suffix and value make sense given the user's intent. The tag suffix should describe *what is being classified* (e.g., `field_type`, `model`, `project_id`) and the value describes *how*. Multiple tags on the same column are fine — each is a separate key. All values are strings.
+
+## Step 1: Read the schema and existing metadata
+
+Read existing metadata before writing, to avoid redundant updates.
+
+Python — `table.schema` (sync property; async: `await table.schema()`) returns a `pyarrow.Schema`. **Arrow field metadata is bytes-keyed in Python**:
+
+```python
+schema = table.schema
+for field in schema:
+    meta = field.metadata or {}  # dict[bytes, bytes], e.g. {b"lancedb:description": b"..."}
+    print(field.name, field.type, field.nullable, meta)
+```
+
+TypeScript — `await table.schema()` returns an Arrow `Schema`; field metadata is a `Map<string, string>`:
+
+```typescript
+const schema = await table.schema();
+for (const field of schema.fields) {
+  console.log(field.name, field.type, field.nullable, field.metadata); // Map
+  // field.metadata.get("lancedb:description")
+}
+```
+
+For struct/nested fields, recurse into the field's children and address them as dot-paths (e.g., `parent.child`).
+
+If the user hasn't specified which columns to update, work with all columns.
+
+## Step 2: Generate metadata
+
+Decide what to generate based on the user's request.
+
+### Descriptions (`lancedb:description`)
+
+Base descriptions on:
+- The column name and Arrow type (e.g., `FixedSizeList` of floats → likely an embedding)
+- User-supplied context (upstream pipeline, sample values, domain knowledge)
+- Name patterns: `_embedding`/`_vec`/`_embed` → vector; `_label`/`_class` → label; `_score`/`_eval`/`_metric` → evaluation metric
+
+Be specific and concise. Good: `"Sentence-BERT embedding of the query text (768-dim)."` Not: `"An embedding column."`
+
+### Tags (`lancedb:tag:<name>`)
+
+Choose tag key names that match what the user asked to annotate. Common patterns:
+
+- Semantic field type → `lancedb:tag:field_type: "embedding"` / `"text"` / `"image"` / `"label"` / `"eval"` / `"id"` / `"metadata"`
+- Model or source → `lancedb:tag:model: "clip"` / `"bert"` / `"vit"`
+- Project affiliation → `lancedb:tag:project_id: "<name>"`
+- Version → `lancedb:tag:version: "v3"` (and `lancedb:tag:latest: "true"` for the newest)
+
+Use Arrow type as a hint: `FixedSizeList` + float → embedding; `Utf8`/`LargeUtf8` → text; `Binary` → image or blob.
+
+### Logical groupings (`lancedb:logical-column`)
+
+Look for naming patterns across columns:
+- `clip_v1`, `clip_v2`, `clip_v3` → logical column `"clip"`, latest is `v3`
+- `text_embed_20240101`, `text_embed_20240601` → logical column `"text_embed"`, latest is the most recent date suffix
+
+Write `lancedb:logical-column` on all members of a group. Mark the newest with `lancedb:tag:latest: "true"` (in addition to its version tag).
+
+## Step 3: Write the metadata
+
+Each update names a field by dot-path and carries a metadata map. Semantics (identical in both SDKs):
+
+- **Merge by default** (`replace` omitted/false) — preserves existing metadata the user didn't ask to change
+- `replace: true` swaps the field's entire metadata map — only if the user explicitly asks to overwrite
+- A value of `None`/`null` deletes that specific key
+- Batch all field updates into a single call when possible
+- Returns the new table version
+
+Python (sync and async take one dict per field, as varargs):
+
+```python
+res = table.update_field_metadata(
+    {
+        "path": "clip_v3",
+        "metadata": {
+            "lancedb:description": "CLIP ViT-L/14 image embedding, L2-normalized (1024-dim).",
+            "lancedb:tag:field_type": "embedding",
+            "lancedb:tag:model": "clip",
+            "lancedb:tag:version": "v3",
+            "lancedb:tag:latest": "true",
+            "lancedb:logical-column": "clip",
+        },
+    },
+    {
+        "path": "clip_v2",
+        "metadata": {
+            "lancedb:description": "CLIP ViT-B/32 image embedding (768-dim), superseded by v3.",
+            "lancedb:tag:field_type": "embedding",
+            "lancedb:tag:model": "clip",
+            "lancedb:tag:version": "v2",
+            "lancedb:logical-column": "clip",
+        },
+    },
+)
+print(res.version)  # new table version
+
+# merge semantics: add a key, delete one via None, keep the rest
+table.update_field_metadata(
+    {"path": "clip_v2", "metadata": {"lancedb:tag:archived": "true", "lancedb:tag:latest": None}}
+)
+```
+
+(`replace_field_metadata` is deprecated — use `update_field_metadata`.)
+
+TypeScript (takes an array of `FieldMetadataUpdate`):
+
+```typescript
+const res = await table.updateFieldMetadata([
+  {
+    path: "clip_v3",
+    metadata: {
+      "lancedb:description": "CLIP ViT-L/14 image embedding, L2-normalized (1024-dim).",
+      "lancedb:tag:field_type": "embedding",
+      "lancedb:tag:model": "clip",
+      "lancedb:tag:version": "v3",
+      "lancedb:tag:latest": "true",
+      "lancedb:logical-column": "clip",
+    },
+  },
+  {
+    path: "clip_v2",
+    metadata: {
+      "lancedb:description": "CLIP ViT-B/32 image embedding (768-dim), superseded by v3.",
+      "lancedb:tag:field_type": "embedding",
+      "lancedb:tag:model": "clip",
+      "lancedb:tag:version": "v2",
+      "lancedb:logical-column": "clip",
+    },
+  },
+]);
+console.log(res.version); // new table version
+
+// merge semantics: add a key, delete one via null, keep the rest
+await table.updateFieldMetadata([
+  { path: "clip_v2", metadata: { "lancedb:tag:archived": "true", "lancedb:tag:latest": null } },
+]);
+```
+
+## Step 4: Confirm
+
+Report back:
+- Which columns were updated and what was written
+- The new table version number (from the result)
+- Any columns skipped (e.g., already had up-to-date metadata)
+
+## Quick examples
+
+**"Write descriptions for all columns in the `product_embeddings` table"**
+1. Read `table.schema` → all fields + existing metadata
+2. Generate a `lancedb:description` for each column based on name + type
+3. One `update_field_metadata` call with all descriptions
+4. Report
+
+**"Tag the columns in `model_outputs` with their field type and model"**
+1. Read the schema
+2. For each field, classify by name + Arrow type → set `lancedb:tag:field_type` and `lancedb:tag:model` where applicable
+3. Write in one batched call
+4. Report
+
+**"Group the feature columns in `training_features` into logical families and mark the latest version"**
+1. Read the schema
+2. Find version patterns → assign `lancedb:logical-column` and `lancedb:tag:version`; mark newest with `lancedb:tag:latest: "true"`
+3. Write in one batched call
+4. Show the grouping

.agents/skills/lancedb/references/python/api_reference.md

@@ -0,0 +1,131 @@
+# Python API Reference
+
+Quick method reference for Python LanceDB code. Cross-check source for non-trivial claims.
+
+## Connect
+
+```python
+import lancedb
+
+db = lancedb.connect("./camelot-db")         # local/OSS
+db = lancedb.connect("db://my-db", api_key=api_key, region=region)  # remote
+```
+
+**Place the local database directory next to the script/entrypoint that opens it** (i.e. resolve the path relative to the script, `Path(__file__).parent / "camelot-db"`), not buried under a shared `data/` folder. The Lance dataset is the database, not a data file — keeping it beside its code makes ownership obvious and paths stable regardless of the working directory the script is launched from.
+
+**Do not name the directory `lancedb`** (e.g. `./lancedb`, `./data/lancedb`). It collides with the imported `lancedb` package name, which is confusing to read and easy to shadow in scripts. Give it a name derived from the repo or dataset with a clear prefix/suffix — for example `./<dataset>-db`, `./<repo>_lancedb`, or `./vectordb`.
+
+Async:
+
+```python
+db = await lancedb.connect_async("./camelot-db")
+```
+
+## Table Reads
+
+| Task | Preferred API |
+| --- | --- |
+| Vector search | `table.search(query_vector).limit(k)` |
+| Full scan with filters/projection (sync) | `table.search().where(...).select(...).limit(...)` |
+| Full scan with filters/projection (async) | `table.query().where(...).select(...).limit(...)` |
+| Filter | `.where("col > 10")` |
+| Projection | `.select(["id", "text"])` |
+| Bound result count | `.limit(20)` |
+| Collect bounded result as Python objects (default, no extra deps) | `.to_list()` on query/search result |
+| Collect bounded result as Arrow (default, `pyarrow` always available) | `.to_arrow()` on query/search result |
+| Collect bounded result as pandas (only if project uses pandas) | `.to_pandas()` on query/search result |
+| Collect bounded result as Polars (only if project uses polars) | `.to_polars()` on query/search result |
+
+## Sync vs Async Scan API
+
+The plain-scan entry point differs between the sync and async clients. **Verified against `lancedb` 0.34.0** — re-check if the pinned version changes:
+
+- **Sync** (`lancedb.connect(...)`): the table has **no `.query()` method**. Use `.search()` with no argument for a plain scan; it returns a query builder that supports `.where()`, `.select()`, `.limit()`, and the `.to_list()` / `.to_arrow()` / `.to_pandas()` / `.to_polars()` collectors.
+  ```python
+  rows = table.search().where("status = 'ready'").select(["id", "text"]).limit(20).to_list()
+  ```
+- **Async** (`lancedb.connect_async(...)`): the table has **both** `.query()` and `.search()`. Use `.query()` for a plain scan.
+  ```python
+  rows = await async_table.query().where("status = 'ready'").select(["id", "text"]).limit(20).to_list()
+  ```
+
+Do not call `table.query()` on a sync table — it raises `AttributeError`.
+
+## Local vs Remote Table Methods
+
+| API | Local table | Remote table | Agent guidance |
+| --- | --- | --- | --- |
+| `table.search(...)` | Yes | Yes | Preferred read path (sync + async) |
+| `table.query()` | Async only | Async only | Sync scan path is `table.search()`; `.query()` is the async scan builder |
+| `table.to_pandas()` | Yes | No / unsafe for portability | Avoid in portable code |
+| `table.to_arrow()` | Yes | No / unsafe for portability | Avoid in portable code |
+| `table.to_polars()` | Yes | No / unsafe for portability | Avoid in portable code |
+| `table.to_lance()` | Yes | No | Local/OSS escape hatch only |
+
+## Indexes
+
+Use `create_index(...)` for vector indexes and modern index configs. Use scalar indexes for filtered or merge keys.
+
+Common calls:
+
+```python
+table.create_index("vector")
+table.create_scalar_index("status")
+table.create_fts_index("text")
+```
+
+Check source docs before specifying advanced index config names or parameters.
+
+## Filtering And Recall Knobs
+
+```python
+table.search(query_vector).where("status = 'ready'")  # pre-filter by default
+table.search(query_vector).where("status = 'ready'", prefilter=False)
+table.search(query_vector).limit(10).refine_factor(20)
+table.search(query_vector).limit(10).nprobes(50)
+```
+
+Use post-filtering only when fewer than `limit` results are acceptable.
+
+## Diagnostics
+
+```python
+print(table.search(query_vector).where("year > 2000").limit(10).analyze_plan())
+print(table.index_stats("vector_idx"))
+```
+
+Use these before changing indexes or search tuning.
+
+## Column (Field) Metadata
+
+```python
+schema = table.schema                       # sync property; async: await table.schema()
+meta = schema.field("category").metadata    # dict[bytes, bytes] — Arrow metadata is bytes-keyed
+res = table.update_field_metadata(          # varargs: one dict per field; works local + remote
+    {"path": "category", "metadata": {"lancedb:description": "...", "lancedb:tag:field_type": "label"}}
+)
+res.version  # new table version
+```
+
+Merges by default; a `None` value deletes that key; `"replace": True` swaps the whole map. Nested fields use dot-paths (`"a.b.c"`). `replace_field_metadata` is deprecated. See `references/column_metadata.md` for key conventions (`lancedb:description`, `lancedb:tag:<name>`, `lancedb:logical-column`) and the authoring workflow.
+
+## Branches
+
+```python
+table.branches.list()                          # non-main branches; {} = only main
+exp = table.branches.create("exp")             # fork off main -> handle scoped to the branch
+wip = table.branches.checkout("wip")           # existing branch -> scoped handle (version= pins read-only)
+wip = db.open_table("t", branch="wip")         # or open scoped directly
+table.branches.delete("stale")                 # removes only the branch pointer
+table.current_branch()                         # None = main
+```
+
+There is no global switch — scoping is per table handle: any read/write on a branch handle lands on that branch; the original handle keeps targeting main. See `references/branch_ops.md` for the model and isolation checks.
+
+## Maintenance
+
+```python
+table.optimize()
+```
+
+Call this after every successful local/OSS ingestion. It handles compaction, cleanup of old versions according to retention, and index optimization. Do not add this for LanceDB Enterprise/Cloud remote tables; Enterprise handles compaction and cleanup automatically from cluster configuration.

.agents/skills/lancedb/references/python/patterns.md

@@ -0,0 +1,173 @@
+# Python Patterns
+
+Use these patterns when writing Python code with `lancedb`.
+
+## Before Writing Code
+
+Choose the output type from what the project actually depends on. **Do not assume `pandas` or `polars` is installed** — they are heavy dependencies that many LanceDB projects do not use. `pyarrow`, by contrast, ships as a LanceDB dependency and is always available, so it is a safe default to lean on.
+
+Default output (after applying `select()` and `limit()`):
+
+- **Python objects**: `.to_list()` — a list of dicts, no extra dependencies. Prefer this for scripts, examples, and agent-generated code unless there is a reason to do otherwise.
+- **PyArrow**: `.to_arrow()` — a `pyarrow.Table`, when the surrounding code is Arrow-native or you need columnar/zero-copy handoff.
+
+Only reach for a DataFrame when the project *already* declares that dependency:
+
+- Pandas projects (pandas in `pyproject.toml`/requirements): `.to_pandas()`.
+- Polars projects (polars declared): `.to_polars()`.
+
+If unsure, check the dependency manifest or the imports in surrounding files. When in doubt, use `.to_list()` or `.to_arrow()`.
+
+## Schema Design and Validation
+
+Favor `LanceModel` and Pydantic validation for Python schemas. They keep field
+types readable, validate source records before a write, and map directly to a
+LanceDB schema. Use `Vector(dimension)` for fixed-size vectors:
+
+```python
+from lancedb.pydantic import LanceModel, Vector
+
+class Document(LanceModel):
+    id: int
+    text: str
+    vector: Vector(384, nullable=False)
+
+rows = [Document.model_validate(row) for row in source_rows]
+table = db.create_table("documents", schema=Document)
+table.add(rows)
+```
+
+Use PyArrow schemas instead when the pipeline is already Arrow-native, needs
+record-batch streaming, or has runtime schema requirements that would make a
+Pydantic model harder to understand. Declare Pydantic as a direct project
+dependency when application code imports it, even if LanceDB also depends on it.
+
+## Recommended Patterns
+
+### Bounded search or query
+
+Use this for application reads, examples, notebooks, and agent-generated scripts:
+
+```python
+results = (
+    table.search(query_vector)
+    .where("status = 'ready'")
+    .select(["id", "text"])
+    .limit(20)
+    .to_list()  # or .to_arrow(); .to_pandas()/.to_polars() only if the project uses them
+)
+```
+
+Why: `search()` works across local and remote tables and on both the sync and async clients. `select()` avoids fetching unused columns. `limit()` prevents accidental full-table reads. `.to_list()` and `.to_arrow()` avoid assuming pandas/polars is installed (see "Before Writing Code").
+
+For a **plain scan** (no query vector), the entry point differs by client:
+
+```python
+# Sync client: no .query() method — use .search() with no argument.
+rows = table.search().where("status = 'ready'").select(["id", "text"]).limit(20).to_list()
+
+# Async client: use .query().
+rows = await async_table.query().where("status = 'ready'").select(["id", "text"]).limit(20).to_list()
+```
+
+`table.query()` on a sync table raises `AttributeError` (verified on `lancedb` 0.34.0). See the "Sync vs Async Scan API" section in `api_reference.md`.
+
+### Bounded query result conversion
+
+It is fine to collect bounded query/search results:
+
+```python
+arrow_table = table.search().select(["id"]).limit(100).to_arrow()  # sync plain scan
+rows = table.search(query_vector).limit(10).to_list()
+df = table.search(query_vector).limit(10).to_pandas()  # only if pandas is a project dep
+```
+
+### Local-only Lance dataset API
+
+`table.to_lance()` does not itself materialize the full dataset. It returns the underlying `lance.LanceDataset`, making the table accessible through the PyLance dataset API. Use it when the task is explicitly local/OSS and needs Lance dataset methods not exposed by LanceDB:
+
+```python
+# Local/OSS only: RemoteTable does not expose table.to_lance().
+ds = table.to_lance()
+for batch in ds.to_batches(columns=["id", "text"], batch_size=10_000):
+    process(batch)
+```
+
+### Async Python
+
+Keep the same shape and bound the result before collecting:
+
+```python
+results = await (
+    async_table.query()
+    .where("status = 'ready'")
+    .select(["id", "text"])
+    .limit(20)
+    .to_list()  # or .to_arrow()
+)
+```
+
+## Anti-Patterns
+
+**Avoid the following anti-patterns in your code.**
+
+### Table-level full materialization
+
+Avoid whole-table collectors in portable or large-table code:
+
+```python
+df = table.to_pandas()
+arrow_table = table.to_arrow()
+polars_df = table.to_polars()
+```
+
+Why: local tables expose these whole-table collectors, but remote tables intentionally do not — a remote production table can be far larger than a local development table, so it is easy to accidentally pull the entire table into memory.
+
+`table.to_lance()` is different: it is not a full materialization call, but it is still local/OSS-only and should not appear in code meant to run against remote Enterprise tables.
+
+### Unbounded result collection
+
+Avoid query/search collection without a meaningful limit:
+
+```python
+rows = table.search().to_list()               # unbounded plain scan
+rows = table.search(query_vector).to_list()   # unbounded vector search
+```
+
+Prefer `select(...).limit(...)` before collecting; for large reads, stream in batches instead.
+
+### Per-row writes
+
+Avoid loops that write one row per call:
+
+```python
+for row in rows:
+    table.add([row])  # one commit + fragment per row
+```
+
+Each `add()` creates a new version and fragment. Pass the whole batch in a single call, or chunk very large inputs:
+
+```python
+table.add(rows)  # single commit
+# for very large inputs, add batches of several thousand rows
+```
+
+After the final successful write to an embedded OSS table, call
+`table.optimize()`. Skip this for Enterprise/Cloud tables because their
+maintenance is automatic.
+
+### Drop-then-reuse the same table name (Enterprise/Cloud)
+
+Avoid dropping or overwriting a remote table and then reusing that name right away:
+
+```python
+db.drop_table("my_table")
+table = db.create_table("my_table", data=rows)          # reads 500 for ~5 min
+table = db.create_table("my_table", data=rows, mode="overwrite")  # same problem
+```
+
+Why: Enterprise/Cloud splits DDL (control plane) from query serving (data plane). The data plane caches the dataset behind a table name for up to `table_cache_ttl` (default 300s / 5 min), so after a drop/overwrite the DDL succeeds but queries against the reused name return `500 Internal Server Error` until the cache expires — and a fresh `describe` may still show the old schema. Instead, write to a **fresh name**, use `list_tables()` and fail if it already exists, then `rename_table(fresh, final)` onto the final name only after the old table's drop has propagated (~5 min). See the "Enterprise: never drop-then-reuse the same table name" section in `SKILL.md`. Local/OSS tables have no separate data plane — overwrite freely there.
+
+### Guessing performance fixes
+
+Avoid changing `nprobes`, `refine_factor`, or index types before checking the query plan and index stats. Diagnose first, then tune one knob at a time.

.agents/skills/lancedb/references/python/performance.md

@@ -0,0 +1,131 @@
+# Python Performance Guidance
+
+Use this when writing Python code that ingests data, queries large tables, builds indexes, or investigates latency.
+
+## Ingestion
+
+### Recommended: validate schemas and records with Pydantic
+
+Favor `LanceModel` for readable Python schema definitions and validate source
+records before writing. Use PyArrow directly for Arrow-native or streaming
+pipelines where it is the clearer representation.
+
+```python
+from lancedb.pydantic import LanceModel, Vector
+
+class Document(LanceModel):
+    id: int
+    text: str
+    vector: Vector(384, nullable=False)
+
+rows = [Document.model_validate(row) for row in source_rows]
+table = db.create_table("documents", schema=Document)
+table.add(rows)
+```
+
+### Recommended: bulk ingestion for materialized data
+
+```python
+table.add(arrow_table)
+table.add(df)
+table.add(pa.dataset("data/", format="parquet"))
+```
+
+For very large initial loads, create the table empty first, then call `add(...)`. Passing data directly to `create_table(name, data)` can skip the auto-parallel write path.
+
+### Recommended: iterator ingestion for generated or streamed data
+
+```python
+def batches():
+    for raw in source:
+        vectors = model.encode(raw["text"])
+        yield pa.RecordBatch.from_pydict({**raw, "vector": vectors})
+
+table.add(batches())
+```
+
+Use chunks of several thousand rows or more when practical. Tiny batches and per-row writes create many small fragments.
+
+### Anti-pattern: per-row `add()`
+
+```python
+for row in rows:
+    table.add([row])
+```
+
+Each call creates a version and fragment. This slows ingestion and later queries.
+
+## Indexing
+
+- Build a vector index once brute-force vector search becomes too slow. As a rule of thumb, local brute force is fine below roughly 100K vectors; beyond that, build an index.
+- Use `IVF_PQ` as the general-purpose default. Enterprise builds this automatically.
+- Use scalar indexes for filtered columns and merge/upsert keys.
+- Use `BTREE` for mostly distinct numeric/string/temporal columns, `BITMAP` for booleans and low-cardinality columns, and `LABEL_LIST` for list membership queries.
+- Keep full-text defaults unless phrase queries require position data.
+
+## Querying
+
+Always be explicit:
+
+```python
+table.search(query_vector).select(["id", "title"]).limit(20)
+```
+
+- `select()` reduces bytes read and transferred.
+- `limit()` prevents accidental full-table materialization.
+- Pre-filtering is the default and guarantees returned rows satisfy the predicate.
+- Use post-filtering only when fewer than `limit` results are acceptable.
+
+## Recall Tuning
+
+Tune one knob at a time:
+
+- Quantized indexes: raise `refine_factor` to rescore more candidates on full vectors.
+- HNSW-backed indexes: raise `ef`; start around `1.5 * k`, increase toward `10 * k` if recall is short.
+- IVF candidate breadth: `nprobes` is auto-tuned; override only when a selective pre-filter leaves too few neighbors.
+
+## Maintenance
+
+After every successful embedded OSS/local ingestion, call `table.optimize()`.
+Do not add this to LanceDB Enterprise/Cloud remote table code; remote compaction
+and cleanup are handled automatically based on the Enterprise cluster
+configuration.
+
+Why local maintenance is needed:
+
+- Frequent writes can create many small fragments. Queries then need to scan across more files, which can increase latency.
+- Updates, deletes, and appends create new table versions. Old versions are retained for time travel and rollback, which can grow disk usage.
+- Indexes may have newly added rows that are not yet fully optimized into the index structure.
+
+For local/OSS tables, run `optimize()` after the final successful ingestion
+write. Also run it after later batches of update/delete operations or on a
+regular maintenance schedule:
+
+```python
+table.optimize()
+```
+
+If the user wants more aggressive local disk cleanup, pass a shorter cleanup retention window:
+
+```python
+from datetime import timedelta
+
+table.optimize(cleanup_older_than=timedelta(days=1))
+```
+
+Do not use very short cleanup windows when the application depends on time travel, rollback, or old versions.
+
+## Diagnostics
+
+Before changing code or indexes, inspect:
+
+```python
+print(table.search(query_vector).where("year > 2000").limit(10).analyze_plan())
+print(table.index_stats("vector_idx"))
+```
+
+Look for high scan bytes, missing indexes, fragmented data, and unindexed rows.
+
+## Python Multiprocessing
+
+When using multiprocessing, use `spawn` rather than `fork`. LanceDB is multi-threaded internally, and `fork` plus a multi-threaded process is unsafe.

.agents/skills/lancedb/references/typescript/api_reference.md

@@ -0,0 +1,105 @@
+# TypeScript API Reference
+
+Quick method reference for TypeScript LanceDB code. Cross-check source for non-trivial claims.
+
+## Connect
+
+```typescript
+import * as lancedb from "@lancedb/lancedb";
+
+const db = await lancedb.connect("./camelot-db");
+```
+
+**Place the local database directory next to the script/entrypoint that opens it** (resolve the path relative to the module, e.g. via `import.meta.dirname` / `__dirname`), not buried under a shared `data/` folder. The Lance dataset is the database, not a data file — keeping it beside its code makes ownership obvious and paths stable regardless of the working directory the script is launched from.
+
+**Do not name the directory `lancedb`** (e.g. `./lancedb`, `./data/lancedb`). It collides with the imported `lancedb` package/namespace, which is confusing to read. Give it a name derived from the repo or dataset with a clear prefix/suffix — for example `./<dataset>-db`, `./<repo>_lancedb`, or `./vectordb`.
+
+Remote connections use `db://...` plus Enterprise/Cloud credentials and deployment settings. Check current source/docs for exact connection options.
+
+## Table Reads
+
+| Task | Preferred API |
+| --- | --- |
+| Vector search | `table.search(queryVector).limit(k)` |
+| Full scan with filters/projection | `table.query().where(...).select(...).limit(...)` |
+| Filter | `.where("col > 10")` |
+| Projection | `.select(["id", "text"])` |
+| Bound result count | `.limit(20)` |
+| Collect bounded result as objects | `.toArray()` on query/search result |
+| Collect bounded result as Arrow | `.toArrow()` on query/search result |
+| Stream result batches | `for await (const batch of table.query()...)` |
+
+## Local vs Remote Safety
+
+| API | Agent guidance |
+| --- | --- |
+| `table.search(...)` | Preferred read path |
+| `table.query()` | Preferred scan/filter path |
+| `await table.toArrow()` | Avoid in portable or large-table code |
+| `await table.query().toArray()` with no `limit()` | Avoid; unbounded collection |
+| `await table.query().toArrow()` with no `limit()` | Avoid; unbounded collection |
+
+## Indexes
+
+```typescript
+await table.createIndex("vector");
+await table.createIndex("status");
+```
+
+Use vector indexes for large vector search workloads and scalar indexes for filtered columns or merge/upsert keys. Check source/docs before specifying advanced index options.
+
+## Filtering And Recall Knobs
+
+```typescript
+await table.search(queryVector).where("status = 'ready'").limit(10).toArray();
+await table.search(queryVector).limit(10).refineFactor(20).toArray();
+await table.search(queryVector).limit(10).nprobes(50).toArray();
+await table.search(queryVector).limit(10).ef(100).toArray();
+await table.search(queryVector).where("status = 'ready'").postfilter().limit(10).toArray();
+```
+
+Use `postfilter()` only when fewer than `limit` results are acceptable.
+
+## Diagnostics
+
+```typescript
+console.log(await table.search(queryVector).where("year > 2000").limit(10).analyzePlan());
+console.log(await table.indexStats("vector_idx"));
+```
+
+Use these before changing indexes or search tuning.
+
+## Column (Field) Metadata
+
+```typescript
+const schema = await table.schema();
+const meta = schema.fields.find((f) => f.name === "category")?.metadata; // Map<string, string>
+const res = await table.updateFieldMetadata([
+  { path: "category", metadata: { "lancedb:description": "...", "lancedb:tag:field_type": "label" } },
+]);
+res.version; // new table version
+```
+
+Merges by default; a `null` value deletes that key; `replace: true` swaps the whole map. Nested fields use dot-paths (`"a.b.c"`). See `references/column_metadata.md` for key conventions (`lancedb:description`, `lancedb:tag:<name>`, `lancedb:logical-column`) and the authoring workflow.
+
+## Branches
+
+```typescript
+const branches = await table.branches();       // async manager
+await branches.list();                         // non-main branches; {} = only main
+const exp = await branches.create("exp");      // fork off main -> Table scoped to the branch
+const wip = await branches.checkout("wip");    // existing branch -> scoped Table (version arg pins read-only)
+const wip2 = await db.openTable("t", { branch: "wip" }); // or open scoped directly
+await branches.delete("stale");                // removes only the branch pointer
+table.currentBranch();                         // null = main
+```
+
+There is no global switch — scoping is per table handle: any read/write on a branch handle lands on that branch; the original handle keeps targeting main. See `references/branch_ops.md` for the model and isolation checks.
+
+## Maintenance
+
+```typescript
+await table.optimize();
+```
+
+Call this after every successful local/OSS ingestion. It handles compaction, cleanup of old versions according to retention, and index optimization. Do not add this for LanceDB Enterprise/Cloud remote tables; Enterprise handles compaction and cleanup automatically from cluster configuration.

.agents/skills/lancedb/references/typescript/patterns.md

@@ -0,0 +1,100 @@
+# TypeScript Patterns
+
+Use these patterns when writing TypeScript code with `@lancedb/lancedb`.
+
+## Recommended Patterns
+
+### Bounded query
+
+Use this for application reads, scripts, and examples:
+
+```typescript
+const rows = await table
+  .query()
+  .where("status = 'ready'")
+  .select(["id", "text"])
+  .limit(20)
+  .toArray();
+```
+
+### Bounded vector search
+
+```typescript
+const rows = await table
+  .search(queryVector)
+  .select(["id", "text"])
+  .limit(20)
+  .toArray();
+```
+
+### Batch streaming for larger reads
+
+When the task needs many rows, avoid collecting everything at once:
+
+```typescript
+for await (const batch of table
+  .query()
+  .where("status = 'ready'")
+  .select(["id", "text"])
+  .limit(10_000)) {
+  process(batch);
+}
+```
+
+## Anti-Patterns
+
+**Avoid the following anti-patterns in your code.**
+
+### Table-level full materialization
+
+Avoid whole-table collectors in portable or large-table code:
+
+```typescript
+const tableArrow = await table.toArrow();
+```
+
+Why: local tables expose these whole-table collectors, but remote tables intentionally do not — a remote production table can be far larger than a local development table, so it is easy to accidentally pull the entire table into memory.
+
+### Unbounded result collection
+
+Avoid query/search collection without a meaningful limit:
+
+```typescript
+const rows = await table.query().toArray();              // unbounded plain scan
+const rows = await table.search(queryVector).toArray();  // unbounded vector search
+```
+
+Prefer `select(...).limit(...)` before collecting; for large reads, stream in batches instead.
+
+### Per-row writes
+
+Avoid loops that write one row per call:
+
+```typescript
+for (const row of rows) {
+  await table.add([row]); // one commit + fragment per row
+}
+```
+
+Each `add()` creates a new version and fragment. Pass the whole batch in a single call, or chunk very large inputs:
+
+```typescript
+await table.add(rows); // single commit
+// for very large inputs, add in chunks of several thousand rows
+```
+
+### Drop-then-reuse the same table name (Enterprise/Cloud)
+
+Avoid dropping or overwriting a remote table and then reusing that name right away:
+
+```typescript
+await db.dropTable("my_table");
+const table = await db.createTable("my_table", rows);                    // reads 500 for ~5 min
+const table = await db.createTable("my_table", rows, { mode: "overwrite" }); // same problem
+```
+
+Why: Enterprise/Cloud splits DDL (control plane) from query serving (data plane). The data plane caches the dataset behind a table name for up to `table_cache_ttl` (default 300s / 5 min), so after a drop/overwrite the DDL succeeds but queries against the reused name return `500 Internal Server Error` until the cache expires — and a fresh `describe` may still show the old schema. Instead, write to a **fresh name**, use `tableNames()` and fail if it already exists, then `renameTable(fresh, final)` onto the final name only after the old table's drop has propagated (~5 min). See the "Enterprise: never drop-then-reuse the same table name" section in `SKILL.md`. Local/OSS tables have no separate data plane — overwrite freely there.
+
+### Guessing performance fixes
+
+Avoid changing `nprobes`, `refineFactor`, `ef`, or index settings before checking `analyzePlan()` and `indexStats(...)`. Diagnose first, then tune one knob at a time.

.agents/skills/lancedb/references/typescript/performance.md

@@ -0,0 +1,78 @@
+# TypeScript Performance Guidance
+
+Use this when writing TypeScript code that ingests data, queries large tables, builds indexes, or investigates latency.
+
+## Ingestion
+
+- Prefer bulk or batched writes.
+- Avoid per-row write loops; they create many small commits/fragments.
+- For generated data, accumulate reasonable batches before adding.
+- For file-backed data, prefer APIs that stream from Arrow/Parquet-style inputs when available.
+
+## Indexing
+
+- Build a vector index once brute-force vector search becomes too slow. As a rule of thumb, local brute force is fine below roughly 100K vectors; beyond that, build an index.
+- Use the general-purpose vector index defaults unless the task has explicit recall/latency requirements.
+- Build scalar indexes for filtered columns and merge/upsert keys.
+- Use full-text index phrase options only when phrase queries require them.
+
+## Querying
+
+Always be explicit:
+
+```typescript
+await table.search(queryVector).select(["id", "title"]).limit(20).toArray();
+```
+
+- `select()` reduces bytes read and transferred.
+- `limit()` prevents accidental full-table collection.
+- Pre-filtering is the default behavior. Use `postfilter()` only when fewer than `limit` results are acceptable.
+
+## Recall Tuning
+
+Tune one knob at a time:
+
+- Quantized indexes: raise `refineFactor(...)` to rescore more candidates on full vectors.
+- HNSW-backed indexes: raise `ef(...)`; start around `1.5 * k`, increase toward `10 * k` if recall is short.
+- IVF candidate breadth: `nprobes(...)` is usually auto-tuned; override only when a selective pre-filter leaves too few neighbors.
+
+## Maintenance
+
+After every successful embedded OSS/local ingestion, call `table.optimize()`.
+Do not add this to LanceDB Enterprise/Cloud remote table code; remote compaction
+and cleanup are handled automatically based on the Enterprise cluster
+configuration.
+
+Why local maintenance is needed:
+
+- Frequent writes can create many small fragments. Queries then need to scan across more files, which can increase latency.
+- Updates, deletes, and appends create new table versions. Old versions are retained for time travel and rollback, which can grow disk usage.
+- Indexes may have newly added rows that are not yet fully optimized into the index structure.
+
+For local/OSS tables, run `optimize()` after the final successful ingestion
+write. Also run it after later batches of update/delete operations or on a
+regular maintenance schedule:
+
+```typescript
+await table.optimize();
+```
+
+If the user wants more aggressive local disk cleanup, pass a shorter cleanup retention window:
+
+```typescript
+const olderThan = new Date(Date.now() - 24 * 60 * 60 * 1000);
+await table.optimize({ cleanupOlderThan: olderThan });
+```
+
+Do not use very short cleanup windows when the application depends on time travel, rollback, or old versions.
+
+## Diagnostics
+
+Before changing code or indexes, inspect:
+
+```typescript
+console.log(await table.search(queryVector).where("year > 2000").limit(10).analyzePlan());
+console.log(await table.indexStats("vector_idx"));
+```
+
+Look for high scan cost, missing indexes, fragmented data, and unindexed rows.

.agents/skills/lancedb/scripts/check_materialization.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""Scan Python and TypeScript for likely unsafe LanceDB materialization."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+
+PY_FULL_TABLE = re.compile(r"\b\w+\.(to_pandas|to_arrow|to_polars)\s*\(")
+TS_TABLE_TO_ARROW = re.compile(r"\b\w+\.toArrow\s*\(")
+TS_QUERY_COLLECTOR = re.compile(r"\.query\s*\(\s*\)[\s\S]*?\.to(Array|Arrow)\s*\(")
+
+
+@dataclass
+class Finding:
+    path: Path
+    line: int
+    message: str
+    text: str
+
+
+def iter_files(paths: list[Path]) -> list[Path]:
+    files: list[Path] = []
+    for path in paths:
+        if path.is_dir():
+            files.extend(
+                p
+                for p in path.rglob("*")
+                if p.suffix in {".py", ".ts", ".tsx"} and "node_modules" not in p.parts
+            )
+        elif path.suffix in {".py", ".ts", ".tsx"}:
+            files.append(path)
+    return sorted(set(files))
+
+
+def line_number(text: str, offset: int) -> int:
+    return text.count("\n", 0, offset) + 1
+
+
+def scan_python(path: Path, text: str) -> list[Finding]:
+    findings: list[Finding] = []
+    for match in PY_FULL_TABLE.finditer(text):
+        line_start = text.rfind("\n", 0, match.start()) + 1
+        line_end = text.find("\n", match.start())
+        if line_end == -1:
+            line_end = len(text)
+        line = text[line_start:line_end].strip()
+        if ".search(" in line or ".query(" in line:
+            continue
+        findings.append(
+            Finding(
+                path,
+                line_number(text, match.start()),
+                f"Review Python `{match.group(1)}()` call; table-level materialization is not portable to remote tables.",
+                line,
+            )
+        )
+    return findings
+
+
+def statement_around(text: str, start: int, end: int) -> str:
+    before = max(text.rfind(";", 0, start), text.rfind("\n\n", 0, start))
+    after_candidates = [pos for pos in (text.find(";", end), text.find("\n\n", end)) if pos != -1]
+    after = min(after_candidates) if after_candidates else len(text)
+    return text[before + 1 : after].strip()
+
+
+def scan_typescript(path: Path, text: str) -> list[Finding]:
+    findings: list[Finding] = []
+    for match in TS_TABLE_TO_ARROW.finditer(text):
+        stmt = statement_around(text, match.start(), match.end())
+        if ".query(" in stmt or ".search(" in stmt:
+            continue
+        findings.append(
+            Finding(
+                path,
+                line_number(text, match.start()),
+                "Review TypeScript `table.toArrow()`-style call; table-level materialization is not portable for large/remote tables.",
+                stmt.splitlines()[0].strip(),
+            )
+        )
+
+    for match in TS_QUERY_COLLECTOR.finditer(text):
+        stmt = statement_around(text, match.start(), match.end())
+        if ".limit(" in stmt:
+            continue
+        findings.append(
+            Finding(
+                path,
+                line_number(text, match.start()),
+                "Review unbounded TypeScript query collection; add `limit()` or stream batches.",
+                stmt.splitlines()[0].strip(),
+            )
+        )
+    return findings
+
+
+def scan_file(path: Path) -> list[Finding]:
+    text = path.read_text(encoding="utf-8", errors="replace")
+    if path.suffix == ".py":
+        return scan_python(path, text)
+    if path.suffix in {".ts", ".tsx"}:
+        return scan_typescript(path, text)
+    return []
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("paths", nargs="+", type=Path)
+    parser.add_argument(
+        "--no-fail", action="store_true", help="Always exit 0 after reporting findings."
+    )
+    args = parser.parse_args()
+
+    findings: list[Finding] = []
+    for path in iter_files(args.paths):
+        findings.extend(scan_file(path))
+
+    for finding in findings:
+        print(f"{finding.path}:{finding.line}: {finding.message}")
+        print(f"  {finding.text}")
+
+    if findings:
+        print(
+            f"\n{len(findings)} finding(s). Review manually; bounded query result conversion may be OK."
+        )
+    return 0 if args.no_fail or not findings else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.38.0-beta.12"
+current_version = "0.32.0-beta.2"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.
@@ -75,13 +75,6 @@ filename = "nodejs/Cargo.toml"
 replace = "\nversion = \"{new_version}\""
 search = "\nversion = \"{current_version}\""
 
-# The Python package takes its version from here (pyproject.toml declares
-# `dynamic = ["version"]`, so maturin reads it out of the crate manifest).
-[[tool.bumpversion.files]]
-filename = "python/Cargo.toml"
-replace = "\nversion = \"{new_version}\""
-search = "\nversion = \"{current_version}\""
-
 # Java documentation
 [[tool.bumpversion.files]]
 filename = "docs/src/java/java.md"

.cargo/config.toml

@@ -9,18 +9,6 @@ debug = true
 codegen-units = 16
 lto = "thin"
 
-[profile.release-no-lto]
-inherits = "release"
-debug = true
-lto = false
-# Prioritize compile time when LTO is not relevant to the measurement.
-codegen-units = 16
-
-[profile.bench]
-inherits = "release"
-lto = "thin"
-codegen-units = 16
-
 [target.'cfg(all())']
 rustflags = [
     "-Wclippy::all",

.claude-plugin/marketplace.json

@@ -1,19 +0,0 @@
-{
-  "name": "lancedb",
-  "owner": {
-    "name": "LanceDB"
-  },
-  "description": "LanceDB plugins for Claude Code.",
-  "plugins": [
-    {
-      "name": "lancedb",
-      "source": "./plugins/lancedb",
-      "description": "Write, review, debug, and document LanceDB pipelines in Python and TypeScript that work across local LanceDB OSS tables and remote LanceDB Enterprise/Cloud tables.",
-      "version": "0.1.0",
-      "author": {
-        "name": "LanceDB"
-      },
-      "category": "development"
-    }
-  ]
-}

.github/actions/create-failure-issue/action.yml

@@ -27,31 +27,19 @@ runs:
           # Extract failed job names
           FAILED_JOBS=$(echo "$JOB_RESULTS" | jq -r 'to_entries | map(select(.value.result == "failure")) | map(.key) | join(", ")')
 
-          TITLE="$WORKFLOW_NAME Failed ($FAILED_JOBS)"
-
-          # This action now also runs on nightly schedules, so a breakage that
-          # persists for a few days would otherwise file one issue per night.
-          # Comment on the open report instead when one already exists.
-          EXISTING=$(gh issue list --state open --label ci --limit 100 --json number,title \
-            | jq -r --arg title "$TITLE" 'map(select(.title == $title)) | .[0].number // empty')
-
-          if [ -n "$EXISTING" ]; then
-            gh issue comment "$EXISTING" --body "Failed again: $RUN_URL"
-            echo "Commented on existing issue #$EXISTING"
-          else
-            gh issue create \
-              --title "$TITLE" \
-              --body "The workflow **$WORKFLOW_NAME** failed during execution.
+          # Create issue with workflow name, failed jobs, and run URL
+          gh issue create \
+            --title "$WORKFLOW_NAME Failed ($FAILED_JOBS)" \
+            --body "The workflow **$WORKFLOW_NAME** failed during execution.
 
         **Failed jobs:** $FAILED_JOBS
 
         **Run URL:** $RUN_URL
 
         Please investigate the failed jobs and address any issues." \
-              --label "ci"
+            --label "ci"
 
-            echo "Issue created successfully"
-          fi
+          echo "Issue created successfully"
         else
           echo "No job failures detected, skipping issue creation"
         fi

.github/dependabot.yml

@@ -17,18 +17,6 @@ updates:
     # newer minimum versions.
     versioning-strategy: lockfile-only
     groups:
-      # The arrow-rs and datafusion crates are released in lockstep and have to
-      # move together, so keep them in one PR instead of one per sub-crate.
-      # Listed first: a dependency joins the first group it matches.
-      arrow-datafusion:
-        patterns:
-          - arrow
-          - arrow-*
-          - parquet
-          - parquet-*
-          - datafusion
-          - datafusion-*
-          - object_store
       rust-minor-patch:
         update-types:
           - minor
@@ -44,27 +32,3 @@ updates:
       python-deps:
         patterns:
           - "*"
-
-  # The npm ecosystem covers pnpm lockfiles. There are two separate installs:
-  # the bindings themselves and the examples, which have their own lockfile.
-  # As with cargo and pip above, only bump the lockfile — the version ranges
-  # in package.json are our consumers' constraints, not ours.
-  - package-ecosystem: npm
-    directory: /nodejs
-    schedule:
-      interval: weekly
-    versioning-strategy: lockfile-only
-    groups:
-      nodejs-deps:
-        patterns:
-          - "*"
-
-  - package-ecosystem: npm
-    directory: /nodejs/examples
-    schedule:
-      interval: weekly
-    versioning-strategy: lockfile-only
-    groups:
-      nodejs-examples-deps:
-        patterns:
-          - "*"

.github/workflows/build_linux_wheel/action.yml

@@ -18,14 +18,6 @@ inputs:
     description: "The manylinux version to build for"
     required: false
     default: "2_17"
-  package-name:
-    description: "Override [project] name in python/pyproject.toml (e.g. 'lancedb-compat'). Default keeps 'lancedb'."
-    required: false
-    default: "lancedb"
-  rustflags:
-    description: "RUSTFLAGS for the build container, as a single whitespace-free token (e.g. '-Ctarget-cpu=x86-64-v2'). Empty leaves RUSTFLAGS unset, keeping the defaults from .cargo/config.toml."
-    required: false
-    default: ""
 runs:
   using: "composite"
   steps:
@@ -35,18 +27,6 @@ runs:
         ARM_BUILD: ${{ inputs.arm-build }}
       run: |
         echo "ARM BUILD: $ARM_BUILD"
-    - name: Patch package name for variant build
-      if: ${{ inputs.package-name != 'lancedb' }}
-      shell: bash
-      env:
-        PACKAGE_NAME: ${{ inputs.package-name }}
-      run: |
-        # Swap the [project] name so this build produces e.g. lancedb-compat
-        # wheels. The package still installs files under the lancedb/
-        # namespace -- import lancedb still works after pip install.
-        sed -i.bak 's/^name = "lancedb"$/name = "'"$PACKAGE_NAME"'"/' python/pyproject.toml
-        rm -f python/pyproject.toml.bak
-        grep '^name = ' python/pyproject.toml
     - name: Build x86_64 Manylinux wheel
       if: ${{ inputs.arm-build == 'false' }}
       uses: PyO3/maturin-action@v1
@@ -54,7 +34,7 @@ runs:
         maturin-version: "1.12.4"
         command: build
         working-directory: python
-        docker-options: "-e PIP_EXTRA_INDEX_URL='https://pypi.fury.io/lance-format/ https://pypi.fury.io/lancedb/' -e PROTOC=/usr/local/bin/protoc ${{ inputs.rustflags != '' && format('-e RUSTFLAGS={0}', inputs.rustflags) || '' }}"
+        docker-options: "-e PIP_EXTRA_INDEX_URL='https://pypi.fury.io/lance-format/ https://pypi.fury.io/lancedb/' -e PROTOC=/usr/local/bin/protoc"
         target: x86_64-unknown-linux-gnu
         manylinux: ${{ inputs.manylinux }}
         args: ${{ inputs.args }}
@@ -71,7 +51,7 @@ runs:
         maturin-version: "1.12.4"
         command: build
         working-directory: python
-        docker-options: "-e PIP_EXTRA_INDEX_URL='https://pypi.fury.io/lance-format/ https://pypi.fury.io/lancedb/' -e PROTOC=/usr/local/bin/protoc ${{ inputs.rustflags != '' && format('-e RUSTFLAGS={0}', inputs.rustflags) || '' }}"
+        docker-options: "-e PIP_EXTRA_INDEX_URL='https://pypi.fury.io/lance-format/ https://pypi.fury.io/lancedb/' -e PROTOC=/usr/local/bin/protoc"
         target: aarch64-unknown-linux-gnu
         manylinux: ${{ inputs.manylinux }}
         args: ${{ inputs.args }}

.github/workflows/cargo-publish.yml

@@ -6,6 +6,7 @@ on:
       # We don't publish pre-releases for Rust. Crates.io is just a source
       # distribution, so we don't need to publish pre-releases.
       - "v*-beta*"
+      - "*-v*" # for example, python-vX.Y.Z
 
 env:
   # This env var is used by Swatinem/rust-cache@v2 for the cache

.github/workflows/ci-scripts.yml

@@ -1,30 +0,0 @@
-name: CI scripts
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - ci/set_lance_version.py
-      - ci/tests/**
-      - .github/workflows/ci-scripts.yml
-  pull_request:
-    paths:
-      - ci/set_lance_version.py
-      - ci/tests/**
-      - .github/workflows/ci-scripts.yml
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    name: Test CI scripts
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: "3.13"
-      - name: Run tests
-        run: python -m unittest discover -s ci/tests -v

.github/workflows/codex-update-lance-dependency.yml

@@ -4,14 +4,14 @@ on:
   workflow_call:
     inputs:
       tag:
-        description: "Tag name from Lance (e.g. `v7.2.0-beta.1`). If omitted, the newest release is resolved automatically — stable releases are preferred over pre-releases — and the run is skipped if it is not newer than the version currently pinned in Cargo.toml."
+        description: "Tag name from Lance. If omitted, the skill will use the latest Lance release that needs an update."
         required: false
         default: ""
         type: string
   workflow_dispatch:
     inputs:
       tag:
-        description: "Tag name from Lance (e.g. `v7.2.0-beta.1`). Leave empty to resolve the newest release automatically — stable releases are preferred over pre-releases — and skip the run if it is not newer than the version currently pinned in Cargo.toml."
+        description: "Tag name from Lance. Leave empty to use the latest Lance release that needs an update."
         required: false
         default: ""
         type: string

.github/workflows/dev.yml

@@ -29,14 +29,12 @@ jobs:
     steps:
       - uses: actions/setup-node@v6
         with:
-          node-version: "24"
-      - uses: pnpm/action-setup@v6
-        with:
-          version: 11.1.1
+          node-version: "18"
       # These rules are disabled because Github will always ensure there
       # is a blank line between the title and the body and Github will
       # word wrap the description field to ensure a reasonable max line
       # length.
+      - run: npm install @commitlint/config-conventional
       - run: >
           echo 'module.exports = {
             "rules": {
@@ -45,11 +43,7 @@ jobs:
               "body-leading-blank": [0, "always"]
             }
           }' > .commitlintrc.js
-      - run: >
-          pnpm dlx
-          --package @commitlint/cli@21.2.2
-          --package @commitlint/config-conventional@21.2.2
-          commitlint --extends @commitlint/config-conventional --verbose <<< $COMMIT_MSG
+      - run: npx commitlint --extends @commitlint/config-conventional --verbose <<< $COMMIT_MSG
         env:
           COMMIT_MSG: >
             ${{ github.event.pull_request.title }}
@@ -60,7 +54,7 @@ jobs:
         with:
           script: |
             const message = `**ACTION NEEDED**
-
+              
               Lance follows the [Conventional Commits specification](https://www.conventionalcommits.org/en/v1.0.0/) for release automation.
 
               The PR title and description are used as the merge commit message.\

.github/workflows/docs-link-check.yml

@@ -1,243 +0,0 @@
-name: Check doc links
-
-# Checking external links is inherently noisy: third-party sites rate-limit
-# automated clients, reject non-browser user agents, and go down temporarily.
-# Blocking pull requests on that trades a lot of false failures for very little
-# signal, so this runs on a schedule and reports findings in a single tracking
-# issue instead of failing anyone's build.
-on:
-  schedule:
-    - cron: "0 7 * * *"
-  workflow_dispatch:
-
-# The report lives in one repository-global issue, so runs must not overlap: a
-# lookup racing a create produces duplicate issues, and a healthy run closing
-# the issue while a failing run only rewrites its body would leave a broken
-# report closed. The group is deliberately ref-independent so that a manual
-# dispatch serializes against the scheduled run.
-concurrency:
-  group: docs-link-check
-  cancel-in-progress: false
-
-permissions: {}
-
-env:
-  REPORT_TITLE: "Docs link checker report"
-
-jobs:
-  scan:
-    name: Scan links
-    runs-on: ubuntu-24.04
-    # lychee-action is pinned by SHA, but its wrapper downloads the lychee
-    # release tarball at run time without verifying a digest, and hands the
-    # resulting binary a GitHub token. Release assets remain replaceable, so
-    # that binary is confined to a job whose token can only read public
-    # content; everything that writes runs in the report job below.
-    permissions:
-      contents: read
-    outputs:
-      checker_outcome: ${{ steps.lychee.outcome }}
-      exit_code: ${{ steps.lychee.outputs.exit_code }}
-      status: ${{ steps.validate.outputs.status }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          # workflow_dispatch can run from any ref, but the report is
-          # repository-global. Always measure the default branch so a manual
-          # run from a topic branch cannot close a report that main warrants,
-          # or overwrite it with branch-only findings.
-          ref: ${{ github.event.repository.default_branch }}
-          persist-credentials: false
-
-      - name: Check links
-        id: lychee
-        continue-on-error: true
-        uses: lycheeverse/lychee-action@e7477775783ea5526144ba13e8db5eec57747ce8 # v2.9.0
-        with:
-          # Restricted to http(s) on purpose. Much of docs/src is generated
-          # API reference (the js/ tree comes from `pnpm run docs` in nodejs)
-          # and the hand-written pages use mkdocstrings cross-references and
-          # nav-relative paths that only resolve in the site mkdocs builds,
-          # not in this checkout, so relative links would be reported as
-          # broken on every run.
-          args: >-
-            --scheme https
-            --scheme http
-            --no-progress
-            --max-retries 3
-            --timeout 20
-            'docs/src/**/*.md'
-          format: json
-          output: ./lychee/out.json
-          jobSummary: false
-          # The report issue, not a red workflow run, is the signal for link
-          # findings and checker failures alike.
-          fail: false
-
-      - name: Validate report
-        id: validate
-        # lychee does not reserve exit code 2 for broken links: its CLI
-        # parser also exits 2 on an invalid option, before any link was
-        # checked or any report written. Only a parseable report whose
-        # counts agree with a completed exit code (0 or 2) counts as a link
-        # verdict. Everything else becomes a checker-error report instead of
-        # failing the workflow. Exit 2 covers timeouts as well as errors, and a
-        # timed-out host is exactly the transient unavailability this report
-        # exists to surface, so both count as findings. Requiring total > 0
-        # also catches a glob that silently stopped matching any file.
-        if: always()
-        env:
-          CHECKER_OUTCOME: ${{ steps.lychee.outcome }}
-          EXIT_CODE: ${{ steps.lychee.outputs.exit_code }}
-        run: |
-          status=checker-error
-          if [[ "$CHECKER_OUTCOME" == success ]] &&
-             [[ "$EXIT_CODE" == 0 || "$EXIT_CODE" == 2 ]] &&
-             jq -e --argjson code "$EXIT_CODE" '
-               (.total > 0) and
-               (if $code == 0
-                then .errors == 0 and .timeouts == 0
-                  and (.error_map | length == 0) and (.timeout_map | length == 0)
-                else (.errors + .timeouts) > 0
-                  and ((.error_map | length) + (.timeout_map | length)) > 0
-                end)
-             ' ./lychee/out.json
-          then
-            if [[ "$EXIT_CODE" == 0 ]]; then
-              status=healthy
-            else
-              status=findings
-            fi
-          fi
-          echo "status=$status" >> "$GITHUB_OUTPUT"
-          echo "Validated link check as $status"
-
-      - name: Upload report
-        if: steps.validate.outputs.status == 'findings'
-        uses: actions/upload-artifact@v7
-        with:
-          name: link-report
-          path: ./lychee/out.json
-          retention-days: 7
-
-  report:
-    name: Update report issue
-    needs: scan
-    runs-on: ubuntu-24.04
-    # Deliberately no checkout: this job needs the report artifact and the
-    # issues API, not the repository contents.
-    permissions:
-      issues: write
-    env:
-      CHECKER_OUTCOME: ${{ needs.scan.outputs.checker_outcome }}
-      EXIT_CODE: ${{ needs.scan.outputs.exit_code }}
-      STATUS: ${{ needs.scan.outputs.status }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - name: Find existing report issue
-        id: report
-        # Matched on title alone, and through search rather than a listing:
-        # the issue action applies labels in a separate call after creating the
-        # issue, so a label filter misses a half-created report, and this
-        # repository has far more open issues than one listing page holds.
-        # Closed issues are included because a healthy run closes the report:
-        # an open-only lookup would forget that identity and the next failing
-        # run would open a duplicate. The oldest match stays the canonical
-        # report and is reopened below when a problem recurs.
-        run: |
-          match=$(gh issue list --repo "$GITHUB_REPOSITORY" --state all \
-            --search "in:title \"$REPORT_TITLE\" author:app/github-actions" \
-            --limit 50 --json number,title,state \
-            --jq "[.[] | select(.title == \"$REPORT_TITLE\")] | sort_by(.number) | first // empty")
-          echo "number=$(jq -r '.number // empty' <<<"$match")" >> "$GITHUB_OUTPUT"
-          echo "state=$(jq -r '.state // empty' <<<"$match")" >> "$GITHUB_OUTPUT"
-
-      - name: Download report
-        if: env.STATUS == 'findings'
-        uses: actions/download-artifact@v8
-        with:
-          name: link-report
-          path: ./lychee
-
-      - name: Compose report
-        if: env.STATUS == 'findings'
-        run: |
-          run_url="$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID"
-          {
-            echo "Broken documentation links found by [\`$GITHUB_WORKFLOW\`]($run_url)."
-            echo
-            echo "This issue is rewritten by every scheduled run and closed automatically once all links resolve."
-            echo
-            echo "Entries can be false positives: some sites rate-limit or block automated clients while working fine in a browser. Confirm before editing the docs, and add persistent offenders to \`--exclude\` in \`.github/workflows/docs-link-check.yml\`."
-            echo
-            # Timeouts are reported alongside errors: entries land in
-            # timeout_map with a status text instead of an HTTP code.
-            jq -r '
-              "\(.errors) of \(.total) links failed, \(.timeouts) timed out.",
-              "",
-              ([(.error_map | to_entries[]), (.timeout_map | to_entries[])]
-               | group_by(.key)[] |
-                "### Errors in \(.[0].key)",
-                "",
-                (map(.value[])[] | "* [\(.status.code // .status.text // "ERR")] <\(.url)> — \(.status.details // .status.text // "unknown error")"),
-                "")
-            ' ./lychee/out.json
-          } > ./lychee/issue.md
-
-      - name: Compose checker error report
-        if: env.STATUS == 'checker-error'
-        run: |
-          mkdir -p ./lychee
-          run_url="$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID"
-          {
-            echo "The documentation link check did not complete in [the latest run]($run_url)."
-            echo
-            echo "This issue is rewritten by every scheduled run and closed automatically once a trustworthy run finds that all links resolve."
-            echo
-            echo "The checker did not produce a trustworthy link verdict. Treat the previous result, if any, as stale until a later run completes."
-            echo
-            echo "* Action outcome: \`$CHECKER_OUTCOME\`"
-            echo "* Exit code: \`${EXIT_CODE:-not reported}\`"
-            echo "* Verdict validation: \`failed\`"
-          } > ./lychee/issue.md
-
-      - name: Reopen report issue
-        # A healthy run closes the report, and the issue action below only
-        # rewrites the body of whatever number it is given. Without an
-        # explicit reopen, a later finding or checker error would rewrite a
-        # closed issue. A CLOSED state implies the lookup found a canonical
-        # issue, so no separate emptiness check.
-        if: >-
-          env.STATUS != 'healthy' &&
-          steps.report.outputs.state == 'CLOSED'
-        env:
-          ISSUE_NUMBER: ${{ steps.report.outputs.number }}
-        run: |
-          run_url="$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID"
-          gh issue reopen "$ISSUE_NUMBER" --repo "$GITHUB_REPOSITORY" \
-            --comment "The documentation link checker reported a problem again in [the latest run]($run_url)."
-
-      - name: Report link-check problem
-        if: env.STATUS != 'healthy'
-        uses: peter-evans/create-issue-from-file@fca9117c27cdc29c6c4db3b86c48e4115a786710 # v6.0.0
-        with:
-          # Empty on the first failing run, which creates the issue; afterwards
-          # the same issue is updated in place.
-          issue-number: ${{ steps.report.outputs.number }}
-          title: ${{ env.REPORT_TITLE }}
-          content-filepath: ./lychee/issue.md
-          labels: documentation
-
-      - name: Close report issue once links are healthy
-        # An OPEN state implies the lookup found a canonical issue; a report
-        # that is already closed needs nothing.
-        if: >-
-          env.STATUS == 'healthy' &&
-          steps.report.outputs.state == 'OPEN'
-        env:
-          ISSUE_NUMBER: ${{ steps.report.outputs.number }}
-        run: |
-          run_url="$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID"
-          gh issue close "$ISSUE_NUMBER" --repo "$GITHUB_REPOSITORY" \
-            --comment "All documentation links resolved in [the latest run]($run_url)."

.github/workflows/docs.yml

@@ -55,7 +55,9 @@ jobs:
       - name: Set up node
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 20
+          cache: 'npm'
+          cache-dependency-path: docs/package-lock.json
       - name: Install node dependencies
         working-directory: nodejs
         run: |

.github/workflows/gh-release.yml

@@ -1,85 +0,0 @@
-name: GitHub Release
-
-# All SDKs share one version, so a single `vX.Y.Z` tag produces a single GitHub
-# release covering all of them. The per-package publish workflows (PyPI, NPM,
-# Cargo, Maven) trigger off the same tag independently.
-
-on:
-  push:
-    tags:
-      - "v*"
-
-permissions:
-  contents: read
-
-jobs:
-  gh-release:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-          lfs: true
-      - name: Extract version
-        id: extract_version
-        env:
-          GITHUB_REF: ${{ github.ref }}
-        run: |
-          set -e
-          echo "Extracting tag and version from $GITHUB_REF"
-          if [[ $GITHUB_REF =~ refs/tags/v(.*) ]]; then
-            VERSION=${BASH_REMATCH[1]}
-            TAG=v$VERSION
-            echo "tag=$TAG" >> $GITHUB_OUTPUT
-            echo "version=$VERSION" >> $GITHUB_OUTPUT
-          else
-            echo "Failed to extract version from $GITHUB_REF"
-            exit 1
-          fi
-          echo "Extracted version $VERSION from $GITHUB_REF"
-          if [[ $VERSION =~ beta ]]; then
-            echo "This is a beta release"
-            echo "prerelease=true" >> $GITHUB_OUTPUT
-
-            # Get last release (that is not this one)
-            FROM_TAG=$(git tag --sort='version:refname' \
-              | grep ^v \
-              | grep -vF "$TAG" \
-              | python ci/semver_sort.py v \
-              | tail -n 1)
-          else
-            echo "This is a stable release"
-            echo "prerelease=false" >> $GITHUB_OUTPUT
-            # Get last stable tag (ignore betas)
-            FROM_TAG=$(git tag --sort='version:refname' \
-              | grep ^v \
-              | grep -vF "$TAG" \
-              | grep -v beta \
-              | python ci/semver_sort.py v \
-              | tail -n 1)
-          fi
-          echo "Found from tag $FROM_TAG"
-          echo "from_tag=$FROM_TAG" >> $GITHUB_OUTPUT
-      - name: Create Release Notes
-        id: release_notes
-        uses: mikepenz/release-changelog-builder-action@v4
-        with:
-          configuration: .github/release_notes.json
-          toTag: ${{ steps.extract_version.outputs.tag }}
-          fromTag: ${{ steps.extract_version.outputs.from_tag }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      - name: Create GH release
-        uses: softprops/action-gh-release@v2
-        with:
-          # Marking betas as pre-releases keeps them from taking the "Latest"
-          # badge on the releases page.
-          prerelease: ${{ steps.extract_version.outputs.prerelease }}
-          make_latest: ${{ steps.extract_version.outputs.prerelease == 'false' }}
-          tag_name: ${{ steps.extract_version.outputs.tag }}
-          token: ${{ secrets.GITHUB_TOKEN }}
-          generate_release_notes: false
-          name: LanceDB v${{ steps.extract_version.outputs.version }}
-          body: ${{ steps.release_notes.outputs.changelog }}

.github/workflows/make-release-commit.yml

@@ -1,14 +1,13 @@
 name: Create release commit
 
-# This workflow increments the version, tags it, and pushes it. All SDKs share
-# a single version, so one tag releases all of them.
+# This workflow increments versions, tags the version, and pushes it.
 # When a tag is pushed, another workflow is triggered that creates a GH release
 # and uploads the binaries. This workflow is only for creating the tag.
 
 # This script will enforce that a minor version is incremented if there are any
-# breaking changes since the last minor increment. A breaking change in any SDK
-# bumps the minor version for all of them. If you wish to bypass this check, you
-# can manually increment the version and push the tag.
+# breaking changes since the last minor increment. However, it isn't able to
+# differentiate between breaking changes in Node versus Python. If you wish to
+# bypass this check, you can manually increment the version and push the tag.
 on:
   workflow_dispatch:
     inputs:
@@ -25,6 +24,16 @@ on:
         options:
           - preview
           - stable
+      python:
+        description: 'Make a Python release'
+        required: true
+        default: true
+        type: boolean
+      other:
+        description: 'Make a Node/Rust/Java release'
+        required: true
+        default: true
+        type: boolean
       bump-minor:
         description: 'Bump minor version'
         required: true
@@ -56,16 +65,29 @@ jobs:
         run: |
           git config user.name 'Lance Release'
           git config user.email 'lance-dev@lancedb.com'
-      - name: Bump version
+      - name: Bump Python version
+        if: ${{ inputs.python }}
+        working-directory: python
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Need to get the commit before bumping the version, so we can
+          # determine if there are breaking changes in the next step as well.
+          echo "COMMIT_BEFORE_BUMP=$(git rev-parse HEAD)" >> $GITHUB_ENV
+
+          pip install bump-my-version PyGithub packaging
+          bash ../ci/bump_version.sh ${{ inputs.type }} ${{ inputs.bump-minor }} python-v
+      - name: Bump Node/Rust version
+        if: ${{ inputs.other }}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           pip install bump-my-version PyGithub packaging
-          bash ci/bump_version.sh ${{ inputs.type }} ${{ inputs.bump-minor }}
+          bash ci/bump_version.sh ${{ inputs.type }} ${{ inputs.bump-minor }} v $COMMIT_BEFORE_BUMP
           bash ci/update_lockfiles.sh --amend
       - name: Push new version tag
         if: ${{ !inputs.dry_run }}
-        uses: ad-m/github-push-action@881a6320fdb16eb5318c5054f31c218aec2b324c # v1.3.0
+        uses: ad-m/github-push-action@master
         with:
           # Need to use PAT here too to trigger next workflow. See comment above.
           github_token: ${{ secrets.LANCEDB_RELEASE_TOKEN }}

.github/workflows/nodejs.yml

@@ -47,8 +47,9 @@ jobs:
         version: 11.1.1
     - uses: actions/setup-node@v6
       with:
-        # Build on a supported LTS; the matrix job below covers every
-        # Node version the library claims to support.
+        # pnpm 11 requires Node >= 22.13; use 24 since 22 hits EOL
+        # in October. The library itself still supports Node >= 18
+        # (see test matrix below).
         node-version: 24
         cache: 'pnpm'
         cache-dependency-path: nodejs/pnpm-lock.yaml
@@ -60,11 +61,6 @@ jobs:
         sudo apt update
         sudo apt install -y protobuf-compiler libssl-dev
     - uses: Swatinem/rust-cache@v2
-      with:
-        # Restore everywhere, but only save from main. Per-PR saves are
-        # unreadable outside their own branch anyway, since GitHub scopes
-        # caches to the creating ref.
-        save-if: ${{ github.ref == 'refs/heads/main' }}
     - name: Format Rust
       run: cargo fmt --all -- --check
     - name: Lint Rust
@@ -83,7 +79,7 @@ jobs:
     timeout-minutes: 30
     strategy:
       matrix:
-        node-version: [ "22", "24", "26" ]
+        node-version: [ "18", "20" ]
     runs-on: "ubuntu-22.04"
     defaults:
       run:
@@ -100,18 +96,13 @@ jobs:
     - uses: actions/setup-node@v6
       name: Setup Node.js 24 for build
       with:
-        # Build and install once on a fixed version so the generated docs
-        # are identical across matrix legs; the tests below then run on each
-        # supported Node version.
+        # pnpm 11 requires Node >= 22.13; use 24 since 22 hits EOL
+        # in October. Build/install runs on Node 24; tests run on the
+        # matrix version below using direct jest invocation.
         node-version: 24
         cache: 'pnpm'
         cache-dependency-path: nodejs/pnpm-lock.yaml
     - uses: Swatinem/rust-cache@v2
-      with:
-        # Restore everywhere, but only save from main. Per-PR saves are
-        # unreadable outside their own branch anyway, since GitHub scopes
-        # caches to the creating ref.
-        save-if: ${{ github.ref == 'refs/heads/main' }}
     - name: Install dependencies
       run: |
         sudo apt update
@@ -151,9 +142,9 @@ jobs:
         S3_TEST: "1"
         # Newer @smithy/core uses dynamic ESM imports.
         NODE_OPTIONS: "--experimental-vm-modules"
-      # Invoke the installed jest binary directly; the pnpm shim is set up
-      # against the build-phase Node, not the version selected above.
-      run: node_modules/.bin/jest --verbose
+      # Invoke jest directly because pnpm 11 itself requires Node 22+
+      # while the matrix tests on older Node versions.
+      run: npx jest --verbose
     - name: Test examples
       working-directory: ./
       env:
@@ -163,7 +154,7 @@ jobs:
       run: |
         python ci/mock_openai.py &
         cd nodejs/examples
-        node_modules/.bin/jest --testEnvironment jest-environment-node-single-context --verbose
+        npx jest --testEnvironment jest-environment-node-single-context --verbose
   macos:
     timeout-minutes: 30
     # macos-15 ships a newer linker; the older macos-14 linker fails to insert
@@ -184,17 +175,13 @@ jobs:
         version: 11.1.1
     - uses: actions/setup-node@v6
       with:
-        # pnpm 11 requires Node >= 22.13.
+        # pnpm 11 requires Node >= 22.13; use 24 since 22 hits EOL
+        # in October.
         node-version: 24
         cache: 'pnpm'
         cache-dependency-path: nodejs/pnpm-lock.yaml
     - uses: dtolnay/rust-toolchain@stable
     - uses: Swatinem/rust-cache@v2
-      with:
-        # Restore everywhere, but only save from main. Per-PR saves are
-        # unreadable outside their own branch anyway, since GitHub scopes
-        # caches to the creating ref.
-        save-if: ${{ github.ref == 'refs/heads/main' }}
     - name: Install dependencies
       run: |
         brew install protobuf

.github/workflows/npm-publish.yml

@@ -10,16 +10,10 @@ permissions:
 
 on:
   push:
+    branches:
+      - main
     tags:
       - "v*"
-  # The cross-compiled targets (musl especially) break from toolchain and
-  # dependency changes that nothing else in CI catches, and discovering that
-  # mid-release is expensive. A nightly run keeps that signal while dropping
-  # the full 8-target release matrix from all ~90 pushes to main each month.
-  # `report-failure` files an issue when a nightly breaks.
-  schedule:
-    - cron: "0 8 * * *"
-  workflow_dispatch:
   pull_request:
     # This should trigger a dry run (we skip the final publish step)
     paths:
@@ -32,6 +26,73 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  gh-release:
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Extract version
+        id: extract_version
+        env:
+          GITHUB_REF: ${{ github.ref }}
+        run: |
+          set -e
+          echo "Extracting tag and version from $GITHUB_REF"
+          if [[ $GITHUB_REF =~ refs/tags/v(.*) ]]; then
+            VERSION=${BASH_REMATCH[1]}
+            TAG=v$VERSION
+            echo "tag=$TAG" >> $GITHUB_OUTPUT
+            echo "version=$VERSION" >> $GITHUB_OUTPUT
+          else
+            echo "Failed to extract version from $GITHUB_REF"
+            exit 1
+          fi
+          echo "Extracted version $VERSION from $GITHUB_REF"
+          if [[ $VERSION =~ beta ]]; then
+            echo "This is a beta release"
+
+            # Get last release (that is not this one)
+            FROM_TAG=$(git tag --sort='version:refname' \
+              | grep ^v \
+              | grep -vF "$TAG" \
+              | python ci/semver_sort.py v \
+              | tail -n 1)
+          else
+            echo "This is a stable release"
+            # Get last stable tag (ignore betas)
+            FROM_TAG=$(git tag --sort='version:refname' \
+              | grep ^v \
+              | grep -vF "$TAG" \
+              | grep -v beta \
+              | python ci/semver_sort.py v \
+              | tail -n 1)
+          fi
+          echo "Found from tag $FROM_TAG"
+          echo "from_tag=$FROM_TAG" >> $GITHUB_OUTPUT
+      - name: Create Release Notes
+        id: release_notes
+        uses: mikepenz/release-changelog-builder-action@v4
+        with:
+          configuration: .github/release_notes.json
+          toTag: ${{ steps.extract_version.outputs.tag }}
+          fromTag: ${{ steps.extract_version.outputs.from_tag }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Create GH release
+        uses: softprops/action-gh-release@v2
+        with:
+          prerelease: ${{ contains('beta', github.ref) }}
+          tag_name: ${{ steps.extract_version.outputs.tag }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+          generate_release_notes: false
+          name: Node/Rust LanceDB v${{ steps.extract_version.outputs.version }}
+          body: ${{ steps.release_notes.outputs.changelog }}
+
   build-lancedb:
     strategy:
       fail-fast: false
@@ -40,31 +101,31 @@ jobs:
           - target: aarch64-apple-darwin
             host: macos-latest
             features: fp16kernels
-            # Fat LTO was ~111 of this job's ~113 minutes.
-            lto: thin
-            codegen_units: 16
-            pre_build: |-
-              brew install protobuf
+            pre_build: brew install protobuf
           - target: x86_64-pc-windows-msvc
-            host: windows-2025
+            host: windows-2025-8x-x64
             features: ","
-            # The lower peak also keeps this on the standard 4-core runner.
-            lto: thin
-            codegen_units: 16
             pre_build: |-
               choco install --no-progress protoc ninja nasm
               tail -n 1000 /c/ProgramData/chocolatey/logs/chocolatey.log
               # There is an issue where choco doesn't add nasm to the path
               export PATH="$PATH:/c/Program Files/NASM"
               nasm -v
+              # Fat LTO of the cdylib is single-threaded and the peak-memory
+              # step of the build, and had started hitting rustc-LLVM OOM on the
+              # Windows runners. ThinLTO parallelizes it across the runner's
+              # cores and keeps peak memory well under the limit.
+              export CARGO_PROFILE_RELEASE_LTO=thin
+              export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=16
           - target: aarch64-pc-windows-msvc
-            host: windows-2025
+            host: windows-2025-8x-x64
             features: ","
-            lto: thin
-            codegen_units: 16
             pre_build: |-
                 choco install --no-progress protoc
                 rustup target add aarch64-pc-windows-msvc
+                # See ThinLTO note on the x86_64-pc-windows-msvc target above.
+                export CARGO_PROFILE_RELEASE_LTO=thin
+                export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=16
           - target: x86_64-unknown-linux-gnu
             host: ubuntu-latest
             features: fp16kernels
@@ -94,14 +155,6 @@ jobs:
             # https://github.com/napi-rs/napi-rs/blob/main/debian-aarch64.Dockerfile
             docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64
             features: "fp16kernels"
-            # Fat LTO OOM-killed rustc every nightly; even with lld it peaked
-            # at 31391 MiB of the runner's 32 GiB.
-            lto: thin
-            codegen_units: 16
-            # arm64 Linux links through GNU `ld` where x86_64 defaults to
-            # `rust-lld`, which is why only arm64 OOM'd. lld cut the largest
-            # linker process 7.0 -> 4.0 GiB (lancedb/sophon#7313).
-            linker: /tmp/aarch64-lld-clang
             pre_build: |-
               set -e &&
               apt-get update &&
@@ -111,30 +164,9 @@ jobs:
               # AT_HWCAP2 (added in Linux 3.17). Define it for aws-lc-sys.
               export CFLAGS="$CFLAGS -DAT_HWCAP2=26" &&
               rustup target add aarch64-unknown-linux-gnu
-              # Not `&&`-chained: in dash, errexit does not fire for a
-              # non-final command in an `&&` list, so failures were ignored.
-              #
-              # A wrapper rather than `-C link-arg` because the per-target
-              # rustflags variable does not reach every unit that links, while
-              # the linker variable does. `clang` because GCC silently ignores
-              # `-fuse-ld=lld` unless built with lld support. Two echoes
-              # because printf's newline escape gets rewritten to `;` between
-              # here and the container.
-              echo '#!/bin/sh' > /tmp/aarch64-lld-clang
-              echo 'exec clang --target=aarch64-unknown-linux-gnu --sysroot=/usr/aarch64-unknown-linux-gnu/aarch64-unknown-linux-gnu/sysroot --gcc-toolchain=/usr/aarch64-unknown-linux-gnu -fuse-ld=lld "$@"' >> /tmp/aarch64-lld-clang
-              chmod 0755 /tmp/aarch64-lld-clang
-              # Fail now, not at the cdylib link ~30 minutes later. Linking at
-              # all also proves lld resolved; clang errors out when it cannot.
-              echo 'int main(void){return 0;}' > /tmp/probe.c
-              /tmp/aarch64-lld-clang /tmp/probe.c -o /tmp/probe
-              readelf -h /tmp/probe | grep AArch64
           - target: aarch64-unknown-linux-musl
             host: ubuntu-2404-8x-x64
             features: ","
-            # Fat LTO took the whole runner down. lld cannot help: it died
-            # inside rustc's LLVM, before any linker was spawned.
-            lto: thin
-            codegen_units: 16
             pre_build: |-
               set -e &&
               sudo apt-get update &&
@@ -143,19 +175,6 @@ jobs:
               export EXTRA_ARGS="-x"
     name: build - ${{ matrix.settings.target }}
     runs-on: ${{ matrix.settings.host }}
-    # On the job, not exported from `pre_build`: `Swatinem/rust-cache` hashes
-    # `CARGO_*` into its cache key before any step runs, so a step-local export
-    # leaves the key unchanged while cargo still rebuilds cold. The ThinLTO
-    # legs had been doing that every run.
-    #
-    # Not `RUSTFLAGS`: setting it, even to "", discards every config-file
-    # rustflag, silently dropping .cargo/config.toml's `target-cpu` and
-    # `target-feature` from the published binaries.
-    env:
-      CARGO_PROFILE_RELEASE_LTO: ${{ matrix.settings.lto || 'fat' }}
-      CARGO_PROFILE_RELEASE_CODEGEN_UNITS: ${{ matrix.settings.codegen_units || '1' }}
-      # Empty elsewhere: a per-target variable is only read for that triple.
-      CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: ${{ matrix.settings.linker }}
     defaults:
       run:
         working-directory: nodejs
@@ -168,7 +187,8 @@ jobs:
       - name: Setup node
         uses: actions/setup-node@v6
         with:
-          # pnpm 11 requires Node >= 22.13.
+          # pnpm 11 requires Node >= 22.13; use 24 since 22 hits EOL
+          # in October.
           node-version: 24
           cache: pnpm
           cache-dependency-path: nodejs/pnpm-lock.yaml
@@ -178,45 +198,16 @@ jobs:
         with:
           toolchain: stable
           targets: ${{ matrix.settings.target }}
-      # These builds were entirely uncached: the old key was static, so
-      # `actions/cache` (which only writes on a miss) could never refresh it,
-      # and the multi-GB whole-`target/` copy it tried to store never fit the
-      # repo's cache budget, so no entry was ever saved. rust-cache prunes
-      # `target/` to dependency artifacts and keys on Cargo.lock plus the rustc
-      # version, which both fixes the key and keeps entries a sane size.
-      #
-      # This caches dependency *compilation* only. The LTO link of the cdylib
-      # re-runs regardless, since the local crate changes every time, so the
-      # win is larger on the non-LTO jobs than here.
-      - name: Cache cargo (native builds)
-        uses: Swatinem/rust-cache@v2
-        if: ${{ !matrix.settings.docker }}
+      - name: Cache cargo
+        uses: actions/cache@v5
         with:
-          # The release profile and per-target dirs differ from what the test
-          # workflows cache, so these need to be separate entries.
-          key: release-${{ matrix.settings.target }}
-          # Only the nightly run on main writes, so tag and PR runs restore a
-          # warm entry without every dependabot PR writing its own (which would
-          # be unreadable elsewhere anyway, since GitHub scopes caches to the
-          # creating ref). The nightly cadence also keeps entries inside
-          # GitHub's 7-day eviction window, which a tag-only trigger would not.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-      # Docker builds can use rust-cache too: the workspace is bind-mounted, so
-      # `target/` lives on the host and rust-cache's prune keeps the entry
-      # small.
-      #
-      # Two differences from the native builds. The container's CARGO_HOME is
-      # bind-mounted from `.cargo-cache` rather than ~/.cargo, so that is cached
-      # explicitly. And the key uses the *host* rustc version, not the compiler
-      # that built these artifacts -- safe, since cargo fingerprints the real
-      # one; a base-image bump just costs one cold build.
-      - name: Cache cargo (docker builds)
-        uses: Swatinem/rust-cache@v2
-        if: ${{ matrix.settings.docker }}
-        with:
-          key: docker-${{ matrix.settings.target }}
-          cache-directories: .cargo-cache
-          save-if: ${{ github.ref == 'refs/heads/main' }}
+          path: |
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            .cargo-cache
+            target/
+          key: nodejs-${{ matrix.settings.target }}-cargo-${{ matrix.settings.host }}
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
       - name: Install Zig
@@ -234,43 +225,24 @@ jobs:
         if: ${{ matrix.settings.docker }}
         with:
           image: ${{ matrix.settings.docker }}
-          # All three mounts must live under `.cargo-cache`, which is what the
-          # cache step above saves. Previously the registry mounts pointed at
-          # `.cargo/...`, a path nothing cached, so the container re-downloaded
-          # the whole crate registry on every run.
-          #
-          # `docker run` inherits nothing; `-e NAME` carries the job's `env:` in.
           options: "--user 0:0 -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db \
-                    -v ${{ github.workspace }}/.cargo-cache/registry/cache:/usr/local/cargo/registry/cache \
-                    -v ${{ github.workspace }}/.cargo-cache/registry/index:/usr/local/cargo/registry/index \
-                    -e CARGO_PROFILE_RELEASE_LTO \
-                    -e CARGO_PROFILE_RELEASE_CODEGEN_UNITS \
-                    -e CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER \
+                    -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache \
+                    -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index \
                     -v ${{ github.workspace }}:/build -w /build/nodejs"
           run: |
             set -e
             ${{ matrix.settings.pre_build }}
-            node_modules/.bin/napi build --platform --release \
+            npx napi build --platform --release \
               --features ${{ matrix.settings.features }} \
               --target ${{ matrix.settings.target }} \
               --dts ../lancedb/native.d.ts \
               --js ../lancedb/native.js \
               --strip \
               --output-dir dist/
-      # The container runs as root (`--user 0:0`), so everything it wrote to the
-      # mounted cache dirs is root-owned. rust-cache's post step runs as the
-      # runner user and has to both read these and delete from them while
-      # pruning, so hand them back before it runs.
-      - name: Take ownership of docker build output
-        if: ${{ matrix.settings.docker }}
-        run: |
-          sudo chown -R "$(id -u):$(id -g)" \
-            "${{ github.workspace }}/.cargo-cache" \
-            "${{ github.workspace }}/target"
       - name: Build
         run: |
           ${{ matrix.settings.pre_build }}
-          node_modules/.bin/napi build --platform --release \
+          npx napi build --platform --release \
               --features ${{ matrix.settings.features }} \
               --target ${{ matrix.settings.target }} \
               --dts ../lancedb/native.d.ts \
@@ -280,27 +252,6 @@ jobs:
               --output-dir dist/
         if: ${{ !matrix.settings.docker }}
         shell: bash
-      # The standard Windows runners have ~14 GB free, and a release `target/`
-      # for this workspace is a large fraction of that. Report the remaining
-      # headroom so a build that only just fits is visible before a dependency
-      # bump turns it into a failed release. `always()` so the numbers are
-      # still there when the build is what ran out of space.
-      - name: Report disk headroom
-        if: always()
-        run: df -h
-        shell: bash
-      - name: Report peak memory
-        if: always() && runner.os == 'Linux'
-        shell: bash
-        run: |
-          peak=$(find /sys/fs/cgroup -name memory.peak -readable \
-                 -exec cat {} + 2>/dev/null | sort -n | tail -1)
-          if [ -n "$peak" ]; then
-            echo "peak memory: $((peak / 1024 / 1024)) MiB"
-          else
-            echo "peak memory: unavailable (no readable cgroup v2 memory.peak)"
-          fi
-          free -g || true
       - name: Upload artifact
         uses: actions/upload-artifact@v7
         with:
@@ -338,7 +289,7 @@ jobs:
           - target: aarch64-unknown-linux-gnu
             host: ubuntu-2404-8x-arm64
         node:
-          - '22'
+          - '20'
     runs-on: ${{ matrix.settings.host }}
     defaults:
       run:
@@ -384,9 +335,9 @@ jobs:
       - name: Move built files
         run: cp dist/native.d.ts dist/native.js dist/*.node lancedb/
       - name: Test bindings
-        # Invoke the installed jest binary directly; the pnpm shim is set up
-        # against the install-phase Node, not the version selected above.
-        run: node_modules/.bin/jest --verbose
+        # Invoke jest directly because pnpm 11 itself requires Node 22+
+        # while the matrix tests on older Node versions.
+        run: npx jest --verbose
   publish:
     name: Publish
     runs-on: ubuntu-latest
@@ -451,9 +402,7 @@ jobs:
     name: Report Workflow Failure
     runs-on: ubuntu-latest
     needs: [build-lancedb, test-lancedb, publish]
-    # Nightly runs are the only thing watching the cross-compiled targets now,
-    # so they have to report failures too or the signal is silently lost.
-    if: always() && failure() && (startsWith(github.ref, 'refs/tags/v') || github.event_name == 'schedule')
+    if: always() && failure() && startsWith(github.ref, 'refs/tags/v')
     permissions:
       contents: read
       issues: write

.github/workflows/pypi-publish.yml

@@ -3,7 +3,7 @@ name: PyPI Publish
 on:
   push:
     tags:
-      - 'v*'
+      - 'python-v*'
   pull_request:
     # This should trigger a dry run (we skip the final publish step)
     paths:
@@ -20,15 +20,9 @@ env:
 permissions:
   contents: read
 
-# Without this, a force-push to a PR leaves the previous run going -- including
-# a ~74 minute Windows job and a billed arm64 wheel build.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
 jobs:
   linux:
-    name: Python ${{ matrix.config.package_name }} ${{ matrix.config.platform }} manylinux${{ matrix.config.manylinux }}
+    name: Python ${{ matrix.config.platform }} manylinux${{ matrix.config.manylinux }}
     timeout-minutes: 60
     strategy:
       matrix:
@@ -37,28 +31,11 @@ jobs:
             manylinux: "2_28"
             extra_args: "--features fp16kernels"
             runner: ubuntu-22.04
-            package_name: "lancedb"
-            rustflags: ""
           # For successful fat LTO builds, we need a large runner to avoid OOM errors.
           - platform: aarch64
             manylinux: "2_28"
             extra_args: "--features fp16kernels"
             runner: ubuntu-2404-8x-arm64
-            package_name: "lancedb"
-            rustflags: ""
-          # `lancedb-compat`: pre-Haswell-friendly variant for x86_64 hosts
-          # without AVX2 (Sandy Bridge / Ivy Bridge / Westmere on Intel,
-          # Bulldozer / Piledriver / Steamroller on AMD). Compiled at the
-          # `x86-64-v2` baseline; runtime SIMD dispatch in lance-linalg
-          # picks the appropriate tier (scalar / AVX / AVX+FMA / AVX2+FMA
-          # / AVX-512) at load time. Same import as `lancedb` -- conflicts
-          # at install time, so users pick one.
-          - platform: x86_64
-            manylinux: "2_28"
-            extra_args: ""
-            runner: ubuntu-22.04
-            package_name: "lancedb-compat"
-            rustflags: "-Ctarget-cpu=x86-64-v2"
     runs-on: ${{ matrix.config.runner }}
     steps:
       - uses: actions/checkout@v6
@@ -69,29 +46,17 @@ jobs:
         uses: actions/setup-python@v6
         with:
           python-version: "3.10"
-      - name: Add swap for Arm fat LTO
-        if: matrix.config.platform == 'aarch64'
-        shell: bash
-        run: |
-          swap_file="$RUNNER_TEMP/lancedb-swap"
-          sudo fallocate --length 16G "$swap_file"
-          sudo chmod 600 "$swap_file"
-          sudo mkswap "$swap_file"
-          sudo swapon "$swap_file"
-          free -h
       - uses: ./.github/workflows/build_linux_wheel
         with:
           python-minor-version: 10
           args: "--release --strip ${{ matrix.config.extra_args }}"
           arm-build: ${{ matrix.config.platform == 'aarch64' }}
           manylinux: ${{ matrix.config.manylinux }}
-          package-name: ${{ matrix.config.package_name }}
-          rustflags: ${{ matrix.config.rustflags }}
       - uses: actions/upload-artifact@v7
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/python-v')
         with:
-          name: wheels-linux-${{ matrix.config.package_name }}-${{ matrix.config.platform }}-${{ matrix.config.manylinux }}
-          path: target/wheels/*.whl
+          name: wheels-linux-${{ matrix.config.platform }}-${{ matrix.config.manylinux }}
+          path: target/wheels/lancedb-*.whl
           if-no-files-found: error
   mac:
     timeout-minutes: 90
@@ -117,7 +82,7 @@ jobs:
           python-minor-version: 10
           args: "--release --strip --target ${{ matrix.config.target }} --features fp16kernels"
       - uses: actions/upload-artifact@v7
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/python-v')
         with:
           name: wheels-mac-${{ matrix.config.target }}
           path: target/wheels/lancedb-*.whl
@@ -129,12 +94,6 @@ jobs:
       # link.exe is single-threaded and the long pole on Windows builds. Use
       # rustc's bundled lld-link instead.
       CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER: rust-lld
-      # Fat LTO of the cdylib is single-threaded and the peak-memory step of the
-      # build. ThinLTO parallelizes it across the runner's cores, at some cost
-      # to runtime performance on our least performance-sensitive platform.
-      # Matches what the nodejs Windows builds already do in npm-publish.yml.
-      CARGO_PROFILE_RELEASE_LTO: thin
-      CARGO_PROFILE_RELEASE_CODEGEN_UNITS: 16
     steps:
       - uses: actions/checkout@v6
         with:
@@ -144,26 +103,19 @@ jobs:
         uses: actions/setup-python@v6
         with:
           python-version: "3.13"
-      # NOTE: caching cargo here would be a no-op. This workflow only runs on
-      # tags and PRs, and GitHub only lets a run restore caches from its own ref
-      # or the default branch -- so with no run on main there is nothing that
-      # can populate an entry the release build would be allowed to read. Fixing
-      # this needs a main/nightly trigger (which would also catch wheel-build
-      # breakage before a release); the ~74 minutes here is otherwise dominated
-      # by the fat-LTO link, which no cache avoids.
       - uses: ./.github/workflows/build_windows_wheel
         with:
           python-minor-version: 10
           args: "--release --strip"
       - uses: actions/upload-artifact@v7
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/python-v')
         with:
           name: wheels-windows
           path: target/wheels/lancedb-*.whl
           if-no-files-found: error
   publish:
     name: Publish wheels
-    if: startsWith(github.ref, 'refs/tags/v')
+    if: startsWith(github.ref, 'refs/tags/python-v')
     needs: [linux, mac, windows]
     runs-on: ubuntu-latest
     permissions:
@@ -193,7 +145,7 @@ jobs:
           FURY_TOKEN: ${{ secrets.FURY_TOKEN }}
         run: |
           shopt -s nullglob
-          WHEELS=(target/wheels/*.whl)
+          WHEELS=(target/wheels/lancedb-*.whl)
           if [[ ${#WHEELS[@]} -eq 0 ]]; then
             echo "No wheels found in target/wheels/" >&2
             exit 1
@@ -212,6 +164,72 @@ jobs:
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           packages-dir: target/wheels/
+  gh-release:
+    if: startsWith(github.ref, 'refs/tags/python-v')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Extract version
+        id: extract_version
+        env:
+          GITHUB_REF: ${{ github.ref }}
+        run: |
+          set -e
+          echo "Extracting tag and version from $GITHUB_REF"
+          if [[ $GITHUB_REF =~ refs/tags/python-v(.*) ]]; then
+            VERSION=${BASH_REMATCH[1]}
+            TAG=python-v$VERSION
+            echo "tag=$TAG" >> $GITHUB_OUTPUT
+            echo "version=$VERSION" >> $GITHUB_OUTPUT
+          else
+            echo "Failed to extract version from $GITHUB_REF"
+            exit 1
+          fi
+          echo "Extracted version $VERSION from $GITHUB_REF"
+          if [[ $VERSION =~ beta ]]; then
+            echo "This is a beta release"
+
+            # Get last release (that is not this one)
+            FROM_TAG=$(git tag --sort='version:refname' \
+              | grep ^python-v \
+              | grep -vF "$TAG" \
+              | python ci/semver_sort.py python-v \
+              | tail -n 1)
+          else
+            echo "This is a stable release"
+            # Get last stable tag (ignore betas)
+            FROM_TAG=$(git tag --sort='version:refname' \
+              | grep ^python-v \
+              | grep -vF "$TAG" \
+              | grep -v beta \
+              | python ci/semver_sort.py python-v \
+              | tail -n 1)
+          fi
+          echo "Found from tag $FROM_TAG"
+          echo "from_tag=$FROM_TAG" >> $GITHUB_OUTPUT
+      - name: Create Python Release Notes
+        id: python_release_notes
+        uses: mikepenz/release-changelog-builder-action@v4
+        with:
+          configuration: .github/release_notes.json
+          toTag: ${{ steps.extract_version.outputs.tag }}
+          fromTag: ${{ steps.extract_version.outputs.from_tag }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Create Python GH release
+        uses: softprops/action-gh-release@v2
+        with:
+          prerelease: ${{ contains('beta', github.ref) }}
+          tag_name: ${{ steps.extract_version.outputs.tag }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+          generate_release_notes: false
+          name: Python LanceDB v${{ steps.extract_version.outputs.version }}
+          body: ${{ steps.python_release_notes.outputs.changelog }}
   report-failure:
     name: Report Workflow Failure
     runs-on: ubuntu-latest
@@ -219,7 +237,7 @@ jobs:
     permissions:
       contents: read
       issues: write
-    if: always() && failure() && startsWith(github.ref, 'refs/tags/v')
+    if: always() && failure() && startsWith(github.ref, 'refs/tags/python-v')
     steps:
       - uses: actions/checkout@v6
       - uses: ./.github/actions/create-failure-issue

.github/workflows/python.yml

@@ -108,15 +108,6 @@ jobs:
         run: |
           sudo apt update
           sudo apt install -y protobuf-compiler
-      # `pip install -e .` builds the extension with maturin, which is most of
-      # this job's ~33 minutes. It had no Rust cache, so every dependency was
-      # recompiled from scratch on every run.
-      - uses: Swatinem/rust-cache@v2
-        with:
-          # Restore everywhere, but only save from main. Per-PR saves are
-          # unreadable outside their own branch anyway, since GitHub scopes
-          # caches to the creating ref.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Install
         run: |
           pip install --extra-index-url https://pypi.fury.io/lance-format/ --extra-index-url https://pypi.fury.io/lancedb/ -e .[tests,dev,embeddings]
@@ -177,14 +168,6 @@ jobs:
         uses: actions/setup-python@v6
         with:
           python-version: "3.13"
-      # maturin runs cargo natively on macOS (docker is Linux-only), so the host
-      # target dir is cacheable. This job had no Rust cache.
-      - uses: Swatinem/rust-cache@v2
-        with:
-          # Restore everywhere, but only save from main. Per-PR saves are
-          # unreadable outside their own branch anyway, since GitHub scopes
-          # caches to the creating ref.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
       - uses: ./.github/workflows/build_mac_wheel
         with:
           args: --profile ci
@@ -214,14 +197,6 @@ jobs:
         uses: actions/setup-python@v6
         with:
           python-version: "3.13"
-      # maturin runs cargo natively on Windows (docker is Linux-only), so the
-      # host target dir is cacheable. This job had no Rust cache at all and so
-      # rebuilt every dependency from scratch on every run.
-      - uses: Swatinem/rust-cache@v2
-        with:
-          # Restore everywhere, but only save from main. The repo sits at
-          # GitHub's cache cap, so per-PR saves just evict main's entries.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
       - uses: ./.github/workflows/build_windows_wheel
         with:
           args: --profile ci
@@ -229,8 +204,7 @@ jobs:
       # Make sure wheels are not included in the Rust cache
       - name: Delete wheels
         run: rm -rf target/wheels
-  min-deps:
-    name: "Minimum dependencies"
+  pydantic1x:
     timeout-minutes: 60
     runs-on: "ubuntu-24.04"
     defaults:
@@ -250,17 +224,10 @@ jobs:
         uses: actions/setup-python@v6
         with:
           python-version: "3.10"
-      # As with Doctest, `pip install -e .` compiles the extension and this job
-      # had no Rust cache, which is most of its ~37 minutes.
-      - uses: Swatinem/rust-cache@v2
-        with:
-          # Restore everywhere, but only save from main. Per-PR saves are
-          # unreadable outside their own branch anyway, since GitHub scopes
-          # caches to the creating ref.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Install lancedb
         run: |
-          pip install "pydantic==2.7.4" "pyarrow==16"
+          pip install "pydantic<2"
+          pip install pyarrow==16
           pip install --extra-index-url https://pypi.fury.io/lance-format/ --extra-index-url https://pypi.fury.io/lancedb/ -e .[tests]
       - name: Run tests
         run: pytest -m "not slow and not s3_test" -x -v --durations=30 python/tests

.github/workflows/rust.yml

@@ -48,11 +48,6 @@ jobs:
         with:
           components: rustfmt, clippy
       - uses: Swatinem/rust-cache@v2
-        with:
-          # Restore everywhere, but only save from main. Per-PR saves are
-          # unreadable outside their own branch anyway, since GitHub scopes
-          # caches to the creating ref.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Install dependencies
         run: |
           sudo apt update
@@ -94,11 +89,6 @@ jobs:
         run: rm -f Cargo.lock
       - uses: rui314/setup-mold@v1
       - uses: Swatinem/rust-cache@v2
-        with:
-          # Restore everywhere, but only save from main. Per-PR saves are
-          # unreadable outside their own branch anyway, since GitHub scopes
-          # caches to the creating ref.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Install dependencies
         run: |
           sudo apt update
@@ -108,7 +98,7 @@ jobs:
           cargo build --profile ci --benches --all-features --tests
 
   linux:
-    timeout-minutes: 60
+    timeout-minutes: 30
     # To build all features, we need more disk space than is available
     # on the free OSS github runner. This is mostly due to the the
     # sentence-transformers feature.
@@ -121,17 +111,13 @@ jobs:
       # Need up-to-date compilers for kernels
       CC: clang-18
       CXX: clang++-18
+      GH_TOKEN: ${{ secrets.SOPHON_READ_TOKEN }}
     steps:
       - uses: actions/checkout@v6
         with:
           fetch-depth: 0
           lfs: true
       - uses: Swatinem/rust-cache@v2
-        with:
-          # Restore everywhere, but only save from main. Per-PR saves are
-          # unreadable outside their own branch anyway, since GitHub scopes
-          # caches to the creating ref.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Install dependencies
         run: |
           sudo apt update
@@ -164,44 +150,15 @@ jobs:
       - name: Run feature tests
         run: CARGO_ARGS="--profile ci" make -C ./lancedb feature-tests
       - name: Run examples
-        run: cargo run --profile ci --all-features --example simple --locked
-
-  remote:
-    timeout-minutes: 30
-    # Running this requires access to secrets, so skip if this is a PR from a
-    # fork. Keep it separate from the all-features build so Cargo does not
-    # retain both dependency graphs in one target directory.
-    if: github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork
-    runs-on: ubuntu-2404-4x-x64
-    defaults:
-      run:
-        shell: bash
-        working-directory: rust
-    env:
-      CC: clang-18
-      CXX: clang++-18
-      GH_TOKEN: ${{ secrets.SOPHON_READ_TOKEN }}
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-          lfs: true
-      - uses: Swatinem/rust-cache@v2
-        with:
-          # Remote tests use a different feature graph from the main Linux
-          # job. Cache downloads, but build into a fresh target directory.
-          cache-targets: false
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-      - name: Install dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y protobuf-compiler libssl-dev
-      - uses: rui314/setup-mold@v1
+        run: cargo run  --profile ci --example simple --locked
       - name: Run remote tests
+        # Running this requires access to secrets, so skip if this is
+        # a PR from a fork.
+        if: github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork
         run: CARGO_ARGS="--profile ci" make -C ./lancedb remote-tests
 
   macos:
-    timeout-minutes: 60
+    timeout-minutes: 30
     strategy:
       matrix:
         mac-runner: ["macos-14", "macos-15"]
@@ -218,11 +175,6 @@ jobs:
       - name: CPU features
         run: sysctl -a | grep cpu
       - uses: Swatinem/rust-cache@v2
-        with:
-          # Restore everywhere, but only save from main. Per-PR saves are
-          # unreadable outside their own branch anyway, since GitHub scopes
-          # caches to the creating ref.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Install dependencies
         run: brew install protobuf
       - name: Run tests
@@ -235,19 +187,12 @@ jobs:
           cargo test --profile ci --features $ALL_FEATURES --locked
 
   windows:
+    runs-on: windows-2022
     strategy:
-      fail-fast: false
       matrix:
-        include:
-          - target: x86_64-pc-windows-msvc
-            runner: windows-2022
-          # windows-11-arm is a standard runner, so it is free on public repos.
-          # Running natively lets the aarch64 tests actually execute -- this
-          # job used to cross-compile them and then skip the test step, paying
-          # full codegen and link cost for a compile check.
-          - target: aarch64-pc-windows-msvc
-            runner: windows-11-arm
-    runs-on: ${{ matrix.runner }}
+        target:
+          - x86_64-pc-windows-msvc
+          - aarch64-pc-windows-msvc
     defaults:
       run:
         working-directory: rust/lancedb
@@ -256,11 +201,6 @@ jobs:
       - name: Set target
         run: rustup target add ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v2
-        with:
-          # Restore everywhere, but only save from main. Per-PR saves are
-          # unreadable outside their own branch anyway, since GitHub scopes
-          # caches to the creating ref.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Install Protoc v21.12
         run: choco install --no-progress protoc
       - name: Build
@@ -268,12 +208,11 @@ jobs:
           $env:VCPKG_ROOT = $env:VCPKG_INSTALLATION_ROOT
           cargo build --profile ci --features aws,remote --tests --locked --target ${{ matrix.target }}
       - name: Run tests
+        # Can only run tests when target matches host
+        if: ${{ matrix.target == 'x86_64-pc-windows-msvc' }}
         run: |
           $env:VCPKG_ROOT = $env:VCPKG_INSTALLATION_ROOT
-          # `--target` has to match the build step above. Without it cargo uses
-          # target/ci/ rather than target/<triple>/ci/ and rebuilds the entire
-          # dependency graph a second time.
-          cargo test --profile ci --features aws,remote --locked --target ${{ matrix.target }}
+          cargo test --profile ci --features aws,remote --locked
 
   msrv:
     # Check the minimum supported Rust version
@@ -299,11 +238,6 @@ jobs:
         with:
           toolchain: ${{ matrix.msrv }}
       - uses: Swatinem/rust-cache@v2
-        with:
-          # Restore everywhere, but only save from main. Per-PR saves are
-          # unreadable outside their own branch anyway, since GitHub scopes
-          # caches to the creating ref.
-          save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Downgrade  dependencies
         # These packages have newer requirements for MSRV
         run: |
@@ -324,18 +258,16 @@ jobs:
           cargo update -p aws-types --precise 1.3.9
           cargo update -p aws-sigv4 --precise 1.3.5
           cargo update -p aws-credential-types --precise 1.2.8
-          # aws-smithy-checksums must stay at or above 0.63.13: OpenDAL's S3
-          # service needs crc-fast ~1.9, and older releases pin it to ~1.3.
-          cargo update -p aws-smithy-checksums --precise 0.63.13
+          cargo update -p aws-smithy-checksums --precise 0.63.9
           cargo update -p aws-smithy-runtime --precise 1.9.3
-          cargo update -p aws-smithy-http --precise 0.62.6
-          cargo update -p aws-smithy-eventstream --precise 0.60.14
+          cargo update -p aws-smithy-http --precise 0.62.4
+          cargo update -p aws-smithy-eventstream --precise 0.60.12
           cargo update -p aws-smithy-http-client --precise 1.1.3
           cargo update -p aws-smithy-observability --precise 0.1.4
           cargo update -p aws-smithy-query --precise 0.60.8
-          cargo update -p aws-smithy-runtime-api --precise 1.9.3
-          cargo update -p aws-smithy-async --precise 1.2.7
-          cargo update -p aws-smithy-types --precise 1.3.6
+          cargo update -p aws-smithy-runtime-api --precise 1.9.1
+          cargo update -p aws-smithy-async --precise 1.2.6
+          cargo update -p aws-smithy-types --precise 1.3.5
           cargo update -p aws-smithy-xml --precise 0.60.11
           cargo update -p home --precise 0.5.9
       - name: cargo +${{ matrix.msrv }} check

.github/workflows/update_package_lock_run.yml

@@ -0,0 +1,22 @@
+name: Update package-lock.json
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          ref: main
+          persist-credentials: false
+          fetch-depth: 0
+          lfs: true
+      - uses: ./.github/workflows/update_package_lock
+        with:
+          github_token: ${{ secrets.LANCEDB_RELEASE_TOKEN }}

.github/workflows/update_package_lock_run_nodejs.yml

@@ -0,0 +1,22 @@
+name: Update NodeJs package-lock.json
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          ref: main
+          persist-credentials: false
+          fetch-depth: 0
+          lfs: true
+      - uses: ./.github/workflows/update_package_lock_nodejs
+        with:
+          github_token: ${{ secrets.LANCEDB_RELEASE_TOKEN }}

.pre-commit-config.yaml

@@ -20,10 +20,7 @@ repos:
     hooks:
       - id: local-biome-check
         name: biome check
-        # Use the biome from nodejs/package.json rather than a separately
-        # pinned one: the two drifted apart and disagreed on formatting, so
-        # this hook rejected code that `pnpm lint` accepted.
-        entry: nodejs/node_modules/.bin/biome check --config-path nodejs/biome.json nodejs/
+        entry: npx @biomejs/biome@1.8.3 check --config-path nodejs/biome.json nodejs/
         language: system
         types: [text]
         files: "nodejs/.*"

AGENTS.md

@@ -18,9 +18,6 @@ Common commands:
 * Run specific test: `cargo test --quiet --features remote -p <package_name> --test <test_name>`
 * Lint: `cargo clippy --quiet --features remote --tests --examples`
 * Format Rust: `cargo fmt --all`
-* Use repository-defined Cargo profiles instead of ad hoc LTO overrides.
-* Use `release-with-debug` for benchmarks and profiling so optimized builds keep debug symbols without a rebuild.
-* Use `release-no-lto` only for local debugging, IO-bound benchmarks, or compile-time-sensitive performance investigation where LTO would not affect the measured bottleneck.
 * Format Python: `ruff format .`
 * Lint Python: `ruff check .`
 * Bootstrap Python dev env: `cd python && uv run --extra tests --extra dev maturin develop --extras tests,dev`
@@ -38,7 +35,7 @@ Before committing changes, run formatting for every language you touched. At min
 * Rust changes: run `cargo fmt --all`.
 * Python changes: run `ruff format .` and `ruff check .` from the repository root,
   and run targeted tests through `cd python && uv run ...`.
-* TypeScript changes: run the relevant `pnpm` lint, format, build, and docs commands in `nodejs`.
+* TypeScript changes: run the relevant `npm`/`pnpm` lint, format, build, and docs commands in `nodejs`.
 
 Before creating a PR, the exact value passed to `gh pr create --title` must follow
 Conventional Commits, such as `fix: support nested field paths in native index creation`
@@ -95,45 +92,16 @@ Python bindings changes:
     * Should use `LOOP.run()` to call the corresponding `AsyncTable` method.
 6. Add concrete sync method to `RemoteTable` class in `python/python/lancedb/remote/table.py`.
 7. Add unit test in `python/tests/test_table.py`.
-8. If you added a new public class or module-level function (not just a method on an
-   existing class), expose it in the API reference. See "Python API reference" below.
 
 TypeScript bindings changes:
 
 1. Add napi-rs method binding on `Table` in `nodejs/src/table.rs`.
-2. Run `pnpm build` to generate TypeScript definitions.
+2. Run `npm run build` to generate TypeScript definitions.
 3. Add typescript method on abstract class `Table` in `nodejs/src/table.ts`.
 4. Add concrete method on `LocalTable` class in `nodejs/src/native_table.ts`.
     * Note: despite the name, this class is also used for remote tables.
 5. Add test in `nodejs/__test__/table.test.ts`.
-6. Run `pnpm run docs` to generate TypeScript documentation.
-
-## Python API reference
-
-`docs/src/python/python.md` is the entire Python API reference. It is maintained by
-hand, and anything not listed there is not rendered at all, so new public classes and
-module-level functions have to be added explicitly. How depends on the module:
-
-* `lancedb.index`, `lancedb.embeddings`, `lancedb.remote`, and `lancedb.rerankers` are
-  rendered by a single directive each, driven by the module's `__all__`. Add the new
-  name to `__all__` and it appears; forget, and it is silently omitted.
-* Everything else (`lancedb`, `lancedb.table`, `lancedb.query`, `lancedb.db`, ...) is
-  listed symbol by symbol. Add a `::: lancedb.<module>.<Name>` line to the matching
-  section, and remember that the page separates synchronous and asynchronous APIs.
-
-Deliberately undocumented: concrete implementations reached through an abstract base
-(`LanceTable`, `LanceDBConnection`, `RemoteDBConnection`), query base classes already
-covered by `inherited_members`, and internal helpers.
-
-Cross-references in docstrings use mkdocstrings syntax, `[text][lancedb.table.Table]`.
-Plain relative links such as `[Table](Table)` do not resolve. To check your work:
-
-```shell
-pip install -r docs/requirements.txt
-cd docs && PYTHONPATH=. mkdocs build
-```
-
-The docs site only builds on pushes to `main`, so this is not covered by PR CI.
+6. Run `npm run docs` to generate TypeScript documentation.
 
 ## Review Guidelines
 

Cargo.toml

@@ -13,21 +13,20 @@ categories = ["database-implementations"]
 rust-version = "1.91.0"
 
 [workspace.dependencies]
-lance = { "version" = "=12.0.0-beta.2", default-features = false, "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-core = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-datagen = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-file = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-io = { "version" = "=12.0.0-beta.2", default-features = false, "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-index = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-linalg = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-namespace = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-namespace-impls = { "version" = "=12.0.0-beta.2", default-features = false, "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-table = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-testing = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-datafusion = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-encoding = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-arrow = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lancedb = { path = "rust/lancedb", default-features = false }
+lance = { "version" = "=9.1.0-beta.2", default-features = false, "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-core = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-datagen = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-file = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-io = { "version" = "=9.1.0-beta.2", default-features = false, "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-index = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-linalg = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-namespace = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-namespace-impls = { "version" = "=9.1.0-beta.2", default-features = false, "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-table = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-testing = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-datafusion = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-encoding = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance-arrow = { "version" = "=9.1.0-beta.2", "tag" = "v9.1.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
 ahash = "0.8"
 # Note that this one does not include pyarrow
 arrow = { version = "58.0.0", optional = false }
@@ -40,7 +39,6 @@ arrow-schema = "58.0.0"
 arrow-select = "58.0.0"
 arrow-cast = "58.0.0"
 async-trait = "0"
-bytes = "1"
 datafusion = { version = "54.0.0", default-features = false }
 datafusion-catalog = "54.0.0"
 datafusion-common = { version = "54.0.0", default-features = false }
@@ -54,7 +52,7 @@ env_logger = "0.11"
 half = { "version" = "2.7.1", default-features = false, features = [
     "num-traits",
 ] }
-futures = "0.3"
+futures = "0"
 log = "0.4"
 metrics = "0.24"
 metrics-util = "0.19"
@@ -66,13 +64,9 @@ snafu = "0.8"
 url = "2"
 num-traits = "0.2"
 regex = "1.10"
+lazy_static = "1"
 semver = "1.0.25"
-serde = "1"
-serde_json = "1"
-tempfile = "3.5.0"
-tokio = { version = "1.23", features = ["rt-multi-thread", "sync"] }
-uuid = { version = "1.7.0", features = ["v4"] }
-chrono = { version = "0.4", default-features = false, features = ["clock"] }
+chrono = "0.4"
 
 [profile.ci]
 debug = "line-tables-only"

Makefile

@@ -5,5 +5,5 @@ licenses:
 	cd python && cargo about generate ../about.hbs -o RUST_THIRD_PARTY_LICENSES.html -c ../about.toml
 	cd python && uv sync --all-extras && uv tool run pip-licenses --python .venv/bin/python --format=markdown --with-urls --output-file=PYTHON_THIRD_PARTY_LICENSES.md
 	cd nodejs && cargo about generate ../about.hbs -o RUST_THIRD_PARTY_LICENSES.html -c ../about.toml
-	cd nodejs && pnpm dlx license-checker@25 --markdown --out NODEJS_THIRD_PARTY_LICENSES.md
+	cd nodejs && npx license-checker --markdown --out NODEJS_THIRD_PARTY_LICENSES.md
 	cd java && ./mvnw license:aggregate-add-third-party -q

ci/bump_version.sh

@@ -2,9 +2,9 @@ set -e
 
 RELEASE_TYPE=${1:-"stable"}
 BUMP_MINOR=${2:-false}
-HEAD_SHA=$(git rev-parse HEAD)
+TAG_PREFIX=${3:-"v"} # Such as "python-v"
+HEAD_SHA=${4:-$(git rev-parse HEAD)}
 
-readonly TAG_PREFIX="v"
 readonly SELF_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
 
 PREV_TAG=$(git tag --sort='version:refname' | grep ^$TAG_PREFIX | python $SELF_DIR/semver_sort.py $TAG_PREFIX | tail -n 1)
@@ -12,7 +12,7 @@ echo "Found previous tag $PREV_TAG"
 
 # Initially, we don't want to tag if we are doing stable, because we will bump
 # again later. See comment at end for why.
-if [[ "$RELEASE_TYPE" == 'stable' ]]; then
+if [[ "$RELEASE_TYPE" == 'stable' ]]; then 
   BUMP_ARGS="--no-tag"
 fi
 

ci/check_breaking_changes.py

@@ -2,7 +2,6 @@
 Check whether there are any breaking changes in the PRs between the base and head commits.
 If there are, assert that we have incremented the minor version.
 """
-
 import argparse
 import os
 from packaging.version import parse
@@ -28,7 +27,7 @@ if __name__ == "__main__":
     else:
         print("No breaking changes found.")
         exit(0)
-
+    
     last_stable_version = parse(args.last_stable_version)
     current_version = parse(args.current_version)
     if current_version.minor <= last_stable_version.minor:

ci/check_lance_release.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 """Determine whether a newer Lance tag exists and expose results for CI."""
-
 from __future__ import annotations
 
 import argparse
@@ -37,16 +36,8 @@ class SemVer:
     prerelease: Tuple[Union[int, str], ...]
 
     def __lt__(self, other: "SemVer") -> bool:  # pragma: no cover - simple comparison
-        if (self.major, self.minor, self.patch) != (
-            other.major,
-            other.minor,
-            other.patch,
-        ):
-            return (self.major, self.minor, self.patch) < (
-                other.major,
-                other.minor,
-                other.patch,
-            )
+        if (self.major, self.minor, self.patch) != (other.major, other.minor, other.patch):
+            return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
         if self.prerelease == other.prerelease:
             return False
         if not self.prerelease:
@@ -151,9 +142,7 @@ def read_current_version(repo_root: Path) -> str:
         deps = data["workspace"]["dependencies"]
         entry = deps["lance"]
     except KeyError as exc:  # pragma: no cover - configuration guard
-        raise RuntimeError(
-            "Failed to locate workspace.dependencies.lance in Cargo.toml"
-        ) from exc
+        raise RuntimeError("Failed to locate workspace.dependencies.lance in Cargo.toml") from exc
 
     if isinstance(entry, str):
         raw_version = entry

ci/mock_openai.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright The LanceDB Authors
 """A zero-dependency mock OpenAI embeddings API endpoint for testing purposes."""
-
 import argparse
 import json
 import http.server
@@ -23,13 +22,11 @@ class MockOpenAIRequestHandler(http.server.BaseHTTPRequestHandler):
 
         data = []
         for i in range(num_inputs):
-            data.append(
-                {
-                    "object": "embedding",
-                    "embedding": [0.1] * 1536,
-                    "index": i,
-                }
-            )
+            data.append({
+                "object": "embedding",
+                "embedding": [0.1] * 1536,
+                "index": i,
+            })
 
         response = {
             "object": "list",
@@ -38,7 +35,7 @@ class MockOpenAIRequestHandler(http.server.BaseHTTPRequestHandler):
             "usage": {
                 "prompt_tokens": 0,
                 "total_tokens": 0,
-            },
+            }
         }
 
         self.send_response(200)

ci/semver_sort.py

@@ -7,7 +7,6 @@ from packaging.version import parse, InvalidVersion
 
 if __name__ == "__main__":
     import argparse
-
     parser = argparse.ArgumentParser()
     parser.add_argument("prefix", default="v")
     args = parser.parse_args()

ci/set_lance_version.py

@@ -22,7 +22,7 @@ def run_command(command: str) -> str:
 def get_latest_stable_version() -> str:
     version_line = run_command("cargo info lance | grep '^version:'")
     # Example output: "version: 0.35.0 (latest 0.37.0)"
-    match = re.search(r"\(latest ([0-9.]+)\)", version_line)
+    match = re.search(r'\(latest ([0-9.]+)\)', version_line)
     if match:
         return match.group(1)
     # Fallback: use the first version after 'version:'
@@ -69,7 +69,7 @@ def extract_default_features(line: str) -> bool:
     """
     import re
 
-    match = re.search(r"default-features\s*=\s*false", line)
+    match = re.search(r'default-features\s*=\s*false', line)
     return match is not None
 
 
@@ -104,7 +104,7 @@ def dict_to_toml_line(package_name: str, config: dict) -> str:
             # This shouldn't happen with our current usage
             parts.append(f'"{key}" = {json.dumps(value)}')
 
-    return f"{package_name} = {{ {', '.join(parts)} }}\n"
+    return f'{package_name} = {{ {", ".join(parts)} }}\n'
 
 
 def update_cargo_toml(line_updater):
@@ -119,7 +119,7 @@ def update_cargo_toml(line_updater):
     lance_line = ""
     is_parsing_lance_line = False
     for line in lines:
-        if re.match(r"^lance(?:\s|[-_])", line):
+        if line.startswith("lance"):
             # Check if this is a single-line or multi-line entry
             # Single-line entries either:
             # 1. End with } (complete inline table)

ci/tests/test_set_lance_version.py

@@ -1,185 +0,0 @@
-import os
-import stat
-import subprocess
-import sys
-import tempfile
-import textwrap
-import unittest
-from pathlib import Path
-
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-SCRIPT = REPO_ROOT / "ci" / "set_lance_version.py"
-LANCE_GIT_URL = "https://github.com/lance-format/lance.git"
-
-CARGO_TOML = """\
-[workspace.dependencies]
-lance = { "version" = "=1.0.0", default-features = false, "features" = ["dynamodb"] }
-lance-core = "1.0.0"
-lance_datafusion = {
-    "version" = "=1.0.0",
-    "features" = ["substrait"]
-}
-lancedb = { path = "rust/lancedb", default-features = false }
-lancedb-common = { path = "rust/lancedb-common" }
-lancewood = "1.0.0"
-my-lance = "1.0.0"
-"""
-
-UNTOUCHED_DEPENDENCIES = """\
-lancedb = { path = "rust/lancedb", default-features = false }
-lancedb-common = { path = "rust/lancedb-common" }
-lancewood = "1.0.0"
-my-lance = "1.0.0"
-"""
-
-
-class SetLanceVersionTest(unittest.TestCase):
-    def test_supported_update_modes_only_rewrite_lance_dependencies(self):
-        cases = {
-            "stable": (
-                """\
-lance = { "version" = "=9.9.9", default-features = false, "features" = ["dynamodb"] }
-lance-core = "=9.9.9"
-lance_datafusion = { "version" = "=9.9.9", "features" = ["substrait"] }
-""",
-                ["cargo info lance", "cargo metadata"],
-            ),
-            "preview": (
-                f"""\
-lance = {{ "version" = "=10.0.0-beta.3", default-features = false, "features" = ["dynamodb"], "tag" = "v10.0.0-beta.3", "git" = "{LANCE_GIT_URL}" }}
-lance-core = {{ "version" = "=10.0.0-beta.3", "tag" = "v10.0.0-beta.3", "git" = "{LANCE_GIT_URL}" }}
-lance_datafusion = {{ "version" = "=10.0.0-beta.3", "features" = ["substrait"], "tag" = "v10.0.0-beta.3", "git" = "{LANCE_GIT_URL}" }}
-""",
-                ["git ls-remote --tags", "cargo metadata"],
-            ),
-            "local": (
-                """\
-lance = { "path" = "../lance/rust/lance", default-features = false, "features" = ["dynamodb"] }
-lance-core = { "path" = "../lance/rust/lance-core" }
-lance_datafusion = { "path" = "../lance/rust/lance_datafusion", "features" = ["substrait"] }
-""",
-                ["cargo metadata"],
-            ),
-            "v8.1.2": (
-                """\
-lance = { "version" = "=8.1.2", default-features = false, "features" = ["dynamodb"] }
-lance-core = "=8.1.2"
-lance_datafusion = { "version" = "=8.1.2", "features" = ["substrait"] }
-""",
-                ["cargo metadata"],
-            ),
-            "v8.2.0-beta.4": (
-                f"""\
-lance = {{ "version" = "=8.2.0-beta.4", default-features = false, "features" = ["dynamodb"], "tag" = "v8.2.0-beta.4", "git" = "{LANCE_GIT_URL}" }}
-lance-core = {{ "version" = "=8.2.0-beta.4", "tag" = "v8.2.0-beta.4", "git" = "{LANCE_GIT_URL}" }}
-lance_datafusion = {{ "version" = "=8.2.0-beta.4", "features" = ["substrait"], "tag" = "v8.2.0-beta.4", "git" = "{LANCE_GIT_URL}" }}
-""",
-                ["cargo metadata"],
-            ),
-        }
-
-        for version, (updated_dependencies, expected_commands) in cases.items():
-            with self.subTest(version=version), tempfile.TemporaryDirectory() as tmp:
-                workdir = Path(tmp)
-                (workdir / "Cargo.toml").write_text(CARGO_TOML)
-                command_log = workdir / "commands.log"
-                fake_bin = workdir / "bin"
-                fake_bin.mkdir()
-                self._write_fake_executables(fake_bin)
-                self._write_fake_python_dependencies(workdir)
-
-                env = os.environ.copy()
-                env["PATH"] = os.pathsep.join([str(fake_bin), env["PATH"]])
-                env["FAKE_COMMAND_LOG"] = str(command_log)
-                env["PYTHONPATH"] = os.pathsep.join(
-                    filter(None, [str(workdir), env.get("PYTHONPATH")])
-                )
-                result = subprocess.run(
-                    [sys.executable, str(SCRIPT), version],
-                    cwd=workdir,
-                    env=env,
-                    capture_output=True,
-                    text=True,
-                    timeout=10,
-                )
-
-                self.assertEqual(result.returncode, 0, result.stderr)
-                self.assertEqual(
-                    (workdir / "Cargo.toml").read_text(),
-                    "[workspace.dependencies]\n"
-                    + updated_dependencies
-                    + UNTOUCHED_DEPENDENCIES,
-                )
-                commands = command_log.read_text().splitlines()
-                for command in expected_commands:
-                    self.assertTrue(
-                        any(line.startswith(command) for line in commands),
-                        f"{command!r} not found in {commands!r}",
-                    )
-
-    def _write_fake_executables(self, fake_bin: Path) -> None:
-        cargo = fake_bin / "cargo"
-        cargo.write_text(
-            textwrap.dedent(
-                """\
-                #!/bin/sh
-                printf 'cargo %s\\n' "$*" >> "$FAKE_COMMAND_LOG"
-                case "$1" in
-                  info)
-                    printf '%s\\n' 'version: 8.8.8 (latest 9.9.9)'
-                    ;;
-                  metadata)
-                    ;;
-                  *)
-                    exit 2
-                    ;;
-                esac
-                """
-            )
-        )
-        cargo.chmod(cargo.stat().st_mode | stat.S_IXUSR)
-
-        git = fake_bin / "git"
-        git.write_text(
-            textwrap.dedent(
-                """\
-                #!/bin/sh
-                printf 'git %s\\n' "$*" >> "$FAKE_COMMAND_LOG"
-                if [ "$1" != "ls-remote" ]; then
-                  exit 2
-                fi
-                printf '%s\\n' \\
-                  '111111 refs/tags/v9.9.9' \\
-                  '222222 refs/tags/v10.0.0-beta.1' \\
-                  '333333 refs/tags/v10.0.0-beta.3'
-                """
-            )
-        )
-        git.chmod(git.stat().st_mode | stat.S_IXUSR)
-
-    def _write_fake_python_dependencies(self, workdir: Path) -> None:
-        packaging = workdir / "packaging"
-        packaging.mkdir()
-        (packaging / "__init__.py").write_text("")
-        (packaging / "version.py").write_text(
-            textwrap.dedent(
-                """\
-                class Version:
-                    def __init__(self, value):
-                        release, _, prerelease = value.partition("-beta.")
-                        self._key = (
-                            tuple(int(part) for part in release.split(".")),
-                            not prerelease,
-                            int(prerelease or 0),
-                        )
-
-                    def __lt__(self, other):
-                        return self._key < other._key
-                """
-            )
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

ci/update_lockfiles.sh

@@ -12,12 +12,16 @@ done
 # This updates the lockfile without building
 cargo metadata --quiet > /dev/null
 
+pushd nodejs || exit 1
+npm install --package-lock-only --silent
+popd
+
 if git diff --quiet --exit-code; then
   echo "No lockfile changes to commit; skipping amend."
 elif $AMEND; then
-  git add Cargo.lock
+  git add Cargo.lock nodejs/package-lock.json
   git commit --amend --no-edit
 else
-  git add Cargo.lock
+  git add Cargo.lock nodejs/package-lock.json
   git commit -m "Update lockfiles"
 fi

ci/validate_stable_lance.py

@@ -12,7 +12,7 @@ with open("Cargo.toml", "rb") as f:
             elif isinstance(dep, dict):
                 # Version doesn't have the beta tag in it, so we instead look
                 # at the git tag.
-                version = dep.get("tag", dep.get("version"))
+                version = dep.get('tag', dep.get('version'))
             else:
                 raise ValueError("Unexpected type for dependency: " + str(dep))
 

deny.toml

@@ -101,19 +101,6 @@ ignore = [
     # https://rustsec.org/advisories/RUSTSEC-2026-0195
     { id = "RUSTSEC-2026-0194", reason = "transitive via inferno/lance/opendal; XML from trusted cloud endpoints, not attacker-controlled" },
     { id = "RUSTSEC-2026-0195", reason = "transitive via inferno/lance/opendal; XML from trusted cloud endpoints, not attacker-controlled" },
-    # smartstring: unmaintained — the repository was archived by its author on
-    # 2026-05-03. Not a vulnerability. Reached only transitively through polars
-    # (polars-core/-io/-ops/-time/-utils); nothing in LanceDB depends on it directly.
-    # The advisory states no safe upgrade is available: upstream recommends
-    # compact_str/smol_str, so clearing this requires polars to migrate.
-    # https://rustsec.org/advisories/RUSTSEC-2026-0249
-    { id = "RUSTSEC-2026-0249", reason = "smartstring unmaintained via polars; no fixed upstream release" },
-
-    # h2 0.3: empty DATA frames can be queued without limit. The patched
-    # h2 0.4 line is locked to 0.4.16, but no patched 0.3 release exists.
-    # The old copy is pulled in by aws-smithy's legacy hyper 0.14 client.
-    # https://rustsec.org/advisories/RUSTSEC-2026-0258
-    { id = "RUSTSEC-2026-0258", reason = "h2 0.3 via legacy aws-smithy/hyper 0.14; no patched 0.3 release" },
 ]
 
 # ---------------------------------------------------------------------------
@@ -131,13 +118,18 @@ allow = [
     "BSD-3-Clause",
     "ISC",
     "Unicode-3.0",
+    "Unicode-DFS-2016",
     "Zlib",
     "CC0-1.0",
     "MPL-2.0",
     "BSL-1.0",
+    "OpenSSL",
     # 0BSD ("BSD Zero Clause") is effectively public domain — no attribution
     # required. Pulled in by `mock_instant`.
     "0BSD",
+    # bzip2-1.0.6 is the permissive upstream bzip2 license (BSD-like). Pulled
+    # in by `libbz2-rs-sys`, the pure-Rust bzip2 implementation.
+    "bzip2-1.0.6",
     # CDLA-Permissive-2.0 is a permissive data license used by `webpki-roots`
     # for the Mozilla CA root bundle. Data-only, distribution-compatible.
     "CDLA-Permissive-2.0",
@@ -145,7 +137,12 @@ allow = [
 confidence-threshold = 0.8
 # Per-crate license exceptions: allow a license for a specific crate only,
 # rather than globally via the `allow` list above.
-exceptions = []
+exceptions = [
+    # CDDL-1.0 (copyleft) is pulled in only as a dev/profiling dependency via
+    # `inferno` -> `pprof` -> `lance-testing`; it is a test dependency that we
+    # do not distribute, so scope the allowance to `inferno` alone.
+    { allow = ["CDDL-1.0"], crate = "inferno" },
+]
 # Crates whose license cannot be determined from Cargo metadata but whose
 # license we've manually confirmed from upstream. Keep this list minimal.
 [[licenses.clarify]]
@@ -167,11 +164,6 @@ multiple-versions = "warn"
 # Wildcard version requirements (`foo = "*"`) are a footgun — they let any
 # future release in without review. Ban them outright.
 wildcards = "deny"
-# Lint every dependency declared by a workspace member against the shared
-# `[workspace.dependencies]` table: any crate used by more than one member must
-# go through `workspace = true`, and entries nothing uses are an error. This
-# keeps versions from drifting between the core crate and the bindings.
-workspace-dependencies = { duplicates = "deny", unused = "deny" }
 # Internal workspace crates reference each other via `path = "..."`, which
 # cargo-deny sees as a wildcard version. That's fine for private workspace
 # members (not published to crates.io), so allow it specifically for paths.

docs/README.md

@@ -47,24 +47,22 @@ pytest -vv python/tests/docs
 
 ### Checking typescript examples
 
-The examples depend on `@lancedb/lancedb` at `file:../dist`, so the package must be
-built before running the tests. This uses pnpm; see the
-[Typescript contributing guide](../nodejs/CONTRIBUTING.md) for the toolchain setup.
+The `@lancedb/lancedb` package must be built before running the tests:
 
 ```shell
 pushd nodejs
-pnpm install
-pnpm build
+npm ci
+npm run build
 popd
 ```
 
-Then you can run the examples by going to the `nodejs/examples` directory, which is a
-separate pnpm package with its own lockfile:
+Then you can run the examples by going to the `nodejs/examples` directory and
+running the tests like a normal npm package:
 
 ```shell
 pushd nodejs/examples
-pnpm install
-pnpm test
+npm ci
+npm test
 popd
 ```
 
@@ -86,7 +84,6 @@ The new files should be checked into the repository.
 
 ```shell
 pushd nodejs
-# `pnpm docs` would invoke pnpm's built-in `docs` command, not the script.
-pnpm run docs
+npm run docs
 popd
 ```

docs/mkdocs.yml

@@ -51,11 +51,6 @@ plugins:
           paths: [../python/python]
           options:
             docstring_style: numpy
-            docstring_options:
-              # Attributes documented in a `Parameters` section, and pydantic
-              # dataclasses whose `__init__` griffe cannot see statically, both
-              # trip this check. It reports nothing actionable here.
-              warn_unknown_params: false
             heading_level: 3
             show_signature_annotations: true
             show_root_heading: true

docs/openapi.yml

@@ -453,16 +453,6 @@ paths:
                     The metric type to use for the index. l2, Cosine, Dot are supported.
                 index_type:
                   type: string
-                custom_stop_words:
-                  type: [array, "null"]
-                  items:
-                    type: string
-                  description: |
-                    The custom stop-word list for an FTS index. A non-null
-                    array replaces the language's built-in stop-word list and is only
-                    applied when remove_stop_words is enabled. Null uses the built-in
-                    language list, while an empty array explicitly replaces it with no
-                    stop words.
       responses:
         "200":
           description: Index successfully created
@@ -520,4 +510,4 @@ paths:
         "401":
           $ref: "#/components/responses/unauthorized"
         "404":
-          $ref: "#/components/responses/not_found"
+          $ref: "#/components/responses/not_found"

docs/package-lock.json

@@ -0,0 +1,135 @@
+{
+  "name": "lancedb-docs-test",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "lancedb-docs-test",
+      "version": "1.0.0",
+      "license": "Apache 2",
+      "dependencies": {
+        "apache-arrow": "file:../node/node_modules/apache-arrow",
+        "vectordb": "file:../node"
+      },
+      "devDependencies": {
+        "@types/node": "^20.11.8",
+        "typescript": "^5.3.3"
+      }
+    },
+    "../node": {
+      "name": "vectordb",
+      "version": "0.21.2-beta.0",
+      "cpu": [
+        "x64",
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "os": [
+        "darwin",
+        "linux",
+        "win32"
+      ],
+      "dependencies": {
+        "@neon-rs/load": "^0.0.74",
+        "axios": "^1.4.0"
+      },
+      "devDependencies": {
+        "@neon-rs/cli": "^0.0.160",
+        "@types/chai": "^4.3.4",
+        "@types/chai-as-promised": "^7.1.5",
+        "@types/mocha": "^10.0.1",
+        "@types/node": "^18.16.2",
+        "@types/sinon": "^10.0.15",
+        "@types/temp": "^0.9.1",
+        "@types/uuid": "^9.0.3",
+        "@typescript-eslint/eslint-plugin": "^5.59.1",
+        "apache-arrow-old": "npm:apache-arrow@13.0.0",
+        "cargo-cp-artifact": "^0.1",
+        "chai": "^4.3.7",
+        "chai-as-promised": "^7.1.1",
+        "eslint": "^8.39.0",
+        "eslint-config-standard-with-typescript": "^34.0.1",
+        "eslint-plugin-import": "^2.26.0",
+        "eslint-plugin-n": "^15.7.0",
+        "eslint-plugin-promise": "^6.1.1",
+        "mocha": "^10.2.0",
+        "openai": "^4.24.1",
+        "sinon": "^15.1.0",
+        "temp": "^0.9.4",
+        "ts-node": "^10.9.1",
+        "ts-node-dev": "^2.0.0",
+        "typedoc": "^0.24.7",
+        "typedoc-plugin-markdown": "^3.15.3",
+        "typescript": "^5.1.0",
+        "uuid": "^9.0.0"
+      },
+      "optionalDependencies": {
+        "@lancedb/vectordb-darwin-arm64": "0.21.2-beta.0",
+        "@lancedb/vectordb-darwin-x64": "0.21.2-beta.0",
+        "@lancedb/vectordb-linux-arm64-gnu": "0.21.2-beta.0",
+        "@lancedb/vectordb-linux-x64-gnu": "0.21.2-beta.0",
+        "@lancedb/vectordb-win32-x64-msvc": "0.21.2-beta.0"
+      },
+      "peerDependencies": {
+        "@apache-arrow/ts": "^14.0.2",
+        "apache-arrow": "^14.0.2"
+      }
+    },
+    "../node/node_modules/apache-arrow": {
+      "version": "14.0.2",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/command-line-args": "5.2.0",
+        "@types/command-line-usage": "5.0.2",
+        "@types/node": "20.3.0",
+        "@types/pad-left": "2.1.1",
+        "command-line-args": "5.2.1",
+        "command-line-usage": "7.0.1",
+        "flatbuffers": "23.5.26",
+        "json-bignum": "^0.0.3",
+        "pad-left": "^2.1.0",
+        "tslib": "^2.5.3"
+      },
+      "bin": {
+        "arrow2csv": "bin/arrow2csv.js"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "20.11.8",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.11.8.tgz",
+      "integrity": "sha512-i7omyekpPTNdv4Jb/Rgqg0RU8YqLcNsI12quKSDkRXNfx7Wxdm6HhK1awT3xTgEkgxPn3bvnSpiEAc7a7Lpyow==",
+      "dev": true,
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
+    },
+    "node_modules/apache-arrow": {
+      "resolved": "../node/node_modules/apache-arrow",
+      "link": true
+    },
+    "node_modules/typescript": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz",
+      "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "5.26.5",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "dev": true
+    },
+    "node_modules/vectordb": {
+      "resolved": "../node",
+      "link": true
+    }
+  }
+}

docs/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "lancedb-docs-test",
+  "version": "1.0.0",
+  "description": "auto-generated tests from doc",
+  "author": "dev@lancedb.com",
+  "license": "Apache 2",
+  "dependencies": {
+    "apache-arrow": "file:../node/node_modules/apache-arrow",
+    "vectordb": "file:../node"
+  },
+  "scripts": {
+    "build": "tsc -b && cd ../node && npm run build-release",
+    "example": "npm run build && node",
+    "test": "npm run build && ls dist/*.js | xargs -n 1 node"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.8",
+    "typescript": "^5.3.3"
+  }
+}

docs/requirements.txt

@@ -5,5 +5,5 @@ mkdocs-autorefs>=0.5,<=1.0
 mkdocstrings[python]>=0.24,<1.0
 griffe>=0.40,<1.0
 mkdocs-render-swagger-plugin>=0.1.0
-pydantic>=2.7.4,<3
-mkdocs-redirects>=1.2.0
+pydantic>=2.0,<3.0
+mkdocs-redirects>=1.2.0

docs/src/java/java.md

@@ -14,7 +14,7 @@ Add the following dependency to your `pom.xml`:
 <dependency>
     <groupId>com.lancedb</groupId>
     <artifactId>lancedb-core</artifactId>
-    <version>0.38.0-beta.12</version>
+    <version>0.32.0-beta.2</version>
 </dependency>
 ```
 
@@ -55,38 +55,6 @@ LanceNamespace namespaceClient = LanceDbNamespaceClientBuilder.newBuilder()
 | `region(String)` | AWS region (default: "us-east-1") | No |
 | `config(String, String)` | Additional configuration parameters | No |
 
-### Opening a Table with Vended Credentials
-
-When the catalog vends temporary object store credentials, open the table through the
-namespace client. The Lance dataset builder fetches the table location and storage options
-from the catalog and refreshes the credentials when they expire.
-
-```java
-import com.lancedb.LanceDbNamespaceClientBuilder;
-import org.lance.Dataset;
-import org.lance.namespace.LanceNamespace;
-
-import java.util.Arrays;
-
-LanceNamespace namespaceClient = LanceDbNamespaceClientBuilder.newBuilder()
-    .apiKey(System.getenv("LANCEDB_API_KEY"))
-    .database(System.getenv("LANCEDB_DATABASE"))
-    // Set the endpoint for a LanceDB Enterprise deployment.
-    // .endpoint("https://your-enterprise-endpoint")
-    .build();
-
-try (Dataset dataset = Dataset.open()
-        .namespaceClient(namespaceClient)
-        .tableId(Arrays.asList("my_namespace", "my_table"))
-        .build()) {
-    System.out.println("Rows: " + dataset.countRows());
-}
-```
-
-Do not call `describeTable()` and then open the returned location with `Dataset.open(uri)`.
-Opening through `namespaceClient()` is what applies the vended storage options and enables
-automatic credential refresh. No object store credentials need to be passed by the application.
-
 ## Metadata Operations
 
 ### Creating a Namespace Path
@@ -281,57 +249,6 @@ try (BufferAllocator allocator = new RootAllocator();
 }
 ```
 
-### Creating an Empty Table
-
-To create an empty table, send an Arrow IPC stream that contains the table schema and no record batches.
-The schema in the IPC stream becomes the table schema, and rows can be inserted later.
-
-```java
-import org.lance.namespace.model.CreateTableRequest;
-import org.lance.namespace.model.CreateTableResponse;
-import org.apache.arrow.memory.BufferAllocator;
-import org.apache.arrow.memory.RootAllocator;
-import org.apache.arrow.vector.VectorSchemaRoot;
-import org.apache.arrow.vector.ipc.ArrowStreamWriter;
-import org.apache.arrow.vector.types.FloatingPointPrecision;
-import org.apache.arrow.vector.types.pojo.ArrowType;
-import org.apache.arrow.vector.types.pojo.Field;
-import org.apache.arrow.vector.types.pojo.FieldType;
-import org.apache.arrow.vector.types.pojo.Schema;
-
-import java.io.ByteArrayOutputStream;
-import java.nio.channels.Channels;
-import java.util.Arrays;
-
-Schema schema = new Schema(Arrays.asList(
-    new Field("id", FieldType.nullable(new ArrowType.Int(32, true)), null),
-    new Field("name", FieldType.nullable(new ArrowType.Utf8()), null),
-    new Field("embedding",
-        FieldType.nullable(new ArrowType.FixedSizeList(128)),
-        Arrays.asList(new Field("item",
-            FieldType.nullable(new ArrowType.FloatingPoint(FloatingPointPrecision.SINGLE)),
-            null)))
-));
-
-byte[] emptyTableData;
-try (BufferAllocator allocator = new RootAllocator();
-     VectorSchemaRoot root = VectorSchemaRoot.create(schema, allocator)) {
-    root.setRowCount(0);
-
-    ByteArrayOutputStream out = new ByteArrayOutputStream();
-    try (ArrowStreamWriter writer = new ArrowStreamWriter(root, null, Channels.newChannel(out))) {
-        writer.start();
-        writer.end();
-    }
-    emptyTableData = out.toByteArray();
-}
-
-CreateTableRequest request = new CreateTableRequest();
-request.setId(Arrays.asList("my_namespace", "empty_table"));
-
-CreateTableResponse response = namespaceClient.createTable(request, emptyTableData);
-```
-
 ### Insert
 
 ```java
@@ -514,88 +431,9 @@ query.setVector(vector);
 byte[] result = namespaceClient.queryTable(query);
 ```
 
-## Indexing
+### Reading Query Results
 
-The Java SDK exposes the REST namespace index operations through the same `LanceNamespace` client.
-Index creation runs asynchronously, so use `listTableIndices` or `describeTableIndexStats` to check progress.
-
-### Creating a Vector Index
-
-```java
-import org.lance.namespace.model.CreateTableIndexRequest;
-import org.lance.namespace.model.CreateTableIndexResponse;
-
-CreateTableIndexRequest request = new CreateTableIndexRequest();
-request.setId(Arrays.asList("my_namespace", "my_table"));
-request.setColumn("embedding");
-request.setIndexType("IVF_PQ");
-request.setDistanceType("cosine");
-request.setName("embedding_idx");
-
-CreateTableIndexResponse response = namespaceClient.createTableIndex(request);
-System.out.println("Index transaction: " + response.getTransactionId());
-```
-
-### Creating a Scalar Index
-
-```java
-import org.lance.namespace.model.CreateTableIndexRequest;
-import org.lance.namespace.model.CreateTableScalarIndexResponse;
-
-CreateTableIndexRequest request = new CreateTableIndexRequest();
-request.setId(Arrays.asList("my_namespace", "my_table"));
-request.setColumn("category");
-request.setIndexType("BTREE");
-request.setName("category_idx");
-
-CreateTableScalarIndexResponse response = namespaceClient.createTableScalarIndex(request);
-System.out.println("Index transaction: " + response.getTransactionId());
-```
-
-### Creating a Full Text Search Index
-
-```java
-import org.lance.namespace.model.CreateTableIndexRequest;
-import org.lance.namespace.model.CreateTableScalarIndexResponse;
-
-CreateTableIndexRequest request = new CreateTableIndexRequest();
-request.setId(Arrays.asList("my_namespace", "my_table"));
-request.setColumn("text_column");
-request.setIndexType("FTS");
-request.setName("text_idx");
-request.setBaseTokenizer("simple");
-request.setLowerCase(true);
-request.setWithPosition(true);
-
-CreateTableScalarIndexResponse response = namespaceClient.createTableScalarIndex(request);
-System.out.println("Index transaction: " + response.getTransactionId());
-```
-
-### Listing Indexes
-
-```java
-import org.lance.namespace.model.IndexContent;
-import org.lance.namespace.model.ListTableIndicesRequest;
-import org.lance.namespace.model.ListTableIndicesResponse;
-
-ListTableIndicesRequest request = new ListTableIndicesRequest();
-request.setId(Arrays.asList("my_namespace", "my_table"));
-
-ListTableIndicesResponse response = namespaceClient.listTableIndices(request);
-for (IndexContent index : response.getIndexes()) {
-    System.out.println(index.getIndexName() + ": " + index.getStatus());
-}
-```
-
-!!! note
-    The current Java namespace API exposes index type, index name, distance type, and full text search tokenizer options.
-    IVF training parameters such as `num_partitions` are not exposed by `CreateTableIndexRequest` yet.
-    To make those configurable from Java, the namespace API must add those fields first.
-
-## Reading Query Results
-
-Query results are returned as bytes in Apache Arrow IPC file format. Put the byte-channel
-adapter behind a small helper so query code can work with `ArrowFileReader` directly:
+Query results are returned in Apache Arrow IPC file format. Here's how to read them:
 
 ```java
 import org.apache.arrow.vector.ipc.ArrowFileReader;
@@ -603,50 +441,45 @@ import org.apache.arrow.vector.VectorSchemaRoot;
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
 
-import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.channels.SeekableByteChannel;
 
-final class ArrowIpc {
-    static ArrowFileReader openFileReader(byte[] data, BufferAllocator allocator) throws IOException {
-        return new ArrowFileReader(new ByteArraySeekableByteChannel(data), allocator);
+// Helper class to read Arrow data from byte array
+class ByteArraySeekableByteChannel implements SeekableByteChannel {
+    private final byte[] data;
+    private long position = 0;
+    private boolean isOpen = true;
+
+    public ByteArraySeekableByteChannel(byte[] data) {
+        this.data = data;
     }
 
-    private static final class ByteArraySeekableByteChannel implements SeekableByteChannel {
-        private final byte[] data;
-        private long position = 0;
-        private boolean isOpen = true;
-
-        private ByteArraySeekableByteChannel(byte[] data) {
-            this.data = data;
-        }
-
-        @Override
-        public int read(ByteBuffer dst) {
-            int remaining = dst.remaining();
-            int available = (int) (data.length - position);
-            if (available <= 0) return -1;
-            int toRead = Math.min(remaining, available);
-            dst.put(data, (int) position, toRead);
-            position += toRead;
-            return toRead;
-        }
-
-        @Override public long position() { return position; }
-        @Override public SeekableByteChannel position(long newPosition) { position = newPosition; return this; }
-        @Override public long size() { return data.length; }
-        @Override public boolean isOpen() { return isOpen; }
-        @Override public void close() { isOpen = false; }
-        @Override public int write(ByteBuffer src) { throw new UnsupportedOperationException(); }
-        @Override public SeekableByteChannel truncate(long size) { throw new UnsupportedOperationException(); }
+    @Override
+    public int read(ByteBuffer dst) {
+        int remaining = dst.remaining();
+        int available = (int) (data.length - position);
+        if (available <= 0) return -1;
+        int toRead = Math.min(remaining, available);
+        dst.put(data, (int) position, toRead);
+        position += toRead;
+        return toRead;
     }
+
+    @Override public long position() { return position; }
+    @Override public SeekableByteChannel position(long newPosition) { position = newPosition; return this; }
+    @Override public long size() { return data.length; }
+    @Override public boolean isOpen() { return isOpen; }
+    @Override public void close() { isOpen = false; }
+    @Override public int write(ByteBuffer src) { throw new UnsupportedOperationException(); }
+    @Override public SeekableByteChannel truncate(long size) { throw new UnsupportedOperationException(); }
 }
 
 // Read query results
 byte[] queryResult = namespaceClient.queryTable(query);
 
 try (BufferAllocator allocator = new RootAllocator();
-     ArrowFileReader reader = ArrowIpc.openFileReader(queryResult, allocator)) {
+     ArrowFileReader reader = new ArrowFileReader(
+         new ByteArraySeekableByteChannel(queryResult), allocator)) {
 
     for (int i = 0; i < reader.getRecordBlocks().size(); i++) {
         reader.loadRecordBatch(reader.getRecordBlocks().get(i));

docs/src/js/_media/CONTRIBUTING.md

@@ -1,7 +1,7 @@
 # Contributing to LanceDB Typescript
 
 This document outlines the process for contributing to LanceDB Typescript.
-For general contribution guidelines, see [CONTRIBUTING.md](https://github.com/lancedb/lancedb/blob/main/CONTRIBUTING.md).
+For general contribution guidelines, see [CONTRIBUTING.md](../CONTRIBUTING.md).
 
 ## Project layout
 

docs/src/js/classes/AutoQuery.md

@@ -1,518 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / AutoQuery
-
-# Class: AutoQuery
-
-A builder for automatic string searches.
-
-Automatic search determines whether to use full-text or vector search from
-the table revision selected for each execution. This builder exposes the
-common operations supported by both query families.
-
-## Extends
-
-- `StandardQueryBase`<`NativeQuery` \| `NativeVectorQuery`>
-
-## Properties
-
-### inner
-
-```ts
-protected inner: Query | VectorQuery | Promise<Query | VectorQuery>;
-```
-
-#### Inherited from
-
-`StandardQueryBase.inner`
-
-## Methods
-
-### analyzePlan()
-
-```ts
-analyzePlan(distributedMetrics?): Promise<string>
-```
-
-Executes the query and returns the physical query plan annotated with runtime metrics.
-
-This is useful for debugging and performance analysis, as it shows how the query was executed
-and includes metrics such as elapsed time, rows processed, and I/O statistics.
-
-#### Parameters
-
-* **distributedMetrics?**: [`AnalyzePlanDistributedMetrics`](../type-aliases/AnalyzePlanDistributedMetrics.md)
-    How distributed worker metrics are displayed for remote query plans.
-    Defaults to `"aggregate"`.
-
-#### Returns
-
-`Promise`&lt;`string`&gt;
-
-A query execution plan with runtime metrics for each step.
-
-#### Example
-
-```ts
-import * as lancedb from "@lancedb/lancedb"
-
-const db = await lancedb.connect("./.lancedb");
-const table = await db.createTable("my_table", [
-  { vector: [1.1, 0.9], id: "1" },
-]);
-
-const plan = await table.query().nearestTo([0.5, 0.2]).analyzePlan();
-
-Example output (with runtime metrics inlined):
-AnalyzeExec verbose=true, metrics=[]
- ProjectionExec: expr=[id@3 as id, vector@0 as vector, _distance@2 as _distance], metrics=[output_rows=1, elapsed_compute=3.292µs]
-  Take: columns="vector, _rowid, _distance, (id)", metrics=[output_rows=1, elapsed_compute=66.001µs, batches_processed=1, bytes_read=8, iops=1, requests=1]
-   CoalesceBatchesExec: target_batch_size=1024, metrics=[output_rows=1, elapsed_compute=3.333µs]
-    GlobalLimitExec: skip=0, fetch=10, metrics=[output_rows=1, elapsed_compute=167ns]
-     FilterExec: _distance@2 IS NOT NULL, metrics=[output_rows=1, elapsed_compute=8.542µs]
-      SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST], metrics=[output_rows=1, elapsed_compute=63.25µs, row_replacements=1]
-       KNNVectorDistance: metric=l2, metrics=[output_rows=1, elapsed_compute=114.333µs, output_batches=1]
-        LanceScan: uri=/path/to/data, projection=[vector], row_id=true, row_addr=false, ordered=false, metrics=[output_rows=1, elapsed_compute=103.626µs, bytes_read=549, iops=2, requests=2]
-```
-
-#### Inherited from
-
-`StandardQueryBase.analyzePlan`
-
-***
-
-### execute()
-
-```ts
-protected execute(options?): AsyncGenerator<RecordBatch<any>, void, unknown>
-```
-
-Execute the query and return the results as an
-
-#### Parameters
-
-* **options?**: `Partial`&lt;[`QueryExecutionOptions`](../interfaces/QueryExecutionOptions.md)&gt;
-
-#### Returns
-
-`AsyncGenerator`&lt;`RecordBatch`&lt;`any`&gt;, `void`, `unknown`&gt;
-
-#### See
-
- - AsyncIterator
-of
- - RecordBatch.
-
-By default, LanceDb will use many threads to calculate results and, when
-the result set is large, multiple batches will be processed at one time.
-This readahead is limited however and backpressure will be applied if this
-stream is consumed slowly (this constrains the maximum memory used by a
-single query)
-
-#### Inherited from
-
-`StandardQueryBase.execute`
-
-***
-
-### explainPlan()
-
-```ts
-explainPlan(verbose): Promise<string>
-```
-
-Generates an explanation of the query execution plan.
-
-#### Parameters
-
-* **verbose**: `boolean` = `false`
-    If true, provides a more detailed explanation. Defaults to false.
-
-#### Returns
-
-`Promise`&lt;`string`&gt;
-
-A Promise that resolves to a string containing the query execution plan explanation.
-
-#### Example
-
-```ts
-import * as lancedb from "@lancedb/lancedb"
-const db = await lancedb.connect("./.lancedb");
-const table = await db.createTable("my_table", [
-  { vector: [1.1, 0.9], id: "1" },
-]);
-const plan = await table.query().nearestTo([0.5, 0.2]).explainPlan();
-```
-
-#### Inherited from
-
-`StandardQueryBase.explainPlan`
-
-***
-
-### fastSearch()
-
-```ts
-fastSearch(): this
-```
-
-Skip searching un-indexed data. This can make search faster, but will miss
-any data that is not yet indexed.
-
-Use [Table#optimize](Table.md#optimize) to index all un-indexed data.
-
-#### Returns
-
-`this`
-
-#### Inherited from
-
-`StandardQueryBase.fastSearch`
-
-***
-
-### ~~filter()~~
-
-```ts
-filter(predicate): this
-```
-
-A filter statement to be applied to this query.
-
-#### Parameters
-
-* **predicate**: `string`
-
-#### Returns
-
-`this`
-
-#### See
-
-where
-
-#### Deprecated
-
-Use `where` instead
-
-#### Inherited from
-
-`StandardQueryBase.filter`
-
-***
-
-### fullTextSearch()
-
-```ts
-fullTextSearch(query, options?): this
-```
-
-#### Parameters
-
-* **query**: `string` \| [`FullTextQuery`](../interfaces/FullTextQuery.md)
-
-* **options?**: `Partial`&lt;[`FullTextSearchOptions`](../interfaces/FullTextSearchOptions.md)&gt;
-
-#### Returns
-
-`this`
-
-#### Inherited from
-
-`StandardQueryBase.fullTextSearch`
-
-***
-
-### limit()
-
-```ts
-limit(limit): this
-```
-
-Set the maximum number of results to return.
-
-By default, a plain search has no limit.  If this method is not
-called then every valid row from the table will be returned.
-
-#### Parameters
-
-* **limit**: `number`
-
-#### Returns
-
-`this`
-
-#### Inherited from
-
-`StandardQueryBase.limit`
-
-***
-
-### offset()
-
-```ts
-offset(offset): this
-```
-
-Set the number of rows to skip before returning results.
-
-This is useful for pagination.
-
-#### Parameters
-
-* **offset**: `number`
-
-#### Returns
-
-`this`
-
-#### Inherited from
-
-`StandardQueryBase.offset`
-
-***
-
-### orderBy()
-
-```ts
-orderBy(ordering): this
-```
-
-Sort the results by the specified column(s).
-
-#### Parameters
-
-* **ordering**: [`ColumnOrdering`](../interfaces/ColumnOrdering.md) \| [`ColumnOrdering`](../interfaces/ColumnOrdering.md)[]
-
-#### Returns
-
-`this`
-
-This query builder.
-
-#### Inherited from
-
-`StandardQueryBase.orderBy`
-
-***
-
-### outputSchema()
-
-```ts
-outputSchema(): Promise<Schema<any>>
-```
-
-Returns the schema of the output that will be returned by this query.
-
-This can be used to inspect the types and names of the columns that will be
-returned by the query before executing it.
-
-#### Returns
-
-`Promise`&lt;`Schema`&lt;`any`&gt;&gt;
-
-An Arrow Schema describing the output columns.
-
-#### Inherited from
-
-`StandardQueryBase.outputSchema`
-
-***
-
-### select()
-
-```ts
-select(columns): this
-```
-
-Return only the specified columns.
-
-By default a query will return all columns from the table.  However, this can have
-a very significant impact on latency.  LanceDb stores data in a columnar fashion.  This
-means we can finely tune our I/O to select exactly the columns we need.
-
-As a best practice you should always limit queries to the columns that you need.  If you
-pass in an array of column names then only those columns will be returned.
-
-You can also use this method to create new "dynamic" columns based on your existing columns.
-For example, you may not care about "a" or "b" but instead simply want "a + b".  This is often
-seen in the SELECT clause of an SQL query (e.g. `SELECT a+b FROM my_table`).
-
-To create dynamic columns you can pass in a Map<string, string>.  A column will be returned
-for each entry in the map.  The key provides the name of the column.  The value is
-an SQL string used to specify how the column is calculated.
-
-For example, an SQL query might state `SELECT a + b AS combined, c`.  The equivalent
-input to this method would be:
-
-#### Parameters
-
-* **columns**: `string` \| `string`[] \| `Record`&lt;`string`, `string`&gt; \| `Map`&lt;`string`, `string`&gt;
-
-#### Returns
-
-`this`
-
-#### Example
-
-```ts
-new Map([["combined", "a + b"], ["c", "c"]])
-
-Columns will always be returned in the order given, even if that order is different than
-the order used when adding the data.
-
-Note that you can pass in a `Record<string, string>` (e.g. an object literal). This method
-uses `Object.entries` which should preserve the insertion order of the object.  However,
-object insertion order is easy to get wrong and `Map` is more foolproof.
-```
-
-#### Inherited from
-
-`StandardQueryBase.select`
-
-***
-
-### toArray()
-
-```ts
-toArray(options?): Promise<any[]>
-```
-
-Collect the results as an array of objects.
-
-#### Parameters
-
-* **options?**: `Partial`&lt;[`QueryExecutionOptions`](../interfaces/QueryExecutionOptions.md)&gt;
-
-#### Returns
-
-`Promise`&lt;`any`[]&gt;
-
-#### Inherited from
-
-`StandardQueryBase.toArray`
-
-***
-
-### toArrow()
-
-```ts
-toArrow(options?): Promise<Table<any>>
-```
-
-Collect the results as an Arrow
-
-#### Parameters
-
-* **options?**: `Partial`&lt;[`QueryExecutionOptions`](../interfaces/QueryExecutionOptions.md)&gt;
-
-#### Returns
-
-`Promise`&lt;`Table`&lt;`any`&gt;&gt;
-
-#### See
-
-ArrowTable.
-
-#### Inherited from
-
-`StandardQueryBase.toArrow`
-
-***
-
-### useLsm()
-
-```ts
-useLsm(enable): this
-```
-
-Control MemWAL read routing for this query.
-
-By default (unset), when the table carries a MemWAL write spec (see
-[Table#setLsmWriteSpec](Table.md#setlsmwritespec)), reads are routed through the LSM scanner so
-they also return data written via the `mergeInsert` LSM path that has not yet
-been compacted into the base table (the active/frozen in-memory memtables and
-the flushed generations), deduplicated by primary key; a table without a spec
-reads the base table.
-
-#### Parameters
-
-* **enable**: `boolean`
-    `true` forces the LSM scanner and errors if the table has no
-    MemWAL write spec. `false` bypasses the MemWAL and reads the base table only,
-    even when a spec is present.
-    Note: the LSM scanner does not support every query shape (e.g. reranking,
-    hybrid search, `orderBy`). On a MemWAL table those shapes error unless
-    `useLsm(false)` is set, because a base-only read would silently exclude
-    un-compacted MemWAL data.
-
-#### Returns
-
-`this`
-
-#### Inherited from
-
-`StandardQueryBase.useLsm`
-
-***
-
-### where()
-
-```ts
-where(predicate): this
-```
-
-A filter statement to be applied to this query.
-
-The filter should be supplied as an SQL query string.  For example:
-
-#### Parameters
-
-* **predicate**: `string`
-
-#### Returns
-
-`this`
-
-#### Example
-
-```ts
-x > 10
-y > 0 AND y < 100
-x > 5 OR y = 'test'
-
-Filtering performance can often be improved by creating a scalar index
-on the filter column(s).
-
-Calling this multiple times combines the filters with a logical AND rather
-than replacing the previous filter.
-```
-
-#### Inherited from
-
-`StandardQueryBase.where`
-
-***
-
-### withRowId()
-
-```ts
-withRowId(): this
-```
-
-Whether to return the row id in the results.
-
-This column can be used to match results between different queries. For
-example, to match results from a full text search and a vector search in
-order to perform hybrid search.
-
-#### Returns
-
-`this`
-
-#### Inherited from
-
-`StandardQueryBase.withRowId`

docs/src/js/classes/Branches.md

@@ -37,31 +37,6 @@ latest and stays writable.
 
 ***
 
-### cherryPick()
-
-```ts
-cherryPick(fromBranch, dryRun): Promise<CherryPickResult>
-```
-
-Cherry-pick a branch onto main.
-
-Set `dryRun` to `true` to preview. A failed cherry-pick resolves
-with `status: "failed"` instead of throwing.
-
-#### Parameters
-
-* **fromBranch**: `string`
-    Branch to cherry-pick from.
-
-* **dryRun**: `boolean` = `false`
-    When true, only preview. Defaults to false.
-
-#### Returns
-
-`Promise`&lt;[`CherryPickResult`](../interfaces/CherryPickResult.md)&gt;
-
-***
-
 ### create()
 
 ```ts
@@ -108,24 +83,6 @@ Delete a branch.
 
 ***
 
-### diff()
-
-```ts
-diff(fromBranch): Promise<BranchDiff>
-```
-
-Compare a branch against main without modifying either branch.
-
-#### Parameters
-
-* **fromBranch**: `string`
-
-#### Returns
-
-`Promise`&lt;[`BranchDiff`](../interfaces/BranchDiff.md)&gt;
-
-***
-
 ### list()
 
 ```ts

docs/src/js/classes/Connection.md

@@ -25,27 +25,6 @@ the underlying connection has been closed.
 
 ## Methods
 
-### cancelJob()
-
-```ts
-abstract cancelJob(jobId): Promise<boolean>
-```
-
-Request cancellation of a server-side job by id.
-
-Resolves to true if the server accepted the cancellation, false if no
-such job exists. Cancelling an already-terminal job is a no-op success.
-
-#### Parameters
-
-* **jobId**: `string`
-
-#### Returns
-
-`Promise`&lt;`boolean`&gt;
-
-***
-
 ### cloneTable()
 
 ```ts
@@ -169,45 +148,6 @@ Creates a new empty Table
 
 ***
 
-### createMaterializedView()
-
-```ts
-abstract createMaterializedView(
-   name,
-   source,
-   options?): Promise<MaterializedView>
-```
-
-Define a materialized view named `name` over the table `source`.
-
-The view is created empty, with the query recorded in its schema
-metadata; `view.refresh()` computes the rows. The view is a normal
-table: it can be queried, indexed and searched, and it appears in
-`tableNames`. The source table must have stable row ids (create it with
-the `newTableEnableStableRowIds` storage option); they keep the view's
-provenance valid across source compactions and cannot be enabled after
-a table exists. Local databases only.
-
-#### Parameters
-
-* **name**: `string`
-
-* **source**: `string`
-
-* **options?**
-
-* **options.limit?**: `number`
-
-* **options.select?**: [`MaterializedViewSelect`](../type-aliases/MaterializedViewSelect.md)
-
-* **options.where?**: `string`
-
-#### Returns
-
-`Promise`&lt;[`MaterializedView`](MaterializedView.md)&gt;
-
-***
-
 ### createNamespace()
 
 ```ts
@@ -425,49 +365,6 @@ Drop an existing table.
 
 ***
 
-### dropTableAsync()
-
-```ts
-abstract dropTableAsync(name, namespacePath?): Promise<Job>
-```
-
-Start dropping a table and return its cleanup job.
-
-The table may become unavailable before its data files are removed. Wait
-on the returned job to know when cleanup has finished.
-
-#### Parameters
-
-* **name**: `string`
-
-* **namespacePath?**: `string`[]
-
-#### Returns
-
-`Promise`&lt;[`Job`](Job.md)&gt;
-
-***
-
-### getJob()
-
-```ts
-abstract getJob(jobId): Promise<null | JobDescription>
-```
-
-Describe a single server-side job by id.
-
-Resolves to `null` when the server has no such job.
-
-#### Parameters
-
-* **jobId**: `string`
-
-#### Returns
-
-`Promise`&lt;`null` \| [`JobDescription`](../interfaces/JobDescription.md)&gt;
-
-***
-
 ### isOpen()
 
 ```ts
@@ -482,78 +379,6 @@ Return true if the connection has not been closed
 
 ***
 
-### job()
-
-```ts
-abstract job(jobId): Job
-```
-
-A [Job](Job.md) handle for a server-side job by id.
-
-The handle is constructed without a server round trip; an unknown id
-surfaces when the handle is used. Dropping the handle has no effect on
-the job itself.
-
-#### Parameters
-
-* **jobId**: `string`
-
-#### Returns
-
-[`Job`](Job.md)
-
-***
-
-### jobHistory()
-
-```ts
-abstract jobHistory(jobId?): Promise<Table<any>>
-```
-
-The lifecycle event history of a server-side job, as an Arrow table.
-
-Lists history across all jobs when `jobId` is omitted.
-
-#### Parameters
-
-* **jobId?**: `string`
-
-#### Returns
-
-`Promise`&lt;`Table`&lt;`any`&gt;&gt;
-
-***
-
-### listJobs()
-
-```ts
-abstract listJobs(): Promise<JobInfo[]>
-```
-
-List server-side jobs across the database's tables.
-
-#### Returns
-
-`Promise`&lt;[`JobInfo`](../interfaces/JobInfo.md)[]&gt;
-
-***
-
-### listMaterializedViews()
-
-```ts
-abstract listMaterializedViews(): Promise<string[]>
-```
-
-The names of the materialized views in this database.
-
-Found by reading every table's schema, so this costs an open per table.
-
-#### Returns
-
-`Promise`&lt;`string`[]&gt;
-
-***
-
 ### listNamespaces()
 
 ```ts
@@ -584,90 +409,6 @@ Child namespace names and
 
 ***
 
-### listTables()
-
-#### listTables(options)
-
-```ts
-abstract listTables(options?): Promise<ListTablesResponse>
-```
-
-List a page of the tables in this database.
-
-To retrieve the tables after the page, pass the `pageToken` the response
-carries back in. A page can be shorter than `limit` without being the last
-one, so walk until a response carries no page token:
-
-```ts
-const names = [];
-let pageToken = undefined;
-do {
-  const page = await conn.listTables({ pageToken, limit: 100 });
-  names.push(...page.tables);
-  pageToken = page.pageToken;
-} while (pageToken);
-```
-
-##### Parameters
-
-* **options?**: `Partial`&lt;[`ListTablesOptions`](../interfaces/ListTablesOptions.md)&gt;
-    Pagination options
-    (`pageToken`, `limit`).
-
-##### Returns
-
-`Promise`&lt;[`ListTablesResponse`](../interfaces/ListTablesResponse.md)&gt;
-
-A page of table names and an
-  optional token for the tables after it.
-
-#### listTables(namespacePath, options)
-
-```ts
-abstract listTables(namespacePath?, options?): Promise<ListTablesResponse>
-```
-
-List a page of the tables in this database.
-
-##### Parameters
-
-* **namespacePath?**: `string`[]
-    The namespace path to list tables from
-    (defaults to root namespace)
-
-* **options?**: `Partial`&lt;[`ListTablesOptions`](../interfaces/ListTablesOptions.md)&gt;
-    Pagination options
-    (`pageToken`, `limit`).
-
-##### Returns
-
-`Promise`&lt;[`ListTablesResponse`](../interfaces/ListTablesResponse.md)&gt;
-
-A page of table names and an
-  optional token for the tables after it.
-
-***
-
-### openMaterializedView()
-
-```ts
-abstract openMaterializedView(name): Promise<MaterializedView>
-```
-
-Open the materialized view named `name`.
-
-Rejects a table that exists but is not a materialized view.
-
-#### Parameters
-
-* **name**: `string`
-
-#### Returns
-
-`Promise`&lt;[`MaterializedView`](MaterializedView.md)&gt;
-
-***
-
 ### openTable()
 
 ```ts
@@ -677,13 +418,18 @@ abstract openTable(
    options?): Promise<Table>
 ```
 
+Open a table in the database.
+
 #### Parameters
 
 * **name**: `string`
+    The name of the table
 
 * **namespacePath?**: `string`[]
+    The namespace path of the table (defaults to root namespace)
 
 * **options?**: `Partial`&lt;[`OpenTableOptions`](../interfaces/OpenTableOptions.md)&gt;
+    Additional options
 
 #### Returns
 
@@ -724,7 +470,7 @@ a "not supported" error.
 
 ***
 
-### ~~tableNames()~~
+### tableNames()
 
 #### tableNames(options)
 
@@ -746,10 +492,6 @@ Tables will be returned in lexicographical order.
 
 `Promise`&lt;`string`[]&gt;
 
-##### Deprecated
-
-Use [Connection.listTables](Connection.md#listtables) instead.
-
 #### tableNames(namespacePath, options)
 
 ```ts
@@ -772,7 +514,3 @@ Tables will be returned in lexicographical order.
 ##### Returns
 
 `Promise`&lt;`string`[]&gt;
-
-##### Deprecated
-
-Use [Connection.listTables](Connection.md#listtables) instead.

docs/src/js/classes/Job.md

@@ -1,83 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / Job
-
-# Class: Job
-
-A handle to an operation that may still be running.
-
-## Constructors
-
-### new Job()
-
-```ts
-new Job(): Job
-```
-
-#### Returns
-
-[`Job`](Job.md)
-
-## Accessors
-
-### id
-
-```ts
-get id(): null | string
-```
-
-Identifies the operation on the server that is running it. Operations
-that run in this process have no server id. The value is opaque.
-
-#### Returns
-
-`null` \| `string`
-
-## Methods
-
-### cancel()
-
-```ts
-cancel(): Promise<void>
-```
-
-Request cancellation. Cancelling a finished operation is a no-op.
-
-#### Returns
-
-`Promise`&lt;`void`&gt;
-
-***
-
-### status()
-
-```ts
-status(): Promise<string>
-```
-
-The operation's current lifecycle state: "running", "finished",
-"failed", or "cancelled".
-
-A point snapshot; unlike [Job.wait](Job.md#wait) it does not block or reject
-on a terminal failure state. States a newer server reports that this
-client version does not know pass through as-is.
-
-#### Returns
-
-`Promise`&lt;`string`&gt;
-
-***
-
-### wait()
-
-```ts
-wait(): Promise<void>
-```
-
-Wait until the operation reaches a terminal state.
-
-#### Returns
-
-`Promise`&lt;`void`&gt;

docs/src/js/classes/MaterializedView.md

@@ -1,101 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / MaterializedView
-
-# Class: MaterializedView
-
-A handle on a materialized view: its table plus its definition.
-
-Obtained from [Connection#createMaterializedView](Connection.md#creatematerializedview) or
-[Connection#openMaterializedView](Connection.md#openmaterializedview). The view is a normal table --
-queries, indexes and search all apply through [MaterializedView#table](MaterializedView.md#table)
--- whose contents are maintained by [MaterializedView#refresh](MaterializedView.md#refresh).
-
-## Constructors
-
-### new MaterializedView()
-
-```ts
-new MaterializedView(table): MaterializedView
-```
-
-#### Parameters
-
-* **table**: [`Table`](Table.md)
-
-#### Returns
-
-[`MaterializedView`](MaterializedView.md)
-
-## Accessors
-
-### name
-
-```ts
-get name(): string
-```
-
-#### Returns
-
-`string`
-
-## Methods
-
-### definition()
-
-```ts
-definition(): Promise<MaterializedViewDefinition>
-```
-
-The query that defines the view, read from its stored schema.
-
-#### Returns
-
-`Promise`&lt;[`MaterializedViewDefinition`](../interfaces/MaterializedViewDefinition.md)&gt;
-
-***
-
-### refresh()
-
-```ts
-refresh(options?): Promise<RefreshMaterializedViewResult>
-```
-
-Recompute the view from its source.
-
-The refresh is incremental when the source's changes can be reconciled
-into the view -- rows added, changed or removed since the last one --
-and otherwise rebuilds. `full` forces a rebuild; `sourceVersion`
-refreshes to that source version instead of the latest.
-
-Concurrent refreshes of one view do not duplicate its rows. Two that
-plan the same source rows conflict on commit, and the loser throws
-rather than writing them a second time.
-
-#### Parameters
-
-* **options?**
-
-* **options.full?**: `boolean`
-
-* **options.sourceVersion?**: `number`
-
-#### Returns
-
-`Promise`&lt;[`RefreshMaterializedViewResult`](../interfaces/RefreshMaterializedViewResult.md)&gt;
-
-***
-
-### table()
-
-```ts
-table(): Table
-```
-
-The view, as the table it is.
-
-#### Returns
-
-[`Table`](Table.md)

docs/src/js/classes/MergeInsertBuilder.md

@@ -76,23 +76,24 @@ the query optimizer chooses a suboptimal path.
 
 ***
 
-### useLsm()
+### useLsmWrite()
 
 ```ts
-useLsm(enable): MergeInsertBuilder
+useLsmWrite(useLsmWrite): MergeInsertBuilder
 ```
 
-Control MemWAL routing for this merge.
+Controls whether the merge uses the MemWAL LSM write path.
 
 By default (unset), a `mergeInsert` on a table with an LSM write spec is
-routed through Lance's MemWAL shard writer, and a table without one uses the
-standard path.
+routed through Lance's MemWAL shard writer, and a table without one uses
+the standard path. Pass `false` to force the standard path even when a
+spec is set. Pass `true` to require a spec — `mergeInsert` rejects if none
+is installed.
 
 #### Parameters
 
-* **enable**: `boolean`
-    `true` forces MemWAL routing and errors if the table has no
-    LSM write spec. `false` forces the standard write path even when a spec is set.
+* **useLsmWrite**: `boolean`
+    Whether to use the LSM write path.
 
 #### Returns
 

docs/src/js/classes/Query.md

@@ -497,42 +497,6 @@ ArrowTable.
 
 ***
 
-### useLsm()
-
-```ts
-useLsm(enable): this
-```
-
-Control MemWAL read routing for this query.
-
-By default (unset), when the table carries a MemWAL write spec (see
-[Table#setLsmWriteSpec](Table.md#setlsmwritespec)), reads are routed through the LSM scanner so
-they also return data written via the `mergeInsert` LSM path that has not yet
-been compacted into the base table (the active/frozen in-memory memtables and
-the flushed generations), deduplicated by primary key; a table without a spec
-reads the base table.
-
-#### Parameters
-
-* **enable**: `boolean`
-    `true` forces the LSM scanner and errors if the table has no
-    MemWAL write spec. `false` bypasses the MemWAL and reads the base table only,
-    even when a spec is present.
-    Note: the LSM scanner does not support every query shape (e.g. reranking,
-    hybrid search, `orderBy`). On a MemWAL table those shapes error unless
-    `useLsm(false)` is set, because a base-only read would silently exclude
-    un-compacted MemWAL data.
-
-#### Returns
-
-`this`
-
-#### Inherited from
-
-`StandardQueryBase.useLsm`
-
-***
-
 ### where()
 
 ```ts

docs/src/js/classes/Table.md

@@ -69,34 +69,14 @@ abstract addColumns(newColumnTransforms): Promise<AddColumnsResult>
 
 Add new columns with defined values.
 
-The `{ computed }` form stores the expression rather than evaluating it
-now: the column is committed with no values, and rows get them from
-[Table#refreshColumn](Table.md#refreshcolumn). Declaring one therefore costs the same on a
-large table as on an empty one.
-
-A refresh does not revisit rows it has already filled, so mutating an
-input leaves the value computed at fill time; recomputing means dropping
-the column and declaring it again. While a declaration reads a column,
-that column cannot be renamed, retyped or dropped.
-
-On LanceDB Cloud and Enterprise the expression is planned by the
-server, and the refresh runs as a server job -- see
-[Table#refreshColumnAsync](Table.md#refreshcolumnasync).
-
 #### Parameters
 
-* **newColumnTransforms**:
-    \| `Field`&lt;`any`&gt;
-    \| `Field`&lt;`any`&gt;[]
-    \| `Schema`&lt;`any`&gt;
-    \| [`AddColumnsSql`](../interfaces/AddColumnsSql.md)[]
-    \| `object`
+* **newColumnTransforms**: `Field`&lt;`any`&gt; \| `Field`&lt;`any`&gt;[] \| `Schema`&lt;`any`&gt; \| [`AddColumnsSql`](../interfaces/AddColumnsSql.md)[]
     Either:
     - An array of objects with column names and SQL expressions to calculate values
     - A single Arrow Field defining one column with its data type (column will be initialized with null values)
     - An array of Arrow Fields defining columns with their data types (columns will be initialized with null values)
     - An Arrow Schema defining columns with their data types (columns will be initialized with null values)
-    - `{ computed }`, declaring columns defined by a SQL expression whose type and inputs are derived from it
 
 #### Returns
 
@@ -105,13 +85,6 @@ server, and the refresh runs as a server job -- see
 A promise that resolves to an object
 containing the new version number of the table after adding the columns.
 
-#### Example
-
-```ts
-await table.addColumns({ computed: [{ name: "doubled", valueSql: "x * 2" }] });
-const { rowsFilled } = await table.refreshColumn("doubled");
-```
-
 ***
 
 ### alterColumns()
@@ -213,39 +186,6 @@ version of the table.
 
 ***
 
-### checkpointLsm()
-
-```ts
-abstract checkpointLsm(): Promise<void>
-```
-
-Converge this table's LSM write path into its base table.
-
-Seals once, then triggers compaction and polls until the L0 that existed
-at the start is gone. The target set is fixed at the start, so
-generations created *during* the checkpoint are ignored — that is what
-lets it terminate under write load, and what makes it best-effort: it
-converges the fresh tier as of some instant. Idempotent, abandonable at
-any point, and safe to run on a cadence.
-
-There is no liveness bound — the compactor pool is shared across tables,
-so a checkpoint queued behind unrelated work looks exactly like one that
-is merging. The caller owns the deadline.
-
-#### Returns
-
-`Promise`&lt;`void`&gt;
-
-#### Example
-
-```ts
-const before = await table.getLsmStats();
-await table.checkpointLsm();
-const after = await table.getLsmStats();
-```
-
-***
-
 ### close()
 
 ```ts
@@ -283,24 +223,6 @@ It is a no-op when no writers are cached.
 
 ***
 
-### compactLsm()
-
-```ts
-abstract compactLsm(): Promise<void>
-```
-
-Trigger a background L0 → base compaction pass per bucket.
-
-Returns once the passes are *dispatched*, not once they finish — watch
-[Table#getLsmStats](Table.md#getlsmstats) for progress, or use
-[Table#checkpointLsm](Table.md#checkpointlsm) to wait for convergence.
-
-#### Returns
-
-`Promise`&lt;`void`&gt;
-
-***
-
 ### countRows()
 
 ```ts
@@ -373,29 +295,6 @@ await table.createIndex("my_float_col");
 
 ***
 
-### createIndexAsync()
-
-```ts
-abstract createIndexAsync(column, options?): Promise<Job>
-```
-
-Create an index, returning a handle to the indexing job.
-
-The job may already be complete when returned; callers must not assume
-the index exists until [Job.wait](Job.md#wait) resolves.
-
-#### Parameters
-
-* **column**: `string`
-
-* **options?**: `Partial`&lt;[`IndexOptions`](../interfaces/IndexOptions.md)&gt;
-
-#### Returns
-
-`Promise`&lt;[`Job`](Job.md)&gt;
-
-***
-
 ### currentBranch()
 
 ```ts
@@ -499,48 +398,6 @@ Drop an index from the table.
 
 ***
 
-### flushLsm()
-
-```ts
-abstract flushLsm(): Promise<void>
-```
-
-Seal every bucket's active memtable into a new L0 generation.
-
-Returns once the seal is committed. Sealing an empty memtable is a no-op,
-so this is safe to call repeatedly.
-
-#### Returns
-
-`Promise`&lt;`void`&gt;
-
-***
-
-### getLsmStats()
-
-```ts
-abstract getLsmStats(includeGenerationRows?): Promise<undefined | LsmStats>
-```
-
-Read live per-bucket LSM state.
-
-Answers "how far behind is my fresh tier", "which bucket is hot", and
-"why is my fresh-tier vector search brute-force". Mutates no table state.
-
-Resolves to `undefined` only when the LSM write path is not enabled.
-
-#### Parameters
-
-* **includeGenerationRows?**: `boolean`
-    Also count rows per L0 generation.
-    Off by default because each count opens an uncached Lance dataset.
-
-#### Returns
-
-`Promise`&lt;`undefined` \| [`LsmStats`](../interfaces/LsmStats.md)&gt;
-
-***
-
 ### getLsmWriteSpec()
 
 ```ts
@@ -551,10 +408,9 @@ Read the [LsmWriteSpec](../interfaces/LsmWriteSpec.md) currently installed on th
 
 Resolves to `undefined` when the MemWAL LSM write path is not enabled (no
 spec has been set, or it was removed with [Table#unsetLsmWriteSpec](Table.md#unsetlsmwritespec)).
-The returned spec mirrors what was passed to
-[Table#setLsmWriteSpec](Table.md#setlsmwritespec), except that `maintainedIndexes` always
-reports the concrete list resolved when the spec was set — `undefined`
-never round-trips.
+The returned spec — including its `maintainedIndexes` and
+`writerConfigDefaults` — mirrors what was passed to
+[Table#setLsmWriteSpec](Table.md#setlsmwritespec).
 
 #### Returns
 
@@ -838,67 +694,6 @@ for await (const batch of table.query()) {
 
 ***
 
-### refreshColumn()
-
-```ts
-abstract refreshColumn(column): Promise<RefreshColumnResult>
-```
-
-Fill the rows of a computed column that hold no value yet.
-
-Rows appended since the last refresh are filled by the next one; rows
-already filled are left as they are, so the call is idempotent and does
-not observe a mutated input. Local tables only: a remote refresh runs
-as a server job, through [Table#refreshColumnAsync](Table.md#refreshcolumnasync).
-
-#### Parameters
-
-* **column**: `string`
-    The name of the computed column to fill.
-
-#### Returns
-
-`Promise`&lt;[`RefreshColumnResult`](../interfaces/RefreshColumnResult.md)&gt;
-
-A promise that resolves to the
-number of rows filled and the new version number of the table.
-
-***
-
-### refreshColumnAsync()
-
-```ts
-abstract refreshColumnAsync(column): Promise<Job>
-```
-
-Like [Table#refreshColumn](Table.md#refreshcolumn), but returns a handle to the refresh
-job instead of blocking until it completes.
-
-The job may already be complete when returned; callers must not assume
-the column is filled until [Job.wait](Job.md#wait) resolves. Invalid input --
-an unknown column, or one that is not computed -- rejects here rather
-than failing the job. On local tables the job runs in-process; on
-LanceDB Cloud and Enterprise it is the server's backfill job.
-
-#### Parameters
-
-* **column**: `string`
-    The name of the computed column to fill.
-
-#### Returns
-
-`Promise`&lt;[`Job`](Job.md)&gt;
-
-#### Example
-
-```ts
-const job = await table.refreshColumnAsync("doubled");
-await job.wait();
-console.log(await job.status()); // "finished"
-```
-
-***
-
 ### restore()
 
 ```ts
@@ -942,7 +737,7 @@ Get the schema of the table.
 abstract search(
    query,
    queryType?,
-   ftsColumns?): Query | VectorQuery | AutoQuery
+   ftsColumns?): Query | VectorQuery
 ```
 
 Create a search query to find the nearest neighbors
@@ -964,7 +759,7 @@ of the given query
 
 #### Returns
 
-[`Query`](Query.md) \| [`VectorQuery`](VectorQuery.md) \| [`AutoQuery`](AutoQuery.md)
+[`Query`](Query.md) \| [`VectorQuery`](VectorQuery.md)
 
 ***
 
@@ -988,11 +783,6 @@ All variants require the table to have an unenforced primary key
 ([Table#setUnenforcedPrimaryKey](Table.md#setunenforcedprimarykey)); bucket sharding additionally
 requires it to be the single column being bucketed.
 
-Omitting `maintainedIndexes` maintains every index on the table, resolved
-here, failing if one cannot be maintained — name them to install anyway.
-Naming them pins an exact set, and a still-building index is rejected
-rather than quietly omitted.
-
 #### Parameters
 
 * **spec**: [`LsmWriteSpec`](../interfaces/LsmWriteSpec.md)
@@ -1292,18 +1082,6 @@ abstract updateFieldMetadata(updates): Promise<UpdateFieldMetadataResult>
 
 Update per-field (column) metadata.
 
-The following keys are treated specially, by convention, and should be
-used when appropriate:
-
-- `lancedb:description`: for a human-readable description of a field.
-- `lancedb:tag:<name>`: for a user-defined key-value tag, where the suffix
-  names the tag category; e.g. `lancedb:tag:model: "clip"`.
-- `lancedb:logical-column`: for a column grouping; e.g. `feature_v1` and
-  `feature_v2` might be in the same logical column.
-- `lancedb:status`: for status options (`production`, `candidate`,
-  `deprecated`, `archived`) to designate the current life cycle state of
-  this column.
-
 #### Parameters
 
 * **updates**: [`FieldMetadataUpdate`](../interfaces/FieldMetadataUpdate.md)[]

docs/src/js/classes/TakeQuery.md

@@ -273,29 +273,6 @@ ArrowTable.
 
 ***
 
-### useLsm()
-
-```ts
-useLsm(enable): this
-```
-
-Control MemWAL read routing for this take query.
-
-`false` bypasses the MemWAL and reads the base table only — the escape hatch,
-since take-by-row-id/offset is not supported on the LSM scanner and, on a
-MemWAL table, auto-routes to it and errors otherwise.
-
-#### Parameters
-
-* **enable**: `boolean`
-    `false` reads the base table only.
-
-#### Returns
-
-`this`
-
-***
-
 ### withRowId()
 
 ```ts

docs/src/js/classes/VectorQuery.md

@@ -746,42 +746,6 @@ ArrowTable.
 
 ***
 
-### useLsm()
-
-```ts
-useLsm(enable): this
-```
-
-Control MemWAL read routing for this query.
-
-By default (unset), when the table carries a MemWAL write spec (see
-[Table#setLsmWriteSpec](Table.md#setlsmwritespec)), reads are routed through the LSM scanner so
-they also return data written via the `mergeInsert` LSM path that has not yet
-been compacted into the base table (the active/frozen in-memory memtables and
-the flushed generations), deduplicated by primary key; a table without a spec
-reads the base table.
-
-#### Parameters
-
-* **enable**: `boolean`
-    `true` forces the LSM scanner and errors if the table has no
-    MemWAL write spec. `false` bypasses the MemWAL and reads the base table only,
-    even when a spec is present.
-    Note: the LSM scanner does not support every query shape (e.g. reranking,
-    hybrid search, `orderBy`). On a MemWAL table those shapes error unless
-    `useLsm(false)` is set, because a base-only read would silently exclude
-    un-compacted MemWAL data.
-
-#### Returns
-
-`this`
-
-#### Inherited from
-
-`StandardQueryBase.useLsm`
-
-***
-
 ### where()
 
 ```ts

docs/src/js/globals.md

@@ -18,7 +18,6 @@
 
 ## Classes
 
-- [AutoQuery](classes/AutoQuery.md)
 - [BooleanQuery](classes/BooleanQuery.md)
 - [BoostQuery](classes/BoostQuery.md)
 - [BranchContents](classes/BranchContents.md)
@@ -26,10 +25,8 @@
 - [Connection](classes/Connection.md)
 - [HeaderProvider](classes/HeaderProvider.md)
 - [Index](classes/Index.md)
-- [Job](classes/Job.md)
 - [MakeArrowTableOptions](classes/MakeArrowTableOptions.md)
 - [MatchQuery](classes/MatchQuery.md)
-- [MaterializedView](classes/MaterializedView.md)
 - [MergeInsertBuilder](classes/MergeInsertBuilder.md)
 - [MultiMatchQuery](classes/MultiMatchQuery.md)
 - [NativeJsHeaderProvider](classes/NativeJsHeaderProvider.md)
@@ -55,15 +52,6 @@
 - [AddDataOptions](interfaces/AddDataOptions.md)
 - [AddResult](interfaces/AddResult.md)
 - [AlterColumnsResult](interfaces/AlterColumnsResult.md)
-- [BranchColumnChange](interfaces/BranchColumnChange.md)
-- [BranchColumnSummary](interfaces/BranchColumnSummary.md)
-- [BranchDiff](interfaces/BranchDiff.md)
-- [BranchIndexSummary](interfaces/BranchIndexSummary.md)
-- [BranchRowCountSummary](interfaces/BranchRowCountSummary.md)
-- [BucketStats](interfaces/BucketStats.md)
-- [CherryPickError](interfaces/CherryPickError.md)
-- [CherryPickPreview](interfaces/CherryPickPreview.md)
-- [CherryPickResult](interfaces/CherryPickResult.md)
 - [ClientConfig](interfaces/ClientConfig.md)
 - [ColumnAlteration](interfaces/ColumnAlteration.md)
 - [ColumnOrdering](interfaces/ColumnOrdering.md)
@@ -87,7 +75,6 @@
 - [FtsToken](interfaces/FtsToken.md)
 - [FullTextQuery](interfaces/FullTextQuery.md)
 - [FullTextSearchOptions](interfaces/FullTextSearchOptions.md)
-- [GenerationStats](interfaces/GenerationStats.md)
 - [HnswPqOptions](interfaces/HnswPqOptions.md)
 - [HnswSqOptions](interfaces/HnswSqOptions.md)
 - [IndexConfig](interfaces/IndexConfig.md)
@@ -96,17 +83,9 @@
 - [IvfFlatOptions](interfaces/IvfFlatOptions.md)
 - [IvfPqOptions](interfaces/IvfPqOptions.md)
 - [IvfRqOptions](interfaces/IvfRqOptions.md)
-- [JobDescription](interfaces/JobDescription.md)
-- [JobFailureInfo](interfaces/JobFailureInfo.md)
-- [JobInfo](interfaces/JobInfo.md)
 - [ListNamespacesOptions](interfaces/ListNamespacesOptions.md)
 - [ListNamespacesResponse](interfaces/ListNamespacesResponse.md)
-- [ListTablesOptions](interfaces/ListTablesOptions.md)
-- [ListTablesResponse](interfaces/ListTablesResponse.md)
-- [LsmStats](interfaces/LsmStats.md)
 - [LsmWriteSpec](interfaces/LsmWriteSpec.md)
-- [MaterializedViewDefinition](interfaces/MaterializedViewDefinition.md)
-- [MemtableStats](interfaces/MemtableStats.md)
 - [MergeResult](interfaces/MergeResult.md)
 - [NativeOAuthConfig](interfaces/NativeOAuthConfig.md)
 - [OAuthConfig](interfaces/OAuthConfig.md)
@@ -114,8 +93,6 @@
 - [OptimizeOptions](interfaces/OptimizeOptions.md)
 - [OptimizeStats](interfaces/OptimizeStats.md)
 - [QueryExecutionOptions](interfaces/QueryExecutionOptions.md)
-- [RefreshColumnResult](interfaces/RefreshColumnResult.md)
-- [RefreshMaterializedViewResult](interfaces/RefreshMaterializedViewResult.md)
 - [RemovalStats](interfaces/RemovalStats.md)
 - [RenameTableOptions](interfaces/RenameTableOptions.md)
 - [RestNamespaceConfig](interfaces/RestNamespaceConfig.md)
@@ -148,7 +125,6 @@
 - [FieldLike](type-aliases/FieldLike.md)
 - [IntoSql](type-aliases/IntoSql.md)
 - [IntoVector](type-aliases/IntoVector.md)
-- [MaterializedViewSelect](type-aliases/MaterializedViewSelect.md)
 - [MultiVector](type-aliases/MultiVector.md)
 - [RecordBatchLike](type-aliases/RecordBatchLike.md)
 - [SchemaLike](type-aliases/SchemaLike.md)

docs/src/js/interfaces/BranchColumnChange.md

@@ -1,33 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / BranchColumnChange
-
-# Interface: BranchColumnChange
-
-A column whose definition differs between main and the branch.
-
-## Properties
-
-### branch
-
-```ts
-branch: BranchColumnSummary;
-```
-
-***
-
-### main
-
-```ts
-main: BranchColumnSummary;
-```
-
-***
-
-### name
-
-```ts
-name: string;
-```

docs/src/js/interfaces/BranchColumnSummary.md

@@ -1,33 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / BranchColumnSummary
-
-# Interface: BranchColumnSummary
-
-Summary of a column in a branch diff.
-
-## Properties
-
-### dataType
-
-```ts
-dataType: string;
-```
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-***
-
-### nullable
-
-```ts
-nullable: boolean;
-```

docs/src/js/interfaces/BranchDiff.md

@@ -1,121 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / BranchDiff
-
-# Interface: BranchDiff
-
-Read-only comparison of a branch against main.
-
-## Properties
-
-### addedColumns
-
-```ts
-addedColumns: BranchColumnSummary[];
-```
-
-***
-
-### addedIndexes
-
-```ts
-addedIndexes: BranchIndexSummary[];
-```
-
-***
-
-### baseMoved
-
-```ts
-baseMoved: boolean;
-```
-
-***
-
-### branchVersion
-
-```ts
-branchVersion: number;
-```
-
-***
-
-### changedColumns
-
-```ts
-changedColumns: BranchColumnChange[];
-```
-
-***
-
-### errors
-
-```ts
-errors: CherryPickError[];
-```
-
-***
-
-### fromBranch
-
-```ts
-fromBranch: string;
-```
-
-***
-
-### mainVersion
-
-```ts
-mainVersion: number;
-```
-
-***
-
-### parentVersion
-
-```ts
-parentVersion: number;
-```
-
-***
-
-### removedColumns
-
-```ts
-removedColumns: BranchColumnSummary[];
-```
-
-***
-
-### removedIndexes
-
-```ts
-removedIndexes: BranchIndexSummary[];
-```
-
-***
-
-### rowCountBranch
-
-```ts
-rowCountBranch: number;
-```
-
-***
-
-### rowCountMain
-
-```ts
-rowCountMain: number;
-```
-
-***
-
-### rowSummary
-
-```ts
-rowSummary: BranchRowCountSummary;
-```

docs/src/js/interfaces/BranchIndexSummary.md

@@ -1,41 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / BranchIndexSummary
-
-# Interface: BranchIndexSummary
-
-Summary of an index in a branch diff.
-
-## Properties
-
-### columns
-
-```ts
-columns: string[];
-```
-
-***
-
-### indexName
-
-```ts
-indexName: string;
-```
-
-***
-
-### indexType?
-
-```ts
-optional indexType: string;
-```
-
-***
-
-### status
-
-```ts
-status: string;
-```

docs/src/js/interfaces/BranchRowCountSummary.md

@@ -1,57 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / BranchRowCountSummary
-
-# Interface: BranchRowCountSummary
-
-Row-level comparison between main and the branch.
-
-## Properties
-
-### deltaAvailable
-
-```ts
-deltaAvailable: boolean;
-```
-
-***
-
-### inputsChanged
-
-```ts
-inputsChanged: number;
-```
-
-***
-
-### newOnBase
-
-```ts
-newOnBase: number;
-```
-
-***
-
-### newOnBranch
-
-```ts
-newOnBranch: number;
-```
-
-***
-
-### staleRecompute
-
-```ts
-staleRecompute: number;
-```
-
-***
-
-### unchanged
-
-```ts
-unchanged: number;
-```

docs/src/js/interfaces/BucketStats.md

@@ -1,116 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / BucketStats
-
-# Interface: BucketStats
-
-Live state of one bucket. A table is N buckets on one node; flattening to a
-single number hides the one hot bucket that is usually why someone opened
-this endpoint.
-
-## Properties
-
-### compacting
-
-```ts
-compacting: boolean;
-```
-
-Whether a pass owns this bucket's compaction latch right now. Says *a*
-driver is running, not *whose*, and the latch is held from dispatch —
-including while the pass queues for a pod-wide compactor permit. Read it
-as "do not pile on", never as "mine is progressing".
-
-***
-
-### currentGeneration
-
-```ts
-currentGeneration: number;
-```
-
-The generation the active memtable will become.
-
-***
-
-### generations
-
-```ts
-generations: GenerationStats[];
-```
-
-Flushed L0 generations not yet merged into the base table.
-
-***
-
-### manifestVersion
-
-```ts
-manifestVersion: number;
-```
-
-Version of the shard manifest these numbers were read from.
-
-***
-
-### memtables?
-
-```ts
-optional memtables: MemtableStats[];
-```
-
-Oldest first, active last. Absent for a `"Sealed"` bucket, whose
-in-memory state is torn down.
-
-***
-
-### replayAfterWalEntryPosition
-
-```ts
-replayAfterWalEntryPosition: number;
-```
-
-WAL position replay resumes from.
-
-***
-
-### shardId
-
-```ts
-shardId: string;
-```
-
-The shard this bucket writes.
-
-***
-
-### status
-
-```ts
-status: string;
-```
-
-`"Active"` or `"Sealed"` (drop-table 2PC in flight).
-
-***
-
-### walEntryPositionLastSeen
-
-```ts
-walEntryPositionLastSeen: number;
-```
-
-Highest WAL position the writer has seen. The difference against
-`replayAfterWalEntryPosition` is the WAL lag.
-
-***
-
-### writerEpoch
-
-```ts
-writerEpoch: number;
-```
-
-Epoch of the writer that currently owns the shard.

docs/src/js/interfaces/CherryPickError.md

@@ -1,25 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / CherryPickError
-
-# Interface: CherryPickError
-
-A reason why a cherry-pick cannot currently land.
-
-## Properties
-
-### code
-
-```ts
-code: string;
-```
-
-***
-
-### message
-
-```ts
-message: string;
-```

docs/src/js/interfaces/CherryPickPreview.md

@@ -1,17 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / CherryPickPreview
-
-# Interface: CherryPickPreview
-
-Changes that would be, or were, promoted by a cherry-pick.
-
-## Properties
-
-### promotedColumns
-
-```ts
-promotedColumns: string[];
-```

docs/src/js/interfaces/CherryPickResult.md

@@ -1,46 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / CherryPickResult
-
-# Interface: CherryPickResult
-
-Result of previewing or attempting a cherry-pick.
-
-## Properties
-
-### diff
-
-```ts
-diff: BranchDiff;
-```
-
-***
-
-### mainVersionAfter?
-
-```ts
-optional mainVersionAfter: number;
-```
-
-***
-
-### preview
-
-```ts
-preview: CherryPickPreview;
-```
-
-***
-
-### status
-
-```ts
-status:
-  | "failed"
-  | "unknown"
-  | "ready"
-  | "notImplemented"
-  | "cherryPicked";
-```

docs/src/js/interfaces/FieldMetadataUpdate.md

@@ -17,8 +17,7 @@ metadata: Record<string, null | string>;
 ```
 
 Metadata key/value pairs. Merged into the field's existing metadata by
-default; a value of `null` deletes that key. See
-[Table.updateFieldMetadata](../classes/Table.md#updatefieldmetadata) for the conventional `lancedb:*` keys.
+default; a value of `null` deletes that key.
 
 ***
 

docs/src/js/interfaces/FtsOptions.md

@@ -43,34 +43,6 @@ The following tokenizers are available:
 
 ***
 
-### blockSize?
-
-```ts
-optional blockSize: 128 | 256;
-```
-
-Number of documents per compressed posting block.
-
-The default is 128. Supported values are 128 and 256. A value of 256 uses
-the experimental FTS V3 format and may introduce breaking changes.
-
-***
-
-### customStopWords?
-
-```ts
-optional customStopWords: string[];
-```
-
-Custom stop words that replace the built-in list for `language`.
-
-This option only affects tokenization when `removeStopWords` is true.
-
-`undefined` keeps the built-in language list. An empty array explicitly
-replaces it with no stop words.
-
-***
-
 ### language?
 
 ```ts

docs/src/js/interfaces/GenerationStats.md

@@ -1,40 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / GenerationStats
-
-# Interface: GenerationStats
-
-One flushed L0 generation.
-
-## Properties
-
-### bytes
-
-```ts
-bytes: number;
-```
-
-On-disk size of the generation.
-
-***
-
-### generation
-
-```ts
-generation: number;
-```
-
-The generation number. Increases as memtables are sealed into L0.
-
-***
-
-### rows?
-
-```ts
-optional rows: number;
-```
-
-Present only when `includeGenerationRows` was requested. Off by default
-because each count opens an uncached Lance dataset.

docs/src/js/interfaces/JobDescription.md

@@ -1,66 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / JobDescription
-
-# Interface: JobDescription
-
-A described job from `Connection.getJob`.
-
-## Properties
-
-### creationMs
-
-```ts
-creationMs: number;
-```
-
-When the job was created, in milliseconds since the epoch.
-
-***
-
-### failure?
-
-```ts
-optional failure: JobFailureInfo;
-```
-
-Why the job failed, when the job is failed and the server reports a
-reason.
-
-***
-
-### jobId
-
-```ts
-jobId: string;
-```
-
-***
-
-### jobType
-
-```ts
-jobType: string;
-```
-
-***
-
-### specJson?
-
-```ts
-optional specJson: string;
-```
-
-The job-type-specific specification as a JSON string, when present.
-
-***
-
-### state
-
-```ts
-state: string;
-```
-
-Lifecycle state: "running", "finished", "failed", or "cancelled".

docs/src/js/interfaces/JobFailureInfo.md

@@ -1,33 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / JobFailureInfo
-
-# Interface: JobFailureInfo
-
-The server's account of why a job failed.
-
-## Properties
-
-### message?
-
-```ts
-optional message: string;
-```
-
-***
-
-### phase?
-
-```ts
-optional phase: string;
-```
-
-***
-
-### retryable?
-
-```ts
-optional retryable: boolean;
-```

docs/src/js/interfaces/JobInfo.md

@@ -1,58 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / JobInfo
-
-# Interface: JobInfo
-
-A row from `Connection.listJobs`: one server-side job.
-
-## Properties
-
-### createdAtMillis
-
-```ts
-createdAtMillis: number;
-```
-
-When the job was created, in milliseconds since the epoch.
-
-***
-
-### jobId
-
-```ts
-jobId: string;
-```
-
-The job id -- what `Connection.getJob` and `Connection.cancelJob`
-accept.
-
-***
-
-### jobType
-
-```ts
-jobType: string;
-```
-
-***
-
-### state
-
-```ts
-state: string;
-```
-
-Lifecycle state: "running", "finished", "failed", or "cancelled".
-
-***
-
-### table
-
-```ts
-table: string;
-```
-
-The table the job runs against, without URI or namespace.

docs/src/js/interfaces/ListTablesOptions.md

@@ -1,34 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / ListTablesOptions
-
-# Interface: ListTablesOptions
-
-## Properties
-
-### limit?
-
-```ts
-optional limit: number;
-```
-
-An upper bound on how many tables to return.
-
-A page may hold fewer than this and still not be the last one, so keep
-going while the response carries a page token rather than while pages are
-full.
-
-***
-
-### pageToken?
-
-```ts
-optional pageToken: string;
-```
-
-Token from a previous response, to resume listing where it left off.
-
-The token is opaque: it carries whatever the database needs to resume, and
-callers should not construct or interpret one.

docs/src/js/interfaces/ListTablesResponse.md

@@ -1,23 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / ListTablesResponse
-
-# Interface: ListTablesResponse
-
-## Properties
-
-### pageToken?
-
-```ts
-optional pageToken: string;
-```
-
-***
-
-### tables
-
-```ts
-tables: string[];
-```

docs/src/js/interfaces/LsmStats.md

@@ -1,22 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / LsmStats
-
-# Interface: LsmStats
-
-Live per-bucket LSM state, as returned by `Table#getLsmStats`.
-
-Nothing here is derived: sums and differences (total L0 bytes, WAL lag) are
-the caller's to compute.
-
-## Properties
-
-### buckets
-
-```ts
-buckets: BucketStats[];
-```
-
-One entry per bucket backing this table.

docs/src/js/interfaces/LsmWriteSpec.md

@@ -34,9 +34,7 @@ Bucket and identity variants: the sharding column.
 optional maintainedIndexes: string[];
 ```
 
-Indexes the MemWAL keeps up to date. Omit to maintain every supported
-index, resolved on install — a snapshot, so indexes created later are not
-maintained. Pass `[]` for none.
+Names of indexes the MemWAL should keep up to date during writes.
 
 ***
 

docs/src/js/interfaces/MaterializedViewDefinition.md

@@ -1,59 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / MaterializedViewDefinition
-
-# Interface: MaterializedViewDefinition
-
-The query that defines a materialized view.
-
-## Properties
-
-### filter?
-
-```ts
-optional filter: string;
-```
-
-SQL predicate selecting the source rows the view holds.
-
-***
-
-### inputs
-
-```ts
-inputs: string[];
-```
-
-Source columns the projections and filter read.
-
-***
-
-### limit?
-
-```ts
-optional limit: number;
-```
-
-Cap on the number of rows the view holds.
-
-***
-
-### projections
-
-```ts
-projections: [string, string][];
-```
-
-`[output column, SQL expression]` pairs, in view schema order.
-
-***
-
-### sourceTable
-
-```ts
-sourceTable: string;
-```
-
-Name of the source table, in the same database as the view.

docs/src/js/interfaces/MemtableStats.md

@@ -1,60 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / MemtableStats
-
-# Interface: MemtableStats
-
-One in-memory memtable.
-
-## Properties
-
-### batches
-
-```ts
-batches: number;
-```
-
-Record batches currently buffered.
-
-***
-
-### bytes
-
-```ts
-bytes: number;
-```
-
-Estimated in-memory size.
-
-***
-
-### generation
-
-```ts
-generation: number;
-```
-
-The generation this memtable will become once sealed.
-
-***
-
-### indexes
-
-```ts
-indexes: string[];
-```
-
-Names of the indexes this memtable carries. An absent name is the whole
-answer to "why is my fresh-tier search on that column brute-force".
-
-***
-
-### rows
-
-```ts
-rows: number;
-```
-
-Rows currently buffered.

docs/src/js/interfaces/RefreshColumnResult.md

@@ -1,23 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / RefreshColumnResult
-
-# Interface: RefreshColumnResult
-
-## Properties
-
-### rowsFilled
-
-```ts
-rowsFilled: number;
-```
-
-***
-
-### version
-
-```ts
-version: number;
-```

docs/src/js/interfaces/RefreshMaterializedViewResult.md

@@ -1,41 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / RefreshMaterializedViewResult
-
-# Interface: RefreshMaterializedViewResult
-
-## Properties
-
-### mode
-
-```ts
-mode: string;
-```
-
-How the view was brought up to date: "rebuild", "incremental" or "no_op".
-
-***
-
-### rowsWritten
-
-```ts
-rowsWritten: number;
-```
-
-***
-
-### sourceVersion
-
-```ts
-sourceVersion: number;
-```
-
-***
-
-### version
-
-```ts
-version: number;
-```

docs/src/js/interfaces/TableNamesOptions.md

@@ -4,16 +4,11 @@
 
 [@lancedb/lancedb](../globals.md) / TableNamesOptions
 
-# Interface: ~~TableNamesOptions~~
-
-## Deprecated
-
-Use [ListTablesOptions](ListTablesOptions.md) with [Connection.listTables](../classes/Connection.md#listtables)
-instead.
+# Interface: TableNamesOptions
 
 ## Properties
 
-### ~~limit?~~
+### limit?
 
 ```ts
 optional limit: number;
@@ -23,7 +18,7 @@ An optional limit to the number of results to return.
 
 ***
 
-### ~~startAfter?~~
+### startAfter?
 
 ```ts
 optional startAfter: string;

docs/src/js/interfaces/TableStatistics.md

@@ -44,7 +44,4 @@ The number of rows in the table
 totalBytes: number;
 ```
 
-The total size, in bytes, of the table's data files, index files, and
-overlay files
-
-Read from the manifest, so this excludes deletion files and manifests.
+The total number of bytes in the table

docs/src/js/interfaces/TokenizeOptions.md

@@ -30,21 +30,6 @@ The tokenizer to use. The default is "simple".
 
 ***
 
-### customStopWords?
-
-```ts
-optional customStopWords: string[];
-```
-
-Custom stop words that replace the built-in list for `language`.
-
-This option only affects tokenization when `removeStopWords` is true.
-
-`undefined` keeps the built-in language list. An empty array explicitly
-replaces it with no stop words.
-
-***
-
 ### language?
 
 ```ts

docs/src/js/namespaces/embedding/README.md

@@ -25,12 +25,9 @@
 ### Type Aliases
 
 - [CreateReturnType](type-aliases/CreateReturnType.md)
-- [EmbeddingMetadataEntry](type-aliases/EmbeddingMetadataEntry.md)
-- [ResolvedEmbeddingFunctionConfig](type-aliases/ResolvedEmbeddingFunctionConfig.md)
 
 ### Functions
 
 - [LanceSchema](functions/LanceSchema.md)
 - [getRegistry](functions/getRegistry.md)
-- [parseEmbeddingMetadata](functions/parseEmbeddingMetadata.md)
 - [register](functions/register.md)

docs/src/js/namespaces/embedding/functions/getRegistry.md

@@ -10,12 +10,16 @@
 function getRegistry(): EmbeddingFunctionRegistry
 ```
 
-Get the global embedding function registry.
-
-LanceDB built-in providers are initialized when this public API is first
-used, so importing the root package does not change automatic search
-selection for tables without embedding metadata.
+Utility function to get the global instance of the registry
 
 ## Returns
 
 [`EmbeddingFunctionRegistry`](../classes/EmbeddingFunctionRegistry.md)
+
+`EmbeddingFunctionRegistry` The global instance of the registry
+
+## Example
+
+```ts
+const registry = getRegistry();
+const openai = registry.get("openai").create();

docs/src/js/namespaces/embedding/functions/parseEmbeddingMetadata.md

@@ -1,22 +0,0 @@
-[**@lancedb/lancedb**](../../../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../../../globals.md) / [embedding](../README.md) / parseEmbeddingMetadata
-
-# Function: parseEmbeddingMetadata()
-
-```ts
-function parseEmbeddingMetadata(json): EmbeddingMetadataEntry[]
-```
-
-The single parser for `embedding_functions` schema metadata: every reader
-goes through here, so the wire contract cannot fork between them.
-
-## Parameters
-
-* **json**: `string`
-
-## Returns
-
-[`EmbeddingMetadataEntry`](../type-aliases/EmbeddingMetadataEntry.md)[]

docs/src/js/namespaces/embedding/type-aliases/EmbeddingMetadataEntry.md

@@ -1,40 +0,0 @@
-[**@lancedb/lancedb**](../../../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../../../globals.md) / [embedding](../README.md) / EmbeddingMetadataEntry
-
-# Type Alias: EmbeddingMetadataEntry
-
-```ts
-type EmbeddingMetadataEntry: object;
-```
-
-One entry of the `embedding_functions` schema metadata, with the column
-keys normalized across the bindings' spellings.
-
-## Type declaration
-
-### model
-
-```ts
-model: EmbeddingFunction["TOptions"];
-```
-
-### name
-
-```ts
-name: string;
-```
-
-### sourceColumn
-
-```ts
-sourceColumn: string;
-```
-
-### vectorColumn
-
-```ts
-vectorColumn: string;
-```

docs/src/js/namespaces/embedding/type-aliases/ResolvedEmbeddingFunctionConfig.md

@@ -1,22 +0,0 @@
-[**@lancedb/lancedb**](../../../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../../../globals.md) / [embedding](../README.md) / ResolvedEmbeddingFunctionConfig
-
-# Type Alias: ResolvedEmbeddingFunctionConfig
-
-```ts
-type ResolvedEmbeddingFunctionConfig: EmbeddingFunctionConfig & object;
-```
-
-An [EmbeddingFunctionConfig] read back from table metadata, where the
-vector column is always recorded.
-
-## Type declaration
-
-### vectorColumn
-
-```ts
-vectorColumn: string;
-```

docs/src/js/type-aliases/MaterializedViewSelect.md

@@ -1,14 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / MaterializedViewSelect
-
-# Type Alias: MaterializedViewSelect
-
-```ts
-type MaterializedViewSelect: (string | [string, string])[] | Record<string, string>;
-```
-
-The view's columns: column names, `[alias, SQL expression]` pairs, or a
-record of the same. A bare name projects itself.

docs/src/python/python.md

@@ -26,18 +26,6 @@ is also an [asynchronous API client](#connections-asynchronous).
 
 ::: lancedb.db.DBConnection
 
-::: lancedb.Session
-
-## Namespaces (Synchronous)
-
-A namespace-backed connection resolves tables through a
-[Lance namespace](https://lance-format.github.io/lance-namespace/) service instead of
-listing a storage directory.
-
-::: lancedb.connect_namespace
-
-::: lancedb.namespace.LanceNamespaceDBConnection
-
 ## Tables (Synchronous)
 
 ::: lancedb.table.Table
@@ -46,68 +34,8 @@ listing a storage directory.
 
 ::: lancedb.table.FragmentSummaryStats
 
-::: lancedb.table.TableStatistics
-
 ::: lancedb.table.Tags
 
-::: lancedb.table.Branches
-
-::: lancedb.LsmWriteSpec
-
-## Functions and Jobs
-
-::: lancedb.functions.FunctionArtifact
-
-::: lancedb.functions.FunctionParameter
-
-::: lancedb.functions.FunctionResultField
-
-::: lancedb.functions.FunctionOutput
-
-::: lancedb.functions.FunctionSignature
-
-::: lancedb.functions.PythonEnvironmentSpec
-
-::: lancedb.functions.udf
-
-::: lancedb.functions.UdfDefinition
-
-::: lancedb.functions.FunctionRegistrationRequest
-
-::: lancedb.functions.FunctionArtifactRequest
-
-::: lancedb.functions.FunctionArtifactContent
-
-::: lancedb.functions.PythonAdapterSpec
-
-::: lancedb.functions.FunctionVersion
-
-::: lancedb.functions.PythonRuntimeSpec
-
-::: lancedb.functions.FunctionVersionRef
-
-::: lancedb.functions.ApplicationInput
-
-::: lancedb.functions.FunctionApplication
-
-::: lancedb.functions.InputBinding
-
-::: lancedb.functions.OutputMapping
-
-::: lancedb.functions.FunctionBinding
-
-::: lancedb.functions.RefreshColumnResult
-
-::: lancedb.job.Job
-
-::: lancedb.job.AsyncJob
-
-## Materialized Views (Synchronous)
-
-::: lancedb.materialized_view.MaterializedView
-
-::: lancedb.materialized_view.MaterializedViewDefinition
-
 ## Expressions
 
 Type-safe expression builder for filters and projections. Use these instead
@@ -134,48 +62,29 @@ of raw SQL strings with [where][lancedb.query.LanceQueryBuilder.where] and
 
 ::: lancedb.query.LanceHybridQueryBuilder
 
-::: lancedb.query.LanceEmptyQueryBuilder
-
-::: lancedb.query.LanceTakeQueryBuilder
-
-## Full text queries
-
-Structured full text queries can be passed to
-[Table.search][lancedb.table.Table.search] or
-[AsyncTable.search][lancedb.table.AsyncTable.search] in place of a query string,
-and combined with [BooleanQuery][lancedb.query.BooleanQuery].
-
-::: lancedb.query.FullTextQuery
-
-::: lancedb.query.MatchQuery
-
-::: lancedb.query.PhraseQuery
-
-::: lancedb.query.BoostQuery
-
-::: lancedb.query.MultiMatchQuery
-
-::: lancedb.query.BooleanQuery
-
-::: lancedb.query.FullTextOperator
-
-::: lancedb.query.DocumentGranularity
-
-::: lancedb.query.Occur
-
 ## Embeddings
 
-::: lancedb.embeddings
-    options:
-      show_root_heading: false
-      show_root_toc_entry: false
+::: lancedb.embeddings.registry.EmbeddingFunctionRegistry
+
+::: lancedb.embeddings.base.EmbeddingFunctionConfig
+
+::: lancedb.embeddings.base.EmbeddingFunction
+
+::: lancedb.embeddings.base.TextEmbeddingFunction
+
+::: lancedb.embeddings.sentence_transformers.SentenceTransformerEmbeddings
+
+::: lancedb.embeddings.openai.OpenAIEmbeddings
+
+::: lancedb.embeddings.open_clip.OpenClipEmbeddings
 
 ## Remote configuration
 
-::: lancedb.remote
-    options:
-      show_root_heading: false
-      show_root_toc_entry: false
+::: lancedb.remote.ClientConfig
+
+::: lancedb.remote.TimeoutConfig
+
+::: lancedb.remote.RetryConfig
 
 ## Context
 
@@ -185,55 +94,11 @@ and combined with [BooleanQuery][lancedb.query.BooleanQuery].
 
 ## Full text search
 
-Pass `custom_stop_words` to [lancedb.index.FTS][]:
+Use [lancedb.table.Table.create_fts_index][] for the synchronous API or
+[lancedb.table.AsyncTable.create_index][] with [lancedb.index.FTS][] for the
+asynchronous API.
 
-```python
-from lancedb.index import FTS
-
-table.create_index(
-    "text",
-    config=FTS(remove_stop_words=True, custom_stop_words=["acme", "internal"]),
-)
-```
-
-The list replaces the built-in stop words and is used only when
-`remove_stop_words=True`:
-
-- `custom_stop_words=None` uses the built-in list for `language`.
-- `custom_stop_words=[]` removes no words.
-- Values are passed through without trimming, lowercasing, or other rewriting.
-
-The same option is available on `lancedb.tokenize(...)` and the deprecated
-[lancedb.table.Table.create_fts_index][] compatibility helper:
-
-```python
-import lancedb
-
-tokens = list(
-    lancedb.tokenize("acme makes searchable data", custom_stop_words=["acme"])
-)
-```
-
-::: lancedb.tokenize
-
-::: lancedb.FtsToken
-
-## Blobs
-
-Blob columns store large binary values out of line so they can be read lazily
-instead of being materialized with the rest of the row.
-
-`lancedb.BlobType` is `lance.blob.BlobType` when pylance is installed. Without
-pylance, LanceDB uses a matching `lance.blob.v2` extension type so blob columns
-still work. Queries return descriptors. Call
-[`fetch_blob_files`][lancedb.table.Table.fetch_blob_files] for lazy reads or
-[`fetch_blobs`][lancedb.table.Table.fetch_blobs] for eager bytes.
-
-::: lancedb.blob
-
-::: lancedb._blob.BlobFile
-    options:
-      show_root_full_path: false
+::: lancedb.index.FTS
 
 ## Utilities
 
@@ -241,14 +106,6 @@ still work. Queries return descriptors. Call
 
 ::: lancedb.merge.LanceMergeInsertBuilder
 
-::: lancedb.otel.instrument_lancedb_metrics
-
-## Exceptions
-
-::: lancedb.exceptions.MissingValueError
-
-::: lancedb.exceptions.MissingColumnError
-
 ## Integrations
 
 ## Pydantic
@@ -257,32 +114,19 @@ still work. Queries return descriptors. Call
 
 ::: lancedb.pydantic.vector
 
-::: lancedb.pydantic.Vector
-
-::: lancedb.pydantic.MultiVector
-
 ::: lancedb.pydantic.LanceModel
 
-## PyTorch
-
-::: lancedb.streaming.StreamingDataset
-
-::: lancedb.streaming.StreamingDataLoader
-
-::: lancedb.permutation.permutation_builder
-
-::: lancedb.permutation.PermutationBuilder
-
-::: lancedb.permutation.Permutation
-
-::: lancedb.permutation.Transforms
-
 ## Reranking
 
-::: lancedb.rerankers
-    options:
-      show_root_heading: false
-      show_root_toc_entry: false
+::: lancedb.rerankers.linear_combination.LinearCombinationReranker
+
+::: lancedb.rerankers.cohere.CohereReranker
+
+::: lancedb.rerankers.colbert.ColbertReranker
+
+::: lancedb.rerankers.cross_encoder.CrossEncoderReranker
+
+::: lancedb.rerankers.openai.OpenaiReranker
 
 ## Connections (Asynchronous)
 
@@ -293,12 +137,6 @@ can be used to create, list, or open tables.
 
 ::: lancedb.db.AsyncConnection
 
-## Namespaces (Asynchronous)
-
-::: lancedb.connect_namespace_async
-
-::: lancedb.namespace.AsyncLanceNamespaceDBConnection
-
 ## Tables (Asynchronous)
 
 Table hold your actual data as a collection of records / rows.
@@ -307,24 +145,32 @@ Table hold your actual data as a collection of records / rows.
 
 ::: lancedb.table.AsyncTags
 
-::: lancedb.table.AsyncBranches
-
-## Materialized Views (Asynchronous)
-
-::: lancedb.materialized_view.AsyncMaterializedView
-
 ## Indices (Asynchronous)
 
 Indices can be created on a table to speed up queries. This section
 lists the indices that LanceDb supports.
 
-::: lancedb.index
-    options:
-      show_root_heading: false
-      show_root_toc_entry: false
-      # `lang_mapping` is defined in the module rather than imported, so it is
-      # picked up despite not being in `__all__`. It is an internal lookup table.
-      filters: ["!^_", "!^lang_mapping$"]
+::: lancedb.index.BTree
+
+::: lancedb.index.Bitmap
+
+::: lancedb.index.LabelList
+
+::: lancedb.index.FTS
+
+::: lancedb.index.IvfPq
+
+::: lancedb.index.HnswPq
+
+::: lancedb.index.HnswSq
+
+::: lancedb.index.IvfFlat
+
+::: lancedb.index.IvfSq
+
+::: lancedb.index.IvfRq
+
+::: lancedb.index.HnswFlat
 
 ::: lancedb.table.IndexStatistics
 
@@ -352,7 +198,3 @@ rows nearest to a query vector and can be created with the
 ::: lancedb.query.AsyncHybridQuery
     options:
       inherited_members: true
-
-::: lancedb.query.AsyncTakeQuery
-    options:
-      inherited_members: true

docs/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "include": [
+    "src/*.ts",
+  ],
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "nodenext",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "allowJs": true,
+    "resolveJsonModule": true,
+  },
+  "exclude": [
+    "./dist/*",
+  ]
+}