Bump version: 0.36.0-beta.1 → 0.36.0

The tests extra pinned 9.0.0rc1 because 9.0.0 had not been released yet.
It now resolves from PyPI instead of the preview index.

.bumpversion.toml

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

.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/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/docs-link-check.yml

@@ -1,222 +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:
-      exit_code: ${{ steps.lychee.outputs.exit_code }}
-    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
-        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, not a red build, is the signal for broken links. The
-          # validation step below still fails the run if the check itself
-          # breaks.
-          fail: false
-
-      - name: Validate report
-        # 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 the exit code counts as a link verdict; anything
-        # else fails here, and the report job below is skipped entirely, so
-        # the tracking issue is never touched. 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: steps.lychee.outputs.exit_code == 0 || steps.lychee.outputs.exit_code == 2
-        env:
-          EXIT_CODE: ${{ steps.lychee.outputs.exit_code }}
-        run: |
-          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
-
-      - name: Upload report
-        if: steps.lychee.outputs.exit_code == 2
-        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:
-      EXIT_CODE: ${{ needs.scan.outputs.exit_code }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - name: Classify checker result
-        # lychee exits 0 when every link resolves and 2 when links fail,
-        # both already cross-checked against the report by the scan job's
-        # validation step. Anything else (1 runtime, 3 bad config) means the
-        # check never produced a link verdict, which must surface as a failed
-        # run rather than be published as "broken documentation links".
-        run: |
-          case "$EXIT_CODE" in
-            0|2)
-              echo "lychee exit code $EXIT_CODE"
-              ;;
-            *)
-              echo "::error::lychee exited with '$EXIT_CODE': the link check did not complete. Leaving the report issue untouched."
-              exit 1
-              ;;
-          esac
-
-      - 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 links break again.
-        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.EXIT_CODE == 2
-        uses: actions/download-artifact@v8
-        with:
-          name: link-report
-          path: ./lychee
-
-      - name: Compose report
-        if: env.EXIT_CODE == 2
-        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: 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, the 2 -> 0 -> 2 sequence would keep rewriting a
-        # closed issue while links are broken. A CLOSED state implies the
-        # lookup found a canonical issue, so no separate emptiness check.
-        if: env.EXIT_CODE == 2 && 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 "Broken documentation links found again in [the latest run]($run_url)."
-
-      - name: Report broken links
-        if: env.EXIT_CODE == 2
-        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.EXIT_CODE == 0 && 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,15 +1,13 @@
 name: Create release commit
 
-# This workflow increments the version, updates lockfiles, tags the final
-# commit, 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:
@@ -26,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
@@ -57,14 +65,26 @@ 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
-          bash ci/create_release_tag.sh
       - name: Push new version tag
         if: ${{ !inputs.dry_run }}
         uses: ad-m/github-push-action@881a6320fdb16eb5318c5054f31c218aec2b324c # v1.3.0

.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 }}
@@ -78,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
@@ -107,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
@@ -128,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:
@@ -196,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
@@ -203,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
@@ -249,14 +224,6 @@ 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"

.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
@@ -128,11 +118,6 @@ jobs:
           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
@@ -190,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
@@ -207,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
@@ -228,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
@@ -240,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
@@ -271,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: |
@@ -296,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

@@ -92,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:
 
@@ -105,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,20 +13,20 @@ categories = ["database-implementations"]
 rust-version = "1.91.0"
 
 [workspace.dependencies]
-lance = { "version" = "=10.0.0", default-features = false }
-lance-core = "=10.0.0"
-lance-datagen = "=10.0.0"
-lance-file = "=10.0.0"
-lance-io = { "version" = "=10.0.0", default-features = false }
-lance-index = "=10.0.0"
-lance-linalg = "=10.0.0"
-lance-namespace = "=10.0.0"
-lance-namespace-impls = { "version" = "=10.0.0", default-features = false }
-lance-table = "=10.0.0"
-lance-testing = "=10.0.0"
-lance-datafusion = "=10.0.0"
-lance-encoding = "=10.0.0"
-lance-arrow = "=10.0.0"
+lance = { "version" = "=9.0.0", default-features = false }
+lance-core = "=9.0.0"
+lance-datagen = "=9.0.0"
+lance-file = "=9.0.0"
+lance-io = { "version" = "=9.0.0", default-features = false }
+lance-index = "=9.0.0"
+lance-linalg = "=9.0.0"
+lance-namespace = "=9.0.0"
+lance-namespace-impls = { "version" = "=9.0.0", default-features = false }
+lance-table = "=9.0.0"
+lance-testing = "=9.0.0"
+lance-datafusion = "=9.0.0"
+lance-encoding = "=9.0.0"
+lance-arrow = "=9.0.0"
 ahash = "0.8"
 # Note that this one does not include pyarrow
 arrow = { version = "58.0.0", optional = false }
@@ -52,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"

ci/bump_version.sh

@@ -2,15 +2,20 @@ 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 )
-readonly BUMP_ARGS="--no-tag"
 
 PREV_TAG=$(git tag --sort='version:refname' | grep ^$TAG_PREFIX | python $SELF_DIR/semver_sort.py $TAG_PREFIX | tail -n 1)
 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 
+  BUMP_ARGS="--no-tag"
+fi
+
 # If last is stable and not bumping minor
 if [[ $PREV_TAG != *beta* ]]; then
     if [[ "$BUMP_MINOR" != "false" ]]; then
@@ -34,12 +39,12 @@ fi
 # a stable version, bump the pre-release level ("pre_l") to make it stable.
 if [[ $RELEASE_TYPE == 'stable' ]]; then
   # X.Y.Z-beta.N -> X.Y.Z
-  bump-my-version bump -vv $BUMP_ARGS pre_l
+  bump-my-version bump -vv pre_l
 fi
 
 # Validate that we have incremented version appropriately for breaking changes
-NEW_VERSION=$(python -c 'import tomllib; print(tomllib.load(open(".bumpversion.toml", "rb"))["tool"]["bumpversion"]["current_version"])')
-NEW_TAG="$TAG_PREFIX$NEW_VERSION"
+NEW_TAG=$(git describe --tags --exact-match HEAD)
+NEW_VERSION=$(echo $NEW_TAG | sed "s/^$TAG_PREFIX//")
 LAST_STABLE_RELEASE=$(git tag --sort='version:refname' | grep ^$TAG_PREFIX | grep -v beta | grep -vF "$NEW_TAG" | python $SELF_DIR/semver_sort.py $TAG_PREFIX | tail -n 1)
 LAST_STABLE_VERSION=$(echo $LAST_STABLE_RELEASE | sed "s/^$TAG_PREFIX//")
 

ci/create_release_tag.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-RELEASE_VERSION=$(python -c 'import tomllib; print(tomllib.load(open(".bumpversion.toml", "rb"))["tool"]["bumpversion"]["current_version"])')
-RELEASE_TAG="v${RELEASE_VERSION}"
-
-if git rev-parse --quiet --verify "refs/tags/${RELEASE_TAG}" >/dev/null; then
-  echo "Release tag ${RELEASE_TAG} already exists" >&2
-  exit 1
-fi
-
-git tag --annotate "$RELEASE_TAG" --message "Release ${RELEASE_TAG}"
-
-HEAD_SHA=$(git rev-parse HEAD)
-TAG_SHA=$(git rev-parse "refs/tags/${RELEASE_TAG}^{}")
-if [[ "$TAG_SHA" != "$HEAD_SHA" ]]; then
-  echo "Release tag ${RELEASE_TAG} points to ${TAG_SHA}, expected ${HEAD_SHA}" >&2
-  exit 1
-fi
-
-echo "Created ${RELEASE_TAG} at ${HEAD_SHA}"

ci/test_validate_stable_lance.py

@@ -1,72 +0,0 @@
-import tempfile
-import unittest
-from pathlib import Path
-
-from validate_stable_lance import validate
-
-
-class ValidateStableLanceTest(unittest.TestCase):
-    def write_fixture(
-        self,
-        root: Path,
-        *,
-        rust: str = "=10.0.0",
-        python: str = "10.0.0",
-        java: str = "10.0.0",
-    ) -> None:
-        (root / "python").mkdir()
-        (root / "java").mkdir()
-        (root / "Cargo.toml").write_text(
-            f'[workspace.dependencies]\nlance = "{rust}"\nlance-core = "{rust}"\n'
-        )
-        (root / "python" / "pyproject.toml").write_text(
-            '[project.optional-dependencies]\ntests = ["pylance==' + python + '"]\n'
-        )
-        (root / "java" / "pom.xml").write_text(
-            "<project><properties><lance-core.version>"
-            + java
-            + "</lance-core.version></properties></project>"
-        )
-
-    def test_accepts_matching_stable_versions(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            root = Path(temp_dir)
-            self.write_fixture(root)
-            self.assertEqual(validate(root), "10.0.0")
-
-    def test_rejects_prerelease(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            root = Path(temp_dir)
-            self.write_fixture(root, python="10.0.0rc1")
-            with self.assertRaisesRegex(ValueError, "not stable"):
-                validate(root)
-
-    def test_rejects_sdk_mismatch(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            root = Path(temp_dir)
-            self.write_fixture(root, java="9.0.0")
-            with self.assertRaisesRegex(ValueError, "do not match across SDKs"):
-                validate(root)
-
-    def test_rejects_non_exact_rust_dependency(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            root = Path(temp_dir)
-            self.write_fixture(root, rust="10.0.0")
-            with self.assertRaisesRegex(ValueError, "not exact"):
-                validate(root)
-
-    def test_rejects_unpublished_rust_source(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            root = Path(temp_dir)
-            self.write_fixture(root)
-            (root / "Cargo.toml").write_text(
-                "[workspace.dependencies]\n"
-                'lance = { version = "=10.0.0", git = "https://example.com/lance", '
-                'tag = "v10.0.0" }\n'
-            )
-            with self.assertRaisesRegex(ValueError, "unpublished source fields"):
-                validate(root)
-
-
-if __name__ == "__main__":
-    unittest.main()

ci/validate_stable_lance.py

@@ -1,112 +1,34 @@
-#!/usr/bin/env python3
-"""Validate that every SDK uses the same published stable Lance release."""
-
-from __future__ import annotations
-
-import re
-import xml.etree.ElementTree as ET
-from pathlib import Path
-
 import tomllib
 
-STABLE_VERSION = re.compile(r"[0-9]+\.[0-9]+\.[0-9]+")
+found_preview_lance = False
 
+with open("Cargo.toml", "rb") as f:
+    cargo_data = tomllib.load(f)
 
-def _stable_version(raw: str, *, dependency: str, exact: bool = False) -> str:
-    value = raw.strip()
-    if exact and not value.startswith("="):
-        raise ValueError(f"Dependency '{dependency}' is not exact: {raw}")
-    value = value.removeprefix("=").removeprefix("v")
-    if STABLE_VERSION.fullmatch(value) is None:
-        raise ValueError(f"Dependency '{dependency}' is not stable: {raw}")
-    return value
+    for name, dep in cargo_data["workspace"]["dependencies"].items():
+        if name == "lance" or name.startswith("lance-"):
+            if isinstance(dep, str):
+                version = dep
+            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'))
+            else:
+                raise ValueError("Unexpected type for dependency: " + str(dep))
 
+            if "beta" in version:
+                found_preview_lance = True
+                print(f"Dependency '{name}' is a preview version: {version}")
 
-def rust_lance_version(repo_root: Path) -> str:
-    with (repo_root / "Cargo.toml").open("rb") as cargo_file:
-        dependencies = tomllib.load(cargo_file)["workspace"]["dependencies"]
+with open("python/pyproject.toml", "rb") as f:
+    py_proj_data = tomllib.load(f)
 
-    versions: dict[str, str] = {}
-    for name, dependency in dependencies.items():
-        if name != "lance" and not name.startswith("lance-"):
-            continue
+    for dep in py_proj_data["project"]["dependencies"]:
+        if dep.startswith("pylance"):
+            if "b" in dep:
+                found_preview_lance = True
+                print(f"Dependency '{dep}' is a preview version")
+            break  # Only one pylance dependency
 
-        if isinstance(dependency, str):
-            raw_version = dependency
-        elif isinstance(dependency, dict):
-            forbidden_sources = [
-                source
-                for source in ("git", "path", "branch", "rev", "tag")
-                if source in dependency
-            ]
-            if forbidden_sources:
-                joined = ", ".join(forbidden_sources)
-                raise ValueError(
-                    f"Dependency '{name}' uses unpublished source fields: {joined}"
-                )
-            raw_version = dependency.get("version")
-            if raw_version is None:
-                raise ValueError(f"Dependency '{name}' has no version")
-        else:
-            raise TypeError(f"Dependency '{name}' has an unexpected definition")
-
-        versions[name] = _stable_version(raw_version, dependency=name, exact=True)
-
-    if not versions:
-        raise ValueError("No Rust Lance dependencies found")
-    unique_versions = set(versions.values())
-    if len(unique_versions) != 1:
-        details = ", ".join(f"{name}={version}" for name, version in versions.items())
-        raise ValueError(f"Rust Lance dependency versions do not match: {details}")
-    return unique_versions.pop()
-
-
-def python_lance_version(repo_root: Path) -> str:
-    with (repo_root / "python" / "pyproject.toml").open("rb") as pyproject_file:
-        pyproject = tomllib.load(pyproject_file)
-
-    requirements = pyproject["project"]["optional-dependencies"]["tests"]
-    pylance_requirements = [
-        requirement for requirement in requirements if requirement.startswith("pylance")
-    ]
-    if len(pylance_requirements) != 1:
-        raise ValueError(
-            "Expected exactly one pylance requirement in the Python test dependencies"
-        )
-
-    requirement = pylance_requirements[0]
-    prefix = "pylance=="
-    if not requirement.startswith(prefix):
-        raise ValueError(f"Python test dependency is not exact: {requirement}")
-    return _stable_version(requirement[len(prefix) :], dependency="pylance")
-
-
-def java_lance_version(repo_root: Path) -> str:
-    pom_root = ET.parse(repo_root / "java" / "pom.xml").getroot()
-    versions = [
-        element.text
-        for element in pom_root.iter()
-        if element.tag.rsplit("}", 1)[-1] == "lance-core.version"
-    ]
-    if len(versions) != 1 or versions[0] is None:
-        raise ValueError("Expected exactly one Java lance-core.version property")
-    return _stable_version(versions[0], dependency="Java lance-core")
-
-
-def validate(repo_root: Path) -> str:
-    versions = {
-        "Rust": rust_lance_version(repo_root),
-        "Python": python_lance_version(repo_root),
-        "Java": java_lance_version(repo_root),
-    }
-    if len(set(versions.values())) != 1:
-        details = ", ".join(f"{sdk}={version}" for sdk, version in versions.items())
-        raise ValueError(
-            f"Lance dependency versions do not match across SDKs: {details}"
-        )
-    return versions["Rust"]
-
-
-if __name__ == "__main__":
-    version = validate(Path(__file__).resolve().parents[1])
-    print(f"Validated published stable Lance v{version} across Rust, Python, and Java")
+if found_preview_lance:
+    raise ValueError("Found preview version of Lance in dependencies")

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/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.37.1</version>
+    <version>0.33.0-beta.0</version>
 </dependency>
 ```
 

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/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
@@ -386,26 +365,6 @@ Drop an existing table.
 
 ***
 
-### 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
@@ -420,62 +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;
-
-***
-
 ### listNamespaces()
 
 ```ts

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

@@ -295,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

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,7 +25,6 @@
 - [Connection](classes/Connection.md)
 - [HeaderProvider](classes/HeaderProvider.md)
 - [Index](classes/Index.md)
-- [Job](classes/Job.md)
 - [MakeArrowTableOptions](classes/MakeArrowTableOptions.md)
 - [MatchQuery](classes/MatchQuery.md)
 - [MergeInsertBuilder](classes/MergeInsertBuilder.md)
@@ -89,9 +88,6 @@
 - [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)
 - [LsmWriteSpec](interfaces/LsmWriteSpec.md)

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/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/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/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,12 +34,8 @@ listing a storage directory.
 
 ::: lancedb.table.FragmentSummaryStats
 
-::: lancedb.table.TableStatistics
-
 ::: lancedb.table.Tags
 
-::: lancedb.table.Branches
-
 ## Expressions
 
 Type-safe expression builder for filters and projections. Use these instead
@@ -78,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
 
@@ -127,50 +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
 
@@ -178,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
@@ -194,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)
 
@@ -228,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.
@@ -242,20 +145,32 @@ Table hold your actual data as a collection of records / rows.
 
 ::: lancedb.table.AsyncTags
 
-::: lancedb.table.AsyncBranches
-
 ## 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
 
@@ -283,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/lancedb-core/pom.xml

@@ -8,7 +8,7 @@
     <parent>
       <groupId>com.lancedb</groupId>
       <artifactId>lancedb-parent</artifactId>
-      <version>0.37.1-final.0</version>
+      <version>0.33.0-beta.0</version>
       <relativePath>../pom.xml</relativePath>
     </parent>
 

java/pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.lancedb</groupId>
     <artifactId>lancedb-parent</artifactId>
-    <version>0.37.1-final.0</version>
+    <version>0.33.0-beta.0</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>10.0.0</lance-core.version>
+        <lance-core.version>9.0.0</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.37.1"
+version = "0.33.0-beta.0"
 publish = false
 license.workspace = true
 description.workspace = true

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"];
@@ -204,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),
@@ -1027,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__/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> {

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__/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 {
@@ -170,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) => {
@@ -258,59 +225,6 @@ 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 merges remote branches", async () => {
     const sampleDiff = {
       fromBranch: "exp",
@@ -909,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;
@@ -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,36 +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();
-  });
 });

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/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,
@@ -21,9 +20,6 @@ import type {
   CreateNamespaceResponse,
   DescribeNamespaceResponse,
   DropNamespaceResponse,
-  Job,
-  JobDescription,
-  JobInfo,
   ListNamespacesResponse,
 } from "./native";
 export type {
@@ -440,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 */
@@ -760,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/index.ts

@@ -85,13 +85,7 @@ export {
   RenameTableOptions,
 } from "./connection";
 
-export {
-  Job,
-  JobDescription,
-  JobFailureInfo,
-  JobInfo,
-  Session,
-} from "./native.js";
+export { Session } from "./native.js";
 
 export {
   ExecutableQuery,
@@ -200,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;
 
@@ -241,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/merge.ts

@@ -88,17 +88,21 @@ export class 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.
    *
-   * @param enable - `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.
+   * @param useLsmWrite - Whether to use the LSM write path.
    */
-  useLsm(enable: boolean): MergeInsertBuilder {
-    return new MergeInsertBuilder(this.#native.useLsm(enable), this.#schema);
+  useLsmWrite(useLsmWrite: boolean): MergeInsertBuilder {
+    return new MergeInsertBuilder(
+      this.#native.useLsmWrite(useLsmWrite),
+      this.#schema,
+    );
   }
   /**
    * Controls how an LSM merge checks that its input targets a single shard.

nodejs/lancedb/query.ts

@@ -460,30 +460,6 @@ export class StandardQueryBase<
     this.doCall((inner: NativeQueryType) => inner.fastSearch());
     return this;
   }
-
-  /**
-   * Control MemWAL read routing for this query.
-   *
-   * By default (unset), when the table carries a MemWAL write spec (see
-   * {@link Table#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.
-   *
-   * @param enable - `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.
-   */
-  useLsm(enable: boolean): this {
-    this.doCall((inner: NativeQueryType) => inner.useLsm(enable));
-    return this;
-  }
 }
 
 /**
@@ -772,20 +748,6 @@ export class TakeQuery extends QueryBase<NativeTakeQuery> {
   constructor(inner: NativeTakeQuery) {
     super(inner);
   }
-
-  /**
-   * 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.
-   *
-   * @param enable - `false` reads the base table only.
-   */
-  useLsm(enable: boolean): this {
-    this.doCall((inner: NativeTakeQuery) => inner.useLsm(enable));
-    return this;
-  }
 }
 
 /** A builder for LanceDB queries.

nodejs/lancedb/sanitize.ts

@@ -9,7 +9,7 @@
 // comes from the exact same library instance.  This is not always the case
 // and so we must sanitize the input to ensure that it is compatible.
 
-import { BufferType, Data, Vector } from "apache-arrow";
+import { BufferType, Data } from "apache-arrow";
 import type { IntBitWidth, TKeys, TimeBitWidth } from "apache-arrow/type";
 import {
   Binary,
@@ -74,20 +74,6 @@ import {
   Utf8,
 } from "./arrow";
 
-type SanitizationContext = {
-  types: WeakMap<object, DataType>;
-  vectors: WeakMap<object, Vector>;
-  data: WeakMap<object, Data<DataType>>;
-};
-
-function createSanitizationContext(): SanitizationContext {
-  return {
-    types: new WeakMap(),
-    vectors: new WeakMap(),
-    data: new WeakMap(),
-  };
-}
-
 export function sanitizeMetadata(
   metadataLike?: unknown,
 ): Map<string, string> | undefined {
@@ -98,7 +84,7 @@ export function sanitizeMetadata(
     throw Error("Expected metadata, if present, to be a Map<string, string>");
   }
   for (const item of metadataLike) {
-    if (typeof item[0] !== "string" || typeof item[1] !== "string") {
+    if (!(typeof item[0] === "string" || !(typeof item[1] === "string"))) {
       throw Error(
         "Expected metadata, if present, to be a Map<string, string> but it had non-string keys or values",
       );
@@ -200,13 +186,6 @@ export function sanitizeInterval(typeLike: object) {
 }
 
 export function sanitizeList(typeLike: object) {
-  return sanitizeListWithContext(typeLike, createSanitizationContext());
-}
-
-function sanitizeListWithContext(
-  typeLike: object,
-  context: SanitizationContext,
-) {
   if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
     throw Error(
       "Expected a List type to have an array-like `children` property",
@@ -215,35 +194,19 @@ function sanitizeListWithContext(
   if (typeLike.children.length !== 1) {
     throw Error("Expected a List type to have exactly one child");
   }
-  return new List(sanitizeFieldWithContext(typeLike.children[0], context));
+  return new List(sanitizeField(typeLike.children[0]));
 }
 
 export function sanitizeStruct(typeLike: object) {
-  return sanitizeStructWithContext(typeLike, createSanitizationContext());
-}
-
-function sanitizeStructWithContext(
-  typeLike: object,
-  context: SanitizationContext,
-) {
   if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
     throw Error(
       "Expected a Struct type to have an array-like `children` property",
     );
   }
-  return new Struct(
-    typeLike.children.map((child) => sanitizeFieldWithContext(child, context)),
-  );
+  return new Struct(typeLike.children.map((child) => sanitizeField(child)));
 }
 
 export function sanitizeUnion(typeLike: object) {
-  return sanitizeUnionWithContext(typeLike, createSanitizationContext());
-}
-
-function sanitizeUnionWithContext(
-  typeLike: object,
-  context: SanitizationContext,
-) {
   if (
     !("typeIds" in typeLike) ||
     !("mode" in typeLike) ||
@@ -263,7 +226,7 @@ function sanitizeUnionWithContext(
     typeLike.mode,
     // biome-ignore lint/suspicious/noExplicitAny: skip
     typeLike.typeIds as any,
-    typeLike.children.map((child) => sanitizeFieldWithContext(child, context)),
+    typeLike.children.map((child) => sanitizeField(child)),
   );
 }
 
@@ -271,19 +234,6 @@ export function sanitizeTypedUnion(
   typeLike: object,
   // eslint-disable-next-line @typescript-eslint/naming-convention
   UnionType: typeof DenseUnion | typeof SparseUnion,
-) {
-  return sanitizeTypedUnionWithContext(
-    typeLike,
-    UnionType,
-    createSanitizationContext(),
-  );
-}
-
-function sanitizeTypedUnionWithContext(
-  typeLike: object,
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  UnionType: typeof DenseUnion | typeof SparseUnion,
-  context: SanitizationContext,
 ) {
   if (!("typeIds" in typeLike)) {
     throw Error(
@@ -298,7 +248,7 @@ function sanitizeTypedUnionWithContext(
 
   return new UnionType(
     typeLike.typeIds as Int32Array | number[],
-    typeLike.children.map((child) => sanitizeFieldWithContext(child, context)),
+    typeLike.children.map((child) => sanitizeField(child)),
   );
 }
 
@@ -312,16 +262,6 @@ export function sanitizeFixedSizeBinary(typeLike: object) {
 }
 
 export function sanitizeFixedSizeList(typeLike: object) {
-  return sanitizeFixedSizeListWithContext(
-    typeLike,
-    createSanitizationContext(),
-  );
-}
-
-function sanitizeFixedSizeListWithContext(
-  typeLike: object,
-  context: SanitizationContext,
-) {
   if (!("listSize" in typeLike) || typeof typeLike.listSize !== "number") {
     throw Error("Expected a FixedSizeList type to have a `listSize` property");
   }
@@ -335,18 +275,11 @@ function sanitizeFixedSizeListWithContext(
   }
   return new FixedSizeList(
     typeLike.listSize,
-    sanitizeFieldWithContext(typeLike.children[0], context),
+    sanitizeField(typeLike.children[0]),
   );
 }
 
 export function sanitizeMap(typeLike: object) {
-  return sanitizeMapWithContext(typeLike, createSanitizationContext());
-}
-
-function sanitizeMapWithContext(
-  typeLike: object,
-  context: SanitizationContext,
-) {
   if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
     throw Error(
       "Expected a Map type to have an array-like `children` property",
@@ -359,10 +292,7 @@ function sanitizeMapWithContext(
     throw Error("Expected a Map type to have exactly one child");
   }
 
-  return new Map_(
-    sanitizeFieldWithContext(typeLike.children[0], context),
-    typeLike.keysSorted,
-  );
+  return new Map_(sanitizeField(typeLike.children[0]), typeLike.keysSorted);
 }
 
 export function sanitizeDuration(typeLike: object) {
@@ -373,13 +303,6 @@ export function sanitizeDuration(typeLike: object) {
 }
 
 export function sanitizeDictionary(typeLike: object) {
-  return sanitizeDictionaryWithContext(typeLike, createSanitizationContext());
-}
-
-function sanitizeDictionaryWithContext(
-  typeLike: object,
-  context: SanitizationContext,
-) {
   if (!("id" in typeLike) || typeof typeLike.id !== "number") {
     throw Error("Expected a Dictionary type to have an `id` property");
   }
@@ -393,8 +316,8 @@ function sanitizeDictionaryWithContext(
     throw Error("Expected a Dictionary type to have an `isOrdered` property");
   }
   return new Dictionary(
-    sanitizeTypeWithContext(typeLike.dictionary, context),
-    sanitizeTypeWithContext(typeLike.indices, context) as TKeys,
+    sanitizeType(typeLike.dictionary),
+    sanitizeType(typeLike.indices) as TKeys,
     typeLike.id,
     typeLike.isOrdered,
   );
@@ -402,23 +325,12 @@ function sanitizeDictionaryWithContext(
 
 // biome-ignore lint/suspicious/noExplicitAny: skip
 export function sanitizeType(typeLike: unknown): DataType<any> {
-  return sanitizeTypeWithContext(typeLike, createSanitizationContext());
-}
-
-function sanitizeTypeWithContext(
-  typeLike: unknown,
-  context: SanitizationContext,
-): DataType {
   if (typeof typeLike === "string") {
     return dataTypeFromName(typeLike);
   }
   if (typeof typeLike !== "object" || typeLike === null) {
     throw Error("Expected a Type but object was null/undefined");
   }
-  const cached = context.types.get(typeLike);
-  if (cached !== undefined) {
-    return cached;
-  }
   if (
     !("typeId" in typeLike) ||
     !(
@@ -437,16 +349,6 @@ function sanitizeTypeWithContext(
     throw Error("Type's typeId property was not a function or number");
   }
 
-  const type = sanitizeTypeById(typeLike, typeId, context);
-  context.types.set(typeLike, type);
-  return type;
-}
-
-function sanitizeTypeById(
-  typeLike: object,
-  typeId: Type,
-  context: SanitizationContext,
-): DataType {
   switch (typeId) {
     case Type.NONE:
       throw Error("Received a Type with a typeId of NONE");
@@ -473,21 +375,21 @@ function sanitizeTypeById(
     case Type.Interval:
       return sanitizeInterval(typeLike);
     case Type.List:
-      return sanitizeListWithContext(typeLike, context);
+      return sanitizeList(typeLike);
     case Type.Struct:
-      return sanitizeStructWithContext(typeLike, context);
+      return sanitizeStruct(typeLike);
     case Type.Union:
-      return sanitizeUnionWithContext(typeLike, context);
+      return sanitizeUnion(typeLike);
     case Type.FixedSizeBinary:
       return sanitizeFixedSizeBinary(typeLike);
     case Type.FixedSizeList:
-      return sanitizeFixedSizeListWithContext(typeLike, context);
+      return sanitizeFixedSizeList(typeLike);
     case Type.Map:
-      return sanitizeMapWithContext(typeLike, context);
+      return sanitizeMap(typeLike);
     case Type.Duration:
       return sanitizeDuration(typeLike);
     case Type.Dictionary:
-      return sanitizeDictionaryWithContext(typeLike, context);
+      return sanitizeDictionary(typeLike);
     case Type.Int8:
       return new Int8();
     case Type.Int16:
@@ -531,9 +433,9 @@ function sanitizeTypeById(
     case Type.TimestampSecond:
       return sanitizeTypedTimestamp(typeLike, TimestampSecond);
     case Type.DenseUnion:
-      return sanitizeTypedUnionWithContext(typeLike, DenseUnion, context);
+      return sanitizeTypedUnion(typeLike, DenseUnion);
     case Type.SparseUnion:
-      return sanitizeTypedUnionWithContext(typeLike, SparseUnion, context);
+      return sanitizeTypedUnion(typeLike, SparseUnion);
     case Type.IntervalDayTime:
       return new IntervalDayTime();
     case Type.IntervalYearMonth:
@@ -552,13 +454,6 @@ function sanitizeTypeById(
 }
 
 export function sanitizeField(fieldLike: unknown): Field {
-  return sanitizeFieldWithContext(fieldLike, createSanitizationContext());
-}
-
-function sanitizeFieldWithContext(
-  fieldLike: unknown,
-  context: SanitizationContext,
-): Field {
   if (fieldLike instanceof Field) {
     return fieldLike;
   }
@@ -576,7 +471,7 @@ function sanitizeFieldWithContext(
   }
   let type: DataType;
   try {
-    type = sanitizeTypeWithContext(fieldLike.type, context);
+    type = sanitizeType(fieldLike.type);
   } catch (error: unknown) {
     throw Error(
       `Unable to sanitize type for field: ${fieldLike.name} due to error: ${error}`,
@@ -606,13 +501,6 @@ function sanitizeFieldWithContext(
  * than lancedb is using.
  */
 export function sanitizeSchema(schemaLike: SchemaLike): Schema {
-  return sanitizeSchemaWithContext(schemaLike, createSanitizationContext());
-}
-
-function sanitizeSchemaWithContext(
-  schemaLike: SchemaLike,
-  context: SanitizationContext,
-): Schema {
   if (schemaLike instanceof Schema) {
     return schemaLike;
   }
@@ -634,7 +522,7 @@ function sanitizeSchemaWithContext(
     );
   }
   const sanitizedFields = schemaLike.fields.map((field) =>
-    sanitizeFieldWithContext(field, context),
+    sanitizeField(field),
   );
   return new Schema(sanitizedFields, metadata);
 }
@@ -656,18 +544,13 @@ export function sanitizeTable(tableLike: TableLike): Table {
       "The table passed in does not appear to be a table (no 'columns' property)",
     );
   }
-  const context = createSanitizationContext();
-  const schema = sanitizeSchemaWithContext(tableLike.schema, context);
-  const batches = tableLike.batches.map((batch) =>
-    sanitizeRecordBatch(batch, context),
-  );
+  const schema = sanitizeSchema(tableLike.schema);
+
+  const batches = tableLike.batches.map(sanitizeRecordBatch);
   return new Table(schema, batches);
 }
 
-function sanitizeRecordBatch(
-  batchLike: RecordBatchLike,
-  context: SanitizationContext,
-): RecordBatch {
+function sanitizeRecordBatch(batchLike: RecordBatchLike): RecordBatch {
   if (batchLike instanceof RecordBatch) {
     return batchLike;
   }
@@ -684,43 +567,19 @@ function sanitizeRecordBatch(
       "The record batch passed in does not appear to be a record batch (no 'data' property)",
     );
   }
-  const schema = sanitizeSchemaWithContext(batchLike.schema, context);
-  const data = sanitizeData(batchLike.data, context) as Data<Struct>;
+  const schema = sanitizeSchema(batchLike.schema);
+  const data = sanitizeData(batchLike.data);
   return new RecordBatch(schema, data);
 }
-
-type DictionaryVectorLike = {
-  data: readonly DataLike[];
-};
-
-type DictionaryDataLike = DataLike & {
-  dictionary?: DictionaryVectorLike;
-};
-
 function sanitizeData(
   dataLike: DataLike,
-  context: SanitizationContext,
-): Data<DataType> {
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+): import("apache-arrow").Data<Struct<any>> {
   if (dataLike instanceof Data) {
     return dataLike;
   }
-  const cachedData = context.data.get(dataLike);
-  if (cachedData !== undefined) {
-    return cachedData;
-  }
-  const dictionaryLike = (dataLike as DictionaryDataLike).dictionary;
-  let dictionary: Vector | undefined;
-  if (dictionaryLike !== undefined) {
-    dictionary = context.vectors.get(dictionaryLike);
-    if (dictionary === undefined) {
-      dictionary = new Vector(
-        dictionaryLike.data.map((data) => sanitizeData(data, context)),
-      );
-      context.vectors.set(dictionaryLike, dictionary);
-    }
-  }
-  const data = new Data(
-    sanitizeTypeWithContext(dataLike.type, context),
+  return new Data(
+    dataLike.type,
     dataLike.offset,
     dataLike.length,
     dataLike.nullCount,
@@ -730,11 +589,7 @@ function sanitizeData(
       [BufferType.VALIDITY]: dataLike.nullBitmap,
       [BufferType.TYPE]: dataLike.typeIds,
     },
-    dataLike.children.map((child) => sanitizeData(child, context)),
-    dictionary,
   );
-  context.data.set(dataLike, data);
-  return data;
 }
 
 const constructorsByTypeName = {

nodejs/lancedb/table.ts

@@ -30,7 +30,6 @@ import {
   DropColumnsResult,
   IndexConfig,
   IndexStatistics,
-  Job,
   Branches as NativeBranches,
   OptimizeStats,
   TableStatistics,
@@ -359,17 +358,6 @@ export abstract class Table {
     options?: Partial<IndexOptions>,
   ): Promise<void>;
 
-  /**
-   * 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 {@link Job.wait} resolves.
-   */
-  abstract createIndexAsync(
-    column: string,
-    options?: Partial<IndexOptions>,
-  ): Promise<Job>;
-
   /**
    * Drop an index from the table.
    *
@@ -952,22 +940,6 @@ export class LocalTable extends Table {
     );
   }
 
-  async createIndexAsync(
-    column: string,
-    options?: Partial<IndexOptions>,
-  ): Promise<Job> {
-    // biome-ignore lint/suspicious/noExplicitAny: skip
-    const nativeIndex = (options?.config as any)?.inner;
-    return await this.inner.createIndexAsync(
-      nativeIndex,
-      column,
-      options?.replace,
-      options?.waitTimeoutSeconds,
-      options?.name,
-      options?.train,
-    );
-  }
-
   async dropIndex(name: string): Promise<void> {
     await this.inner.dropIndex(name);
   }

nodejs/npm/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-darwin-arm64",
-	"version": "0.37.1",
+	"version": "0.33.0-beta.0",
 	"os": ["darwin"],
 	"cpu": ["arm64"],
 	"main": "lancedb.darwin-arm64.node",

nodejs/npm/linux-arm64-gnu/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-arm64-gnu",
-	"version": "0.37.1",
+	"version": "0.33.0-beta.0",
 	"os": ["linux"],
 	"cpu": ["arm64"],
 	"main": "lancedb.linux-arm64-gnu.node",

nodejs/npm/linux-arm64-musl/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-arm64-musl",
-	"version": "0.37.1",
+	"version": "0.33.0-beta.0",
 	"os": ["linux"],
 	"cpu": ["arm64"],
 	"main": "lancedb.linux-arm64-musl.node",

nodejs/npm/linux-x64-gnu/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-x64-gnu",
-	"version": "0.37.1",
+	"version": "0.33.0-beta.0",
 	"os": ["linux"],
 	"cpu": ["x64"],
 	"main": "lancedb.linux-x64-gnu.node",

nodejs/npm/linux-x64-musl/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-x64-musl",
-	"version": "0.37.1",
+	"version": "0.33.0-beta.0",
 	"os": ["linux"],
 	"cpu": ["x64"],
 	"main": "lancedb.linux-x64-musl.node",

nodejs/npm/win32-arm64-msvc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lancedb/lancedb-win32-arm64-msvc",
-  "version": "0.37.1",
+  "version": "0.33.0-beta.0",
   "os": [
     "win32"
   ],

nodejs/npm/win32-x64-msvc/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-win32-x64-msvc",
-	"version": "0.37.1",
+	"version": "0.33.0-beta.0",
 	"os": ["win32"],
 	"cpu": ["x64"],
 	"main": "lancedb.win32-x64-msvc.node",

nodejs/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@lancedb/lancedb",
-  "version": "0.37.1",
+  "version": "0.33.0-beta.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@lancedb/lancedb",
-      "version": "0.37.1",
+      "version": "0.33.0-beta.0",
       "cpu": [
         "x64",
         "arm64"
@@ -55,13 +55,7 @@
         "openai": "4.29.2"
       },
       "peerDependencies": {
-        "@types/node": ">=18",
         "apache-arrow": ">=15.0.0 <=18.1.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
       }
     },
     "node_modules/@aws-crypto/crc32": {

nodejs/package.json

@@ -11,7 +11,7 @@
     "ann"
   ],
   "private": false,
-  "version": "0.37.1",
+  "version": "0.33.0-beta.0",
   "main": "dist/index.js",
   "exports": {
     ".": "./dist/index.js",
@@ -101,12 +101,6 @@
     "openai": "4.29.2"
   },
   "peerDependencies": {
-    "@types/node": ">=18",
     "apache-arrow": ">=15.0.0 <=18.1.0"
-  },
-  "peerDependenciesMeta": {
-    "@types/node": {
-      "optional": true
-    }
   }
 }

nodejs/src/connection.rs

@@ -340,69 +340,6 @@ impl Connection {
         self.get_inner()?.drop_all_tables(&ns).await.default_error()
     }
 
-    /// A `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.
-    #[napi]
-    pub fn job(&self, job_id: String) -> napi::Result<crate::job::Job> {
-        let job = self.get_inner()?.job(job_id).default_error()?;
-        Ok(crate::job::Job::new(job))
-    }
-
-    /// List server-side jobs across the database's tables.
-    #[napi(catch_unwind)]
-    pub async fn list_jobs(&self) -> napi::Result<Vec<crate::job::JobInfo>> {
-        let jobs = self.get_inner()?.list_jobs().await.default_error()?;
-        Ok(jobs.into_iter().map(Into::into).collect())
-    }
-
-    /// Describe a single server-side job by id. `null` when the server has
-    /// no such job.
-    #[napi(catch_unwind)]
-    pub async fn get_job(
-        &self,
-        job_id: String,
-    ) -> napi::Result<Option<crate::job::JobDescription>> {
-        let description = self.get_inner()?.get_job(&job_id).await.default_error()?;
-        Ok(description.map(Into::into))
-    }
-
-    /// Request cancellation of a server-side job by id. Returns true if the
-    /// server accepted the cancellation, false if no such job exists.
-    #[napi(catch_unwind)]
-    pub async fn cancel_job(&self, job_id: String) -> napi::Result<bool> {
-        self.get_inner()?.cancel_job(&job_id).await.default_error()
-    }
-
-    /// The lifecycle event history of a server-side job (all jobs when
-    /// `job_id` is null), as an Arrow IPC stream buffer. Empty when there is
-    /// no history.
-    #[napi(catch_unwind)]
-    pub async fn job_history(&self, job_id: Option<String>) -> napi::Result<Buffer> {
-        let batches = self
-            .get_inner()?
-            .job_history(job_id.as_deref())
-            .await
-            .default_error()?;
-        let Some(first) = batches.first() else {
-            return Ok(Buffer::from(Vec::<u8>::new()));
-        };
-        let mut out = Vec::new();
-        let mut writer = arrow_ipc::writer::StreamWriter::try_new(&mut out, &first.schema())
-            .map_err(|e| napi::Error::from_reason(e.to_string()))?;
-        for batch in &batches {
-            writer
-                .write(batch)
-                .map_err(|e| napi::Error::from_reason(e.to_string()))?;
-        }
-        writer
-            .finish()
-            .map_err(|e| napi::Error::from_reason(e.to_string()))?;
-        drop(writer);
-        Ok(Buffer::from(out))
-    }
-
     #[napi(catch_unwind)]
     /// Describe a namespace and return its properties.
     pub async fn describe_namespace(

nodejs/src/index.rs

@@ -43,7 +43,6 @@ pub fn tokenize(
     lower_case: Option<bool>,
     stem: Option<bool>,
     remove_stop_words: Option<bool>,
-    custom_stop_words: Option<Vec<String>>,
     ascii_folding: Option<bool>,
     ngram_min_length: Option<u32>,
     ngram_max_length: Option<u32>,
@@ -73,7 +72,6 @@ pub fn tokenize(
     if let Some(remove_stop_words) = remove_stop_words {
         opts = opts.remove_stop_words(remove_stop_words);
     }
-    opts = opts.custom_stop_words(custom_stop_words);
     if let Some(ascii_folding) = ascii_folding {
         opts = opts.ascii_folding(ascii_folding);
     }
@@ -224,13 +222,11 @@ impl Index {
         lower_case: Option<bool>,
         stem: Option<bool>,
         remove_stop_words: Option<bool>,
-        custom_stop_words: Option<Vec<String>>,
         ascii_folding: Option<bool>,
         ngram_min_length: Option<u32>,
         ngram_max_length: Option<u32>,
         prefix_only: Option<bool>,
-        block_size: Option<u32>,
-    ) -> napi::Result<Self> {
+    ) -> Self {
         let mut opts = FtsIndexBuilder::default();
         if let Some(with_position) = with_position {
             opts = opts.with_position(with_position);
@@ -253,7 +249,6 @@ impl Index {
         if let Some(remove_stop_words) = remove_stop_words {
             opts = opts.remove_stop_words(remove_stop_words);
         }
-        opts = opts.custom_stop_words(custom_stop_words);
         if let Some(ascii_folding) = ascii_folding {
             opts = opts.ascii_folding(ascii_folding);
         }
@@ -266,15 +261,10 @@ impl Index {
         if let Some(prefix_only) = prefix_only {
             opts = opts.ngram_prefix_only(prefix_only);
         }
-        if let Some(block_size) = block_size {
-            opts = opts
-                .block_size(block_size as usize)
-                .map_err(|err| napi::Error::from_reason(err.to_string()))?;
-        }
 
-        Ok(Self {
+        Self {
             inner: Mutex::new(Some(LanceDbIndex::FTS(opts))),
-        })
+        }
     }
 
     #[napi(factory)]

nodejs/src/job.rs

@@ -1,123 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-use std::sync::Arc;
-
-use napi_derive::napi;
-
-use crate::error::NapiErrorExt;
-
-/// A handle to an operation that may still be running.
-#[napi]
-pub struct Job {
-    inner: Arc<lancedb::Job>,
-}
-
-impl Job {
-    pub(crate) fn new(inner: lancedb::Job) -> Self {
-        Self {
-            inner: Arc::new(inner),
-        }
-    }
-}
-
-#[napi]
-impl Job {
-    /// Identifies the operation on the server that is running it. Operations
-    /// that run in this process have no server id. The value is opaque.
-    #[napi(getter)]
-    pub fn id(&self) -> Option<String> {
-        self.inner.id().map(str::to_string)
-    }
-
-    /// The operation's current lifecycle state: "running", "finished",
-    /// "failed", or "cancelled".
-    ///
-    /// A point snapshot; unlike {@link Job.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.
-    #[napi(catch_unwind)]
-    pub async fn status(&self) -> napi::Result<String> {
-        self.inner.status().await.default_error()
-    }
-
-    /// Wait until the operation reaches a terminal state.
-    #[napi(catch_unwind)]
-    pub async fn wait(&self) -> napi::Result<()> {
-        self.inner.wait().await.default_error()
-    }
-
-    /// Request cancellation. Cancelling a finished operation is a no-op.
-    #[napi(catch_unwind)]
-    pub async fn cancel(&self) -> napi::Result<()> {
-        self.inner.cancel().await.default_error()
-    }
-}
-
-/// A row from `Connection.listJobs`: one server-side job.
-#[napi(object)]
-pub struct JobInfo {
-    /// The job id -- what `Connection.getJob` and `Connection.cancelJob`
-    /// accept.
-    pub job_id: String,
-    /// The table the job runs against, without URI or namespace.
-    pub table: String,
-    pub job_type: String,
-    /// Lifecycle state: "running", "finished", "failed", or "cancelled".
-    pub state: String,
-    /// When the job was created, in milliseconds since the epoch.
-    pub created_at_millis: i64,
-}
-
-impl From<lancedb::database::JobInfo> for JobInfo {
-    fn from(info: lancedb::database::JobInfo) -> Self {
-        Self {
-            job_id: info.job_id,
-            table: info.table,
-            job_type: info.job_type,
-            state: info.state,
-            created_at_millis: info.created_at_millis,
-        }
-    }
-}
-
-/// The server's account of why a job failed.
-#[napi(object)]
-pub struct JobFailureInfo {
-    pub phase: Option<String>,
-    pub message: Option<String>,
-    pub retryable: Option<bool>,
-}
-
-/// A described job from `Connection.getJob`.
-#[napi(object)]
-pub struct JobDescription {
-    pub job_id: String,
-    pub job_type: String,
-    /// Lifecycle state: "running", "finished", "failed", or "cancelled".
-    pub state: String,
-    /// When the job was created, in milliseconds since the epoch.
-    pub creation_ms: i64,
-    /// The job-type-specific specification as a JSON string, when present.
-    pub spec_json: Option<String>,
-    /// Why the job failed, when the job is failed and the server reports a
-    /// reason.
-    pub failure: Option<JobFailureInfo>,
-}
-
-impl From<lancedb::database::JobDescription> for JobDescription {
-    fn from(description: lancedb::database::JobDescription) -> Self {
-        Self {
-            job_id: description.job_id,
-            job_type: description.job_type,
-            state: description.state,
-            creation_ms: description.creation_ms,
-            spec_json: (!description.spec.is_null()).then(|| description.spec.to_string()),
-            failure: description.failure.map(|failure| JobFailureInfo {
-                phase: failure.phase,
-                message: failure.message,
-                retryable: failure.retryable,
-            }),
-        }
-    }
-}

nodejs/src/lib.rs

@@ -11,7 +11,6 @@ mod error;
 mod header;
 mod index;
 mod iterator;
-mod job;
 pub mod merge;
 pub mod otel;
 pub mod permutation;

nodejs/src/merge.rs

@@ -51,9 +51,9 @@ impl NativeMergeInsertBuilder {
     }
 
     #[napi]
-    pub fn use_lsm(&self, enable: bool) -> Self {
+    pub fn use_lsm_write(&self, use_lsm_write: bool) -> Self {
         let mut this = self.clone();
-        this.inner.use_lsm(enable);
+        this.inner.use_lsm_write(use_lsm_write);
         this
     }
 

nodejs/src/query.rs

@@ -168,11 +168,6 @@ impl Query {
         self.inner = self.inner.clone().with_row_id();
     }
 
-    #[napi]
-    pub fn use_lsm(&mut self, enable: bool) {
-        self.inner = self.inner.clone().use_lsm(enable);
-    }
-
     #[napi]
     pub fn order_by(&mut self, ordering: Option<Vec<ColumnOrdering>>) -> napi::Result<()> {
         let ordering = ordering.map(|ordering| {
@@ -379,11 +374,6 @@ impl VectorQuery {
         self.inner = self.inner.clone().with_row_id();
     }
 
-    #[napi]
-    pub fn use_lsm(&mut self, enable: bool) {
-        self.inner = self.inner.clone().use_lsm(enable);
-    }
-
     #[napi]
     pub fn rerank(
         &mut self,
@@ -489,11 +479,6 @@ impl TakeQuery {
         self.inner = self.inner.clone().with_row_id();
     }
 
-    #[napi]
-    pub fn use_lsm(&mut self, enable: bool) {
-        self.inner = self.inner.clone().use_lsm(enable);
-    }
-
     #[napi(catch_unwind)]
     pub async fn output_schema(&self) -> napi::Result<Buffer> {
         let schema = self.inner.output_schema().await.default_error()?;

nodejs/src/table.rs

@@ -168,39 +168,6 @@ impl Table {
         builder.execute().await.default_error()
     }
 
-    #[napi(catch_unwind)]
-    pub async fn create_index_async(
-        &self,
-        index: Option<&Index>,
-        column: String,
-        replace: Option<bool>,
-        wait_timeout_s: Option<i64>,
-        name: Option<String>,
-        train: Option<bool>,
-    ) -> napi::Result<crate::job::Job> {
-        let lancedb_index = if let Some(index) = index {
-            index.consume()?
-        } else {
-            lancedb::index::Index::Auto
-        };
-        let mut builder = self.inner_ref()?.create_index(&[column], lancedb_index);
-        if let Some(replace) = replace {
-            builder = builder.replace(replace);
-        }
-        if let Some(timeout) = wait_timeout_s {
-            builder =
-                builder.wait_timeout(std::time::Duration::from_secs(timeout.try_into().unwrap()));
-        }
-        if let Some(name) = name {
-            builder = builder.name(name);
-        }
-        if let Some(train) = train {
-            builder = builder.train(train);
-        }
-        let job = builder.execute_async().await.default_error()?;
-        Ok(crate::job::Job::new(job))
-    }
-
     #[napi(catch_unwind)]
     pub async fn drop_index(&self, index_name: String) -> napi::Result<()> {
         self.inner_ref()?
@@ -339,9 +306,7 @@ impl Table {
         let transforms = NewColumnTransform::SqlExpressions(transforms);
         let res = self
             .inner_ref()?
-            .add_columns()
-            .transform(transforms)
-            .execute()
+            .add_columns(transforms, None)
             .await
             .default_error()?;
         Ok(res.into())
@@ -358,9 +323,7 @@ impl Table {
         let transforms = NewColumnTransform::AllNulls(schema);
         let res = self
             .inner_ref()?
-            .add_columns()
-            .transform(transforms)
-            .execute()
+            .add_columns(transforms, None)
             .await
             .default_error()?;
         Ok(res.into())
@@ -1043,10 +1006,7 @@ impl From<lancedb::index::IndexStatistics> for IndexStatistics {
 
 #[napi(object)]
 pub struct TableStatistics {
-    /// 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
     pub total_bytes: i64,
 
     /// The number of rows in the table

python/.bumpversion.toml

@@ -0,0 +1,49 @@
+[tool.bumpversion]
+current_version = "0.36.0"
+parse = """(?x)
+    (?P<major>0|[1-9]\\d*)\\.
+    (?P<minor>0|[1-9]\\d*)\\.
+    (?P<patch>0|[1-9]\\d*)
+    (?:-(?P<pre_l>[a-zA-Z-]+)\\.(?P<pre_n>0|[1-9]\\d*))?
+"""
+serialize = [
+    "{major}.{minor}.{patch}-{pre_l}.{pre_n}",
+    "{major}.{minor}.{patch}",
+]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags = false
+tag_name = "python-v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = true
+commit = true
+message = "Bump version: {current_version} → {new_version}"
+commit_args = ""
+# bump-my-version >=1.4.0 rejects pre_commit_hooks containing shell syntax unless opted in.
+allow_shell_hooks = true
+
+# Update Cargo.lock after version bump
+pre_commit_hooks = [
+  """
+    cd python && cargo update -p lancedb-python
+    if git diff --quiet ../Cargo.lock; then
+        echo "Cargo.lock unchanged"
+    else
+        git add ../Cargo.lock
+        echo "Updated and staged Cargo.lock"
+    fi
+    """,
+]
+
+[tool.bumpversion.parts.pre_l]
+values = ["beta", "final"]
+optional_value = "final"
+
+[[tool.bumpversion.files]]
+filename = "Cargo.toml"
+search = "\nversion = \"{current_version}\""
+replace = "\nversion = \"{new_version}\""

python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lancedb-python"
-version = "0.37.1"
+version = "0.36.0"
 publish = false
 edition.workspace = true
 description = "Python bindings for LanceDB"
@@ -26,7 +26,7 @@ lance-namespace-impls.workspace = true
 lance-io.workspace = true
 env_logger.workspace = true
 log.workspace = true
-pyo3 = { version = "0.28", features = ["extension-module", "abi3-py310", "chrono"] }
+pyo3 = { version = "0.28", features = ["extension-module", "abi3-py39", "chrono"] }
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 pyo3-async-runtimes = { version = "0.28", features = [
     "attributes",
@@ -43,7 +43,7 @@ libc = "0.2"
 [build-dependencies]
 pyo3-build-config = { version = "0.28", features = [
     "extension-module",
-    "abi3-py310",
+    "abi3-py39",
 ] }
 
 [features]

python/pyproject.toml

@@ -60,10 +60,10 @@ tests = [
     "pytest-asyncio>=0.21",
     "duckdb>=0.9.0",
     "pytz>=2023.3",
-    "polars>=0.19, <=1.32.3",
+    "polars>=0.19, <=1.3.0",
     "pyarrow<25",
     "pyarrow-stubs>=16.0",
-    "pylance==10.0.0",
+    "pylance==9.0.0",
     "requests>=2.31.0",
     "datafusion>=54,<55",
     "opentelemetry-sdk>=1.30.0",
@@ -140,7 +140,6 @@ include = [
     "python/lancedb/remote/errors.py",
     "python/lancedb/embeddings/__init__.py",
     "python/lancedb/_lancedb.pyi",
-    "python/type_tests/connect.py",
 ]
 exclude = ["python/tests/"]
 pythonVersion = "3.13"

python/python/lancedb/__init__.py

@@ -20,7 +20,6 @@ from .remote import ClientConfig
 from .remote.db import RemoteDBConnection
 from .expr import Expr, col, lit, func
 from .schema import blob, vector, BlobType
-from .job import AsyncJob, Job
 from .table import AsyncTable, Table
 from .types import BaseTokenizerType
 from ._lancedb import Session
@@ -259,7 +258,6 @@ def tokenize(
     lower_case: bool = True,
     stem: bool = True,
     remove_stop_words: bool = True,
-    custom_stop_words: Optional[List[str]] = None,
     ascii_folding: bool = True,
     ngram_min_length: int = 3,
     ngram_max_length: int = 3,
@@ -267,10 +265,9 @@ def tokenize(
 ) -> Iterable[FtsToken]:
     """Tokenize a full-text search query using an explicit tokenizer.
 
-    This does not require an FTS index. The tokenizer options match
-    :class:`lancedb.index.FTS`. ``custom_stop_words`` accepts a list of strings.
+    This does not require a table or FTS index. The tokenizer options match
+    :class:`lancedb.index.FTS`.
     """
-
     return _tokenize(
         query,
         base_tokenizer=base_tokenizer,
@@ -279,7 +276,6 @@ def tokenize(
         lower_case=lower_case,
         stem=stem,
         remove_stop_words=remove_stop_words,
-        custom_stop_words=custom_stop_words,
         ascii_folding=ascii_folding,
         ngram_min_length=ngram_min_length,
         ngram_max_length=ngram_max_length,
@@ -501,7 +497,6 @@ __all__ = [
     "connect_namespace",
     "connect_namespace_async",
     "AsyncConnection",
-    "AsyncJob",
     "AsyncLanceNamespaceDBConnection",
     "AsyncTable",
     "FtsToken",
@@ -515,7 +510,6 @@ __all__ = [
     "BlobType",
     "vector",
     "DBConnection",
-    "Job",
     "LanceDBConnection",
     "LanceNamespaceDBConnection",
     "RemoteDBConnection",

python/python/lancedb/_blob.py

@@ -14,10 +14,14 @@ import pyarrow as pa
 from .expr import Expr
 from .schema import blob_v2_column_paths
 from .types import BlobMode, QueryProjection, QueryProjectionSpec
+from .util import get_uri_scheme
 
 if TYPE_CHECKING:
     from _typeshed import WriteableBuffer
 
+    from .remote.table import RemoteTable
+    from .table import AsyncTable, Table
+
 BLOB_MODE_TO_HANDLING = {
     "lazy": "blobs_descriptions",
     "bytes": "all_binary",
@@ -100,6 +104,22 @@ def validate_blob_mode(blob_mode: BlobMode) -> None:
         raise ValueError(f"blob_mode must be one of {modes}, got {blob_mode!r}")
 
 
+def supports_blob_auto_row_id(table: Table | AsyncTable | RemoteTable) -> bool:
+    """Blob auto row-id applies to native tables, not LanceDB Cloud."""
+    from .remote.table import RemoteTable
+
+    if isinstance(table, RemoteTable):
+        return False
+
+    inner = getattr(table, "_inner", None)
+    if inner is not None:
+        uri = inner.database().uri
+        if isinstance(uri, str) and get_uri_scheme(uri) == "db":
+            return False
+
+    return True
+
+
 def projection_includes_blob_column(
     projection: QueryProjection,
     blob_columns: Iterable[str],
@@ -144,14 +164,16 @@ def v2_projection_needs_row_id(
 
 
 def blob_auto_row_id_for_scan(
+    table: Table | AsyncTable | RemoteTable,
     schema: pa.Schema,
     projection: QueryProjection,
     *,
     with_row_id: bool | None,
 ) -> bool:
-    """Auto row-id only applies when the caller said nothing about row ids."""
     if with_row_id is not None:
         return False
+    if not supports_blob_auto_row_id(table):
+        return False
     return v2_projection_needs_row_id(schema, projection, with_row_id=False)
 
 
@@ -164,11 +186,6 @@ def finalize_blob_query_table(
 ) -> pa.Table:
     if user_requested_row_id or not blob_auto_row_id:
         return tbl
-    if "_rowid" not in tbl.column_names:
-        # A backend that ignores the row-id request leaves nothing to stash. Hand
-        # back the projection as-is so fetch_blobs raises the error that names the
-        # ways to supply row ids, rather than failing here about a hidden column.
-        return tbl
     return stash_auto_row_ids(tbl, blob_paths)
 
 

python/python/lancedb/_lancedb.pyi

@@ -59,7 +59,6 @@ def tokenize(
     lower_case: bool = True,
     stem: bool = True,
     remove_stop_words: bool = True,
-    custom_stop_words: Optional[List[str]] = None,
     ascii_folding: bool = True,
     ngram_min_length: int = 3,
     ngram_max_length: int = 3,
@@ -146,13 +145,6 @@ class Connection(object):
         start_after: Optional[str],
         limit: Optional[int],
     ) -> list[str]: ...  # Deprecated: Use list_tables instead
-    def job(self, job_id: str) -> Job: ...
-    async def list_jobs(self) -> List[JobInfo]: ...
-    async def get_job(self, job_id: str) -> Optional[JobDescription]: ...
-    async def cancel_job(self, job_id: str) -> bool: ...
-    async def job_history(
-        self, job_id: Optional[str] = None
-    ) -> List[pa.RecordBatch]: ...
     async def create_table(
         self,
         name: str,
@@ -216,47 +208,6 @@ class BlobFile:
     def read_range(self, offset: int, length: int) -> bytes: ...
     def read_up_to(self, length: int) -> bytes: ...
 
-class Job:
-    @property
-    def id(self) -> Optional[str]: ...
-    async def status(self) -> str: ...
-    async def wait(self) -> None: ...
-    async def cancel(self) -> None: ...
-
-class JobInfo:
-    @property
-    def job_id(self) -> str: ...
-    @property
-    def table(self) -> str: ...
-    @property
-    def job_type(self) -> str: ...
-    @property
-    def state(self) -> str: ...
-    @property
-    def created_at_millis(self) -> int: ...
-
-class JobFailureInfo:
-    @property
-    def phase(self) -> Optional[str]: ...
-    @property
-    def message(self) -> Optional[str]: ...
-    @property
-    def retryable(self) -> Optional[bool]: ...
-
-class JobDescription:
-    @property
-    def job_id(self) -> str: ...
-    @property
-    def job_type(self) -> str: ...
-    @property
-    def state(self) -> str: ...
-    @property
-    def creation_ms(self) -> int: ...
-    @property
-    def spec_json(self) -> Optional[str]: ...
-    @property
-    def failure(self) -> Optional[JobFailureInfo]: ...
-
 class Table:
     def name(self) -> str: ...
     def __repr__(self) -> str: ...
@@ -296,28 +247,6 @@ class Table:
         name: Optional[str],
         train: Optional[bool],
     ): ...
-    async def create_index_async(
-        self,
-        column: str,
-        index: Union[
-            IvfFlat,
-            IvfSq,
-            IvfPq,
-            HnswPq,
-            HnswSq,
-            HnswFlat,
-            BTree,
-            Bitmap,
-            LabelList,
-            Fm,
-            FTS,
-        ],
-        replace: Optional[bool],
-        wait_timeout: Optional[object],
-        *,
-        name: Optional[str],
-        train: Optional[bool],
-    ) -> Job: ...
     async def list_versions(self) -> List[Dict[str, Any]]: ...
     async def version(self) -> int: ...
     async def checkout(self, version: Union[int, str]): ...
@@ -355,10 +284,6 @@ class Table:
     async def set_lsm_write_spec(self, spec: LsmWriteSpec) -> None: ...
     async def unset_lsm_write_spec(self) -> None: ...
     async def get_lsm_write_spec(self) -> Optional[LsmWriteSpec]: ...
-    async def checkpoint_lsm(self) -> None: ...
-    async def flush_lsm(self) -> None: ...
-    async def compact_lsm(self) -> None: ...
-    async def get_lsm_stats(self, include_generation_rows: bool) -> Optional[dict]: ...
     async def close_lsm_writers(self) -> None: ...
     @property
     def tags(self) -> Tags: ...
@@ -372,11 +297,6 @@ class Table:
     async def fetch_blobs(
         self, column: str, row_ids: list[int]
     ) -> pa.LargeBinaryArray: ...
-    async def fetch_blob_ranges(
-        self,
-        column: str,
-        requests: List[Tuple[int, int, int]],
-    ) -> pa.LargeBinaryArray: ...
     async def fetch_blob_files(
         self, column: str, row_ids: list[int]
     ) -> list[Optional[BlobFile]]: ...
@@ -471,7 +391,6 @@ class Query:
     def fast_search(self): ...
     def with_row_id(self): ...
     def postfilter(self): ...
-    def use_lsm(self, enable: bool): ...
     def nearest_to(self, query_vec: pa.Array) -> VectorQuery: ...
     def nearest_to_text(self, query: dict) -> FTSQuery: ...
     def order_by(self, ordering: Optional[List[ColumnOrdering]]): ...
@@ -488,7 +407,6 @@ class Query:
 class TakeQuery:
     def select(self, columns: List[str]): ...
     def with_row_id(self): ...
-    def use_lsm(self, enable: bool): ...
     async def output_schema(self) -> pa.Schema: ...
     async def execute(self) -> RecordBatchStream: ...
     async def explain_plan(self, verbose: Optional[bool]) -> str: ...
@@ -507,7 +425,6 @@ class FTSQuery:
     def fast_search(self): ...
     def with_row_id(self): ...
     def postfilter(self): ...
-    def use_lsm(self, enable: bool): ...
     def get_query(self) -> str: ...
     def add_query_vector(self, query_vec: pa.Array) -> None: ...
     def nearest_to(self, query_vec: pa.Array) -> HybridQuery: ...
@@ -535,7 +452,6 @@ class VectorQuery:
     def column(self, column: str): ...
     def distance_type(self, distance_type: str): ...
     def postfilter(self): ...
-    def use_lsm(self, enable: bool): ...
     def refine_factor(self, refine_factor: int): ...
     def nprobes(self, nprobes: int): ...
     def minimum_nprobes(self, minimum_nprobes: int): ...
@@ -559,7 +475,6 @@ class HybridQuery:
     def fast_search(self): ...
     def with_row_id(self): ...
     def postfilter(self): ...
-    def use_lsm(self, enable: bool): ...
     def distance_type(self, distance_type: str): ...
     def refine_factor(self, refine_factor: int): ...
     def nprobes(self, nprobes: int): ...
@@ -584,7 +499,6 @@ class PyQueryRequest:
     select: Optional[Union[str, List[str]]]
     fast_search: Optional[bool]
     with_row_id: Optional[bool]
-    use_lsm: Optional[bool]
     column: Optional[str]
     query_vector: Optional[List[pa.Array]]
     minimum_nprobes: Optional[int]

python/python/lancedb/db.py

@@ -45,7 +45,6 @@ from lance_namespace.errors import NamespaceNotEmptyError, TableNotFoundError
 
 from . import __version__
 from ._lancedb import connect as lancedb_connect  # type: ignore
-from .job import AsyncJob, Job
 from .table import (
     AsyncTable,
     LanceTable,
@@ -64,7 +63,6 @@ if TYPE_CHECKING:
     from .pydantic import LanceModel
 
     from ._lancedb import Connection as LanceDbConnection
-    from ._lancedb import JobDescription, JobInfo
     from .common import DATA, URI
     from .embeddings import EmbeddingFunctionConfig
     from ._lancedb import Session
@@ -180,51 +178,6 @@ class DBConnection(EnforceOverrides):
             "Namespace operations are not supported for this connection type"
         )
 
-    def namespace_exists(self, namespace_id: List[str]) -> bool:
-        """Check if a namespace exists.
-
-        Parameters
-        ----------
-        namespace_id: List[str]
-            The namespace identifier to check.
-
-        Returns
-        -------
-        bool
-            True if the namespace exists, False otherwise.
-
-        Raises
-        ------
-        NotImplementedError
-            If the connection type does not support namespace operations.
-        """
-        raise NotImplementedError(
-            "Namespace operations are not supported for this connection type"
-        )
-
-    def table_exists(self, table_id: List[str]) -> bool:
-        """Check if a table exists.
-
-        Parameters
-        ----------
-        table_id: List[str]
-            The table identifier to check (full path including namespace
-            segments and table name).
-
-        Returns
-        -------
-        bool
-            True if the table exists, False otherwise.
-
-        Raises
-        ------
-        NotImplementedError
-            If the connection type does not support namespace operations.
-        """
-        raise NotImplementedError(
-            "Namespace operations are not supported for this connection type"
-        )
-
     def list_tables(
         self,
         namespace_path: Optional[List[str]] = None,
@@ -406,7 +359,7 @@ class DBConnection(EnforceOverrides):
 
         Data is converted to Arrow before being written to disk. For maximum
         control over how data is saved, either provide the PyArrow schema to
-        convert to or else provide a [PyArrow Table][pyarrow.Table] directly.
+        convert to or else provide a [PyArrow Table](pyarrow.Table) directly.
 
         >>> import pyarrow as pa
         >>> custom_schema = pa.schema([
@@ -610,46 +563,6 @@ class DBConnection(EnforceOverrides):
         """
         raise NotImplementedError("serialize is not supported for this connection type")
 
-    def job(self, job_id: str) -> Job:
-        """A [Job][lancedb.job.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.
-        """
-        raise NotImplementedError("job is not supported for this connection type")
-
-    def list_jobs(self) -> List[JobInfo]:
-        """List server-side jobs across the database's tables."""
-        raise NotImplementedError("list_jobs is not supported for this connection type")
-
-    def get_job(self, job_id: str) -> Optional[JobDescription]:
-        """Describe a single server-side job by id.
-
-        Returns None when the server has no such job.
-        """
-        raise NotImplementedError("get_job is not supported for this connection type")
-
-    def cancel_job(self, job_id: str) -> bool:
-        """Request cancellation of a server-side job by id.
-
-        Returns True if the server accepted the cancellation, False if no
-        such job exists. Cancelling an already-terminal job is a no-op
-        success.
-        """
-        raise NotImplementedError(
-            "cancel_job is not supported for this connection type"
-        )
-
-    def job_history(self, job_id: Optional[str] = None) -> List[pa.RecordBatch]:
-        """The lifecycle event history of a server-side job, as Arrow batches.
-
-        Lists history across all jobs when `job_id` is None.
-        """
-        raise NotImplementedError(
-            "job_history is not supported for this connection type"
-        )
-
 
 class LanceDBConnection(DBConnection):
     """
@@ -707,9 +620,6 @@ class LanceDBConnection(DBConnection):
         self._namespace_client_properties = namespace_client_properties
         if _inner is not None:
             self._conn = _inner
-            # Native-derived wrappers resolve this in their async reconstruction
-            # path so construction never synchronously re-enters LOOP.
-            self._read_consistency_interval = read_consistency_interval
             self._cached_namespace_client = None
             return
 
@@ -759,14 +669,11 @@ class LanceDBConnection(DBConnection):
         # storage_options.  Also, this class really shouldn't be holding any state
         # beyond _conn.
         self._conn = AsyncConnection(LOOP.run(do_connect()))
-        # Keep property access synchronous so debugger introspection cannot wait on
-        # the background loop while that thread is suspended at a breakpoint.
-        self._read_consistency_interval = read_consistency_interval
         self._cached_namespace_client: Optional[LanceNamespace] = None
 
     @property
     def read_consistency_interval(self) -> Optional[timedelta]:
-        return self._read_consistency_interval
+        return LOOP.run(self._conn.get_read_consistency_interval())
 
     @property
     def session(self) -> Optional[Session]:
@@ -777,19 +684,15 @@ class LanceDBConnection(DBConnection):
         return self._conn.uri
 
     @classmethod
-    def from_inner(
-        cls,
-        inner: LanceDbConnection,
-        read_consistency_interval: Optional[timedelta],
-    ):
-        return cls(
-            None,
-            read_consistency_interval=read_consistency_interval,
-            _inner=inner,
-        )
+    def from_inner(cls, inner: LanceDbConnection):
+        return cls(None, _inner=inner)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(uri={self._conn.uri!r})"
+        val = f"{self.__class__.__name__}(uri={self._conn.uri!r}"
+        if self.read_consistency_interval is not None:
+            val += f", read_consistency_interval={repr(self.read_consistency_interval)}"
+        val += ")"
+        return val
 
     @override
     def serialize(self) -> str:
@@ -1226,47 +1129,6 @@ class LanceDBConnection(DBConnection):
             )
         )
 
-    @override
-    def job(self, job_id: str) -> Job:
-        """A [Job][lancedb.job.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.
-        """
-        return Job(self._conn.job(job_id))
-
-    @override
-    def list_jobs(self) -> List[JobInfo]:
-        """List server-side jobs across the database's tables."""
-        return LOOP.run(self._conn.list_jobs())
-
-    @override
-    def get_job(self, job_id: str) -> Optional[JobDescription]:
-        """Describe a single server-side job by id.
-
-        Returns None when the server has no such job.
-        """
-        return LOOP.run(self._conn.get_job(job_id))
-
-    @override
-    def cancel_job(self, job_id: str) -> bool:
-        """Request cancellation of a server-side job by id.
-
-        Returns True if the server accepted the cancellation, False if no
-        such job exists. Cancelling an already-terminal job is a no-op
-        success.
-        """
-        return LOOP.run(self._conn.cancel_job(job_id))
-
-    @override
-    def job_history(self, job_id: Optional[str] = None) -> List[pa.RecordBatch]:
-        """The lifecycle event history of a server-side job, as Arrow batches.
-
-        Lists history across all jobs when `job_id` is None.
-        """
-        return LOOP.run(self._conn.job_history(job_id))
-
     @override
     def namespace_client(self) -> LanceNamespace:
         """Get the equivalent namespace client for this connection.
@@ -1667,7 +1529,7 @@ class AsyncConnection(object):
 
         Data is converted to Arrow before being written to disk. For maximum
         control over how data is saved, either provide the PyArrow schema to
-        convert to or else provide a [PyArrow Table][pyarrow.Table] directly.
+        convert to or else provide a [PyArrow Table](pyarrow.Table) directly.
 
         >>> import pyarrow as pa
         >>> custom_schema = pa.schema([
@@ -1976,43 +1838,6 @@ class AsyncConnection(object):
             namespace_path = []
         await self._inner.drop_all_tables(namespace_path=namespace_path)
 
-    def job(self, job_id: str) -> AsyncJob:
-        """An [AsyncJob][lancedb.job.AsyncJob] 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.
-        """
-        return AsyncJob(self._inner.job(job_id))
-
-    async def list_jobs(self) -> List[JobInfo]:
-        """List server-side jobs across the database's tables."""
-        return await self._inner.list_jobs()
-
-    async def get_job(self, job_id: str) -> Optional[JobDescription]:
-        """Describe a single server-side job by id.
-
-        Returns None when the server has no such job.
-        """
-        return await self._inner.get_job(job_id)
-
-    async def cancel_job(self, job_id: str) -> bool:
-        """Request cancellation of a server-side job by id.
-
-        Returns True if the server accepted the cancellation, False if no
-        such job exists. Cancelling an already-terminal job is a no-op
-        success.
-        """
-        return await self._inner.cancel_job(job_id)
-
-    async def job_history(self, job_id: Optional[str] = None) -> List[pa.RecordBatch]:
-        """The lifecycle event history of a server-side job, as Arrow batches.
-
-        Lists history across all jobs when `job_id` is None.
-        """
-        return await self._inner.job_history(job_id)
-
     async def namespace_client(self) -> LanceNamespace:
         """Get the equivalent namespace client for this connection.
 

python/python/lancedb/embeddings/__init__.py

@@ -21,32 +21,3 @@ from .watsonx import WatsonxEmbeddings
 from .voyageai import VoyageAIEmbeddingFunction
 from .colpali import ColPaliEmbeddings
 from .siglip import SigLipEmbeddings
-
-# The API reference renders this package with a single mkdocstrings directive,
-# which only picks up names listed here. New embedding functions must be added
-# to both the imports above and this list, or they will silently go undocumented.
-__all__ = [
-    "EmbeddingFunction",
-    "EmbeddingFunctionConfig",
-    "TextEmbeddingFunction",
-    "EmbeddingFunctionRegistry",
-    "get_registry",
-    "register",
-    "SentenceTransformerEmbeddings",
-    "OpenAIEmbeddings",
-    "OpenClipEmbeddings",
-    "BedRockText",
-    "CohereEmbeddingFunction",
-    "GeminiText",
-    "GteEmbeddings",
-    "InstructorEmbeddingFunction",
-    "JinaEmbeddings",
-    "OllamaEmbeddings",
-    "TransformersEmbeddingFunction",
-    "ColbertEmbeddings",
-    "VoyageAIEmbeddingFunction",
-    "WatsonxEmbeddings",
-    "ColPaliEmbeddings",
-    "ImageBindEmbeddings",
-    "SigLipEmbeddings",
-]

python/python/lancedb/embeddings/bedrock.py

@@ -21,20 +21,20 @@ class BedRockText(TextEmbeddingFunction):
     """
     Parameters
     ----------
-    name : str, default "amazon.titan-embed-text-v1"
+    name: str, default "amazon.titan-embed-text-v1"
         The model ID of the bedrock model to use. Supported models for are:
         - amazon.titan-embed-text-v1
         - cohere.embed-english-v3
         - cohere.embed-multilingual-v3
-    region : str, default "us-east-1"
+    region: str, default "us-east-1"
         Optional name of the AWS Region in which the service should be called.
-    profile_name : str, default None
+    profile_name: str, default None
         Optional name of the AWS profile to use for calling the Bedrock service.
         If not specified, the default profile will be used.
-    assumed_role : str, default None
+    assumed_role: str, default None
         Optional ARN of an AWS IAM role to assume for calling the Bedrock service.
         If not specified, the current active credentials will be used.
-    role_session_name : str, default "lancedb-embeddings"
+    role_session_name: str, default "lancedb-embeddings"
         Optional name of the AWS IAM role session to use for calling the Bedrock
         service. If not specified, "lancedb-embeddings" name will be used.
 

python/python/lancedb/embeddings/cohere.py

@@ -22,7 +22,7 @@ class CohereEmbeddingFunction(TextEmbeddingFunction):
 
     Parameters
     ----------
-    name : str, default "embed-multilingual-v2.0"
+    name: str, default "embed-multilingual-v2.0"
         The name of the model to use. List of acceptable models:
 
             * embed-english-v3.0
@@ -33,14 +33,12 @@ class CohereEmbeddingFunction(TextEmbeddingFunction):
             * embed-english-light-v2.0
             * embed-multilingual-v2.0
 
-    source_input_type : str, default "search_document"
+    source_input_type: str, default "search_document"
         The input type for the source column in the database
 
-    query_input_type : str, default "search_query"
+    query_input_type: str, default "search_query"
         The input type for the query column in the database
 
-    Notes
-    -----
     Cohere supports following input types:
 
     | Input Type               | Description                          |

python/python/lancedb/embeddings/colpali.py

@@ -44,7 +44,7 @@ class ColPaliEmbeddings(EmbeddingFunction):
         The token pooling strategy to use, by default "hierarchical".
         - "hierarchical": Progressively pools tokens to reduce sequence length.
         - "lambda": A simpler pooling that uses a custom `pooling_func`.
-    pooling_func : typing.Callable, optional
+    pooling_func: typing.Callable, optional
         A function to use for pooling when `pooling_strategy` is "lambda".
     pool_factor : int
         Factor to reduce sequence length if token pooling is enabled (default 2).
@@ -52,7 +52,7 @@ class ColPaliEmbeddings(EmbeddingFunction):
         Quantization configuration for the model. (default None, bitsandbytes needed)
     batch_size : int
         Batch size for processing inputs (default 2).
-    offload_folder : str, optional
+    offload_folder: str, optional
         Folder to offload model weights if using CPU offloading (default None). This is
         useful for large models that do not fit in memory.
     """

python/python/lancedb/embeddings/gemini_text.py

@@ -48,16 +48,16 @@ class GeminiText(TextEmbeddingFunction):
 
     Parameters
     ----------
-    name : str, default "gemini-embedding-001"
+    name: str, default "gemini-embedding-001"
         The name of the model to use. Supported models include:
         - "gemini-embedding-001" (768 dimensions)
 
         Note: The legacy "models/embedding-001" format is also supported but
         "gemini-embedding-001" is recommended.
 
-    query_task_type : str, default "retrieval_query"
+    query_task_type: str, default "retrieval_query"
         Sets the task type for the queries.
-    source_task_type : str, default "retrieval_document"
+    source_task_type: str, default "retrieval_document"
         Sets the task type for ingestion.
 
     Examples

python/python/lancedb/embeddings/gte.py

@@ -26,13 +26,13 @@ class GteEmbeddings(TextEmbeddingFunction):
 
     Parameters
     ----------
-    name : str, default "thenlper/gte-large"
+    name: str, default "thenlper/gte-large"
         The name of the model to use.
-    device : str, default "cpu"
+    device: str, default "cpu"
         Sets the device type for the model.
-    normalize : str, default "True"
+    normalize: str, default "True"
         Controls normalize param in encode function for the transformer.
-    mlx : bool, default False
+    mlx: bool, default False
         Controls which model to use. False for gte-large,True for the mlx version.
 
     Examples

python/python/lancedb/embeddings/instructor.py

@@ -35,23 +35,23 @@ class InstructorEmbeddingFunction(TextEmbeddingFunction):
 
     Parameters
     ----------
-    name : str
+    name: str
         The name of the model to use. Available models are listed at
         https://github.com/xlang-ai/instructor-embedding#model-list;
         The default model is hkunlp/instructor-base
-    batch_size : int, default 32
+    batch_size: int, default 32
         The batch size to use when generating embeddings
-    device : str, default "cpu"
+    device: str, default "cpu"
         The device to use when generating embeddings
-    show_progress_bar : bool, default True
+    show_progress_bar: bool, default True
         Whether to show a progress bar when generating embeddings
-    normalize_embeddings : bool, default True
+    normalize_embeddings: bool, default True
         Whether to normalize the embeddings
-    quantize : bool, default False
+    quantize: bool, default False
         Whether to quantize the model
-    source_instruction : str, default "represent the document for retrieval"
+    source_instruction: str, default "represent the document for retrieval"
         The instruction for the source column
-    query_instruction : str, default "represent the document for retrieving the most
+    query_instruction: str, default "represent the document for retrieving the most
         similar documents"
         The instruction for the query
 
@@ -101,7 +101,8 @@ class InstructorEmbeddingFunction(TextEmbeddingFunction):
 
     @weak_lru(maxsize=1)
     def ndims(self):
-        return len(self.generate_embeddings([[self.source_instruction, "foo"]])[0])
+        model = self.get_model()
+        return model.encode("foo").shape[0]
 
     def compute_query_embeddings(self, query: str, *args, **kwargs) -> List[np.array]:
         return self.generate_embeddings([[self.query_instruction, query]])

python/python/lancedb/embeddings/jinaai.py

@@ -40,10 +40,10 @@ class JinaEmbeddings(EmbeddingFunction):
 
     Parameters
     ----------
-    name : str, default "jina-clip-v1". Note that some models support both image
+    name: str, default "jina-clip-v1". Note that some models support both image
         and text embeddings and some just text embedding
 
-    api_key : str, default None
+    api_key: str, default None
         The api key to access Jina API. If you pass None, you can set JINA_API_KEY
         environment variable
 
@@ -87,13 +87,12 @@ class JinaEmbeddings(EmbeddingFunction):
         if isinstance(image, bytes):
             image_dict = {"image": base64.b64encode(image).decode("utf-8")}
         elif isinstance(image, (str, Path)):
-            parsed = urlparse(str(image))
+            parsed = urlparse.urlparse(image)
+            # TODO handle drive letter on windows.
             PIL_Image = attempt_import_or_raise("PIL.Image", "pillow")
             if parsed.scheme == "file":
                 pil_image = PIL_Image.open(parsed.path)
-            elif parsed.scheme == "" or (os.name == "nt" and len(parsed.scheme) == 1):
-                # A Windows drive letter parses as a one-character scheme
-                # ("C:\\img.png" -> scheme="c"), so treat it as a local path.
+            elif parsed.scheme == "":
                 pil_image = PIL_Image.open(image if os.name == "nt" else parsed.path)
             elif parsed.scheme.startswith("http"):
                 pil_image = PIL_Image.open(io.BytesIO(url_retrieve(image)))

python/python/lancedb/embeddings/sentence_transformers.py

@@ -21,13 +21,13 @@ class SentenceTransformerEmbeddings(TextEmbeddingFunction):
 
     Parameters
     ----------
-    name : str, default "all-MiniLM-L6-v2"
+    name: str, default "all-MiniLM-L6-v2"
         The name of the model to use.
-    device : str, default "cpu"
+    device: str, default "cpu"
         The device to use for the model
-    normalize : bool, default True
+    normalize: bool, default True
         Whether to normalize the embeddings
-    trust_remote_code : bool, default True
+    trust_remote_code: bool, default True
         Whether to trust the remote code
     """
 

python/python/lancedb/embeddings/voyageai.py

@@ -167,7 +167,7 @@ class VoyageAIEmbeddingFunction(EmbeddingFunction):
 
     Parameters
     ----------
-    name : str
+    name: str
         The name of the model to use. List of acceptable models:
 
             * voyage-4 (1024 dims, general-purpose and multilingual retrieval)
@@ -185,7 +185,7 @@ class VoyageAIEmbeddingFunction(EmbeddingFunction):
             * voyage-law-2
             * voyage-code-2
 
-    output_dimension : int, optional
+    output_dimension: int, optional
         The output dimension for models that support flexible dimensions.
         Currently only voyage-multimodal-3.5 supports this feature.
         Valid options: 256, 512, 1024 (default), 2048.

python/python/lancedb/exceptions.py

@@ -23,15 +23,3 @@ class MissingColumnError(KeyError):
         return (
             f"Error: Column '{self.column_name}' does not exist in the DataFrame object"
         )
-
-
-class JobFailedError(RuntimeError):
-    """Exception raised when an asynchronous job reaches the failed state."""
-
-    pass
-
-
-class JobCancelledError(RuntimeError):
-    """Exception raised when an asynchronous job was cancelled."""
-
-    pass

python/python/lancedb/index.py

@@ -2,7 +2,7 @@
 # SPDX-FileCopyrightText: Copyright The LanceDB Authors
 
 from dataclasses import dataclass
-from typing import List, Literal, Optional
+from typing import Literal, Optional
 
 from ._lancedb import (
     IndexConfig,
@@ -115,12 +115,6 @@ class FTS:
 
     For example, it works with `title`, `description`, `content`, etc.
 
-    Examples
-    --------
-    Create an index configuration that uses 256-document posting blocks:
-
-    >>> config = FTS(block_size=256)
-
     Attributes
     ----------
     with_position : bool, default False
@@ -151,18 +145,9 @@ class FTS:
     remove_stop_words : bool, default True
         Whether to remove stop words. Stop words are common words that are often
         removed from text before indexing. For example, in English "the" and "and".
-    custom_stop_words : list of str, optional
-        Custom words replace the built-in language stop words
-        and only take effect when ``remove_stop_words`` is True. ``None`` uses
-        the built-in language list, while an empty list explicitly uses no
-        stop words.
     ascii_folding : bool, default True
         Whether to fold ASCII characters. This converts accented characters to
         their ASCII equivalent. For example, "café" would be converted to "cafe".
-    block_size : int, default 128
-        The number of documents per compressed posting block. Supported values
-        are 128 and 256. A value of 256 uses the experimental FTS V3 format
-        and may introduce breaking changes.
 
     Notes
     -----
@@ -183,8 +168,6 @@ class FTS:
     ngram_min_length: int = 3
     ngram_max_length: int = 3
     prefix_only: bool = False
-    block_size: int = 128
-    custom_stop_words: Optional[List[str]] = None
 
 
 @dataclass
@@ -219,7 +202,7 @@ class HnswPq:
         distance has a range of (-∞, ∞). If the vectors are normalized (i.e. their
         l2 norm is 1), then dot distance is equivalent to the cosine distance.
 
-    num_partitions: int, default sqrt(num_rows)
+    num_partitions, default sqrt(num_rows)
 
         The number of IVF partitions to create.
 
@@ -228,7 +211,7 @@ class HnswPq:
         will require too much memory. Each partition becomes its own HNSW graph, so
         setting this value higher reduces the peak memory use of training.
 
-    num_sub_vectors: int, default is vector dimension / 16
+    num_sub_vectors, default is vector dimension / 16
 
         Number of sub-vectors of PQ.
 
@@ -244,13 +227,13 @@ class HnswPq:
         If the dimension is not visible by 8 then we use 1 subvector.  This is not
         ideal and will likely result in poor performance.
 
-    num_bits: int, default 8
+     num_bits: int, default 8
         Number of bits to encode each sub-vector.
 
         This value controls how much the sub-vectors are compressed.  The more bits
         the more accurate the index but the slower search. Only 4 and 8 are supported.
 
-    max_iterations: int, default 50
+    max_iterations, default 50
 
         Max iterations to train kmeans.
 
@@ -263,7 +246,7 @@ class HnswPq:
         those cases it is unlikely that setting this larger will lead to the index
         converging anyways.
 
-    sample_rate: int, default 256
+    sample_rate, default 256
 
         The rate used to calculate the number of training vectors for kmeans.
 
@@ -279,14 +262,14 @@ class HnswPq:
         Increasing this value might improve the quality of the index but in
         most cases the default should be sufficient.
 
-    m: int, default 20
+    m, default 20
 
         The number of neighbors to select for each vector in the HNSW graph.
 
         This value controls the tradeoff between search speed and accuracy.
         The higher the value the more accurate the search but the slower it will be.
 
-    ef_construction: int, default 300
+    ef_construction, default 300
 
         The number of candidates to evaluate during the construction of the HNSW graph.
 
@@ -297,7 +280,7 @@ class HnswPq:
         This value should be set to a value that is not less than `ef` in the
         search phase.
 
-    target_partition_size: int, default is 1,048,576
+    target_partition_size, default is 1,048,576
 
         The target size of each partition.
 
@@ -351,7 +334,7 @@ class HnswSq:
         distance has a range of (-∞, ∞). If the vectors are normalized (i.e. their
         l2 norm is 1), then dot distance is equivalent to the cosine distance.
 
-    num_partitions: int, default sqrt(num_rows)
+    num_partitions, default sqrt(num_rows)
 
         The number of IVF partitions to create.
 
@@ -360,7 +343,7 @@ class HnswSq:
         will require too much memory. Each partition becomes its own HNSW graph, so
         setting this value higher reduces the peak memory use of training.
 
-    max_iterations: int, default 50
+    max_iterations, default 50
 
         Max iterations to train kmeans.
 
@@ -373,7 +356,7 @@ class HnswSq:
         In those cases it is unlikely that setting this larger will lead to
         the index converging anyways.
 
-    sample_rate: int, default 256
+    sample_rate, default 256
 
         The rate used to calculate the number of training vectors for kmeans.
 
@@ -389,14 +372,14 @@ class HnswSq:
         Increasing this value might improve the quality of the index but in
         most cases the default should be sufficient.
 
-    m: int, default 20
+    m, default 20
 
         The number of neighbors to select for each vector in the HNSW graph.
 
         This value controls the tradeoff between search speed and accuracy.
         The higher the value the more accurate the search but the slower it will be.
 
-    ef_construction: int, default 300
+    ef_construction, default 300
 
         The number of candidates to evaluate during the construction of the HNSW graph.
 
@@ -407,7 +390,7 @@ class HnswSq:
         This value should be set to a value that is not less than `ef` in the search
         phase.
 
-    target_partition_size: int, default is 1,048,576
+    target_partition_size, default is 1,048,576
 
         The target size of each partition.
 
@@ -460,7 +443,7 @@ class HnswFlat:
         distance has a range of (-∞, ∞). If the vectors are normalized (i.e. their
         l2 norm is 1), then dot distance is equivalent to the cosine distance.
 
-    num_partitions: int, default sqrt(num_rows)
+    num_partitions, default sqrt(num_rows)
 
         The number of IVF partitions to create.
 
@@ -470,18 +453,18 @@ class HnswFlat:
         graph, so setting this value higher reduces the peak memory use of
         training.
 
-    max_iterations: int, default 50
+    max_iterations, default 50
 
         Max iterations to train kmeans.
 
         When training an IVF index we use kmeans to calculate the partitions.
         This parameter controls how many iterations of kmeans to run.
 
-    sample_rate: int, default 256
+    sample_rate, default 256
 
         The rate used to calculate the number of training vectors for kmeans.
 
-    m: int, default 20
+    m, default 20
 
         The number of neighbors to select for each vector in the HNSW graph.
 
@@ -489,7 +472,7 @@ class HnswFlat:
         The higher the value the more accurate the search but the slower it
         will be.
 
-    ef_construction: int, default 300
+    ef_construction, default 300
 
         The number of candidates to evaluate during the construction of the HNSW
         graph.
@@ -501,7 +484,7 @@ class HnswFlat:
         than 500.  This value should be set to a value that is not less than `ef`
         in the search phase.
 
-    target_partition_size: int, default is 1,048,576
+    target_partition_size, default is 1,048,576
 
         The target size of each partition.
     """
@@ -605,7 +588,7 @@ class IvfFlat:
 
         The default value is 256.
 
-    target_partition_size: int, default is 8192
+    target_partition_size, default is 8192
 
         The target size of each partition.
 
@@ -769,7 +752,7 @@ class IvfPq:
 
         The default value is 256.
 
-    target_partition_size: int, default is 8192
+    target_partition_size, default is 8192
 
         The target size of each partition.
 
@@ -830,7 +813,7 @@ class IvfRq:
     sample_rate: int, default 256
         Controls the number of training vectors: sample_rate * num_partitions.
 
-    target_partition_size: int, default is 8192
+    target_partition_size, default is 8192
         Target size of each partition.
     """
 
@@ -845,9 +828,6 @@ class IvfRq:
     accelerator: Optional[str] = None
 
 
-# The API reference renders this module with a single mkdocstrings directive,
-# which only picks up names listed here. New public names must be added to this
-# list, or they will silently go undocumented.
 __all__ = [
     "BTree",
     "IvfPq",

python/python/lancedb/job.py

@@ -1,105 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-"""Handles to operations a server may run asynchronously."""
-
-import asyncio
-from datetime import timedelta
-from typing import Optional
-
-from lancedb.background_loop import LOOP
-
-from . import _lancedb
-
-
-class AsyncJob:
-    """A handle to an operation that may still be running.
-
-    The operation may already be complete when the handle is created.
-    """
-
-    def __init__(self, inner: Optional["_lancedb.Job"]):
-        self._inner = inner
-
-    @property
-    def id(self) -> Optional[str]:
-        """Identifies the operation on the server that is running it.
-
-        Returned for correlating with server logs or the jobs API. Operations
-        that run in this process have no server id and return `None`. The value
-        is opaque: parsing it or storing it to resume the job later is not
-        supported.
-        """
-        return self._inner.id if self._inner is not None else None
-
-    async def status(self) -> str:
-        """The operation's current lifecycle state: "running", "finished",
-        "failed", or "cancelled".
-
-        A point snapshot; unlike `wait` it does not block or raise on a
-        terminal failure state. States a newer server reports that this
-        client version does not know pass through as-is.
-        """
-        if self._inner is None:
-            return "finished"
-        return await self._inner.status()
-
-    async def wait(self, timeout: Optional[timedelta] = None):
-        """Wait until the operation reaches a terminal state.
-
-        Raises `JobFailedError` if the operation failed, `JobCancelledError`
-        if it was cancelled, and `TimeoutError` if `timeout` elapses first.
-        """
-        if self._inner is None:
-            return
-        if timeout is None:
-            await self._inner.wait()
-        else:
-            await asyncio.wait_for(self._inner.wait(), timeout.total_seconds())
-
-    async def cancel(self):
-        """Request cancellation. Cancelling a finished operation is a no-op."""
-        if self._inner is None:
-            return
-        await self._inner.cancel()
-
-
-class Job:
-    """Synchronous counterpart of `AsyncJob`."""
-
-    def __init__(self, inner: Optional[AsyncJob]):
-        self._inner = inner
-
-    @property
-    def id(self) -> Optional[str]:
-        """Identifies the operation on the server that is running it.
-
-        See :attr:`AsyncJob.id`.
-        """
-        return self._inner.id if self._inner is not None else None
-
-    def status(self) -> str:
-        """The operation's current lifecycle state: "running", "finished",
-        "failed", or "cancelled".
-
-        See :meth:`AsyncJob.status`.
-        """
-        if self._inner is None:
-            return "finished"
-        return LOOP.run(self._inner.status())
-
-    def wait(self, timeout: Optional[timedelta] = None):
-        """Block until the operation reaches a terminal state.
-
-        Raises `JobFailedError` if the operation failed, `JobCancelledError`
-        if it was cancelled, and `TimeoutError` if `timeout` elapses first.
-        """
-        if self._inner is None:
-            return
-        LOOP.run(self._inner.wait(timeout))
-
-    def cancel(self):
-        """Request cancellation. Cancelling a finished operation is a no-op."""
-        if self._inner is None:
-            return
-        LOOP.run(self._inner.cancel())

python/python/lancedb/merge.py

@@ -37,7 +37,7 @@ class LanceMergeInsertBuilder(object):
         self._when_not_matched_by_source_condition_expr = None
         self._timeout = None
         self._use_index = True
-        self._use_lsm = None
+        self._use_lsm_write = None
         self._validate_single_shard = None
 
     def when_matched_update_all(
@@ -92,10 +92,8 @@ class LanceMergeInsertBuilder(object):
         self._when_not_matched_by_source_delete = True
         if isinstance(condition, Expr):
             self._when_not_matched_by_source_condition_expr = condition._inner
-            self._when_not_matched_by_source_condition = None
-        else:
+        elif condition is not None:
             self._when_not_matched_by_source_condition = condition
-            self._when_not_matched_by_source_condition_expr = None
         return self
 
     def use_index(self, use_index: bool) -> LanceMergeInsertBuilder:
@@ -115,22 +113,22 @@ class LanceMergeInsertBuilder(object):
         self._use_index = use_index
         return self
 
-    def use_lsm(self, enable: bool) -> LanceMergeInsertBuilder:
+    def use_lsm_write(self, use_lsm_write: bool) -> LanceMergeInsertBuilder:
         """
-        Control MemWAL routing for this merge.
+        Controls whether the merge uses the MemWAL LSM write path.
 
-        By default (unset), a `merge_insert` 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.
+        By default (unset), a `merge_insert` 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. Pass `False` to force the standard path even
+        when a spec is set. Pass `True` to require a spec — `merge_insert`
+        raises an error if none is installed.
 
         Parameters
         ----------
-        enable: bool
-            ``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.
+        use_lsm_write: bool
+            Whether to use the LSM write path.
         """
-        self._use_lsm = enable
+        self._use_lsm_write = use_lsm_write
         return self
 
     def validate_single_shard(

python/python/lancedb/namespace.py

@@ -38,11 +38,7 @@ from lance_namespace_urllib3_client.models.query_table_request_vector import (
     QueryTableRequestVector,
 )
 from lance_namespace_urllib3_client.models.string_fts_query import StringFtsQuery
-from lance_namespace.errors import (
-    NamespaceNotEmptyError,
-    NamespaceNotFoundError,
-    TableNotFoundError,
-)
+from lance_namespace.errors import NamespaceNotEmptyError, TableNotFoundError
 from lancedb._lancedb import (
     connect_namespace as _connect_namespace,
     connect_namespace_client as _connect_namespace_client,
@@ -57,8 +53,6 @@ from lance_namespace import (
     DropNamespaceResponse,
     ListNamespacesResponse,
     ListTablesResponse,
-    NamespaceExistsRequest,
-    TableExistsRequest,
 )
 from lancedb.table import AsyncTable, LanceTable, Table
 from lancedb.util import validate_table_name
@@ -786,51 +780,6 @@ class LanceNamespaceDBConnection(DBConnection):
         """
         return LOOP.run(self._inner.describe_namespace(namespace_path))
 
-    @override
-    def namespace_exists(self, namespace_id: List[str]) -> bool:
-        """
-        Check if a namespace exists.
-
-        Parameters
-        ----------
-        namespace_id : List[str]
-            The namespace identifier to check.
-
-        Returns
-        -------
-        bool
-            True if the namespace exists, False otherwise.
-        """
-        request = NamespaceExistsRequest(id=namespace_id)
-        try:
-            self._namespace_client.namespace_exists(request)
-            return True
-        except NamespaceNotFoundError:
-            return False
-
-    @override
-    def table_exists(self, table_id: List[str]) -> bool:
-        """
-        Check if a table exists.
-
-        Parameters
-        ----------
-        table_id : List[str]
-            The table identifier to check (full path including namespace
-            segments and table name).
-
-        Returns
-        -------
-        bool
-            True if the table exists, False otherwise.
-        """
-        request = TableExistsRequest(id=table_id)
-        try:
-            self._namespace_client.table_exists(request)
-            return True
-        except TableNotFoundError:
-            return False
-
     @override
     def list_tables(
         self,
@@ -1284,49 +1233,6 @@ class AsyncLanceNamespaceDBConnection:
         """
         return await self._inner.describe_namespace(namespace_path)
 
-    async def namespace_exists(self, namespace_id: List[str]) -> bool:
-        """
-        Check if a namespace exists.
-
-        Parameters
-        ----------
-        namespace_id : List[str]
-            The namespace identifier to check.
-
-        Returns
-        -------
-        bool
-            True if the namespace exists, False otherwise.
-        """
-        request = NamespaceExistsRequest(id=namespace_id)
-        try:
-            self._namespace_client.namespace_exists(request)
-            return True
-        except NamespaceNotFoundError:
-            return False
-
-    async def table_exists(self, table_id: List[str]) -> bool:
-        """
-        Check if a table exists.
-
-        Parameters
-        ----------
-        table_id : List[str]
-            The table identifier to check (full path including namespace
-            segments and table name).
-
-        Returns
-        -------
-        bool
-            True if the table exists, False otherwise.
-        """
-        request = TableExistsRequest(id=table_id)
-        try:
-            self._namespace_client.table_exists(request)
-            return True
-        except TableNotFoundError:
-            return False
-
     async def list_tables(
         self,
         namespace_path: Optional[List[str]] = None,

python/python/lancedb/permutation.py

@@ -226,7 +226,7 @@ class PermutationBuilder:
 
         async def do_execute():
             inner_tbl = await self._async.execute()
-            return await LanceTable.from_inner(inner_tbl)
+            return LanceTable.from_inner(inner_tbl)
 
         return LOOP.run(do_execute())
 
@@ -438,8 +438,7 @@ class Permutation:
         _reader: Optional[PermutationReader] = None,
     ):
         """
-        Internal constructor.  Use
-        [from_tables][lancedb.permutation.Permutation.from_tables] instead.
+        Internal constructor.  Use [from_tables](#from_tables) instead.
         """
         assert base_table is not None, "base_table is required"
         assert selection is not None, "selection is required"
@@ -986,9 +985,8 @@ class Permutation:
         types.  Conversion of strings, lists, and structs will require creating python
         objects and this is not zero-copy.
 
-        For custom formatting, use
-        [with_transform][lancedb.permutation.Permutation.with_transform] which
-        overrides this method.
+        For custom formatting, use [with_transform](#with_transform) which overrides
+        this method.
         """
         assert format is not None, "format is required"
         if format == "python":
@@ -1063,8 +1061,7 @@ class Permutation:
         Note: this method returns a new permutation and does not modify `self`
         It is provided for compatibility with the huggingface Dataset API.
 
-        Use [with_skip][lancedb.permutation.Permutation.with_skip] instead to
-        avoid confusion.
+        Use [with_skip](#with_skip) instead to avoid confusion.
         """
         return self.with_skip(skip)
 
@@ -1087,8 +1084,7 @@ class Permutation:
         Note: this method returns a new permutation and does not modify `self`
         It is provided for compatibility with the huggingface Dataset API.
 
-        Use [with_take][lancedb.permutation.Permutation.with_take] instead to
-        avoid confusion.
+        Use [with_take](#with_take) instead to avoid confusion.
         """
         return self.with_take(limit)
 
@@ -1111,8 +1107,7 @@ class Permutation:
         Note: this method returns a new permutation and does not modify `self`
         It is provided for compatibility with the huggingface Dataset API.
 
-        Use [with_repeat][lancedb.permutation.Permutation.with_repeat] instead
-        to avoid confusion.
+        Use [with_repeat](#with_repeat) instead to avoid confusion.
         """
         return self.with_repeat(times)
 

python/python/lancedb/py.typed

@@ -1 +0,0 @@
-

python/python/lancedb/pydantic.py

@@ -153,16 +153,6 @@ def Vector(
     return FixedSizeList
 
 
-def _raise_bare_vector_error(*_args):
-    raise TypeError("Vector must be parameterized with a dimension, e.g. Vector(128).")
-
-
-# Pydantic v1 and v2 otherwise treat the bare Vector factory as a field validator
-# and inspect its signature, which produces misleading errors about internal types.
-setattr(Vector, "__get_validators__", _raise_bare_vector_error)
-setattr(Vector, "__get_pydantic_core_schema__", _raise_bare_vector_error)
-
-
 def MultiVector(
     dim: int, value_type: pa.DataType = pa.float32(), nullable: bool = True
 ) -> Type:

python/python/lancedb/query.py

@@ -52,6 +52,7 @@ from ._blob import (
     finalize_blob_query_table,
     replace_v2_blob_columns_with_bytes,
     replace_v2_blob_columns_with_bytes_sync,
+    supports_blob_auto_row_id,
     validate_blob_mode,
 )
 from .types import BlobMode, QueryProjection
@@ -650,8 +651,7 @@ class Query(pydantic.BaseModel):
     distance_type : Optional[str]
         the distance type to use for vector search
 
-        This can be l2 (default), cosine and dot.  See
-        [metric definitions](https://lancedb.com/docs/search/vector-search/) for
+        This can be l2 (default), cosine and dot.  See [metric definitions][search] for
         more details.
 
         If this is not a vector search this will be None.
@@ -664,9 +664,8 @@ class Query(pydantic.BaseModel):
 
         - A higher number makes search more accurate but also slower.
 
-        - See discussion in
-          [Querying an ANN Index](https://lancedb.com/docs/indexing/)
-          for tuning advice.
+        - See discussion in [Querying an ANN Index][querying-an-ann-index] for
+          tuning advice.
 
         Will be None if this is not a vector search.
     refine_factor : Optional[int]
@@ -674,9 +673,8 @@ class Query(pydantic.BaseModel):
 
         - A higher number makes search more accurate but also slower.
 
-        - See discussion in
-          [Querying an ANN Index](https://lancedb.com/docs/indexing/)
-          for tuning advice.
+        - See discussion in [Querying an ANN Index][querying-an-ann-index] for
+          tuning advice.
 
         Will be None if this is not a vector search.
     lower_bound : Optional[float]
@@ -780,11 +778,6 @@ class Query(pydantic.BaseModel):
     # if true, will only search the indexed data
     fast_search: Optional[bool] = None
 
-    # MemWAL LSM read routing: None auto-routes when the table carries a write
-    # spec, True forces the LSM scanner (errors without a spec), False reads the
-    # base table only
-    use_lsm: Optional[bool] = None
-
     # size of the nearest neighbor list maintained during HNSW search
     ef: Optional[int] = None
 
@@ -802,9 +795,6 @@ class Query(pydantic.BaseModel):
         query.full_text_query = req.full_text_search
         query.columns = req.select
         query.with_row_id = req.with_row_id
-        # use_lsm is a genuine tri-state (None / True / False); preserve it as-is
-        # so a round-tripped query keeps an explicit False.
-        query.use_lsm = req.use_lsm
         query.vector_column = req.column
         query.vector = req.query_vector
         query.distance_type = req.distance_type
@@ -977,7 +967,6 @@ class LanceQueryBuilder(ABC):
         self._with_row_address = None
         self._fragments = None
         self._fragment_ids = None
-        self._use_lsm = None
         self._vector = None
         self._text = None
         self._ef = None
@@ -1279,7 +1268,10 @@ class LanceQueryBuilder(ABC):
         return self._with_row_id is True
 
     def _blob_auto_row_id_enabled(self) -> bool:
+        if not supports_blob_auto_row_id(self._table):
+            return False
         return blob_auto_row_id_for_scan(
+            self._table,
             self._table.schema,
             self._columns,
             with_row_id=self._with_row_id,
@@ -1334,30 +1326,6 @@ class LanceQueryBuilder(ABC):
         self._fragment_ids = fragment_ids
         return self
 
-    def use_lsm(self, enable: bool) -> Self:
-        """Control MemWAL LSM read routing for this query.
-
-        By default (unset), a query against a table with an LSM write spec is
-        routed through the LSM scanner so it also returns data written via the
-        ``merge_insert`` LSM path that has not yet been compacted into the base
-        table (active/frozen memtables + flushed generations); a table without a
-        spec reads the base table.
-
-        Parameters
-        ----------
-        enable : bool
-            ``True`` forces the LSM scanner and errors if the table has no LSM
-            write spec. ``False`` bypasses the MemWAL and reads the base table
-            only, even when a spec is present.
-
-        Returns
-        -------
-        LanceQueryBuilder
-            The LanceQueryBuilder object.
-        """
-        self._use_lsm = enable
-        return self
-
     def explain_plan(self, verbose: Optional[bool] = False) -> str:
         """Return the execution plan for this query.
 
@@ -1650,8 +1618,8 @@ class LanceVectorQueryBuilder(LanceQueryBuilder):
         Higher values will yield better recall (more likely to find vectors if
         they exist) at the expense of latency.
 
-        See discussion in [Querying an ANN Index](https://lancedb.com/docs/indexing/)
-        for tuning advice.
+        See discussion in [Querying an ANN Index][querying-an-ann-index] for
+        tuning advice.
 
         This method sets both the minimum and maximum number of probes to the same
         value. See `minimum_nprobes` and `maximum_nprobes` for more fine-grained
@@ -1751,8 +1719,8 @@ class LanceVectorQueryBuilder(LanceQueryBuilder):
         As an example, a refine factor of 2 will sample 2x as many vectors as
         requested, re-ranks them, and returns the top half most relevant results.
 
-        See discussion in [Querying an ANN Index](https://lancedb.com/docs/indexing/)
-        for tuning advice.
+        See discussion in [Querying an ANN Index][querying-an-ann-index] for
+        tuning advice.
 
         Parameters
         ----------
@@ -1820,7 +1788,6 @@ class LanceVectorQueryBuilder(LanceQueryBuilder):
             with_row_address=self._with_row_address,
             fragments=self._fragments,
             fragment_ids=self._fragment_ids,
-            use_lsm=self._use_lsm,
             offset=self._offset,
             fast_search=self._fast_search,
             ef=self._ef,
@@ -2045,7 +2012,6 @@ class LanceFtsQueryBuilder(LanceQueryBuilder):
             with_row_address=self._with_row_address,
             fragments=self._fragments,
             fragment_ids=self._fragment_ids,
-            use_lsm=self._use_lsm,
             full_text_query=FullTextSearchQuery(
                 query=self._query_with_phrase_semantics(), columns=self._fts_columns
             ),
@@ -2112,7 +2078,6 @@ class LanceEmptyQueryBuilder(LanceQueryBuilder):
             with_row_address=self._with_row_address,
             fragments=self._fragments,
             fragment_ids=self._fragment_ids,
-            use_lsm=self._use_lsm,
             offset=self._offset,
             order_by=self._order_by,
         )
@@ -2690,14 +2655,11 @@ class LanceHybridQueryBuilder(LanceQueryBuilder):
         if self._with_row_id:
             self._vector_query.with_row_id(True)
             self._fts_query.with_row_id(True)
-        if self._use_lsm is not None:
-            self._vector_query.use_lsm(self._use_lsm)
-            self._fts_query.use_lsm(self._use_lsm)
         if self._phrase_query:
             self._fts_query.phrase_query(True)
         if self._distance_type:
             self._vector_query.metric(self._distance_type)
-        if self._minimum_nprobes is not None:
+        if self._minimum_nprobes:
             self._vector_query.minimum_nprobes(self._minimum_nprobes)
         if self._maximum_nprobes is not None:
             self._vector_query.maximum_nprobes(self._maximum_nprobes)
@@ -2770,7 +2732,7 @@ class AsyncQueryBase(object):
         )
 
     async def _maybe_add_blob_row_id(self) -> None:
-        if self._table is None:
+        if self._table is None or not supports_blob_auto_row_id(self._table):
             self._blob_auto_row_id = False
             self._blob_paths = ()
             return
@@ -2778,6 +2740,7 @@ class AsyncQueryBase(object):
         req = self._inner.to_query_request()
         schema = await self._table.schema()
         self._blob_auto_row_id = blob_auto_row_id_for_scan(
+            self._table,
             schema,
             req.select,
             with_row_id=self._with_row_id,
@@ -3029,6 +2992,7 @@ class AsyncQueryBase(object):
 
         schema = await self._table.schema()
         blob_auto_row_id = blob_auto_row_id_for_scan(
+            self._table,
             schema,
             query.columns,
             with_row_id=self._with_row_id,
@@ -3038,7 +3002,7 @@ class AsyncQueryBase(object):
             if blob_mode == "bytes"
             else {}
         )
-        dataset = await self._table.to_lance()
+        dataset = await self._table._to_lance()
         scanner = dataset.scanner(
             **_scanner_kwargs_for_query(
                 query,
@@ -3267,27 +3231,6 @@ class AsyncStandardQuery(AsyncQueryBase):
         self._inner.fast_search()
         return self
 
-    def use_lsm(self, enable: bool) -> Self:
-        """
-        Control MemWAL LSM read routing for this query.
-
-        By default (unset), a query against a table with an LSM write spec (see
-        [AsyncTable.set_lsm_write_spec][lancedb.table.AsyncTable.set_lsm_write_spec])
-        is routed through the LSM scanner so it also returns data written via the
-        ``merge_insert`` 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 : bool
-            ``True`` forces the LSM scanner and errors if the table has no LSM
-            write spec. ``False`` bypasses the MemWAL and reads the base table
-            only, even when a spec is present.
-        """
-        self._inner.use_lsm(enable)
-        return self
-
     def postfilter(self) -> Self:
         """
         If this is called then filtering will happen after the search instead of
@@ -3376,9 +3319,8 @@ class AsyncQuery(AsyncStandardQuery):
         are various ANN search parameters that will let you fine tune your recall
         accuracy vs search latency.
 
-        Vector searches always have a
-        [limit][lancedb.query.AsyncVectorQuery.limit].  If `limit` has not been
-        called then a default `limit` of 10 will be used.
+        Vector searches always have a [limit][].  If `limit` has not been called then
+        a default `limit` of 10 will be used.
 
         Typically, a single vector is passed in as the query. However, you can also
         pass in multiple vectors. When multiple vectors are passed in, if the vector
@@ -3509,9 +3451,8 @@ class AsyncFTSQuery(AsyncStandardQuery):
         are various ANN search parameters that will let you fine tune your recall
         accuracy vs search latency.
 
-        Hybrid searches always have a
-        [limit][lancedb.query.AsyncHybridQuery.limit].  If `limit` has not been
-        called then a default `limit` of 10 will be used.
+        Hybrid searches always have a [limit][].  If `limit` has not been called then
+        a default `limit` of 10 will be used.
 
         Typically, a single vector is passed in as the query. However, you can also
         pass in multiple vectors.  This can be useful if you want to find the nearest
@@ -3874,9 +3815,10 @@ class AsyncHybridQuery(AsyncStandardQuery, AsyncVectorQueryBase):
         req = fts_query._inner.to_query_request()
         blob_auto_row_id = False
         blob_paths: tuple[str, ...] = ()
-        if self._table is not None:
+        if self._table is not None and supports_blob_auto_row_id(self._table):
             schema = await self._table.schema()
             blob_auto_row_id = blob_auto_row_id_for_scan(
+                self._table,
                 schema,
                 req.select,
                 with_row_id=self._with_row_id,
@@ -4002,15 +3944,6 @@ class AsyncTakeQuery(AsyncQueryBase):
     def __init__(self, inner: LanceTakeQuery, table: Optional["AsyncTable"] = None):
         super().__init__(inner, table)
 
-    def use_lsm(self, enable: bool) -> "AsyncTakeQuery":
-        """Control MemWAL LSM 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.
-        """
-        self._inner.use_lsm(enable)
-        return self
-
     async def _plain_scan_to_pandas(
         self,
         blob_mode: BlobMode,
@@ -4069,16 +4002,6 @@ class BaseQueryBuilder(object):
         self._inner.with_row_id()
         return self
 
-    def use_lsm(self, enable: bool) -> Self:
-        """
-        Control MemWAL LSM read routing for this query.
-
-        ``False`` bypasses the MemWAL and reads the base table only, the escape
-        hatch for shapes the LSM scanner cannot honor (e.g. take-by-row-id).
-        """
-        self._inner.use_lsm(enable)
-        return self
-
     def with_row_address(self, with_row_address: bool = True) -> Self:
         """
         Include the _rowaddr column in scanner-backed plain query results.

python/python/lancedb/remote/__init__.py

@@ -11,9 +11,6 @@ from lancedb import __version__
 from .header import HeaderProvider
 from .oauth import OAuthConfig, OAuthFlowType
 
-# The API reference renders this module with a single mkdocstrings directive,
-# which only picks up names listed here. New public names must be added to this
-# list, or they will silently go undocumented.
 __all__ = [
     "TimeoutConfig",
     "RetryConfig",

python/python/lancedb/remote/db.py

@@ -7,7 +7,7 @@ import json
 import logging
 from concurrent.futures import ThreadPoolExecutor
 import sys
-from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Union
+from typing import Any, Dict, Iterable, List, Optional, Union
 from urllib.parse import urlparse
 import warnings
 
@@ -23,10 +23,6 @@ import pyarrow as pa
 
 from ..common import DATA
 from ..db import DBConnection, LOOP
-from ..job import Job
-
-if TYPE_CHECKING:
-    from .._lancedb import JobDescription, JobInfo
 from ..embeddings import EmbeddingFunctionConfig
 from lance_namespace import (
     LanceNamespace,
@@ -419,11 +415,6 @@ class RemoteDBConnection(DBConnection):
 
         if namespace_path is None:
             namespace_path = []
-        if storage_options is not None:
-            logging.info(
-                "storage_options is ignored in LanceDb Cloud"
-                " (storage is managed; set storage_options on connect() instead)"
-            )
         if index_cache_size is not None:
             logging.info(
                 "index_cache_size is ignored in LanceDb Cloud"
@@ -693,47 +684,6 @@ class RemoteDBConnection(DBConnection):
             )
         )
 
-    @override
-    def job(self, job_id: str) -> Job:
-        """A [Job][lancedb.job.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.
-        """
-        return Job(self._conn.job(job_id))
-
-    @override
-    def list_jobs(self) -> List["JobInfo"]:
-        """List server-side jobs across the database's tables."""
-        return LOOP.run(self._conn.list_jobs())
-
-    @override
-    def get_job(self, job_id: str) -> Optional["JobDescription"]:
-        """Describe a single server-side job by id.
-
-        Returns None when the server has no such job.
-        """
-        return LOOP.run(self._conn.get_job(job_id))
-
-    @override
-    def cancel_job(self, job_id: str) -> bool:
-        """Request cancellation of a server-side job by id.
-
-        Returns True if the server accepted the cancellation, False if no
-        such job exists. Cancelling an already-terminal job is a no-op
-        success.
-        """
-        return LOOP.run(self._conn.cancel_job(job_id))
-
-    @override
-    def job_history(self, job_id: Optional[str] = None) -> List[pa.RecordBatch]:
-        """The lifecycle event history of a server-side job, as Arrow batches.
-
-        Lists history across all jobs when `job_id` is None.
-        """
-        return LOOP.run(self._conn.job_history(job_id))
-
     @override
     def namespace_client(self) -> LanceNamespace:
         """Get the equivalent namespace client for this connection.

python/python/lancedb/remote/errors.py

@@ -53,9 +53,9 @@ class RetryError(LanceDBClientError):
     """An error that occurs when the client has exceeded the maximum number of retries.
 
     The retry strategy can be adjusted by setting the
-    [retry_config][lancedb.remote.ClientConfig.retry_config] in the client
+    [retry_config](lancedb.remote.ClientConfig.retry_config) in the client
     configuration. This is passed in the `client_config` argument of
-    [connect][lancedb.connect] and [connect_async][lancedb.connect_async].
+    [connect](lancedb.connect) and [connect_async](lancedb.connect_async).
 
     The __cause__ attribute of this exception will be the last exception that
     caused the retry to fail. It will be an