build: point lance dependencies at the sibling submodule checkout

Path deps replace the git+tag pins so the sophon build resolves lance
from src/lance directly, independent of the pinned tag's version.

.agents/skills/README.md

@@ -5,3 +5,7 @@ This directory contains repo-scoped code agent skills for the LanceDB project.
 Each skill is a folder that contains a required `SKILL.md` and optional bundled resources.
 
 Codex discovers skills from `.agents/skills` in the current working directory and parent directories.
+
+The `lancedb` skill lives in the `plugins/lancedb` plugin (see `plugins/lancedb/skills/lancedb`)
+so it can be installed via the plugin marketplaces (`.claude-plugin/marketplace.json` and
+`.agents/plugins/marketplace.json`); the `lancedb` entry here is a symlink into that plugin.

.agents/skills/lancedb

@@ -0,0 +1 @@
+../../plugins/lancedb/skills/lancedb

.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.38.0-beta.4"
+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",

.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

.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/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 `npm 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/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,12 +65,25 @@ 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 }}

.github/workflows/nodejs.yml

@@ -61,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
@@ -108,11 +103,6 @@ jobs:
         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
@@ -192,11 +182,6 @@ jobs:
         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,18 +101,9 @@ jobs:
           - target: aarch64-apple-darwin
             host: macos-latest
             features: fp16kernels
-            pre_build: |-
-              brew install protobuf
-              # Fat LTO (the workspace default in .cargo/config.toml) is
-              # single-threaded and is the peak-memory step of the build. On
-              # this runner it accounted for ~111 of the job's ~113 minutes,
-              # making it the critical path of the entire publish pipeline.
-              # ThinLTO parallelizes it across the runner's cores, for a few
-              # percent of runtime performance.
-              export CARGO_PROFILE_RELEASE_LTO=thin
-              export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=16
+            pre_build: brew install protobuf
           - target: x86_64-pc-windows-msvc
-            host: windows-2025
+            host: windows-2025-8x-x64
             features: ","
             pre_build: |-
               choco install --no-progress protoc ninja nasm
@@ -59,19 +111,19 @@ jobs:
               # There is an issue where choco doesn't add nasm to the path
               export PATH="$PATH:/c/Program Files/NASM"
               nasm -v
-              # See the ThinLTO note on aarch64-apple-darwin above. Keeping
-              # peak memory down is also what lets this run on the standard
-              # 4-core runner: the 8-core larger runner was only needed to
-              # stop fat LTO from OOMing rustc-LLVM.
+              # 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: ","
             pre_build: |-
                 choco install --no-progress protoc
                 rustup target add aarch64-pc-windows-msvc
-                # See the ThinLTO note on aarch64-apple-darwin above.
+                # 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
@@ -146,49 +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. `target/` already lives on the
-      # host because the whole workspace is bind-mounted into the container, and
-      # rust-cache's prune and save run host-side, so they can manage it -- which
-      # is what keeps the entry to dependency artifacts rather than a multi-GB
-      # copy of everything.
-      #
-      # Two differences from the native builds. The container's CARGO_HOME is
-      # bind-mounted from `.cargo-cache` rather than the host's ~/.cargo, so that
-      # has to be cached explicitly. And the key is derived from the *host* rustc
-      # version, which is not the compiler that produced these artifacts; that is
-      # safe because cargo fingerprints the real compiler and rebuilds on a
-      # mismatch, it just means a base-image toolchain bump costs one cold build
-      # instead of invalidating the key.
-      - 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
@@ -206,13 +225,9 @@ 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.
           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 \
+                    -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
@@ -224,16 +239,6 @@ jobs:
               --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 }}
@@ -247,15 +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: Upload artifact
         uses: actions/upload-artifact@v7
         with:
@@ -406,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,12 +20,6 @@ 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 }}
@@ -69,16 +63,6 @@ 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
@@ -88,7 +72,7 @@ jobs:
           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
@@ -117,7 +101,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 +113,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 +122,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:
@@ -212,6 +183,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 +256,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
@@ -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,40 +150,11 @@ 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:
@@ -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

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`
@@ -95,8 +92,6 @@ 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:
 
@@ -108,33 +103,6 @@ TypeScript bindings changes:
 5. Add test in `nodejs/__test__/table.test.ts`.
 6. Run `npm 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.
-
 ## Review Guidelines
 
 Please consider the following when reviewing code contributions.

Cargo.toml

@@ -13,21 +13,20 @@ categories = ["database-implementations"]
 rust-version = "1.91.0"
 
 [workspace.dependencies]
-lance = { "version" = "=11.0.0-beta.19", default-features = false, "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-core = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-datagen = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-file = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-io = { "version" = "=11.0.0-beta.19", default-features = false, "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-index = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-linalg = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-namespace = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-namespace-impls = { "version" = "=11.0.0-beta.19", default-features = false, "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-table = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-testing = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-datafusion = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-encoding = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lance-arrow = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
-lancedb = { path = "rust/lancedb", default-features = false }
+lance = { path = "../lance/rust/lance", default-features = false }
+lance-core = { path = "../lance/rust/lance-core" }
+lance-datagen = { path = "../lance/rust/lance-datagen" }
+lance-file = { path = "../lance/rust/lance-file" }
+lance-io = { path = "../lance/rust/lance-io", default-features = false }
+lance-index = { path = "../lance/rust/lance-index" }
+lance-linalg = { path = "../lance/rust/lance-linalg" }
+lance-namespace = { path = "../lance/rust/lance-namespace" }
+lance-namespace-impls = { path = "../lance/rust/lance-namespace-impls", default-features = false }
+lance-table = { path = "../lance/rust/lance-table" }
+lance-testing = { path = "../lance/rust/lance-testing" }
+lance-datafusion = { path = "../lance/rust/lance-datafusion" }
+lance-encoding = { path = "../lance/rust/lance-encoding" }
+lance-arrow = { path = "../lance/rust/lance-arrow" }
 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"
@@ -67,12 +65,7 @@ url = "2"
 num-traits = "0.2"
 regex = "1.10"
 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"

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/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" },
 ]
 
 # ---------------------------------------------------------------------------
@@ -177,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/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/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.4</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

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/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
@@ -137,3 +112,28 @@ List all branches, mapping name to branch metadata.
 #### Returns
 
 `Promise`&lt;`Record`&lt;`string`, [`BranchContents`](BranchContents.md)&gt;&gt;
+
+***
+
+### merge()
+
+```ts
+merge(fromBranch, dryRun): Promise<MergeBranchResult>
+```
+
+Merge a branch into main.
+
+Set `dryRun` to `true` to preview the merge. A rejected merge resolves
+with `status: "rejected"` instead of throwing.
+
+#### Parameters
+
+* **fromBranch**: `string`
+    Branch to merge from.
+
+* **dryRun**: `boolean` = `false`
+    When true, only preview the merge. Defaults to false.
+
+#### Returns
+
+`Promise`&lt;[`MergeBranchResult`](../interfaces/MergeBranchResult.md)&gt;

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,26 +409,6 @@ Child namespace names and
 
 ***
 
-### 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
@@ -613,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
 

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
@@ -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)

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

@@ -25,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)
@@ -59,10 +57,6 @@
 - [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)
@@ -86,7 +80,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)
@@ -95,15 +88,12 @@
 - [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)
-- [LsmStats](interfaces/LsmStats.md)
 - [LsmWriteSpec](interfaces/LsmWriteSpec.md)
-- [MaterializedViewDefinition](interfaces/MaterializedViewDefinition.md)
-- [MemtableStats](interfaces/MemtableStats.md)
+- [MergeBlocker](interfaces/MergeBlocker.md)
+- [MergeBranchResult](interfaces/MergeBranchResult.md)
+- [MergePreview](interfaces/MergePreview.md)
 - [MergeResult](interfaces/MergeResult.md)
 - [NativeOAuthConfig](interfaces/NativeOAuthConfig.md)
 - [OAuthConfig](interfaces/OAuthConfig.md)
@@ -111,8 +101,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)
@@ -145,7 +133,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/BranchDiff.md

@@ -50,14 +50,6 @@ changedColumns: BranchColumnChange[];
 
 ***
 
-### errors
-
-```ts
-errors: CherryPickError[];
-```
-
-***
-
 ### fromBranch
 
 ```ts
@@ -74,6 +66,22 @@ mainVersion: number;
 
 ***
 
+### mergeBlockers
+
+```ts
+mergeBlockers: MergeBlocker[];
+```
+
+***
+
+### mergeable
+
+```ts
+mergeable: boolean;
+```
+
+***
+
 ### parentVersion
 
 ```ts

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/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/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/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/MergeBlocker.md

@@ -2,11 +2,11 @@
 
 ***
 
-[@lancedb/lancedb](../globals.md) / CherryPickError
+[@lancedb/lancedb](../globals.md) / MergeBlocker
 
-# Interface: CherryPickError
+# Interface: MergeBlocker
 
-A reason why a cherry-pick cannot currently land.
+A reason why a branch cannot currently be merged.
 
 ## Properties
 

docs/src/js/interfaces/MergeBranchResult.md

@@ -2,11 +2,11 @@
 
 ***
 
-[@lancedb/lancedb](../globals.md) / CherryPickResult
+[@lancedb/lancedb](../globals.md) / MergeBranchResult
 
-# Interface: CherryPickResult
+# Interface: MergeBranchResult
 
-Result of previewing or attempting a cherry-pick.
+Result of previewing or attempting a branch merge.
 
 ## Properties
 
@@ -29,7 +29,7 @@ optional mainVersionAfter: number;
 ### preview
 
 ```ts
-preview: CherryPickPreview;
+preview: MergePreview;
 ```
 
 ***
@@ -38,9 +38,9 @@ preview: CherryPickPreview;
 
 ```ts
 status:
-  | "failed"
   | "unknown"
+  | "rejected"
   | "ready"
   | "notImplemented"
-  | "cherryPicked";
+  | "merged";
 ```

docs/src/js/interfaces/MergePreview.md

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

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/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/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,46 +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.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
 
@@ -183,51 +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.blob
-
-::: lancedb.BlobType
-
-::: lancedb._blob.BlobFile
-    options:
-      show_root_full_path: false
+::: lancedb.index.FTS
 
 ## Utilities
 
@@ -235,14 +106,6 @@ instead of being materialized with the rest of the row.
 
 ::: lancedb.merge.LanceMergeInsertBuilder
 
-::: lancedb.otel.instrument_lancedb_metrics
-
-## Exceptions
-
-::: lancedb.exceptions.MissingValueError
-
-::: lancedb.exceptions.MissingColumnError
-
 ## Integrations
 
 ## Pydantic
@@ -251,30 +114,19 @@ instead of being materialized with the rest of the row.
 
 ::: lancedb.pydantic.vector
 
-::: lancedb.pydantic.Vector
-
-::: lancedb.pydantic.MultiVector
-
 ::: lancedb.pydantic.LanceModel
 
-## PyTorch
-
-::: lancedb.streaming.StreamingDataset
-
-::: 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)
 
@@ -285,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.
@@ -299,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
 
@@ -344,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

java/README.md

@@ -29,48 +29,6 @@ LanceNamespace namespaceClient = LanceDbNamespaceClientBuilder.newBuilder()
     .build();
 ```
 
-## MemWAL LSM write path
-
-Most table operations reach LanceDB through the `LanceNamespace` above, which is
-generated from the Lance Namespace specification. The MemWAL LSM routes are not part
-of that specification, so they are issued through a separate client:
-
-```java
-import com.lancedb.LanceDbRestClient;
-import com.lancedb.LanceDbTableLsm;
-import com.lancedb.LsmWriteSpec;
-
-LanceDbRestClient client = LanceDbNamespaceClientBuilder.newBuilder()
-    .apiKey("your_lancedb_cloud_api_key")
-    .database("your_database_name")
-    .buildRestClient();
-
-LanceDbTableLsm lsm = new LanceDbTableLsm(client, "my_table");
-
-// Route future merge_insert upserts through the MemWAL, hash-bucketed by `id`.
-lsm.setLsmWriteSpec(LsmWriteSpec.bucket("id", 16));
-
-// ... merge_insert traffic ...
-
-// Converge the fresh tier into the base table.
-lsm.checkpointLsm();
-
-// Inspect live per-bucket state.
-lsm.getLsmStats().ifPresent(stats -> stats.buckets().forEach(bucket ->
-    System.out.println(bucket.shardId() + ": " + bucket.generations().size() + " L0 generations")));
-
-client.close();
-```
-
-`maintainedIndexes` is tri-state, and the null default is the opposite of what a Java
-reader usually expects:
-
-| Value | Meaning |
-| --- | --- |
-| unset (null) | Maintain **every** index the MemWAL can, resolved on install |
-| `Collections.emptyList()` | Maintain **none** |
-| `Arrays.asList("id_idx")` | Maintain exactly those |
-
 ## Development
 
 Build:

java/lancedb-core/pom.xml

@@ -8,7 +8,7 @@
     <parent>
       <groupId>com.lancedb</groupId>
       <artifactId>lancedb-parent</artifactId>
-      <version>0.38.0-beta.4</version>
+      <version>0.32.0-beta.2</version>
       <relativePath>../pom.xml</relativePath>
     </parent>
 
@@ -33,20 +33,6 @@
             <artifactId>arrow-memory-netty</artifactId>
         </dependency>
 
-        <!-- Transport for the LanceDB routes outside the Lance Namespace spec.
-             Versions match what lance-namespace-apache-client resolves to. -->
-        <dependency>
-            <groupId>org.apache.httpcomponents.client5</groupId>
-            <artifactId>httpclient5</artifactId>
-            <version>5.2.1</version>
-        </dependency>
-
-        <dependency>
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-databind</artifactId>
-            <version>2.17.1</version>
-        </dependency>
-
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>

java/lancedb-core/src/main/java/com/lancedb/BucketStats.java

@@ -1,194 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.lancedb;
-
-import com.fasterxml.jackson.databind.JsonNode;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
-import java.util.OptionalLong;
-
-/**
- * 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.
- */
-public class BucketStats {
-  private static final String CONTEXT = "bucket stats";
-
-  private final String shardId;
-  private final String status;
-  private final long writerEpoch;
-  private final long manifestVersion;
-  private final long currentGeneration;
-  private final long replayAfterWalEntryPosition;
-  private final long walEntryPositionLastSeen;
-  private final List<GenerationStats> generations;
-  private final boolean compacting;
-  private final List<MemtableStats> memtables;
-
-  BucketStats(
-      String shardId,
-      String status,
-      long writerEpoch,
-      long manifestVersion,
-      long currentGeneration,
-      long replayAfterWalEntryPosition,
-      long walEntryPositionLastSeen,
-      List<GenerationStats> generations,
-      boolean compacting,
-      List<MemtableStats> memtables) {
-    this.shardId = shardId;
-    this.status = status;
-    this.writerEpoch = writerEpoch;
-    this.manifestVersion = manifestVersion;
-    this.currentGeneration = currentGeneration;
-    this.replayAfterWalEntryPosition = replayAfterWalEntryPosition;
-    this.walEntryPositionLastSeen = walEntryPositionLastSeen;
-    this.generations = Collections.unmodifiableList(generations);
-    this.compacting = compacting;
-    this.memtables = memtables == null ? null : Collections.unmodifiableList(memtables);
-  }
-
-  /** The shard this bucket writes. */
-  public String shardId() {
-    return shardId;
-  }
-
-  /** {@code "Active"} or {@code "Sealed"} (drop-table 2PC in flight). */
-  public String status() {
-    return status;
-  }
-
-  /** Epoch of the writer that currently owns the shard. */
-  public long writerEpoch() {
-    return writerEpoch;
-  }
-
-  /** Version of the shard manifest these numbers were read from. */
-  public long manifestVersion() {
-    return manifestVersion;
-  }
-
-  /** The generation the active memtable will become. */
-  public long currentGeneration() {
-    return currentGeneration;
-  }
-
-  /** WAL position replay resumes from. */
-  public long replayAfterWalEntryPosition() {
-    return replayAfterWalEntryPosition;
-  }
-
-  /**
-   * Highest WAL position the writer has seen. The difference against {@link
-   * #replayAfterWalEntryPosition()} is the WAL lag.
-   */
-  public long walEntryPositionLastSeen() {
-    return walEntryPositionLastSeen;
-  }
-
-  /** Flushed L0 generations not yet merged into the base table. */
-  public List<GenerationStats> generations() {
-    return generations;
-  }
-
-  /**
-   * Whether a pass owns this bucket's compaction latch right now. Says <em>a</em> driver is
-   * running, not <em>whose</em>, 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".
-   */
-  public boolean compacting() {
-    return compacting;
-  }
-
-  /** Oldest first, active last. Empty for a {@code "Sealed"} bucket, whose state is torn down. */
-  public Optional<List<MemtableStats>> memtables() {
-    return Optional.ofNullable(memtables);
-  }
-
-  /** The newest flushed generation, or empty when L0 is empty. */
-  OptionalLong newestGeneration() {
-    OptionalLong newest = OptionalLong.empty();
-    for (GenerationStats generation : generations) {
-      if (!newest.isPresent() || generation.generation() > newest.getAsLong()) {
-        newest = OptionalLong.of(generation.generation());
-      }
-    }
-    return newest;
-  }
-
-  /**
-   * How many generations at or below {@code target} are still in L0.
-   *
-   * <p>A count, not a boolean: one pass drains a bounded prefix rather than the whole target set,
-   * so a boolean would read as "no progress" for every pass but the last. Compaction drains
-   * oldest-first, so this decreases monotonically.
-   */
-  long outstandingGenerations(long target) {
-    long count = 0;
-    for (GenerationStats generation : generations) {
-      if (generation.generation() <= target) {
-        count++;
-      }
-    }
-    return count;
-  }
-
-  static BucketStats fromJson(JsonNode node) {
-    JsonFields.requiredObject(node, CONTEXT);
-    List<GenerationStats> generations = new ArrayList<GenerationStats>();
-    for (JsonNode generation : JsonFields.requiredArray(node, "generations", CONTEXT)) {
-      generations.add(GenerationStats.fromJson(generation));
-    }
-
-    JsonNode memtablesNode = JsonFields.optionalArray(node, "memtables", CONTEXT);
-    List<MemtableStats> memtables = null;
-    if (memtablesNode != null) {
-      memtables = new ArrayList<MemtableStats>();
-      for (JsonNode memtable : memtablesNode) {
-        memtables.add(MemtableStats.fromJson(memtable));
-      }
-    }
-
-    return new BucketStats(
-        JsonFields.requiredText(node, "shard_id", CONTEXT),
-        JsonFields.requiredText(node, "status", CONTEXT),
-        JsonFields.requiredLong(node, "writer_epoch", CONTEXT),
-        JsonFields.requiredLong(node, "manifest_version", CONTEXT),
-        JsonFields.requiredLong(node, "current_generation", CONTEXT),
-        JsonFields.requiredLong(node, "replay_after_wal_entry_position", CONTEXT),
-        JsonFields.requiredLong(node, "wal_entry_position_last_seen", CONTEXT),
-        generations,
-        JsonFields.requiredBoolean(node, "compacting", CONTEXT),
-        memtables);
-  }
-
-  @Override
-  public String toString() {
-    return "BucketStats{shardId="
-        + shardId
-        + ", status="
-        + status
-        + ", currentGeneration="
-        + currentGeneration
-        + ", generations="
-        + generations
-        + ", compacting="
-        + compacting
-        + "}";
-  }
-}

java/lancedb-core/src/main/java/com/lancedb/GenerationStats.java

@@ -1,64 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.lancedb;
-
-import com.fasterxml.jackson.databind.JsonNode;
-
-import java.util.OptionalLong;
-
-/** One flushed L0 generation. */
-public class GenerationStats {
-  private static final String CONTEXT = "generation stats";
-
-  private final long generation;
-  private final long bytes;
-  private final Long rows;
-
-  GenerationStats(long generation, long bytes, Long rows) {
-    this.generation = generation;
-    this.bytes = bytes;
-    this.rows = rows;
-  }
-
-  /** The generation number. Increases as memtables are sealed into L0. */
-  public long generation() {
-    return generation;
-  }
-
-  /** On-disk size of the generation. */
-  public long bytes() {
-    return bytes;
-  }
-
-  /**
-   * Rows in this generation, present only when {@code includeGenerationRows} was requested. Off by
-   * default because each count opens an uncached Lance dataset.
-   */
-  public OptionalLong rows() {
-    return rows == null ? OptionalLong.empty() : OptionalLong.of(rows);
-  }
-
-  static GenerationStats fromJson(JsonNode node) {
-    JsonFields.requiredObject(node, CONTEXT);
-    return new GenerationStats(
-        JsonFields.requiredLong(node, "generation", CONTEXT),
-        JsonFields.requiredLong(node, "bytes", CONTEXT),
-        JsonFields.optionalLong(node, "rows", CONTEXT));
-  }
-
-  @Override
-  public String toString() {
-    return "GenerationStats{generation=" + generation + ", bytes=" + bytes + ", rows=" + rows + "}";
-  }
-}

java/lancedb-core/src/main/java/com/lancedb/JsonFields.java

@@ -1,109 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.lancedb;
-
-import com.fasterxml.jackson.databind.JsonNode;
-
-/**
- * Strict readers for decoding LanceDB JSON responses.
- *
- * <p>Every reader fails closed: a missing, null, or wrong-typed field throws rather than
- * defaulting. That mirrors the serde decoding the Rust client applies to the same payloads in
- * {@code rust/lancedb/src/table/lsm_stats.rs}, where a required field has no default and a
- * malformed response is an error rather than a zero.
- *
- * <p>The alternative — Jackson's {@code path()}, which yields a missing node that reads as an empty
- * array or a zero — is unsafe here because {@link LanceDbTableLsm#checkpointLsm()} decides
- * convergence from these numbers. A defaulted {@code generations} array is indistinguishable from a
- * drained one, so a malformed response would report a checkpoint that never happened.
- */
-final class JsonFields {
-  private JsonFields() {}
-
-  /** The node itself, once confirmed to be a JSON object. */
-  static JsonNode requiredObject(JsonNode node, String context) {
-    if (node == null || !node.isObject()) {
-      throw new IllegalStateException(context + " is not a JSON object: " + node);
-    }
-    return node;
-  }
-
-  static String requiredText(JsonNode owner, String field, String context) {
-    JsonNode value = required(owner, field, context);
-    if (!value.isTextual()) {
-      throw new IllegalStateException(fieldIs(context, field, "a string", value));
-    }
-    return value.asText();
-  }
-
-  static long requiredLong(JsonNode owner, String field, String context) {
-    JsonNode value = required(owner, field, context);
-    if (!value.isIntegralNumber()) {
-      throw new IllegalStateException(fieldIs(context, field, "an integer", value));
-    }
-    return value.asLong();
-  }
-
-  static boolean requiredBoolean(JsonNode owner, String field, String context) {
-    JsonNode value = required(owner, field, context);
-    if (!value.isBoolean()) {
-      throw new IllegalStateException(fieldIs(context, field, "a boolean", value));
-    }
-    return value.asBoolean();
-  }
-
-  static JsonNode requiredArray(JsonNode owner, String field, String context) {
-    JsonNode value = required(owner, field, context);
-    if (!value.isArray()) {
-      throw new IllegalStateException(fieldIs(context, field, "an array", value));
-    }
-    return value;
-  }
-
-  /** Null when the field is absent or JSON null, mirroring a serde {@code Option}. */
-  static Long optionalLong(JsonNode owner, String field, String context) {
-    JsonNode value = owner.get(field);
-    if (value == null || value.isNull()) {
-      return null;
-    }
-    if (!value.isIntegralNumber()) {
-      throw new IllegalStateException(fieldIs(context, field, "an integer", value));
-    }
-    return value.asLong();
-  }
-
-  /** Null when the field is absent or JSON null, mirroring a serde {@code Option}. */
-  static JsonNode optionalArray(JsonNode owner, String field, String context) {
-    JsonNode value = owner.get(field);
-    if (value == null || value.isNull()) {
-      return null;
-    }
-    if (!value.isArray()) {
-      throw new IllegalStateException(fieldIs(context, field, "an array", value));
-    }
-    return value;
-  }
-
-  private static JsonNode required(JsonNode owner, String field, String context) {
-    JsonNode value = owner.get(field);
-    if (value == null || value.isNull()) {
-      throw new IllegalStateException(context + " is missing required field '" + field + "'");
-    }
-    return value;
-  }
-
-  private static String fieldIs(String context, String field, String expected, JsonNode value) {
-    return context + " field '" + field + "' is not " + expected + ": " + value;
-  }
-}

java/lancedb-core/src/main/java/com/lancedb/LanceDbNamespaceClientBuilder.java

@@ -136,48 +136,29 @@ public class LanceDbNamespaceClientBuilder {
    * @throws IllegalStateException if required parameters are missing
    */
   public LanceNamespace build() {
-    validate();
-
-    // Build configuration map
-    Map<String, String> config = new HashMap<>(additionalConfig);
-    config.put("header.x-lancedb-database", database);
-    config.put("header.x-api-key", apiKey);
-    config.put("uri", resolveUri());
-
-    return LanceNamespace.connect("rest", config, null);
-  }
-
-  /**
-   * Build a {@link LanceDbRestClient} for the same endpoint.
-   *
-   * <p>Needed only for LanceDB routes that the Lance Namespace specification does not cover — the
-   * MemWAL LSM write path, reached through {@link LanceDbTableLsm}. Every other table operation
-   * belongs on the {@link LanceNamespace} from {@link #build()}.
-   *
-   * <p>The returned client owns an HTTP connection pool; close it when you are done with it.
-   *
-   * @return A configured LanceDbRestClient
-   * @throws IllegalStateException if required parameters are missing
-   */
-  public LanceDbRestClient buildRestClient() {
-    validate();
-    return new LanceDbRestClient(resolveUri(), apiKey, database);
-  }
-
-  private void validate() {
+    // Validate required fields
     if (apiKey == null) {
       throw new IllegalStateException("API key is required");
     }
     if (database == null) {
       throw new IllegalStateException("Database is required");
     }
-  }
 
-  /** The custom endpoint when set, else the LanceDB Cloud URL for this database and region. */
-  private String resolveUri() {
+    // Build configuration map
+    Map<String, String> config = new HashMap<>(additionalConfig);
+    config.put("header.x-lancedb-database", database);
+    config.put("header.x-api-key", apiKey);
+
+    // Determine base URL
+    String uri;
     if (endpoint.isPresent()) {
-      return endpoint.get();
+      uri = endpoint.get();
+    } else {
+      String effectiveRegion = region.orElse(DEFAULT_REGION);
+      uri = String.format(CLOUD_URL_PATTERN, database, effectiveRegion);
     }
-    return String.format(CLOUD_URL_PATTERN, database, region.orElse(DEFAULT_REGION));
+    config.put("uri", uri);
+
+    return LanceNamespace.connect("rest", config, null);
   }
 }

java/lancedb-core/src/main/java/com/lancedb/LanceDbRestClient.java

@@ -1,119 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.lancedb;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.apache.hc.client5.http.classic.methods.HttpPost;
-import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
-import org.apache.hc.client5.http.impl.classic.HttpClients;
-import org.apache.hc.core5.http.ContentType;
-import org.apache.hc.core5.http.io.entity.EntityUtils;
-import org.apache.hc.core5.http.io.entity.StringEntity;
-
-import java.io.Closeable;
-import java.io.IOException;
-import java.io.UncheckedIOException;
-
-/**
- * Minimal HTTP client for LanceDB Cloud and Enterprise routes that the Lance Namespace
- * specification does not cover.
- *
- * <p>Most table operations reach LanceDB through {@link org.lance.namespace.LanceNamespace}, which
- * is generated from the namespace spec. A handful of routes — the MemWAL LSM write path in
- * particular — are served by the same endpoint but are not part of that spec, so they are issued
- * directly here. See {@link LanceDbTableLsm}.
- *
- * <p>Obtain one from {@link LanceDbNamespaceClientBuilder#buildRestClient()}.
- */
-public class LanceDbRestClient implements Closeable {
-  private static final ObjectMapper MAPPER = new ObjectMapper();
-
-  private final String baseUri;
-  private final String apiKey;
-  private final String database;
-  private final CloseableHttpClient http;
-
-  LanceDbRestClient(String baseUri, String apiKey, String database) {
-    this.baseUri = baseUri.endsWith("/") ? baseUri.substring(0, baseUri.length() - 1) : baseUri;
-    this.apiKey = apiKey;
-    this.database = database;
-    // Automatic retries off, deliberately. The default strategy retries 429 and 503 —
-    // exactly the two statuses LanceDbTableLsm.checkpointLsm() acts on — which would
-    // silently double its explicit retry budget and would also retry compact_lsm in
-    // place, where the loop is designed to fall through to a fresh stats poll instead.
-    // The checkpoint loop owns the 421/429/503 transitions; the transport must not.
-    this.http = HttpClients.custom().disableAutomaticRetries().build();
-  }
-
-  /**
-   * POST {@code path}, sending {@code body} as JSON when it is non-null.
-   *
-   * @param path Absolute request path, beginning with {@code /}.
-   * @param body Object to serialize as the request body, or null to send no body.
-   * @return The parsed response body, or null when the response carried no content.
-   * @throws HttpException if the server returned a non-2xx status.
-   */
-  public JsonNode post(String path, Object body) {
-    HttpPost request = new HttpPost(baseUri + path);
-    request.setHeader("x-api-key", apiKey);
-    request.setHeader("x-lancedb-database", database);
-    try {
-      if (body != null) {
-        request.setEntity(
-            new StringEntity(MAPPER.writeValueAsString(body), ContentType.APPLICATION_JSON));
-      }
-      return http.execute(
-          request,
-          response -> {
-            String text =
-                response.getEntity() == null ? "" : EntityUtils.toString(response.getEntity());
-            int status = response.getCode();
-            if (status < 200 || status >= 300) {
-              throw new HttpException(status, "LanceDB request to " + path + " failed: " + text);
-            }
-            return text.isEmpty() ? null : MAPPER.readTree(text);
-          });
-    } catch (IOException e) {
-      throw new UncheckedIOException("LanceDB request to " + path + " failed", e);
-    }
-  }
-
-  @Override
-  public void close() throws IOException {
-    http.close();
-  }
-
-  /**
-   * A non-2xx response.
-   *
-   * <p>The status is exposed because callers act on it: {@link LanceDbTableLsm#checkpointLsm()}
-   * treats 429 and 503 as retryable and 421 as a lost node claim.
-   */
-  public static class HttpException extends RuntimeException {
-    private static final long serialVersionUID = 1L;
-
-    private final int statusCode;
-
-    public HttpException(int statusCode, String message) {
-      super(message);
-      this.statusCode = statusCode;
-    }
-
-    /** The HTTP status the failed response carried. */
-    public int statusCode() {
-      return statusCode;
-    }
-  }
-}

java/lancedb-core/src/main/java/com/lancedb/LanceDbTableLsm.java

@@ -1,394 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.lancedb;
-
-import com.fasterxml.jackson.databind.JsonNode;
-
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Optional;
-import java.util.OptionalLong;
-
-/**
- * The MemWAL LSM write path for one LanceDB Cloud or Enterprise table.
- *
- * <p>Installing an {@link LsmWriteSpec} routes {@code mergeInsert} upserts through Lance's MemWAL —
- * an LSM-style append — instead of the standard merge path. Rows land in an in-memory memtable,
- * seal into L0 generations, and are merged into the base table by compaction.
- *
- * <p>These routes are not part of the Lance Namespace specification, so they are issued directly
- * rather than through {@link org.lance.namespace.LanceNamespace}.
- *
- * <pre>{@code
- * LanceDbRestClient client = LanceDbNamespaceClientBuilder.newBuilder()
- *     .apiKey("your_lancedb_cloud_api_key")
- *     .database("your_database_name")
- *     .buildRestClient();
- *
- * LanceDbTableLsm lsm = new LanceDbTableLsm(client, "my_table");
- * lsm.setLsmWriteSpec(LsmWriteSpec.bucket("id", 16));
- * // ... merge_insert traffic ...
- * lsm.checkpointLsm();
- * }</pre>
- */
-public class LanceDbTableLsm {
-
-  /**
-   * Interval between {@code get_lsm_stats} polls during a checkpoint. One interval is roughly one
-   * compaction pass, the granularity at which the answer can change.
-   */
-  private static final long POLL_INTERVAL_MS = 5_000L;
-
-  /**
-   * Cap on re-issues from {@code flushLsm} after a 421, so a crash-looping node cannot turn flush →
-   * compact → 421 → flush into a spin.
-   *
-   * <p>Deliberately not shared with {@link #MAX_RETRIES}: a claim that keeps evaporating is a
-   * broken node, while contention is routine and wants a real budget.
-   */
-  private static final int MAX_REISSUES = 3;
-
-  /**
-   * Retryable faults tolerated on a <em>single</em> request, reset on every success — scattered
-   * contention across a long checkpoint must not accumulate toward a cap.
-   */
-  private static final int MAX_RETRIES = 8;
-
-  private static final long RETRY_BACKOFF_BASE_MS = 100L;
-  private static final long RETRY_BACKOFF_MAX_MS = 5_000L;
-
-  private final LanceDbRestClient client;
-  private final String tableIdentifier;
-
-  /**
-   * Bind the LSM routes for one table.
-   *
-   * @param client Transport for the LanceDB endpoint.
-   * @param tableIdentifier The table's full identifier, {@code $}-delimited when it sits inside a
-   *     namespace, such as {@code analytics$events}.
-   */
-  public LanceDbTableLsm(LanceDbRestClient client, String tableIdentifier) {
-    if (client == null) {
-      throw new IllegalArgumentException("Client cannot be null");
-    }
-    if (tableIdentifier == null || tableIdentifier.trim().isEmpty()) {
-      throw new IllegalArgumentException("Table identifier cannot be null or empty");
-    }
-    this.client = client;
-    this.tableIdentifier = tableIdentifier;
-  }
-
-  /**
-   * Install an {@link LsmWriteSpec} on this table, selecting the MemWAL LSM write path for future
-   * {@code mergeInsert} calls.
-   *
-   * <p>All variants require the table to have an unenforced primary key; bucket sharding
-   * additionally requires it to be the single column being bucketed.
-   */
-  public void setLsmWriteSpec(LsmWriteSpec spec) {
-    if (spec == null) {
-      throw new IllegalArgumentException("Spec cannot be null");
-    }
-    client.post(route("set_lsm_write_spec"), spec.toRequestBody());
-  }
-
-  /**
-   * Remove the {@link LsmWriteSpec} from this table, reverting to the standard {@code mergeInsert}
-   * write path.
-   *
-   * <p>Errors if no spec is currently set.
-   */
-  public void unsetLsmWriteSpec() {
-    client.post(route("unset_lsm_write_spec"), null);
-  }
-
-  /**
-   * Read the {@link LsmWriteSpec} currently installed on this table.
-   *
-   * <p>Empty when the LSM write path is not enabled. The returned spec mirrors what was installed,
-   * except that {@link LsmWriteSpec#maintainedIndexes()} always reports the concrete list resolved
-   * when the spec was set — a null selection never round-trips.
-   */
-  public Optional<LsmWriteSpec> getLsmWriteSpec() {
-    JsonNode response = client.post(route("get_lsm_write_spec"), null);
-    if (response == null || !response.hasNonNull("lsm_write_spec")) {
-      return Optional.empty();
-    }
-    return Optional.of(LsmWriteSpec.fromJson(response.get("lsm_write_spec")));
-  }
-
-  /**
-   * Seal every bucket's active memtable into a new L0 generation.
-   *
-   * <p>Returns once the seal is committed. Sealing an empty memtable is a no-op, so this is safe to
-   * call repeatedly.
-   */
-  public void flushLsm() {
-    client.post(route("flush_lsm"), null);
-  }
-
-  /**
-   * Trigger a background L0 → base compaction pass per bucket.
-   *
-   * <p>Returns once the passes are <em>dispatched</em>, not once they finish — watch {@link
-   * #getLsmStats}, or use {@link #checkpointLsm} to wait for convergence.
-   */
-  public void compactLsm() {
-    client.post(route("compact_lsm"), null);
-  }
-
-  /**
-   * Read live per-bucket LSM state.
-   *
-   * <p>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.
-   *
-   * <p>Empty only when the LSM write path is not enabled — that is, when the server sends an absent
-   * or null {@code lsm_stats}. A stats object that is present is decoded strictly, and a malformed
-   * one throws rather than decoding to something empty, because {@link #checkpointLsm} reads
-   * convergence out of these numbers and cannot tell a defaulted array from a drained one.
-   *
-   * @param includeGenerationRows Also count rows per L0 generation. Off by default because each
-   *     count opens an uncached Lance dataset.
-   * @throws IllegalStateException if the response is absent or does not decode.
-   */
-  public Optional<LsmStats> getLsmStats(boolean includeGenerationRows) {
-    Map<String, Object> body = new LinkedHashMap<String, Object>();
-    body.put("include_generation_rows", includeGenerationRows);
-    JsonNode response = client.post(route("get_lsm_stats"), body);
-    if (response == null) {
-      throw new IllegalStateException("get_lsm_stats returned an empty response body");
-    }
-    JsonNode stats = response.get("lsm_stats");
-    if (stats == null || stats.isNull()) {
-      return Optional.empty();
-    }
-    return Optional.of(LsmStats.fromJson(stats));
-  }
-
-  /** Equivalent to {@code getLsmStats(false)}. */
-  public Optional<LsmStats> getLsmStats() {
-    return getLsmStats(false);
-  }
-
-  /**
-   * Converge this table's LSM write path into its base table.
-   *
-   * <p>Seals once, fixes a target watermark from the resulting L0, then triggers compaction and
-   * polls until that L0 is gone. The target set is fixed at the start, so generations created
-   * <em>during</em> 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, safe on a cadence.
-   *
-   * <p>The loop runs here, not on the server: {@link #compactLsm} dispatches a pass and returns, so
-   * nothing holds a socket and a client can vanish mid-operation with nothing to reconcile.
-   * Completion is read from generation numbers in the shard manifest — durable state, unlike a
-   * count in a compact response, which a concurrent write invalidates.
-   *
-   * <p>No liveness bound — the caller owns the deadline. The compactor pool is shared across
-   * tables, so a checkpoint queued behind unrelated work looks exactly like one that is merging.
-   */
-  public void checkpointLsm() {
-    for (int reissue = 0; reissue <= MAX_REISSUES; reissue++) {
-      // The seal turns everything written before this call into a generation, so the
-      // watermark has to be read after it. Idempotent: sealing an empty memtable is a
-      // no-op, so a re-issue does not churn empty generations.
-      if (issueVoid(this::flushLsm)) {
-        backoff(reissue);
-        continue;
-      }
-
-      Attempt<Optional<LsmStats>> stats = issue(() -> getLsmStats(false));
-      if (stats.lostClaim) {
-        backoff(reissue);
-        continue;
-      }
-      if (!stats.value.isPresent()) {
-        // Not WAL-backed; flushLsm would have errored first but for a race.
-        return;
-      }
-
-      Map<String, Long> targets = newestGenerations(stats.value.get());
-      if (targets.isEmpty()) {
-        return;
-      }
-
-      if (drainToTargets(targets)) {
-        return;
-      }
-      backoff(reissue);
-    }
-    throw new IllegalStateException(
-        "checkpointLsm: the owning node kept losing its claim; re-issued from flush the maximum "
-            + "number of times");
-  }
-
-  /**
-   * Trigger and poll until no bucket holds a generation at or below its target.
-   *
-   * @return true when the drain finished, false when the table needs re-claiming from flush.
-   */
-  private boolean drainToTargets(Map<String, Long> targets) {
-    while (true) {
-      Attempt<Optional<LsmStats>> stats = issue(() -> getLsmStats(false));
-      if (stats.lostClaim) {
-        return false;
-      }
-      if (!stats.value.isPresent()) {
-        return true;
-      }
-
-      // `compacting` is the bucket's compaction latch, held from dispatch until the pass
-      // ends — including while it waits on a pod-wide permit. So it answers one question
-      // only: do not pile on. Buckets with nothing outstanding are skipped, not counted
-      // as idle.
-      long outstanding = 0;
-      boolean allCompacting = true;
-      for (BucketStats bucket : stats.value.get().buckets()) {
-        Long target = targets.get(bucket.shardId());
-        if (target == null) {
-          continue;
-        }
-        long remaining = bucket.outstandingGenerations(target);
-        if (remaining > 0) {
-          outstanding += remaining;
-          allCompacting &= bucket.compacting();
-        }
-      }
-      if (outstanding == 0) {
-        return true;
-      }
-
-      if (!allCompacting) {
-        try {
-          compactLsm();
-        } catch (LanceDbRestClient.HttpException e) {
-          if (isLostClaim(e)) {
-            return false;
-          }
-          if (!isRetryable(e)) {
-            throw e;
-          }
-          // A 429 here means the server could latch no bucket at all, which the poll
-          // above already handles. Not retried in place: the latch it would contend for
-          // is the one doing the work, so fall through and re-read — POLL_INTERVAL_MS is
-          // the backoff.
-        }
-      }
-      sleep(POLL_INTERVAL_MS);
-    }
-  }
-
-  /** The newest generation held by each bucket, skipping buckets holding none. */
-  private static Map<String, Long> newestGenerations(LsmStats stats) {
-    Map<String, Long> targets = new HashMap<String, Long>();
-    for (BucketStats bucket : stats.buckets()) {
-      OptionalLong newest = bucket.newestGeneration();
-      if (newest.isPresent()) {
-        targets.put(bucket.shardId(), newest.getAsLong());
-      }
-    }
-    return targets;
-  }
-
-  /**
-   * 429 (latch held, pool saturated, or the pod replaying its WAL) and 503 (a draining node, or a
-   * proxy between here and it).
-   */
-  private static boolean isRetryable(LanceDbRestClient.HttpException e) {
-    return e.statusCode() == 429 || e.statusCode() == 503;
-  }
-
-  /**
-   * 421: the owning node holds no claim. Only {@code flush} re-claims and replays, so this cannot
-   * be retried in place — the caller has to start over.
-   */
-  private static boolean isLostClaim(LanceDbRestClient.HttpException e) {
-    return e.statusCode() == 421;
-  }
-
-  /**
-   * Issue one LSM request, retrying in place while the fault is retryable.
-   *
-   * <p>The two recoverable faults have separate budgets: contention clears on its own and retries
-   * here against {@link #MAX_RETRIES}, while a 421 needs {@code flush} to re-claim, which only the
-   * caller can drive.
-   *
-   * <p>An exhausted budget propagates the last error as itself rather than a synthesized one — "429
-   * after nine tries" beats "checkpoint failed".
-   */
-  private static <T> Attempt<T> issue(Call<T> call) {
-    int retries = 0;
-    while (true) {
-      try {
-        return new Attempt<T>(call.run(), false);
-      } catch (LanceDbRestClient.HttpException e) {
-        if (isLostClaim(e)) {
-          return new Attempt<T>(null, true);
-        }
-        if (!isRetryable(e) || retries >= MAX_RETRIES) {
-          throw e;
-        }
-        backoff(retries);
-        retries++;
-      }
-    }
-  }
-
-  /** {@link #issue} for a call with no return value. Returns true when the claim was lost. */
-  private static boolean issueVoid(Runnable call) {
-    return issue(
-            () -> {
-              call.run();
-              return Boolean.TRUE;
-            })
-        .lostClaim;
-  }
-
-  /** Sleep before re-issuing a retryable request. Doubles up to {@link #RETRY_BACKOFF_MAX_MS}. */
-  private static void backoff(int attempt) {
-    long delay = RETRY_BACKOFF_BASE_MS << Math.min(attempt, 8);
-    sleep(Math.min(delay, RETRY_BACKOFF_MAX_MS));
-  }
-
-  private static void sleep(long millis) {
-    try {
-      Thread.sleep(millis);
-    } catch (InterruptedException e) {
-      Thread.currentThread().interrupt();
-      throw new IllegalStateException("Interrupted while waiting on the LSM checkpoint", e);
-    }
-  }
-
-  private String route(String operation) {
-    return "/v1/table/" + tableIdentifier + "/" + operation + "/";
-  }
-
-  /** What one LSM request produced: its value, or word that the owning node holds no claim. */
-  private static final class Attempt<T> {
-    private final T value;
-    private final boolean lostClaim;
-
-    private Attempt(T value, boolean lostClaim) {
-      this.value = value;
-      this.lostClaim = lostClaim;
-    }
-  }
-
-  @FunctionalInterface
-  private interface Call<T> {
-    T run();
-  }
-}

java/lancedb-core/src/main/java/com/lancedb/LsmStats.java

@@ -1,56 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.lancedb;
-
-import com.fasterxml.jackson.databind.JsonNode;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * Live per-bucket LSM state, as returned by {@link LanceDbTableLsm#getLsmStats()}.
- *
- * <p>Nothing here is derived: sums and differences (total L0 bytes, WAL lag) are the caller's to
- * compute. There is no "LSM is off" shape — that case is an empty {@link java.util.Optional},
- * because a stats object of zeros would read as measurements.
- */
-public class LsmStats {
-  private static final String CONTEXT = "lsm stats";
-
-  private final List<BucketStats> buckets;
-
-  LsmStats(List<BucketStats> buckets) {
-    this.buckets = Collections.unmodifiableList(buckets);
-  }
-
-  /** One entry per bucket. */
-  public List<BucketStats> buckets() {
-    return buckets;
-  }
-
-  static LsmStats fromJson(JsonNode node) {
-    JsonFields.requiredObject(node, CONTEXT);
-    List<BucketStats> buckets = new ArrayList<BucketStats>();
-    for (JsonNode bucket : JsonFields.requiredArray(node, "buckets", CONTEXT)) {
-      buckets.add(BucketStats.fromJson(bucket));
-    }
-    return new LsmStats(buckets);
-  }
-
-  @Override
-  public String toString() {
-    return "LsmStats{buckets=" + buckets + "}";
-  }
-}

java/lancedb-core/src/main/java/com/lancedb/LsmWriteSpec.java

@@ -1,260 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.lancedb;
-
-import com.fasterxml.jackson.databind.JsonNode;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Specification selecting Lance's MemWAL LSM-style write path for {@code mergeInsert}.
- *
- * <p>Construct via {@link #bucket}, {@link #identity}, or {@link #unsharded}, then optionally chain
- * {@link #withMaintainedIndexes} and {@link #withWriterConfigDefaults}. Install it with {@link
- * LanceDbTableLsm#setLsmWriteSpec} and remove it with {@link LanceDbTableLsm#unsetLsmWriteSpec}.
- *
- * <p>This is deliberately not {@code org.lance.memwal.InitializeMemWalParams}. That type is Lance's
- * own, and its maintained-index default is the opposite of this one: it defaults to maintaining
- * <em>nothing</em>, while a fresh spec here maintains <em>every</em> index. It also cannot express
- * the null that asks the server to resolve the set.
- */
-public class LsmWriteSpec {
-
-  /** How writes are routed to MemWAL shards. */
-  public enum Sharding {
-    /** Hash-bucket writes by a scalar column. */
-    BUCKET("bucket"),
-    /** Shard by the raw value of a scalar column. */
-    IDENTITY("identity"),
-    /** Route every write to a single shard. */
-    UNSHARDED("unsharded");
-
-    private final String wireName;
-
-    Sharding(String wireName) {
-      this.wireName = wireName;
-    }
-
-    String wireName() {
-      return wireName;
-    }
-
-    static Sharding fromWireName(String name) {
-      for (Sharding s : values()) {
-        if (s.wireName.equals(name)) {
-          return s;
-        }
-      }
-      throw new IllegalArgumentException("Unknown sharding mode: " + name);
-    }
-  }
-
-  private final Sharding sharding;
-  private final String column;
-  private final Integer numBuckets;
-  private final List<String> maintainedIndexes;
-  private final Map<String, String> writerConfigDefaults;
-
-  private LsmWriteSpec(
-      Sharding sharding,
-      String column,
-      Integer numBuckets,
-      List<String> maintainedIndexes,
-      Map<String, String> writerConfigDefaults) {
-    this.sharding = sharding;
-    this.column = column;
-    this.numBuckets = numBuckets;
-    this.maintainedIndexes = maintainedIndexes;
-    this.writerConfigDefaults = writerConfigDefaults;
-  }
-
-  /**
-   * Hash-bucket sharding by a scalar column, maintaining every index on the table.
-   *
-   * <p>Iceberg-compatible Murmur3-x86-32 (seed 0) is used, so each row's {@code bucket(column,
-   * numBuckets)} value is stable across processes.
-   *
-   * @param column A non-nested column with a supported scalar type.
-   * @param numBuckets The number of buckets, in {@code [1, 1024]}.
-   */
-  public static LsmWriteSpec bucket(String column, int numBuckets) {
-    if (column == null || column.trim().isEmpty()) {
-      throw new IllegalArgumentException("Column cannot be null or empty");
-    }
-    return new LsmWriteSpec(
-        Sharding.BUCKET, column, numBuckets, null, new HashMap<String, String>());
-  }
-
-  /**
-   * Identity sharding — shard by the raw value of {@code column} — maintaining every index on the
-   * table.
-   *
-   * <p>{@code column} must be a deterministic function of the unenforced primary key: every row
-   * with a given primary key must always produce the same {@code column} value, or upserts of that
-   * key can land in different shards and a stale version can win.
-   */
-  public static LsmWriteSpec identity(String column) {
-    if (column == null || column.trim().isEmpty()) {
-      throw new IllegalArgumentException("Column cannot be null or empty");
-    }
-    return new LsmWriteSpec(Sharding.IDENTITY, column, null, null, new HashMap<String, String>());
-  }
-
-  /** No sharding — every write goes to a single MemWAL shard — maintaining every index. */
-  public static LsmWriteSpec unsharded() {
-    return new LsmWriteSpec(Sharding.UNSHARDED, null, null, null, new HashMap<String, String>());
-  }
-
-  /**
-   * Set the indexes the MemWAL keeps up to date as rows are appended.
-   *
-   * <p>Pass {@code null} — the default for a fresh spec — to maintain every index the MemWAL can,
-   * resolved when the spec is installed. That is a snapshot: indexes created later are not
-   * maintained until the spec is unset and set again. Pass an empty list to maintain none.
-   *
-   * <p>Note that {@code null} and the empty list mean opposite things here.
-   */
-  public LsmWriteSpec withMaintainedIndexes(List<String> maintainedIndexes) {
-    return new LsmWriteSpec(
-        sharding,
-        column,
-        numBuckets,
-        maintainedIndexes == null ? null : new ArrayList<String>(maintainedIndexes),
-        writerConfigDefaults);
-  }
-
-  /**
-   * Set default {@code ShardWriter} configuration recorded in the MemWAL index.
-   *
-   * <p>A sparse override map — only the keys you set are recorded. Recognized keys include {@code
-   * durable_write}, {@code max_wal_buffer_size}, {@code max_memtable_size}, {@code
-   * max_memtable_rows}, {@code max_memtable_batches}, {@code manifest_scan_batch_size}, {@code
-   * max_unflushed_memtable_bytes}, and {@code enable_memtable}. Duration knobs carry an {@code _ms}
-   * suffix, such as {@code max_wal_flush_interval_ms}.
-   */
-  public LsmWriteSpec withWriterConfigDefaults(Map<String, String> writerConfigDefaults) {
-    if (writerConfigDefaults == null) {
-      throw new IllegalArgumentException("writerConfigDefaults cannot be null");
-    }
-    return new LsmWriteSpec(
-        sharding,
-        column,
-        numBuckets,
-        maintainedIndexes,
-        new HashMap<String, String>(writerConfigDefaults));
-  }
-
-  /** How writes are routed to shards. */
-  public Sharding sharding() {
-    return sharding;
-  }
-
-  /** The sharding column for {@link Sharding#BUCKET} and {@link Sharding#IDENTITY}, else null. */
-  public String column() {
-    return column;
-  }
-
-  /** The bucket count for {@link Sharding#BUCKET}, else null. */
-  public Integer numBuckets() {
-    return numBuckets;
-  }
-
-  /**
-   * The indexes the MemWAL maintains, or null to have the server resolve every maintainable index
-   * on install. An empty list means none.
-   */
-  public List<String> maintainedIndexes() {
-    return maintainedIndexes == null ? null : Collections.unmodifiableList(maintainedIndexes);
-  }
-
-  /** Default {@code ShardWriter} configuration recorded in the MemWAL index. */
-  public Map<String, String> writerConfigDefaults() {
-    return Collections.unmodifiableMap(writerConfigDefaults);
-  }
-
-  /** Render this spec as the {@code set_lsm_write_spec} request body. */
-  Map<String, Object> toRequestBody() {
-    Map<String, Object> shardingBody = new LinkedHashMap<String, Object>();
-    shardingBody.put("mode", sharding.wireName());
-    if (column != null) {
-      shardingBody.put("column", column);
-    }
-    if (numBuckets != null) {
-      shardingBody.put("num_buckets", numBuckets);
-    }
-
-    Map<String, Object> body = new LinkedHashMap<String, Object>();
-    body.put("sharding", shardingBody);
-    // Null is meaningful: it asks the server to resolve every maintainable index.
-    body.put("maintained_indexes", maintainedIndexes);
-    body.put("writer_config_defaults", writerConfigDefaults);
-    return body;
-  }
-
-  /**
-   * Rebuild a spec from a {@code get_lsm_write_spec} response body.
-   *
-   * <p>The server always reports a concrete maintained-index list, so a null selection never
-   * round-trips.
-   */
-  static LsmWriteSpec fromJson(JsonNode node) {
-    JsonNode shardingNode = node.get("sharding");
-    if (shardingNode == null || shardingNode.get("mode") == null) {
-      throw new IllegalStateException("get_lsm_write_spec response has no sharding mode");
-    }
-    Sharding sharding = Sharding.fromWireName(shardingNode.get("mode").asText());
-
-    String column = shardingNode.hasNonNull("column") ? shardingNode.get("column").asText() : null;
-    Integer numBuckets =
-        shardingNode.hasNonNull("num_buckets") ? shardingNode.get("num_buckets").asInt() : null;
-
-    List<String> maintainedIndexes = new ArrayList<String>();
-    JsonNode indexesNode = node.get("maintained_indexes");
-    if (indexesNode != null && indexesNode.isArray()) {
-      for (JsonNode index : indexesNode) {
-        maintainedIndexes.add(index.asText());
-      }
-    }
-
-    Map<String, String> defaults = new HashMap<String, String>();
-    JsonNode defaultsNode = node.get("writer_config_defaults");
-    if (defaultsNode != null && defaultsNode.isObject()) {
-      defaultsNode
-          .fieldNames()
-          .forEachRemaining(name -> defaults.put(name, defaultsNode.get(name).asText()));
-    }
-
-    return new LsmWriteSpec(sharding, column, numBuckets, maintainedIndexes, defaults);
-  }
-
-  @Override
-  public String toString() {
-    return "LsmWriteSpec{sharding="
-        + sharding
-        + ", column="
-        + column
-        + ", numBuckets="
-        + numBuckets
-        + ", maintainedIndexes="
-        + maintainedIndexes
-        + ", writerConfigDefaults="
-        + writerConfigDefaults
-        + "}";
-  }
-}

java/lancedb-core/src/main/java/com/lancedb/MemtableStats.java

@@ -1,99 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.lancedb;
-
-import com.fasterxml.jackson.databind.JsonNode;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-/** One in-memory memtable. */
-public class MemtableStats {
-  private static final String CONTEXT = "memtable stats";
-
-  private final long generation;
-  private final long rows;
-  private final long bytes;
-  private final long batches;
-  private final List<String> indexes;
-
-  MemtableStats(long generation, long rows, long bytes, long batches, List<String> indexes) {
-    this.generation = generation;
-    this.rows = rows;
-    this.bytes = bytes;
-    this.batches = batches;
-    this.indexes = Collections.unmodifiableList(indexes);
-  }
-
-  /** The generation this memtable will become once sealed. */
-  public long generation() {
-    return generation;
-  }
-
-  /** Rows currently buffered. */
-  public long rows() {
-    return rows;
-  }
-
-  /** Estimated in-memory size. */
-  public long bytes() {
-    return bytes;
-  }
-
-  /** Record batches currently buffered. */
-  public long batches() {
-    return batches;
-  }
-
-  /**
-   * 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".
-   */
-  public List<String> indexes() {
-    return indexes;
-  }
-
-  static MemtableStats fromJson(JsonNode node) {
-    JsonFields.requiredObject(node, CONTEXT);
-    List<String> indexes = new ArrayList<String>();
-    for (JsonNode index : JsonFields.requiredArray(node, "indexes", CONTEXT)) {
-      if (!index.isTextual()) {
-        throw new IllegalStateException(CONTEXT + " has a non-string index name: " + index);
-      }
-      indexes.add(index.asText());
-    }
-    return new MemtableStats(
-        JsonFields.requiredLong(node, "generation", CONTEXT),
-        JsonFields.requiredLong(node, "rows", CONTEXT),
-        JsonFields.requiredLong(node, "bytes", CONTEXT),
-        JsonFields.requiredLong(node, "batches", CONTEXT),
-        indexes);
-  }
-
-  @Override
-  public String toString() {
-    return "MemtableStats{generation="
-        + generation
-        + ", rows="
-        + rows
-        + ", bytes="
-        + bytes
-        + ", batches="
-        + batches
-        + ", indexes="
-        + indexes
-        + "}";
-  }
-}

java/lancedb-core/src/test/java/com/lancedb/LanceDbTableLsmTest.java

@@ -1,570 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.lancedb;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.sun.net.httpserver.HttpServer;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.UncheckedIOException;
-import java.net.InetSocketAddress;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * Unit tests for the MemWAL LSM routes, run against a scripted local HTTP server.
- *
- * <p>The wire assertions mirror the Rust mocked-endpoint tests in {@code
- * rust/lancedb/src/remote/table.rs}, which are the contract these routes have to match.
- */
-public class LanceDbTableLsmTest {
-  private static final ObjectMapper MAPPER = new ObjectMapper();
-
-  private HttpServer server;
-  private LanceDbRestClient client;
-  private LanceDbTableLsm lsm;
-
-  private final List<String> requestPaths = Collections.synchronizedList(new ArrayList<String>());
-  private final List<String> requestBodies = Collections.synchronizedList(new ArrayList<String>());
-  private final Map<String, Deque<Reply>> replies = new ConcurrentHashMap<String, Deque<Reply>>();
-
-  @BeforeEach
-  public void setUp() throws IOException {
-    start();
-  }
-
-  /** Tear down and restart the scripted server, for a test that scripts several exchanges. */
-  private void setUpFresh() {
-    try {
-      client.close();
-      server.stop(0);
-      requestPaths.clear();
-      requestBodies.clear();
-      replies.clear();
-      start();
-    } catch (IOException e) {
-      throw new UncheckedIOException(e);
-    }
-  }
-
-  private void start() throws IOException {
-    server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
-    server.createContext(
-        "/",
-        exchange -> {
-          String path = exchange.getRequestURI().getPath();
-          requestPaths.add(path);
-          requestBodies.add(readAll(exchange.getRequestBody()));
-
-          Reply reply = nextReply(path);
-          byte[] out = reply.body.getBytes(StandardCharsets.UTF_8);
-          exchange.sendResponseHeaders(reply.status, out.length == 0 ? -1 : out.length);
-          if (out.length > 0) {
-            exchange.getResponseBody().write(out);
-          }
-          exchange.close();
-        });
-    server.start();
-
-    client =
-        LanceDbNamespaceClientBuilder.newBuilder()
-            .apiKey("test-key")
-            .database("test-db")
-            .endpoint("http://127.0.0.1:" + server.getAddress().getPort())
-            .buildRestClient();
-    lsm = new LanceDbTableLsm(client, "my_table");
-  }
-
-  @AfterEach
-  public void tearDown() throws IOException {
-    client.close();
-    server.stop(0);
-  }
-
-  // ===========================================================================
-  // set / unset / get spec
-  // ===========================================================================
-
-  @Test
-  public void testSetLsmWriteSpecUnsharded() throws Exception {
-    enqueue("set_lsm_write_spec", 200, "");
-
-    lsm.setLsmWriteSpec(LsmWriteSpec.unsharded());
-
-    assertEquals("/v1/table/my_table/set_lsm_write_spec/", requestPaths.get(0));
-    JsonNode body = MAPPER.readTree(requestBodies.get(0));
-    assertEquals("unsharded", body.get("sharding").get("mode").asText());
-    assertFalse(body.get("sharding").has("column"));
-    assertFalse(body.get("sharding").has("num_buckets"));
-  }
-
-  @Test
-  public void testSetLsmWriteSpecBucket() throws Exception {
-    enqueue("set_lsm_write_spec", 200, "");
-
-    lsm.setLsmWriteSpec(
-        LsmWriteSpec.bucket("id", 16).withMaintainedIndexes(Arrays.asList("id_idx")));
-
-    JsonNode body = MAPPER.readTree(requestBodies.get(0));
-    assertEquals("bucket", body.get("sharding").get("mode").asText());
-    assertEquals("id", body.get("sharding").get("column").asText());
-    assertEquals(16, body.get("sharding").get("num_buckets").asInt());
-    assertEquals(1, body.get("maintained_indexes").size());
-    assertEquals("id_idx", body.get("maintained_indexes").get(0).asText());
-  }
-
-  @Test
-  public void testSetLsmWriteSpecIdentity() throws Exception {
-    enqueue("set_lsm_write_spec", 200, "");
-
-    lsm.setLsmWriteSpec(LsmWriteSpec.identity("tenant"));
-
-    JsonNode body = MAPPER.readTree(requestBodies.get(0));
-    assertEquals("identity", body.get("sharding").get("mode").asText());
-    assertEquals("tenant", body.get("sharding").get("column").asText());
-    assertFalse(body.get("sharding").has("num_buckets"));
-  }
-
-  /**
-   * The tri-state that motivated a LanceDB-owned spec type: a null selection asks the server to
-   * resolve every maintainable index, while an empty list asks for none. They must not collapse.
-   */
-  @Test
-  public void testMaintainedIndexesNullAndEmptyAreDistinctOnTheWire() throws Exception {
-    enqueue("set_lsm_write_spec", 200, "");
-
-    lsm.setLsmWriteSpec(LsmWriteSpec.unsharded());
-    JsonNode fresh = MAPPER.readTree(requestBodies.get(0));
-    assertTrue(fresh.has("maintained_indexes"), "the key must be present");
-    assertTrue(fresh.get("maintained_indexes").isNull(), "a fresh spec sends null, not []");
-
-    lsm.setLsmWriteSpec(
-        LsmWriteSpec.unsharded().withMaintainedIndexes(Collections.<String>emptyList()));
-    JsonNode none = MAPPER.readTree(requestBodies.get(1));
-    assertTrue(none.get("maintained_indexes").isArray());
-    assertEquals(0, none.get("maintained_indexes").size());
-  }
-
-  @Test
-  public void testSetLsmWriteSpecWriterConfigDefaults() throws Exception {
-    enqueue("set_lsm_write_spec", 200, "");
-
-    Map<String, String> defaults = new HashMap<String, String>();
-    defaults.put("max_memtable_rows", "50000");
-    lsm.setLsmWriteSpec(LsmWriteSpec.unsharded().withWriterConfigDefaults(defaults));
-
-    JsonNode body = MAPPER.readTree(requestBodies.get(0));
-    assertEquals("50000", body.get("writer_config_defaults").get("max_memtable_rows").asText());
-  }
-
-  @Test
-  public void testUnsetLsmWriteSpec() {
-    enqueue("unset_lsm_write_spec", 200, "");
-
-    lsm.unsetLsmWriteSpec();
-
-    assertEquals("/v1/table/my_table/unset_lsm_write_spec/", requestPaths.get(0));
-    assertEquals("", requestBodies.get(0));
-  }
-
-  @Test
-  public void testGetLsmWriteSpec() {
-    enqueue(
-        "get_lsm_write_spec",
-        200,
-        "{\"lsm_write_spec\":{\"sharding\":{\"mode\":\"bucket\",\"column\":\"id\","
-            + "\"num_buckets\":16},\"maintained_indexes\":[\"id_idx\"],"
-            + "\"writer_config_defaults\":{\"durable_write\":\"true\"}}}");
-
-    Optional<LsmWriteSpec> spec = lsm.getLsmWriteSpec();
-
-    assertTrue(spec.isPresent());
-    assertEquals(LsmWriteSpec.Sharding.BUCKET, spec.get().sharding());
-    assertEquals("id", spec.get().column());
-    assertEquals(Integer.valueOf(16), spec.get().numBuckets());
-    assertEquals(Arrays.asList("id_idx"), spec.get().maintainedIndexes());
-    assertEquals("true", spec.get().writerConfigDefaults().get("durable_write"));
-  }
-
-  @Test
-  public void testGetLsmWriteSpecAbsent() {
-    enqueue("get_lsm_write_spec", 200, "{\"lsm_write_spec\":null}");
-
-    assertFalse(lsm.getLsmWriteSpec().isPresent());
-  }
-
-  // ===========================================================================
-  // stats
-  // ===========================================================================
-
-  @Test
-  public void testGetLsmStats() throws Exception {
-    enqueue("get_lsm_stats", 200, stats(bucket("shard-0", false, 7L, 8L)));
-
-    Optional<LsmStats> got = lsm.getLsmStats(true);
-
-    assertEquals("/v1/table/my_table/get_lsm_stats/", requestPaths.get(0));
-    assertTrue(MAPPER.readTree(requestBodies.get(0)).get("include_generation_rows").asBoolean());
-    assertTrue(got.isPresent());
-    BucketStats decoded = got.get().buckets().get(0);
-    assertEquals("shard-0", decoded.shardId());
-    assertEquals("Active", decoded.status());
-    assertEquals(1, decoded.writerEpoch());
-    assertEquals(2, decoded.manifestVersion());
-    assertEquals(9, decoded.currentGeneration());
-    assertFalse(decoded.compacting());
-    assertEquals(Arrays.asList(7L, 8L), generationNumbers(decoded));
-    assertEquals(1024, decoded.generations().get(0).bytes());
-    assertFalse(decoded.generations().get(0).rows().isPresent(), "rows absent unless requested");
-    assertFalse(decoded.memtables().isPresent(), "absent memtables stay absent");
-  }
-
-  /** The optional fields decode when the server does send them. */
-  @Test
-  public void testGetLsmStatsDecodesOptionalFields() {
-    enqueue(
-        "get_lsm_stats",
-        200,
-        "{\"lsm_stats\":{\"buckets\":[{\"shard_id\":\"shard-0\",\"status\":\"Active\","
-            + "\"writer_epoch\":1,\"manifest_version\":2,\"current_generation\":9,"
-            + "\"replay_after_wal_entry_position\":3,\"wal_entry_position_last_seen\":11,"
-            + "\"generations\":[{\"generation\":7,\"bytes\":1024,\"rows\":42}],"
-            + "\"compacting\":true,\"memtables\":[{\"generation\":8,\"rows\":5,"
-            + "\"bytes\":64,\"batches\":2,\"indexes\":[\"id_idx\"]}]}]}}");
-
-    BucketStats decoded = lsm.getLsmStats(true).get().buckets().get(0);
-
-    assertEquals(3, decoded.replayAfterWalEntryPosition());
-    assertEquals(11, decoded.walEntryPositionLastSeen());
-    assertTrue(decoded.compacting());
-    assertEquals(42, decoded.generations().get(0).rows().getAsLong());
-    assertTrue(decoded.memtables().isPresent());
-    MemtableStats memtable = decoded.memtables().get().get(0);
-    assertEquals(8, memtable.generation());
-    assertEquals(5, memtable.rows());
-    assertEquals(64, memtable.bytes());
-    assertEquals(2, memtable.batches());
-    assertEquals(Arrays.asList("id_idx"), memtable.indexes());
-  }
-
-  @Test
-  public void testGetLsmStatsAbsentWhenLsmDisabled() {
-    enqueue("get_lsm_stats", 200, "{\"lsm_stats\":null}");
-
-    assertFalse(lsm.getLsmStats().isPresent());
-  }
-
-  @Test
-  public void testGetLsmStatsDefaultsToExcludingGenerationRows() throws Exception {
-    enqueue("get_lsm_stats", 200, stats());
-
-    lsm.getLsmStats();
-
-    assertFalse(MAPPER.readTree(requestBodies.get(0)).get("include_generation_rows").asBoolean());
-  }
-
-  // ===========================================================================
-  // flush / compact
-  // ===========================================================================
-
-  @Test
-  public void testFlushAndCompactRoutes() {
-    enqueue("flush_lsm", 200, "");
-    enqueue("compact_lsm", 200, "");
-
-    lsm.flushLsm();
-    lsm.compactLsm();
-
-    assertEquals("/v1/table/my_table/flush_lsm/", requestPaths.get(0));
-    assertEquals("/v1/table/my_table/compact_lsm/", requestPaths.get(1));
-  }
-
-  @Test
-  public void testHttpErrorCarriesStatus() {
-    enqueue("flush_lsm", 404, "no such table");
-
-    LanceDbRestClient.HttpException e =
-        assertThrows(LanceDbRestClient.HttpException.class, () -> lsm.flushLsm());
-    assertEquals(404, e.statusCode());
-  }
-
-  // ===========================================================================
-  // checkpoint
-  // ===========================================================================
-
-  @Test
-  public void testCheckpointReturnsWhenLsmDisabled() {
-    enqueue("flush_lsm", 200, "");
-    enqueue("get_lsm_stats", 200, "{\"lsm_stats\":null}");
-
-    lsm.checkpointLsm();
-
-    assertEquals(0, countCalls("compact_lsm"), "nothing to compact when the LSM path is off");
-  }
-
-  @Test
-  public void testCheckpointReturnsWhenNoGenerationsOutstanding() {
-    enqueue("flush_lsm", 200, "");
-    // A bucket with no L0 generations yields no target, so the drain never starts.
-    enqueue("get_lsm_stats", 200, stats(bucket("shard-0", false)));
-
-    lsm.checkpointLsm();
-
-    assertEquals(0, countCalls("compact_lsm"));
-  }
-
-  @Test
-  public void testCheckpointConvergesOnceTargetGenerationsAreGone() {
-    enqueue("flush_lsm", 200, "");
-    // Watermark read: shard-0 holds generations 7 and 8, so target = 8.
-    enqueue("get_lsm_stats", 200, stats(bucket("shard-0", false, 7L, 8L)));
-    // First drain poll: both still outstanding, nothing compacting -> dispatch a pass.
-    enqueue("get_lsm_stats", 200, stats(bucket("shard-0", false, 7L, 8L)));
-    // Second drain poll: drained past the target -> done.
-    enqueue("get_lsm_stats", 200, stats(bucket("shard-0", false, 9L)));
-    enqueue("compact_lsm", 200, "");
-
-    lsm.checkpointLsm();
-
-    assertEquals(1, countCalls("compact_lsm"), "one pass dispatched");
-    assertEquals(3, countCalls("get_lsm_stats"), "watermark read plus two drain polls");
-  }
-
-  @Test
-  public void testCheckpointDoesNotPileOnWhileEveryTargetBucketIsCompacting() {
-    enqueue("flush_lsm", 200, "");
-    enqueue("get_lsm_stats", 200, stats(bucket("shard-0", true, 4L)));
-    // Still compacting on the first poll, so no pass is dispatched; then it drains.
-    enqueue("get_lsm_stats", 200, stats(bucket("shard-0", true, 4L)));
-    enqueue("get_lsm_stats", 200, stats(bucket("shard-0", false, 5L)));
-
-    lsm.checkpointLsm();
-
-    assertEquals(0, countCalls("compact_lsm"), "a latched bucket is left alone");
-  }
-
-  @Test
-  public void testCheckpointRetriesFromFlushAfterLostClaim() {
-    // 421 on the watermark read: the node lost its claim, so the whole thing restarts
-    // from flush rather than retrying the read in place.
-    enqueue("flush_lsm", 200, "");
-    enqueue("get_lsm_stats", 421, "no claim");
-    enqueue("get_lsm_stats", 200, stats(bucket("shard-0", false)));
-
-    lsm.checkpointLsm();
-
-    assertEquals(2, countCalls("flush_lsm"), "re-issued from flush");
-  }
-
-  @Test
-  public void testCheckpointRetriesRetryableStatusInPlace() {
-    enqueue("flush_lsm", 429, "latch held");
-    enqueue("flush_lsm", 200, "");
-    enqueue("get_lsm_stats", 200, stats(bucket("shard-0", false)));
-
-    lsm.checkpointLsm();
-
-    assertEquals(2, countCalls("flush_lsm"), "429 retried in place, not re-issued");
-  }
-
-  @Test
-  public void testCheckpointPropagatesTerminalStatus() {
-    enqueue("flush_lsm", 400, "bad request");
-
-    LanceDbRestClient.HttpException e =
-        assertThrows(LanceDbRestClient.HttpException.class, () -> lsm.checkpointLsm());
-    assertEquals(400, e.statusCode());
-    assertEquals(1, countCalls("flush_lsm"), "a terminal status is not retried");
-  }
-
-  @Test
-  public void testCheckpointGivesUpAfterRepeatedLostClaims() {
-    enqueue("flush_lsm", 421, "no claim");
-
-    IllegalStateException e = assertThrows(IllegalStateException.class, () -> lsm.checkpointLsm());
-    assertTrue(e.getMessage().contains("kept losing its claim"), e.getMessage());
-    assertEquals(4, countCalls("flush_lsm"), "the initial attempt plus MAX_REISSUES");
-  }
-
-  // ===========================================================================
-  // strict decoding
-  // ===========================================================================
-
-  /**
-   * A stats payload that does not decode must fail closed. Every one of these bodies used to be
-   * read as "no buckets", which is indistinguishable from a drained table, so {@code checkpointLsm}
-   * reported convergence for a checkpoint that never ran.
-   */
-  @Test
-  public void testCheckpointRejectsMalformedStats() {
-    Map<String, String> malformed = new LinkedHashMap<String, String>();
-    malformed.put("no response body at all", "");
-    malformed.put("stats object with no buckets", "{\"lsm_stats\":{}}");
-    malformed.put("bucket missing its required fields", "{\"lsm_stats\":{\"buckets\":[{}]}}");
-    malformed.put(
-        "bucket missing generations",
-        "{\"lsm_stats\":{\"buckets\":[{\"shard_id\":\"shard-0\",\"status\":\"Active\","
-            + "\"writer_epoch\":1,\"manifest_version\":2,\"current_generation\":9,"
-            + "\"replay_after_wal_entry_position\":0,\"wal_entry_position_last_seen\":0,"
-            + "\"compacting\":false}]}}");
-    malformed.put(
-        "generation with a non-numeric generation number",
-        "{\"lsm_stats\":{\"buckets\":[{\"shard_id\":\"shard-0\",\"status\":\"Active\","
-            + "\"writer_epoch\":1,\"manifest_version\":2,\"current_generation\":9,"
-            + "\"replay_after_wal_entry_position\":0,\"wal_entry_position_last_seen\":0,"
-            + "\"generations\":[{\"generation\":\"7\",\"bytes\":1024}],"
-            + "\"compacting\":false}]}}");
-
-    for (Map.Entry<String, String> each : malformed.entrySet()) {
-      setUpFresh();
-      enqueue("flush_lsm", 200, "");
-      enqueue("get_lsm_stats", 200, each.getValue());
-
-      assertThrows(
-          IllegalStateException.class,
-          () -> lsm.checkpointLsm(),
-          each.getKey() + " must not report convergence");
-    }
-  }
-
-  /** The one shape that legitimately means "this table has no LSM write path". */
-  @Test
-  public void testCheckpointTreatsNullStatsAsNotWalBacked() {
-    enqueue("flush_lsm", 200, "");
-    enqueue("get_lsm_stats", 200, "{\"lsm_stats\":null}");
-
-    lsm.checkpointLsm();
-
-    assertEquals(1, countCalls("get_lsm_stats"));
-  }
-
-  // ===========================================================================
-  // retry budget
-  // ===========================================================================
-
-  /**
-   * The transport must not retry on the checkpoint loop's behalf. Apache HttpClient's default
-   * strategy retries exactly 429 and 503 — the two statuses {@code isRetryable} owns — which
-   * doubled every budget here and also retried {@code compact_lsm} in place, where the loop is
-   * built to fall through to a fresh stats poll instead.
-   */
-  @Test
-  public void testCheckpointRetryBudgetIsNotDoubledByTheTransport() {
-    enqueue("flush_lsm", 429, "latch held");
-
-    LanceDbRestClient.HttpException e =
-        assertThrows(LanceDbRestClient.HttpException.class, () -> lsm.checkpointLsm());
-
-    assertEquals(429, e.statusCode(), "the exhausted budget propagates the last error as itself");
-    assertEquals(9, countCalls("flush_lsm"), "the initial request plus MAX_RETRIES, and no more");
-  }
-
-  // ===========================================================================
-  // harness
-  // ===========================================================================
-
-  private static List<Long> generationNumbers(BucketStats bucket) {
-    List<Long> numbers = new ArrayList<Long>();
-    for (GenerationStats generation : bucket.generations()) {
-      numbers.add(generation.generation());
-    }
-    return numbers;
-  }
-
-  /** Build an {@code lsm_stats} response body from bucket fragments. */
-  private static String stats(String... buckets) {
-    return "{\"lsm_stats\":{\"buckets\":[" + String.join(",", buckets) + "]}}";
-  }
-
-  private static String bucket(String shardId, boolean compacting, Long... generations) {
-    StringBuilder gens = new StringBuilder();
-    for (Long generation : generations) {
-      if (gens.length() > 0) {
-        gens.append(",");
-      }
-      gens.append("{\"generation\":").append(generation).append(",\"bytes\":1024}");
-    }
-    return "{\"shard_id\":\""
-        + shardId
-        + "\",\"status\":\"Active\",\"writer_epoch\":1,\"manifest_version\":2,"
-        + "\"current_generation\":9,\"replay_after_wal_entry_position\":0,"
-        + "\"wal_entry_position_last_seen\":0,\"generations\":["
-        + gens
-        + "],\"compacting\":"
-        + compacting
-        + "}";
-  }
-
-  /** Queue a reply for an operation. The last queued reply repeats once the queue drains. */
-  private void enqueue(String operation, int status, String body) {
-    replies.computeIfAbsent(operation, key -> new ArrayDeque<Reply>()).add(new Reply(status, body));
-  }
-
-  private Reply nextReply(String path) {
-    String operation = operationOf(path);
-    Deque<Reply> queued = replies.get(operation);
-    if (queued == null || queued.isEmpty()) {
-      return new Reply(200, "");
-    }
-    return queued.size() > 1 ? queued.poll() : queued.peek();
-  }
-
-  private long countCalls(String operation) {
-    return requestPaths.stream().filter(path -> operationOf(path).equals(operation)).count();
-  }
-
-  /** {@code /v1/table/my_table/flush_lsm/} -> {@code flush_lsm}. */
-  private static String operationOf(String path) {
-    String[] segments = path.split("/");
-    return segments.length == 0 ? "" : segments[segments.length - 1];
-  }
-
-  private static String readAll(InputStream in) throws IOException {
-    ByteArrayOutputStream out = new ByteArrayOutputStream();
-    byte[] buffer = new byte[4096];
-    int read;
-    while ((read = in.read(buffer)) != -1) {
-      out.write(buffer, 0, read);
-    }
-    return new String(out.toByteArray(), StandardCharsets.UTF_8);
-  }
-
-  private static final class Reply {
-    private final int status;
-    private final String body;
-
-    private Reply(int status, String body) {
-      this.status = status;
-      this.body = body;
-    }
-  }
-}

java/pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.lancedb</groupId>
     <artifactId>lancedb-parent</artifactId>
-    <version>0.38.0-beta.4</version>
+    <version>0.32.0-beta.2</version>
     <packaging>pom</packaging>
     <name>${project.artifactId}</name>
     <description>LanceDB Java SDK Parent POM</description>
@@ -28,7 +28,7 @@
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <arrow.version>15.0.0</arrow.version>
-        <lance-core.version>11.0.0-beta.19</lance-core.version>
+        <lance-core.version>10.0.0-beta.2</lance-core.version>
         <spotless.skip>false</spotless.skip>
         <spotless.version>2.30.0</spotless.version>
         <spotless.java.googlejavaformat.version>1.7</spotless.java.googlejavaformat.version>

nodejs/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
 

nodejs/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "lancedb-nodejs"
 edition.workspace = true
-version = "0.38.0-beta.4"
+version = "0.32.0-beta.2"
 publish = false
 license.workspace = true
 description.workspace = true
@@ -16,12 +16,12 @@ crate-type = ["cdylib"]
 async-trait.workspace = true
 arrow-ipc.workspace = true
 arrow-array.workspace = true
-arrow-buffer.workspace = true
+arrow-buffer = "58.0.0"
 half.workspace = true
 arrow-schema.workspace = true
 env_logger.workspace = true
 futures.workspace = true
-lancedb.workspace = true
+lancedb = { path = "../rust/lancedb", default-features = false }
 lance-namespace.workspace = true
 napi = { version = "3.8.3", default-features = false, features = [
     "napi9",
@@ -29,8 +29,8 @@ napi = { version = "3.8.3", default-features = false, features = [
     "chrono_date",
     "serde-json",
 ] }
-chrono.workspace = true
-serde_json.workspace = true
+chrono = { version = "0.4", default-features = false, features = ["clock"] }
+serde_json = "1"
 napi-derive = "3.5.2"
 # Prevent dynamic linking of lzma, which comes from datafusion
 lzma-sys = { version = "0.1", features = ["static"] }

nodejs/__test__/arrow.test.ts

@@ -6,9 +6,7 @@ import * as arrow17 from "apache-arrow-17";
 import * as arrow18 from "apache-arrow-18";
 
 import {
-  Vector as CurrentVector,
   convertToTable,
-  tableFromIPC as currentTableFromIPC,
   fromBufferToRecordBatch,
   fromDataToBuffer,
   fromRecordBatchToBuffer,
@@ -21,7 +19,6 @@ import {
   FunctionOptions,
 } from "../lancedb/embedding/embedding_function";
 import { EmbeddingFunctionConfig } from "../lancedb/embedding/registry";
-import { sanitizeTable } from "../lancedb/sanitize";
 
 // biome-ignore lint/suspicious/noExplicitAny: skip
 function sampleRecords(): Array<Record<string, any>> {
@@ -67,11 +64,7 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
       tableFromIPC,
       DataType,
       Dictionary,
-      RecordBatch: ArrowRecordBatch,
-      Table: ArrowTable,
       Uint8: ArrowUint8,
-      makeData: arrowMakeData,
-      vectorFromArray,
       // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     } = <any>arrow;
     type Schema = ApacheArrow["Schema"];
@@ -173,36 +166,6 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
     }
 
     describe("The function makeArrowTable", function () {
-      it("accepts snake_case embedding metadata like camelCase", function () {
-        const spellings = [
-          // biome-ignore lint/style/useNamingConvention: the Python wire spelling
-          { source_column: "text", vector_column: "vector" },
-          { sourceColumn: "text", vectorColumn: "vector" },
-        ];
-        for (const columns of spellings) {
-          const schema = new Schema(
-            [
-              new Field("text", new Utf8(), false),
-              new Field(
-                "vector",
-                new FixedSizeList(3, new Field("item", new Float32(), true)),
-                false,
-              ),
-            ],
-            new Map([
-              [
-                "embedding_functions",
-                JSON.stringify([{ name: "mock", model: {}, ...columns }]),
-              ],
-            ]),
-          );
-          // The vector field is non-nullable and absent from the data; only a
-          // recognized embedding config makes that acceptable.
-          const table = makeArrowTable([{ text: "hello" }], { schema });
-          expect(table.numRows).toBe(1);
-        }
-      });
-
       it("will use data types from a provided schema instead of inference", async function () {
         const schema = new Schema([
           new Field("a", new Int32(), false),
@@ -234,35 +197,6 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
         expect(table.getChild("d")?.toJSON()).toEqual([9n, 10n, null]);
       });
 
-      it("will use a provided FixedSizeList schema with typed array values", function () {
-        const schema = new Schema([
-          new Field("text", new Utf8(), false),
-          new Field(
-            "vector",
-            new FixedSizeList(3, new Field("item", new Float32(), false)),
-            false,
-          ),
-        ]);
-
-        const table = makeArrowTable(
-          [
-            {
-              text: "foo",
-              vector: new Float32Array([1, 2, 3]),
-            },
-          ],
-          { schema },
-        );
-
-        expect(table.getChild("text")?.toJSON()).toEqual(["foo"]);
-        expect(
-          table
-            .getChild("vector")
-            ?.toJSON()
-            .map((value) => value.toJSON()),
-        ).toEqual([[1, 2, 3]]);
-      });
-
       it("will assume the column `vector` is FixedSizeList<Float32> by default", async function () {
         const schema = new Schema([
           new Field("a", new Float(Precision.DOUBLE), true),
@@ -1057,148 +991,9 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
 
         expectValidMapField(roundTripped.schema.fields[0]);
       });
-
-      it("preserves string schema metadata", function () {
-        const metadata = new Map([["source", "fixture"]]);
-        const schema = new Schema(
-          [new Field("value", new Int32(), true)],
-          metadata,
-        );
-
-        expect(makeEmptyTable(schema).schema.metadata.get("source")).toBe(
-          "fixture",
-        );
-      });
-
-      it.each([
-        ["non-string keys", new Map<unknown, unknown>([[42, "fixture"]])],
-        ["non-string values", new Map<unknown, unknown>([["source", 42]])],
-        [
-          "non-string keys and values",
-          new Map<unknown, unknown>([[42, false]]),
-        ],
-      ])("rejects schema metadata with %s", function (_, metadataLike) {
-        const metadata = metadataLike as unknown as Map<string, string>;
-        const schema = new Schema(
-          [new Field("value", new Int32(), true)],
-          metadata,
-        );
-
-        expect(() => makeEmptyTable(schema)).toThrow(
-          "Expected metadata, if present, to be a Map<string, string> but it had non-string keys or values",
-        );
-      });
     });
 
     describe("when using two versions of arrow", function () {
-      it("preserves a dictionary shared by multiple fields", async function () {
-        const values = ["alpha", "beta", "alpha"];
-        const dictionaryVector = vectorFromArray(values);
-        const batch = new ArrowRecordBatch({
-          first: dictionaryVector.data[0],
-          second: dictionaryVector.data[0],
-        });
-        const table = new ArrowTable([batch]);
-
-        const sanitized = sanitizeTable(table);
-        expect([...sanitized.getChild("first")!]).toEqual(values);
-        expect([...sanitized.getChild("second")!]).toEqual(values);
-        const firstType = sanitized.schema.fields[0].type as {
-          dictionary: unknown;
-        };
-        const secondType = sanitized.schema.fields[1].type as {
-          dictionary: unknown;
-        };
-        expect(secondType.dictionary).toBe(firstType.dictionary);
-        expect(sanitized.batches[0].data.children[1].dictionary).toBe(
-          sanitized.batches[0].data.children[0].dictionary,
-        );
-
-        const buf = await fromDataToBuffer(table);
-        const actual = currentTableFromIPC(buf);
-        expect([...actual.getChild("first")!]).toEqual(values);
-        expect([...actual.getChild("second")!]).toEqual(values);
-      });
-
-      it("preserves shared dictionary data from another Arrow version", async function () {
-        const values = ["alpha", "beta", "alpha"];
-        const dictionaryVector = vectorFromArray(values);
-        const firstBatch = new ArrowRecordBatch({
-          label: dictionaryVector.slice(0, 2).data[0],
-        });
-        const secondBatch = new ArrowRecordBatch({
-          label: dictionaryVector.slice(2).data[0],
-        });
-        const table = new ArrowTable([firstBatch, secondBatch]);
-
-        const sanitized = sanitizeTable(table);
-        expect([...sanitized.getChild("label")!]).toEqual(values);
-
-        const dictionaries = sanitized.batches.map(
-          (batch) => batch.data.children[0].dictionary,
-        );
-        expect(dictionaries[0]).toBeInstanceOf(CurrentVector);
-        expect(dictionaries[1]).toBe(dictionaries[0]);
-
-        const buf = await fromDataToBuffer(table);
-        const actual = currentTableFromIPC(buf);
-        expect([...actual.getChild("label")!]).toEqual(values);
-      });
-
-      it("preserves shared chunks in growing dictionaries", async function () {
-        const type = new Dictionary(new Utf8(), new Int32(), 42, false);
-        const firstDictionary = vectorFromArray(["alpha", "beta"], new Utf8());
-        const secondDictionary = firstDictionary.concat(
-          vectorFromArray(["gamma"], new Utf8()),
-        );
-        const firstData = arrowMakeData({
-          type,
-          data: Int32Array.from([0, 1]),
-          dictionary: firstDictionary,
-        });
-        const secondData = arrowMakeData({
-          type,
-          data: Int32Array.from([2]),
-          dictionary: secondDictionary,
-        });
-        const table = new ArrowTable([
-          new ArrowRecordBatch({ label: firstData }),
-          new ArrowRecordBatch({ label: secondData }),
-        ]);
-
-        const sanitized = sanitizeTable(table);
-        const expected = ["alpha", "beta", "gamma"];
-        expect([...sanitized.getChild("label")!]).toEqual(expected);
-        const firstLocalDictionary =
-          sanitized.batches[0].data.children[0].dictionary!;
-        const secondLocalDictionary =
-          sanitized.batches[1].data.children[0].dictionary!;
-        expect(secondLocalDictionary.data[0]).toBe(
-          firstLocalDictionary.data[0],
-        );
-
-        const buf = await fromTableToBuffer(sanitized);
-        const actual = currentTableFromIPC(buf);
-        expect([...actual.getChild("label")!]).toEqual(expected);
-      });
-
-      it("can serialize list data from another Arrow version", async function () {
-        const values = [["anime", "action"], [], null];
-        const vector = vectorFromArray(
-          values,
-          new List(new Field("item", new Utf8(), true)),
-        );
-        const table = new ArrowTable({ tags: vector });
-
-        const buf = await fromDataToBuffer(table);
-        const actual = currentTableFromIPC(buf);
-        const actualTags = actual.getChild("tags");
-
-        expect(actualTags?.get(0)?.toJSON()).toEqual(values[0]);
-        expect(actualTags?.get(1)?.toJSON()).toEqual(values[1]);
-        expect(actualTags?.get(2)).toBeNull();
-      });
-
       it("can still import data", async function () {
         const schema = new arrow15.Schema([
           new arrow15.Field("id", new arrow15.Int32()),

nodejs/__test__/connection.test.ts

@@ -89,16 +89,6 @@ describe("given a connection", () => {
     await db.createTable("test4", [{ id: 1 }, { id: 2 }]);
   });
 
-  it("should return a completed job when dropping a local table", async () => {
-    await db.createTable("async-drop", [{ id: 1 }]);
-
-    const job = await db.dropTableAsync("async-drop");
-    expect(job.id).toBeNull();
-    await expect(job.status()).resolves.toBe("finished");
-    await job.wait();
-    await expect(db.tableNames()).resolves.toEqual([]);
-  });
-
   it("should fail if creating table twice, unless overwrite is true", async () => {
     let tbl = await db.createTable("test", [{ id: 1 }, { id: 2 }]);
     await expect(tbl.countRows()).resolves.toBe(2);

nodejs/__test__/embedding.test.ts

@@ -11,11 +11,8 @@ import {
   Float16,
   Float32,
   Float64,
-  Int32,
   Schema,
   Utf8,
-  fromDataToBuffer,
-  tableFromIPC,
 } from "../lancedb/arrow";
 import { EmbeddingFunction, LanceSchema } from "../lancedb/embedding";
 import { getRegistry, register } from "../lancedb/embedding/registry";
@@ -187,63 +184,6 @@ describe("embedding functions", () => {
     const vector0 = JSON.parse(JSON.stringify(arr[0].vector));
     expect(vector0).toEqual([1, 2, 3]);
   });
-
-  it("should append generated vectors to a non-nullable schema", async () => {
-    @register("non_nullable_schema_test")
-    class MockEmbeddingFunction extends EmbeddingFunction<string> {
-      ndims() {
-        return 3;
-      }
-      embeddingDataType(): Float {
-        return new Float64();
-      }
-      async computeSourceEmbeddings(data: string[]) {
-        return data.map(() => [1, 2, 3]);
-      }
-    }
-
-    const schema = new Schema([
-      new Field("id", new Int32()),
-      new Field("text", new Utf8()),
-      new Field("type", new Utf8()),
-      new Field(
-        "vector",
-        new FixedSizeList(3, new Field("item", new Float64())),
-      ),
-    ]);
-    const func = new MockEmbeddingFunction();
-    const db = await connect(tmpDir.name);
-    const table = await db.createEmptyTable("test_non_nullable", schema, {
-      embeddingFunction: {
-        function: func,
-        sourceColumn: "text",
-      },
-    });
-
-    const data = [
-      { id: 1, text: "Carrot", type: "vegetable" },
-      { id: 2, text: "Apple", type: "fruit" },
-    ];
-    const buffer = await fromDataToBuffer(
-      data,
-      undefined,
-      await table.schema(),
-    );
-    const generatedTable = tableFromIPC(buffer);
-    const vectorField = generatedTable.schema.fields.find(
-      (field) => field.name === "vector",
-    );
-    expect(vectorField?.nullable).toBe(false);
-
-    await table.add(data);
-
-    const rows = await table.query().toArray();
-    expect(rows).toHaveLength(2);
-    for (const row of rows) {
-      expect([...row.vector]).toEqual([1, 2, 3]);
-    }
-  });
-
   it("should error when appending to a table with an unregistered embedding function", async () => {
     @register("mock")
     class MockEmbeddingFunction extends EmbeddingFunction<string> {
@@ -487,52 +427,4 @@ describe("embedding functions", () => {
       expect(stringSchema3).toEqual(stringExpectedSchema);
     },
   );
-  test("parses one function writing several vector columns", async () => {
-    class MockEmbeddingFunction extends EmbeddingFunction<string> {
-      ndims() {
-        return 3;
-      }
-      embeddingDataType(): Float {
-        return new Float32();
-      }
-      async computeQueryEmbeddings(_data: string) {
-        return [1, 2, 3];
-      }
-      async computeSourceEmbeddings(data: string[]) {
-        return Array.from({ length: data.length }).fill([
-          1, 2, 3,
-        ]) as number[][];
-      }
-    }
-    const registry = getRegistry();
-    registry.register("multi_output_mock")(MockEmbeddingFunction);
-
-    // A materialized view can project one source vector column under two
-    // names, so a table's configuration names the same function twice.
-    const parsed = await registry.parseFunctions(
-      new Map([
-        [
-          "embedding_functions",
-          JSON.stringify([
-            {
-              name: "multi_output_mock",
-              sourceColumn: "text",
-              vectorColumn: "vector_a",
-              model: {},
-            },
-            {
-              name: "multi_output_mock",
-              sourceColumn: "text",
-              vectorColumn: "vector_b",
-              model: {},
-            },
-          ]),
-        ],
-      ]),
-    );
-
-    expect(
-      [...parsed.values()].map(({ vectorColumn }) => vectorColumn).sort(),
-    ).toEqual(["vector_a", "vector_b"]);
-  });
 });

nodejs/__test__/materialized_view.test.ts

@@ -1,147 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-import * as tmp from "tmp";
-
-import { Connection, connect } from "../lancedb";
-import {
-  DEFINITION_META_KEY,
-  definitionFromMetadata,
-} from "../lancedb/materialized_view";
-
-describe("materialized views", () => {
-  let tmpDir: tmp.DirResult;
-  let db: Connection;
-
-  beforeEach(async () => {
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
-    db = await connect(tmpDir.name);
-    await db.createTable(
-      "people",
-      [
-        { name: "ada", age: 36 },
-        { name: "kid", age: 7 },
-        { name: "grace", age: 85 },
-      ],
-      { storageOptions: { newTableEnableStableRowIds: "true" } },
-    );
-  });
-  afterEach(() => tmpDir.removeCallback());
-
-  it("rejects a stored limit a number cannot carry", () => {
-    const big = new Map([
-      [
-        DEFINITION_META_KEY,
-        '{"kind":"select","source_table":"people","limit":9007199254740993}',
-      ],
-    ]);
-    expect(() => definitionFromMetadata(big, "v")).toThrow(
-      /too large to represent exactly/,
-    );
-
-    const safe = new Map([
-      [
-        DEFINITION_META_KEY,
-        '{"kind":"select","source_table":"people","limit":42}',
-      ],
-    ]);
-    expect(definitionFromMetadata(safe, "v").limit).toBe(42);
-  });
-
-  it("creates, refreshes and queries a view", async () => {
-    const view = await db.createMaterializedView("adults", "people", {
-      select: ["name", ["shout", "upper(name)"]],
-      where: "age >= 18",
-    });
-    expect(view.name).toBe("adults");
-    expect(await view.table().countRows()).toBe(0);
-
-    const result = await view.refresh();
-    expect(result.mode).toBe("rebuild");
-    expect(Number(result.rowsWritten)).toBe(2);
-
-    const rows = await view.table().query().toArray();
-    expect(rows.map((r) => r.shout).sort()).toEqual(["ADA", "GRACE"]);
-  });
-
-  it("round-trips the definition", async () => {
-    await db.createMaterializedView("adults", "people", {
-      where: "age >= 18",
-    });
-    const view = await db.openMaterializedView("adults");
-    const definition = await view.definition();
-    expect(definition.sourceTable).toBe("people");
-    expect(definition.filter).toBe("age >= 18");
-    expect(definition.projections).toEqual([
-      ["name", "`name`"],
-      ["age", "`age`"],
-    ]);
-    expect(definition.inputs).toEqual(["age", "name"]);
-  });
-
-  it("refreshes incrementally after an append", async () => {
-    const view = await db.createMaterializedView("copy", "people");
-    await view.refresh();
-
-    const people = await db.openTable("people");
-    await people.add([{ name: "alan", age: 41 }]);
-    const result = await view.refresh();
-    expect(result.mode).toBe("incremental");
-    expect(Number(result.rowsWritten)).toBe(1);
-    expect(await view.table().countRows()).toBe(4);
-
-    expect((await view.refresh()).mode).toBe("no_op");
-  });
-
-  it("lists views and rejects non-views", async () => {
-    await db.createMaterializedView("adults", "people", {
-      where: "age >= 18",
-    });
-    expect(await db.listMaterializedViews()).toEqual(["adults"]);
-    await expect(db.openMaterializedView("people")).rejects.toThrow(
-      "not a materialized view",
-    );
-  });
-
-  it("rejects an invalid expression at create time", async () => {
-    await expect(
-      db.createMaterializedView("bad", "people", {
-        select: [["x", "missing + 1"]],
-      }),
-    ).rejects.toThrow("missing");
-  });
-
-  it("rejects invalid numeric options before creating anything", async () => {
-    for (const limit of [-5, 1.5, Infinity, NaN]) {
-      await expect(
-        db.createMaterializedView("bad", "people", { limit }),
-      ).rejects.toThrow("non-negative integer");
-    }
-    expect(await db.listMaterializedViews()).toEqual([]);
-
-    const view = await db.createMaterializedView("copy", "people");
-    for (const sourceVersion of [-1, 1.5, Infinity, NaN]) {
-      await expect(view.refresh({ sourceVersion })).rejects.toThrow(
-        "non-negative integer",
-      );
-    }
-  });
-
-  it("quotes bare select names", async () => {
-    await db.createTable("odd_names", [{ "order item": "widget" }], {
-      storageOptions: { newTableEnableStableRowIds: "true" },
-    });
-    const view = await db.createMaterializedView("quoted", "odd_names", {
-      select: ["order item"],
-    });
-    const result = await view.refresh();
-    expect(Number(result.rowsWritten)).toBe(1);
-  });
-
-  it("requires stable row ids on the source", async () => {
-    await db.createTable("plain", [{ x: 1 }]);
-    await expect(db.createMaterializedView("v", "plain")).rejects.toThrow(
-      "stable row ids",
-    );
-  });
-});

nodejs/__test__/package.test.ts

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-import packageJson = require("../package.json");
-
-describe("package metadata", () => {
-  it("requires Node.js type declarations compatible with the runtime", () => {
-    expect(packageJson.engines.node).toBe(">= 18");
-    expect(packageJson.peerDependencies["@types/node"]).toBe(">=18");
-    expect(packageJson.peerDependenciesMeta["@types/node"]).toEqual({
-      optional: true,
-    });
-  });
-});

nodejs/__test__/query.test.ts

@@ -110,81 +110,6 @@ describe("Query outputSchema", () => {
   });
 });
 
-describe("Search pagination", () => {
-  let tmpDir: tmp.DirResult;
-  let table: Table;
-
-  beforeEach(async () => {
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
-    const db = await connect(tmpDir.name);
-    const schema = new Schema([
-      new Field("id", new Int64(), false),
-      new Field("text", new Utf8(), false),
-      new Field(
-        "vector",
-        new FixedSizeList(2, new Field("item", new Float32())),
-        false,
-      ),
-    ]);
-    const data = makeArrowTable(
-      [
-        { id: 1n, text: "common", vector: [0, 0] },
-        { id: 2n, text: "common common", vector: [1, 1] },
-        { id: 3n, text: "common common common", vector: [2, 2] },
-        { id: 4n, text: "common common common common", vector: [3, 3] },
-      ],
-      { schema },
-    );
-    table = await db.createTable("test", data);
-  });
-
-  afterEach(() => {
-    tmpDir.removeCallback();
-  });
-
-  it("applies offset after the vector search limit", async () => {
-    const allResults = await table
-      .vectorSearch([0, 0])
-      .select(["id"])
-      .limit(4)
-      .toArray();
-    const secondPage = await table
-      .vectorSearch([0, 0])
-      .select(["id"])
-      .limit(2)
-      .offset(2)
-      .toArray();
-
-    expect(allResults).toHaveLength(4);
-    expect(secondPage).toHaveLength(2);
-    expect(secondPage.map((row) => row.id)).toEqual(
-      allResults.slice(2, 4).map((row) => row.id),
-    );
-  });
-
-  it("applies offset after the full-text search limit", async () => {
-    await table.createIndex("text", { config: Index.fts() });
-
-    const allResults = await table
-      .search("common", "fts")
-      .select(["id"])
-      .limit(4)
-      .toArray();
-    const secondPage = await table
-      .search("common", "fts")
-      .select(["id"])
-      .limit(2)
-      .offset(2)
-      .toArray();
-
-    expect(allResults).toHaveLength(4);
-    expect(secondPage).toHaveLength(2);
-    expect(secondPage.map((row) => row.id)).toEqual(
-      allResults.slice(2, 4).map((row) => row.id),
-    );
-  });
-});
-
 describe("Query orderBy", () => {
   let tmpDir: tmp.DirResult;
   let table: Table;

nodejs/__test__/registry.test.ts

@@ -106,77 +106,6 @@ describe.each([arrow15, arrow16, arrow17, arrow18])("Registry", (arrow) => {
       'Embedding function with alias "mock-embedding" already exists',
     );
   });
-  test("parseFunctions keeps entries sharing a function name", async () => {
-    class MockEmbeddingFunction extends EmbeddingFunction<string> {
-      ndims() {
-        return 3;
-      }
-      embeddingDataType() {
-        return new arrow.Float32() as apiArrow.Float;
-      }
-      async computeSourceEmbeddings(data: string[]) {
-        return data.map(() => [1, 2, 3]);
-      }
-    }
-    register("mock-embedding")(MockEmbeddingFunction);
-    const parsed = await getRegistry().parseFunctions(
-      new Map([
-        [
-          "embedding_functions",
-          JSON.stringify([
-            {
-              name: "mock-embedding",
-              sourceColumn: "text",
-              vectorColumn: "vector_a",
-              model: {},
-            },
-            {
-              name: "mock-embedding",
-              sourceColumn: "text",
-              vectorColumn: "vector_b",
-              model: {},
-            },
-          ]),
-        ],
-      ]),
-    );
-    expect([...parsed.values()].map((f) => f.vectorColumn)).toEqual([
-      "vector_a",
-      "vector_b",
-    ]);
-
-    // The Python bindings write snake_case keys.
-    const snake = await getRegistry().parseFunctions(
-      new Map([
-        [
-          "embedding_functions",
-          JSON.stringify([
-            {
-              name: "mock-embedding",
-              // biome-ignore lint/style/useNamingConvention: the Python wire spelling
-              source_column: "text",
-              // biome-ignore lint/style/useNamingConvention: the Python wire spelling
-              vector_column: "vector_a",
-              model: {},
-            },
-            {
-              name: "mock-embedding",
-              // biome-ignore lint/style/useNamingConvention: the Python wire spelling
-              source_column: "text",
-              // biome-ignore lint/style/useNamingConvention: the Python wire spelling
-              vector_column: "vector_b",
-              model: {},
-            },
-          ]),
-        ],
-      ]),
-    );
-    expect([...snake.keys()]).toEqual(["vector_a", "vector_b"]);
-    expect([...snake.values()].map((f) => f.sourceColumn)).toEqual([
-      "text",
-      "text",
-    ]);
-  });
   test("schema should contain correct metadata", async () => {
     class MockEmbeddingFunction extends EmbeddingFunction<string> {
       constructor(args: FunctionOptions = {}) {

nodejs/__test__/remote.test.ts

@@ -15,7 +15,6 @@ import {
   OAuthHeaderProvider,
   StaticHeaderProvider,
 } from "../lancedb/header";
-import { Index } from "../lancedb/indices";
 
 // Test-only header providers
 class CustomProvider extends HeaderProvider {
@@ -75,25 +74,6 @@ async function withMockDatabase(
 }
 
 describe("remote connection", () => {
-  it("refuses materialized views before issuing any request", async () => {
-    const paths: string[] = [];
-    await withMockDatabase(
-      (req, res) => {
-        paths.push(req.url ?? "");
-        res.writeHead(404).end();
-      },
-      async (db) => {
-        await expect(db.openMaterializedView("secret_table")).rejects.toThrow(
-          /only on local databases/,
-        );
-        await expect(db.listMaterializedViews()).rejects.toThrow(
-          /only on local databases/,
-        );
-        expect(paths).toEqual([]);
-      },
-    );
-  });
-
   it("should accept partial connection options", async () => {
     await connect("db://test", {
       apiKey: "fake",
@@ -189,38 +169,6 @@ describe("remote connection", () => {
     );
   });
 
-  it("surfaces JSON server errors from remote table operations", async () => {
-    await withMockDatabase(
-      (req, res) => {
-        const path = req.url ?? "";
-        if (path.endsWith("/describe/")) {
-          res.writeHead(200, { "Content-Type": "application/json" }).end(
-            JSON.stringify({
-              name: "broken_table",
-              version: 1,
-              schema: { fields: [] },
-            }),
-          );
-          return;
-        }
-
-        if (path.endsWith("/count_rows/")) {
-          res
-            .writeHead(400, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: "count rows failed" }));
-          return;
-        }
-
-        res.writeHead(404).end();
-      },
-      async (db) => {
-        const table = await db.openTable("broken_table");
-
-        await expect(table.countRows()).rejects.toThrow("count rows failed");
-      },
-    );
-  });
-
   it("should pass on requested extra headers", async () => {
     await withMockDatabase(
       (req, res) => {
@@ -277,60 +225,7 @@ describe("remote connection", () => {
     );
   });
 
-  it("sends FTS options to remote tables", async () => {
-    let createIndexBody: Record<string, unknown> | undefined;
-
-    await withMockDatabase(
-      (req, res) => {
-        const path = req.url ?? "";
-        if (path.endsWith("/describe/")) {
-          res.writeHead(200, { "Content-Type": "application/json" }).end(
-            JSON.stringify({
-              name: "t",
-              version: 1,
-              schema: {
-                fields: [
-                  { name: "text", type: { type: "string" }, nullable: false },
-                ],
-              },
-            }),
-          );
-          return;
-        }
-
-        if (path.endsWith("/create_index/")) {
-          let raw = "";
-          req.on("data", (chunk) => {
-            raw += chunk;
-          });
-          req.on("end", () => {
-            createIndexBody = JSON.parse(raw);
-            res.writeHead(200).end();
-          });
-          return;
-        }
-
-        res.writeHead(404).end();
-      },
-      async (db) => {
-        const table = await db.openTable("t");
-        await table.createIndex("text", {
-          config: Index.fts({
-            blockSize: 256,
-            removeStopWords: true,
-            customStopWords: ["the"],
-          }),
-        });
-      },
-    );
-
-    expect(createIndexBody?.["column"]).toBe("text");
-    expect(createIndexBody?.["index_type"]).toBe("FTS");
-    expect(createIndexBody?.["block_size"]).toBe(256);
-    expect(createIndexBody?.["custom_stop_words"]).toEqual(["the"]);
-  });
-
-  it("diffs and cherry-picks remote branches", async () => {
+  it("diffs and merges remote branches", async () => {
     const sampleDiff = {
       fromBranch: "exp",
       parentVersion: 1,
@@ -352,9 +247,10 @@ describe("remote connection", () => {
       changedColumns: [],
       addedIndexes: [],
       removedIndexes: [],
-      errors: [],
+      mergeable: true,
+      mergeBlockers: [],
     };
-    const cherryPickBodies: Record<string, unknown>[] = [];
+    const mergeBodies: Record<string, unknown>[] = [];
 
     await withMockDatabase(
       (req, res) => {
@@ -384,16 +280,17 @@ describe("remote connection", () => {
               .end(JSON.stringify(sampleDiff));
             return;
           }
-          if (path.endsWith("/branches/cherry_pick/")) {
-            cherryPickBodies.push(body);
+          if (path.endsWith("/branches/merge/")) {
+            mergeBodies.push(body);
             const dryRun = body["dry_run"] === true;
             const response = {
-              status: dryRun ? "ready" : "failed",
+              status: dryRun ? "ready" : "rejected",
               diff: dryRun
                 ? sampleDiff
                 : {
                     ...sampleDiff,
-                    errors: [
+                    mergeable: false,
+                    mergeBlockers: [
                       { code: "baseMoved", message: "main has advanced" },
                     ],
                   },
@@ -415,19 +312,19 @@ describe("remote connection", () => {
 
         await expect(branches.diff("exp")).resolves.toEqual(sampleDiff);
 
-        const failed = await branches.cherryPick("exp");
-        expect(failed.status).toBe("failed");
-        expect(failed.diff.errors).toEqual([
+        const rejected = await branches.merge("exp");
+        expect(rejected.status).toBe("rejected");
+        expect(rejected.diff.mergeBlockers).toEqual([
           { code: "baseMoved", message: "main has advanced" },
         ]);
 
-        const preview = await branches.cherryPick("exp", true);
+        const preview = await branches.merge("exp", true);
         expect(preview.status).toBe("ready");
         expect(preview.preview.promotedColumns).toEqual(["tag"]);
       },
     );
 
-    expect(cherryPickBodies).toEqual([
+    expect(mergeBodies).toEqual([
       // biome-ignore lint/style/useNamingConvention: snake_case mandated by the server wire format
       { from_branch: "exp", dry_run: false },
       // biome-ignore lint/style/useNamingConvention: snake_case mandated by the server wire format
@@ -926,96 +823,3 @@ describe("remote connection", () => {
     });
   });
 });
-
-describe("remote connection jobs surface", () => {
-  it("lists, describes, cancels, and reads history", async () => {
-    const { tableFromArrays, tableToIPC } = await import("apache-arrow");
-    const eventsTable = tableFromArrays({ state: ["created", "succeeded"] });
-    const eventsBody = Buffer.from(tableToIPC(eventsTable, "stream"));
-
-    await withMockDatabase(
-      (req, res) => {
-        let body = "";
-        req.on("data", (chunk) => {
-          body += chunk;
-        });
-        req.on("end", () => {
-          const payload = body.length > 0 ? JSON.parse(body) : {};
-          if (req.url === "/v1/jobs/list") {
-            if (payload["page_token"] === undefined) {
-              res
-                .writeHead(200, { "Content-Type": "application/json" })
-                .end(
-                  '{"jobs": [{"job_id": "job-1", "table": "t1", ' +
-                    '"job_type": "create_index", "state": "in_progress", ' +
-                    '"created_at_millis": 1000}], "page_token": "next"}',
-                );
-            } else {
-              res
-                .writeHead(200, { "Content-Type": "application/json" })
-                .end(
-                  '{"jobs": [{"job_id": "job-2", "table": "t2", ' +
-                    '"job_type": "create_index", "state": "succeeded", ' +
-                    '"created_at_millis": 2000}]}',
-                );
-            }
-          } else if (req.url === "/v1/jobs/describe") {
-            if (payload["job_id"] !== "job-1") {
-              res.writeHead(404).end("no such job");
-              return;
-            }
-            res
-              .writeHead(200, { "Content-Type": "application/json" })
-              .end(
-                '{"job_id": "job-1", "job_type": "create_index", ' +
-                  '"job_state": "FAILED", "creation_ms": 1000, ' +
-                  '"spec": {"column": "vec"}, "failure": {"phase": "execute", ' +
-                  '"message": "worker died", "retryable": true}}',
-              );
-          } else if (req.url === "/v1/jobs/cancel") {
-            if (payload["job_id"] !== "job-1") {
-              res.writeHead(404).end("no such job");
-              return;
-            }
-            res
-              .writeHead(200, { "Content-Type": "application/json" })
-              .end('{"job_id": "job-1"}');
-          } else if (req.url === "/v1/jobs/query_events") {
-            res
-              .writeHead(200, {
-                "Content-Type": "application/vnd.apache.arrow.stream",
-              })
-              .end(eventsBody);
-          } else {
-            res.writeHead(404).end();
-          }
-        });
-      },
-      async (db) => {
-        const jobs = await db.listJobs();
-        expect(jobs.map((job) => job.jobId)).toEqual(["job-1", "job-2"]);
-        expect(jobs[0].state).toEqual("running");
-        expect(jobs[1].state).toEqual("finished");
-
-        const description = await db.getJob("job-1");
-        expect(description?.state).toEqual("failed");
-        expect(JSON.parse(description?.specJson ?? "")).toEqual({
-          column: "vec",
-        });
-        expect(description?.failure?.message).toEqual("worker died");
-        expect(await db.getJob("missing")).toBeNull();
-
-        expect(await db.cancelJob("job-1")).toBe(true);
-        expect(await db.cancelJob("missing")).toBe(false);
-
-        const history = await db.jobHistory("job-1");
-        expect(history.numRows).toEqual(2);
-
-        const job = db.job("job-1");
-        expect(job.id).toEqual("job-1");
-        expect(await job.status()).toEqual("failed");
-        await expect(job.wait()).rejects.toThrow("worker died");
-      },
-    );
-  });
-});

nodejs/__test__/table.test.ts

@@ -86,44 +86,6 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
       await expect(table.countRows()).resolves.toBe(3);
     });
 
-    it("should support a foreign Float64 vector schema end to end", async () => {
-      const conn = await connect(tmpDir.name);
-      const schema = new arrow.Schema([
-        new arrow.Field("resource_id", new arrow.Int32(), false),
-        new arrow.Field(
-          "vector",
-          new arrow.FixedSizeList(
-            3,
-            new arrow.Field("value", new arrow.Float64(), true),
-          ),
-          false,
-        ),
-      ]);
-      const data = [
-        {
-          // biome-ignore lint/style/useNamingConvention: matches the reported schema
-          resource_id: 0,
-          vector: [0.1, 0.1, 0.1],
-        },
-      ];
-
-      const resources = await conn.createTable("resources", data, { schema });
-
-      const existing = await resources
-        .query()
-        .where("resource_id = 0")
-        .limit(1)
-        .toArray();
-      expect(existing).toHaveLength(1);
-
-      const matched = await resources
-        .search(Float64Array.from(data[0].vector))
-        .limit(1)
-        .toArray();
-      expect(matched).toHaveLength(1);
-      expect(matched[0]["resource_id"]).toBe(0);
-    });
-
     it("should support branches", async () => {
       await table.add([{ id: 1 }]);
       expect(await table.countRows()).toBe(1);
@@ -277,16 +239,8 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
         },
         numIndices: 0,
         numRows: 3,
-        // Full on-disk size of the two data files, footers and metadata included.
-        totalBytes: 684,
+        totalBytes: 44,
       });
-
-      // Index files count toward totalBytes too (only deletion files and
-      // manifests are excluded).
-      await table.createIndex("id", { config: Index.btree() });
-      const statsWithIndex = await table.stats();
-      expect(statsWithIndex.numIndices).toBe(1);
-      expect(statsWithIndex.totalBytes).toBeGreaterThan(684);
     });
 
     it("should overwrite data if asked", async () => {
@@ -573,14 +527,6 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
       );
     });
 
-    it("should expose useLsm on takeRowIds as the base-only escape hatch", async () => {
-      await table.add([{ id: 1 }, { id: 2 }, { id: 3 }]);
-      // useLsm(false) is reachable on TakeQuery (the escape hatch for MemWAL tables,
-      // where take-by-row-id auto-routes to the LSM scanner and is rejected).
-      const res = await table.takeRowIds([0, 2]).useLsm(false).toArray();
-      expect(res.map((r) => r.id)).toEqual([1, 3]);
-    });
-
     it("should throw for negative number in takeRowIds", () => {
       expect(() => table.takeRowIds([-1])).toThrow("Row id cannot be negative");
       expect(() => table.takeRowIds([0, -5, 2])).toThrow(
@@ -897,11 +843,7 @@ describe("When creating an index", () => {
   afterEach(() => tmpDir.removeCallback());
 
   it("should create a vector index on vector columns", async () => {
-    const job = await tbl.createIndexAsync("vec");
-    expect(job.id).toBeNull();
-    await job.wait();
-    // Cancelling a job that already finished succeeds and does nothing.
-    await job.cancel();
+    await tbl.createIndex("vec");
 
     // check index directory
     const indexDir = path.join(tmpDir.name, "test.lance", "_indices");
@@ -2585,35 +2527,6 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
       expect(results3.length).toBe(1);
     });
 
-    test("full text search with custom posting block size", async () => {
-      const db = await connect(tmpDir.name);
-      const data = [
-        { text: "hello world", vector: [0.1, 0.2, 0.3] },
-        { text: "goodbye world", vector: [0.4, 0.5, 0.6] },
-      ];
-      const table = await db.createTable("test", data);
-      await table.createIndex("text", {
-        config: Index.fts({ blockSize: 256 }),
-      });
-
-      const index = (await table.listIndices()).find(
-        (index) => index.indexType === "FTS",
-      );
-      expect(index?.indexVersion).toBe(3);
-      expect(
-        (index?.indexDetails as Record<string, unknown>)["block_size"],
-      ).toBe(256);
-
-      const results = await table.search("hello").toArray();
-      expect(results[0].text).toBe(data[0].text);
-    });
-
-    test("rejects invalid full text posting block size", () => {
-      expect(() => Index.fts({ blockSize: 129 as 128 | 256 })).toThrow(
-        "128 or 256",
-      );
-    });
-
     test("full text search without lowercase", async () => {
       const db = await connect(tmpDir.name);
       const data = [
@@ -2819,15 +2732,6 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
   },
 );
 
-test("tokenize supports custom stop words", async () => {
-  const tokens = await tokenize("the lance data", {
-    stem: false,
-    removeStopWords: true,
-    customStopWords: ["lance"],
-  });
-  expect(tokens.map((token) => token.text)).toEqual(["the", "data"]);
-});
-
 describe("when calling explainPlan", () => {
   let tmpDir: tmp.DirResult;
   let table: Table;
@@ -2953,7 +2857,7 @@ describe("column name options", () => {
       .limit(10)
       .toArray();
     expect(results2.length).toBe(10);
-  }, 30_000);
+  });
 });
 
 describe("when creating an empty table", () => {
@@ -3266,14 +3170,14 @@ describe("LSM merge insert", () => {
     await table.closeLsmWriters();
   });
 
-  it("falls back to the standard path with useLsm(false)", async () => {
+  it("falls back to the standard path with useLsmWrite(false)", async () => {
     const conn = await connect(tmpDir.name);
     const table = await bucketTable(conn);
 
     const res = await table
       .mergeInsert("id")
       .whenNotMatchedInsertAll()
-      .useLsm(false)
+      .useLsmWrite(false)
       .execute([
         { id: "b", value: 9 },
         { id: "e", value: 5 },
@@ -3307,153 +3211,4 @@ describe("LSM merge insert", () => {
         .execute([{ id: "g", value: 7 }]),
     ).rejects.toThrow();
   });
-
-  it("auto-routes reads through the MemWAL scanner", async () => {
-    const conn = await connect(tmpDir.name);
-    const table = await bucketTable(conn); // base ids "a", "b"
-
-    await table
-      .mergeInsert("id")
-      .whenMatchedUpdateAll()
-      .whenNotMatchedInsertAll()
-      .execute([{ id: "c", value: 3 }]);
-
-    // Default read auto-routes and includes the active memtable row.
-    const lsm = await table.query().toArray();
-    expect(lsm.map((r) => r.id).sort()).toEqual(["a", "b", "c"]);
-
-    // useLsm(false) bypasses the MemWAL and reads the base table only.
-    const baseOnly = await table.query().useLsm(false).toArray();
-    expect(baseOnly.map((r) => r.id).sort()).toEqual(["a", "b"]);
-  });
-
-  it("reads the base table when no LSM spec is installed", async () => {
-    const conn = await connect(tmpDir.name);
-    const table = await conn.createEmptyTable(
-      "plain",
-      new arrow.Schema([new arrow.Field("id", new arrow.Utf8(), false)]),
-    );
-    // No spec: default read and useLsm(false) both succeed against the base table.
-    await expect(table.query().toArray()).resolves.toBeDefined();
-    await expect(table.query().useLsm(false).toArray()).resolves.toBeDefined();
-    // useLsm(true) demands MemWAL routing; without a spec it errors.
-    await expect(table.query().useLsm(true).toArray()).rejects.toThrow();
-  });
-});
-
-describe("LSM convergence and stats", () => {
-  let tmpDir: tmp.DirResult;
-
-  beforeEach(() => {
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
-  });
-  afterEach(() => tmpDir.removeCallback());
-
-  async function lsmTable(conn: Connection): Promise<Table> {
-    const table = await conn.createEmptyTable(
-      "t",
-      new arrow.Schema([new arrow.Field("id", new arrow.Utf8(), false)]),
-    );
-    await table.setUnenforcedPrimaryKey("id");
-    await table.setLsmWriteSpec({ specType: "unsharded" });
-    return table;
-  }
-
-  // These four route through the server that owns the MemWAL, so a local table
-  // rejects them rather than answering. What is asserted here is that the
-  // bindings reach the core at all; the behavior against a real endpoint is
-  // covered by the mocked endpoint tests in rust/lancedb/src/remote/table.rs.
-  it("rejects flushLsm on a local table", async () => {
-    const conn = await connect(tmpDir.name);
-    const table = await lsmTable(conn);
-
-    await expect(table.flushLsm()).rejects.toThrow(/not supported/i);
-  });
-
-  it("rejects compactLsm on a local table", async () => {
-    const conn = await connect(tmpDir.name);
-    const table = await lsmTable(conn);
-
-    await expect(table.compactLsm()).rejects.toThrow(/not supported/i);
-  });
-
-  it("rejects getLsmStats on a local table", async () => {
-    const conn = await connect(tmpDir.name);
-    const table = await lsmTable(conn);
-
-    await expect(table.getLsmStats()).rejects.toThrow(/not supported/i);
-    await expect(table.getLsmStats(true)).rejects.toThrow(/not supported/i);
-  });
-
-  it("rejects checkpointLsm on a local table", async () => {
-    const conn = await connect(tmpDir.name);
-    const table = await lsmTable(conn);
-
-    // checkpointLsm seals first, so it surfaces flushLsm's rejection.
-    await expect(table.checkpointLsm()).rejects.toThrow(/not supported/i);
-  });
-});
-
-describe("computed columns", () => {
-  let tmpDir: tmp.DirResult;
-  beforeEach(() => {
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
-  });
-  afterEach(() => tmpDir.removeCallback());
-
-  it("declares a column and fills it on refresh", async () => {
-    const db = await connect(tmpDir.name);
-    const table = await db.createTable("computed", [{ x: 1 }, { x: 2 }]);
-
-    await table.addColumns({
-      computed: [{ name: "doubled", valueSql: "x * 2" }],
-    });
-    let rows = await table.query().toArray();
-    expect(rows.map((r) => r.doubled)).toEqual([null, null]);
-
-    const result = await table.refreshColumn("doubled");
-    expect(result.rowsFilled).toBe(2);
-
-    rows = await table.query().toArray();
-    expect(rows.map((r) => r.doubled).sort()).toEqual([2, 4]);
-  });
-
-  it("returns a job handle from refreshColumnAsync", async () => {
-    const db = await connect(tmpDir.name);
-    const table = await db.createTable("computed_job", [{ x: 1 }, { x: 2 }]);
-
-    await table.addColumns({
-      computed: [{ name: "doubled", valueSql: "x * 2" }],
-    });
-
-    const job = await table.refreshColumnAsync("doubled");
-    expect(job.id).toBeNull();
-    await job.wait();
-    expect(await job.status()).toBe("finished");
-
-    const rows = await table.query().toArray();
-    expect(rows.map((r) => r.doubled).sort()).toEqual([2, 4]);
-
-    // Bad input rejects at the call, not through the job.
-    await expect(table.refreshColumnAsync("x")).rejects.toThrow(
-      "not a computed column",
-    );
-  });
-
-  it("fills rows added since the last refresh", async () => {
-    const db = await connect(tmpDir.name);
-    const table = await db.createTable("computed_append", [{ x: 1 }]);
-
-    await table.addColumns({
-      computed: [{ name: "doubled", valueSql: "x * 2" }],
-    });
-    await table.refreshColumn("doubled");
-    await table.add([{ x: 5 }]);
-
-    const result = await table.refreshColumn("doubled");
-    expect(result.rowsFilled).toBe(1);
-
-    const rows = await table.query().toArray();
-    expect(rows.map((r) => r.doubled).sort()).toEqual([10, 2]);
-  });
 });

nodejs/examples/full_text_search.test.ts

@@ -29,14 +29,8 @@ test("full text search", async () => {
     const tbl = await db.createTable("myVectors", data, { mode: "overwrite" });
 
     await tbl.createIndex("doc", {
-      config: lancedb.Index.fts({
-        stem: false,
-        removeStopWords: true,
-        customStopWords: ["banana"],
-      }),
+      config: lancedb.Index.fts(),
     });
-    const tokens = await tbl.tokenize("apple banana", { column: "doc" });
-    expect(tokens.map((token) => token.text)).toEqual(["apple"]);
 
     // --8<-- [start:full_text_search]
     const result = await tbl

nodejs/lancedb/arrow.ts

@@ -48,11 +48,7 @@ import {
 } from "apache-arrow";
 import { Buffers } from "apache-arrow/data";
 import { type EmbeddingFunction } from "./embedding/embedding_function";
-import {
-  EmbeddingFunctionConfig,
-  getRegistry,
-  parseEmbeddingMetadata,
-} from "./embedding/registry";
+import { EmbeddingFunctionConfig, getRegistry } from "./embedding/registry";
 import {
   sanitizeField,
   sanitizeSchema,
@@ -937,7 +933,7 @@ async function applyEmbeddingsFromMetadata(
 
   for (const functionEntry of functions.values()) {
     const sourceColumn = columns[functionEntry.sourceColumn];
-    const destColumn = functionEntry.vectorColumn;
+    const destColumn = functionEntry.vectorColumn ?? "vector";
     if (sourceColumn === undefined) {
       throw new Error(
         `Cannot apply embedding function because the source column '${functionEntry.sourceColumn}' was not present in the data`,
@@ -1389,10 +1385,11 @@ function validateSchemaEmbeddings(
 
         // Check schema metadata for embedding functions
         if (schema.metadata.has("embedding_functions")) {
-          const entries = parseEmbeddingMetadata(
+          const embeddings = JSON.parse(
             schema.metadata.get("embedding_functions")!,
           );
-          if (entries.some((f) => f.vectorColumn === field.name)) {
+          // biome-ignore lint/suspicious/noExplicitAny: we don't know the type of `f`
+          if (embeddings.find((f: any) => f["vectorColumn"] === field.name)) {
             hasEmbeddingFunction = true;
           }
         }

nodejs/lancedb/connection.ts

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright The LanceDB Authors
 
-import { tableFromIPC } from "apache-arrow";
 import {
   Data,
   SchemaLike,
@@ -16,20 +15,11 @@ import {
   makeEmptyTable,
 } from "./arrow";
 import { EmbeddingFunctionConfig, getRegistry } from "./embedding/registry";
-import {
-  MaterializedView,
-  MaterializedViewSelect,
-  normalizeSelect,
-  validateNonNegativeInteger,
-} from "./materialized_view";
 import { Connection as LanceDbConnection } from "./native";
 import type {
   CreateNamespaceResponse,
   DescribeNamespaceResponse,
   DropNamespaceResponse,
-  Job,
-  JobDescription,
-  JobInfo,
   ListNamespacesResponse,
 } from "./native";
 export type {
@@ -253,41 +243,6 @@ export abstract class Connection {
    * @param {string[]} namespacePath - The namespace path of the table (defaults to root namespace)
    * @param {Partial<OpenTableOptions>} options - Additional options
    */
-  /**
-   * 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.
-   */
-  abstract createMaterializedView(
-    name: string,
-    source: string,
-    options?: {
-      select?: MaterializedViewSelect;
-      where?: string;
-      limit?: number;
-    },
-  ): Promise<MaterializedView>;
-
-  /**
-   * Open the materialized view named `name`.
-   *
-   * Rejects a table that exists but is not a materialized view.
-   */
-  abstract openMaterializedView(name: string): Promise<MaterializedView>;
-
-  /**
-   * The names of the materialized views in this database.
-   *
-   * Found by reading every table's schema, so this costs an open per table.
-   */
-  abstract listMaterializedViews(): Promise<string[]>;
-
   abstract openTable(
     name: string,
     namespacePath?: string[],
@@ -368,14 +323,6 @@ export abstract class Connection {
    */
   abstract dropTable(name: string, namespacePath?: string[]): Promise<void>;
 
-  /**
-   * 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.
-   */
-  abstract dropTableAsync(name: string, namespacePath?: string[]): Promise<Job>;
-
   /**
    * Drop all tables in the database.
    * @param {string[]} namespacePath The namespace path to drop tables from (defaults to root namespace).
@@ -489,40 +436,6 @@ export abstract class Connection {
     newName: string,
     options?: RenameTableOptions,
   ): Promise<void>;
-
-  /**
-   * A {@link Job} 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.
-   */
-  abstract job(jobId: string): Job;
-
-  /** List server-side jobs across the database's tables. */
-  abstract listJobs(): Promise<JobInfo[]>;
-
-  /**
-   * Describe a single server-side job by id.
-   *
-   * Resolves to `null` when the server has no such job.
-   */
-  abstract getJob(jobId: string): Promise<JobDescription | null>;
-
-  /**
-   * 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.
-   */
-  abstract cancelJob(jobId: string): Promise<boolean>;
-
-  /**
-   * The lifecycle event history of a server-side job, as an Arrow table.
-   *
-   * Lists history across all jobs when `jobId` is omitted.
-   */
-  abstract jobHistory(jobId?: string): Promise<ArrowTable>;
 }
 
 /** @hideconstructor */
@@ -572,35 +485,6 @@ export class LocalConnection extends Connection {
     );
   }
 
-  async createMaterializedView(
-    name: string,
-    source: string,
-    options?: {
-      select?: MaterializedViewSelect;
-      where?: string;
-      limit?: number;
-    },
-  ): Promise<MaterializedView> {
-    validateNonNegativeInteger(options?.limit, "limit");
-    const innerTable = await this.inner.createMaterializedView(
-      name,
-      source,
-      normalizeSelect(options?.select),
-      options?.where,
-      options?.limit,
-    );
-    return new MaterializedView(new LocalTable(innerTable));
-  }
-
-  async openMaterializedView(name: string): Promise<MaterializedView> {
-    const innerTable = await this.inner.openMaterializedView(name);
-    return new MaterializedView(new LocalTable(innerTable));
-  }
-
-  async listMaterializedViews(): Promise<string[]> {
-    return await this.inner.listMaterializedViews();
-  }
-
   async openTable(
     name: string,
     namespacePath?: string[],
@@ -783,10 +667,6 @@ export class LocalConnection extends Connection {
     return this.inner.dropTable(name, namespacePath ?? []);
   }
 
-  async dropTableAsync(name: string, namespacePath?: string[]): Promise<Job> {
-    return this.inner.dropTableAsync(name, namespacePath ?? []);
-  }
-
   async dropAllTables(namespacePath?: string[]): Promise<void> {
     return this.inner.dropAllTables(namespacePath ?? []);
   }
@@ -842,30 +722,6 @@ export class LocalConnection extends Connection {
       options?.newNamespacePath,
     );
   }
-
-  job(jobId: string): Job {
-    return this.inner.job(jobId);
-  }
-
-  async listJobs(): Promise<JobInfo[]> {
-    return this.inner.listJobs();
-  }
-
-  async getJob(jobId: string): Promise<JobDescription | null> {
-    return this.inner.getJob(jobId);
-  }
-
-  async cancelJob(jobId: string): Promise<boolean> {
-    return this.inner.cancelJob(jobId);
-  }
-
-  async jobHistory(jobId?: string): Promise<ArrowTable> {
-    const buf = await this.inner.jobHistory(jobId);
-    if (buf.length === 0) {
-      return new ArrowTable();
-    }
-    return tableFromIPC(buf);
-  }
 }
 
 /**

nodejs/lancedb/embedding/registry.ts

@@ -104,29 +104,41 @@ export class EmbeddingFunctionRegistry {
   async parseFunctions(
     this: EmbeddingFunctionRegistry,
     metadata: Map<string, string>,
-  ): Promise<Map<string, ResolvedEmbeddingFunctionConfig>> {
+  ): Promise<Map<string, EmbeddingFunctionConfig>> {
     if (!metadata.has("embedding_functions")) {
       return new Map();
+    } else {
+      type FunctionConfig = {
+        name: string;
+        sourceColumn: string;
+        vectorColumn: string;
+        model: EmbeddingFunction["TOptions"];
+      };
+
+      const functions = <FunctionConfig[]>(
+        JSON.parse(metadata.get("embedding_functions")!)
+      );
+
+      const items: [string, EmbeddingFunctionConfig][] = await Promise.all(
+        functions.map(async (f) => {
+          const fn = this.get(f.name);
+          if (!fn) {
+            throw new Error(`Function "${f.name}" not found in registry`);
+          }
+          const func = await this.get(f.name)!.create(f.model);
+          return [
+            f.name,
+            {
+              sourceColumn: f.sourceColumn,
+              vectorColumn: f.vectorColumn,
+              function: func,
+            },
+          ];
+        }),
+      );
+
+      return new Map(items);
     }
-    const entries = parseEmbeddingMetadata(
-      metadata.get("embedding_functions")!,
-    );
-    const items = await Promise.all(
-      entries.map(async (f): Promise<ResolvedEmbeddingFunctionConfig> => {
-        const fn = this.get(f.name);
-        if (!fn) {
-          throw new Error(`Function "${f.name}" not found in registry`);
-        }
-        const func = await fn.create(f.model);
-        return {
-          sourceColumn: f.sourceColumn,
-          vectorColumn: f.vectorColumn,
-          function: func,
-        };
-      }),
-    );
-    // Keyed by output column: one function may serve several columns.
-    return new Map(items.map((config) => [config.vectorColumn, config]));
   }
   // biome-ignore lint/suspicious/noExplicitAny: <explanation>
   functionToMetadata(conf: EmbeddingFunctionConfig): Record<string, any> {
@@ -206,52 +218,3 @@ export interface EmbeddingFunctionConfig {
   vectorColumn?: string;
   function: EmbeddingFunction;
 }
-
-/** An [EmbeddingFunctionConfig] read back from table metadata, where the
- * vector column is always recorded. */
-export type ResolvedEmbeddingFunctionConfig = EmbeddingFunctionConfig & {
-  vectorColumn: string;
-};
-
-/** One entry of the `embedding_functions` schema metadata, with the column
- * keys normalized across the bindings' spellings. */
-export type EmbeddingMetadataEntry = {
-  name: string;
-  sourceColumn: string;
-  vectorColumn: string;
-  model: EmbeddingFunction["TOptions"];
-};
-
-/** The single parser for `embedding_functions` schema metadata: every reader
- * goes through here, so the wire contract cannot fork between them. */
-export function parseEmbeddingMetadata(json: string): EmbeddingMetadataEntry[] {
-  // The wire format, honestly: the Python bindings write snake_case keys.
-  type Raw = {
-    name: string;
-    sourceColumn?: string;
-    // biome-ignore lint/style/useNamingConvention: the Python wire spelling
-    source_column?: string;
-    vectorColumn?: string;
-    // biome-ignore lint/style/useNamingConvention: the Python wire spelling
-    vector_column?: string;
-    model: EmbeddingFunction["TOptions"];
-  };
-  const entries = <Raw[]>JSON.parse(json);
-  const seen = new Set<string>();
-  return entries.map((f) => {
-    const sourceColumn = f.sourceColumn ?? f.source_column;
-    const vectorColumn = f.vectorColumn ?? f.vector_column;
-    if (sourceColumn === undefined || vectorColumn === undefined) {
-      throw new Error(
-        `Embedding function "${f.name}" metadata names no source or vector column`,
-      );
-    }
-    if (seen.has(vectorColumn)) {
-      throw new Error(
-        `Multiple embedding configs claim vector column "${vectorColumn}"`,
-      );
-    }
-    seen.add(vectorColumn);
-    return { name: f.name, sourceColumn, vectorColumn, model: f.model };
-  });
-}

nodejs/lancedb/index.ts

@@ -21,11 +21,6 @@ import type { BaseTokenizer } from "./indices";
 import type { FtsToken } from "./table";
 
 // Re-export native header provider for use with connectWithHeaderProvider
-export {
-  MaterializedView,
-  MaterializedViewDefinition,
-  MaterializedViewSelect,
-} from "./materialized_view";
 export { JsHeaderProvider as NativeJsHeaderProvider } from "./native.js";
 
 // OpenTelemetry metrics bridge. Only the high-level entry point is public; the
@@ -55,8 +50,6 @@ export {
   MergeResult,
   AddResult,
   AddColumnsResult,
-  RefreshColumnResult,
-  RefreshMaterializedViewResult,
   AlterColumnsResult,
   UpdateFieldMetadataResult,
   DeleteResult,
@@ -92,13 +85,7 @@ export {
   RenameTableOptions,
 } from "./connection";
 
-export {
-  Job,
-  JobDescription,
-  JobFailureInfo,
-  JobInfo,
-  Session,
-} from "./native.js";
+export { Session } from "./native.js";
 
 export {
   ExecutableQuery,
@@ -141,10 +128,10 @@ export {
   BranchColumnChange,
   BranchIndexSummary,
   BranchRowCountSummary,
-  CherryPickError,
+  MergeBlocker,
   BranchDiff,
-  CherryPickPreview,
-  CherryPickResult,
+  MergePreview,
+  MergeBranchResult,
   AddDataOptions,
   UpdateOptions,
   OptimizeOptions,
@@ -153,10 +140,6 @@ export {
   FtsToken,
   TokenizeTableOptions,
   LsmWriteSpec,
-  LsmStats,
-  BucketStats,
-  GenerationStats,
-  MemtableStats,
   ColumnAlteration,
   FieldMetadataUpdate,
 } from "./table";
@@ -211,16 +194,6 @@ export interface TokenizeOptions {
   /** Whether to remove stop words. */
   removeStopWords?: boolean;
 
-  /**
-   * 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.
-   */
-  customStopWords?: string[];
-
   /** Whether to fold ASCII characters. */
   asciiFolding?: boolean;
 
@@ -252,7 +225,6 @@ export async function tokenize(
     options?.lowercase,
     options?.stem,
     options?.removeStopWords,
-    options?.customStopWords,
     options?.asciiFolding,
     options?.ngramMinLength,
     options?.ngramMaxLength,

nodejs/lancedb/indices.ts

@@ -553,16 +553,6 @@ export interface FtsOptions {
    */
   removeStopWords?: boolean;
 
-  /**
-   * 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.
-   */
-  customStopWords?: string[];
-
   /**
    * whether to remove punctuation
    */
@@ -582,14 +572,6 @@ export interface FtsOptions {
    * whether to only index the prefix of the token for ngram tokenizer
    */
   prefixOnly?: boolean;
-
-  /**
-   * 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.
-   */
-  blockSize?: 128 | 256;
 }
 
 export class Index {
@@ -765,12 +747,10 @@ export class Index {
         options?.lowercase,
         options?.stem,
         options?.removeStopWords,
-        options?.customStopWords,
         options?.asciiFolding,
         options?.ngramMinLength,
         options?.ngramMaxLength,
         options?.prefixOnly,
-        options?.blockSize,
       ),
     );
   }

nodejs/lancedb/materialized_view.ts

@@ -1,161 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-import { RefreshMaterializedViewResult } from "./native";
-import { Table } from "./table";
-
-/** Schema metadata key holding a materialized view's definition. */
-export const DEFINITION_META_KEY = "mv.definition";
-
-/** The query that defines a materialized view. */
-export interface MaterializedViewDefinition {
-  /** Name of the source table, in the same database as the view. */
-  sourceTable: string;
-  /** `[output column, SQL expression]` pairs, in view schema order. */
-  projections: [string, string][];
-  /** SQL predicate selecting the source rows the view holds. */
-  filter?: string;
-  /** Cap on the number of rows the view holds. */
-  limit?: number;
-  /** Source columns the projections and filter read. */
-  inputs: string[];
-}
-
-/**
- * The view's columns: column names, `[alias, SQL expression]` pairs, or a
- * record of the same. A bare name projects itself.
- */
-export type MaterializedViewSelect =
-  | (string | [string, string])[]
-  | Record<string, string>;
-
-/**
- * @internal Reject a numeric option N-API would otherwise silently coerce:
- * `Infinity` reaches Rust as 0, `1.5` as 1.
- */
-export function validateNonNegativeInteger(
-  value: number | undefined,
-  name: string,
-): void {
-  if (value !== undefined && !(Number.isSafeInteger(value) && value >= 0)) {
-    throw new Error(`${name} must be a non-negative integer`);
-  }
-}
-
-/** @internal Quote a column name as a Lance SQL identifier (backticks). */
-function quoteIdentifier(name: string): string {
-  return "`" + name.replace(/`/g, "``") + "`";
-}
-
-/**
- * @internal Normalize a select argument into `[alias, expression]` pairs.
- * A bare name projects itself and is quoted, so any valid column name works;
- * pair and record entries are kept verbatim because their right side is an
- * expression.
- */
-export function normalizeSelect(
-  select?: MaterializedViewSelect,
-): [string, string][] | undefined {
-  if (select === undefined) {
-    return undefined;
-  }
-  if (Array.isArray(select)) {
-    return select.map((item) =>
-      typeof item === "string" ? [item, quoteIdentifier(item)] : item,
-    );
-  }
-  return Object.entries(select);
-}
-
-/** @internal Parse a definition off a table's stored schema metadata. */
-export function definitionFromMetadata(
-  metadata: Map<string, string>,
-  name: string,
-): MaterializedViewDefinition {
-  const raw = metadata.get(DEFINITION_META_KEY);
-  if (raw === undefined) {
-    throw new Error(`Table '${name}' is not a materialized view`);
-  }
-  // biome-ignore lint/suspicious/noExplicitAny: raw JSON
-  const value: any = JSON.parse(raw);
-  if (value.kind !== "select") {
-    throw new Error(
-      `materialized view '${name}' is defined by '${value.kind}', which this ` +
-        "version of lancedb cannot refresh",
-    );
-  }
-  const limit = value.limit ?? undefined;
-  // JSON.parse rounds integers past 2^53; every exact u64 parses to a safe
-  // integer and every rounded one does not, so this rejects precisely the
-  // values a number cannot carry.
-  if (limit !== undefined && !Number.isSafeInteger(limit)) {
-    throw new Error(
-      `materialized view '${name}' has a stored limit too large to represent exactly`,
-    );
-  }
-  return {
-    sourceTable: value.source_table,
-    // biome-ignore lint/suspicious/noExplicitAny: raw JSON
-    projections: (value.projections ?? []).map((p: any) => [
-      p.output,
-      p.expression,
-    ]),
-    filter: value.filter ?? undefined,
-    limit,
-    inputs: value.inputs ?? [],
-  };
-}
-
-/**
- * A handle on a materialized view: its table plus its definition.
- *
- * Obtained from {@link Connection#createMaterializedView} or
- * {@link Connection#openMaterializedView}. The view is a normal table --
- * queries, indexes and search all apply through {@link MaterializedView#table}
- * -- whose contents are maintained by {@link MaterializedView#refresh}.
- */
-export class MaterializedView {
-  private readonly inner: Table;
-
-  constructor(table: Table) {
-    this.inner = table;
-  }
-
-  get name(): string {
-    return this.inner.name;
-  }
-
-  /** The view, as the table it is. */
-  table(): Table {
-    return this.inner;
-  }
-
-  /** The query that defines the view, read from its stored schema. */
-  async definition(): Promise<MaterializedViewDefinition> {
-    const schema = await this.inner.schema();
-    return definitionFromMetadata(schema.metadata, this.name);
-  }
-
-  /**
-   * 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.
-   */
-  async refresh(options?: {
-    full?: boolean;
-    sourceVersion?: number;
-  }): Promise<RefreshMaterializedViewResult> {
-    validateNonNegativeInteger(options?.sourceVersion, "sourceVersion");
-    return await this.inner.refreshMaterializedView(
-      options?.full,
-      options?.sourceVersion,
-    );
-  }
-}