fix(ci): allow recovery artifact downloads

fix(ci): recover timed-out Windows release builds
Bump version: 0.37.1-beta.3 → 0.37.1
2026-08-28 17:08:43 +00:00 · 2026-08-10 18:00:09 +08:00 · 2026-08-10 17:52:48 +08:00 · 2026-08-10 07:54:42 +00:00 · 2026-08-10 07:53:53 +00:00 · 2026-08-10 06:30:45 +00:00
86 changed files with 1077 additions and 6691 deletions
@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.38.0-beta.2"
+current_version = "0.37.1"
 parse = """(?x)
    (?P<major>0|[1-9]\\d*)\\.
    (?P<minor>0|[1-9]\\d*)\\.
@@ -4,14 +4,14 @@ on:
  workflow_call:
    inputs:
      tag:
-        description: "Tag name from Lance (e.g. `v7.2.0-beta.1`). If omitted, the newest release is resolved automatically — stable releases are preferred over pre-releases — and the run is skipped if it is not newer than the version currently pinned in Cargo.toml."
+        description: "Tag name from Lance. If omitted, the skill will use the latest Lance release that needs an update."
        required: false
        default: ""
        type: string
  workflow_dispatch:
    inputs:
      tag:
-        description: "Tag name from Lance (e.g. `v7.2.0-beta.1`). Leave empty to resolve the newest release automatically — stable releases are preferred over pre-releases — and skip the run if it is not newer than the version currently pinned in Cargo.toml."
+        description: "Tag name from Lance. Leave empty to use the latest Lance release that needs an update."
        required: false
        default: ""
        type: string
@@ -36,9 +36,7 @@ jobs:
    permissions:
      contents: read
    outputs:
-      checker_outcome: ${{ steps.lychee.outcome }}
      exit_code: ${{ steps.lychee.outputs.exit_code }}
-      status: ${{ steps.validate.outputs.status }}
    steps:
      - name: Checkout
        uses: actions/checkout@v6
@@ -52,7 +50,6 @@ jobs:

      - name: Check links
        id: lychee
-        continue-on-error: true
        uses: lycheeverse/lychee-action@e7477775783ea5526144ba13e8db5eec57747ce8 # v2.9.0
        with:
          # Restricted to http(s) on purpose. Much of docs/src is generated
@@ -71,50 +68,38 @@ jobs:
          format: json
          output: ./lychee/out.json
          jobSummary: false
-          # The report issue, not a red workflow run, is the signal for link
-          # findings and checker failures alike.
+          # 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
-        id: validate
        # lychee does not reserve exit code 2 for broken links: its CLI
        # parser also exits 2 on an invalid option, before any link was
        # checked or any report written. Only a parseable report whose
-        # counts agree with a completed exit code (0 or 2) counts as a link
-        # verdict. Everything else becomes a checker-error report instead of
-        # failing the workflow. Exit 2 covers timeouts as well as errors, and a
-        # timed-out host is exactly the transient unavailability this report
-        # exists to surface, so both count as findings. Requiring total > 0
-        # also catches a glob that silently stopped matching any file.
-        if: always()
+        # 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:
-          CHECKER_OUTCOME: ${{ steps.lychee.outcome }}
          EXIT_CODE: ${{ steps.lychee.outputs.exit_code }}
        run: |
-          status=checker-error
-          if [[ "$CHECKER_OUTCOME" == success ]] &&
-             [[ "$EXIT_CODE" == 0 || "$EXIT_CODE" == 2 ]] &&
-             jq -e --argjson code "$EXIT_CODE" '
-               (.total > 0) and
-               (if $code == 0
-                then .errors == 0 and .timeouts == 0
-                  and (.error_map | length == 0) and (.timeout_map | length == 0)
-                else (.errors + .timeouts) > 0
-                  and ((.error_map | length) + (.timeout_map | length)) > 0
-                end)
-             ' ./lychee/out.json
-          then
-            if [[ "$EXIT_CODE" == 0 ]]; then
-              status=healthy
-            else
-              status=findings
-            fi
-          fi
-          echo "status=$status" >> "$GITHUB_OUTPUT"
-          echo "Validated link check as $status"
+          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.validate.outputs.status == 'findings'
+        if: steps.lychee.outputs.exit_code == 2
        uses: actions/upload-artifact@v7
        with:
          name: link-report
@@ -130,11 +115,26 @@ jobs:
    permissions:
      issues: write
    env:
-      CHECKER_OUTCOME: ${{ needs.scan.outputs.checker_outcome }}
      EXIT_CODE: ${{ needs.scan.outputs.exit_code }}
-      STATUS: ${{ needs.scan.outputs.status }}
      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    steps:
+      - name: 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:
@@ -144,7 +144,7 @@ jobs:
        # Closed issues are included because a healthy run closes the report:
        # an open-only lookup would forget that identity and the next failing
        # run would open a duplicate. The oldest match stays the canonical
-        # report and is reopened below when a problem recurs.
+        # 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" \
@@ -154,14 +154,14 @@ jobs:
          echo "state=$(jq -r '.state // empty' <<<"$match")" >> "$GITHUB_OUTPUT"

      - name: Download report
-        if: env.STATUS == 'findings'
+        if: env.EXIT_CODE == 2
        uses: actions/download-artifact@v8
        with:
          name: link-report
          path: ./lychee

      - name: Compose report
-        if: env.STATUS == 'findings'
+        if: env.EXIT_CODE == 2
        run: |
          run_url="$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID"
          {
@@ -185,41 +185,22 @@ jobs:
            ' ./lychee/out.json
          } > ./lychee/issue.md

-      - name: Compose checker error report
-        if: env.STATUS == 'checker-error'
-        run: |
-          mkdir -p ./lychee
-          run_url="$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID"
-          {
-            echo "The documentation link check did not complete in [the latest run]($run_url)."
-            echo
-            echo "This issue is rewritten by every scheduled run and closed automatically once a trustworthy run finds that all links resolve."
-            echo
-            echo "The checker did not produce a trustworthy link verdict. Treat the previous result, if any, as stale until a later run completes."
-            echo
-            echo "* Action outcome: \`$CHECKER_OUTCOME\`"
-            echo "* Exit code: \`${EXIT_CODE:-not reported}\`"
-            echo "* Verdict validation: \`failed\`"
-          } > ./lychee/issue.md
-
      - name: Reopen report issue
        # A healthy run closes the report, and the issue action below only
        # rewrites the body of whatever number it is given. Without an
-        # explicit reopen, a later finding or checker error would rewrite a
-        # closed issue. A CLOSED state implies the lookup found a canonical
-        # issue, so no separate emptiness check.
-        if: >-
-          env.STATUS != 'healthy' &&
-          steps.report.outputs.state == 'CLOSED'
+        # 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 "The documentation link checker reported a problem again in [the latest run]($run_url)."
+            --comment "Broken documentation links found again in [the latest run]($run_url)."

-      - name: Report link-check problem
-        if: env.STATUS != 'healthy'
+      - 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
@@ -232,9 +213,7 @@ jobs:
      - name: Close report issue once links are healthy
        # An OPEN state implies the lookup found a canonical issue; a report
        # that is already closed needs nothing.
-        if: >-
-          env.STATUS == 'healthy' &&
-          steps.report.outputs.state == 'OPEN'
+        if: env.EXIT_CODE == 0 && steps.report.outputs.state == 'OPEN'
        env:
          ISSUE_NUMBER: ${{ steps.report.outputs.number }}
        run: |
@@ -1,7 +1,8 @@
 name: Create release commit

-# This workflow increments the version, tags it, and pushes it. All SDKs share
-# a single version, so one tag releases all of them.
+# This workflow increments the version, updates lockfiles, tags the final
+# commit, and pushes it. All SDKs share a single version, so one tag releases
+# all of them.
 # 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.

@@ -63,6 +64,7 @@ jobs:
          pip install bump-my-version PyGithub packaging
          bash ci/bump_version.sh ${{ inputs.type }} ${{ inputs.bump-minor }}
          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
@@ -4,6 +4,16 @@ on:
  push:
    tags:
      - 'v*'
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        description: Stable release tag to recover (for example, v0.37.1)
+        required: true
+        type: string
+      source_run_id:
+        description: Failed tag workflow run containing the completed non-Windows wheels
+        required: true
+        type: string
  pull_request:
    # This should trigger a dry run (we skip the final publish step)
    paths:
@@ -29,6 +39,7 @@ concurrency:
 jobs:
  linux:
    name: Python ${{ matrix.config.package_name }} ${{ matrix.config.platform }} manylinux${{ matrix.config.manylinux }}
+    if: github.event_name != 'workflow_dispatch'
    timeout-minutes: 60
    strategy:
      matrix:
@@ -69,16 +80,6 @@ jobs:
        uses: actions/setup-python@v6
        with:
          python-version: "3.10"
-      - name: Add swap for Arm fat LTO
-        if: matrix.config.platform == 'aarch64'
-        shell: bash
-        run: |
-          swap_file="$RUNNER_TEMP/lancedb-swap"
-          sudo fallocate --length 16G "$swap_file"
-          sudo chmod 600 "$swap_file"
-          sudo mkswap "$swap_file"
-          sudo swapon "$swap_file"
-          free -h
      - uses: ./.github/workflows/build_linux_wheel
        with:
          python-minor-version: 10
@@ -94,6 +95,7 @@ jobs:
          path: target/wheels/*.whl
          if-no-files-found: error
  mac:
+    if: github.event_name != 'workflow_dispatch'
    timeout-minutes: 90
    runs-on: ${{ matrix.config.runner }}
    strategy:
@@ -123,7 +125,8 @@ jobs:
          path: target/wheels/lancedb-*.whl
          if-no-files-found: error
  windows:
-    timeout-minutes: 90
+    if: github.event_name != 'workflow_dispatch'
+    timeout-minutes: 120
    runs-on: windows-latest
    env:
      # link.exe is single-threaded and the long pole on Windows builds. Use
@@ -155,6 +158,32 @@ jobs:
          name: wheels-windows
          path: target/wheels/lancedb-*.whl
          if-no-files-found: error
+  recover-windows:
+    name: Recover Windows wheel
+    if: github.event_name == 'workflow_dispatch'
+    timeout-minutes: 120
+    runs-on: windows-latest
+    env:
+      CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER: rust-lld
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ inputs.release_tag }}
+          fetch-depth: 0
+          lfs: true
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - uses: ./.github/workflows/build_windows_wheel
+        with:
+          python-minor-version: 10
+          args: "--release --strip"
+      - uses: actions/upload-artifact@v7
+        with:
+          name: wheels-windows-recovery
+          path: target/wheels/lancedb-*.whl
+          if-no-files-found: error
  publish:
    name: Publish wheels
    if: startsWith(github.ref, 'refs/tags/v')
@@ -175,11 +204,13 @@ jobs:
        run: ls -la target/wheels
      - name: Choose repo
        id: choose_repo
+        env:
+          RELEASE_REF: ${{ github.ref }}
        run: |
-          if [[ ${{ github.ref }} == *beta* ]]; then
-            echo "repo=fury" >> $GITHUB_OUTPUT
+          if [[ "$RELEASE_REF" == *beta* ]]; then
+            echo "repo=fury" >> "$GITHUB_OUTPUT"
          else
-            echo "repo=pypi" >> $GITHUB_OUTPUT
+            echo "repo=pypi" >> "$GITHUB_OUTPUT"
          fi
      - name: Publish to Fury
        if: steps.choose_repo.outputs.repo == 'fury'
@@ -206,6 +237,71 @@ jobs:
        uses: pypa/gh-action-pypi-publish@release/v1
        with:
          packages-dir: target/wheels/
+  recover-publish:
+    name: Recover PyPI publish
+    if: github.event_name == 'workflow_dispatch'
+    needs: [recover-windows]
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ inputs.release_tag }}
+          fetch-depth: 0
+      - name: Verify recovery source
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ inputs.release_tag }}
+          SOURCE_RUN_ID: ${{ inputs.source_run_id }}
+        run: |
+          if [[ "$RELEASE_TAG" != v* || "$RELEASE_TAG" == *beta* ]]; then
+            echo "Recovery only supports stable v* release tags" >&2
+            exit 1
+          fi
+          TAG_SHA=$(git rev-parse HEAD)
+          RUN_SHA=$(gh api "/repos/${{ github.repository }}/actions/runs/$SOURCE_RUN_ID" --jq .head_sha)
+          if [[ "$TAG_SHA" != "$RUN_SHA" ]]; then
+            echo "Source run $SOURCE_RUN_ID ($RUN_SHA) does not match $RELEASE_TAG ($TAG_SHA)" >&2
+            exit 1
+          fi
+      - name: Download Linux wheel artifacts
+        uses: actions/download-artifact@v8
+        with:
+          github-token: ${{ github.token }}
+          repository: ${{ github.repository }}
+          run-id: ${{ inputs.source_run_id }}
+          pattern: wheels-linux-*
+          path: target/wheels
+          merge-multiple: true
+      - name: Download macOS wheel artifacts
+        uses: actions/download-artifact@v8
+        with:
+          github-token: ${{ github.token }}
+          repository: ${{ github.repository }}
+          run-id: ${{ inputs.source_run_id }}
+          pattern: wheels-mac-*
+          path: target/wheels
+          merge-multiple: true
+      - name: Download recovered Windows wheel
+        uses: actions/download-artifact@v8
+        with:
+          name: wheels-windows-recovery
+          path: target/wheels
+      - name: Validate recovered wheels
+        run: |
+          find target/wheels -maxdepth 1 -type f -name '*.whl' -print
+          WHEEL_COUNT=$(find target/wheels -maxdepth 1 -type f -name '*.whl' | wc -l)
+          if [[ "$WHEEL_COUNT" -ne 5 ]]; then
+            echo "Expected 5 wheels, found $WHEEL_COUNT" >&2
+            exit 1
+          fi
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: target/wheels/
  report-failure:
    name: Report Workflow Failure
    runs-on: ubuntu-latest
@@ -775,7 +775,7 @@ dependencies = [
 "http 0.2.12",
 "http 1.5.0",
 "http-body 1.1.0",
- "lru 0.16.4",
+ "lru",
 "percent-encoding",
 "regex-lite",
 "sha2 0.11.0",
@@ -1970,6 +1970,15 @@ dependencies = [
 "spin 0.10.1",
 ]

+[[package]]
+name = "crc32c"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a47af21622d091a8f0fb295b88bc886ac74efcc613efc19f5d0b21de5c89e47"
+dependencies = [
+ "rustc_version",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -3441,12 +3450,6 @@ dependencies = [
 "percent-encoding",
 ]

-[[package]]
-name = "frostem"
-version = "1.20260804.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82eb03a32a1d50555353c85a7b9d3279a6f1e91af9890b789acdf544ed57c8d7"
-
 [[package]]
 name = "fs_extra"
 version = "1.3.0"
@@ -3455,8 +3458,9 @@ checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"

 [[package]]
 name = "fsst"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0981ce90521824089f3cd68a48b1c4c89e9ad96d0eb74f58d6e550a3d604545"
 dependencies = [
 "arrow-array",
 "rand 0.9.5",
@@ -3813,23 +3817,14 @@ dependencies = [

 [[package]]
 name = "goosefs-sdk"
-version = "0.1.9"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1ea4eee6dcbc31b25ab4fd577adc55b677d2bed3aa3016c44c58fbe1b2298a5"
+checksum = "9ae079b88ffe7772d12cfc5c40a5a324babb357893d95b5e3a22ae857f236c5f"
 dependencies = [
- "arc-swap",
 "async-trait",
 "bytes",
 "dashmap",
- "fastrand",
- "futures",
 "hostname",
- "io-uring",
- "itoa",
- "libc",
- "lru 0.18.2",
- "memmap2 0.9.10",
- "moka",
 "prost",
 "prost-types",
 "rand 0.9.5",
@@ -3842,7 +3837,6 @@ dependencies = [
 "tonic-prost",
 "tracing",
 "uuid",
- "xxhash-rust",
 ]

 [[package]]
@@ -4815,8 +4809,9 @@ checksum = "e037a2e1d8d5fdbd49b16a4ea09d5d6401c1f29eca5ff29d03d3824dba16256a"

 [[package]]
 name = "lance"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830548f9fc92ae74b848a504282d4da06f016f2ee94b663773c2738b9cb61c42"
 dependencies = [
 "arc-swap",
 "arrow",
@@ -4832,6 +4827,7 @@ dependencies = [
 "async-recursion",
 "async-trait",
 "async_cell",
+ "aws-credential-types",
 "aws-sdk-dynamodb",
 "byteorder",
 "bytes",
@@ -4847,6 +4843,7 @@ dependencies = [
 "either",
 "fst",
 "futures",
+ "half",
 "humantime",
 "itertools 0.14.0",
 "lance-arrow",
@@ -4888,8 +4885,9 @@ dependencies = [

 [[package]]
 name = "lance-arrow"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24187f972374567bb3573cffd8728f2f4f7f06d644c3c5d4430b79d6b0b67300"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -4911,7 +4909,8 @@ dependencies = [
 [[package]]
 name = "lance-arrow-scalar"
 version = "58.0.0"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "771f68b04b47f3addf781116f65061808de94b05e1e9411c23c18f32d14ebe79"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -4925,17 +4924,20 @@ dependencies = [
 [[package]]
 name = "lance-arrow-stats"
 version = "58.0.0"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd47ec33c90bf29f688fd02118e37d3a5ad5c339caa3163f89e417dc0867001f"
 dependencies = [
 "arrow-array",
 "arrow-schema",
+ "half",
 "lance-arrow-scalar",
 ]

 [[package]]
 name = "lance-bitpacking"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55fa50ad941e25298afb54eec107c3584f80c16db4adf7a6e4e9c4b6066f4281"
 dependencies = [
 "arrayref",
 "crunchy",
@@ -4945,8 +4947,9 @@ dependencies = [

 [[package]]
 name = "lance-core"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21f4fd872bfe948150a6878d983327c4f150dc1b629e94ae7677310fa6a3f35f"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -4954,10 +4957,12 @@ dependencies = [
 "arrow-schema",
 "async-trait",
 "blake3",
+ "byteorder",
 "bytes",
 "datafusion-common",
 "datafusion-sql",
 "futures",
+ "itertools 0.14.0",
 "lance-arrow",
 "lance-derive",
 "libc",
@@ -4975,6 +4980,7 @@ dependencies = [
 "snafu 0.9.0",
 "tempfile",
 "tokio",
+ "tokio-stream",
 "tokio-util",
 "tracing",
 "twox-hash",
@@ -4983,8 +4989,9 @@ dependencies = [

 [[package]]
 name = "lance-datafusion"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "230770734cd5f6fe1f1cb4a66750acad5c5a862c23c7f587d7def57c9f2c5f6b"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -5003,6 +5010,7 @@ dependencies = [
 "jsonb",
 "lance-arrow",
 "lance-core",
+ "lance-datagen",
 "log",
 "pin-project",
 "prost",
@@ -5013,8 +5021,9 @@ dependencies = [

 [[package]]
 name = "lance-datagen"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0c9edcea9dbf154a3baf470595bdcdb7ef6b44dcf2b5a0c28e8815c2d4837c5"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -5031,8 +5040,9 @@ dependencies = [

 [[package]]
 name = "lance-derive"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03ac280ef94d66c2e7a4b0104e60d548f45156f114f02cd0ac57423721ec96ec"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -5041,8 +5051,9 @@ dependencies = [

 [[package]]
 name = "lance-encoding"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65b345fecf1792d4147982e9ded1cf211992a442bcf73dd17a598b1c8c9b53a5"
 dependencies = [
 "arrow-arith",
 "arrow-array",
@@ -5067,6 +5078,8 @@ dependencies = [
 "num-traits",
 "prost",
 "prost-build",
+ "rand 0.9.5",
+ "strum 0.26.3",
 "tokio",
 "tracing",
 "xxhash-rust",
@@ -5075,8 +5088,9 @@ dependencies = [

 [[package]]
 name = "lance-file"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "203400160ecd4ac6f67f6bfdb3c186f94758ff70a6ca76d4f300c327f5c14a11"
 dependencies = [
 "arrow-arith",
 "arrow-array",
@@ -5107,8 +5121,9 @@ dependencies = [

 [[package]]
 name = "lance-index"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db67792e22332a7be08d35e60ce9e4c6fb7f75f70ab1566b67b462d1aac21b13"
 dependencies = [
 "arc-swap",
 "arrow",
@@ -5123,6 +5138,7 @@ dependencies = [
 "async-trait",
 "bitvec",
 "bytes",
+ "chrono",
 "crossbeam-queue",
 "datafusion",
 "datafusion-common",
@@ -5140,6 +5156,7 @@ dependencies = [
 "lance-bitpacking",
 "lance-core",
 "lance-datafusion",
+ "lance-datagen",
 "lance-encoding",
 "lance-file",
 "lance-index-core",
@@ -5168,12 +5185,14 @@ dependencies = [
 "tempfile",
 "tokio",
 "tracing",
+ "uuid",
 ]

 [[package]]
 name = "lance-index-core"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49b5700d71f43e5da2057908f3243a6bc01247b5dd12247313f789c280155aae"
 dependencies = [
 "arrow-array",
 "arrow-schema",
@@ -5195,8 +5214,9 @@ dependencies = [

 [[package]]
 name = "lance-io"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b8a6872b9bff95e75e223e04011feebd990d8784878eaf5df73c86d6acebb47"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -5208,8 +5228,10 @@ dependencies = [
 "bytes",
 "chrono",
 "futures",
+ "goosefs-sdk",
 "http 1.5.0",
 "io-uring",
+ "lance-arrow",
 "lance-core",
 "lance-namespace",
 "log",
@@ -5227,28 +5249,31 @@ dependencies = [
 "tokio",
 "tracing",
 "url",
- "uuid",
 ]

 [[package]]
 name = "lance-linalg"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a1dd49fdf61da86650dc335fbe1f239803f9d73bc2bc5ffbc0c905dd8809892"
 dependencies = [
 "arrow-array",
+ "arrow-buffer",
 "arrow-schema",
 "cc",
 "half",
 "lance-arrow",
 "lance-core",
 "num-traits",
+ "rand 0.9.5",
 "rayon",
 ]

 [[package]]
 name = "lance-namespace"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1449221f599147e570bec6e09eaea6ce6b9286f632e00a27f945dd0c6b70ccd8"
 dependencies = [
 "arrow",
 "async-trait",
@@ -5260,8 +5285,9 @@ dependencies = [

 [[package]]
 name = "lance-namespace-impls"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c30bff40ab9a9a58313818ab97241cff7bab2b90b8d65039908425a065a797de"
 dependencies = [
 "arrow",
 "arrow-ipc",
@@ -5291,6 +5317,7 @@ dependencies = [
 "serde",
 "serde_json",
 "sha2 0.10.9",
+ "time",
 "tokio",
 "tower",
 "tower-http 0.5.2",
@@ -5300,9 +5327,9 @@ dependencies = [

 [[package]]
 name = "lance-namespace-reqwest-client"
-version = "0.11.0"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a030196da1c994b63a96a4f0bf5b0cfa459fe6dadc9e962320246ca328da22a"
+checksum = "ba3f0a235e3ed5f8805205649ccc7d7d0f3df23ce1294242c9265ad488d7f19d"
 dependencies = [
 "reqwest 0.12.28",
 "serde",
@@ -5314,13 +5341,15 @@ dependencies = [

 [[package]]
 name = "lance-select"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66c5cb12ed194c7c8e427a0e90e990cdbc7159edba2bfc7b7e8db2c90c747af"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
 "arrow-schema",
 "byteorder",
+ "bytes",
 "itertools 0.14.0",
 "lance-core",
 "roaring",
@@ -5329,8 +5358,9 @@ dependencies = [

 [[package]]
 name = "lance-table"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cd2a39f2e288d1acecf887cb9cc655711fb67bcf3b24a2034158dbac7a6f60e"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -5340,7 +5370,6 @@ dependencies = [
 "async-trait",
 "aws-credential-types",
 "aws-sdk-dynamodb",
- "blake3",
 "byteorder",
 "bytes",
 "chrono",
@@ -5370,8 +5399,9 @@ dependencies = [

 [[package]]
 name = "lance-testing"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0847352699e869a465b49bd49ecbc467bc5a3dcb168757bf39368362aad05f99"
 dependencies = [
 "arrow-array",
 "arrow-schema",
@@ -5384,13 +5414,14 @@ dependencies = [

 [[package]]
 name = "lance-tokenizer"
-version = "11.0.0-beta.13"
-source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.13#ee41152ceb9a78e5df4d2456fdbdb98542eb2059"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "254c1e9287789c8d744f93f2010a8389a5ea3fcedc0dddf7649c4117ec830c57"
 dependencies = [
- "frostem",
 "icu_segmenter",
 "jieba-rs",
 "lindera",
+ "rust-stemmers",
 "serde",
 "stop-words",
 "unicode-normalization",
@@ -5398,7 +5429,7 @@ dependencies = [

 [[package]]
 name = "lancedb"
-version = "0.38.0-beta.1"
+version = "0.37.1"
 dependencies = [
 "ahash",
 "anyhow",
@@ -5486,7 +5517,7 @@ dependencies = [

 [[package]]
 name = "lancedb-nodejs"
-version = "0.38.0-beta.1"
+version = "0.37.1"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -5511,7 +5542,7 @@ dependencies = [

 [[package]]
 name = "lancedb-python"
-version = "0.38.0-beta.1"
+version = "0.37.1"
 dependencies = [
 "arrow",
 "async-trait",
@@ -5668,7 +5699,7 @@ dependencies = [
 "serde",
 "serde_json",
 "serde_yaml_ng",
- "strum",
+ "strum 0.28.0",
 "strum_macros 0.28.0",
 "unicode-blocks",
 "unicode-normalization",
@@ -5698,7 +5729,7 @@ dependencies = [
 "rkyv",
 "serde",
 "serde_json",
- "strum",
+ "strum 0.28.0",
 "strum_macros 0.28.0",
 "thiserror 2.0.18",
 ]
@@ -5770,15 +5801,6 @@ dependencies = [
 "hashbrown 0.16.1",
 ]

-[[package]]
-name = "lru"
-version = "0.18.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d2f2f9b4ba7e6b24d95e7e899329d35be83bcded72c8540cdd5368932d1d90a"
-dependencies = [
- "hashbrown 0.17.1",
-]
-
 [[package]]
 name = "lru-slab"
 version = "0.1.2"
@@ -6416,9 +6438,9 @@ dependencies = [

 [[package]]
 name = "object_store_opendal"
-version = "0.58.0"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88f165780495c17aa3ce86846600504198c3fffd99073521552751c2430fa6ac"
+checksum = "0eb12a624a41fce745838d0ef3701ff6c47797c13cd18ad3612fd2a3134fdbd8"
 dependencies = [
 "async-trait",
 "bytes",
@@ -6479,13 +6501,12 @@ checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"

 [[package]]
 name = "opendal"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f20562cc7447fcc915fc5c23df305a412ea80a733c9f2fd9e2d267e2815be6d"
+checksum = "96c9c85ce253ff87225e7669979d877a20c98a06604ec9d6dd5f4473e08f1ae1"
 dependencies = [
 "ctor 1.0.12",
 "opendal-core",
- "opendal-http-transport-reqwest",
 "opendal-layer-concurrent-limit",
 "opendal-layer-logging",
 "opendal-layer-retry",
@@ -6502,22 +6523,24 @@ dependencies = [

 [[package]]
 name = "opendal-core"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec75551ff4cf3e57da98979f6a937aaa9ddb3915bf68cc17d03df733be6646ed"
+checksum = "c4f8607c90e2c963a91467f50fb49fbc7fb3d573f88cea219ca59ccd3740b309"
 dependencies = [
 "anyhow",
- "base64 0.23.1",
+ "base64 0.22.1",
 "bytes",
 "futures",
 "http 1.5.0",
+ "http-body 1.1.0",
 "jiff",
 "log",
 "md-5 0.11.0",
 "mea",
 "percent-encoding",
- "quick-xml 0.41.0",
+ "quick-xml 0.39.4",
 "reqsign-core",
+ "reqwest 0.13.4",
 "serde",
 "serde_json",
 "tokio",
@@ -6526,25 +6549,11 @@ dependencies = [
 "web-time",
 ]

-[[package]]
-name = "opendal-http-transport-reqwest"
-version = "0.58.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad4d4f19c3ce01126a30611f8e544eaa217104a278c889ac17c9374fe4f9e4ef"
-dependencies = [
- "bytes",
- "futures",
- "http 1.5.0",
- "http-body 1.1.0",
- "opendal-core",
- "reqwest 0.13.4",
-]
-
 [[package]]
 name = "opendal-layer-concurrent-limit"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "249ac5b0aa5a7a6c3737342d10456067937f9c9a6f3f02544271f7908ab91081"
+checksum = "0d6f81ba6960e3fae1882f253b114b21d7e444e1534f209c7737a79f6243eb6f"
 dependencies = [
 "futures",
 "http 1.5.0",
@@ -6554,9 +6563,9 @@ dependencies = [

 [[package]]
 name = "opendal-layer-logging"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c75411ab00f77851ff086b686c1e9ca8175ac18c15afa2cb75b9036436cb06c"
+checksum = "58ada45c6d81d1aa4c9305d0c7d4bc317c59c85866a0908a2d75a7a978aa5ee2"
 dependencies = [
 "log",
 "opendal-core",
@@ -6564,9 +6573,9 @@ dependencies = [

 [[package]]
 name = "opendal-layer-retry"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80b7738bd5f233ad8da39af9b9316b9b7a4eaddd91e8e32a1e19b7030688121d"
+checksum = "7b2a25a718afb81fad81cb9a0580a1cb989221fa2317f888c6a37f8dad408eb7"
 dependencies = [
 "backon",
 "log",
@@ -6575,9 +6584,9 @@ dependencies = [

 [[package]]
 name = "opendal-layer-timeout"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a704141924500f3803c05ed871b53305d2a2f11cb5ef20160c3ee688a1857f66"
+checksum = "1e91f731724c213af81e9d03517859c8fc47b4578e64ad61ae4f099f10fe36e3"
 dependencies = [
 "opendal-core",
 "tokio",
@@ -6585,17 +6594,17 @@ dependencies = [

 [[package]]
 name = "opendal-service-azblob"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3310fbbb48f111c6f590473c2cd15e1b7f8e384444b0d4e328f0464c864d767"
+checksum = "0030644366ef5d8cbe3a4a5822bf99a4aafddc1666e9d24b44d158d9062fc76a"
 dependencies = [
- "base64 0.23.1",
+ "base64 0.22.1",
 "bytes",
 "http 1.5.0",
 "log",
 "opendal-core",
 "opendal-service-azure-common",
- "quick-xml 0.41.0",
+ "quick-xml 0.39.4",
 "reqsign-azure-storage",
 "reqsign-core",
 "reqsign-file-read-tokio",
@@ -6606,18 +6615,17 @@ dependencies = [

 [[package]]
 name = "opendal-service-azdls"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e3c406729935fe214ce574d68681a1ff7e0b322548f14094912bdbfe50e5c53"
+checksum = "6dea4908d490143a9b0b7f7a790e139ff829b06a023f670455ed3d44f664b361"
 dependencies = [
- "base64 0.23.1",
+ "base64 0.22.1",
 "bytes",
 "http 1.5.0",
 "log",
- "mea",
 "opendal-core",
 "opendal-service-azure-common",
- "quick-xml 0.41.0",
+ "quick-xml 0.39.4",
 "reqsign-azure-storage",
 "reqsign-core",
 "reqsign-file-read-tokio",
@@ -6627,9 +6635,9 @@ dependencies = [

 [[package]]
 name = "opendal-service-azure-common"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7348c88edf15af435b7be930077746b569fac5e738c1bf6a363b675e7317c9df"
+checksum = "9b489f13c42e69d69bdd72952b634356ec43a7881a20259b38b540fcecdf4051"
 dependencies = [
 "http 1.5.0",
 "opendal-core",
@@ -6637,15 +6645,15 @@ dependencies = [

 [[package]]
 name = "opendal-service-cos"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d533d4582105d269c8aebeee5f0e8bcf960f41b8aab6197df7012254d9f39bf0"
+checksum = "aa8cafe9729213375c7331019b0cb756ad3e1aff7f45cd32c45eae91ebde8901"
 dependencies = [
 "bytes",
 "http 1.5.0",
 "log",
 "opendal-core",
- "quick-xml 0.41.0",
+ "quick-xml 0.39.4",
 "reqsign-core",
 "reqsign-file-read-tokio",
 "reqsign-tencent-cos",
@@ -6654,9 +6662,9 @@ dependencies = [

 [[package]]
 name = "opendal-service-gcs"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "007f3fba63c21e516c956b891e96ff9892d8175662bfb781cdada9d3766a11e6"
+checksum = "48de101aac565ed06af4b47903c24eafd249075553ec1fb18256751c45148d47"
 dependencies = [
 "async-trait",
 "bytes",
@@ -6664,7 +6672,7 @@ dependencies = [
 "log",
 "opendal-core",
 "percent-encoding",
- "quick-xml 0.41.0",
+ "quick-xml 0.39.4",
 "reqsign-core",
 "reqsign-file-read-tokio",
 "reqsign-google",
@@ -6675,9 +6683,9 @@ dependencies = [

 [[package]]
 name = "opendal-service-goosefs"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60871e6386f04d831e6a5bdbc032af4a91aeba49963252d0ef456a2cf36a9b78"
+checksum = "69e43048bde419947ba826fbdc2f134d6c03f44ebf48bd33a03b72f9fc45fcb4"
 dependencies = [
 "bytes",
 "goosefs-sdk",
@@ -6689,9 +6697,9 @@ dependencies = [

 [[package]]
 name = "opendal-service-hf"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b41fd41eb7ed03c5e66cefda61e8e117808ffd2908f2916737cb020a6beb02c7"
+checksum = "c4922661976a1d40794a2adfbdb888cc3c23097690f825a92f773af38908a848"
 dependencies = [
 "bytes",
 "hf-xet",
@@ -6699,21 +6707,22 @@ dependencies = [
 "log",
 "opendal-core",
 "percent-encoding",
+ "reqwest 0.13.4",
 "serde",
 "serde_json",
 ]

 [[package]]
 name = "opendal-service-oss"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd528ec2d49c5ca69e674ffed7b3e0686fb9cfcfea0596870de381467fda4f1b"
+checksum = "328fa55e8888cbdfe00826bfea2a79042422b720e8369e9e021e46121dea5ace"
 dependencies = [
 "bytes",
 "http 1.5.0",
 "log",
 "opendal-core",
- "quick-xml 0.41.0",
+ "quick-xml 0.39.4",
 "reqsign-aliyun-oss",
 "reqsign-core",
 "reqsign-file-read-tokio",
@@ -6722,18 +6731,18 @@ dependencies = [

 [[package]]
 name = "opendal-service-s3"
-version = "0.58.1"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58e80cdf192d7eff05feed747894d64f81905ac4eaf132edf7ea270abdd2d663"
+checksum = "313d46c9f5ae70bca26b7c3e3fbb9b639292625f28af73aa016f47e788af9deb"
 dependencies = [
- "base64 0.23.1",
+ "base64 0.22.1",
 "bytes",
- "crc-fast",
+ "crc32c",
 "http 1.5.0",
 "log",
 "md-5 0.11.0",
 "opendal-core",
- "quick-xml 0.41.0",
+ "quick-xml 0.39.4",
 "reqsign-aws-v4",
 "reqsign-core",
 "reqsign-file-read-tokio",
@@ -8666,6 +8675,16 @@ dependencies = [
 "ordered-multimap",
 ]

+[[package]]
+name = "rust-stemmers"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e46a2036019fdb888131db7a4c847a1063a7493f971ed94ea82c67eada63ca54"
+dependencies = [
+ "serde",
+ "serde_derive",
+]
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.27"
@@ -9539,6 +9558,15 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"

+[[package]]
+name = "strum"
+version = "0.26.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
+dependencies = [
+ "strum_macros 0.26.4",
+]
+
 [[package]]
 name = "strum"
 version = "0.28.0"
@@ -9561,6 +9589,19 @@ dependencies = [
 "syn 2.0.117",
 ]

+[[package]]
+name = "strum_macros"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "strum_macros"
 version = "0.28.0"
@@ -13,20 +13,20 @@ categories = ["database-implementations"]
 rust-version = "1.91.0"

 [workspace.dependencies]
-lance = { "version" = "=11.0.0-beta.13", default-features = false, "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-core = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-datagen = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-file = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-io = { "version" = "=11.0.0-beta.13", default-features = false, "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-index = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-linalg = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-namespace = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-namespace-impls = { "version" = "=11.0.0-beta.13", default-features = false, "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-table = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-testing = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-datafusion = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-encoding = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
-lance-arrow = { "version" = "=11.0.0-beta.13", "tag" = "v11.0.0-beta.13", "git" = "https://github.com/lance-format/lance.git" }
+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"
 ahash = "0.8"
 # Note that this one does not include pyarrow
 arrow = { version = "58.0.0", optional = false }
@@ -6,16 +6,11 @@ HEAD_SHA=$(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
@@ -39,12 +34,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 pre_l
+  bump-my-version bump -vv $BUMP_ARGS pre_l
 fi

 # Validate that we have incremented version appropriately for breaking changes
-NEW_TAG=$(git describe --tags --exact-match HEAD)
-NEW_VERSION=$(echo $NEW_TAG | sed "s/^$TAG_PREFIX//")
+NEW_VERSION=$(python -c 'import tomllib; print(tomllib.load(open(".bumpversion.toml", "rb"))["tool"]["bumpversion"]["current_version"])')
+NEW_TAG="$TAG_PREFIX$NEW_VERSION"
 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//")

@@ -0,0 +1,21 @@
+#!/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}"
@@ -0,0 +1,72 @@
+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()
@@ -1,34 +1,112 @@
+#!/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

-found_preview_lance = False
+STABLE_VERSION = re.compile(r"[0-9]+\.[0-9]+\.[0-9]+")

-with open("Cargo.toml", "rb") as f:
-    cargo_data = tomllib.load(f)

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

-            if "beta" in version:
-                found_preview_lance = True
-                print(f"Dependency '{name}' is a preview version: {version}")

-with open("python/pyproject.toml", "rb") as f:
-    py_proj_data = tomllib.load(f)
+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"]

-    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
+    versions: dict[str, str] = {}
+    for name, dependency in dependencies.items():
+        if name != "lance" and not name.startswith("lance-"):
+            continue

-if found_preview_lance:
-    raise ValueError("Found preview version of Lance in dependencies")
+        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")
@@ -101,13 +101,6 @@ ignore = [
    # https://rustsec.org/advisories/RUSTSEC-2026-0195
    { id = "RUSTSEC-2026-0194", reason = "transitive via inferno/lance/opendal; XML from trusted cloud endpoints, not attacker-controlled" },
    { id = "RUSTSEC-2026-0195", reason = "transitive via inferno/lance/opendal; XML from trusted cloud endpoints, not attacker-controlled" },
-    # smartstring: unmaintained — the repository was archived by its author on
-    # 2026-05-03. Not a vulnerability. Reached only transitively through polars
-    # (polars-core/-io/-ops/-time/-utils); nothing in LanceDB depends on it directly.
-    # The advisory states no safe upgrade is available: upstream recommends
-    # compact_str/smol_str, so clearing this requires polars to migrate.
-    # https://rustsec.org/advisories/RUSTSEC-2026-0249
-    { id = "RUSTSEC-2026-0249", reason = "smartstring unmaintained via polars; no fixed upstream release" },
 ]

 # ---------------------------------------------------------------------------
@@ -14,7 +14,7 @@ Add the following dependency to your `pom.xml`:
 <dependency>
    <groupId>com.lancedb</groupId>
    <artifactId>lancedb-core</artifactId>
-    <version>0.38.0-beta.2</version>
+    <version>0.37.1</version>
 </dependency>
 ```

@@ -55,38 +55,6 @@ LanceNamespace namespaceClient = LanceDbNamespaceClientBuilder.newBuilder()
 | `region(String)` | AWS region (default: "us-east-1") | No |
 | `config(String, String)` | Additional configuration parameters | No |

-### Opening a Table with Vended Credentials
-
-When the catalog vends temporary object store credentials, open the table through the
-namespace client. The Lance dataset builder fetches the table location and storage options
-from the catalog and refreshes the credentials when they expire.
-
-```java
-import com.lancedb.LanceDbNamespaceClientBuilder;
-import org.lance.Dataset;
-import org.lance.namespace.LanceNamespace;
-
-import java.util.Arrays;
-
-LanceNamespace namespaceClient = LanceDbNamespaceClientBuilder.newBuilder()
-    .apiKey(System.getenv("LANCEDB_API_KEY"))
-    .database(System.getenv("LANCEDB_DATABASE"))
-    // Set the endpoint for a LanceDB Enterprise deployment.
-    // .endpoint("https://your-enterprise-endpoint")
-    .build();
-
-try (Dataset dataset = Dataset.open()
-        .namespaceClient(namespaceClient)
-        .tableId(Arrays.asList("my_namespace", "my_table"))
-        .build()) {
-    System.out.println("Rows: " + dataset.countRows());
-}
-```
-
-Do not call `describeTable()` and then open the returned location with `Dataset.open(uri)`.
-Opening through `namespaceClient()` is what applies the vended storage options and enables
-automatic credential refresh. No object store credentials need to be passed by the application.
-
 ## Metadata Operations

 ### Creating a Namespace Path
@@ -386,29 +386,6 @@ Drop an existing table.

 ***

-### dropTableAsync()
-
-```ts
-abstract dropTableAsync(name, namespacePath?): Promise<Job>
-```
-
-Start dropping a table and return its cleanup job.
-
-The table may become unavailable before its data files are removed. Wait
-on the returned job to know when cleanup has finished.
-
-#### Parameters
-
-* **name**: `string`
-
-* **namespacePath?**: `string`[]
-
-#### Returns
-
-`Promise`&lt;[`Job`](Job.md)&gt;
-
-***
-
 ### getJob()

 ```ts
@@ -69,34 +69,14 @@ abstract addColumns(newColumnTransforms): Promise<AddColumnsResult>

 Add new columns with defined values.

-The `{ computed }` form stores the expression rather than evaluating it
-now: the column is committed with no values, and rows get them from
-[Table#refreshColumn](Table.md#refreshcolumn). Declaring one therefore costs the same on a
-large table as on an empty one.
-
-A refresh does not revisit rows it has already filled, so mutating an
-input leaves the value computed at fill time; recomputing means dropping
-the column and declaring it again. While a declaration reads a column,
-that column cannot be renamed, retyped or dropped.
-
-On LanceDB Cloud and Enterprise the expression is planned by the
-server, and the refresh runs as a server job -- see
-[Table#refreshColumnAsync](Table.md#refreshcolumnasync).
-
 #### Parameters

-* **newColumnTransforms**:
-    \| `Field`&lt;`any`&gt;
-    \| `Field`&lt;`any`&gt;[]
-    \| `Schema`&lt;`any`&gt;
-    \| [`AddColumnsSql`](../interfaces/AddColumnsSql.md)[]
-    \| `object`
+* **newColumnTransforms**: `Field`&lt;`any`&gt; \| `Field`&lt;`any`&gt;[] \| `Schema`&lt;`any`&gt; \| [`AddColumnsSql`](../interfaces/AddColumnsSql.md)[]
    Either:
    - An array of objects with column names and SQL expressions to calculate values
    - A single Arrow Field defining one column with its data type (column will be initialized with null values)
    - An array of Arrow Fields defining columns with their data types (columns will be initialized with null values)
    - An Arrow Schema defining columns with their data types (columns will be initialized with null values)
-    - `{ computed }`, declaring columns defined by a SQL expression whose type and inputs are derived from it

 #### Returns

@@ -105,13 +85,6 @@ server, and the refresh runs as a server job -- see
 A promise that resolves to an object
 containing the new version number of the table after adding the columns.

-#### Example
-
-```ts
-await table.addColumns({ computed: [{ name: "doubled", valueSql: "x * 2" }] });
-const { rowsFilled } = await table.refreshColumn("doubled");
-```
-
 ***

 ### alterColumns()
@@ -458,10 +431,9 @@ Read the [LsmWriteSpec](../interfaces/LsmWriteSpec.md) currently installed on th

 Resolves to `undefined` when the MemWAL LSM write path is not enabled (no
 spec has been set, or it was removed with [Table#unsetLsmWriteSpec](Table.md#unsetlsmwritespec)).
-The returned spec mirrors what was passed to
-[Table#setLsmWriteSpec](Table.md#setlsmwritespec), except that `maintainedIndexes` always
-reports the concrete list resolved when the spec was set — `undefined`
-never round-trips.
+The returned spec — including its `maintainedIndexes` and
+`writerConfigDefaults` — mirrors what was passed to
+[Table#setLsmWriteSpec](Table.md#setlsmwritespec).

 #### Returns

@@ -745,67 +717,6 @@ for await (const batch of table.query()) {

 ***

-### refreshColumn()
-
-```ts
-abstract refreshColumn(column): Promise<RefreshColumnResult>
-```
-
-Fill the rows of a computed column that hold no value yet.
-
-Rows appended since the last refresh are filled by the next one; rows
-already filled are left as they are, so the call is idempotent and does
-not observe a mutated input. Local tables only: a remote refresh runs
-as a server job, through [Table#refreshColumnAsync](Table.md#refreshcolumnasync).
-
-#### Parameters
-
-* **column**: `string`
-    The name of the computed column to fill.
-
-#### Returns
-
-`Promise`&lt;[`RefreshColumnResult`](../interfaces/RefreshColumnResult.md)&gt;
-
-A promise that resolves to the
-number of rows filled and the new version number of the table.
-
-***
-
-### refreshColumnAsync()
-
-```ts
-abstract refreshColumnAsync(column): Promise<Job>
-```
-
-Like [Table#refreshColumn](Table.md#refreshcolumn), but returns a handle to the refresh
-job instead of blocking until it completes.
-
-The job may already be complete when returned; callers must not assume
-the column is filled until [Job.wait](Job.md#wait) resolves. Invalid input --
-an unknown column, or one that is not computed -- rejects here rather
-than failing the job. On local tables the job runs in-process; on
-LanceDB Cloud and Enterprise it is the server's backfill job.
-
-#### Parameters
-
-* **column**: `string`
-    The name of the computed column to fill.
-
-#### Returns
-
-`Promise`&lt;[`Job`](Job.md)&gt;
-
-#### Example
-
-```ts
-const job = await table.refreshColumnAsync("doubled");
-await job.wait();
-console.log(await job.status()); // "finished"
-```
-
-***
-
 ### restore()

 ```ts
@@ -895,11 +806,6 @@ All variants require the table to have an unenforced primary key
 ([Table#setUnenforcedPrimaryKey](Table.md#setunenforcedprimarykey)); bucket sharding additionally
 requires it to be the single column being bucketed.

-Omitting `maintainedIndexes` maintains every index on the table, resolved
-here, failing if one cannot be maintained — name them to install anyway.
-Naming them pins an exact set, and a still-building index is rejected
-rather than quietly omitted.
-
 #### Parameters

 * **spec**: [`LsmWriteSpec`](../interfaces/LsmWriteSpec.md)
@@ -105,7 +105,6 @@
 - [OptimizeOptions](interfaces/OptimizeOptions.md)
 - [OptimizeStats](interfaces/OptimizeStats.md)
 - [QueryExecutionOptions](interfaces/QueryExecutionOptions.md)
- [RefreshColumnResult](interfaces/RefreshColumnResult.md)
 - [RemovalStats](interfaces/RemovalStats.md)
 - [RenameTableOptions](interfaces/RenameTableOptions.md)
 - [RestNamespaceConfig](interfaces/RestNamespaceConfig.md)
@@ -34,9 +34,7 @@ Bucket and identity variants: the sharding column.
 optional maintainedIndexes: string[];
 ```

-Indexes the MemWAL keeps up to date. Omit to maintain every supported
-index, resolved on install — a snapshot, so indexes created later are not
-maintained. Pass `[]` for none.
+Names of indexes the MemWAL should keep up to date during writes.

 ***

@@ -1,23 +0,0 @@
-[**@lancedb/lancedb**](../README.md) • **Docs**
-
-***
-
-[@lancedb/lancedb](../globals.md) / RefreshColumnResult
-
-# Interface: RefreshColumnResult
-
-## Properties
-
-### rowsFilled
-
-```ts
-rowsFilled: number;
-```
-
-***
-
-### version
-
-```ts
-version: number;
-```
@@ -8,7 +8,7 @@
    <parent>
      <groupId>com.lancedb</groupId>
      <artifactId>lancedb-parent</artifactId>
-      <version>0.38.0-beta.2</version>
+      <version>0.37.1-final.0</version>
      <relativePath>../pom.xml</relativePath>
    </parent>

@@ -6,7 +6,7 @@

    <groupId>com.lancedb</groupId>
    <artifactId>lancedb-parent</artifactId>
-    <version>0.38.0-beta.2</version>
+    <version>0.37.1-final.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>11.0.0-beta.13</lance-core.version>
+        <lance-core.version>10.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>
@@ -1,7 +1,7 @@
 [package]
 name = "lancedb-nodejs"
 edition.workspace = true
-version = "0.38.0-beta.2"
+version = "0.37.1"
 publish = false
 license.workspace = true
 description.workspace = true
@@ -89,16 +89,6 @@ describe("given a connection", () => {
    await db.createTable("test4", [{ id: 1 }, { id: 2 }]);
  });

-  it("should return a completed job when dropping a local table", async () => {
-    await db.createTable("async-drop", [{ id: 1 }]);
-
-    const job = await db.dropTableAsync("async-drop");
-    expect(job.id).toBeNull();
-    await expect(job.status()).resolves.toBe("finished");
-    await job.wait();
-    await expect(db.tableNames()).resolves.toEqual([]);
-  });
-
  it("should fail if creating table twice, unless overwrite is true", async () => {
    let tbl = await db.createTable("test", [{ id: 1 }, { id: 2 }]);
    await expect(tbl.countRows()).resolves.toBe(2);
@@ -3340,67 +3340,3 @@ describe("LSM merge insert", () => {
    await expect(table.query().useLsm(true).toArray()).rejects.toThrow();
  });
 });
-
-describe("computed columns", () => {
-  let tmpDir: tmp.DirResult;
-  beforeEach(() => {
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
-  });
-  afterEach(() => tmpDir.removeCallback());
-
-  it("declares a column and fills it on refresh", async () => {
-    const db = await connect(tmpDir.name);
-    const table = await db.createTable("computed", [{ x: 1 }, { x: 2 }]);
-
-    await table.addColumns({
-      computed: [{ name: "doubled", valueSql: "x * 2" }],
-    });
-    let rows = await table.query().toArray();
-    expect(rows.map((r) => r.doubled)).toEqual([null, null]);
-
-    const result = await table.refreshColumn("doubled");
-    expect(result.rowsFilled).toBe(2);
-
-    rows = await table.query().toArray();
-    expect(rows.map((r) => r.doubled).sort()).toEqual([2, 4]);
-  });
-
-  it("returns a job handle from refreshColumnAsync", async () => {
-    const db = await connect(tmpDir.name);
-    const table = await db.createTable("computed_job", [{ x: 1 }, { x: 2 }]);
-
-    await table.addColumns({
-      computed: [{ name: "doubled", valueSql: "x * 2" }],
-    });
-
-    const job = await table.refreshColumnAsync("doubled");
-    expect(job.id).toBeNull();
-    await job.wait();
-    expect(await job.status()).toBe("finished");
-
-    const rows = await table.query().toArray();
-    expect(rows.map((r) => r.doubled).sort()).toEqual([2, 4]);
-
-    // Bad input rejects at the call, not through the job.
-    await expect(table.refreshColumnAsync("x")).rejects.toThrow(
-      "not a computed column",
-    );
-  });
-
-  it("fills rows added since the last refresh", async () => {
-    const db = await connect(tmpDir.name);
-    const table = await db.createTable("computed_append", [{ x: 1 }]);
-
-    await table.addColumns({
-      computed: [{ name: "doubled", valueSql: "x * 2" }],
-    });
-    await table.refreshColumn("doubled");
-    await table.add([{ x: 5 }]);
-
-    const result = await table.refreshColumn("doubled");
-    expect(result.rowsFilled).toBe(1);
-
-    const rows = await table.query().toArray();
-    expect(rows.map((r) => r.doubled).sort()).toEqual([10, 2]);
-  });
-});
@@ -327,14 +327,6 @@ export abstract class Connection {
   */
  abstract dropTable(name: string, namespacePath?: string[]): Promise<void>;

-  /**
-   * Start dropping a table and return its cleanup job.
-   *
-   * The table may become unavailable before its data files are removed. Wait
-   * on the returned job to know when cleanup has finished.
-   */
-  abstract dropTableAsync(name: string, namespacePath?: string[]): Promise<Job>;
-
  /**
   * Drop all tables in the database.
   * @param {string[]} namespacePath The namespace path to drop tables from (defaults to root namespace).
@@ -713,10 +705,6 @@ export class LocalConnection extends Connection {
    return this.inner.dropTable(name, namespacePath ?? []);
  }

-  async dropTableAsync(name: string, namespacePath?: string[]): Promise<Job> {
-    return this.inner.dropTableAsync(name, namespacePath ?? []);
-  }
-
  async dropAllTables(namespacePath?: string[]): Promise<void> {
    return this.inner.dropAllTables(namespacePath ?? []);
  }
@@ -50,7 +50,6 @@ export {
  MergeResult,
  AddResult,
  AddColumnsResult,
-  RefreshColumnResult,
  AlterColumnsResult,
  UpdateFieldMetadataResult,
  DeleteResult,
@@ -33,7 +33,6 @@ import {
  Job,
  Branches as NativeBranches,
  OptimizeStats,
-  RefreshColumnResult,
  TableStatistics,
  Tags,
  UpdateFieldMetadataResult,
@@ -198,11 +197,7 @@ export interface LsmWriteSpec {
  column?: string;
  /** Bucket variant: the number of buckets, in `[1, 1024]`. */
  numBuckets?: number;
-  /**
-   * Indexes the MemWAL keeps up to date. Omit to maintain every supported
-   * index, resolved on install — a snapshot, so indexes created later are not
-   * maintained. Pass `[]` for none.
-   */
+  /** Names of indexes the MemWAL should keep up to date during writes. */
  maintainedIndexes?: string[];
  /** Default `ShardWriter` configuration recorded in the MemWAL index. */
  writerConfigDefaults?: Record<string, string>;
@@ -526,75 +521,18 @@ export abstract class Table {
  abstract vectorSearch(vector: IntoVector | MultiVector): VectorQuery;
  /**
   * Add new columns with defined values.
-   *
-   * The `{ computed }` form stores the expression rather than evaluating it
-   * now: the column is committed with no values, and rows get them from
-   * {@link Table#refreshColumn}. Declaring one therefore costs the same on a
-   * large table as on an empty one.
-   *
-   * A refresh does not revisit rows it has already filled, so mutating an
-   * input leaves the value computed at fill time; recomputing means dropping
-   * the column and declaring it again. While a declaration reads a column,
-   * that column cannot be renamed, retyped or dropped.
-   *
-   * On LanceDB Cloud and Enterprise the expression is planned by the
-   * server, and the refresh runs as a server job -- see
-   * {@link Table#refreshColumnAsync}.
   * @param {AddColumnsSql[] | Field | Field[] | Schema} newColumnTransforms Either:
   *   - An array of objects with column names and SQL expressions to calculate values
   *   - A single Arrow Field defining one column with its data type (column will be initialized with null values)
   *   - An array of Arrow Fields defining columns with their data types (columns will be initialized with null values)
   *   - An Arrow Schema defining columns with their data types (columns will be initialized with null values)
-   *   - `{ computed }`, declaring columns defined by a SQL expression whose type and inputs are derived from it
   * @returns {Promise<AddColumnsResult>} A promise that resolves to an object
   * containing the new version number of the table after adding the columns.
-   * @example
-   * ```ts
-   * await table.addColumns({ computed: [{ name: "doubled", valueSql: "x * 2" }] });
-   * const { rowsFilled } = await table.refreshColumn("doubled");
-   * ```
   */
  abstract addColumns(
-    newColumnTransforms:
-      | AddColumnsSql[]
-      | Field
-      | Field[]
-      | Schema
-      | { computed: AddColumnsSql[] },
+    newColumnTransforms: AddColumnsSql[] | Field | Field[] | Schema,
  ): Promise<AddColumnsResult>;

-  /**
-   * Fill the rows of a computed column that hold no value yet.
-   *
-   * Rows appended since the last refresh are filled by the next one; rows
-   * already filled are left as they are, so the call is idempotent and does
-   * not observe a mutated input. Local tables only: a remote refresh runs
-   * as a server job, through {@link Table#refreshColumnAsync}.
-   * @param {string} column The name of the computed column to fill.
-   * @returns {Promise<RefreshColumnResult>} A promise that resolves to the
-   * number of rows filled and the new version number of the table.
-   */
-  abstract refreshColumn(column: string): Promise<RefreshColumnResult>;
-
-  /**
-   * Like {@link Table#refreshColumn}, but returns a handle to the refresh
-   * job instead of blocking until it completes.
-   *
-   * The job may already be complete when returned; callers must not assume
-   * the column is filled until {@link Job.wait} resolves. Invalid input --
-   * an unknown column, or one that is not computed -- rejects here rather
-   * than failing the job. On local tables the job runs in-process; on
-   * LanceDB Cloud and Enterprise it is the server's backfill job.
-   * @param {string} column The name of the computed column to fill.
-   * @example
-   * ```ts
-   * const job = await table.refreshColumnAsync("doubled");
-   * await job.wait();
-   * console.log(await job.status()); // "finished"
-   * ```
-   */
-  abstract refreshColumnAsync(column: string): Promise<Job>;
-
  /**
   * Alter the name or nullability of columns.
   * @param {ColumnAlteration[]} columnAlterations One or more alterations to
@@ -657,11 +595,6 @@ export abstract class Table {
   * All variants require the table to have an unenforced primary key
   * ({@link Table#setUnenforcedPrimaryKey}); bucket sharding additionally
   * requires it to be the single column being bucketed.
-   *
-   * Omitting `maintainedIndexes` maintains every index on the table, resolved
-   * here, failing if one cannot be maintained — name them to install anyway.
-   * Naming them pins an exact set, and a still-building index is rejected
-   * rather than quietly omitted.
   * @param {LsmWriteSpec} spec The sharding spec to install.
   * @returns {Promise<void>}
   * @example
@@ -689,10 +622,9 @@ export abstract class Table {
   *
   * Resolves to `undefined` when the MemWAL LSM write path is not enabled (no
   * spec has been set, or it was removed with {@link Table#unsetLsmWriteSpec}).
-   * The returned spec mirrors what was passed to
-   * {@link Table#setLsmWriteSpec}, except that `maintainedIndexes` always
-   * reports the concrete list resolved when the spec was set — `undefined`
-   * never round-trips.
+   * The returned spec — including its `maintainedIndexes` and
+   * `writerConfigDefaults` — mirrors what was passed to
+   * {@link Table#setLsmWriteSpec}.
   * @returns {Promise<LsmWriteSpec | undefined>}
   */
  abstract getLsmWriteSpec(): Promise<LsmWriteSpec | undefined>;
@@ -1146,22 +1078,8 @@ export class LocalTable extends Table {
  // TODO: Support BatchUDF

  async addColumns(
-    newColumnTransforms:
-      | AddColumnsSql[]
-      | Field
-      | Field[]
-      | Schema
-      | { computed: AddColumnsSql[] },
+    newColumnTransforms: AddColumnsSql[] | Field | Field[] | Schema,
  ): Promise<AddColumnsResult> {
-    // Columns defined by an expression are declared, not materialized here.
-    if (
-      typeof newColumnTransforms === "object" &&
-      !Array.isArray(newColumnTransforms) &&
-      "computed" in newColumnTransforms
-    ) {
-      return await this.inner.addComputedColumns(newColumnTransforms.computed);
-    }
-
    // Handle single Field -> convert to array of Fields
    if (newColumnTransforms instanceof Field) {
      newColumnTransforms = [newColumnTransforms];
@@ -1196,14 +1114,6 @@ export class LocalTable extends Table {
    throw new Error("Invalid input type for addColumns");
  }

-  async refreshColumn(column: string): Promise<RefreshColumnResult> {
-    return await this.inner.refreshColumn(column);
-  }
-
-  async refreshColumnAsync(column: string): Promise<Job> {
-    return await this.inner.refreshColumnAsync(column);
-  }
-
  async alterColumns(
    columnAlterations: ColumnAlteration[],
  ): Promise<AlterColumnsResult> {
@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-darwin-arm64",
-	"version": "0.38.0-beta.2",
+	"version": "0.37.1",
 	"os": ["darwin"],
 	"cpu": ["arm64"],
 	"main": "lancedb.darwin-arm64.node",
@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-arm64-gnu",
-	"version": "0.38.0-beta.2",
+	"version": "0.37.1",
 	"os": ["linux"],
 	"cpu": ["arm64"],
 	"main": "lancedb.linux-arm64-gnu.node",
@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-arm64-musl",
-	"version": "0.38.0-beta.2",
+	"version": "0.37.1",
 	"os": ["linux"],
 	"cpu": ["arm64"],
 	"main": "lancedb.linux-arm64-musl.node",
@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-x64-gnu",
-	"version": "0.38.0-beta.2",
+	"version": "0.37.1",
 	"os": ["linux"],
 	"cpu": ["x64"],
 	"main": "lancedb.linux-x64-gnu.node",
@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-x64-musl",
-	"version": "0.38.0-beta.2",
+	"version": "0.37.1",
 	"os": ["linux"],
 	"cpu": ["x64"],
 	"main": "lancedb.linux-x64-musl.node",
@@ -1,6 +1,6 @@
 {
  "name": "@lancedb/lancedb-win32-arm64-msvc",
-  "version": "0.38.0-beta.2",
+  "version": "0.37.1",
  "os": [
    "win32"
  ],
@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-win32-x64-msvc",
-	"version": "0.38.0-beta.2",
+	"version": "0.37.1",
 	"os": ["win32"],
 	"cpu": ["x64"],
 	"main": "lancedb.win32-x64-msvc.node",
@@ -1,12 +1,12 @@
 {
  "name": "@lancedb/lancedb",
-  "version": "0.38.0-beta.1",
+  "version": "0.37.1",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@lancedb/lancedb",
-      "version": "0.38.0-beta.1",
+      "version": "0.37.1",
      "cpu": [
        "x64",
        "arm64"
@@ -11,7 +11,7 @@
    "ann"
  ],
  "private": false,
-  "version": "0.38.0-beta.2",
+  "version": "0.37.1",
  "main": "dist/index.js",
  "exports": {
    ".": "./dist/index.js",
@@ -334,22 +334,6 @@ impl Connection {
            .default_error()
    }

-    /// Start dropping a table and return its cleanup job.
-    #[napi(catch_unwind)]
-    pub async fn drop_table_async(
-        &self,
-        name: String,
-        namespace_path: Option<Vec<String>>,
-    ) -> napi::Result<crate::job::Job> {
-        let ns = namespace_path.unwrap_or_default();
-        let job = self
-            .get_inner()?
-            .drop_table_async(&name, &ns)
-            .await
-            .default_error()?;
-        Ok(crate::job::Job::new(job))
-    }
-
    #[napi(catch_unwind)]
    pub async fn drop_all_tables(&self, namespace_path: Option<Vec<String>>) -> napi::Result<()> {
        let ns = namespace_path.unwrap_or_default();
@@ -347,40 +347,6 @@ impl Table {
        Ok(res.into())
    }

-    #[napi(catch_unwind)]
-    pub async fn add_computed_columns(
-        &self,
-        columns: Vec<AddColumnsSql>,
-    ) -> napi::Result<AddColumnsResult> {
-        let table = self.inner_ref()?;
-        let mut builder = table.add_columns();
-        for column in columns {
-            builder = builder.computed(column.name, column.value_sql);
-        }
-        let res = builder.execute().await.default_error()?;
-        Ok(res.into())
-    }
-
-    #[napi(catch_unwind)]
-    pub async fn refresh_column(&self, column: String) -> napi::Result<RefreshColumnResult> {
-        let res = self
-            .inner_ref()?
-            .refresh_column(column)
-            .await
-            .default_error()?;
-        Ok(res.into())
-    }
-
-    #[napi(catch_unwind)]
-    pub async fn refresh_column_async(&self, column: String) -> napi::Result<crate::job::Job> {
-        let job = self
-            .inner_ref()?
-            .refresh_column_async(column)
-            .await
-            .default_error()?;
-        Ok(crate::job::Job::new(job))
-    }
-
    #[napi(catch_unwind)]
    pub async fn add_columns_with_schema(
        &self,
@@ -806,8 +772,7 @@ pub struct LsmWriteSpec {
    pub column: Option<String>,
    /// Bucket variant: the number of buckets, in `[1, 1024]`.
    pub num_buckets: Option<u32>,
-    /// Indexes the MemWAL keeps up to date. Omitted resolves every
-    /// maintainable index on install; an empty array means none.
+    /// Names of indexes the MemWAL should keep up to date during writes.
    pub maintained_indexes: Option<Vec<String>>,
    /// Default `ShardWriter` configuration recorded in the MemWAL index.
    pub writer_config_defaults: Option<HashMap<String, String>>,
@@ -817,6 +782,7 @@ impl TryFrom<LsmWriteSpec> for lancedb::table::LsmWriteSpec {
    type Error = napi::Error;

    fn try_from(value: LsmWriteSpec) -> napi::Result<Self> {
+        let maintained = value.maintained_indexes.unwrap_or_default();
        let writer_config_defaults = value.writer_config_defaults.unwrap_or_default();
        let spec = match value.spec_type.as_str() {
            "bucket" => {
@@ -843,7 +809,7 @@ impl TryFrom<LsmWriteSpec> for lancedb::table::LsmWriteSpec {
            }
        };
        Ok(spec
-            .with_maintained_indexes(value.maintained_indexes)
+            .with_maintained_indexes(maintained)
            .with_writer_config_defaults(writer_config_defaults))
    }
 }
@@ -861,7 +827,7 @@ impl From<lancedb::table::LsmWriteSpec> for LsmWriteSpec {
                spec_type: "bucket".to_string(),
                column: Some(column),
                num_buckets: Some(num_buckets),
-                maintained_indexes,
+                maintained_indexes: Some(maintained_indexes),
                writer_config_defaults: Some(writer_config_defaults),
            },
            Native::Identity {
@@ -872,7 +838,7 @@ impl From<lancedb::table::LsmWriteSpec> for LsmWriteSpec {
                spec_type: "identity".to_string(),
                column: Some(column),
                num_buckets: None,
-                maintained_indexes,
+                maintained_indexes: Some(maintained_indexes),
                writer_config_defaults: Some(writer_config_defaults),
            },
            Native::Unsharded {
@@ -882,7 +848,7 @@ impl From<lancedb::table::LsmWriteSpec> for LsmWriteSpec {
                spec_type: "unsharded".to_string(),
                column: None,
                num_buckets: None,
-                maintained_indexes,
+                maintained_indexes: Some(maintained_indexes),
                writer_config_defaults: Some(writer_config_defaults),
            },
        }
@@ -1230,21 +1196,6 @@ pub struct AddColumnsResult {
    pub version: i64,
 }

-#[napi(object)]
-pub struct RefreshColumnResult {
-    pub rows_filled: i64,
-    pub version: i64,
-}
-
-impl From<lancedb::table::RefreshColumnResult> for RefreshColumnResult {
-    fn from(value: lancedb::table::RefreshColumnResult) -> Self {
-        Self {
-            rows_filled: value.rows_filled as i64,
-            version: value.version as i64,
-        }
-    }
-}
-
 impl From<lancedb::table::AddColumnsResult> for AddColumnsResult {
    fn from(value: lancedb::table::AddColumnsResult) -> Self {
        Self {
@@ -1,6 +1,6 @@
 [package]
 name = "lancedb-python"
-version = "0.38.0-beta.2"
+version = "0.37.1"
 publish = false
 edition.workspace = true
 description = "Python bindings for LanceDB"
@@ -63,7 +63,7 @@ tests = [
    "polars>=0.19, <=1.32.3",
    "pyarrow<25",
    "pyarrow-stubs>=16.0",
-    "pylance==9.0.0rc1",
+    "pylance==10.0.0",
    "requests>=2.31.0",
    "datafusion>=54,<55",
    "opentelemetry-sdk>=1.30.0",
@@ -198,9 +198,6 @@ class Connection(object):
    async def drop_table(
        self, name: str, namespace_path: Optional[List[str]] = None
    ) -> None: ...
-    async def drop_table_async(
-        self, name: str, namespace_path: Optional[List[str]] = None
-    ) -> Job: ...
    async def drop_all_tables(
        self, namespace_path: Optional[List[str]] = None
    ) -> None: ...
@@ -338,11 +335,6 @@ class Table:
    ) -> list[FtsToken]: ...
    async def delete(self, filter: Union[str, PyExpr]) -> DeleteResult: ...
    async def add_columns(self, columns: list[tuple[str, str]]) -> AddColumnsResult: ...
-    async def add_computed_columns(
-        self, columns: list[tuple[str, str]]
-    ) -> AddColumnsResult: ...
-    async def refresh_column(self, column: str) -> RefreshColumnResult: ...
-    async def refresh_column_async(self, column: str) -> Job: ...
    async def add_columns_with_schema(self, schema: pa.Schema) -> AddColumnsResult: ...
    async def alter_columns(
        self, columns: list[dict[str, Any]]
@@ -661,10 +653,9 @@ class LsmWriteSpec:
    def identity(column: str) -> "LsmWriteSpec": ...
    @staticmethod
    def unsharded() -> "LsmWriteSpec": ...
-    def with_maintained_indexes(self, indexes: Optional[List[str]]) -> "LsmWriteSpec":
-        """Set which indexes the MemWAL keeps up to date. None resolves every
-        index on the table at install, failing if one cannot be maintained;
-        a list is verbatim, empty means none."""
+    def with_maintained_indexes(self, indexes: List[str]) -> "LsmWriteSpec":
+        """Return a copy of this spec asking the MemWAL to keep the named
+        indexes up to date as rows are appended."""
        ...
    def with_writer_config_defaults(self, defaults: Dict[str, str]) -> "LsmWriteSpec":
        """Return a copy of this spec recording the given default
@@ -679,19 +670,13 @@ class LsmWriteSpec:
    @property
    def num_buckets(self) -> Optional[int]: ...
    @property
-    def maintained_indexes(self) -> Optional[List[str]]:
-        """Indexes the MemWAL keeps up to date, or None for every supported one."""
-        ...
+    def maintained_indexes(self) -> List[str]: ...
    @property
    def writer_config_defaults(self) -> Dict[str, str]: ...

 class AddColumnsResult:
    version: int

-class RefreshColumnResult:
-    rows_filled: int
-    version: int
-
 class AlterColumnsResult:
    version: int

@@ -524,12 +524,6 @@ class DBConnection(EnforceOverrides):
            namespace_path = []
        raise NotImplementedError

-    def drop_table_async(
-        self, name: str, namespace_path: Optional[List[str]] = None
-    ) -> Job:
-        """Start dropping a table and return its cleanup job."""
-        raise NotImplementedError
-
    def rename_table(
        self,
        cur_name: str,
@@ -1192,20 +1186,6 @@ class LanceDBConnection(DBConnection):
            )
        )

-    @override
-    def drop_table_async(
-        self, name: str, namespace_path: Optional[List[str]] = None
-    ) -> Job:
-        """Start dropping a table and return its cleanup job.
-
-        The table may become unavailable before its data files are removed.
-        Call :meth:`Job.wait` to wait for cleanup to finish.
-        """
-        if namespace_path is None:
-            namespace_path = []
-        job = LOOP.run(self._conn.drop_table_async(name, namespace_path=namespace_path))
-        return Job(job if isinstance(job, AsyncJob) else AsyncJob(job))
-
    @override
    def drop_all_tables(self, namespace_path: Optional[List[str]] = None):
        if namespace_path is None:
@@ -1983,23 +1963,6 @@ class AsyncConnection(object):
            if f"Table '{name}' was not found" not in str(e):
                raise e

-    async def drop_table_async(
-        self,
-        name: str,
-        *,
-        namespace_path: Optional[List[str]] = None,
-    ) -> AsyncJob:
-        """Start dropping a table and return its cleanup job.
-
-        The table may become unavailable before its data files are removed.
-        Await :meth:`AsyncJob.wait` to wait for cleanup to finish.
-        """
-        if namespace_path is None:
-            namespace_path = []
-        return AsyncJob(
-            await self._inner.drop_table_async(name, namespace_path=namespace_path)
-        )
-
    async def drop_all_tables(self, namespace_path: Optional[List[str]] = None):
        """Drop all tables from the database.

@@ -49,7 +49,6 @@ from lancedb._lancedb import (
 )
 from lancedb.background_loop import LOOP
 from lancedb.db import AsyncConnection, DBConnection
-from lancedb.job import AsyncJob, Job
 from lance_namespace import (
    LanceNamespace,
    connect as namespace_connect,
@@ -625,18 +624,6 @@ class LanceNamespaceDBConnection(DBConnection):
            namespace_path = []
        LOOP.run(self._inner.drop_table(name, namespace_path=namespace_path))

-    @override
-    def drop_table_async(
-        self, name: str, namespace_path: Optional[List[str]] = None
-    ) -> Job:
-        """Start dropping a table and return its cleanup job."""
-        if namespace_path is None:
-            namespace_path = []
-        job = LOOP.run(
-            self._inner.drop_table_async(name, namespace_path=namespace_path)
-        )
-        return Job(job if isinstance(job, AsyncJob) else AsyncJob(job))
-
    @override
    def rename_table(
        self,
@@ -1147,14 +1134,6 @@ class AsyncLanceNamespaceDBConnection:
            namespace_path = []
        await self._inner.drop_table(name, namespace_path=namespace_path)

-    async def drop_table_async(
-        self, name: str, namespace_path: Optional[List[str]] = None
-    ) -> AsyncJob:
-        """Start dropping a table and return its cleanup job."""
-        if namespace_path is None:
-            namespace_path = []
-        return await self._inner.drop_table_async(name, namespace_path=namespace_path)
-
    async def rename_table(
        self,
        cur_name: str,
@@ -2235,7 +2235,6 @@ class LanceHybridQueryBuilder(LanceQueryBuilder):
            reranker=self._reranker,
            limit=self._limit,
            with_row_ids=True,
-            offset=self._offset,
        )
        return self._finish_hybrid_results(results)

@@ -2257,7 +2256,6 @@ class LanceHybridQueryBuilder(LanceQueryBuilder):
        reranker,
        limit: int,
        with_row_ids: bool,
-        offset: Optional[int] = None,
    ) -> pa.Table:
        if norm == "rank":
            vector_results = LanceHybridQueryBuilder._rank(vector_results, "_distance")
@@ -2334,7 +2332,7 @@ class LanceHybridQueryBuilder(LanceQueryBuilder):
            score_i = results.column_names.index("_score")
            results = results.set_column(score_i, "_score", original_scores)

-        results = results.slice(offset=offset or 0, length=limit)
+        results = results.slice(length=limit)

        if not with_row_ids:
            results = results.drop(["_rowid"])
@@ -2681,12 +2679,8 @@ class LanceHybridQueryBuilder(LanceQueryBuilder):

        # Apply common configurations
        if self._limit:
-            # The final offset/limit window is sliced out of the combined,
-            # reranked results, so each sub-query must fetch enough rows to
-            # cover the skipped prefix as well as the window itself.
-            sub_query_limit = self._limit + (self._offset or 0)
-            self._vector_query.limit(sub_query_limit)
-            self._fts_query.limit(sub_query_limit)
+            self._vector_query.limit(self._limit)
+            self._fts_query.limit(self._limit)
        if self._columns:
            self._vector_query.select(self._columns)
            self._fts_query.select(self._columns)
@@ -23,7 +23,7 @@ import pyarrow as pa

 from ..common import DATA
 from ..db import DBConnection, LOOP
-from ..job import AsyncJob, Job
+from ..job import Job

 if TYPE_CHECKING:
    from .._lancedb import JobDescription, JobInfo
@@ -663,16 +663,6 @@ class RemoteDBConnection(DBConnection):
            namespace_path = []
        LOOP.run(self._conn.drop_table(name, namespace_path=namespace_path))

-    @override
-    def drop_table_async(
-        self, name: str, namespace_path: Optional[List[str]] = None
-    ) -> Job:
-        """Start dropping a table and return its cleanup job."""
-        if namespace_path is None:
-            namespace_path = []
-        job = LOOP.run(self._conn.drop_table_async(name, namespace_path=namespace_path))
-        return Job(job if isinstance(job, AsyncJob) else AsyncJob(job))
-
    @override
    def rename_table(
        self,
@@ -958,19 +958,8 @@ class RemoteTable(Table):
    def count_rows(self, filter: Optional[str] = None) -> int:
        return LOOP.run(self._table.count_rows(filter))

-    def add_columns(
-        self,
-        transforms: Dict[str, str] | None = None,
-        *,
-        computed: Dict[str, str] | None = None,
-    ) -> AddColumnsResult:
-        return LOOP.run(self._table.add_columns(transforms, computed=computed))
-
-    def refresh_column(self, column: str):
-        return LOOP.run(self._table.refresh_column(column))
-
-    def refresh_column_async(self, column: str) -> Job:
-        return Job(LOOP.run(self._table.refresh_column_async(column)))
+    def add_columns(self, transforms: Dict[str, str]) -> AddColumnsResult:
+        return LOOP.run(self._table.add_columns(transforms))

    def alter_columns(
        self, *alterations: Iterable[Dict[str, str]]
@@ -990,39 +979,17 @@ class RemoteTable(Table):
        return LOOP.run(self._table.set_unenforced_primary_key(columns))

    def set_lsm_write_spec(self, spec: "LsmWriteSpec") -> None:
-        """Install an LsmWriteSpec."""
+        """Not supported on LanceDB Cloud."""
        return LOOP.run(self._table.set_lsm_write_spec(spec))

    def unset_lsm_write_spec(self) -> None:
-        """Remove the LsmWriteSpec."""
+        """Not supported on LanceDB Cloud."""
        return LOOP.run(self._table.unset_lsm_write_spec())

    def get_lsm_write_spec(self) -> Optional["LsmWriteSpec"]:
        """Read the installed LsmWriteSpec, or ``None``."""
        return LOOP.run(self._table.get_lsm_write_spec())

-    def checkpoint_lsm(self) -> None:
-        """Synchronous version of
-        [`AsyncTable.checkpoint_lsm`][lancedb.AsyncTable.checkpoint_lsm]."""
-        return LOOP.run(self._table.checkpoint_lsm())
-
-    def flush_lsm(self) -> None:
-        """Synchronous version of
-        [`AsyncTable.flush_lsm`][lancedb.AsyncTable.flush_lsm]."""
-        return LOOP.run(self._table.flush_lsm())
-
-    def compact_lsm(self) -> None:
-        """Synchronous version of
-        [`AsyncTable.compact_lsm`][lancedb.AsyncTable.compact_lsm]."""
-        return LOOP.run(self._table.compact_lsm())
-
-    def get_lsm_stats(self, *, include_generation_rows: bool = False) -> Optional[dict]:
-        """Synchronous version of
-        [`AsyncTable.get_lsm_stats`][lancedb.AsyncTable.get_lsm_stats]."""
-        return LOOP.run(
-            self._table.get_lsm_stats(include_generation_rows=include_generation_rows)
-        )
-
    def close_lsm_writers(self) -> None:
        """No-op on LanceDB Cloud (no local shard writers)."""
        return LOOP.run(self._table.close_lsm_writers())
@@ -11,11 +11,6 @@ Provides StreamingDataset, a PyTorch IterableDataset that guarantees:
 - **Resumability**: state_dict / load_state_dict capture per-split consumption
  counts so training can resume from an exact mid-epoch position even when the
  distributed topology changes between runs.
-
-Transform failures on bad rows (e.g. nulls or NaNs from incomplete data) can
-be tolerated with ``on_transform_error="skip"``; see the parameter
-documentation on StreamingDataset for how this interacts with the guarantees
-above.
 """

 import ctypes
@@ -27,7 +22,7 @@ import time
 from collections import deque
 from concurrent.futures import ThreadPoolExecutor
 from multiprocessing import RawArray
-from typing import Any, Callable, Iterator, Optional, Union
+from typing import Any, Callable, Iterator, Optional

 from torch.utils.data import IterableDataset, get_worker_info

@@ -132,49 +127,6 @@ class StreamingDataset(IterableDataset):
        Maximum number of transforms to run concurrently.  Must be greater
        than zero.  When ``None`` (the default), uses ``os.cpu_count()`` or 1
        when the CPU count is unavailable.
-    on_transform_error:
-        What to do when the transform raises an exception:
-
-        - ``"raise"`` (the default): the exception propagates and iteration
-          aborts.
-        - ``"skip"``: the failing rows are dropped and iteration continues.
-        - ``"warn"``: like ``"skip"``, but a warning is logged for each
-          failing batch.
-        - a callable ``handler(exc) -> bool``: called with the exception;
-          return ``True`` to skip the failing rows or ``False`` to re-raise.
-          Useful to skip only expected error types (compatible with
-          ``webdataset.handlers`` style handlers).
-
-        When a batch fails, the transform is re-invoked on each single-row
-        slice of the batch so that only the rows that actually fail are
-        dropped.  Transforms should therefore be deterministic and accept
-        batches of any size (including one row).  Skipped rows are counted in
-        ``rows_skipped``.
-
-        Skipping weakens the elastic-determinism guarantee at the end of the
-        epoch: splits that lose more rows than others run dry earlier, and
-        each rank's iterator ends at the last cycle where every split *it
-        owns* still has a row.  Because bad rows are not distributed evenly
-        across splits, this means one rank's iterator can yield noticeably
-        fewer or more steps than another rank's *in the same run* — there is
-        no cross-rank coordination that stops every rank at the same global
-        step.  This is generally safe for asynchronous or single-rank use,
-        but synchronous distributed training (e.g. ranks that call
-        ``all_reduce`` every step) can hang or deadlock if one rank's
-        iterator is exhausted while others are still stepping; callers doing
-        synchronous multi-rank training with ``on_transform_error != "raise"``
-        are responsible for their own cross-rank stopping mechanism (e.g.
-        broadcasting a stop signal on ``StopIteration``).  The final few
-        global steps can also differ across topologies (bounded by the skew
-        in bad-row counts across splits).  The sequence of samples yielded
-        from each split remains deterministic.  Mid-epoch
-        checkpoints remain exact provided the transform fails
-        deterministically; in multi-rank training each rank must save its
-        own ``state_dict`` and the states must be combined with
-        ``merge_state_dicts`` before resuming on a different topology.
-        Prefer the ``filter`` parameter when bad rows can be expressed as a
-        SQL predicate (e.g. ``"col IS NOT NULL"``) — filtering happens before
-        splits are built, so every guarantee is fully preserved.
    worker_info_override:
        If set, used in place of ``torch.utils.data.get_worker_info()`` to
        determine the DataLoader worker assignment.  Intended for unit tests
@@ -200,7 +152,6 @@ class StreamingDataset(IterableDataset):
        filter: Optional[str] = None,
        transform: Optional[Callable] = None,
        transform_parallelism: Optional[int] = None,
-        on_transform_error: Union[str, Callable[[Exception], bool]] = "raise",
        connection_factory: Optional[Callable[[str], Any]] = None,
        worker_info_override=None,
    ):
@@ -216,13 +167,6 @@ class StreamingDataset(IterableDataset):
            )
        if transform_parallelism is not None and transform_parallelism <= 0:
            raise ValueError("transform_parallelism must be greater than 0")
-        if on_transform_error not in ("raise", "skip", "warn") and not callable(
-            on_transform_error
-        ):
-            raise ValueError(
-                "on_transform_error must be 'raise', 'skip', 'warn', or a "
-                f"callable, got {on_transform_error!r}"
-            )

        self._table = table
        self._num_splits = num_splits
@@ -238,7 +182,6 @@ class StreamingDataset(IterableDataset):
        self._filter = filter
        self._transform = transform
        self._transform_parallelism = transform_parallelism
-        self._on_transform_error = on_transform_error
        self._connection_factory = connection_factory
        self._worker_info_override = worker_info_override

@@ -256,28 +199,19 @@ class StreamingDataset(IterableDataset):
        # in the main process.  RawArray is picklable via the forkserver
        # reduction protocol so it survives the dataset pickle round-trip.
        # Layout: [unscanned_rows, raw_rows, cooked_rows, consumed_rows,
-        #          bytes_loaded, fetch_time_us, transform_time_us,
-        #          rows_skipped]
-        self._worker_stats: RawArray = RawArray(ctypes.c_int64, 8)
+        #          bytes_loaded, fetch_time_us, transform_time_us]
+        self._worker_stats: RawArray = RawArray(ctypes.c_int64, 7)

        # Cumulative bytes of Arrow buffer data fetched across all iterations.
        self._bytes_loaded: int = 0
        # Cumulative seconds spent in LanceDB I/O and in transform functions.
        self._fetch_time: float = 0.0
        self._transform_time: float = 0.0
-        # Cumulative rows dropped by on_transform_error across all iterations.
-        self._rows_skipped: int = 0

        # Number of samples each split has already been consumed.  At global
        # step boundaries all splits have consumed this many samples, so a
        # single scalar captures the topology-independent checkpoint state.
        self._resume_offset: int = 0
-        # Permutation position each split has consumed through, keyed by
-        # global split index.  Equal to _resume_offset for every split unless
-        # on_transform_error skipped rows, in which case skipped positions
-        # push the watermark of the affected splits further ahead.  Splits
-        # this instance has never iterated have no entry.
-        self._resume_positions: dict[int, int] = {}

        # Build the permutation table once, deterministically.
        builder = permutation_builder(table)
@@ -341,7 +275,6 @@ class StreamingDataset(IterableDataset):
        # Set identity transform on each Permutation so __getitems__ returns
        # the raw RecordBatch.  Stage 2 applies the real transform.
        permutations: list[Permutation] = []
-        initial_positions: list[int] = []
        for split_idx in my_splits:
            perm = Permutation.from_tables(
                self._table, self._perm_table, split=split_idx
@@ -349,20 +282,14 @@ class StreamingDataset(IterableDataset):
            if self._columns is not None:
                perm = perm.select_columns(self._columns)
            perm = perm.with_transform(lambda batch: batch)
-            start_pos = self._resume_positions.get(split_idx, self._resume_offset)
-            if start_pos > 0:
-                perm = perm.with_skip(start_pos)
-            initial_positions.append(start_pos)
+            if self._resume_offset > 0:
+                perm = perm.with_skip(self._resume_offset)
            permutations.append(perm)

        n = len(permutations)
        split_sizes = [perm.num_rows for perm in permutations]
        initial_offset = self._resume_offset
        local_consumed = [0] * n
-        # Permutation position each split has consumed through (absolute,
-        # i.e. counted from the start of the unskipped split).  Runs ahead of
-        # initial + local_consumed when rows are skipped.
-        pos_consumed = list(initial_positions)

        batch_size = self._read_batch_size
        max_prefetch = self._prefetch_batches
@@ -375,14 +302,12 @@ class StreamingDataset(IterableDataset):
            self._transform if self._transform is not None else Transforms.arrow2python
        )

-        # Per-split pipeline state.  Batches are paired with the absolute
-        # permutation position of their first row so that skipped rows can be
-        # accounted for in pos_consumed.
+        # Per-split pipeline state.
        fetch_head = [0] * n
-        io_pending = [deque() for _ in range(n)]  # (abs_start, Future[RecordBatch])
-        raw_batches = [deque() for _ in range(n)]  # (abs_start, RecordBatch)
-        tx_pending = [deque() for _ in range(n)]  # Future[list[(abs_pos, row)]]
-        cooked = [deque() for _ in range(n)]  # (abs_pos, row) ready to yield
+        io_pending = [deque() for _ in range(n)]  # Future[RecordBatch]
+        raw_batches = [deque() for _ in range(n)]  # RecordBatch — fetched, awaiting tx
+        tx_pending = [deque() for _ in range(n)]  # Future[list[Any]]
+        cooked = [deque() for _ in range(n)]  # rows ready to yield

        # Limit simultaneous transforms to transform_workers across all splits.
        tx_semaphore = threading.Semaphore(transform_workers)
@@ -405,8 +330,7 @@ class StreamingDataset(IterableDataset):
            fetch_head[i] += fetch
            perm_i = permutations[i]
            indices = list(range(start, start + fetch))
-            abs_start = initial_positions[i] + start
-            io_pending[i].append((abs_start, io_pool.submit(_io_call, perm_i, indices)))
+            io_pending[i].append(io_pool.submit(_io_call, perm_i, indices))

        def _fill_io(i: int) -> None:
            while len(io_pending[i]) < max_prefetch and fetch_head[i] < split_sizes[i]:
@@ -414,72 +338,15 @@ class StreamingDataset(IterableDataset):

        def _drain_io(i: int) -> None:
            """Move completed I/O futures into raw_batches non-blockingly."""
-            while io_pending[i] and io_pending[i][0][1].done():
-                abs_start, fut = io_pending[i].popleft()
-                raw_batches[i].append((abs_start, fut.result()))
+            while io_pending[i] and io_pending[i][0].done():
+                raw_batches[i].append(io_pending[i].popleft().result())

        # ── Stage 2 helpers ───────────────────────────────────────────────────

-        on_error = self._on_transform_error
-
-        def _should_skip(exc: Exception) -> bool:
-            if on_error == "raise":
-                return False
-            if callable(on_error):
-                return bool(on_error(exc))
-            return True  # "skip" or "warn"
-
-        def _check_row_count(rows: list, num_rows: int) -> None:
-            if len(rows) != num_rows:
-                raise ValueError(
-                    f"transform returned {len(rows)} rows for a batch of "
-                    f"{num_rows}; transforms must return exactly one output "
-                    "row per input row.  To drop bad rows, raise inside the "
-                    "transform and pass on_transform_error='skip'."
-                )
-
-        def _transform_isolated(abs_start, batch, batch_exc):
-            """Re-run the transform on single-row slices, dropping failures."""
-            out = []
-            skipped = 0
-            first_exc = None
-            for j in range(batch.num_rows):
-                try:
-                    rows = list(final_transform(batch.slice(j, 1)))
-                except Exception as exc:
-                    if not _should_skip(exc):
-                        raise
-                    skipped += 1
-                    if first_exc is None:
-                        first_exc = exc
-                    continue
-                _check_row_count(rows, 1)
-                out.append((abs_start + j, rows[0]))
-            self._rows_skipped += skipped
-            if skipped and on_error == "warn":
-                logger.warning(
-                    "Skipped %d of %d rows whose transform failed (first error: %r)",
-                    skipped,
-                    batch.num_rows,
-                    first_exc if first_exc is not None else batch_exc,
-                )
-            return out
-
-        def _transform_batch(abs_start, batch):
-            """Apply the transform, returning [(abs_pos, row), ...]."""
-            try:
-                rows = list(final_transform(batch))
-            except Exception as exc:
-                if not _should_skip(exc):
-                    raise
-                return _transform_isolated(abs_start, batch, exc)
-            _check_row_count(rows, batch.num_rows)
-            return [(abs_start + j, row) for j, row in enumerate(rows)]
-
-        def _tx_call_guarded(abs_start, batch):
+        def _tx_call_guarded(batch):
            try:
                t0 = time.perf_counter()
-                result = _transform_batch(abs_start, batch)
+                result = final_transform(batch)
                self._transform_time += time.perf_counter() - t0
                return result
            finally:
@@ -488,8 +355,8 @@ class StreamingDataset(IterableDataset):
        def _try_submit_tx(i: int) -> None:
            """Submit transforms for raw_batches[i] up to available capacity."""
            while raw_batches[i] and tx_semaphore.acquire(blocking=False):
-                abs_start, batch = raw_batches[i].popleft()
-                tx_pending[i].append(tx_pool.submit(_tx_call_guarded, abs_start, batch))
+                batch = raw_batches[i].popleft()
+                tx_pending[i].append(tx_pool.submit(_tx_call_guarded, batch))

        def _drain_tx(i: int) -> None:
            """Move completed transform futures into cooked non-blockingly."""
@@ -517,14 +384,11 @@ class StreamingDataset(IterableDataset):
                    # Acquire a transform slot (may block briefly if all
                    # transform_workers are busy with other splits).
                    tx_semaphore.acquire()
-                    abs_start, batch = raw_batches[i].popleft()
-                    tx_pending[i].append(
-                        tx_pool.submit(_tx_call_guarded, abs_start, batch)
-                    )
+                    batch = raw_batches[i].popleft()
+                    tx_pending[i].append(tx_pool.submit(_tx_call_guarded, batch))
                elif io_pending[i]:
                    # Block on the oldest in-flight I/O fetch.
-                    abs_start, fut = io_pending[i].popleft()
-                    raw_batches[i].append((abs_start, fut.result()))
+                    raw_batches[i].append(io_pending[i].popleft().result())
                    _advance(i)
                else:
                    break  # split exhausted
@@ -543,28 +407,15 @@ class StreamingDataset(IterableDataset):
                        _fill_io(i)

                    while True:
-                        # A cycle only runs if every split can still produce a
-                        # row.  Without skips all splits exhaust simultaneously
-                        # (equal split sizes + round-robin); when
-                        # on_transform_error drops rows a split can run dry
-                        # early, ending the epoch at the last complete cycle.
-                        # This check only sees splits owned by this rank/worker
-                        # (my_splits) — there is no cross-rank coordination, so
-                        # a different rank with fewer skipped rows keeps going;
-                        # see the on_transform_error docstring.
-                        exhausted = False
-                        for i in range(n):
-                            _ensure_cooked(i)
-                            if not cooked[i]:
-                                exhausted = True
-                                break
-                        if exhausted:
+                        # Stop when any split is exhausted (all exhaust
+                        # simultaneously: equal split sizes + round-robin).
+                        if any(local_consumed[i] >= split_sizes[i] for i in range(n)):
                            break

                        for i in range(n):
-                            pos, row = cooked[i].popleft()
+                            _ensure_cooked(i)
+                            row = cooked[i].popleft()
                            local_consumed[i] += 1
-                            pos_consumed[i] = pos + 1
                            _advance(i)

                            # After the last split in each cycle: update the
@@ -573,39 +424,21 @@ class StreamingDataset(IterableDataset):
                            # even when __iter__ runs in a worker process.
                            if i == n - 1:
                                self._resume_offset = initial_offset + local_consumed[i]
-                                for j, split_idx in enumerate(my_splits):
-                                    self._resume_positions[split_idx] = pos_consumed[j]
                                ws = self._worker_stats
                                ws[0] = sum(
                                    split_sizes[j] - fetch_head[j] for j in range(n)
                                )
                                ws[1] = sum(
-                                    batch.num_rows
-                                    for q in raw_batches
-                                    for _, batch in q
+                                    batch.num_rows for q in raw_batches for batch in q
                                )
                                ws[2] = sum(len(q) for q in cooked)
                                ws[3] = sum(local_consumed)
                                ws[4] = self._bytes_loaded
                                ws[5] = int(self._fetch_time * 1_000_000)
                                ws[6] = int(self._transform_time * 1_000_000)
-                                ws[7] = self._rows_skipped

                            yield row
                finally:
-                    # Final stats flush: the per-cycle write above never runs
-                    # when iteration ends mid-cycle (e.g. a split whose rows
-                    # were all skipped before completing a single cycle), so
-                    # counters like rows_skipped would otherwise be stale.
-                    ws = self._worker_stats
-                    ws[0] = sum(split_sizes[j] - fetch_head[j] for j in range(n))
-                    ws[1] = 0  # queue-depth properties document 0 when idle
-                    ws[2] = 0
-                    ws[3] = sum(local_consumed)
-                    ws[4] = self._bytes_loaded
-                    ws[5] = int(self._fetch_time * 1_000_000)
-                    ws[6] = int(self._transform_time * 1_000_000)
-                    ws[7] = self._rows_skipped
                    self._raw_batches_ref = None
                    self._cooked_ref = None
                    self._fetch_head_ref = None
@@ -659,7 +492,7 @@ class StreamingDataset(IterableDataset):
        batches.  Returns 0 when not iterating.
        """
        if self._raw_batches_ref is not None:
-            return sum(batch.num_rows for q in self._raw_batches_ref for _, batch in q)
+            return sum(batch.num_rows for q in self._raw_batches_ref for batch in q)
        return int(self._worker_stats[1])

    @property
@@ -689,19 +522,6 @@ class StreamingDataset(IterableDataset):
            )
        return int(self._worker_stats[0])

-    @property
-    def rows_skipped(self) -> int:
-        """Number of rows dropped because their transform raised an exception.
-
-        Only ever non-zero when ``on_transform_error`` is set to ``"skip"``,
-        ``"warn"``, or a callable that returned ``True``.  Accumulates across
-        multiple iterations of the same dataset instance and is never reset
-        automatically.
-        """
-        if self._raw_batches_ref is not None:
-            return self._rows_skipped
-        return int(self._worker_stats[7])
-
    @property
    def consumed_rows(self) -> int:
        """Number of rows already yielded to the caller across all splits.
@@ -767,27 +587,12 @@ class StreamingDataset(IterableDataset):
        every split has been consumed the same number of times (by the
        round-robin design), so the per-split count is a single uniform value
        that is identical across all ranks and DataLoader workers.
-
-        ``positions_consumed_per_split`` records how far into each split's
-        permutation iteration has advanced.  It only differs from
-        ``samples_consumed_per_split`` when ``on_transform_error`` skipped
-        rows, in which case entries are exact for the splits this instance
-        iterated and a lower bound (the sample count) for splits owned by
-        other ranks or workers.  Combine the state dicts from all ranks with
-        [merge_state_dicts][lancedb.streaming.StreamingDataset.merge_state_dicts]
-        to recover the exact value for every split before resuming on a
-        different topology.
        """
-        positions = [
-            self._resume_positions.get(split, self._resume_offset)
-            for split in range(self._num_splits)
-        ]
        return {
            "shuffle_seed": self._shuffle_seed,
            "num_splits": self._num_splits,
            "epoch": self._epoch,
            "samples_consumed_per_split": [self._resume_offset] * self._num_splits,
-            "positions_consumed_per_split": positions,
        }

    def load_state_dict(self, state: dict) -> None:
@@ -813,96 +618,3 @@ class StreamingDataset(IterableDataset):
            self._resume_offset = consumed[0] if consumed else 0
        else:
            self._resume_offset = int(consumed)
-        # Older checkpoints predate positions_consumed_per_split; without
-        # skipped rows positions equal sample counts, so falling back to
-        # _resume_offset (the .get default in __iter__) is exact.
-        positions = state.get("positions_consumed_per_split")
-        if positions is None:
-            self._resume_positions = {}
-        else:
-            self._resume_positions = {
-                split: int(pos) for split, pos in enumerate(positions)
-            }
-
-    @staticmethod
-    def merge_state_dicts(states: list[dict]) -> dict:
-        """Merge state dicts saved by different ranks into one exact state.
-
-        Only needed when ``on_transform_error`` skips rows in multi-rank
-        training: each rank then knows the exact permutation position only for
-        its own splits, and records a lower bound for the rest.  Because
-        exactly one rank owns each split, the elementwise maximum across all
-        ranks' ``positions_consumed_per_split`` recovers the exact position of
-        every split.  Without skipped rows every rank's state is already
-        identical and merging is a no-op.
-
-        Raises ``ValueError`` if the states are empty or were not produced by
-        the same run (mismatched seed, split count, epoch, or sample counts).
-
-        The merge is always all-to-all and topology-agnostic: collect the
-        ``state_dict()`` from every rank of the *previous* run into one list,
-        merge that whole list, and hand the identical merged result to every
-        rank of the *next* run — regardless of whether the rank count grew,
-        shrank, or stayed the same. There is no pairwise or subset merging
-        step, because each split's exact position is only known to whichever
-        rank owned that split, and the elementwise maximum needs every rank's
-        contribution to be correct.
-
-        For example, checkpointing 8 ranks and resuming on 4 (the same
-        pattern applies when growing, e.g. 4 ranks resuming on 8)::
-
-            states = [ds.state_dict() for ds in previous_run_datasets]  # 8
-            merged = StreamingDataset.merge_state_dicts(states)
-            for ds in resumed_datasets:  # now only 4 ranks
-                ds.load_state_dict(merged)  # same dict on every rank
-
-        The rank count on either side never affects the merge itself, since
-        ``merge_state_dicts`` only cares about the list of states it is
-        given.  Each split's position is recovered by elementwise maximum;
-        here rank 0 owned split 0 (and skipped two rows there) while rank 1
-        owned split 1 (and skipped one row):
-
-        >>> rank0 = {
-        ...     "shuffle_seed": 0, "num_splits": 2, "epoch": 0,
-        ...     "samples_consumed_per_split": [3, 3],
-        ...     "positions_consumed_per_split": [5, 3],
-        ... }
-        >>> rank1 = {
-        ...     "shuffle_seed": 0, "num_splits": 2, "epoch": 0,
-        ...     "samples_consumed_per_split": [3, 3],
-        ...     "positions_consumed_per_split": [3, 4],
-        ... }
-        >>> merged = StreamingDataset.merge_state_dicts([rank0, rank1])
-        >>> merged["positions_consumed_per_split"]
-        [5, 4]
-        """
-        if not states:
-            raise ValueError("merge_state_dicts requires at least one state dict")
-        first = states[0]
-        for state in states[1:]:
-            for key in ("shuffle_seed", "num_splits", "epoch"):
-                if state[key] != first[key]:
-                    raise ValueError(
-                        f"{key} mismatch across state dicts: "
-                        f"{state[key]} != {first[key]}"
-                    )
-            if (
-                state["samples_consumed_per_split"]
-                != first["samples_consumed_per_split"]
-            ):
-                raise ValueError(
-                    "samples_consumed_per_split mismatch across state dicts; "
-                    "state_dict() must be called at the same global step "
-                    "boundary on every rank"
-                )
-        merged = dict(first)
-        all_positions = [
-            state.get(
-                "positions_consumed_per_split", state["samples_consumed_per_split"]
-            )
-            for state in states
-        ]
-        merged["positions_consumed_per_split"] = [
-            max(per_split) for per_split in zip(*all_positions)
-        ]
-        return merged
@@ -176,7 +176,6 @@ if TYPE_CHECKING:
        CompactionStats,
        Tag,
        AddColumnsResult,
-        RefreshColumnResult,
        AddResult,
        AlterColumnsResult,
        UpdateFieldMetadataResult,
@@ -1917,14 +1916,7 @@ class Table(ABC):

    @abstractmethod
    def add_columns(
-        self,
-        transforms: Dict[str, str]
-        | pa.Field
-        | List[pa.Field]
-        | pa.Schema
-        | None = None,
-        *,
-        computed: Dict[str, str] | None = None,
+        self, transforms: Dict[str, str] | pa.Field | List[pa.Field] | pa.Schema
    ):
        """
        Add new columns with defined values.
@@ -1938,95 +1930,11 @@ class Table(ABC):
            Alternatively, a pyarrow Field or Schema can be provided to add
            new columns with the specified data types. The new columns will
            be initialized with null values.
-        computed: Dict[str, str], optional
-            A map of column name to a SQL expression defining the column. The
-            column's type and inputs are derived from the expression, so no
-            data type is supplied.
-
-            Unlike ``transforms``, the expression is stored rather than
-            evaluated now: the column is committed with no values, and rows get
-            them from [`refresh_column`][lancedb.table.Table.refresh_column].
-            Declaring one therefore costs the same on a large table as on an
-            empty one.
-
-            A refresh does not revisit rows it has already filled, so mutating
-            an input leaves the value computed at fill time; recomputing means
-            dropping the column and declaring it again. While a declaration
-            reads a column, that column cannot be renamed, retyped or dropped.
-
-            On LanceDB Cloud and Enterprise the expression is planned by the
-            server, and the refresh runs as a server job -- see
-            [`refresh_column_async`][lancedb.table.Table.refresh_column_async].
-            Cannot be combined with ``transforms``.

        Returns
        -------
        AddColumnsResult
            version: the new version number of the table after adding columns.
-
-        Examples
-        --------
-        >>> import lancedb
-        >>> db = lancedb.connect("./.lancedb")
-        >>> table = db.create_table("computed_demo", [{"x": 1}, {"x": 2}])
-        >>> table.add_columns(computed={"doubled": "x * 2"})
-        AddColumnsResult(version=2)
-        >>> table.refresh_column("doubled")
-        RefreshColumnResult(rows_filled=2, version=3)
-        >>> table.to_arrow().sort_by("x").to_pandas()
-           x  doubled
-        0  1        2
-        1  2        4
-        """
-
-    @abstractmethod
-    def refresh_column(self, column: str) -> "RefreshColumnResult":
-        """
-        Fill the rows of a computed column that hold no value yet.
-
-        Declared with ``add_columns(computed=...)``, a column starts empty and
-        gets its values here. Rows appended since the last refresh are filled
-        by the next one; rows already filled are left as they are, so the call
-        is idempotent and does not observe a mutated input.
-
-        Local tables only: a remote refresh runs as a server job, through
-        [`refresh_column_async`][lancedb.table.Table.refresh_column_async].
-
-        Parameters
-        ----------
-        column: str
-            The name of the computed column to fill.
-
-        Returns
-        -------
-        RefreshColumnResult
-            rows_filled: the number of rows given a value.
-            version: the new version number of the table.
-        """
-
-    @abstractmethod
-    def refresh_column_async(self, column: str) -> Job:
-        """
-        Like :meth:`refresh_column`, but returns a handle to the refresh job
-        instead of blocking until it completes.
-
-        The job may already be complete when returned; callers must not assume
-        the column is filled until :meth:`Job.wait` returns. Invalid input --
-        an unknown column, or one that is not computed -- raises here rather
-        than failing the job. On local tables the job runs in-process; on
-        LanceDB Cloud and Enterprise it is the server's backfill job.
-
-        Examples
-        --------
-        >>> import lancedb
-        >>> db = lancedb.connect("./.lancedb")
-        >>> table = db.create_table("computed_job_demo", [{"x": 1}, {"x": 2}])
-        >>> table.add_columns(computed={"doubled": "x * 2"})
-        AddColumnsResult(version=2)
-        >>> job = table.refresh_column_async("doubled")
-        >>> job.wait()
-        >>> job.status()
-        'finished'
        """

    @abstractmethod
@@ -4031,28 +3939,9 @@ class LanceTable(Table):
        return LOOP.run(self._table.index_stats(index_name))

    def add_columns(
-        self,
-        transforms: Dict[str, str]
-        | pa.field
-        | List[pa.field]
-        | pa.Schema
-        | None = None,
-        *,
-        computed: Dict[str, str] | None = None,
+        self, transforms: Dict[str, str] | pa.field | List[pa.field] | pa.Schema
    ) -> AddColumnsResult:
-        return LOOP.run(self._table.add_columns(transforms, computed=computed))
-
-    def refresh_column(self, column: str) -> "RefreshColumnResult":
-        """Fill a computed column's unfilled rows. See
-        [`AsyncTable.refresh_column`][lancedb.AsyncTable.refresh_column]."""
-        return LOOP.run(self._table.refresh_column(column))
-
-    def refresh_column_async(self, column: str) -> Job:
-        """Fill a computed column's unfilled rows, returning a handle to the
-        refresh job. See
-        [`Table.refresh_column_async`][lancedb.table.Table.refresh_column_async].
-        """
-        return Job(LOOP.run(self._table.refresh_column_async(column)))
+        return LOOP.run(self._table.add_columns(transforms))

    def alter_columns(
        self, *alterations: Iterable[Dict[str, str]]
@@ -4787,13 +4676,6 @@ class AsyncTable:
        via [`set_unenforced_primary_key`]; bucket sharding additionally
        requires it to be the single column being bucketed.

-        By default the MemWAL maintains every index on the table, resolved
-        here — a snapshot, so an index created afterwards needs the spec unset
-        and set again. This fails if one cannot be maintained; name the set
-        with ``with_maintained_indexes`` to install anyway. That pins an exact
-        set (a still-building index is rejected, not omitted); ``[]`` maintains
-        none.
-
        Parameters
        ----------
        spec : LsmWriteSpec
@@ -4820,9 +4702,9 @@ class AsyncTable:

        Returns ``None`` when the MemWAL LSM write path is not enabled (no
        spec has been set, or it was removed with `unset_lsm_write_spec`).
-        The returned spec mirrors what was passed to `set_lsm_write_spec`,
-        except that ``maintained_indexes`` always reports the concrete list
-        resolved when the spec was set — ``None`` never round-trips.
+        The returned spec — including its ``maintained_indexes`` and
+        ``writer_config_defaults`` — mirrors what was passed to
+        `set_lsm_write_spec`.
        """
        return await self._inner.get_lsm_write_spec()

@@ -4846,7 +4728,7 @@ class AsyncTable:
        ``asyncio.wait_for`` for a wall-clock bound; abandoning it partway
        costs nothing.
        """
-        await self._inner.checkpoint_lsm()
+        return await self._inner.checkpoint_lsm()

    async def flush_lsm(self) -> None:
        """Seal every bucket's active memtable into L0.
@@ -4855,7 +4737,7 @@ class AsyncTable:
        `compact_lsm`. On a node that has not claimed this table, this claims
        it and replays its WAL log first.
        """
-        await self._inner.flush_lsm()
+        return await self._inner.flush_lsm()

    async def compact_lsm(self) -> None:
        """Trigger a background L0 to base compaction pass per bucket.
@@ -4864,7 +4746,7 @@ class AsyncTable:
        ``get_lsm_stats`` for progress, or use ``checkpoint_lsm`` to loop
        until the current L0 has reached base.
        """
-        await self._inner.compact_lsm()
+        return await self._inner.compact_lsm()

    async def get_lsm_stats(
        self, *, include_generation_rows: bool = False
@@ -5967,14 +5849,7 @@ class AsyncTable:
        return await self._inner.update(updates_sql, where)

    async def add_columns(
-        self,
-        transforms: dict[str, str]
-        | pa.field
-        | List[pa.field]
-        | pa.Schema
-        | None = None,
-        *,
-        computed: dict[str, str] | None = None,
+        self, transforms: dict[str, str] | pa.field | List[pa.field] | pa.Schema
    ) -> AddColumnsResult:
        """
        Add new columns with defined values.
@@ -5987,22 +5862,6 @@ class AsyncTable:
            each row in the table, and can reference existing columns.
            Alternatively, you can pass a pyarrow field or schema to add
            new columns with NULLs.
-        computed: Dict[str, str], optional
-            A map of column name to a SQL expression defining the column. The
-            column's type and inputs are derived from the expression.
-
-            Unlike ``transforms``, the expression is stored rather than
-            evaluated now: the column is committed with no values, and rows get
-            them from
-            [`refresh_column`][lancedb.table.AsyncTable.refresh_column].
-
-            A refresh does not revisit rows it has already filled, so mutating
-            an input leaves the value computed at fill time. While a
-            declaration reads a column, that column cannot be renamed, retyped
-            or dropped.
-
-            On LanceDB Cloud and Enterprise the expression is planned by
-            the server. Cannot be combined with ``transforms``.

        Returns
        -------
@@ -6016,71 +5875,11 @@ class AsyncTable:
            {isinstance(f, pa.Field) for f in transforms}
        ):
            transforms = pa.schema(transforms)
-        if computed:
-            if transforms:
-                raise ValueError(
-                    "add_columns cannot take both transforms and computed columns"
-                )
-            return await self._inner.add_computed_columns(list(computed.items()))
-        if transforms is None:
-            raise ValueError("add_columns requires transforms or computed columns")
        if isinstance(transforms, pa.Schema):
            return await self._inner.add_columns_with_schema(transforms)
        else:
            return await self._inner.add_columns(list(transforms.items()))

-    async def refresh_column(self, column: str) -> RefreshColumnResult:
-        """
-        Fill the rows of a computed column that hold no value yet.
-
-        Declared with ``add_columns(computed=...)``, a column starts empty and
-        gets its values here. Rows appended since the last refresh are filled
-        by the next one; rows already filled are left as they are, so the call
-        is idempotent and does not observe a mutated input.
-
-        Local tables only: a remote refresh runs as a server job, through
-        [`refresh_column_async`][lancedb.table.Table.refresh_column_async].
-
-        Parameters
-        ----------
-        column: str
-            The name of the computed column to fill.
-
-        Returns
-        -------
-        RefreshColumnResult
-            The number of rows filled and the new version of the table.
-        """
-        return await self._inner.refresh_column(column)
-
-    async def refresh_column_async(self, column: str) -> AsyncJob:
-        """
-        Like :meth:`refresh_column`, but returns a handle to the refresh job
-        instead of blocking until it completes.
-
-        The job may already be complete when returned; callers must not assume
-        the column is filled until :meth:`AsyncJob.wait` resolves. Invalid
-        input -- an unknown column, or one that is not computed -- raises here
-        rather than failing the job. On local tables the job runs
-        in-process; on LanceDB Cloud and Enterprise it is the server's
-        backfill job.
-
-        Examples
-        --------
-        >>> import asyncio
-        >>> import lancedb
-        >>> async def refresh_in_background():
-        ...     db = await lancedb.connect_async("./.lancedb")
-        ...     table = await db.create_table("computed_job_async_demo", [{"x": 1}])
-        ...     await table.add_columns(computed={"doubled": "x * 2"})
-        ...     job = await table.refresh_column_async("doubled")
-        ...     await job.wait()
-        ...     return await job.status()
-        >>> asyncio.run(refresh_in_background())
-        'finished'
-        """
-        return AsyncJob(await self._inner.refresh_column_async(column))
-
    async def alter_columns(
        self, *alterations: Iterable[dict[str, Any]]
    ) -> AlterColumnsResult:
@@ -755,7 +755,8 @@ def test_delete_table(tmp_db: lancedb.DBConnection):
    assert tmp_db.table_names() == []


-def test_drop_table_async(tmp_db: lancedb.DBConnection):
+@pytest.mark.asyncio
+async def test_delete_table_async(tmp_db: lancedb.DBConnection):
    data = pd.DataFrame(
        {
            "vector": [[3.1, 4.1], [5.9, 26.5]],
@@ -771,10 +772,7 @@ def test_drop_table_async(tmp_db: lancedb.DBConnection):

    assert tmp_db.table_names() == ["test"]

-    job = tmp_db.drop_table_async("test")
-    assert job.id is None
-    assert job.status() == "finished"
-    job.wait()
+    tmp_db.drop_table("test")
    assert tmp_db.table_names() == []

    tmp_db.create_table("test", data=data)
@@ -783,17 +781,6 @@ def test_drop_table_async(tmp_db: lancedb.DBConnection):
    tmp_db.drop_table("does_not_exist", ignore_missing=True)


-@pytest.mark.asyncio
-async def test_drop_table_async_connection(tmp_db_async: lancedb.AsyncConnection):
-    await tmp_db_async.create_table("test", data=pa.table({"id": [1, 2]}))
-
-    job = await tmp_db_async.drop_table_async("test")
-    assert job.id is None
-    assert await job.status() == "finished"
-    await job.wait()
-    assert await tmp_db_async.table_names() == []
-
-
 def test_drop_database(tmp_db: lancedb.DBConnection):
    data = pd.DataFrame(
        {
@@ -1456,408 +1456,6 @@ def test_shuffle_clump_size_yields_all_rows(lance_table):
    )


-# ---------------------------------------------------------------------------
-# on_transform_error tests
-# ---------------------------------------------------------------------------
-
-
-class BadRowError(ValueError):
-    """Raised by the failing transforms below when a batch contains a bad id."""
-
-
-def _failing_transform(bad_ids: set):
-    """A transform that raises BadRowError whenever the batch has a bad id.
-
-    Raises on the full batch and on any single-row slice containing a bad id,
-    so per-row isolation drops exactly the bad rows.
-    """
-
-    def transform(batch: pa.RecordBatch) -> list:
-        ids = batch.column("id").to_pylist()
-        bad = sorted(set(ids) & bad_ids)
-        if bad:
-            raise BadRowError(f"bad ids in batch: {bad}")
-        return [{"id": i} for i in ids]
-
-    return transform
-
-
-def _sequential_split_members(table) -> list[list[int]]:
-    """Return each split's ids in yield order for shuffle=False.
-
-    With a single rank and no workers the round-robin yields one row per split
-    per cycle, so item k of a clean run belongs to split k % NUM_SPLITS.
-    """
-    ds = StreamingDataset(table, num_splits=NUM_SPLITS, shuffle=False)
-    members: list[list[int]] = [[] for _ in range(NUM_SPLITS)]
-    for k, row in enumerate(ds):
-        members[k % NUM_SPLITS].append(row["id"])
-    return members
-
-
-def test_on_transform_error_default_raises(lance_table):
-    """By default a transform exception propagates and aborts iteration."""
-    ds = StreamingDataset(
-        lance_table,
-        num_splits=NUM_SPLITS,
-        shuffle_seed=SHUFFLE_SEED,
-        transform=_failing_transform({7}),
-    )
-    with pytest.raises(BadRowError):
-        list(ds)
-
-
-def test_on_transform_error_invalid_value(lance_table):
-    with pytest.raises(ValueError, match="on_transform_error"):
-        StreamingDataset(lance_table, num_splits=NUM_SPLITS, on_transform_error="bogus")
-
-
-def test_on_transform_error_skip_drops_bad_rows(lance_table):
-    """With one bad row per split, 'skip' yields every good row exactly once
-    and counts the dropped rows in rows_skipped."""
-    members = _sequential_split_members(lance_table)
-    bad_ids = {members[i][4] for i in range(NUM_SPLITS)}
-
-    ds = StreamingDataset(
-        lance_table,
-        num_splits=NUM_SPLITS,
-        shuffle=False,
-        transform=_failing_transform(bad_ids),
-        on_transform_error="skip",
-    )
-    assert ds.rows_skipped == 0
-
-    ids = [row["id"] for row in ds]
-
-    assert sorted(ids) == sorted(set(range(NUM_ROWS)) - bad_ids)
-    assert ds.rows_skipped == NUM_SPLITS
-
-
-def test_on_transform_error_skip_uneven_ends_at_last_complete_cycle(lance_table):
-    """When one split loses more rows than the others, the epoch ends at the
-    last cycle where every split still has a row — no crash, no bad rows, and
-    every step remains one sample per split."""
-    members = _sequential_split_members(lance_table)
-    bad_ids = set(members[0][:3])  # all 3 bad rows in split 0
-
-    ds = StreamingDataset(
-        lance_table,
-        num_splits=NUM_SPLITS,
-        shuffle=False,
-        transform=_failing_transform(bad_ids),
-        on_transform_error="skip",
-    )
-    items = [row["id"] for row in ds]
-
-    rows_per_split = NUM_ROWS // NUM_SPLITS
-    expected_cycles = rows_per_split - len(bad_ids)
-    assert len(items) == expected_cycles * NUM_SPLITS
-    assert len(set(items)) == len(items), "duplicate samples yielded"
-    assert not set(items) & bad_ids, "a bad row was yielded"
-    # Split 0 contributed exactly its surviving rows, in order, one per cycle.
-    survivors = [i for i in members[0] if i not in bad_ids]
-    assert items[0::NUM_SPLITS] == survivors[:expected_cycles]
-
-
-def test_on_transform_error_warn_logs(lance_table, caplog):
-    """'warn' skips like 'skip' but logs a warning for the failing batch."""
-    members = _sequential_split_members(lance_table)
-    bad_ids = {members[i][3] for i in range(NUM_SPLITS)}
-
-    ds = StreamingDataset(
-        lance_table,
-        num_splits=NUM_SPLITS,
-        shuffle=False,
-        transform=_failing_transform(bad_ids),
-        on_transform_error="warn",
-    )
-    with caplog.at_level(logging.WARNING, logger="lancedb.streaming"):
-        items = list(ds)
-
-    assert len(items) == NUM_ROWS - NUM_SPLITS
-    assert ds.rows_skipped == NUM_SPLITS
-    assert "Skipped" in caplog.text
-    assert "BadRowError" in caplog.text
-
-
-def test_on_transform_error_callable_selective(lance_table):
-    """A callable handler can skip expected errors and re-raise the rest."""
-    members = _sequential_split_members(lance_table)
-    bad_ids = {members[i][0] for i in range(NUM_SPLITS)}
-
-    handled: list[Exception] = []
-
-    def handler(exc: Exception) -> bool:
-        handled.append(exc)
-        return isinstance(exc, BadRowError)
-
-    ds = StreamingDataset(
-        lance_table,
-        num_splits=NUM_SPLITS,
-        shuffle=False,
-        transform=_failing_transform(bad_ids),
-        on_transform_error=handler,
-    )
-    items = list(ds)
-    assert len(items) == NUM_ROWS - NUM_SPLITS
-    assert handled and all(isinstance(exc, BadRowError) for exc in handled)
-
-    def broken_transform(batch: pa.RecordBatch) -> list:
-        raise TypeError("boom")
-
-    ds2 = StreamingDataset(
-        lance_table,
-        num_splits=NUM_SPLITS,
-        shuffle=False,
-        transform=broken_transform,
-        on_transform_error=handler,
-    )
-    with pytest.raises(TypeError, match="boom"):
-        list(ds2)
-
-
-def test_transform_wrong_row_count_raises(lance_table):
-    """A transform that returns the wrong number of rows is an error even with
-    on_transform_error='skip' — silent shrinkage would corrupt accounting."""
-
-    def drops_rows(batch: pa.RecordBatch) -> list:
-        return batch.column("id").to_pylist()[:-1]
-
-    ds = StreamingDataset(
-        lance_table,
-        num_splits=NUM_SPLITS,
-        shuffle_seed=SHUFFLE_SEED,
-        transform=drops_rows,
-        on_transform_error="skip",
-    )
-    with pytest.raises(ValueError, match="one output row per input row"):
-        list(ds)
-
-
-def test_skip_deterministic_across_runs(lance_table):
-    """With a fixed seed, skipping produces the identical sample sequence on
-    every run — skips are data-dependent, not run-dependent."""
-    bad_ids = {5, 17, 46}
-
-    def run() -> tuple[list[int], int]:
-        ds = StreamingDataset(
-            lance_table,
-            num_splits=NUM_SPLITS,
-            shuffle_seed=SHUFFLE_SEED,
-            transform=_failing_transform(bad_ids),
-            on_transform_error="skip",
-        )
-        return [row["id"] for row in ds], ds.rows_skipped
-
-    ids_a, skipped_a = run()
-    ids_b, skipped_b = run()
-    assert ids_a == ids_b
-    assert skipped_a == skipped_b
-    assert not set(ids_a) & bad_ids
-
-
-def test_skip_elastic_det_across_world_sizes(lance_table):
-    """With equal bad-row counts per split, skipping preserves the full
-    elastic-determinism guarantee: identical global batches at every step for
-    every compatible world_size."""
-    members = _sequential_split_members(lance_table)
-    bad_ids = {members[i][6] for i in range(NUM_SPLITS)}
-
-    def collect(world_size: int) -> list[frozenset[int]]:
-        micro = GLOBAL_BATCH_SIZE // world_size
-        iters = [
-            iter(
-                StreamingDataset(
-                    lance_table,
-                    num_splits=NUM_SPLITS,
-                    shuffle=False,
-                    rank=rank,
-                    world_size=world_size,
-                    transform=_failing_transform(bad_ids),
-                    on_transform_error="skip",
-                )
-            )
-            for rank in range(world_size)
-        ]
-        _STOP = object()
-        batches: list[frozenset[int]] = []
-        while True:
-            step_samples: set[int] = set()
-            exhausted = 0
-            for it in iters:
-                for _ in range(micro):
-                    val = next(it, _STOP)
-                    if val is _STOP:
-                        exhausted += 1
-                        break
-                    step_samples.add(val["id"])
-            if exhausted == len(iters):
-                break
-            assert exhausted == 0, (
-                "Rank iterators exhausted at different steps despite equal "
-                "bad-row counts per split"
-            )
-            batches.append(frozenset(step_samples))
-        return batches
-
-    reference = collect(1)
-    assert len(reference) == NUM_ROWS // NUM_SPLITS - 1
-    for ws in (2, 3, 4):
-        assert collect(ws) == reference, f"world_size={ws} diverged"
-
-
-def test_resumability_with_skips_same_topology(lance_table):
-    """Checkpointing mid-epoch with skipped rows resumes exactly: no sample
-    repeated, no sample lost, skipped rows stay skipped."""
-    members = _sequential_split_members(lance_table)
-    # Uneven skips: positions diverge across splits (2 bad in split 0, 1 in
-    # split 5), which only a position-based checkpoint can resume exactly.
-    bad_ids = {members[0][2], members[0][3], members[5][7]}
-    kwargs = dict(
-        num_splits=NUM_SPLITS,
-        shuffle=False,
-        transform=_failing_transform(bad_ids),
-        on_transform_error="skip",
-    )
-
-    reference = [row["id"] for row in StreamingDataset(lance_table, **kwargs)]
-    rows_per_split = NUM_ROWS // NUM_SPLITS
-    assert len(reference) == (rows_per_split - 2) * NUM_SPLITS
-
-    steps = 3
-    ds = StreamingDataset(lance_table, **kwargs)
-    it = iter(ds)
-    consumed = [next(it)["id"] for _ in range(steps * NUM_SPLITS)]
-    checkpoint = ds.state_dict()
-    it.close()
-
-    # Split 0 skipped positions 2 and 3 within its first 3 yields; split 5's
-    # bad row is beyond the checkpoint.  Everything else is at 3 = the sample
-    # count.
-    positions = checkpoint["positions_consumed_per_split"]
-    assert positions[0] == 5
-    assert positions[1:] == [3] * (NUM_SPLITS - 1)
-    assert checkpoint["samples_consumed_per_split"] == [3] * NUM_SPLITS
-
-    ds2 = StreamingDataset(lance_table, **kwargs)
-    ds2.load_state_dict(checkpoint)
-    resumed = [row["id"] for row in ds2]
-
-    assert consumed == reference[: steps * NUM_SPLITS]
-    assert resumed == reference[steps * NUM_SPLITS :]
-
-
-def test_resumability_with_skips_elastic_merge(lance_table):
-    """Elastic resume with skips: each rank's checkpoint knows exact positions
-    only for its own splits; merge_state_dicts recovers the global state, and
-    a run on a different world_size continues exactly."""
-    members = _sequential_split_members(lance_table)
-    # Bad rows early in split 0 (rank 0) and split 6 (rank 1 of a ws=2 run) so
-    # both ranks' position vectors diverge before the checkpoint.
-    bad_ids = {members[0][0], members[0][2], members[6][1]}
-    kwargs = dict(
-        num_splits=NUM_SPLITS,
-        shuffle=False,
-        transform=_failing_transform(bad_ids),
-        on_transform_error="skip",
-    )
-
-    reference = [row["id"] for row in StreamingDataset(lance_table, **kwargs)]
-
-    steps = 3
-    world_size = 2
-    micro = GLOBAL_BATCH_SIZE // world_size
-    datasets = [
-        StreamingDataset(lance_table, rank=rank, world_size=world_size, **kwargs)
-        for rank in range(world_size)
-    ]
-    iters = [iter(ds) for ds in datasets]
-    seen: list[frozenset[int]] = []
-    for _ in range(steps):
-        step_samples = set()
-        for it in iters:
-            for _ in range(micro):
-                step_samples.add(next(it)["id"])
-        seen.append(frozenset(step_samples))
-    states = [ds.state_dict() for ds in datasets]
-    for it in iters:
-        it.close()
-
-    merged = StreamingDataset.merge_state_dicts(states)
-    expected_positions = [3] * NUM_SPLITS
-    expected_positions[0] = 5  # skipped positions 0 and 2
-    expected_positions[6] = 4  # skipped position 1
-    assert merged["positions_consumed_per_split"] == expected_positions
-
-    # The first 3 global batches match the world_size=1 reference.
-    ref_batches = [
-        frozenset(reference[s * NUM_SPLITS : (s + 1) * NUM_SPLITS])
-        for s in range(len(reference) // NUM_SPLITS)
-    ]
-    assert seen == ref_batches[:steps]
-
-    # Resume on world_size=1 from the merged state.
-    ds_resume = StreamingDataset(lance_table, **kwargs)
-    ds_resume.load_state_dict(merged)
-    resumed = [row["id"] for row in ds_resume]
-    assert resumed == reference[steps * NUM_SPLITS :]
-
-
-def test_rows_skipped_flushed_when_split_entirely_bad(lance_table):
-    """A split whose rows all fail never completes a cycle, so the epoch ends
-    immediately — but rows_skipped must still report the drops after the
-    iterator exits (the shared-memory counter is flushed on exhaustion)."""
-    members = _sequential_split_members(lance_table)
-    bad_ids = set(members[0])  # every row of split 0 is bad
-
-    ds = StreamingDataset(
-        lance_table,
-        num_splits=NUM_SPLITS,
-        shuffle=False,
-        transform=_failing_transform(bad_ids),
-        on_transform_error="skip",
-    )
-    assert list(ds) == []
-    assert ds.rows_skipped == len(bad_ids)
-
-
-def test_merge_state_dicts_validates_consistency(lance_table):
-    ds = StreamingDataset(lance_table, num_splits=NUM_SPLITS, shuffle_seed=SHUFFLE_SEED)
-    state = ds.state_dict()
-    other = dict(state, shuffle_seed=SHUFFLE_SEED + 1)
-    with pytest.raises(ValueError, match="shuffle_seed mismatch"):
-        StreamingDataset.merge_state_dicts([state, other])
-    with pytest.raises(ValueError, match="at least one"):
-        StreamingDataset.merge_state_dicts([])
-
-
-def test_load_state_dict_without_positions_key(lance_table):
-    """Checkpoints from before positions_consumed_per_split existed still
-    resume exactly (positions equal sample counts when nothing is skipped)."""
-    reference = [
-        row["id"]
-        for row in StreamingDataset(
-            lance_table, num_splits=NUM_SPLITS, shuffle_seed=SHUFFLE_SEED
-        )
-    ]
-
-    steps = 4
-    ds = StreamingDataset(lance_table, num_splits=NUM_SPLITS, shuffle_seed=SHUFFLE_SEED)
-    it = iter(ds)
-    for _ in range(steps * NUM_SPLITS):
-        next(it)
-    checkpoint = ds.state_dict()
-    it.close()
-    del checkpoint["positions_consumed_per_split"]
-
-    ds2 = StreamingDataset(
-        lance_table, num_splits=NUM_SPLITS, shuffle_seed=SHUFFLE_SEED
-    )
-    ds2.load_state_dict(checkpoint)
-    resumed = [row["id"] for row in ds2]
-    assert resumed == reference[steps * NUM_SPLITS :]
-
-
 def test_num_splits_defaults_to_world_size(lance_table):
    """Omitting num_splits gives world_size splits (one per rank)."""
    ds = StreamingDataset(
@@ -632,101 +632,3 @@ class TestExprBytesIntegration:
            .to_arrow()
        )
        assert result.num_rows == 2
-
-
-# ── datetime / timezone integration for lit() (issue #3262) ──────────────────
-
-
-class TestExprDatetimeTimezoneIntegration:
-    """Integration coverage for lit(datetime) against table timestamp columns.
-
-    PyArrow stores naive timestamps as UTC wall-clock microseconds. Python's
-    datetime.timestamp() treats naive values as *local* time, which used to
-    shift lit(naive) by the host UTC offset and break equality filters on
-    non-UTC machines. These cases lock the expected semantics.
-    """
-
-    def test_both_naive_match(self, tmp_path):
-        """Table naive + lit naive with the same wall clock must match."""
-        db = lancedb.connect(str(tmp_path / "naive"))
-        ts = datetime(2024, 7, 1, 10, 0, 0)
-        table = db.create_table(
-            "t", [{"id": 1, "ts": ts}, {"id": 2, "ts": datetime(2024, 7, 2, 10, 0, 0)}]
-        )
-        result = table.search().where(col("ts") == lit(ts)).to_list()
-        assert len(result) == 1
-        assert result[0]["id"] == 1
-
-    def test_both_same_timezone_match(self, tmp_path):
-        """Table UTC + lit UTC for the same instant must match."""
-        db = lancedb.connect(str(tmp_path / "utc"))
-        ts = datetime(2024, 7, 1, 10, 0, 0, tzinfo=timezone.utc)
-        table = db.create_table(
-            "t",
-            pa.table(
-                {
-                    "id": [1, 2],
-                    "ts": pa.array(
-                        [ts, datetime(2024, 7, 2, 10, 0, 0, tzinfo=timezone.utc)],
-                        type=pa.timestamp("us", tz="UTC"),
-                    ),
-                }
-            ),
-        )
-        result = table.search().where(col("ts") == lit(ts)).to_list()
-        assert len(result) == 1
-        assert result[0]["id"] == 1
-
-    def test_different_timezones_same_instant(self, tmp_path):
-        """UTC table row equals lit of the same instant in a different zone."""
-        db = lancedb.connect(str(tmp_path / "diff_tz"))
-        ts_utc = datetime(2024, 7, 1, 10, 0, 0, tzinfo=timezone.utc)
-        # Same instant as 06:00 in UTC-4
-        ts_est = datetime(2024, 7, 1, 6, 0, 0, tzinfo=timezone(timedelta(hours=-4)))
-        table = db.create_table(
-            "t",
-            pa.table(
-                {
-                    "id": [1],
-                    "ts": pa.array([ts_utc], type=pa.timestamp("us", tz="UTC")),
-                }
-            ),
-        )
-        result = table.search().where(col("ts") == lit(ts_est)).to_list()
-        assert len(result) == 1
-        assert result[0]["id"] == 1
-
-    def test_table_tz_literal_naive(self, tmp_path):
-        """UTC table + naive lit uses wall-clock equality (10:00 == 10:00 UTC)."""
-        db = lancedb.connect(str(tmp_path / "tz_naive"))
-        ts_utc = datetime(2024, 7, 1, 10, 0, 0, tzinfo=timezone.utc)
-        ts_naive = datetime(2024, 7, 1, 10, 0, 0)
-        table = db.create_table(
-            "t",
-            pa.table(
-                {
-                    "id": [1],
-                    "ts": pa.array([ts_utc], type=pa.timestamp("us", tz="UTC")),
-                }
-            ),
-        )
-        result = table.search().where(col("ts") == lit(ts_naive)).to_list()
-        assert len(result) == 1
-        assert result[0]["id"] == 1
-
-    def test_table_naive_literal_aware(self, tmp_path):
-        """Naive table + UTC lit with the same wall clock must match."""
-        db = lancedb.connect(str(tmp_path / "naive_aware"))
-        ts_naive = datetime(2024, 7, 1, 10, 0, 0)
-        ts_utc = datetime(2024, 7, 1, 10, 0, 0, tzinfo=timezone.utc)
-        table = db.create_table("t", [{"id": 1, "ts": ts_naive}])
-        result = table.search().where(col("ts") == lit(ts_utc)).to_list()
-        assert len(result) == 1
-        assert result[0]["id"] == 1
-
-    def test_naive_lit_sql_is_wall_clock_not_local_shifted(self):
-        """Regression: naive lit must not apply the host local UTC offset."""
-        ts = datetime(2024, 7, 1, 10, 0, 0)
-        sql = lit(ts).to_sql()
-        # Must encode 10:00 wall clock, not 10:00+local_offset.
-        assert "2024-07-01 10:00:00" in sql
@@ -203,31 +203,6 @@ async def test_async_hybrid_query_default_limit(table: AsyncTable):
    assert texts.count("a") == 1


-def test_hybrid_query_offset(sync_table: Table):
-    # The offset window of a hybrid query must be a suffix of the same query
-    # run without an offset -- it must not be silently ignored.
-    full = (
-        sync_table.search(query_type="hybrid")
-        .vector([0.0, 0.4])
-        .text("dog")
-        .limit(4)
-        .with_row_id(True)
-        .to_arrow()
-    )
-    assert len(full) == 4
-
-    offset_result = (
-        sync_table.search(query_type="hybrid")
-        .vector([0.0, 0.4])
-        .text("dog")
-        .offset(2)
-        .limit(2)
-        .with_row_id(True)
-        .to_arrow()
-    )
-    assert offset_result["_rowid"].to_pylist() == full["_rowid"].to_pylist()[2:]
-
-
 def test_hybrid_query_minimum_nprobes_zero_raises(sync_table: Table):
    # minimum_nprobes(0) must raise the same validation error a plain vector
    # query raises, not silently no-op because 0 is falsy.
@@ -83,9 +83,7 @@ def test_lsm_write_spec_repr():
    assert s.spec_type == "bucket"
    assert s.column == "id"
    assert s.num_buckets == 4
-    # A fresh spec defers its maintained set to install time.
-    assert s.maintained_indexes is None
-    assert s.with_maintained_indexes([]).maintained_indexes == []
+    assert s.maintained_indexes == []
    assert "bucket" in repr(s)
    assert "id" in repr(s)
    assert "4" in repr(s)
@@ -171,23 +169,18 @@ def test_get_lsm_write_spec(tmp_path):
    table.unset_lsm_write_spec()
    assert table.get_lsm_write_spec() is None

-    # Identity round-trips (column recovered from the schema). Leaving the
-    # maintained set to be inferred picks up the index on the table, so the
-    # spec reads back naming it rather than as "infer".
+    # Identity round-trips (column recovered from the schema).
    table.set_lsm_write_spec(LsmWriteSpec.identity("id"))
    spec = table.get_lsm_write_spec()
    assert spec.spec_type == "identity"
    assert spec.column == "id"
-    assert spec.maintained_indexes == [idx_name]
    table.unset_lsm_write_spec()

-    # Unsharded round-trips (no routing column). Opting out is distinct from
-    # the inferred default.
-    table.set_lsm_write_spec(LsmWriteSpec.unsharded().with_maintained_indexes([]))
+    # Unsharded round-trips (no routing column).
+    table.set_lsm_write_spec(LsmWriteSpec.unsharded())
    spec = table.get_lsm_write_spec()
    assert spec.spec_type == "unsharded"
    assert spec.column is None
-    assert spec.maintained_indexes == []


@pytest.mark.asyncio
@@ -544,7 +544,7 @@ def test_lsm_read_fts_unmaintained_index_errors(tmp_path):
    table.create_index("text", config=FTS())
    # No maintained indexes: the active memtable FTS arm cannot serve un-compacted
    # docs, so the search would silently omit them — reject instead.
-    table.set_lsm_write_spec(LsmWriteSpec.unsharded().with_maintained_indexes([]))
+    table.set_lsm_write_spec(LsmWriteSpec.unsharded())
    with pytest.raises(Exception, match="maintained"):
        table.search("fox", query_type="fts", fts_columns="text").to_arrow()

@@ -631,7 +631,7 @@ def test_lsm_read_vector_unmaintained_index_errors(tmp_path):
    )
    # Spec with NO maintained indexes: the base vector index's catch-up is untracked,
    # so the scanner rejects rather than risk dropping compacted-but-unindexed rows.
-    table.set_lsm_write_spec(LsmWriteSpec.unsharded().with_maintained_indexes([]))
+    table.set_lsm_write_spec(LsmWriteSpec.unsharded())
    with pytest.raises(Exception, match="maintained"):
        table.search([1.0] * VECTOR_DIM).to_arrow()

@@ -1133,131 +1133,6 @@ def test_stats():
        assert res == stats


-@contextlib.contextmanager
-def lsm_test_table(lsm_handler):
-    """A remote table whose LSM routes are served by ``lsm_handler``.
-
-    ``lsm_handler(request, route)`` is called for ``/v1/table/test/<route>/``
-    where route is one of flush_lsm, compact_lsm, get_lsm_stats, and is
-    responsible for writing the response.
-    """
-    routes = ("flush_lsm", "compact_lsm", "get_lsm_stats")
-
-    def handler(request):
-        match = re.fullmatch(r"/v1/table/test/(\w+)/", request.path)
-        route = match.group(1) if match else None
-        if route in routes:
-            lsm_handler(request, route)
-        elif route == "describe":
-            request.send_response(200)
-            request.send_header("Content-Type", "application/json")
-            request.end_headers()
-            request.wfile.write(b'{"version": 1, "schema": {"fields": []}}')
-        else:
-            request.send_response(404)
-            request.end_headers()
-
-    with mock_lancedb_connection(handler) as db:
-        yield db.open_table("test")
-
-
-def read_json_body(request):
-    content_len = int(request.headers.get("Content-Length"))
-    return json.loads(request.rfile.read(content_len))
-
-
-def send_json(request, payload, status=200):
-    request.send_response(status)
-    request.send_header("Content-Type", "application/json")
-    request.end_headers()
-    request.wfile.write(json.dumps(payload).encode())
-
-
-def test_get_lsm_stats_sync():
-    """The sync wrapper round-trips the server payload into a dict."""
-    bucket = {
-        "shard_id": "b0",
-        "status": "Active",
-        "writer_epoch": 3,
-        "manifest_version": 12,
-        "current_generation": 6,
-        "replay_after_wal_entry_position": 40,
-        "wal_entry_position_last_seen": 42,
-        "generations": [{"generation": 5, "bytes": 1024, "rows": 7}],
-        "compacting": False,
-        "memtables": [
-            {
-                "generation": 6,
-                "rows": 2,
-                "bytes": 64,
-                "batches": 1,
-                "indexes": ["vec_idx"],
-            }
-        ],
-    }
-    seen_bodies = []
-
-    def lsm_handler(request, route):
-        assert route == "get_lsm_stats"
-        seen_bodies.append(read_json_body(request))
-        send_json(request, {"lsm_stats": {"buckets": [bucket]}})
-
-    with lsm_test_table(lsm_handler) as table:
-        assert table.get_lsm_stats() == {"buckets": [bucket]}
-        # Off by default, and forwarded when asked for.
-        assert seen_bodies == [{"include_generation_rows": False}]
-        table.get_lsm_stats(include_generation_rows=True)
-        assert seen_bodies[-1] == {"include_generation_rows": True}
-
-
-def test_get_lsm_stats_sync_returns_none_when_lsm_disabled():
-    """A null envelope means the LSM write path is not enabled, not an error."""
-
-    def lsm_handler(request, route):
-        send_json(request, {"lsm_stats": None})
-
-    with lsm_test_table(lsm_handler) as table:
-        assert table.get_lsm_stats() is None
-
-
-def test_flush_and_compact_lsm_sync():
-    """Both are one-shot POSTs answered 202 with no body."""
-    called = []
-
-    def lsm_handler(request, route):
-        called.append(route)
-        request.send_response(202)
-        request.end_headers()
-
-    with lsm_test_table(lsm_handler) as table:
-        assert table.flush_lsm() is None
-        assert table.compact_lsm() is None
-        assert called == ["flush_lsm", "compact_lsm"]
-
-
-def test_checkpoint_lsm_sync():
-    """Seal, read the watermark, and return once L0 holds nothing.
-
-    The convergence loop itself is covered in Rust; this pins the sync
-    binding to the endpoints it drives.
-    """
-    called = []
-
-    def lsm_handler(request, route):
-        called.append(route)
-        if route == "get_lsm_stats":
-            # An empty L0 yields no target watermark, so the loop is done
-            # after the seal without ever polling compaction.
-            send_json(request, {"lsm_stats": {"buckets": []}})
-        else:
-            request.send_response(202)
-            request.end_headers()
-
-    with lsm_test_table(lsm_handler) as table:
-        assert table.checkpoint_lsm() is None
-        assert called == ["flush_lsm", "get_lsm_stats"]
-
-
@contextlib.contextmanager
 def query_test_table(query_handler, *, server_version=Version("0.1.0")):
    def handler(request):
@@ -3854,65 +3854,3 @@ async def test_async_search_runs_embedding_on_dedicated_executor(
    assert all(name.startswith("lancedb-embedding") for name in captured_threads), (
        f"embedding ran off the dedicated executor: {captured_threads}"
    )
-
-
-def test_computed_column_declare_and_refresh(tmp_path):
-    db = lancedb.connect(tmp_path)
-    table = db.create_table("computed", [{"x": 1}, {"x": 2}])
-
-    table.add_columns(computed={"doubled": "x * 2"})
-    assert table.to_arrow()["doubled"].to_pylist() == [None, None]
-
-    result = table.refresh_column("doubled")
-    assert result.rows_filled == 2
-    assert sorted(table.to_arrow()["doubled"].to_pylist()) == [2, 4]
-
-    table.add([{"x": 5}])
-    assert table.refresh_column("doubled").rows_filled == 1
-    assert sorted(table.to_arrow()["doubled"].to_pylist()) == [2, 4, 10]
-
-
-def test_computed_column_rejects_transforms_and_computed_together(tmp_path):
-    db = lancedb.connect(tmp_path)
-    table = db.create_table("computed_mixed", [{"x": 1}])
-    with pytest.raises(ValueError):
-        table.add_columns({"a": "x + 1"}, computed={"b": "x * 2"})
-
-
-@pytest.mark.asyncio
-async def test_computed_column_async(tmp_path):
-    db = await lancedb.connect_async(tmp_path)
-    table = await db.create_table("computed_async", [{"x": 3}])
-
-    await table.add_columns(computed={"tripled": "x * 3"})
-    await table.refresh_column("tripled")
-
-    assert (await table.to_arrow())["tripled"].to_pylist() == [9]
-
-
-def test_refresh_column_async_returns_job(tmp_path):
-    db = lancedb.connect(tmp_path)
-    table = db.create_table("computed_job", [{"x": 1}, {"x": 2}])
-    table.add_columns(computed={"doubled": "x * 2"})
-
-    job = table.refresh_column_async("doubled")
-    assert job.id is None  # in-process jobs have no server id
-    job.wait()
-    assert job.status() == "finished"
-    assert sorted(table.to_arrow()["doubled"].to_pylist()) == [2, 4]
-
-    # Bad input raises at the call, not through the job.
-    with pytest.raises(Exception, match="not a computed column"):
-        table.refresh_column_async("x")
-
-
-@pytest.mark.asyncio
-async def test_refresh_column_async_job_async_table(tmp_path):
-    db = await lancedb.connect_async(tmp_path)
-    table = await db.create_table("computed_job_async", [{"x": 3}])
-    await table.add_columns(computed={"tripled": "x * 3"})
-
-    job = await table.refresh_column_async("tripled")
-    await job.wait()
-    assert await job.status() == "finished"
-    assert (await table.to_arrow())["tripled"].to_pylist() == [9]
@@ -346,23 +346,6 @@ impl Connection {
        })
    }

-    #[pyo3(signature = (name, namespace_path=None))]
-    pub fn drop_table_async(
-        self_: PyRef<'_, Self>,
-        name: String,
-        namespace_path: Option<Vec<String>>,
-    ) -> PyResult<Bound<'_, PyAny>> {
-        let inner = self_.get_inner()?.clone();
-        let ns_path = namespace_path.unwrap_or_default();
-        future_into_py(self_.py(), async move {
-            inner
-                .drop_table_async(name, &ns_path)
-                .await
-                .infer_error()
-                .map(crate::job::Job::new)
-        })
-    }
-
    #[pyo3(signature = (namespace_path=None,))]
    pub fn drop_all_tables(
        self_: PyRef<'_, Self>,
@@ -191,27 +191,8 @@ pub fn expr_lit(value: Bound<'_, PyAny>) -> PyResult<PyExpr> {
    }

    // datetime.datetime is a subclass of datetime.date, so it must be checked first.
-    //
-    // Python's datetime.timestamp() treats *naive* datetimes as local wall time.
-    // PyArrow (and therefore Lance table storage) encodes naive timestamps as
-    // UTC wall-clock microseconds. Using .timestamp() for naive values therefore
-    // shifts the literal by the local UTC offset on non-UTC machines, so
-    // `col("ts") == lit(naive_dt)` fails against a table that holds the same
-    // naive value. Fix: treat naive datetimes as UTC wall clock (match Arrow);
-    // keep aware datetimes on the real .timestamp() path (correct epoch).
    if let Ok(dt) = value.cast::<PyDateTime>() {
-        let ts: f64 = if dt.getattr("tzinfo")?.is_none() {
-            // Force UTC interpretation of the naive wall clock.
-            let utc = pyo3::types::PyModule::import(value.py(), "datetime")?
-                .getattr("timezone")?
-                .getattr("utc")?;
-            let kwargs = pyo3::types::PyDict::new(value.py());
-            kwargs.set_item("tzinfo", utc)?;
-            let aware = dt.call_method("replace", (), Some(&kwargs))?;
-            aware.call_method0("timestamp")?.extract()?
-        } else {
-            dt.call_method0("timestamp")?.extract()?
-        };
+        let ts: f64 = dt.call_method0("timestamp")?.extract()?;
        let micros = (ts * 1_000_000.0).round() as i64;
        return Ok(PyExpr(df_lit(ScalarValue::TimestampMicrosecond(
            Some(micros),
@@ -289,7 +289,7 @@ struct IvfHnswFlatParams {
    target_partition_size: Option<u32>,
 }

-#[pyclass(module = "lancedb._lancedb", get_all)]
+#[pyclass(get_all)]
 /// A description of an index currently configured on a column
 pub struct IndexConfig {
    /// The type of the index
@@ -16,8 +16,7 @@ use query::{FTSQuery, HybridQuery, Query, VectorQuery};
 use session::Session;
 use table::{
    AddColumnsResult, AddResult, AlterColumnsResult, DeleteResult, DropColumnsResult, FtsToken,
-    LsmWriteSpec, MergeResult, PyBlobFile, RefreshColumnResult, Table, UpdateFieldMetadataResult,
-    UpdateResult,
+    LsmWriteSpec, MergeResult, PyBlobFile, Table, UpdateFieldMetadataResult, UpdateResult,
 };

 pub mod arrow;
@@ -58,7 +57,6 @@ pub fn _lancedb(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_class::<VectorQuery>()?;
    m.add_class::<RecordBatchStream>()?;
    m.add_class::<AddColumnsResult>()?;
-    m.add_class::<RefreshColumnResult>()?;
    m.add_class::<AlterColumnsResult>()?;
    m.add_class::<UpdateFieldMetadataResult>()?;
    m.add_class::<AddResult>()?;
@@ -11,7 +11,7 @@ use pyo3::{PyResult, pyclass, pymethods};
 /// Sessions allow you to configure cache sizes for index and metadata caches,
 /// which can significantly impact memory use and performance. They can
 /// also be re-used across multiple connections to share the same cache state.
-#[pyclass(module = "lancedb._lancedb", from_py_object)]
+#[pyclass(from_py_object)]
 #[derive(Clone)]
 pub struct Session {
    pub(crate) inner: Arc<LanceSession>,
@@ -246,22 +246,12 @@ impl From<lancedb::table::MergeResult> for MergeResult {
    }
 }

-/// Render for `__repr__`, so the default reads as Python's `None` rather than
-/// Rust's `Some([..])`.
-fn fmt_maintained(maintained: &Option<Vec<String>>) -> String {
-    match maintained {
-        Some(names) => format!("{:?}", names),
-        None => "None".to_string(),
-    }
-}
-
 /// Specification selecting Lance's MemWAL LSM-style write path for
 /// `merge_insert`.
 ///
 /// Constructed via the `bucket(...)`, `identity(...)`, or `unsharded()`
 /// classmethods, then optionally chain `with_maintained_indexes(...)` and
-/// `with_writer_config_defaults(...)`. A fresh spec maintains every index the
-/// MemWAL supports, resolved on install.
+/// `with_writer_config_defaults(...)`.
 #[pyclass(from_py_object)]
 #[derive(Clone, Debug)]
 pub struct LsmWriteSpec {
@@ -301,11 +291,11 @@ impl LsmWriteSpec {
        }
    }

-    /// Set which indexes the MemWAL maintains. `None` (the default)
-    /// resolves every supported index on install; a list is verbatim,
-    /// and an empty list maintains nothing.
-    #[pyo3(signature = (indexes))]
-    pub fn with_maintained_indexes(&self, indexes: Option<Vec<String>>) -> Self {
+    /// Replace the list of indexes the MemWAL should keep up to date as
+    /// rows are appended. Each name must reference an index that
+    /// already exists on the table at the time `set_lsm_write_spec`
+    /// is called.
+    pub fn with_maintained_indexes(&self, indexes: Vec<String>) -> Self {
        Self {
            inner: self.inner.clone().with_maintained_indexes(indexes),
        }
@@ -327,29 +317,23 @@ impl LsmWriteSpec {
                maintained_indexes,
                writer_config_defaults,
            } => format!(
-                "LsmWriteSpec.bucket(column={:?}, num_buckets={}, maintained_indexes={}, writer_config_defaults={:?})",
-                column,
-                num_buckets,
-                fmt_maintained(maintained_indexes),
-                writer_config_defaults,
+                "LsmWriteSpec.bucket(column={:?}, num_buckets={}, maintained_indexes={:?}, writer_config_defaults={:?})",
+                column, num_buckets, maintained_indexes, writer_config_defaults,
            ),
            lancedb::table::LsmWriteSpec::Identity {
                column,
                maintained_indexes,
                writer_config_defaults,
            } => format!(
-                "LsmWriteSpec.identity(column={:?}, maintained_indexes={}, writer_config_defaults={:?})",
-                column,
-                fmt_maintained(maintained_indexes),
-                writer_config_defaults,
+                "LsmWriteSpec.identity(column={:?}, maintained_indexes={:?}, writer_config_defaults={:?})",
+                column, maintained_indexes, writer_config_defaults,
            ),
            lancedb::table::LsmWriteSpec::Unsharded {
                maintained_indexes,
                writer_config_defaults,
            } => format!(
-                "LsmWriteSpec.unsharded(maintained_indexes={}, writer_config_defaults={:?})",
-                fmt_maintained(maintained_indexes),
-                writer_config_defaults,
+                "LsmWriteSpec.unsharded(maintained_indexes={:?}, writer_config_defaults={:?})",
+                maintained_indexes, writer_config_defaults,
            ),
        }
    }
@@ -384,10 +368,10 @@ impl LsmWriteSpec {
        }
    }

-    /// Indexes the MemWAL keeps up to date, or `None` for every supported one.
+    /// Names of indexes the MemWAL should keep up to date during writes.
    #[getter]
-    pub fn maintained_indexes(&self) -> Option<Vec<String>> {
-        self.inner.maintained_indexes().map(<[String]>::to_vec)
+    pub fn maintained_indexes(&self) -> Vec<String> {
+        self.inner.maintained_indexes().to_vec()
    }

    /// Default `ShardWriter` configuration recorded by this spec.
@@ -415,32 +399,6 @@ pub struct AddColumnsResult {
    pub version: u64,
 }

-#[pyclass(get_all, from_py_object)]
-#[derive(Clone, Debug)]
-pub struct RefreshColumnResult {
-    pub rows_filled: u64,
-    pub version: u64,
-}
-
-#[pymethods]
-impl RefreshColumnResult {
-    pub fn __repr__(&self) -> String {
-        format!(
-            "RefreshColumnResult(rows_filled={}, version={})",
-            self.rows_filled, self.version
-        )
-    }
-}
-
-impl From<lancedb::table::RefreshColumnResult> for RefreshColumnResult {
-    fn from(result: lancedb::table::RefreshColumnResult) -> Self {
-        Self {
-            rows_filled: result.rows_filled,
-            version: result.version,
-        }
-    }
-}
-
 #[pymethods]
 impl AddColumnsResult {
    pub fn __repr__(&self) -> String {
@@ -605,7 +563,7 @@ impl PyBlobFile {
    }
 }

-#[pyclass(module = "lancedb._lancedb", get_all, from_py_object)]
+#[pyclass(get_all, from_py_object)]
 #[derive(Clone, Debug)]
 pub struct FtsToken {
    pub text: String,
@@ -1536,40 +1494,6 @@ impl Table {
        })
    }

-    pub fn add_computed_columns(
-        self_: PyRef<'_, Self>,
-        columns: Vec<(String, String)>,
-    ) -> PyResult<Bound<'_, PyAny>> {
-        let inner = self_.inner_ref()?.clone();
-        future_into_py(self_.py(), async move {
-            let mut builder = inner.add_columns();
-            for (name, expression) in columns {
-                builder = builder.computed(name, expression);
-            }
-            let result = builder.execute().await.infer_error()?;
-            Ok(AddColumnsResult::from(result))
-        })
-    }
-
-    pub fn refresh_column(self_: PyRef<'_, Self>, column: String) -> PyResult<Bound<'_, PyAny>> {
-        let inner = self_.inner_ref()?.clone();
-        future_into_py(self_.py(), async move {
-            let result = inner.refresh_column(column).await.infer_error()?;
-            Ok(RefreshColumnResult::from(result))
-        })
-    }
-
-    pub fn refresh_column_async(
-        self_: PyRef<'_, Self>,
-        column: String,
-    ) -> PyResult<Bound<'_, PyAny>> {
-        let inner = self_.inner_ref()?.clone();
-        future_into_py(self_.py(), async move {
-            let job = inner.refresh_column_async(column).await.infer_error()?;
-            Ok(crate::job::Job::new(job))
-        })
-    }
-
    pub fn add_columns_with_schema(
        self_: PyRef<'_, Self>,
        schema: PyArrowType<Schema>,
@@ -799,7 +799,7 @@ name = "cuda-bindings"
 version = "13.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cuda-pathfinder", marker = "(python_full_version < '3.14' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "cuda-pathfinder" },
 ]
 wheels = [
    { url = "https://files.pythonhosted.org/packages/a9/21/8464d133752951c154feafb3b65c297e7d80f301183d220bec4c830f1441/cuda_bindings-13.3.1-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:120fcc53d57903df529c3486962c56528cba5b7d6c57c99537320ed9922c8b86", size = 6073403, upload-time = "2026-05-29T23:11:36.22Z" },
@@ -834,37 +834,37 @@ wheels = [

 [package.optional-dependencies]
 cublas = [
-    { name = "nvidia-cublas", marker = "(python_full_version < '3.14' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cublas" },
 ]
 cudart = [
-    { name = "nvidia-cuda-runtime", marker = "(python_full_version < '3.14' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cuda-runtime" },
 ]
 cufft = [
-    { name = "nvidia-cufft", marker = "(python_full_version < '3.14' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cufft" },
 ]
 cufile = [
-    { name = "nvidia-cufile", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cufile" },
 ]
 cupti = [
-    { name = "nvidia-cuda-cupti", marker = "(python_full_version < '3.14' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cuda-cupti" },
 ]
 curand = [
-    { name = "nvidia-curand", marker = "(python_full_version < '3.14' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-curand" },
 ]
 cusolver = [
-    { name = "nvidia-cusolver", marker = "(python_full_version < '3.14' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cusolver" },
 ]
 cusparse = [
-    { name = "nvidia-cusparse", marker = "(python_full_version < '3.14' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cusparse" },
 ]
 nvjitlink = [
-    { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.14' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-nvjitlink" },
 ]
 nvrtc = [
-    { name = "nvidia-cuda-nvrtc", marker = "(python_full_version < '3.14' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cuda-nvrtc" },
 ]
 nvtx = [
-    { name = "nvidia-nvtx", marker = "(python_full_version < '3.14' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-nvtx" },
 ]

 [[package]]
@@ -1023,7 +1023,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
@@ -1440,16 +1440,16 @@ resolution-markers = [
    "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "cachetools", marker = "python_full_version < '3.11'" },
-    { name = "certifi", marker = "python_full_version < '3.11'" },
-    { name = "httpx", marker = "python_full_version < '3.11'" },
-    { name = "ibm-cos-sdk", marker = "python_full_version < '3.11'" },
-    { name = "lomond", marker = "python_full_version < '3.11'" },
-    { name = "packaging", marker = "python_full_version < '3.11'" },
-    { name = "pandas", version = "2.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "requests", marker = "python_full_version < '3.11'" },
-    { name = "tabulate", marker = "python_full_version < '3.11'" },
-    { name = "urllib3", marker = "python_full_version < '3.11'" },
+    { name = "cachetools" },
+    { name = "certifi" },
+    { name = "httpx" },
+    { name = "ibm-cos-sdk" },
+    { name = "lomond" },
+    { name = "packaging" },
+    { name = "pandas", version = "2.2.3", source = { registry = "https://pypi.org/simple" } },
+    { name = "requests" },
+    { name = "tabulate" },
+    { name = "urllib3" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/c7/56/2e3df38a1f13062095d7bde23c87a92f3898982993a15186b1bfecbd206f/ibm_watsonx_ai-1.3.42.tar.gz", hash = "sha256:ee5be59009004245d957ce97d1227355516df95a2640189749487614fef674ff", size = 688651, upload-time = "2025-10-01T13:35:41.527Z" }
 wheels = [
@@ -1468,17 +1468,17 @@ resolution-markers = [
    "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "cachetools", marker = "python_full_version >= '3.11'" },
-    { name = "certifi", marker = "python_full_version >= '3.11'" },
-    { name = "httpx", marker = "python_full_version >= '3.11'" },
-    { name = "ibm-cos-sdk", marker = "python_full_version >= '3.11'" },
-    { name = "lomond", marker = "python_full_version >= '3.11'" },
-    { name = "packaging", marker = "python_full_version >= '3.11'" },
-    { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and python_full_version < '3.14'" },
+    { name = "cachetools" },
+    { name = "certifi" },
+    { name = "httpx" },
+    { name = "ibm-cos-sdk" },
+    { name = "lomond" },
+    { name = "packaging" },
+    { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.14'" },
    { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.14'" },
-    { name = "requests", marker = "python_full_version >= '3.11'" },
-    { name = "tabulate", marker = "python_full_version >= '3.11'" },
-    { name = "urllib3", marker = "python_full_version >= '3.11'" },
+    { name = "requests" },
+    { name = "tabulate" },
+    { name = "urllib3" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/29/a3/c756b534696ab2f3f29882fdb7ca7198b7a5c94e10c0a3a327853d6d6b79/ibm_watsonx_ai-1.5.14.tar.gz", hash = "sha256:a756488bd57e87c0fc51be42dcba871143cfe0ac1e805c497c5047e1e4f13e9d", size = 735804, upload-time = "2026-06-22T12:32:43.85Z" }
 wheels = [
@@ -1554,17 +1554,17 @@ resolution-markers = [
    "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "colorama", marker = "python_full_version < '3.11' and sys_platform == 'win32'" },
-    { name = "decorator", marker = "python_full_version < '3.11'" },
-    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
-    { name = "jedi", marker = "python_full_version < '3.11'" },
-    { name = "matplotlib-inline", marker = "python_full_version < '3.11'" },
-    { name = "pexpect", marker = "python_full_version < '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
-    { name = "prompt-toolkit", marker = "python_full_version < '3.11'" },
-    { name = "pygments", marker = "python_full_version < '3.11'" },
-    { name = "stack-data", marker = "python_full_version < '3.11'" },
-    { name = "traitlets", marker = "python_full_version < '3.11'" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "decorator" },
+    { name = "exceptiongroup" },
+    { name = "jedi" },
+    { name = "matplotlib-inline" },
+    { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "prompt-toolkit" },
+    { name = "pygments" },
+    { name = "stack-data" },
+    { name = "traitlets" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/40/18/f8598d287006885e7136451fdea0755af4ebcbfe342836f24deefaed1164/ipython-8.39.0.tar.gz", hash = "sha256:4110ae96012c379b8b6db898a07e186c40a2a1ef5d57a7fa83166047d9da7624", size = 5513971, upload-time = "2026-03-27T10:02:13.94Z" }
 wheels = [
@@ -1583,18 +1583,18 @@ resolution-markers = [
    "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" },
-    { name = "decorator", marker = "python_full_version >= '3.11'" },
-    { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11'" },
-    { name = "jedi", marker = "python_full_version >= '3.11'" },
-    { name = "matplotlib-inline", marker = "python_full_version >= '3.11'" },
-    { name = "pexpect", marker = "python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
-    { name = "prompt-toolkit", marker = "python_full_version >= '3.11'" },
-    { name = "psutil", marker = "python_full_version >= '3.11' and sys_platform != 'cygwin' and sys_platform != 'emscripten'" },
-    { name = "pygments", marker = "python_full_version >= '3.11'" },
-    { name = "stack-data", marker = "python_full_version >= '3.11'" },
-    { name = "traitlets", marker = "python_full_version >= '3.11'" },
-    { name = "typing-extensions", marker = "python_full_version == '3.11.*'" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "decorator" },
+    { name = "ipython-pygments-lexers" },
+    { name = "jedi" },
+    { name = "matplotlib-inline" },
+    { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "prompt-toolkit" },
+    { name = "psutil", marker = "sys_platform != 'cygwin' and sys_platform != 'emscripten'" },
+    { name = "pygments" },
+    { name = "stack-data" },
+    { name = "traitlets" },
+    { name = "typing-extensions", marker = "python_full_version < '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/53/59/165d3b4d75cc34add3122c4417ecb229085140ac573103c223cd01dde96f/ipython-9.15.0.tar.gz", hash = "sha256:da2819ce2aa83135257df830660b1176d986c3d2876db24df01974fa955b2756", size = 4442580, upload-time = "2026-06-26T11:03:35.913Z" }
 wheels = [
@@ -1606,7 +1606,7 @@ name = "ipython-pygments-lexers"
 version = "1.1.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pygments", marker = "python_full_version >= '3.11'" },
+    { name = "pygments" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" }
 wheels = [
@@ -2005,7 +2005,7 @@ requires-dist = [
    { name = "pyarrow-stubs", marker = "extra == 'tests'", specifier = ">=16.0" },
    { name = "pydantic", specifier = ">=1.10" },
    { name = "pylance", marker = "extra == 'pylance'", specifier = ">=5.0.0b5" },
-    { name = "pylance", marker = "extra == 'tests'", specifier = "==9.0.0rc1" },
+    { name = "pylance", marker = "extra == 'tests'", specifier = "==10.0.0" },
    { name = "pyright", marker = "extra == 'dev'", specifier = ">=1.1.350" },
    { name = "pytest", marker = "extra == 'tests'", specifier = ">=7.0" },
    { name = "pytest-asyncio", marker = "extra == 'tests'", specifier = ">=0.21" },
@@ -2858,7 +2858,7 @@ name = "nvidia-cudnn-cu13"
 version = "9.19.0.56"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas", marker = "(python_full_version < '3.14' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "nvidia-cublas" },
 ]
 wheels = [
    { url = "https://files.pythonhosted.org/packages/f1/84/26025437c1e6b61a707442184fa0c03d083b661adf3a3eecfd6d21677740/nvidia_cudnn_cu13-9.19.0.56-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:6ed29ffaee1176c612daf442e4dd6cfeb6a0caa43ddcbeb59da94953030b1be4", size = 433781201, upload-time = "2026-02-03T20:40:53.805Z" },
@@ -2870,7 +2870,7 @@ name = "nvidia-cufft"
 version = "12.0.0.61"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.14' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "nvidia-nvjitlink" },
 ]
 wheels = [
    { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" },
@@ -2900,9 +2900,9 @@ name = "nvidia-cusolver"
 version = "12.0.4.66"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas", marker = "(python_full_version < '3.14' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
-    { name = "nvidia-cusparse", marker = "(python_full_version < '3.14' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
-    { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.14' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "nvidia-cublas" },
+    { name = "nvidia-cusparse" },
+    { name = "nvidia-nvjitlink" },
 ]
 wheels = [
    { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" },
@@ -2914,7 +2914,7 @@ name = "nvidia-cusparse"
 version = "12.6.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.14' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "nvidia-nvjitlink" },
 ]
 wheels = [
    { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" },
@@ -3091,10 +3091,10 @@ resolution-markers = [
    "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "python-dateutil", marker = "python_full_version < '3.11'" },
-    { name = "pytz", marker = "python_full_version < '3.11'" },
-    { name = "tzdata", marker = "python_full_version < '3.11'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213, upload-time = "2024-09-20T13:10:04.827Z" }
 wheels = [
@@ -3143,11 +3143,11 @@ resolution-markers = [
    "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12' or python_full_version >= '3.14'" },
    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' and python_full_version < '3.14'" },
-    { name = "python-dateutil", marker = "python_full_version >= '3.11' and python_full_version < '3.14'" },
-    { name = "pytz", marker = "python_full_version >= '3.11' and python_full_version < '3.14'" },
-    { name = "tzdata", marker = "python_full_version >= '3.11' and python_full_version < '3.14'" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" }
 wheels = [
@@ -3210,9 +3210,9 @@ resolution-markers = [
    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.14'" },
-    { name = "python-dateutil", marker = "python_full_version >= '3.14'" },
-    { name = "tzdata", marker = "(python_full_version >= '3.14' and sys_platform == 'emscripten') or (python_full_version >= '3.14' and sys_platform == 'win32')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" } },
+    { name = "python-dateutil" },
+    { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/f8/87/4341c6252d1c47b08768c3d25ac487362bf403f0313ddae4a2a26c9b1b4c/pandas-3.0.3.tar.gz", hash = "sha256:696a4a00a2a2a35d4e5deb3fc946641b96c944f02230e4f76137fe35d806c4fc", size = 4651414, upload-time = "2026-05-11T18:54:29.21Z" }
 wheels = [
@@ -3320,7 +3320,7 @@ name = "pexpect"
 version = "4.9.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "ptyprocess", marker = "(python_full_version < '3.14' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "ptyprocess" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
 wheels = [
@@ -3912,7 +3912,7 @@ crypto = [

 [[package]]
 name = "pylance"
-version = "7.0.0"
+version = "10.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "lance-namespace" },
@@ -3922,12 +3922,12 @@ dependencies = [
    { name = "pyarrow" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ac/ad/2f64921bf346e7075aef24a72595db44821724a3d89a9a92dd24e79632aa/pylance-7.0.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:98422021975be76e72b1572f41b8c9abb3bee5bdc9bfa5e9ce731110a65ed4d1", size = 62134146, upload-time = "2026-05-27T21:59:37.459Z" },
-    { url = "https://files.pythonhosted.org/packages/73/1c/c5a01bee0160b55d9a98895cbd33091d038f0a0995b121ab72e629008d02/pylance-7.0.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4bec86ee5b6fbd8bfc493e653f0a1fba0303cfe5492b9b46fc25ab908edc7183", size = 65373684, upload-time = "2026-05-27T22:04:01.584Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/da/1fe8b8f7dbfe734d76af76acc994fc360a0d0c79a4874ef69f5a72a58fe3/pylance-7.0.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881491432c53184e52f8d1db8d5f872f39a03f36fb104bec77b33d379519d8b5", size = 69458555, upload-time = "2026-05-27T22:16:50.567Z" },
-    { url = "https://files.pythonhosted.org/packages/76/f0/dd505cf3fd0226ab9d94759acd713125af1d3bfacfd80bbd52e3b9f89509/pylance-7.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:18453999e7fff4f76b16d6b7882c9df0628bd142ff95e2461bd7dd5ee3fe0af3", size = 65394430, upload-time = "2026-05-27T22:05:30.923Z" },
-    { url = "https://files.pythonhosted.org/packages/17/ba/2357b81034f28eb00790e258ed140289a6a887a7468ca9df6349fd186b27/pylance-7.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:04a58051d408c60fe76d41a220dcaf8fea8fb6d1aa0ca78a709b60bc3cc8d19a", size = 69473470, upload-time = "2026-05-27T22:17:18.935Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/ec/5c00b6303a67d787f9475141832cbdc513d674ac3dcaeef8a7b169905e65/pylance-7.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:467d4864af047eaab4e1370e2f1e88e2c6f507c079874421116cb41d78bc3629", size = 74792863, upload-time = "2026-05-27T22:19:23.875Z" },
+    { url = "https://files.pythonhosted.org/packages/82/b2/c81de196076c4c8d768f485324a0043e113ce0950a339977d83fee9783ef/pylance-10.0.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:d4bba56ae829202b7e9cdc82c92c00a4b52f03e679dc3edfad1db09d1285be2e", size = 69279797, upload-time = "2026-08-07T18:25:24.812Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/e9/af671a6225740bd70c1e70bd83fa08091d628b960397cbecc477f16aaaf1/pylance-10.0.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:489b944827c0271e16a62b4006f8c75acc3bd7fbc381f35388a2afaaae38d438", size = 72775384, upload-time = "2026-08-07T18:31:29.686Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/22/e07194195bb3bbdf062b0c31690fc92fccb2686d5e768efa1dc379a93350/pylance-10.0.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:018efe7d437d326b9049c1223458bd955e85e48509b4b0bbf8b2d3d94075dbff", size = 76632194, upload-time = "2026-08-07T18:44:29.001Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/71/ed9956cf657e86a5fee5d5ddcfa7bfed0d7c2968bee39ed85d12629d8c93/pylance-10.0.0-cp310-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:254bad5d765c14db6c4eddd5323133dee3c76ff6d40c4777afe0b0e91d4c04d2", size = 72804222, upload-time = "2026-08-07T18:31:24.264Z" },
+    { url = "https://files.pythonhosted.org/packages/94/96/de449c246b2892df9d5a0af775b79a061e9897e6942bcee5c4ab6d6071f8/pylance-10.0.0-cp310-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:9f0c089e30389d9b7765a4c16f3d9325b05ed4fbf6cc2bbc9418292983472e54", size = 76602015, upload-time = "2026-08-07T18:46:27.724Z" },
+    { url = "https://files.pythonhosted.org/packages/53/81/4a5a9072b6d68c4dbb8c7b5530a381c7a6bea4ba92f9eca58ac885142722/pylance-10.0.0-cp310-abi3-win_amd64.whl", hash = "sha256:9fecf46e6835dc64b2d71767d5eab4f73787543a852432e9ba8ecf8527b3cdab", size = 82799247, upload-time = "2026-08-07T18:47:46.855Z" },
 ]

 [[package]]
@@ -4683,10 +4683,10 @@ resolution-markers = [
    "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "joblib", marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "threadpoolctl", marker = "python_full_version < '3.11'" },
+    { name = "joblib" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
+    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" } },
+    { name = "threadpoolctl" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/98/c2/a7855e41c9d285dfe86dc50b250978105dce513d6e459ea66a6aeb0e1e0c/scikit_learn-1.7.2.tar.gz", hash = "sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda", size = 7193136, upload-time = "2025-09-09T08:21:29.075Z" }
 wheels = [
@@ -4734,13 +4734,13 @@ resolution-markers = [
    "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "joblib", marker = "python_full_version >= '3.11'" },
-    { name = "narwhals", marker = "python_full_version >= '3.11'" },
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "joblib" },
+    { name = "narwhals" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
-    { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
    { name = "scipy", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
-    { name = "threadpoolctl", marker = "python_full_version >= '3.11'" },
+    { name = "threadpoolctl" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/fa/6f/37092bdb25f712817231799fc5674d8e704066a8a70c1d2d40517e18b4ab/scikit_learn-1.9.0.tar.gz", hash = "sha256:8833266989d3a5110178a9fae30783675460724d0e1efb13b14901d2c660c557", size = 7750767, upload-time = "2026-06-02T11:54:32.706Z" }
 wheels = [
@@ -4784,7 +4784,7 @@ resolution-markers = [
    "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" }
 wheels = [
@@ -4843,7 +4843,7 @@ resolution-markers = [
    "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
 wheels = [
@@ -4920,7 +4920,7 @@ resolution-markers = [
    "python_full_version >= '3.12' and python_full_version < '3.14'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a7/25/c2700dfaf6442b4effaa91af24ebce5dc9d31bb4a69706313aae70d72cd0/scipy-1.18.0.tar.gz", hash = "sha256:67b2ad2ad54c72ca6d04975a9b2df8c3638c34ddd5b28738e94fc2b57929d378", size = 30774447, upload-time = "2026-06-19T15:01:43.456Z" }
 wheels = [
@@ -1,6 +1,6 @@
 [package]
 name = "lancedb"
-version = "0.38.0-beta.2"
+version = "0.37.1"
 edition.workspace = true
 description = "LanceDB: A serverless, low-latency vector database for AI applications"
 license.workspace = true
@@ -188,9 +188,6 @@ required-features = ["bedrock"]
 [[example]]
 name = "bench_streaming_dataloader"

-[[example]]
-name = "bench_open_missing_table"
-
 [[example]]
 name = "simple"

@@ -1,150 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-// Release benchmark for opening a missing table as sibling-table cardinality grows.
-//
-// The fixture uses real `.lance` directories and marker files. Fixture creation is
-// outside the timed section. Defaults intentionally cover 1k, 10k, and 100k siblings
-// with 10 warmups and 100 distinct missing-table opens per scale:
-//
-// ```text
-// cargo run --release -p lancedb --example bench_open_missing_table
-// ```
-//
-// `BENCH_SIBLINGS`, `BENCH_WARMUPS`, and `BENCH_TRIALS` override those defaults.
-// Reduced settings are useful only as a smoke test. Performance comparisons require
-// the same machine, filesystem, fixture sizes, settings, lockfile, and alternating
-// baseline/candidate execution order.
-
-use std::time::{Duration, Instant};
-
-use anyhow::{Context, Result, bail};
-use lancedb::connection::Connection;
-use lancedb::{Error, connect};
-use object_store::ObjectStoreExt as _;
-use object_store::path::Path;
-
-const MAX_SIBLINGS: usize = 1_000_000;
-const MAX_WARMUPS: usize = 10_000;
-const MAX_TRIALS: usize = 100_000;
-
-fn env_usize(key: &str, default: usize, max: usize) -> Result<usize> {
-    let value = match std::env::var(key) {
-        Ok(value) => value
-            .parse()
-            .with_context(|| format!("invalid {key} value: {value}"))?,
-        Err(std::env::VarError::NotPresent) => default,
-        Err(error) => return Err(error).with_context(|| format!("reading {key}")),
-    };
-    if value == 0 || value > max {
-        bail!("{key} must be between 1 and {max}");
-    }
-    Ok(value)
-}
-
-fn sibling_counts() -> Result<Vec<usize>> {
-    let raw = std::env::var("BENCH_SIBLINGS").unwrap_or_else(|_| "1000,10000,100000".into());
-    let mut counts = raw
-        .split(',')
-        .map(|value| {
-            value
-                .trim()
-                .parse::<usize>()
-                .with_context(|| format!("invalid BENCH_SIBLINGS value: {value}"))
-        })
-        .collect::<Result<Vec<_>>>()?;
-    counts.sort_unstable();
-    counts.dedup();
-    if counts.is_empty() || counts[0] == 0 || counts[counts.len() - 1] > MAX_SIBLINGS {
-        bail!("BENCH_SIBLINGS values must be between 1 and {MAX_SIBLINGS}");
-    }
-    Ok(counts)
-}
-
-async fn add_siblings(
-    store: &object_store::local::LocalFileSystem,
-    start: usize,
-    end: usize,
-) -> Result<()> {
-    for index in start..end {
-        let marker = Path::from(format!("sibling_{index:06}.lance/_marker"));
-        store
-            .put(&marker, bytes::Bytes::new().into())
-            .await
-            .with_context(|| format!("creating benchmark marker {marker}"))?;
-    }
-    Ok(())
-}
-
-async fn time_missing_open(db: &Connection, name: &str) -> Result<Duration> {
-    let started = Instant::now();
-    let result = db.open_table(name).execute().await;
-    let elapsed = started.elapsed();
-    match result {
-        Err(Error::TableNotFound { .. }) => Ok(elapsed),
-        Err(error) => bail!("expected TableNotFound for {name}, got {error:?}"),
-        Ok(_) => bail!("benchmark missing-table name unexpectedly exists: {name}"),
-    }
-}
-
-fn percentile(sorted: &[Duration], percentile: usize) -> Duration {
-    let rank = (sorted.len() * percentile).div_ceil(100).saturating_sub(1);
-    sorted[rank]
-}
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    let counts = sibling_counts()?;
-    let warmups = env_usize("BENCH_WARMUPS", 10, MAX_WARMUPS)?;
-    let trials = env_usize("BENCH_TRIALS", 100, MAX_TRIALS)?;
-
-    let fixture = tempfile::tempdir().context("creating benchmark fixture")?;
-    let database_path = fixture.path();
-    let fixture_store = object_store::local::LocalFileSystem::new_with_prefix(database_path)
-        .context("creating benchmark object store")?;
-    let db = connect(database_path.to_str().context("non-UTF-8 fixture path")?)
-        .execute()
-        .await?;
-
-    println!(
-        "config: siblings={counts:?} warmups={warmups} trials={trials} profile={} os={} arch={}",
-        if cfg!(debug_assertions) {
-            "debug"
-        } else {
-            "release"
-        },
-        std::env::consts::OS,
-        std::env::consts::ARCH,
-    );
-    println!("lower is better; fixture setup and teardown are excluded");
-    println!("| siblings | samples | p50 | p95 | max |");
-    println!("| ---: | ---: | ---: | ---: | ---: |");
-
-    let mut created = 0;
-    for sibling_count in counts {
-        add_siblings(&fixture_store, created, sibling_count).await?;
-        created = sibling_count;
-
-        for index in 0..warmups {
-            let name = format!("__missing_warmup_{sibling_count}_{index}");
-            let _ = time_missing_open(&db, &name).await?;
-        }
-
-        let mut samples = Vec::with_capacity(trials);
-        for index in 0..trials {
-            let name = format!("__missing_trial_{sibling_count}_{index}");
-            samples.push(time_missing_open(&db, &name).await?);
-        }
-        samples.sort_unstable();
-
-        println!(
-            "| {sibling_count} | {} | {:?} | {:?} | {:?} |",
-            samples.len(),
-            percentile(&samples, 50),
-            percentile(&samples, 95),
-            samples[samples.len() - 1],
-        );
-    }
-
-    Ok(())
-}
@@ -17,7 +17,7 @@ use arrow_array::builder::LargeBinaryBuilder;
 use arrow_schema::{DataType, Field, Schema};
 use lance::dataset::{BlobRangeRequest as LanceBlobRangeRequest, Dataset, WriteParams};
 use lance_arrow::FieldExt;
-use lance_file::version::{ConcreteFileVersion, LanceFileVersion};
+use lance_file::version::LanceFileVersion;
 use lance_io::object_store::ObjectStore;
 use object_store::path::Path;

@@ -333,10 +333,7 @@ pub(crate) fn ensure_blob_storage_version(schema: &Schema, params: &mut WritePar
        .data_storage_version
        .unwrap_or(LanceFileVersion::Stable)
        .resolve();
-    if matches!(
-        resolved,
-        ConcreteFileVersion::V1 | ConcreteFileVersion::V2_0 | ConcreteFileVersion::V2_1
-    ) {
+    if resolved < LanceFileVersion::V2_2 {
        params.data_storage_version = Some(LanceFileVersion::V2_2);
    }
 }
@@ -502,7 +499,7 @@ mod tests {
        ensure_blob_storage_version(&blob_schema(), &mut params);
        assert_eq!(
            params.data_storage_version.unwrap().resolve(),
-            ConcreteFileVersion::V2_2
+            LanceFileVersion::V2_2
        );
    }

@@ -515,7 +512,7 @@ mod tests {
        ensure_blob_storage_version(&blob_schema(), &mut params);
        assert_eq!(
            params.data_storage_version.unwrap().resolve(),
-            ConcreteFileVersion::V2_2
+            LanceFileVersion::V2_2
        );
    }

@@ -409,11 +409,6 @@ impl Connection {
    ///
    /// The names will be returned in lexicographical order (ascending)
    ///
-    /// Listing databases discover physical `*.lance` entries without opening every
-    /// dataset. The result is a point-in-time discovery snapshot: an entry may still be
-    /// under creation, may contain only uncommitted storage, or may be concurrently
-    /// dropped before it is opened.
-    ///
    /// The parameters `page_token` and `limit` can be used to paginate the results
    pub fn table_names(&self) -> TableNamesBuilder {
        TableNamesBuilder::new(self.internal.clone())
@@ -461,9 +456,10 @@ impl Connection {
    ///
    /// # Returns
    /// Created [`TableRef`], or [`Error::TableNotFound`] if the table does not exist.
-    /// On listing databases, a committed Lance manifest is authoritative for table
-    /// existence. Uncommitted files or a physical `<name>.lance` directory alone do not
-    /// make a table openable.
+    /// If the table's storage is present but holds no readable dataset (for example a
+    /// `<name>.lance` directory left behind by an interrupted drop and re-create, which
+    /// [`Self::table_names`] still lists) this returns [`Error::TableCorrupted`]
+    /// instead.
    pub fn open_table(&self, name: impl Into<String>) -> OpenTableBuilder {
        OpenTableBuilder::new(
            self.internal.clone(),
@@ -565,21 +561,6 @@ impl Connection {
            .await
    }

-    /// Start dropping a table and return a handle to the cleanup job.
-    ///
-    /// The table may become unavailable before its physical data is removed.
-    /// Call [`crate::job::Job::wait`] to wait for cleanup to finish. Local
-    /// backends may complete the drop before returning the handle.
-    pub async fn drop_table_async(
-        &self,
-        name: impl AsRef<str>,
-        namespace_path: &[String],
-    ) -> Result<crate::job::Job> {
-        self.internal
-            .drop_table_async(name.as_ref(), namespace_path)
-            .await
-    }
-
    /// Drop the database
    ///
    /// This is the same as dropping all of the tables
@@ -438,9 +438,10 @@ mod tests {
            .await
            .unwrap()
            .data_storage_format
-            .lance_file_format();
+            .lance_file_version()
+            .unwrap();
        // Compare resolved versions since Stable/Next are aliases that resolve at storage time
-        assert_eq!(storage_format, data_storage_version.resolve());
+        assert_eq!(storage_format.resolve(), data_storage_version.resolve());
    }

    #[tokio::test]
@@ -323,18 +323,6 @@ pub trait Database:
    ) -> Result<()>;
    /// Drop a table in the database
    async fn drop_table(&self, name: &str, namespace_path: &[String]) -> Result<()>;
-    /// Start dropping a table and return a handle to the cleanup job.
-    ///
-    /// Backends without asynchronous cleanup complete the drop before
-    /// returning an already-finished job.
-    async fn drop_table_async(
-        &self,
-        name: &str,
-        namespace_path: &[String],
-    ) -> Result<crate::job::Job> {
-        self.drop_table(name, namespace_path).await?;
-        Ok(crate::job::Job::new_done())
-    }
    /// Drop all tables in the database
    async fn drop_all_tables(&self, namespace_path: &[String]) -> Result<()>;
    fn as_any(&self) -> &dyn std::any::Any;
@@ -1032,7 +1032,6 @@ impl Database for ListingDatabase {
        };

        Ok(ListTablesResponse {
-            context: None,
            tables: f,
            page_token: next_page_token,
        })
@@ -1292,21 +1291,16 @@ impl Database for ListingDatabase {
 mod tests {
    use super::*;
    use crate::Table;
-    use crate::arrow::{SendableRecordBatchStream, SimpleRecordBatchStream};
    use crate::connection::ConnectRequest;
    use crate::data::scannable::Scannable;
    use crate::database::{CreateTableMode, CreateTableRequest};
    use crate::query::QueryRequest;
    use crate::table::{AnyQuery, WriteOptions};
    use arrow_array::{Int32Array, RecordBatch, StringArray};
-    use arrow_schema::{DataType, Field, Schema, SchemaRef};
-    use futures::{TryStreamExt, stream::once};
+    use arrow_schema::{DataType, Field, Schema};
+    use futures::TryStreamExt;
    use std::path::PathBuf;
-    use std::sync::Arc;
-    use std::time::Duration;
    use tempfile::tempdir;
-    use tokio::sync::Barrier;
-    use tokio::time::timeout;

    async fn setup_database() -> (tempfile::TempDir, ListingDatabase) {
        let tempdir = tempdir().unwrap();
@@ -1330,114 +1324,6 @@ mod tests {
        (tempdir, db)
    }

-    struct BarrierScannable {
-        batch: RecordBatch,
-        barrier: Arc<Barrier>,
-    }
-
-    impl Scannable for BarrierScannable {
-        fn schema(&self) -> SchemaRef {
-            self.batch.schema()
-        }
-
-        fn scan_as_stream(&mut self) -> SendableRecordBatchStream {
-            let batch = self.batch.clone();
-            let schema = batch.schema();
-            let barrier = self.barrier.clone();
-            Box::pin(SimpleRecordBatchStream {
-                schema,
-                stream: once(async move {
-                    barrier.wait().await;
-                    Ok(batch)
-                }),
-            })
-        }
-    }
-
-    fn create_request(name: &str, data: Box<dyn Scannable>) -> CreateTableRequest {
-        CreateTableRequest {
-            name: name.to_string(),
-            namespace_path: vec![],
-            data,
-            mode: CreateTableMode::Create,
-            write_options: Default::default(),
-            location: None,
-            namespace_client: None,
-        }
-    }
-
-    #[tokio::test]
-    async fn test_create_ignores_uncommitted_storage_without_manifest() {
-        let (tmp_dir, db) = setup_database().await;
-        let data_dir = tmp_dir.path().join("test.lance/data");
-        std::fs::create_dir_all(&data_dir).unwrap();
-        std::fs::write(data_dir.join("orphan.lance"), b"uncommitted").unwrap();
-
-        let schema = Arc::new(Schema::new(vec![Field::new("id", DataType::Int32, false)]));
-        let batch =
-            RecordBatch::try_new(schema, vec![Arc::new(Int32Array::from(vec![1]))]).unwrap();
-
-        let table = db
-            .create_table(create_request("test", Box::new(batch)))
-            .await
-            .unwrap();
-        assert_eq!(table.count_rows(None).await.unwrap(), 1);
-    }
-
-    #[tokio::test]
-    async fn test_concurrent_create_is_arbitrated_by_manifest_commit() {
-        let uri = format!("memory:///concurrent-create-{}", uuid::Uuid::new_v4());
-        let db = crate::connect(&uri).execute().await.unwrap();
-        let store: Arc<dyn object_store::ObjectStore> =
-            Arc::new(object_store::memory::InMemory::new());
-        let table_url = url::Url::parse("memory:///database/test.lance").unwrap();
-        let schema = Arc::new(Schema::new(vec![Field::new("id", DataType::Int32, false)]));
-        let batch =
-            RecordBatch::try_new(schema, vec![Arc::new(Int32Array::from(vec![1]))]).unwrap();
-        let barrier = Arc::new(Barrier::new(2));
-
-        #[allow(deprecated)]
-        let request = |batch, barrier| {
-            let mut request = create_request("test", Box::new(BarrierScannable { batch, barrier }));
-            request.write_options = WriteOptions {
-                lance_write_params: Some(lance::dataset::WriteParams {
-                    store_params: Some(ObjectStoreParams {
-                        object_store: Some((store.clone(), table_url.clone())),
-                        ..Default::default()
-                    }),
-                    commit_handler: Some(Arc::new(
-                        lance_table::io::commit::ConditionalPutCommitHandler,
-                    )),
-                    ..Default::default()
-                }),
-            };
-            request
-        };
-
-        let left = db
-            .database()
-            .create_table(request(batch.clone(), barrier.clone()));
-        let right = db.database().create_table(request(batch, barrier));
-        let (left, right) = timeout(Duration::from_secs(30), async { tokio::join!(left, right) })
-            .await
-            .expect("concurrent creates deadlocked");
-
-        let results = [left, right];
-        assert_eq!(
-            results.iter().filter(|result| result.is_ok()).count(),
-            1,
-            "expected one successful create, got {results:?}"
-        );
-        assert_eq!(
-            results
-                .iter()
-                .filter(|result| matches!(result, Err(Error::TableAlreadyExists { .. })))
-                .count(),
-            1,
-            "expected one manifest conflict, got {results:?}"
-        );
-    }
-
    #[tokio::test]
    async fn test_listing_database_root_ops_do_not_create_manifest() {
        let tempdir = tempdir().unwrap();
@@ -12,8 +12,7 @@ use lance_encoding::decoder::{DecoderPlugins, FilterExpression};
 use lance_file::{
    reader::{FileReader, FileReaderOptions},
    version::ConcreteFileVersion,
-    versions,
-    writer::FileWriterOptions,
+    writer::{FileWriter, FileWriterOptions},
 };
 use lance_io::{
    ReadBatchParams,
@@ -154,11 +153,13 @@ impl Shuffler {
                    source: None,
                })?;
            let object_writer = object_store.create(&path).await?;
-            let writer = versions::create_writer(
-                ConcreteFileVersion::V2_1,
+            let writer = FileWriter::try_new(
                object_writer,
                schema.clone(),
-                FileWriterOptions::default(),
+                FileWriterOptions {
+                    format_version: Some(ConcreteFileVersion::V2_1.into()),
+                    ..Default::default()
+                },
            )?;
            file_writers.push(writer);
        }
@@ -71,14 +71,6 @@ pub enum Error {
    IndexNotFound { name: String },
    #[snafu(display("Embedding function '{name}' was not found. : {reason}"))]
    EmbeddingFunctionNotFound { name: String, reason: String },
-    #[snafu(display("Column '{name}' was not found"))]
-    ColumnNotFound { name: String },
-    #[snafu(display("Column '{name}' already exists"))]
-    ColumnAlreadyExists { name: String },
-    #[snafu(display("Column '{name}' is not a computed column"))]
-    NotAComputedColumn { name: String },
-    #[snafu(display("Invalid expression for column '{column}': {message}"))]
-    InvalidExpression { column: String, message: String },

    #[snafu(display("Table '{name}' already exists"))]
    TableAlreadyExists { name: String },
@@ -141,7 +141,7 @@ impl SpawnedJob {
                Ok(Err(err)) => Outcome::Failed(Arc::new(err)),
                Err(err) if err.is_cancelled() => Outcome::Cancelled,
                Err(err) => Outcome::Failed(Arc::new(Error::Runtime {
-                    message: format!("job task failed: {err}"),
+                    message: format!("index job task failed: {err}"),
                })),
            };
            let _ = tx.send(Some(outcome));
@@ -19,15 +19,6 @@ const ARROW_FILE_CONTENT_TYPE: &str = "application/vnd.apache.arrow.file";
 #[cfg(test)]
 const JSON_CONTENT_TYPE: &str = "application/json";

-fn extract_job_id(body: &str) -> Option<String> {
-    serde_json::from_str::<serde_json::Value>(body)
-        .ok()?
-        .get("job_id")?
-        .as_str()
-        .filter(|job_id| !job_id.is_empty())
-        .map(str::to_string)
-}
-
 pub use client::{ClientConfig, HeaderProvider, RetryConfig, TimeoutConfig, TlsConfig};
 pub use db::{RemoteDatabaseOptions, RemoteDatabaseOptionsBuilder};
 pub use oauth::{OAuthConfig, OAuthFlow, OAuthHeaderProvider};
@@ -9,7 +9,6 @@ use http::StatusCode;
 use lance_io::object_store::StorageOptions;
 use lance_namespace_impls::{DynamicContextProvider, OperationInfo};
 use moka::future::Cache;
-use reqwest::Response;
 use reqwest::header::CONTENT_TYPE;

 use lance_namespace::models::{
@@ -24,17 +23,15 @@ use crate::database::{
    JobDescription, JobInfo, OpenTableRequest, ReadConsistency, TableNamesRequest,
 };
 use crate::error::Result;
-use crate::job::Job;
-use crate::remote::job::RemoteJob;
 use crate::remote::util::stream_as_body;
 use crate::table::BaseTable;

+use super::ARROW_STREAM_CONTENT_TYPE;
 use super::client::{
    ClientConfig, HeaderProvider, HttpSend, RequestResultExt, RestfulLanceDbClient, Sender,
 };
 use super::table::RemoteTable;
 use super::util::parse_server_version;
-use super::{ARROW_STREAM_CONTENT_TYPE, extract_job_id};

 // Request structure for the remote clone table API
 #[derive(serde::Serialize)]
@@ -329,22 +326,6 @@ impl RemoteDatabase {
    }
 }

-impl<S: HttpSend> RemoteDatabase<S> {
-    async fn submit_drop_table(
-        &self,
-        name: &str,
-        namespace_path: &[String],
-    ) -> Result<(String, Response)> {
-        let identifier = build_table_identifier(name, namespace_path, &self.client.id_delimiter);
-        let cache_key = build_cache_key(name, namespace_path);
-        let req = self.client.post(&format!("/v1/table/{}/drop/", identifier));
-        let (request_id, resp) = self.client.send(req).await?;
-        let resp = self.client.check_response(&request_id, resp).await?;
-        self.table_cache.remove(&cache_key).await;
-        Ok((request_id, resp))
-    }
-}
-
 #[cfg(all(test, feature = "remote"))]
 mod test_utils {
    use super::*;
@@ -913,28 +894,13 @@ impl<S: HttpSend> Database for RemoteDatabase<S> {
    }

    async fn drop_table(&self, name: &str, namespace_path: &[String]) -> Result<()> {
-        self.submit_drop_table(name, namespace_path)
-            .await
-            .map(|_| ())
-    }
-
-    async fn drop_table_async(&self, name: &str, namespace_path: &[String]) -> Result<Job> {
-        let (request_id, response) = self.submit_drop_table(name, namespace_path).await?;
-        let status = response.status();
-        let body = response.text().await.err_to_http(request_id.clone())?;
-        let job_id = extract_job_id(&body);
-        Ok(match job_id {
-            Some(job_id) => Job::new(Box::new(RemoteJob::new(self.client.clone(), job_id))),
-            None if status == StatusCode::ACCEPTED => {
-                return Err(Error::Http {
-                    source: "asynchronous drop-table response did not contain a valid job_id"
-                        .into(),
-                    request_id,
-                    status_code: Some(status),
-                });
-            }
-            None => Job::new_done(),
-        })
+        let identifier = build_table_identifier(name, namespace_path, &self.client.id_delimiter);
+        let cache_key = build_cache_key(name, namespace_path);
+        let req = self.client.post(&format!("/v1/table/{}/drop/", identifier));
+        let (request_id, resp) = self.client.send(req).await?;
+        self.client.check_response(&request_id, resp).await?;
+        self.table_cache.remove(&cache_key).await;
+        Ok(())
    }

    async fn drop_all_tables(&self, namespace_path: &[String]) -> Result<()> {
@@ -1526,67 +1492,6 @@ mod tests {
        // NOTE: the API will return 200 even if the table does not exist. So we shouldn't expect 404.
    }

-    #[tokio::test]
-    async fn test_drop_table_does_not_read_response_body() {
-        let conn = Connection::new_with_handler(|_| {
-            http::Response::builder()
-                .status(200)
-                .body(vec![0xff])
-                .unwrap()
-        });
-
-        conn.drop_table("table1", &[]).await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn test_drop_table_async_returns_job() {
-        let conn = Connection::new_with_handler(|request| {
-            assert_eq!(request.method(), &reqwest::Method::POST);
-            assert_eq!(request.url().path(), "/v1/table/table1/drop/");
-            http::Response::builder()
-                .status(202)
-                .body(r#"{"job_id":"drop-job-123"}"#)
-                .unwrap()
-        });
-
-        let job = conn.drop_table_async("table1", &[]).await.unwrap();
-        assert_eq!(job.id(), Some("drop-job-123"));
-    }
-
-    #[tokio::test]
-    async fn test_drop_table_async_old_server_returns_done_job() {
-        let conn = Connection::new_with_handler(|_| {
-            http::Response::builder().status(200).body("").unwrap()
-        });
-
-        let job = conn.drop_table_async("table1", &[]).await.unwrap();
-        assert_eq!(job.id(), None);
-        assert_eq!(job.status().await.unwrap(), "finished");
-    }
-
-    #[tokio::test]
-    async fn test_drop_table_async_rejects_accepted_response_without_job_id() {
-        let conn = Connection::new_with_handler(|_| {
-            http::Response::builder().status(202).body("{}").unwrap()
-        });
-
-        let error = conn.drop_table_async("table1", &[]).await.err().unwrap();
-        assert!(error.to_string().contains("valid job_id"));
-    }
-
-    #[tokio::test]
-    async fn test_drop_table_async_rejects_empty_job_id() {
-        let conn = Connection::new_with_handler(|_| {
-            http::Response::builder()
-                .status(202)
-                .body(r#"{"job_id":""}"#)
-                .unwrap()
-        });
-
-        let error = conn.drop_table_async("table1", &[]).await.err().unwrap();
-        assert!(error.to_string().contains("valid job_id"));
-    }
-
    #[tokio::test]
    async fn test_rename_table() {
        let conn = Connection::new_with_handler(|request| {
@@ -8,7 +8,7 @@ use self::insert::{RemoteWriteExec, WriteOp};
 use super::client::RequestResultExt;
 use super::client::{HttpSend, RestfulLanceDbClient, Sender};
 use super::db::ServerVersion;
-use super::{ARROW_FILE_CONTENT_TYPE, ARROW_STREAM_CONTENT_TYPE, extract_job_id};
+use super::{ARROW_FILE_CONTENT_TYPE, ARROW_STREAM_CONTENT_TYPE};
 use crate::blob::BlobFile;
 use crate::data::scannable::{PeekedScannable, Scannable, estimate_write_partitions};
 use crate::expr::expr_to_sql_string;
@@ -33,9 +33,7 @@ use crate::table::lsm_stats::GetLsmStatsResponse;
 use crate::table::merge::MergeFilter;
 use crate::table::query::create_multi_vector_plan;
 use crate::table::write_progress::FinishOnDrop;
-use crate::table::{
-    AlterColumnsResult, FieldMetadataUpdate, RefreshColumnResult, UpdateFieldMetadataResult,
-};
+use crate::table::{AlterColumnsResult, FieldMetadataUpdate, UpdateFieldMetadataResult};
 use crate::table::{AnyQuery, Filter, Predicate, PreprocessingOutput, TableStatistics};
 use crate::utils::background_cache::BackgroundCache;
 use crate::utils::{
@@ -142,40 +140,6 @@ impl FreshnessHeaders {
    }
 }

-/// A backfill job whose successful wait establishes a read-freshness
-/// baseline on the submitting handle, so a later read cannot be served
-/// from a cache older than the completed fill. A handle pinned by checkout
-/// at completion keeps its time-travel view instead.
-struct FreshnessJob<S: HttpSend> {
-    inner: RemoteJob<S>,
-    freshness: Arc<Mutex<FreshnessState>>,
-    version: Arc<RwLock<Option<u64>>>,
-}
-
-#[async_trait]
-impl<S: HttpSend> crate::job::JobHandle for FreshnessJob<S> {
-    fn id(&self) -> Option<&str> {
-        crate::job::JobHandle::id(&self.inner)
-    }
-
-    async fn status(&self) -> Result<String> {
-        crate::job::JobHandle::status(&self.inner).await
-    }
-
-    async fn wait(&self) -> Result<()> {
-        crate::job::JobHandle::wait(&self.inner).await?;
-        let version = self.version.read().await;
-        if version.is_none() {
-            self.freshness.lock().unwrap().checkout_baseline = Some(SystemTime::now());
-        }
-        Ok(())
-    }
-
-    async fn cancel(&self) -> Result<()> {
-        crate::job::JobHandle::cancel(&self.inner).await
-    }
-}
-
 fn compute_min_timestamp(
    state: &FreshnessState,
    interval: Option<Duration>,
@@ -310,10 +274,10 @@ pub struct RemoteTable<S: HttpSend = Sender> {
    identifier: String,
    server_version: ServerVersion,

-    version: Arc<RwLock<Option<u64>>>,
+    version: RwLock<Option<u64>>,
    location: RwLock<Option<String>>,
    schema_cache: BackgroundCache<SchemaRef, Error>,
-    freshness: Arc<Mutex<FreshnessState>>,
+    freshness: Mutex<FreshnessState>,
    /// The branch this handle is scoped to, or `None` for the main branch.
    /// Stamped onto every branch-accepting request so reads and writes resolve
    /// on the branch's own version chain rather than main's.
@@ -428,7 +392,13 @@ impl<S: HttpSend> RemoteTable<S> {
            .text()
            .await
            .ok()
-            .and_then(|body| extract_job_id(&body));
+            .and_then(|body| serde_json::from_str::<serde_json::Value>(&body).ok())
+            .and_then(|value| {
+                value
+                    .get("job_id")
+                    .and_then(|id| id.as_str())
+                    .map(str::to_string)
+            });

        if let Some(wait_timeout) = index.wait_timeout {
            let index_name = index.name.unwrap_or_else(|| format!("{}_idx", column));
@@ -451,10 +421,10 @@ impl<S: HttpSend> RemoteTable<S> {
            namespace,
            identifier,
            server_version,
-            version: Arc::new(RwLock::new(None)),
+            version: RwLock::new(None),
            location: RwLock::new(None),
            schema_cache: BackgroundCache::new(SCHEMA_CACHE_TTL, SCHEMA_CACHE_REFRESH_WINDOW),
-            freshness: Arc::new(Mutex::new(FreshnessState::default())),
+            freshness: Mutex::new(FreshnessState::default()),
            branch: None,
        }
    }
@@ -483,10 +453,10 @@ impl<S: HttpSend> RemoteTable<S> {
            namespace: self.namespace.clone(),
            identifier: self.identifier.clone(),
            server_version: self.server_version.clone(),
-            version: Arc::new(RwLock::new(None)),
+            version: RwLock::new(None),
            location: RwLock::new(None),
            schema_cache: BackgroundCache::new(SCHEMA_CACHE_TTL, SCHEMA_CACHE_REFRESH_WINDOW),
-            freshness: Arc::new(Mutex::new(FreshnessState::default())),
+            freshness: Mutex::new(FreshnessState::default()),
            branch,
        }
    }
@@ -1304,10 +1274,10 @@ mod test_utils {
                namespace: vec![],
                identifier: name,
                server_version: version.map(ServerVersion).unwrap_or_default(),
-                version: Arc::new(RwLock::new(None)),
+                version: RwLock::new(None),
                location: RwLock::new(None),
                schema_cache: BackgroundCache::new(SCHEMA_CACHE_TTL, SCHEMA_CACHE_REFRESH_WINDOW),
-                freshness: Arc::new(Mutex::new(FreshnessState::default())),
+                freshness: Mutex::new(FreshnessState::default()),
                branch: None,
            }
        }
@@ -1328,10 +1298,10 @@ mod test_utils {
                namespace: vec![],
                identifier: name,
                server_version: ServerVersion::default(),
-                version: Arc::new(RwLock::new(None)),
+                version: RwLock::new(None),
                location: RwLock::new(None),
                schema_cache: BackgroundCache::new(SCHEMA_CACHE_TTL, SCHEMA_CACHE_REFRESH_WINDOW),
-                freshness: Arc::new(Mutex::new(FreshnessState::default())),
+                freshness: Mutex::new(FreshnessState::default()),
                branch: None,
            }
        }
@@ -1361,10 +1331,10 @@ mod test_utils {
                namespace: vec![],
                identifier: name,
                server_version: version.map(ServerVersion).unwrap_or_default(),
-                version: Arc::new(RwLock::new(None)),
+                version: RwLock::new(None),
                location: RwLock::new(None),
                schema_cache: BackgroundCache::new(SCHEMA_CACHE_TTL, SCHEMA_CACHE_REFRESH_WINDOW),
-                freshness: Arc::new(Mutex::new(FreshnessState::default())),
+                freshness: Mutex::new(FreshnessState::default()),
                branch: None,
            }
        }
@@ -2550,9 +2520,9 @@ impl<S: HttpSend> BaseTable for RemoteTable<S> {
        self.check_mutable().await?;

        // Map the spec onto the server's request DTO. `sharding` is internally
-        // tagged on `mode` to mirror sophon's `Sharding` enum. A null
-        // `maintained_indexes` asks the server to resolve every maintainable
-        // index at HEAD; a list is verbatim, an empty one meaning none.
+        // tagged on `mode` to mirror sophon's `Sharding` enum; `maintained_indexes`
+        // and `writer_config_defaults` are sent verbatim (an empty list means "no
+        // maintained indexes", not "default to all").
        let sharding = match &spec {
            LsmWriteSpec::Bucket {
                column,
@@ -2744,86 +2714,6 @@ impl<S: HttpSend> BaseTable for RemoteTable<S> {
        }
    }

-    async fn add_computed_columns(&self, columns: &[(String, String)]) -> Result<AddColumnsResult> {
-        self.check_mutable().await?;
-        // The server plans the declaration: expression validation, type
-        // inference and the persisted binding all happen there.
-        let entries = columns
-            .iter()
-            .map(
-                |(name, expression)| lance_namespace::models::AddColumnsEntry {
-                    name: name.clone(),
-                    computed: Some(Some(expression.clone())),
-                    ..Default::default()
-                },
-            )
-            .collect::<Vec<_>>();
-        let mut body = serde_json::json!({ "new_columns": entries });
-        self.apply_branch_body(&mut body);
-        let request = self
-            .client
-            .post(&format!("/v1/table/{}/add_columns/", self.identifier))
-            .json(&body);
-        let (request_id, response) = self.send(request, true).await?;
-        let response = self.check_table_response(&request_id, response).await?;
-        let body = response.text().await.err_to_http(request_id.clone())?;
-
-        if body.trim().is_empty() {
-            // Backward compatible with old servers
-            return Ok(AddColumnsResult { version: 0 });
-        }
-
-        let result: AddColumnsResult = serde_json::from_str(&body).map_err(|e| Error::Http {
-            source: format!("Failed to parse add_columns response: {}", e).into(),
-            request_id,
-            status_code: None,
-        })?;
-
-        self.invalidate_schema_cache();
-        self.track_write_version(result.version);
-
-        Ok(result)
-    }
-
-    async fn refresh_column(&self, _column: &str) -> Result<RefreshColumnResult> {
-        // The server runs a refresh as a job and does not report a fill
-        // count, so the blocking form has no honest result to return.
-        Err(Error::NotSupported {
-            message: "a remote refresh runs as a server job; use refresh_column_async and \
-                      wait on the returned handle"
-                .into(),
-        })
-    }
-
-    async fn refresh_column_async(&self, column: &str) -> Result<Job> {
-        self.check_mutable().await?;
-        let mut body = serde_json::json!({ "column": column });
-        self.apply_branch_body(&mut body);
-        let request = self
-            .client
-            .post(&format!("/v1/table/{}/backfill_column", self.identifier))
-            .json(&body);
-        let (request_id, response) = self.send(request, true).await?;
-        let response = self.check_table_response(&request_id, response).await?;
-        let body = response.text().await.err_to_http(request_id.clone())?;
-
-        #[derive(serde::Deserialize)]
-        struct BackfillResponse {
-            job_id: String,
-        }
-        let response: BackfillResponse = serde_json::from_str(&body).map_err(|e| Error::Http {
-            source: format!("Failed to parse backfill_column response: {}", e).into(),
-            request_id,
-            status_code: None,
-        })?;
-
-        Ok(Job::new(Box::new(FreshnessJob {
-            inner: RemoteJob::new(self.client.clone(), response.job_id),
-            freshness: self.freshness.clone(),
-            version: self.version.clone(),
-        })))
-    }
-
    async fn alter_columns(&self, alterations: &[ColumnAlteration]) -> Result<AlterColumnsResult> {
        self.check_mutable().await?;
        let body = alterations
@@ -6065,18 +5955,17 @@ mod tests {
            .await
            .unwrap();

-        // Positions are relative to the first retained token, so dropping the
-        // leading "hello" stop word does not shift the remaining tokens.
+        // Lance 10 retains original token positions after stop-word removal.
        assert_eq!(
            tokens,
            vec![
                FtsToken {
                    text: "こんにちは".to_string(),
-                    position: 0,
+                    position: 1,
                },
                FtsToken {
                    text: "世界".to_string(),
-                    position: 1,
+                    position: 2,
                },
            ]
        );
@@ -6565,346 +6454,6 @@ mod tests {
        assert_eq!(result.version, if old_server { 0 } else { 43 });
    }

-    /// A declaration is sent as `{name, computed}` entries for the server to
-    /// plan; the client never types the expression itself.
-    #[tokio::test]
-    async fn test_add_computed_columns_sends_the_expression() {
-        let table = Table::new_with_handler("my_table", |request| {
-            assert_eq!(request.method(), "POST");
-            assert_eq!(request.url().path(), "/v1/table/my_table/add_columns/");
-            let body = request.body().unwrap().as_bytes().unwrap();
-            let value: serde_json::Value = serde_json::from_slice(body).unwrap();
-            assert_eq!(
-                value["new_columns"],
-                serde_json::json!([{"name": "doubled", "computed": "x * 2"}])
-            );
-            http::Response::builder()
-                .status(200)
-                .body(r#"{"version": 7}"#)
-                .unwrap()
-        });
-
-        let result = table
-            .add_columns()
-            .computed("doubled", "x * 2")
-            .execute()
-            .await
-            .unwrap();
-        assert_eq!(result.version, 7);
-    }
-
-    /// A remote refresh is a server job: the async form returns its handle,
-    /// and the blocking form refuses rather than invent a fill count.
-    #[tokio::test]
-    async fn test_refresh_column_async_submits_a_backfill_job() {
-        let table = Table::new_with_handler("my_table", |request| {
-            assert_eq!(request.method(), "POST");
-            assert_eq!(request.url().path(), "/v1/table/my_table/backfill_column");
-            let body = request.body().unwrap().as_bytes().unwrap();
-            let value: serde_json::Value = serde_json::from_slice(body).unwrap();
-            assert_eq!(value["column"], "doubled");
-            http::Response::builder()
-                .status(202)
-                .body(r#"{"job_id": "j-42"}"#)
-                .unwrap()
-        });
-
-        let job = table.refresh_column_async("doubled").await.unwrap();
-        assert_eq!(job.id(), Some("j-42"));
-
-        let err = table.refresh_column("doubled").await.unwrap_err();
-        assert!(
-            matches!(&err, Error::NotSupported { message }
-                if message.contains("refresh_column_async")),
-            "{err:?}"
-        );
-    }
-
-    /// The gate's reproducer: after a successful wait, a same-handle read
-    /// must carry a freshness baseline so a stale server cache cannot serve
-    /// the pre-backfill snapshot.
-    #[tokio::test]
-    async fn test_backfill_wait_establishes_read_freshness() {
-        let saw_min_timestamp = Arc::new(std::sync::atomic::AtomicBool::new(false));
-        let saw = saw_min_timestamp.clone();
-        let table =
-            Table::new_with_handler("my_table", move |request| match request.url().path() {
-                "/v1/table/my_table/backfill_column" => http::Response::builder()
-                    .status(202)
-                    .body(r#"{"job_id": "j-7"}"#.to_string())
-                    .unwrap(),
-                "/v1/jobs/describe" => http::Response::builder()
-                    .status(200)
-                    .body(r#"{"job_id": "j-7", "job_state": "DONE"}"#.to_string())
-                    .unwrap(),
-                "/v1/table/my_table/count_rows/" => {
-                    saw.store(
-                        request.headers().contains_key("x-lancedb-min-timestamp"),
-                        std::sync::atomic::Ordering::SeqCst,
-                    );
-                    http::Response::builder()
-                        .status(200)
-                        .body("1".to_string())
-                        .unwrap()
-                }
-                path => panic!("unexpected request: {path}"),
-            });
-
-        let job = table.refresh_column_async("doubled").await.unwrap();
-        job.wait().await.unwrap();
-        table.count_rows(None).await.unwrap();
-        assert!(
-            saw_min_timestamp.load(std::sync::atomic::Ordering::SeqCst),
-            "read after wait carried no freshness baseline"
-        );
-    }
-
-    /// A checkout after submission wins over the completion fence: the
-    /// pinned view must not regain a timestamp floor from the job.
-    #[tokio::test]
-    async fn test_checkout_after_submit_beats_the_completion_fence() {
-        let saw_min_timestamp = Arc::new(std::sync::atomic::AtomicBool::new(false));
-        let saw = saw_min_timestamp.clone();
-        let table =
-            Table::new_with_handler("my_table", move |request| match request.url().path() {
-                "/v1/table/my_table/backfill_column" => http::Response::builder()
-                    .status(202)
-                    .body(r#"{"job_id": "j-8"}"#.to_string())
-                    .unwrap(),
-                "/v1/jobs/describe" => http::Response::builder()
-                    .status(200)
-                    .body(r#"{"job_id": "j-8", "job_state": "DONE"}"#.to_string())
-                    .unwrap(),
-                "/v1/table/my_table/describe/" => {
-                    let schema = Schema::new(vec![Field::new("x", DataType::Int32, true)]);
-                    http::Response::builder()
-                        .status(200)
-                        .body(describe_response(&schema))
-                        .unwrap()
-                }
-                "/v1/table/my_table/count_rows/" => {
-                    saw.store(
-                        request.headers().contains_key("x-lancedb-min-timestamp"),
-                        std::sync::atomic::Ordering::SeqCst,
-                    );
-                    http::Response::builder()
-                        .status(200)
-                        .body("1".to_string())
-                        .unwrap()
-                }
-                path => panic!("unexpected request: {path}"),
-            });
-
-        let job = table.refresh_column_async("doubled").await.unwrap();
-        table.checkout(3).await.unwrap();
-        job.wait().await.unwrap();
-        table.count_rows(None).await.unwrap();
-        assert!(
-            !saw_min_timestamp.load(std::sync::atomic::Ordering::SeqCst),
-            "completion fence overrode an explicit checkout"
-        );
-    }
-
-    /// Tag checkout resets freshness state wholesale; the fence must not
-    /// survive it.
-    #[tokio::test]
-    async fn test_tag_checkout_after_submit_beats_the_completion_fence() {
-        let saw_min_timestamp = Arc::new(std::sync::atomic::AtomicBool::new(false));
-        let saw = saw_min_timestamp.clone();
-        let table =
-            Table::new_with_handler("my_table", move |request| match request.url().path() {
-                "/v1/table/my_table/backfill_column" => http::Response::builder()
-                    .status(202)
-                    .body(r#"{"job_id": "j-9"}"#.to_string())
-                    .unwrap(),
-                "/v1/jobs/describe" => http::Response::builder()
-                    .status(200)
-                    .body(r#"{"job_id": "j-9", "job_state": "DONE"}"#.to_string())
-                    .unwrap(),
-                "/v1/table/my_table/tags/version/" => http::Response::builder()
-                    .status(200)
-                    .body(r#"{"version": 5}"#.to_string())
-                    .unwrap(),
-                "/v1/table/my_table/describe/" => {
-                    let schema = Schema::new(vec![Field::new("x", DataType::Int32, true)]);
-                    http::Response::builder()
-                        .status(200)
-                        .body(describe_response(&schema))
-                        .unwrap()
-                }
-                "/v1/table/my_table/count_rows/" => {
-                    saw.store(
-                        request.headers().contains_key("x-lancedb-min-timestamp"),
-                        std::sync::atomic::Ordering::SeqCst,
-                    );
-                    http::Response::builder()
-                        .status(200)
-                        .body("1".to_string())
-                        .unwrap()
-                }
-                path => panic!("unexpected request: {path}"),
-            });
-
-        let job = table.refresh_column_async("doubled").await.unwrap();
-        table.checkout_tag("v1").await.unwrap();
-        job.wait().await.unwrap();
-        table.count_rows(None).await.unwrap();
-        assert!(
-            !saw_min_timestamp.load(std::sync::atomic::Ordering::SeqCst),
-            "completion fence overrode a tag checkout"
-        );
-    }
-
-    /// A checkout landing while the submission request is in flight advances
-    /// the epoch past the token captured at submit.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_checkout_during_submission_beats_the_completion_fence() {
-        let saw_min_timestamp = Arc::new(std::sync::atomic::AtomicBool::new(false));
-        let saw = saw_min_timestamp.clone();
-        let (release_tx, release_rx) = std::sync::mpsc::channel::<()>();
-        let release_rx = Arc::new(std::sync::Mutex::new(release_rx));
-        let (arrived_tx, arrived_rx) = std::sync::mpsc::channel::<()>();
-        let arrived_tx = Arc::new(std::sync::Mutex::new(arrived_tx));
-        let table = Table::new_with_handler("my_table", move |request| {
-            match request.url().path() {
-                "/v1/table/my_table/backfill_column" => {
-                    // Signal arrival, then hold the response until the
-                    // test's checkout completes.
-                    arrived_tx.lock().unwrap().send(()).unwrap();
-                    release_rx
-                        .lock()
-                        .unwrap()
-                        .recv_timeout(std::time::Duration::from_secs(10))
-                        .unwrap();
-                    http::Response::builder()
-                        .status(202)
-                        .body(r#"{"job_id": "j-10"}"#.to_string())
-                        .unwrap()
-                }
-                "/v1/jobs/describe" => http::Response::builder()
-                    .status(200)
-                    .body(r#"{"job_id": "j-10", "job_state": "DONE"}"#.to_string())
-                    .unwrap(),
-                "/v1/table/my_table/describe/" => {
-                    let schema = Schema::new(vec![Field::new("x", DataType::Int32, true)]);
-                    http::Response::builder()
-                        .status(200)
-                        .body(describe_response(&schema))
-                        .unwrap()
-                }
-                "/v1/table/my_table/count_rows/" => {
-                    saw.store(
-                        request.headers().contains_key("x-lancedb-min-timestamp"),
-                        std::sync::atomic::Ordering::SeqCst,
-                    );
-                    http::Response::builder()
-                        .status(200)
-                        .body("1".to_string())
-                        .unwrap()
-                }
-                path => panic!("unexpected request: {path}"),
-            }
-        });
-
-        let submit = tokio::spawn({
-            let table = table.clone();
-            async move { table.refresh_column_async("doubled").await }
-        });
-        tokio::task::spawn_blocking(move || {
-            arrived_rx
-                .recv_timeout(std::time::Duration::from_secs(10))
-                .unwrap()
-        })
-        .await
-        .unwrap();
-        table.checkout(7).await.unwrap();
-        release_tx.send(()).unwrap();
-
-        let job = submit.await.unwrap().unwrap();
-        job.wait().await.unwrap();
-        table.count_rows(None).await.unwrap();
-        assert!(
-            !saw_min_timestamp.load(std::sync::atomic::Ordering::SeqCst),
-            "completion fence overrode a checkout that landed mid-submission"
-        );
-    }
-
-    /// checkout_latest keeps the handle on latest, so a completed backfill
-    /// must still establish its post-fill baseline -- strictly later than the
-    /// checkout's own, or a pre-fill cache could still serve.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_checkout_latest_during_submission_keeps_the_fence() {
-        let seen_min_timestamp = Arc::new(std::sync::Mutex::new(None::<String>));
-        let saw = seen_min_timestamp.clone();
-        let (release_tx, release_rx) = std::sync::mpsc::channel::<()>();
-        let release_rx = Arc::new(std::sync::Mutex::new(release_rx));
-        let (arrived_tx, arrived_rx) = std::sync::mpsc::channel::<()>();
-        let arrived_tx = Arc::new(std::sync::Mutex::new(arrived_tx));
-        let table =
-            Table::new_with_handler("my_table", move |request| match request.url().path() {
-                "/v1/table/my_table/backfill_column" => {
-                    arrived_tx.lock().unwrap().send(()).unwrap();
-                    release_rx
-                        .lock()
-                        .unwrap()
-                        .recv_timeout(std::time::Duration::from_secs(10))
-                        .unwrap();
-                    http::Response::builder()
-                        .status(202)
-                        .body(r#"{"job_id": "j-11"}"#.to_string())
-                        .unwrap()
-                }
-                "/v1/jobs/describe" => http::Response::builder()
-                    .status(200)
-                    .body(r#"{"job_id": "j-11", "job_state": "DONE"}"#.to_string())
-                    .unwrap(),
-                "/v1/table/my_table/count_rows/" => {
-                    *saw.lock().unwrap() = request
-                        .headers()
-                        .get("x-lancedb-min-timestamp")
-                        .map(|v| v.to_str().unwrap().to_string());
-                    http::Response::builder()
-                        .status(200)
-                        .body("1".to_string())
-                        .unwrap()
-                }
-                path => panic!("unexpected request: {path}"),
-            });
-
-        let submit = tokio::spawn({
-            let table = table.clone();
-            async move { table.refresh_column_async("doubled").await }
-        });
-        tokio::task::spawn_blocking(move || {
-            arrived_rx
-                .recv_timeout(std::time::Duration::from_secs(10))
-                .unwrap()
-        })
-        .await
-        .unwrap();
-        table.checkout_latest().await.unwrap();
-        let after_checkout = SystemTime::now();
-        // Real separation between the checkout baseline and completion.
-        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
-        release_tx.send(()).unwrap();
-
-        let job = submit.await.unwrap().unwrap();
-        job.wait().await.unwrap();
-        table.count_rows(None).await.unwrap();
-        let header = seen_min_timestamp
-            .lock()
-            .unwrap()
-            .clone()
-            .expect("no baseline");
-        let sent: SystemTime = chrono::DateTime::parse_from_rfc3339(&header)
-            .unwrap()
-            .into();
-        assert!(
-            sent > after_checkout,
-            "baseline {header} did not advance past the checkout"
-        );
-    }
-
    #[tokio::test]
    async fn test_prewarm_index() {
        let table = Table::new_with_handler("my_table", |request| {
@@ -7049,7 +6598,7 @@ mod tests {
                .unwrap()
        });
        let spec = crate::table::LsmWriteSpec::unsharded()
-            .with_maintained_indexes(vec!["id_idx".to_string()])
+            .with_maintained_indexes(["id_idx"])
            .with_writer_config_defaults([("max_memtable_rows", "1000")]);
        table.set_lsm_write_spec(spec).await.unwrap();
    }
@@ -7068,29 +6617,11 @@ mod tests {
                body["sharding"],
                serde_json::json!({ "mode": "bucket", "column": "id", "num_buckets": 16 })
            );
-            // An unpinned maintained set sends null: resolve server-side.
-            assert_eq!(body["maintained_indexes"], serde_json::Value::Null);
-            http::Response::builder().status(200).body("{}").unwrap()
-        });
-        table
-            .set_lsm_write_spec(crate::table::LsmWriteSpec::bucket("id", 16))
-            .await
-            .unwrap();
-    }
-
-    /// `[]` (none) must stay distinguishable on the wire from null (all).
-    #[tokio::test]
-    async fn test_set_lsm_write_spec_no_maintained_indexes() {
-        let table = Table::new_with_handler("my_table", |request| {
-            let body = request.body().unwrap().as_bytes().unwrap();
-            let body: serde_json::Value = serde_json::from_slice(body).unwrap();
            assert_eq!(body["maintained_indexes"], serde_json::json!([]));
            http::Response::builder().status(200).body("{}").unwrap()
        });
        table
-            .set_lsm_write_spec(
-                crate::table::LsmWriteSpec::bucket("id", 16).with_maintained_indexes(Vec::new()),
-            )
+            .set_lsm_write_spec(crate::table::LsmWriteSpec::bucket("id", 16))
            .await
            .unwrap();
    }
@@ -7169,7 +6700,7 @@ mod tests {
            } => {
                assert_eq!(column, "id");
                assert_eq!(num_buckets, 4);
-                assert_eq!(maintained_indexes, Some(vec!["id_idx".to_string()]));
+                assert_eq!(maintained_indexes, vec!["id_idx".to_string()]);
                assert_eq!(
                    writer_config_defaults
                        .get("durable_write")
@@ -50,6 +50,7 @@ use crate::DistanceType;
 use crate::blob::BlobRangeRequest;
 use crate::data::scannable::{PeekedScannable, Scannable, estimate_write_partitions};
 use crate::database::Database;
+use crate::database::listing::LANCE_FILE_EXTENSION;
 use crate::database::read_freshness::TableFreshness;
 use crate::embeddings::{EmbeddingDefinition, EmbeddingRegistry, MemoryRegistry};
 use crate::error::{Error, Result};
@@ -68,7 +69,6 @@ pub mod add_columns;
 mod add_data;
 pub mod branch_merge;
 pub mod checkpoint;
-pub mod computed_columns;
 mod create_index;
 pub mod datafusion;
 pub(crate) mod dataset;
@@ -78,7 +78,6 @@ pub mod merge;
 pub mod optimize;
 mod primary_key;
 pub mod query;
-pub mod refresh;
 pub mod schema_evolution;
 pub mod update;
 pub mod write_progress;
@@ -92,9 +91,6 @@ pub use branch_merge::{
    MergeBranchResult, MergeBranchStatus, MergePreview, RowCountSummary,
 };
 pub use chrono::Duration;
-pub use computed_columns::{
-    ComputedColumn, ComputedColumnKind, computed_column_from_field, computed_columns,
-};
 pub use delete::DeleteResult;
 use futures::future::join_all;
 pub use lance::dataset::refs::{BranchContents, Ref, TagContents, Tags as LanceTags};
@@ -102,7 +98,6 @@ pub use lance::dataset::scanner::DatasetRecordBatchStream;
 pub use lance_index::optimize::OptimizeOptions;
 pub use lsm_stats::{BucketStats, GenerationStats, LsmStats, MemtableStats};
 pub use optimize::{CompactionOptions, OptimizeAction, OptimizeStats};
-pub use refresh::RefreshColumnResult;
 pub use schema_evolution::{
    AddColumnsResult, AlterColumnsResult, DropColumnsResult, FieldMetadataUpdate,
    UpdateFieldMetadataResult,
@@ -157,6 +152,55 @@ pub(crate) fn map_namespace_lance_error(err: lance::Error, table_name: &str) ->
    }
 }

+/// Map a `lance::Error::DatasetNotFound` for the table at `uri` into a `lancedb::Error`.
+///
+/// Lance reports "there is nothing at this location" and "there is a table directory
+/// here but nothing loadable inside it" with the same error. Only the first is a
+/// `TableNotFound`: a `<name>.lance` directory left behind by an interrupted drop and
+/// re-create is still reported by `Connection::table_names`, so callers need to be able
+/// to tell "never existed" from "exists but is broken".
+///
+/// See <https://github.com/lancedb/lancedb/issues/3127>.
+async fn map_dataset_not_found(
+    uri: &str,
+    name: &str,
+    params: ReadParams,
+    err: lance::Error,
+) -> Error {
+    let name = name.to_string();
+    let source = Box::new(err);
+    if table_dir_exists(uri, params).await.unwrap_or(false) {
+        Error::TableCorrupted { name, source }
+    } else {
+        Error::TableNotFound { name, source }
+    }
+}
+
+/// Whether a table directory is present at `uri`, even though no dataset could be
+/// loaded from it.
+///
+/// This looks for a `<name>.lance` entry in the parent directory, which is exactly what
+/// `ListingDatabase::table_names` lists, so the two APIs agree on whether a table is
+/// present. Probing `uri` itself would not work: object stores have no empty
+/// directories to probe, and on a local filesystem the interesting case is precisely an
+/// empty directory.
+async fn table_dir_exists(uri: &str, params: ReadParams) -> Result<bool> {
+    let (object_store, path, _) = DatasetBuilder::from_uri(uri)
+        .with_read_params(params)
+        .build_object_store()
+        .await?;
+    // Only `*.lance` entries are ever reported as tables, so nothing else can produce
+    // the list-then-open mismatch this guards against.
+    if path.extension() != Some(LANCE_FILE_EXTENSION) {
+        return Ok(false);
+    }
+    let (Some(parent), Some(dir_name)) = (path.parent(), path.filename()) else {
+        return Ok(false);
+    };
+    let entries = object_store.read_dir(parent).await?;
+    Ok(entries.iter().any(|entry| entry.as_str() == dir_name))
+}
+
 /// Defines the type of column
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ColumnKind {
@@ -326,8 +370,6 @@ pub use self::merge::MergeResult;
 /// date) and [`LsmWriteSpec::with_writer_config_defaults`] (default
 /// `ShardWriter` configuration recorded in the MemWAL index).
 ///
-/// A fresh spec maintains every index on the table, resolved on install.
-///
 /// Install a spec with [`Table::set_lsm_write_spec`] and remove it with
 /// [`Table::unset_lsm_write_spec`]. The actual `merge_insert` dispatch
 /// onto the MemWAL writer is a follow-up.
@@ -342,12 +384,9 @@ pub enum LsmWriteSpec {
    Bucket {
        column: String,
        num_buckets: u32,
-        /// Indexes the MemWAL maintains in-memory as rows are appended.
-        ///
-        /// `None` means every index it can maintain, resolved on install — a
-        /// snapshot, so indexes created later need the spec unset and re-set.
-        /// `Some([])` maintains nothing.
-        maintained_indexes: Option<Vec<String>>,
+        /// Names of indexes (already created on the table) that the
+        /// MemWAL should maintain in-memory as rows are appended.
+        maintained_indexes: Vec<String>,
        /// Default `ShardWriter` configuration recorded in the MemWAL index.
        writer_config_defaults: HashMap<String, String>,
    },
@@ -357,41 +396,35 @@ pub enum LsmWriteSpec {
    /// distinct value of `column` becomes its own shard.
    Identity {
        column: String,
-        /// Indexes the MemWAL maintains in-memory as rows are appended.
-        ///
-        /// `None` means every index it can maintain, resolved on install — a
-        /// snapshot, so indexes created later need the spec unset and re-set.
-        /// `Some([])` maintains nothing.
-        maintained_indexes: Option<Vec<String>>,
+        /// Names of indexes (already created on the table) that the
+        /// MemWAL should maintain in-memory as rows are appended.
+        maintained_indexes: Vec<String>,
        /// Default `ShardWriter` configuration recorded in the MemWAL index.
        writer_config_defaults: HashMap<String, String>,
    },
    /// No sharding — every `merge_insert` call writes to a single MemWAL shard.
    Unsharded {
-        /// Indexes the MemWAL maintains in-memory as rows are appended.
-        ///
-        /// `None` means every index it can maintain, resolved on install — a
-        /// snapshot, so indexes created later need the spec unset and re-set.
-        /// `Some([])` maintains nothing.
-        maintained_indexes: Option<Vec<String>>,
+        /// Names of indexes (already created on the table) that the
+        /// MemWAL should maintain in-memory as rows are appended.
+        maintained_indexes: Vec<String>,
        /// Default `ShardWriter` configuration recorded in the MemWAL index.
        writer_config_defaults: HashMap<String, String>,
    },
 }

 impl LsmWriteSpec {
-    /// Construct a hash-bucket sharding spec maintaining every index on the table.
+    /// Construct a hash-bucket sharding spec with no maintained indexes.
    pub fn bucket(column: impl Into<String>, num_buckets: u32) -> Self {
        Self::Bucket {
            column: column.into(),
            num_buckets,
-            maintained_indexes: None,
+            maintained_indexes: Vec::new(),
            writer_config_defaults: HashMap::new(),
        }
    }

    /// Construct an identity-sharding spec (shard by the raw value of
-    /// `column`) maintaining every index on the table.
+    /// `column`) with no maintained indexes.
    ///
    /// `column` must be a deterministic function of the unenforced primary
    /// key: every row with a given primary key must always produce the same
@@ -403,37 +436,28 @@ impl LsmWriteSpec {
    pub fn identity(column: impl Into<String>) -> Self {
        Self::Identity {
            column: column.into(),
-            maintained_indexes: None,
+            maintained_indexes: Vec::new(),
            writer_config_defaults: HashMap::new(),
        }
    }

-    /// Construct an unsharded spec maintaining every index on the table.
+    /// Construct an unsharded spec with no maintained indexes.
    pub fn unsharded() -> Self {
        Self::Unsharded {
-            maintained_indexes: None,
+            maintained_indexes: Vec::new(),
            writer_config_defaults: HashMap::new(),
        }
    }

-    /// Set which indexes the MemWAL maintains.
-    ///
-    /// `None` (the default) resolves to every index on the table at install,
-    /// failing if one cannot be maintained — name the set to install anyway. A
-    /// list is verbatim: each name must already exist and be maintainable, and
-    /// an empty list maintains nothing.
-    ///
-    /// ```
-    /// # use lancedb::table::LsmWriteSpec;
-    /// // Every index the table has when the spec is installed:
-    /// LsmWriteSpec::unsharded().with_maintained_indexes(None);
-    /// // Exactly these:
-    /// LsmWriteSpec::unsharded().with_maintained_indexes(vec!["id_idx".to_string()]);
-    /// // None at all:
-    /// LsmWriteSpec::unsharded().with_maintained_indexes(Vec::new());
-    /// ```
-    pub fn with_maintained_indexes(mut self, indexes: impl Into<Option<Vec<String>>>) -> Self {
-        let indexes = indexes.into();
+    /// Replace the list of indexes the MemWAL should keep up to date as
+    /// rows are appended. Each name must reference an index that already
+    /// exists on the table at the time `set_lsm_write_spec` is called.
+    pub fn with_maintained_indexes<I, S>(mut self, indexes: I) -> Self
+    where
+        I: IntoIterator<Item = S>,
+        S: Into<String>,
+    {
+        let v: Vec<String> = indexes.into_iter().map(Into::into).collect();
        match &mut self {
            Self::Bucket {
                maintained_indexes, ..
@@ -443,7 +467,7 @@ impl LsmWriteSpec {
            }
            | Self::Unsharded {
                maintained_indexes, ..
-            } => *maintained_indexes = indexes,
+            } => *maintained_indexes = v,
        }
        self
    }
@@ -479,9 +503,8 @@ impl LsmWriteSpec {
        self
    }

-    /// Borrow the list of index names this spec asks MemWAL to maintain, or
-    /// `None` when it asks for every index on the table.
-    pub fn maintained_indexes(&self) -> Option<&[String]> {
+    /// Borrow the list of index names this spec asks MemWAL to maintain.
+    pub fn maintained_indexes(&self) -> &[String] {
        match self {
            Self::Bucket {
                maintained_indexes, ..
@@ -491,7 +514,7 @@ impl LsmWriteSpec {
            }
            | Self::Unsharded {
                maintained_indexes, ..
-            } => maintained_indexes.as_deref(),
+            } => maintained_indexes,
        }
    }

@@ -643,15 +666,6 @@ pub trait BaseTable: std::fmt::Display + std::fmt::Debug + Send + Sync {
            message: "set_lsm_write_spec is not supported on this table type".into(),
        })
    }
-    /// Switch this table to required index catch-up, one way.
-    ///
-    /// The default implementation returns `NotSupported`. Implementations
-    /// that support the MemWAL LSM write path must override this.
-    async fn require_mem_wal_index_catchup(&self) -> Result<()> {
-        Err(Error::NotSupported {
-            message: "require_mem_wal_index_catchup is not supported on this table type".into(),
-        })
-    }
    /// Remove the [`LsmWriteSpec`] from this table.
    ///
    /// This is a no-op if no spec is currently set.
@@ -747,34 +761,6 @@ pub trait BaseTable: std::fmt::Display + std::fmt::Debug + Send + Sync {
        transforms: NewColumnTransform,
        read_columns: Option<Vec<String>>,
    ) -> Result<AddColumnsResult>;
-    /// Declare computed columns, each defined by a SQL expression.
-    ///
-    /// Where the declaration is planned depends on the backend: a local table
-    /// validates and types the expression itself, a remote one sends the text
-    /// for the server to plan.
-    async fn add_computed_columns(
-        &self,
-        _columns: &[(String, String)],
-    ) -> Result<AddColumnsResult> {
-        Err(Error::NotSupported {
-            message: "computed columns are not supported on this table type".into(),
-        })
-    }
-    /// Fill a computed column's unfilled rows.
-    ///
-    /// The default returns `NotSupported`; Lance-backed tables override it.
-    async fn refresh_column(&self, _column: &str) -> Result<RefreshColumnResult> {
-        Err(Error::NotSupported {
-            message: "computed columns are supported only on local tables".into(),
-        })
-    }
-    /// Fill a computed column's unfilled rows, returning a [`Job`] tracking
-    /// the operation.
-    async fn refresh_column_async(&self, _column: &str) -> Result<Job> {
-        Err(Error::NotSupported {
-            message: "computed columns are supported only on local tables".into(),
-        })
-    }
    /// Alter columns in the table.
    async fn alter_columns(&self, alterations: &[ColumnAlteration]) -> Result<AlterColumnsResult>;
    /// Drop columns from the table.
@@ -1667,53 +1653,6 @@ impl Table {
        AddColumnsBuilder::new(self.inner.clone())
    }

-    /// Fill the fragments of a computed column that hold no values yet.
-    ///
-    /// Declared with
-    /// [`AddColumnsBuilder::computed`](add_columns::AddColumnsBuilder::computed),
-    /// a column starts empty and gets its values here. Fragments appended
-    /// since the last refresh are filled by the next one; fragments already
-    /// filled are left as they are, so the call is idempotent and does not
-    /// observe a mutated input.
-    ///
-    /// Local tables only: a remote refresh runs as a server job, through
-    /// [`Table::refresh_column_async`].
-    ///
-    /// ```
-    /// # use lancedb::Table;
-    /// # async fn refresh(table: &Table) -> Result<(), Box<dyn std::error::Error>> {
-    /// let result = table.refresh_column("doubled").await?;
-    /// println!("filled {} rows at version {}", result.rows_filled, result.version);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub async fn refresh_column(&self, column: impl AsRef<str>) -> Result<RefreshColumnResult> {
-        self.inner.refresh_column(column.as_ref()).await
-    }
-
-    /// Like [`Table::refresh_column`], but returns a [`Job`] tracking the
-    /// operation instead of blocking until it completes.
-    ///
-    /// The job may already be complete when returned, and callers must not
-    /// assume the column is filled until [`Job::wait`] returns. Invalid input
-    /// -- an unknown column, or one that is not computed -- is reported by
-    /// this call rather than by the job. On local tables the job runs as an
-    /// in-process task; on LanceDB Cloud and Enterprise it is the server's
-    /// backfill job.
-    ///
-    /// ```
-    /// # use lancedb::Table;
-    /// # async fn refresh_in_background(table: &Table) -> Result<(), Box<dyn std::error::Error>> {
-    /// let job = table.refresh_column_async("doubled").await?;
-    /// println!("refresh running: {:?}", job.status().await?);
-    /// job.wait().await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub async fn refresh_column_async(&self, column: impl AsRef<str>) -> Result<Job> {
-        self.inner.refresh_column_async(column.as_ref()).await
-    }
-
    /// Change a column's name or nullability.
    pub async fn alter_columns(
        &self,
@@ -1773,7 +1712,7 @@ impl Table {
    /// # async fn example(table: &Table) -> Result<(), Box<dyn std::error::Error>> {
    /// table
    ///     .set_lsm_write_spec(
-    ///         LsmWriteSpec::bucket("id", 16).with_maintained_indexes(vec!["id_idx".to_string()]),
+    ///         LsmWriteSpec::bucket("id", 16).with_maintained_indexes(["id_idx"]),
    ///     )
    ///     .await?;
    /// # Ok(())
@@ -1783,20 +1722,6 @@ impl Table {
        self.inner.set_lsm_write_spec(spec).await
    }

-    /// Switch this table to required index catch-up, one way.
-    ///
-    /// Separate from [`Self::set_lsm_write_spec`] on purpose: a table carrying
-    /// the bit retains its SSTables until an index records that it holds the
-    /// compacted rows, so turn it on only once something can repair coverage.
-    /// A writer that already holds the dataset can call the equivalent on
-    /// `DatasetMemWalExt` instead; this is the table-level entry point.
-    ///
-    /// Errors if no spec is set, or if the table already records SSTable
-    /// compaction progress from before this protocol.
-    pub async fn require_mem_wal_index_catchup(&self) -> Result<()> {
-        self.inner.require_mem_wal_index_catchup().await
-    }
-
    /// Remove the [`LsmWriteSpec`] from this table, reverting to the standard
    /// `merge_insert` write path.
    ///
@@ -1809,10 +1734,9 @@ impl Table {
    ///
    /// Returns `Ok(None)` when the MemWAL LSM write path is not enabled (no
    /// spec has been set, or it was removed with [`Table::unset_lsm_write_spec`]).
-    /// The returned spec mirrors what was passed to
-    /// [`Table::set_lsm_write_spec`], except that
-    /// [`LsmWriteSpec::maintained_indexes`] always reports the concrete list
-    /// resolved when the spec was set — `None` never round-trips.
+    /// The returned spec — including its [`LsmWriteSpec::maintained_indexes`] and
+    /// [`LsmWriteSpec::writer_config_defaults`] — mirrors what was passed to
+    /// [`Table::set_lsm_write_spec`].
    ///
    /// # Example
    ///
@@ -2474,6 +2398,8 @@ impl NativeTable {
            None => false,
        };

+        // Kept so that a `DatasetNotFound` can be re-checked against storage below.
+        let recovery_params = params.clone();
        let mut builder = DatasetBuilder::from_uri(uri).with_read_params(params);

        // Set up commit handler when managed_versioning is enabled
@@ -2492,12 +2418,7 @@ impl NativeTable {
        let dataset = match builder.load().await {
            Ok(dataset) => dataset,
            Err(e @ lance::Error::DatasetNotFound { .. }) => {
-                // The manifest load is the existence check. A physical prefix may be
-                // from a concurrent or abandoned create, so it cannot refine this error.
-                return Err(Error::TableNotFound {
-                    name: name.to_string(),
-                    source: Box::new(e),
-                });
+                return Err(map_dataset_not_found(uri, name, recovery_params, e).await);
            }
            Err(e) => return Err(e.into()),
        };
@@ -2709,7 +2630,6 @@ impl NativeTable {
        namespace_client: Option<Arc<dyn LanceNamespace>>,
        pushdown_operations: HashSet<NamespaceClientPushdownOperation>,
    ) -> Result<Self> {
-        computed_columns::ensure_no_foreign_declarations(batches.arrow_schema().fields())?;
        // Default params uses format v1.
        let params = params.unwrap_or(WriteParams {
            ..Default::default()
@@ -3158,13 +3078,6 @@ impl BaseTable for NativeTable {
        let ds = self.dataset.get().await?;

        let table_schema = Schema::from(&ds.schema().clone());
-        computed_columns::ensure_not_written(
-            &table_schema,
-            add.data.schema().fields().iter().map(|f| f.name().as_str()),
-        )?;
-        if matches!(add.mode, AddDataMode::Overwrite) {
-            computed_columns::ensure_no_foreign_declarations(add.data.schema().fields())?;
-        }

        let num_partitions = if let Some(parallelism) = add.write_parallelism {
            parallelism
@@ -3325,11 +3238,6 @@ impl BaseTable for NativeTable {
        params: MergeInsertBuilder,
        new_data: Box<dyn RecordBatchReader + Send>,
    ) -> Result<MergeResult> {
-        let source_schema = arrow_array::RecordBatchReader::schema(&new_data);
-        computed_columns::ensure_not_written(
-            &Schema::from(self.dataset.get().await?.schema()),
-            source_schema.fields().iter().map(|f| f.name().as_str()),
-        )?;
        let result = merge::execute_merge_insert(self, params, new_data).await?;
        self.bump_freshness();
        Ok(result)
@@ -3343,10 +3251,6 @@ impl BaseTable for NativeTable {
        merge::lsm::set_lsm_write_spec(self, spec).await
    }

-    async fn require_mem_wal_index_catchup(&self) -> Result<()> {
-        merge::lsm::require_mem_wal_index_catchup(self).await
-    }
-
    async fn unset_lsm_write_spec(&self) -> Result<()> {
        merge::lsm::unset_lsm_write_spec(self).await
    }
@@ -3415,22 +3319,6 @@ impl BaseTable for NativeTable {
        Ok(result)
    }

-    async fn add_computed_columns(&self, columns: &[(String, String)]) -> Result<AddColumnsResult> {
-        let result = schema_evolution::execute_declare(self, columns).await?;
-        self.bump_freshness();
-        Ok(result)
-    }
-
-    async fn refresh_column(&self, column: &str) -> Result<RefreshColumnResult> {
-        let result = refresh::execute_refresh_column(self, column).await?;
-        self.bump_freshness();
-        Ok(result)
-    }
-
-    async fn refresh_column_async(&self, column: &str) -> Result<Job> {
-        refresh::execute_refresh_column_async(self, column).await
-    }
-
    async fn alter_columns(&self, alterations: &[ColumnAlteration]) -> Result<AlterColumnsResult> {
        let result = schema_evolution::execute_alter_columns(self, alterations).await?;
        self.bump_freshness();
@@ -3798,7 +3686,7 @@ pub struct FragmentSummaryStats {
 #[allow(deprecated)]
 mod tests {
    use std::sync::Arc;
-    use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+    use std::sync::atomic::{AtomicBool, Ordering};
    use std::time::Duration;

    use arrow_array::{
@@ -3880,50 +3768,73 @@ mod tests {
        );
    }

-    #[tokio::test]
-    async fn test_open_not_found_when_empty_directory_exists() {
-        let tmp_dir = tempdir().unwrap();
-        let dataset_path = tmp_dir.path().join("test.lance");
-        std::fs::create_dir(&dataset_path).unwrap();
+    /// Write a table and then break it, leaving the `<name>.lance` directory in place.
+    ///
+    /// `remove_all` reproduces an interrupted drop + re-create (the directory is left
+    /// empty); otherwise only the manifests are removed, leaving the data files behind.
+    async fn write_then_corrupt_table(dir: &std::path::Path, remove_all: bool) -> String {
+        let dataset_path = dir.join("test.lance");
+        let uri = dataset_path.to_str().unwrap().to_string();

-        let err = NativeTable::open(dataset_path.to_str().unwrap())
-            .await
-            .unwrap_err();
+        let batch = make_test_batches();
+        let reader = RecordBatchIterator::new(vec![Ok(batch.clone())], batch.schema());
+        Dataset::write(reader, &uri, None).await.unwrap();
+
+        if remove_all {
+            for entry in std::fs::read_dir(&dataset_path).unwrap() {
+                let entry = entry.unwrap();
+                if entry.file_type().unwrap().is_dir() {
+                    std::fs::remove_dir_all(entry.path()).unwrap();
+                } else {
+                    std::fs::remove_file(entry.path()).unwrap();
+                }
+            }
+            assert_eq!(std::fs::read_dir(&dataset_path).unwrap().count(), 0);
+        } else {
+            let versions = dataset_path.join("_versions");
+            assert!(versions.is_dir(), "expected manifests under {versions:?}");
+            std::fs::remove_dir_all(&versions).unwrap();
+            assert!(std::fs::read_dir(&dataset_path).unwrap().count() > 0);
+        }
+
+        uri
+    }
+
+    #[tokio::test]
+    async fn test_open_corrupt_empty_dir() {
+        let tmp_dir = tempdir().unwrap();
+        let uri = write_then_corrupt_table(tmp_dir.path(), true).await;
+
+        let err = NativeTable::open(&uri).await.unwrap_err();
        assert!(
-            matches!(&err, Error::TableNotFound { name, .. } if name == "test"),
+            matches!(&err, Error::TableCorrupted { name, .. } if name == "test"),
            "got {err:?}"
        );
    }

    #[tokio::test]
-    async fn test_open_not_found_when_only_uncommitted_storage_exists() {
+    async fn test_open_corrupt_missing_manifest() {
        let tmp_dir = tempdir().unwrap();
-        let dataset_path = tmp_dir.path().join("test.lance");
-        let data_dir = dataset_path.join("data");
-        std::fs::create_dir_all(&data_dir).unwrap();
-        std::fs::write(data_dir.join("orphan.lance"), b"uncommitted").unwrap();
+        let uri = write_then_corrupt_table(tmp_dir.path(), false).await;

-        let err = NativeTable::open(dataset_path.to_str().unwrap())
-            .await
-            .unwrap_err();
+        let err = NativeTable::open(&uri).await.unwrap_err();
        assert!(
-            matches!(&err, Error::TableNotFound { name, .. } if name == "test"),
+            matches!(&err, Error::TableCorrupted { name, .. } if name == "test"),
            "got {err:?}"
        );
    }

-    /// Listing databases discover physical `*.lance` entries. That snapshot is not an
-    /// authoritative table-existence check: only a committed manifest makes a table
-    /// openable, and the entry could also be concurrently created or dropped.
+    /// A table listed by `table_names()` must not be reported as missing by
+    /// `open_table()`. See <https://github.com/lancedb/lancedb/issues/3127>.
    #[tokio::test]
-    async fn test_table_names_may_include_uncommitted_storage() {
+    async fn test_open_table_corrupt_is_still_listed() {
        let tmp_dir = tempdir().unwrap();
        let db = connect(tmp_dir.path().to_str().unwrap())
            .execute()
            .await
            .unwrap();

-        std::fs::create_dir(tmp_dir.path().join("test.lance")).unwrap();
+        write_then_corrupt_table(tmp_dir.path(), true).await;

        assert_eq!(
            db.table_names().execute().await.unwrap(),
@@ -3931,177 +3842,12 @@ mod tests {
        );
        let err = db.open_table("test").execute().await.unwrap_err();
        assert!(
-            matches!(&err, Error::TableNotFound { name, .. } if name == "test"),
-            "physical storage without a committed manifest is not a table: {err:?}"
-        );
-    }
-
-    #[derive(Debug)]
-    struct ParentListGuardStore {
-        inner: Arc<dyn object_store::ObjectStore>,
-        parent: object_store::path::Path,
-        parent_list_calls: Arc<AtomicUsize>,
-    }
-
-    impl std::fmt::Display for ParentListGuardStore {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            f.write_str("ParentListGuardStore")
-        }
-    }
-
-    #[async_trait::async_trait]
-    #[deny(clippy::missing_trait_methods)]
-    impl object_store::ObjectStore for ParentListGuardStore {
-        async fn put_opts(
-            &self,
-            location: &object_store::path::Path,
-            payload: object_store::PutPayload,
-            opts: object_store::PutOptions,
-        ) -> object_store::Result<object_store::PutResult> {
-            self.inner.put_opts(location, payload, opts).await
-        }
-
-        async fn put_multipart_opts(
-            &self,
-            location: &object_store::path::Path,
-            opts: object_store::PutMultipartOptions,
-        ) -> object_store::Result<Box<dyn object_store::MultipartUpload>> {
-            self.inner.put_multipart_opts(location, opts).await
-        }
-
-        async fn get_opts(
-            &self,
-            location: &object_store::path::Path,
-            options: object_store::GetOptions,
-        ) -> object_store::Result<object_store::GetResult> {
-            self.inner.get_opts(location, options).await
-        }
-
-        async fn get_ranges(
-            &self,
-            location: &object_store::path::Path,
-            ranges: &[std::ops::Range<u64>],
-        ) -> object_store::Result<Vec<bytes::Bytes>> {
-            self.inner.get_ranges(location, ranges).await
-        }
-
-        fn delete_stream(
-            &self,
-            locations: futures::stream::BoxStream<
-                'static,
-                object_store::Result<object_store::path::Path>,
-            >,
-        ) -> futures::stream::BoxStream<'static, object_store::Result<object_store::path::Path>>
-        {
-            self.inner.delete_stream(locations)
-        }
-
-        fn list(
-            &self,
-            prefix: Option<&object_store::path::Path>,
-        ) -> futures::stream::BoxStream<'static, object_store::Result<object_store::ObjectMeta>>
-        {
-            if prefix == Some(&self.parent) {
-                self.parent_list_calls.fetch_add(1, Ordering::Relaxed);
-            }
-            self.inner.list(prefix)
-        }
-
-        fn list_with_offset(
-            &self,
-            prefix: Option<&object_store::path::Path>,
-            offset: &object_store::path::Path,
-        ) -> futures::stream::BoxStream<'static, object_store::Result<object_store::ObjectMeta>>
-        {
-            if prefix == Some(&self.parent) {
-                self.parent_list_calls.fetch_add(1, Ordering::Relaxed);
-            }
-            self.inner.list_with_offset(prefix, offset)
-        }
-
-        async fn list_with_delimiter(
-            &self,
-            prefix: Option<&object_store::path::Path>,
-        ) -> object_store::Result<object_store::ListResult> {
-            if prefix == Some(&self.parent) {
-                self.parent_list_calls.fetch_add(1, Ordering::Relaxed);
-            }
-            self.inner.list_with_delimiter(prefix).await
-        }
-
-        async fn copy_opts(
-            &self,
-            from: &object_store::path::Path,
-            to: &object_store::path::Path,
-            options: object_store::CopyOptions,
-        ) -> object_store::Result<()> {
-            self.inner.copy_opts(from, to, options).await
-        }
-
-        async fn rename_opts(
-            &self,
-            from: &object_store::path::Path,
-            to: &object_store::path::Path,
-            options: object_store::RenameOptions,
-        ) -> object_store::Result<()> {
-            self.inner.rename_opts(from, to, options).await
-        }
-    }
-
-    #[derive(Debug)]
-    struct ParentListGuardWrapper {
-        parent_list_calls: Arc<AtomicUsize>,
-    }
-
-    impl WrappingObjectStore for ParentListGuardWrapper {
-        fn wrap(
-            &self,
-            _store_prefix: &str,
-            inner: Arc<dyn object_store::ObjectStore>,
-        ) -> Arc<dyn object_store::ObjectStore> {
-            Arc::new(ParentListGuardStore {
-                inner,
-                parent: object_store::path::Path::from("database"),
-                parent_list_calls: self.parent_list_calls.clone(),
-            })
-        }
-    }
-
-    #[tokio::test]
-    async fn test_open_missing_never_lists_database_parent() {
-        let parent_list_calls = Arc::new(AtomicUsize::new(0));
-        let params = ReadParams {
-            store_options: Some(ObjectStoreParams {
-                object_store_wrapper: Some(Arc::new(ParentListGuardWrapper {
-                    parent_list_calls: parent_list_calls.clone(),
-                })),
-                ..Default::default()
-            }),
-            ..Default::default()
-        };
-
-        let err = NativeTable::open_with_params(
-            "memory:///database/missing.lance",
-            "missing",
-            Vec::new(),
-            None,
-            Some(params),
-            None,
-            None,
-            HashSet::new(),
-            None,
-        )
-        .await
-        .unwrap_err();
-
-        assert!(
-            matches!(&err, Error::TableNotFound { name, .. } if name == "missing"),
+            matches!(&err, Error::TableCorrupted { name, .. } if name == "test"),
            "got {err:?}"
        );
-        assert_eq!(
-            parent_list_calls.load(Ordering::Relaxed),
-            0,
-            "opening one missing table must not enumerate sibling tables"
+        assert!(
+            err.to_string().contains("exists but could not be loaded"),
+            "got {err}"
        );
    }

@@ -5339,7 +5085,7 @@ mod tests {
        // Bucket spec round-trips exactly, including the routing column (recovered
        // from its field id), maintained indexes, and writer config defaults.
        let spec = LsmWriteSpec::bucket("id", 4)
-            .with_maintained_indexes(vec![idx_name.clone()])
+            .with_maintained_indexes([idx_name])
            .with_writer_config_defaults([("durable_write", "false")]);
        table.set_lsm_write_spec(spec.clone()).await.unwrap();
        assert_eq!(table.get_lsm_write_spec().await.unwrap(), Some(spec));
@@ -5349,125 +5095,15 @@ mod tests {
        assert_eq!(table.get_lsm_write_spec().await.unwrap(), None);

        // Identity sharding round-trips (column recovered from the schema).
-        // A spec left at its default maintains every index on the table, so it
-        // reads back naming the one on the table rather than as "infer".
        let spec = LsmWriteSpec::identity("region");
        table.set_lsm_write_spec(spec.clone()).await.unwrap();
-        assert_eq!(
-            table.get_lsm_write_spec().await.unwrap(),
-            Some(spec.with_maintained_indexes(vec![idx_name.clone()]))
-        );
+        assert_eq!(table.get_lsm_write_spec().await.unwrap(), Some(spec));
        table.unset_lsm_write_spec().await.unwrap();

        // Unsharded round-trips (no routing column).
        let spec = LsmWriteSpec::unsharded();
        table.set_lsm_write_spec(spec.clone()).await.unwrap();
-        assert_eq!(
-            table.get_lsm_write_spec().await.unwrap(),
-            Some(spec.with_maintained_indexes(vec![idx_name]))
-        );
-    }
-
-    /// The maintained set defaults to every index on the table, resolved at
-    /// install. An index the memtable cannot build fails the install rather
-    /// than being dropped: maintaining it would take the table offline for
-    /// writes, dropping it would hide that from the caller.
-    #[tokio::test]
-    async fn test_set_lsm_write_spec_infers_maintained_indexes() {
-        let tmp_dir = tempdir().unwrap();
-        let uri = tmp_dir.path().to_str().unwrap();
-
-        let schema = Arc::new(Schema::new(vec![
-            Field::new("id", DataType::Int64, false),
-            Field::new("tag", DataType::Utf8, true),
-        ]));
-        let batch = RecordBatch::try_new(
-            schema.clone(),
-            vec![
-                Arc::new(arrow_array::Int64Array::from(vec![1, 2, 3])),
-                Arc::new(StringArray::from(vec!["a", "b", "c"])),
-            ],
-        )
-        .unwrap();
-        let reader: Box<dyn arrow_array::RecordBatchReader + Send> =
-            Box::new(RecordBatchIterator::new(vec![Ok(batch)], schema.clone()));
-        let conn = ConnectBuilder::new(uri)
-            .read_consistency_interval(Duration::from_secs(0))
-            .execute()
-            .await
-            .unwrap();
-        let table = conn.create_table("t", reader).execute().await.unwrap();
-
-        table
-            .create_index(&["id"], Index::BTree(Default::default()))
-            .name("id_btree".to_string())
-            .execute()
-            .await
-            .unwrap();
-        table
-            .create_index(&["tag"], Index::Bitmap(Default::default()))
-            .name("tag_bitmap".to_string())
-            .execute()
-            .await
-            .unwrap();
-
-        // Explicitly naming the bitmap index fails before anything commits.
-        let err = table
-            .set_lsm_write_spec(
-                LsmWriteSpec::unsharded().with_maintained_indexes(vec!["tag_bitmap".to_string()]),
-            )
-            .await
-            .unwrap_err();
-        assert!(
-            matches!(err, Error::InvalidInput { ref message } if message.contains("tag_bitmap")),
-            "expected the bitmap index to be rejected, got {err:?}"
-        );
-        assert_eq!(table.get_lsm_write_spec().await.unwrap(), None);
-
-        // The default covers every index, so the bitmap fails it too.
-        let err = table
-            .set_lsm_write_spec(LsmWriteSpec::unsharded())
-            .await
-            .unwrap_err();
-        assert!(
-            matches!(err, Error::InvalidInput { ref message }
-                if message.contains("tag_bitmap") && message.contains("maintained_indexes")),
-            "expected the inferred set to be rejected, got {err:?}"
-        );
-        assert_eq!(table.get_lsm_write_spec().await.unwrap(), None);
-
-        // Naming the maintainable subset installs.
-        table
-            .set_lsm_write_spec(
-                LsmWriteSpec::unsharded().with_maintained_indexes(vec!["id_btree".to_string()]),
-            )
-            .await
-            .unwrap();
-        assert_eq!(
-            table
-                .get_lsm_write_spec()
-                .await
-                .unwrap()
-                .unwrap()
-                .maintained_indexes(),
-            Some(["id_btree".to_string()].as_slice())
-        );
-
-        // Opting out entirely is distinct from the default.
-        table.unset_lsm_write_spec().await.unwrap();
-        table
-            .set_lsm_write_spec(LsmWriteSpec::unsharded().with_maintained_indexes(Vec::new()))
-            .await
-            .unwrap();
-        assert_eq!(
-            table
-                .get_lsm_write_spec()
-                .await
-                .unwrap()
-                .unwrap()
-                .maintained_indexes(),
-            Some([].as_slice())
-        );
+        assert_eq!(table.get_lsm_write_spec().await.unwrap(), Some(spec));
    }

    #[tokio::test]
@@ -5571,8 +5207,8 @@ mod tests {
    pub async fn test_stats_includes_index_and_overlay_files() {
        use lance::dataset::WriteDestination;
        use lance::dataset::transaction::{DataOverlayGroup, Operation};
-        use lance_file::version::stable_file_version;
-        use lance_file::writer::FileWriterOptions;
+        use lance_file::version::{ConcreteFileVersion, LanceFileVersion};
+        use lance_file::writer::{FileWriter, FileWriterOptions};
        use lance_io::utils::CachedFileSize;
        use lance_table::format::DataFile;
        use lance_table::format::overlay::{DataOverlayFile, OverlayCoverage};
@@ -5637,17 +5273,19 @@ mod tests {
        let fragment_id = dataset.get_fragments()[0].id() as u64;
        let foo_field_id = dataset.schema().field("foo").unwrap().id;
        let overlay_schema = dataset.schema().project_by_ids(&[foo_field_id], true);
-        let file_version = stable_file_version();
+        let file_version = ConcreteFileVersion::from(LanceFileVersion::Stable);

        let filename = "overlay.lance".to_string();
        let store = dataset.object_store(None).await.unwrap();
        let path = dataset.data_dir().child(filename.clone());
        let obj_writer = store.create(&path).await.unwrap();
-        let mut writer = lance_file::versions::create_writer(
-            file_version,
+        let mut writer = FileWriter::try_new(
            obj_writer,
            overlay_schema,
-            FileWriterOptions::default(),
+            FileWriterOptions {
+                format_version: Some(file_version.into()),
+                ..Default::default()
+            },
        )
        .unwrap();
        writer
@@ -15,7 +15,6 @@ use crate::{Error, Result};
 pub struct AddColumnsBuilder {
    parent: Arc<dyn BaseTable>,
    transform: Option<NewColumnTransform>,
-    computed: Vec<(String, String)>,
    read_columns: Option<Vec<String>>,
 }

@@ -24,7 +23,6 @@ impl std::fmt::Debug for AddColumnsBuilder {
        f.debug_struct("AddColumnsBuilder")
            .field("parent", &self.parent)
            .field("has_transform", &self.transform.is_some())
-            .field("computed", &self.computed)
            .field("read_columns", &self.read_columns)
            .finish()
    }
@@ -35,58 +33,19 @@ impl AddColumnsBuilder {
        Self {
            parent,
            transform: None,
-            computed: Vec::new(),
            read_columns: None,
        }
    }

-    /// Set how the new columns' values are produced.
+    /// Set how the new columns' values are produced. Required.
    pub fn transform(mut self, transform: NewColumnTransform) -> Self {
        self.transform = Some(transform);
        self
    }

-    /// Add a column defined by `expression`, evaluated by a later refresh
-    /// rather than by this commit. Its type and inputs are derived from the
-    /// expression.
-    ///
-    /// The column is committed with no values, so declaring one costs the same
-    /// on an empty table as on a large one. Rows get values from
-    /// [`Table::refresh_column`](super::Table::refresh_column), which fills
-    /// every fragment that has none -- including fragments appended since the
-    /// last refresh.
-    ///
-    /// Refresh does not revisit a fragment it has filled, so mutating an input
-    /// leaves the value computed at fill time; recomputing means dropping the
-    /// column and declaring it again. An input cannot be renamed, retyped or
-    /// dropped while a declaration reads it, since the expression names it.
-    ///
-    /// On LanceDB Cloud and Enterprise the expression is planned by the
-    /// server, and the refresh runs as a server job -- see
-    /// [`Table::refresh_column_async`](super::Table::refresh_column_async).
-    ///
-    /// ```
-    /// # use lancedb::Table;
-    /// # async fn declare(table: &Table) -> Result<(), Box<dyn std::error::Error>> {
-    /// table
-    ///     .add_columns()
-    ///     .computed("doubled", "x * 2")
-    ///     .execute()
-    ///     .await?;
-    /// let filled = table.refresh_column("doubled").await?;
-    /// println!("filled {} rows", filled.rows_filled);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn computed(mut self, name: impl Into<String>, expression: impl Into<String>) -> Self {
-        self.computed.push((name.into(), expression.into()));
-        self
-    }
-
    /// Limit which existing columns a [`NewColumnTransform::BatchUDF`] mapper
-    /// receives. Every other transform, and a computed column, determines what
-    /// it reads, so setting this alongside one is an error rather than a silent
-    /// no-op.
+    /// receives. Every other transform determines what it reads, so setting
+    /// this alongside one is an error rather than a silent no-op.
    pub fn read_columns(mut self, columns: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.read_columns = Some(columns.into_iter().map(Into::into).collect());
        self
@@ -97,42 +56,24 @@ impl AddColumnsBuilder {
        let Self {
            parent,
            transform,
-            computed,
            read_columns,
        } = self;

-        match (transform, computed.is_empty()) {
-            (None, true) => Err(Error::InvalidInput {
-                message: "add_columns requires a transform or a computed column".into(),
-            }),
-            // The two commit through different transforms, so one call covering
-            // both would be two commits and could half-apply.
-            (Some(_), false) => Err(Error::InvalidInput {
-                message: "add_columns cannot mix a transform with computed columns; \
-                          they cannot be added atomically in one call"
+        let Some(transform) = transform else {
+            return Err(Error::InvalidInput {
+                message: "add_columns requires a transform".into(),
+            });
+        };
+
+        if read_columns.is_some() && !matches!(transform, NewColumnTransform::BatchUDF(_)) {
+            return Err(Error::InvalidInput {
+                message: "read_columns applies only to a BatchUDF transform; \
+                          every other transform determines what it reads"
                    .into(),
-            }),
-            (Some(transform), true) => {
-                if read_columns.is_some() && !matches!(transform, NewColumnTransform::BatchUDF(_)) {
-                    return Err(Error::InvalidInput {
-                        message: "read_columns applies only to a BatchUDF transform; \
-                                  every other transform determines what it reads"
-                            .into(),
-                    });
-                }
-                parent.add_columns(transform, read_columns).await
-            }
-            (None, false) => {
-                if read_columns.is_some() {
-                    return Err(Error::InvalidInput {
-                        message: "read_columns applies only to a BatchUDF transform; \
-                                  a computed column's inputs come from its expression"
-                            .into(),
-                    });
-                }
-                parent.add_computed_columns(&computed).await
-            }
+            });
        }
+
+        parent.add_columns(transform, read_columns).await
    }
 }

@@ -144,8 +85,8 @@ mod tests {
    use arrow_schema::{DataType, Field, Schema};
    use lance::dataset::{BatchUDF, NewColumnTransform};

+    use crate::Table;
    use crate::connect;
-    use crate::{Error, Table};

    async fn table_with_two_columns(name: &str) -> Table {
        let conn = connect("memory://").execute().await.unwrap();
@@ -157,7 +98,10 @@ mod tests {
    async fn test_requires_a_transform() {
        let table = table_with_two_columns("no_transform").await;
        let err = table.add_columns().execute().await.unwrap_err();
-        assert!(matches!(err, Error::InvalidInput { .. }));
+        assert!(
+            err.to_string().contains("requires a transform"),
+            "got: {err}"
+        );
    }

    #[tokio::test]
@@ -173,7 +117,7 @@ mod tests {
            .execute()
            .await
            .unwrap_err();
-        assert!(matches!(err, Error::InvalidInput { .. }));
+        assert!(err.to_string().contains("BatchUDF"), "got: {err}");

        let schema = table.schema().await.unwrap();
        assert!(
@@ -182,47 +126,6 @@ mod tests {
        );
    }

-    #[tokio::test]
-    async fn test_mixing_transform_and_computed_is_rejected() {
-        let table = table_with_two_columns("mixed_add").await;
-        let err = table
-            .add_columns()
-            .transform(NewColumnTransform::SqlExpressions(vec![(
-                "eager".into(),
-                "x * 2".into(),
-            )]))
-            .computed("lazy", "x * 3")
-            .execute()
-            .await
-            .unwrap_err();
-        assert!(matches!(err, Error::InvalidInput { .. }));
-
-        let schema = table.schema().await.unwrap();
-        assert!(schema.field_with_name("eager").is_err());
-        assert!(schema.field_with_name("lazy").is_err());
-    }
-
-    #[tokio::test]
-    async fn test_read_columns_with_computed_is_rejected() {
-        let table = table_with_two_columns("read_cols_computed").await;
-        let err = table
-            .add_columns()
-            .computed("doubled", "x * 2")
-            .read_columns(["x"])
-            .execute()
-            .await
-            .unwrap_err();
-        assert!(matches!(err, Error::InvalidInput { .. }));
-        assert!(
-            table
-                .schema()
-                .await
-                .unwrap()
-                .field_with_name("doubled")
-                .is_err()
-        );
-    }
-
    #[tokio::test]
    async fn test_read_columns_limits_what_a_batch_udf_sees() {
        let table = table_with_two_columns("read_cols_udf").await;
@@ -17,7 +17,7 @@ use datafusion_physical_plan::stream::RecordBatchStreamAdapter;
 use datafusion_physical_plan::{
    DisplayAs, DisplayFormatType, ExecutionPlan, ExecutionPlanProperties, PlanProperties,
 };
-use futures::StreamExt;
+use futures::TryStreamExt;
 use lance::Dataset;
 use lance::dataset::transaction::{Operation, Transaction};
 use lance::dataset::{CommitBuilder, InsertBuilder, WriteParams, WriteProgressFn};
@@ -194,23 +194,12 @@ impl ExecutionPlan for InsertExec {

        let output_bytes = MetricBuilder::new(&self.metrics).output_bytes(partition);
        let input_schema = input_stream.schema();
-        let declared: Vec<String> = crate::table::computed_columns::computed_columns(
-            &arrow_schema::Schema::from(self.dataset.schema()),
-        )
-        .into_iter()
-        .map(|declaration| declaration.name)
-        .collect();
        let input_stream: SendableRecordBatchStream =
            Box::pin(InstrumentedRecordBatchStreamAdapter::new(
                input_schema,
-                input_stream.map(move |batch| {
-                    let batch = batch?;
-                    crate::table::computed_columns::ensure_batch_writes_no_computed_values(
-                        &declared, &batch,
-                    )
-                    .map_err(|e| datafusion::error::DataFusionError::External(Box::new(e)))?;
+                input_stream.map_ok(move |batch| {
                    output_bytes.add(batch.get_array_memory_size());
-                    Ok(batch)
+                    batch
                }),
                partition,
                &self.metrics,
@@ -1161,7 +1161,7 @@ mod lsm_tests {
            .unwrap();
        let fts_index = table.list_indices().await.unwrap()[0].name.clone();
        table
-            .set_lsm_write_spec(LsmWriteSpec::unsharded().with_maintained_indexes(vec![fts_index]))
+            .set_lsm_write_spec(LsmWriteSpec::unsharded().with_maintained_indexes([fts_index]))
            .await
            .unwrap();

@@ -1254,7 +1254,7 @@ mod lsm_tests {
            .unwrap();
        let vec_index = table.list_indices().await.unwrap()[0].name.clone();
        table
-            .set_lsm_write_spec(LsmWriteSpec::unsharded().with_maintained_indexes(vec![vec_index]))
+            .set_lsm_write_spec(LsmWriteSpec::unsharded().with_maintained_indexes([vec_index]))
            .await
            .unwrap();

@@ -29,7 +29,6 @@ use arrow_schema::{DataType, Schema as ArrowSchema, SchemaRef};
 use lance::Dataset;
 use lance::dataset::mem_wal::{
    DatasetMemWalExt, ShardWriter, ShardWriterConfig, evaluate_sharding_spec,
-    validate_maintained_indexes,
 };
 use lance::index::DatasetIndexExt;
 use lance_core::datatypes::Schema as LanceSchema;
@@ -38,9 +37,8 @@ use tokio::sync::RwLock;
 use uuid::Uuid;

 use crate::error::{Error, Result};
-use crate::index::IndexConfig;
 use crate::table::merge::{MergeInsertBuilder, MergeResult};
-use crate::table::{BaseTable, LsmWriteSpec, NativeTable};
+use crate::table::{LsmWriteSpec, NativeTable};

 /// Spec id of the sole sharding spec installed by [`set_lsm_write_spec`].
 /// Must match Lance's `InitializeMemWalBuilder` (`SHARDING_SPEC_ID`).
@@ -82,53 +80,32 @@ pub(crate) async fn set_lsm_write_spec(table: &NativeTable, spec: LsmWriteSpec)
        }
    }

-    // Before the builder borrows the dataset clone. `list_indices` merges an
-    // index's segments into one entry, so the result needs no dedup.
-    let maintained_indexes = {
-        let dataset = table.dataset.get().await?;
-        resolve_maintained_indexes(
-            &dataset,
-            &table.list_indices().await?,
-            spec.maintained_indexes(),
-        )
-        .await?
-    };
-
-    table.checkout_latest().await?;
    let mut dataset = (*table.dataset.get().await?).clone();
-    let schema = arrow_schema::Schema::from(dataset.schema());
-    if !crate::table::computed_columns::computed_columns(&schema).is_empty() {
-        return Err(Error::NotSupported {
-            message: "an LSM write spec cannot be installed on a table with computed \
-                      columns: rows in un-compacted tiers are invisible to refresh"
-                .into(),
-        });
-    }
    let mut builder = dataset.initialize_mem_wal();
-    let writer_config_defaults = match spec {
+    let (maintained_indexes, writer_config_defaults) = match spec {
        LsmWriteSpec::Bucket {
            column,
            num_buckets,
+            maintained_indexes,
            writer_config_defaults,
-            ..
        } => {
            builder = builder.bucket_sharding(column, num_buckets);
-            writer_config_defaults
+            (maintained_indexes, writer_config_defaults)
        }
        LsmWriteSpec::Identity {
            column,
+            maintained_indexes,
            writer_config_defaults,
-            ..
        } => {
            builder = builder.identity_sharding(column);
-            writer_config_defaults
+            (maintained_indexes, writer_config_defaults)
        }
        LsmWriteSpec::Unsharded {
+            maintained_indexes,
            writer_config_defaults,
-            ..
        } => {
            builder = builder.unsharded();
-            writer_config_defaults
+            (maintained_indexes, writer_config_defaults)
        }
    };
    builder = builder.maintained_indexes(maintained_indexes);
@@ -140,88 +117,6 @@ pub(crate) async fn set_lsm_write_spec(table: &NativeTable, spec: LsmWriteSpec)
    Ok(())
 }

-/// Resolve a spec's maintained-index selection against `indices`, as reported
-/// by [`Table::list_indices`](crate::Table::list_indices).
-///
-/// `None` means every index on the table, snapshotted now. Lance validates
-/// either selection against its shard-writer rules, so a spec that installs is
-/// one the MemWAL can open.
-///
-/// An unmaintainable index fails an inferred set rather than being dropped from
-/// it — dropping would leave the caller believing it is maintained.
-async fn resolve_maintained_indexes(
-    dataset: &Dataset,
-    indices: &[IndexConfig],
-    requested: Option<&[String]>,
-) -> Result<Vec<String>> {
-    let Some(requested) = requested else {
-        let all: Vec<String> = indices.iter().map(|index| index.name.clone()).collect();
-        validate_maintained_indexes(dataset, &all)
-            .await
-            .map_err(|source| Error::InvalidInput {
-                message: format!(
-                    "cannot maintain every index on this table: {source}. Set \
-                     maintained_indexes explicitly to choose from {}",
-                    index_name_list(indices),
-                ),
-            })?;
-        return Ok(all);
-    };
-    for name in requested {
-        if !indices.iter().any(|index| &index.name == name) {
-            return Err(Error::InvalidInput {
-                message: format!(
-                    "maintained index '{}' does not exist on this table; it has {}",
-                    name,
-                    index_name_list(indices),
-                ),
-            });
-        }
-    }
-    validate_maintained_indexes(dataset, requested).await?;
-    Ok(requested.to_vec())
-}
-
-/// Index names for an error message.
-fn index_name_list(indices: &[IndexConfig]) -> String {
-    if indices.is_empty() {
-        return "no indexes".to_string();
-    }
-    let mut names: Vec<&str> = indices.iter().map(|index| index.name.as_str()).collect();
-    names.sort_unstable();
-    format!("[{}]", names.join(", "))
-}
-
-// =============================================================================
-// require_mem_wal_index_catchup
-// =============================================================================
-
-/// Switch this table to required index catch-up, one way.
-///
-/// Deliberately **not** part of installing the write spec. Until something can
-/// actually repair coverage, a table carrying the bit reports every index as
-/// not known to hold the compacted rows, so its SSTables are retained
-/// indefinitely -- and the WAL pod trims on the legacy rule meanwhile, leaving
-/// readers pointed at files that are gone. Turn this on only once remote
-/// maintenance owns the merge and the repair for the table.
-///
-/// Lance refuses the activation if the table already records SSTable
-/// compaction progress: those numbers predate this protocol and cannot be
-/// validated, so such a table must be drained rather than activated.
-#[allow(clippy::redundant_pub_crate)]
-pub(crate) async fn require_mem_wal_index_catchup(table: &NativeTable) -> Result<()> {
-    table.dataset.ensure_mutable()?;
-    let mut dataset = (*table.dataset.get().await?).clone();
-    if dataset.mem_wal_index_details().await?.is_none() {
-        return Err(Error::InvalidInput {
-            message: "require_mem_wal_index_catchup: no LSM write spec is set on this table".into(),
-        });
-    }
-    dataset.require_mem_wal_index_catchup().await?;
-    table.dataset.update(dataset);
-    Ok(())
-}
-
 // =============================================================================
 // unset_lsm_write_spec
 // =============================================================================
@@ -36,7 +36,6 @@ use lance::dataset::mem_wal::{
    DatasetMemWalExt, LsmScanner, ShardManifestStore, ShardSnapshot, ShardWriterConfig,
 };
 use lance_index::mem_wal::{MemWalIndexDetails, ShardManifest};
-use lance_table::feature_flags::FLAG_MEM_WAL_INDEX_CATCHUP;
 use uuid::Uuid;

 use super::NativeTable;
@@ -85,8 +84,9 @@ pub(super) async fn create_lsm_plan(
    let pk_columns = pk_columns(&ds_ref)?;
    // The base index an indexed arm relies on may lag compaction; resolve it so the
    // snapshot retains SSTables the index has not yet caught up to.
-    let arm_indexes = arm_maintained_index_names(&ds_ref, &query, &details).await?;
-    let (snapshots, in_memory) = build_read_context(table, &ds_ref, &details, &arm_indexes).await?;
+    let arm_index = arm_maintained_index_name(&ds_ref, &query, &details).await?;
+    let (snapshots, in_memory) =
+        build_read_context(table, &ds_ref, &details, arm_index.as_deref()).await?;

    let limit = query.base.limit;
    let offset = query.base.offset;
@@ -232,44 +232,28 @@ fn pk_columns(dataset: &Dataset) -> Result<Vec<String>> {
    Ok(pk)
 }

-/// Per-shard SSTable exclusion watermark: the generation at or below which
-/// SSTables are safe to drop for this query.
-///
-/// A generation is droppable only once it is compacted into the base table AND
-/// covered by the catch-up of every index the query relies on, so the watermark
-/// is the minimum across `index_names`. Gating on fewer than all of them would
-/// drop SSTables holding rows an uncounted index has not yet indexed, and that
-/// arm would silently return fewer rows.
-///
-/// See [`arm_maintained_index_names`] for which indexes are collected today: a
-/// vector search with a scalar prefilter is not yet among them.
-///
-/// An empty `index_names` (a plain scan) uses the compaction watermark alone.
-/// First occurrence per shard mirrors Lance's `compacted_generation_for_shard`.
+/// Per-shard SSTable exclusion watermark: the generation at or below which SSTables
+/// are safe to drop for this arm. A generation is droppable only once it is
+/// compacted into the base table AND covered by `index_name`'s catch-up (for an
+/// indexed arm); a plain scan (`index_name == None`) uses the compaction watermark
+/// alone. Capping at the index catch-up keeps rows the base index has not yet
+/// indexed visible through their SSTable. First occurrence per shard mirrors Lance's
+/// `compacted_generation_for_shard`.
 fn exclusion_watermarks(
    details: &MemWalIndexDetails,
-    index_names: &[String],
-    catchup_required: bool,
+    index_name: Option<&str>,
 ) -> HashMap<Uuid, u64> {
    let mut exclude: HashMap<Uuid, u64> = HashMap::new();
    for entry in &details.compacted_sstables {
        let mut watermark = entry.generation;
-        for name in index_names {
-            match details
+        if let Some(name) = index_name
+            && let Some(caught_up) = details
                .index_catchup
                .iter()
-                .find(|icp| icp.index_name == *name)
+                .find(|icp| icp.index_name == name)
                .and_then(|icp| icp.caught_up_generation_for_shard(&entry.shard_id))
-            {
-                Some(caught_up) => watermark = watermark.min(caught_up),
-                // No entry. On a table that requires catch-up this means the
-                // index is *not* known to hold these rows, and the base arm is
-                // index-only -- so every generation stays readable from its
-                // SSTable. Without the bit the field is not maintained at all,
-                // and absence carries no information.
-                None if catchup_required => watermark = 0,
-                None => {}
-            }
+        {
+            watermark = watermark.min(caught_up);
        }
        exclude.entry(entry.shard_id).or_insert(watermark);
    }
@@ -283,26 +267,13 @@ fn exclusion_watermarks(
 /// with a live cached `ShardWriter` (this session's in-flight writes) the
 /// writer's authoritative in-memory manifest and memtables override the
 /// on-disk view so a read sees data not yet flushed.
-/// Whether this table reads a missing `index_catchup` entry as "not caught up".
-///
-/// Both words must be set. A reader honouring the bit while a writer does not
-/// would retain SSTables the writer had already trimmed, and the reverse would
-/// serve rows from files the writer still expects to be excluded -- so a
-/// half-set manifest is treated as legacy, which is the conservative side.
-fn requires_index_catchup(dataset: &Dataset) -> bool {
-    let manifest = dataset.manifest();
-    manifest.reader_feature_flags & FLAG_MEM_WAL_INDEX_CATCHUP != 0
-        && manifest.writer_feature_flags & FLAG_MEM_WAL_INDEX_CATCHUP != 0
-}
-
 async fn build_read_context(
    table: &NativeTable,
    dataset: &Dataset,
    details: &MemWalIndexDetails,
-    index_names: &[String],
+    index_name: Option<&str>,
 ) -> Result<(Vec<ShardSnapshot>, HashMap<Uuid, InMemoryMemTables>)> {
-    let catchup_required = requires_index_catchup(dataset);
-    let exclude = exclusion_watermarks(details, index_names, catchup_required);
+    let exclude = exclusion_watermarks(details, index_name);

    let shard_ids = dataset.list_mem_wal_latest_shard_ids().await?;
    // Use the dataset's own object store (not `ObjectStore::from_uri`, which
@@ -516,33 +487,19 @@ async fn index_maintained(
    }))
 }

-/// Every maintained base index this query relies on, used to gate SSTable
-/// exclusion by index catch-up.
-///
-/// Returns a list because the watermark must be the lowest across every index a
-/// query relies on. Today it never holds more than one: `reject_unsupported`
-/// refuses hybrid search, so the vector and full-text arms are mutually
-/// exclusive.
-///
-/// The case that is genuinely multi-index -- a vector search with a scalar or
-/// bitmap prefilter -- is **not collected yet**. Identifying those needs the
-/// planner's chosen indexes, not the columns the filter names, and no Lance API
-/// exposes them. Until it does, such a query is gated on its vector index alone.
-///
-/// Empty for a plain scan, or when no maintained index covers the searched
-/// column.
-async fn arm_maintained_index_names(
+/// The maintained base index the query's arm relies on (vector index for ANN, FTS
+/// index for full-text), used to gate SSTable compaction exclusion by index catch-up.
+/// `None` for a plain scan or when no maintained index covers the searched column.
+async fn arm_maintained_index_name(
    dataset: &Dataset,
    query: &VectorQueryRequest,
    details: &MemWalIndexDetails,
-) -> Result<Vec<String>> {
+) -> Result<Option<String>> {
    use lance::index::DatasetIndexExt;
-
-    // Each arm's searched column, the index-detail type it relies on, and a
+    // Resolve the arm's searched column, the index-detail type it relies on, and a
    // label for diagnostics — catch-up is taken from the vector/FTS index
    // specifically, not a BTree on the same column.
-    let mut arms: Vec<(String, &str, &str)> = Vec::new();
-    if !query.query_vector.is_empty() {
+    let (column, type_url_suffix, arm) = if !query.query_vector.is_empty() {
        let arrow_schema = ArrowSchema::from(dataset.schema());
        let column = match &query.column {
            Some(column) => column.clone(),
@@ -551,43 +508,31 @@ async fn arm_maintained_index_names(
                default_vector_column(&arrow_schema, dim)?
            }
        };
-        arms.push((column, "VectorIndexDetails", "vector"));
-    }
-    if let Some(fts) = &query.base.full_text_search
-        && let Some(column) = fts.columns().into_iter().next()
-    {
-        arms.push((column, "InvertedIndexDetails", "full-text"));
-    }
-    if arms.is_empty() {
-        return Ok(Vec::new());
-    }
-
-    let indices = dataset.load_indices().await?;
-    let mut names = Vec::with_capacity(arms.len());
-    for (column, type_url_suffix, arm) in arms {
-        let Some(field) = dataset.schema().field(&column) else {
-            continue;
-        };
-        let segment_names: Vec<String> = indices
-            .iter()
-            .filter(|idx| {
-                idx.fields.contains(&field.id)
-                    && idx
-                        .index_details
-                        .as_ref()
-                        .is_some_and(|d| d.type_url.ends_with(type_url_suffix))
-            })
-            .map(|idx| idx.name.clone())
-            .collect();
-        if let Some(name) =
-            resolve_single_index(segment_names, &details.maintained_indexes, arm, &column)?
-        {
-            names.push(name);
+        (column, "VectorIndexDetails", "vector")
+    } else if let Some(fts) = &query.base.full_text_search {
+        match fts.columns().into_iter().next() {
+            Some(column) => (column, "InvertedIndexDetails", "full-text"),
+            None => return Ok(None),
        }
-    }
-    names.sort();
-    names.dedup();
-    Ok(names)
+    } else {
+        return Ok(None);
+    };
+    let Some(field) = dataset.schema().field(&column) else {
+        return Ok(None);
+    };
+    let indices = dataset.load_indices().await?;
+    let segment_names: Vec<String> = indices
+        .iter()
+        .filter(|idx| {
+            idx.fields.contains(&field.id)
+                && idx
+                    .index_details
+                    .as_ref()
+                    .is_some_and(|d| d.type_url.ends_with(type_url_suffix))
+        })
+        .map(|idx| idx.name.clone())
+        .collect();
+    resolve_single_index(segment_names, &details.maintained_indexes, arm, &column)
 }

 /// Resolve the single logical index from the names of its matching physical
@@ -789,117 +734,22 @@ mod tests {
        };

        // Plain scan: drop every compacted generation (through 5).
-        assert_eq!(
-            exclusion_watermarks(&details, &[], false).get(&shard),
-            Some(&5)
-        );
+        assert_eq!(exclusion_watermarks(&details, None).get(&shard), Some(&5));

        // FTS arm with a lagging index: exclusion is capped at the index catch-up
        // (2), so SSTable generations 3..=5 are retained until the index covers
        // them — otherwise those documents would silently vanish from FTS results.
        assert_eq!(
-            exclusion_watermarks(&details, &["fts_idx".to_string()], false).get(&shard),
+            exclusion_watermarks(&details, Some("fts_idx")).get(&shard),
            Some(&2)
        );

        // A caught-up index — or one untracked in index_catchup — falls back to the
        // compaction watermark.
        assert_eq!(
-            exclusion_watermarks(&details, &["caught_up_idx".to_string()], false).get(&shard),
+            exclusion_watermarks(&details, Some("caught_up_idx")).get(&shard),
            Some(&5)
        );
-
-        // The same missing entry, once the table requires catch-up: absence now
-        // means "not known to hold these rows", so nothing may be excluded and
-        // every generation stays readable from its SSTable. This is the whole
-        // point of the protocol -- an indexed query against a table whose index
-        // has not caught up must not silently lose rows.
-        assert_eq!(
-            exclusion_watermarks(&details, &["untracked_idx".to_string()], true).get(&shard),
-            Some(&0)
-        );
-
-        // A tracked index is unaffected by the mode: the recorded position is
-        // information either way, and it still caps the exclusion.
-        assert_eq!(
-            exclusion_watermarks(&details, &["fts_idx".to_string()], true).get(&shard),
-            Some(&2)
-        );
-
-        // One missing entry is enough to hold everything back, even alongside an
-        // index that has caught up.
-        let mixed = vec!["fts_idx".to_string(), "untracked_idx".to_string()];
-        assert_eq!(
-            exclusion_watermarks(&details, &mixed, true).get(&shard),
-            Some(&0)
-        );
-    }
-
-    /// A hybrid search reads a vector and a full-text index, and either may lag.
-    /// Retaining to the lower of the two is what keeps both arms complete;
-    /// gating on one alone would drop SSTables the other has not indexed.
-    #[test]
-    fn exclusion_watermark_takes_the_minimum_across_every_index_used() {
-        let shard = Uuid::from_u128(1);
-        let details = MemWalIndexDetails {
-            compacted_sstables: vec![CompactedSsTable::new(shard, 9)],
-            index_catchup: vec![
-                IndexCatchupProgress::new(
-                    "vec_idx".to_string(),
-                    vec![CompactedSsTable::new(shard, 7)],
-                ),
-                IndexCatchupProgress::new(
-                    "fts_idx".to_string(),
-                    vec![CompactedSsTable::new(shard, 4)],
-                ),
-            ],
-            maintained_indexes: vec!["vec_idx".to_string(), "fts_idx".to_string()],
-            ..Default::default()
-        };
-
-        // Each index alone stops at its own catch-up.
-        assert_eq!(
-            exclusion_watermarks(&details, &["vec_idx".to_string()], false).get(&shard),
-            Some(&7)
-        );
-        assert_eq!(
-            exclusion_watermarks(&details, &["fts_idx".to_string()], false).get(&shard),
-            Some(&4)
-        );
-
-        // Used together, the lower one governs regardless of order.
-        let both = ["vec_idx".to_string(), "fts_idx".to_string()];
-        assert_eq!(
-            exclusion_watermarks(&details, &both, false).get(&shard),
-            Some(&4)
-        );
-        let reversed = ["fts_idx".to_string(), "vec_idx".to_string()];
-        assert_eq!(
-            exclusion_watermarks(&details, &reversed, false).get(&shard),
-            Some(&4)
-        );
-    }
-
-    /// An index with no catch-up entry contributes no cap today, so a lagging
-    /// sibling must still govern rather than being widened by the untracked one.
-    #[test]
-    fn an_untracked_index_does_not_widen_a_lagging_sibling() {
-        let shard = Uuid::from_u128(1);
-        let details = MemWalIndexDetails {
-            compacted_sstables: vec![CompactedSsTable::new(shard, 9)],
-            index_catchup: vec![IndexCatchupProgress::new(
-                "fts_idx".to_string(),
-                vec![CompactedSsTable::new(shard, 4)],
-            )],
-            maintained_indexes: vec!["fts_idx".to_string(), "untracked_idx".to_string()],
-            ..Default::default()
-        };
-
-        let both = ["fts_idx".to_string(), "untracked_idx".to_string()];
-        assert_eq!(
-            exclusion_watermarks(&details, &both, false).get(&shard),
-            Some(&4)
-        );
    }

    #[test]
@@ -1,954 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-//! Filling computed columns.
-//!
-//! A row without a value gets one; a row that has one keeps it. Refresh is
-//! therefore idempotent and does not observe input mutation -- once a row is
-//! filled, changing what the expression reads leaves the stored result alone.
-//!
-//! Two passes per fragment. The first scans only the unfilled live rows and
-//! evaluates the expression over them, which yields the exact fill count and
-//! decides whether the fragment is staged at all -- a fragment where nothing
-//! would change stages nothing, which is what lets an expression yielding
-//! null settle instead of restaging forever. The second streams the
-//! fragment's physical rows into `write_column` a batch at a time, so peak
-//! memory is bounded by a scan batch. The expression is evaluated by this
-//! module, never through a projection alias, and only over rows being
-//! filled: every other row -- deleted, or already holding a value -- has its
-//! inputs masked to null first, so a poison value in a row nobody is filling
-//! cannot fail the refresh.
-
-use std::sync::Arc;
-
-use arrow_array::{ArrayRef, BooleanArray, RecordBatch, RecordBatchOptions};
-use arrow_schema::Schema as ArrowSchema;
-use datafusion_expr::ColumnarValue;
-use futures::{Stream, StreamExt, TryStreamExt};
-use lance::Dataset;
-use lance::dataset::WriteDestination;
-use lance::dataset::fragment::FileFragment;
-use lance::dataset::transaction::Operation;
-use lance_core::ROW_ID;
-use lance_core::datatypes::Schema as LanceSchema;
-use serde::{Deserialize, Serialize};
-
-use super::computed_columns::{BoundExpression, ComputedColumnKind, computed_column_from_field};
-use super::{BaseTable, NativeTable};
-use crate::job::Job;
-use crate::{Error, Result};
-
-/// The result of refreshing a computed column.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct RefreshColumnResult {
-    /// Rows that had a value computed.
-    #[serde(default)]
-    pub rows_filled: u64,
-    /// The commit version associated with the operation.
-    #[serde(default)]
-    pub version: u64,
-}
-
-/// Internal implementation of the refresh logic.
-pub(crate) async fn execute_refresh_column(
-    table: &NativeTable,
-    column: &str,
-) -> Result<RefreshColumnResult> {
-    table.dataset.ensure_mutable()?;
-    ensure_no_lsm_write_spec(table).await?;
-    let dataset = table.dataset.get().await?;
-
-    let expression = declared_expression(&dataset, column)?;
-    let schema = Arc::new(ArrowSchema::from(dataset.schema()));
-    let bound = Arc::new(super::computed_columns::bind(schema, column, &expression)?);
-    let field = dataset
-        .schema()
-        .field(column)
-        .ok_or_else(|| Error::ColumnNotFound {
-            name: column.to_string(),
-        })?;
-    // The dataset's own field, so the identity write_column checks against the
-    // manifest holds by construction.
-    let column_schema = LanceSchema {
-        fields: vec![field.clone()],
-        metadata: Default::default(),
-    };
-
-    let mut rows_filled = 0u64;
-    let mut replacements = Vec::new();
-    for fragment in dataset.get_fragments() {
-        let gained = count_fragment_gains(&dataset, &fragment, &bound, column).await?;
-        if gained == 0 {
-            continue;
-        }
-        rows_filled += gained;
-        let values = fill_stream(&dataset, &fragment, bound.clone(), column).await?;
-        replacements.push(fragment.write_column(values, &column_schema).await?);
-    }
-
-    if replacements.is_empty() {
-        return Ok(RefreshColumnResult {
-            rows_filled: 0,
-            version: dataset.version().version,
-        });
-    }
-
-    let read_version = dataset.version().version;
-    // The dataset's own session, so registrations and caches survive the
-    // commit being installed on the handle.
-    let session = dataset.session();
-    let new_dataset = Dataset::commit(
-        WriteDestination::Dataset(dataset.clone()),
-        Operation::DataReplacement { replacements },
-        Some(read_version),
-        None,
-        None,
-        session,
-        false,
-    )
-    .await?;
-
-    let version = new_dataset.version().version;
-    table.dataset.update(new_dataset);
-    Ok(RefreshColumnResult {
-        rows_filled,
-        version,
-    })
-}
-
-/// Run the refresh as a [`Job`] in this process.
-pub(crate) async fn execute_refresh_column_async(table: &NativeTable, column: &str) -> Result<Job> {
-    // Validate before spawning so bad input is reported by this call rather
-    // than only by the job.
-    table.dataset.ensure_mutable()?;
-    ensure_no_lsm_write_spec(table).await?;
-    let dataset = table.dataset.get().await?;
-    declared_expression(&dataset, column)?;
-    drop(dataset);
-
-    let table = table.clone();
-    let column = column.to_string();
-    Ok(Job::spawned(tokio::spawn(async move {
-        execute_refresh_column(&table, &column).await?;
-        table.bump_freshness();
-        Ok(())
-    })))
-}
-
-/// Refuse to refresh under an LSM write spec.
-///
-/// Refresh enumerates base fragments, and a write spec keeps visible rows in
-/// un-compacted MemWAL tiers it cannot reach -- success would silently omit
-/// readable rows.
-async fn ensure_no_lsm_write_spec(table: &NativeTable) -> Result<()> {
-    // The catch-up flag outlives unset and marks retained SSTable rows.
-    let catchup = table.dataset.get().await?.manifest().reader_feature_flags
-        & lance_table::feature_flags::FLAG_MEM_WAL_INDEX_CATCHUP
-        != 0;
-    if catchup || table.get_lsm_write_spec().await?.is_some() {
-        return Err(Error::NotSupported {
-            message: "refresh_column is not supported on a table with an LSM write \
-                      spec: rows in un-compacted tiers are invisible to refresh"
-                .into(),
-        });
-    }
-    Ok(())
-}
-
-/// The SQL expression `column` is declared with.
-fn declared_expression(dataset: &Dataset, column: &str) -> Result<String> {
-    let schema = ArrowSchema::from(dataset.schema());
-    let field = schema
-        .field_with_name(column)
-        .map_err(|_| Error::ColumnNotFound {
-            name: column.to_string(),
-        })?;
-    let declaration =
-        computed_column_from_field(field).ok_or_else(|| Error::NotAComputedColumn {
-            name: column.to_string(),
-        })?;
-    match declaration.kind {
-        ComputedColumnKind::Sql { expression } => Ok(expression),
-        ComputedColumnKind::Unrecognized { kind } => Err(Error::NotSupported {
-            message: format!(
-                "computed column '{column}' is defined by '{kind}', which this version of \
-                 lancedb cannot evaluate"
-            ),
-        }),
-    }
-}
-
-/// Quote `name` as a lance SQL identifier.
-///
-/// Lance's dialect delimits with backticks, so a double-quoted name would
-/// parse as a string literal rather than a column.
-fn quote_identifier(name: &str) -> String {
-    format!("`{}`", name.replace('`', "``"))
-}
-
-/// Assemble the batch evaluation runs against: the bound roots, in read-schema
-/// order. Built by name so scan-side column order never matters.
-fn evaluation_batch(
-    batch: &RecordBatch,
-    bound: &BoundExpression,
-    mask_out: Option<&BooleanArray>,
-) -> lance_core::Result<RecordBatch> {
-    let mut columns = Vec::with_capacity(bound.roots.len());
-    for name in &bound.roots {
-        let column = batch.column_by_name(name).ok_or_else(|| {
-            lance_core::Error::invalid_input(format!(
-                "refreshing a computed column read no {name} column"
-            ))
-        })?;
-        // Rows outside the mask must not reach the expression: a value in a
-        // deleted or already-filled row can be one it would choke on.
-        columns.push(match mask_out {
-            Some(mask) => arrow::compute::nullif(column, mask)?,
-            None => column.clone(),
-        });
-    }
-    Ok(RecordBatch::try_new_with_options(
-        bound.read_schema.clone(),
-        columns,
-        &RecordBatchOptions::new().with_row_count(Some(batch.num_rows())),
-    )?)
-}
-
-/// Evaluate the expression over `batch`, materializing a constant result to
-/// the batch's length.
-fn evaluate(bound: &BoundExpression, batch: &RecordBatch) -> lance_core::Result<ArrayRef> {
-    let value = bound
-        .physical
-        .evaluate(batch)
-        .map_err(lance_core::Error::from)?;
-    match value {
-        ColumnarValue::Array(array) => Ok(array),
-        scalar => scalar
-            .into_array(batch.num_rows())
-            .map_err(lance_core::Error::from),
-    }
-}
-
-/// How many rows of one fragment would gain a value.
-///
-/// Scans only the unfilled live rows -- deleted rows never reach the
-/// expression here, the filter having already excluded them -- and counts the
-/// non-null results. Exact, so it is both the staging decision and the
-/// fragment's contribution to `rows_filled`.
-async fn count_fragment_gains(
-    dataset: &Dataset,
-    fragment: &FileFragment,
-    bound: &BoundExpression,
-    column: &str,
-) -> Result<u64> {
-    let mut scanner = dataset.scan();
-    scanner
-        .with_fragments(vec![fragment.metadata().clone()])
-        .with_row_id()
-        .filter(&format!("{} IS NULL", quote_identifier(column)))?
-        .project(&bound.roots)?;
-
-    let mut gained = 0u64;
-    let mut batches = scanner.try_into_stream().await?;
-    while let Some(batch) = batches.try_next().await? {
-        let evaluated = evaluate(bound, &evaluation_batch(&batch, bound, None)?)?;
-        gained += (batch.num_rows() - evaluated.null_count()) as u64;
-    }
-    Ok(gained)
-}
-
-/// Stream one fragment's column in physical order, filling the unfilled live
-/// rows and keeping every other value.
-///
-/// Deleted rows are carried through so the values line up positionally with
-/// the fragment's data files; they are never read back, but the column file
-/// has to cover them.
-async fn fill_stream(
-    dataset: &Dataset,
-    fragment: &FileFragment,
-    bound: Arc<BoundExpression>,
-    column: &str,
-) -> Result<impl Stream<Item = lance_core::Result<RecordBatch>> + Send + use<>> {
-    let mut projection: Vec<String> = bound.roots.clone();
-    projection.push(column.to_string());
-    let mut scanner = dataset.scan();
-    scanner
-        .with_fragments(vec![fragment.metadata().clone()])
-        .with_row_id()
-        .include_deleted_rows()
-        .project(&projection)?;
-
-    let projected = Arc::new(ArrowSchema::new(vec![
-        ArrowSchema::from(dataset.schema())
-            .field_with_name(column)
-            .map_err(|_| Error::ColumnNotFound {
-                name: column.to_string(),
-            })?
-            .clone(),
-    ]));
-
-    let column = column.to_string();
-    let batches = scanner.try_into_stream().await?;
-    Ok(batches.map(move |batch| {
-        let batch = batch?;
-        let missing = |name: &str| {
-            lance_core::Error::invalid_input(format!(
-                "refreshing a computed column read no {name} column"
-            ))
-        };
-        let existing = batch
-            .column_by_name(&column)
-            .ok_or_else(|| missing(&column))?;
-        let row_ids = batch
-            .column_by_name(ROW_ID)
-            .ok_or_else(|| missing(ROW_ID))?;
-
-        // Only an unfilled live row gains a value; a deleted row has a null
-        // row id and keeps its (null) slot.
-        let unfilled = arrow::compute::is_null(existing.as_ref())?;
-        let live = arrow::compute::is_not_null(row_ids.as_ref())?;
-        let fill = arrow::compute::and(&unfilled, &live)?;
-        let keep = arrow::compute::not(&fill)?;
-
-        let computed = evaluate(&bound, &evaluation_batch(&batch, &bound, Some(&keep))?)?;
-        let merged = arrow_select::zip::zip(&fill, &computed, existing)?;
-        Ok(RecordBatch::try_new(projected.clone(), vec![merged])?)
-    }))
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use arrow_array::{Int32Array, record_batch};
-    use futures::TryStreamExt;
-
-    use crate::connect;
-    use crate::query::{ExecutableQuery, QueryBase, Select};
-    use crate::{Error, Result, Table};
-
-    async fn table_with(name: &str, values: Vec<i32>) -> Table {
-        let conn = connect("memory://").execute().await.unwrap();
-        let batch = record_batch!(("x", Int32, values)).unwrap();
-        conn.create_table(name, batch).execute().await.unwrap()
-    }
-
-    async fn declare_doubled(table: &Table) -> Result<u64> {
-        Ok(table
-            .add_columns()
-            .computed("doubled", "x * 2")
-            .execute()
-            .await?
-            .version)
-    }
-
-    async fn read(table: &Table, column: &str) -> Vec<Option<i32>> {
-        let batches = table
-            .query()
-            .select(Select::columns(&[column]))
-            .execute()
-            .await
-            .unwrap()
-            .try_collect::<Vec<_>>()
-            .await
-            .unwrap();
-        let mut values: Vec<Option<i32>> = batches
-            .iter()
-            .flat_map(|batch| {
-                batch[column]
-                    .as_any()
-                    .downcast_ref::<Int32Array>()
-                    .unwrap()
-                    .iter()
-                    .collect::<Vec<_>>()
-            })
-            .collect();
-        values.sort();
-        values
-    }
-
-    async fn append(table: &Table, values: Vec<i32>) {
-        let batch = record_batch!(("x", Int32, values)).unwrap();
-        table.add(batch).execute().await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn test_refresh_fills_a_declared_column() {
-        let table = table_with("refresh_fills", vec![1, 2, 3]).await;
-        let declared = declare_doubled(&table).await.unwrap();
-        assert_eq!(read(&table, "doubled").await, vec![None, None, None]);
-
-        let result = table.refresh_column("doubled").await.unwrap();
-        assert!(result.version > declared);
-        assert_eq!(result.rows_filled, 3);
-        assert_eq!(
-            read(&table, "doubled").await,
-            vec![Some(2), Some(4), Some(6)]
-        );
-    }
-
-    /// Values written after the last refresh must be reachable by another one.
-    #[tokio::test]
-    async fn test_refresh_fills_rows_appended_since_the_last_refresh() {
-        let table = table_with("refresh_appended", vec![1, 2]).await;
-        declare_doubled(&table).await.unwrap();
-        table.refresh_column("doubled").await.unwrap();
-
-        append(&table, vec![5, 6]).await;
-        assert_eq!(
-            read(&table, "doubled").await,
-            vec![None, None, Some(2), Some(4)]
-        );
-
-        let result = table.refresh_column("doubled").await.unwrap();
-        assert_eq!(result.rows_filled, 2);
-        assert_eq!(
-            read(&table, "doubled").await,
-            vec![Some(2), Some(4), Some(10), Some(12)]
-        );
-    }
-
-    #[tokio::test]
-    async fn test_refresh_with_nothing_to_fill() {
-        let table = table_with("refresh_noop", vec![1, 2, 3]).await;
-        declare_doubled(&table).await.unwrap();
-        table.refresh_column("doubled").await.unwrap();
-
-        let again = table.refresh_column("doubled").await.unwrap();
-        assert_eq!(again.rows_filled, 0);
-        assert_eq!(
-            read(&table, "doubled").await,
-            vec![Some(2), Some(4), Some(6)]
-        );
-    }
-
-    /// A row is filled only by gaining a value, so an expression yielding null
-    /// settles at once instead of re-selecting the same rows forever. Nothing
-    /// is staged, so the version does not move either.
-    #[tokio::test]
-    async fn test_refresh_converges_on_a_null_result() {
-        let table = table_with("refresh_null_result", vec![1, 2, 3]).await;
-        let declared = table
-            .add_columns()
-            .computed("maybe", "nullif(x, x)")
-            .execute()
-            .await
-            .unwrap()
-            .version;
-
-        let first = table.refresh_column("maybe").await.unwrap();
-        assert_eq!(first.rows_filled, 0);
-        assert_eq!(first.version, declared);
-        assert_eq!(read(&table, "maybe").await, vec![None, None, None]);
-
-        let again = table.refresh_column("maybe").await.unwrap();
-        assert_eq!(again.rows_filled, 0);
-        assert_eq!(again.version, declared);
-    }
-
-    /// The contract's boundary: a filled fragment is not revisited, so
-    /// mutating an input leaves the value computed at fill time.
-    #[tokio::test]
-    async fn test_refresh_does_not_observe_input_mutation() {
-        let table = table_with("refresh_mutation", vec![1]).await;
-        declare_doubled(&table).await.unwrap();
-        table.refresh_column("doubled").await.unwrap();
-        assert_eq!(read(&table, "doubled").await, vec![Some(2)]);
-
-        table.update().column("x", "3").execute().await.unwrap();
-
-        let again = table.refresh_column("doubled").await.unwrap();
-        assert_eq!(again.rows_filled, 0);
-        assert_eq!(read(&table, "doubled").await, vec![Some(2)]);
-    }
-
-    /// A row rewrite before the first refresh materializes the declared
-    /// column as null behind a covering data file. Those rows are still
-    /// unfilled and a later refresh has to reach them.
-    #[tokio::test]
-    async fn test_update_before_the_first_refresh() {
-        let table = table_with("refresh_update_first", vec![1]).await;
-        declare_doubled(&table).await.unwrap();
-
-        table.update().column("x", "3").execute().await.unwrap();
-
-        let result = table.refresh_column("doubled").await.unwrap();
-        assert_eq!(result.rows_filled, 1);
-        assert_eq!(read(&table, "doubled").await, vec![Some(6)]);
-    }
-
-    /// The contract holds row by row, not fragment by fragment: revisiting a
-    /// fragment to fill one row must not recompute a filled row sitting beside
-    /// it, even where the input behind it has since changed.
-    #[tokio::test]
-    async fn test_refresh_does_not_recompute_a_filled_row_beside_an_unfilled_one() {
-        let table = table_with("refresh_mixed", vec![1, 2]).await;
-        declare_doubled(&table).await.unwrap();
-        table.refresh_column("doubled").await.unwrap();
-
-        append(&table, vec![5]).await;
-        table
-            .update()
-            .column("x", "100")
-            .only_if("x = 1")
-            .execute()
-            .await
-            .unwrap();
-        table
-            .optimize(crate::table::OptimizeAction::Compact {
-                options: crate::table::CompactionOptions::default(),
-                remap_options: None,
-            })
-            .await
-            .unwrap();
-
-        let result = table.refresh_column("doubled").await.unwrap();
-        assert_eq!(result.rows_filled, 1);
-        // 2 is the mutated row keeping the value it was filled with, not 200.
-        assert_eq!(
-            read(&table, "doubled").await,
-            vec![Some(2), Some(4), Some(10)]
-        );
-    }
-
-    /// Filling a fragment must not disturb the values it already holds, which
-    /// is what makes a compaction-mixed fragment safe to revisit.
-    #[tokio::test]
-    async fn test_refresh_preserves_already_filled_rows() {
-        let table = table_with("refresh_preserves", vec![1, 2]).await;
-        declare_doubled(&table).await.unwrap();
-        table.refresh_column("doubled").await.unwrap();
-
-        append(&table, vec![5]).await;
-        table
-            .optimize(crate::table::OptimizeAction::Compact {
-                options: crate::table::CompactionOptions::default(),
-                remap_options: None,
-            })
-            .await
-            .unwrap();
-
-        let result = table.refresh_column("doubled").await.unwrap();
-        assert_eq!(result.rows_filled, 1);
-        assert_eq!(
-            read(&table, "doubled").await,
-            vec![Some(2), Some(4), Some(10)]
-        );
-    }
-
-    #[tokio::test]
-    async fn test_refresh_leaves_deleted_rows_alone() {
-        let table = table_with("refresh_deleted", vec![1, 2, 3, 4]).await;
-        declare_doubled(&table).await.unwrap();
-        table.delete("x = 2").await.unwrap();
-
-        let result = table.refresh_column("doubled").await.unwrap();
-        assert_eq!(result.rows_filled, 3);
-        assert_eq!(
-            read(&table, "doubled").await,
-            vec![Some(2), Some(6), Some(8)]
-        );
-    }
-
-    #[tokio::test]
-    async fn test_refresh_a_constant_expression() {
-        let table = table_with("refresh_constant", vec![1, 2, 3]).await;
-        table
-            .add_columns()
-            .computed("answer", "42")
-            .execute()
-            .await
-            .unwrap();
-
-        let result = table.refresh_column("answer").await.unwrap();
-        assert_eq!(result.rows_filled, 3);
-    }
-
-    /// A name needing quotes reaches the evaluator intact: it is carried as a
-    /// projection alias, never spliced into SQL text.
-    #[tokio::test]
-    async fn test_refresh_a_column_whose_name_needs_quoting() {
-        let table = table_with("refresh_quoted", vec![1, 2, 3]).await;
-        table
-            .add_columns()
-            .computed("double value", "x * 2")
-            .execute()
-            .await
-            .unwrap();
-
-        let result = table.refresh_column("double value").await.unwrap();
-        assert_eq!(result.rows_filled, 3);
-        assert_eq!(
-            read(&table, "double value").await,
-            vec![Some(2), Some(4), Some(6)]
-        );
-    }
-
-    /// A fragment spanning several scan batches exercises the streamed fill:
-    /// the probe buffers only until the first gained value and the rest flows
-    /// through write_column a batch at a time.
-    #[tokio::test]
-    async fn test_refresh_streams_a_multi_batch_fragment() {
-        let values: Vec<i32> = (0..20_000).collect();
-        let table = table_with("refresh_multi_batch", values.clone()).await;
-        declare_doubled(&table).await.unwrap();
-
-        let result = table.refresh_column("doubled").await.unwrap();
-        assert_eq!(result.rows_filled, 20_000);
-
-        let read_back = read(&table, "doubled").await;
-        assert_eq!(read_back.len(), 20_000);
-        let mut expected: Vec<Option<i32>> = values.iter().map(|v| Some(v * 2)).collect();
-        expected.sort();
-        assert_eq!(read_back, expected);
-    }
-
-    /// The gate's reproducer: the commit must reuse the configured session,
-    /// or registrations and caches vanish from the handle after a refresh.
-    #[tokio::test]
-    async fn test_refresh_preserves_the_configured_session() {
-        let session = Arc::new(lance::session::Session::default());
-        let conn = crate::connect("memory://")
-            .session(session.clone())
-            .execute()
-            .await
-            .unwrap();
-        let batch = record_batch!(("x", Int32, [1, 2])).unwrap();
-        let table = conn
-            .create_table("session_kept", batch)
-            .execute()
-            .await
-            .unwrap();
-        declare_doubled(&table).await.unwrap();
-        table.refresh_column("doubled").await.unwrap();
-
-        let dataset = table.as_native().unwrap().dataset.get().await.unwrap();
-        assert!(Arc::ptr_eq(&dataset.session(), &session));
-    }
-
-    /// The async form's job settles with the fill visible, like
-    /// create_index's execute_async.
-    #[tokio::test]
-    async fn test_refresh_async_job_waits_for_the_fill() {
-        let table = table_with("refresh_async", vec![1, 2, 3]).await;
-        declare_doubled(&table).await.unwrap();
-
-        let job = table.refresh_column_async("doubled").await.unwrap();
-        assert!(job.id().is_none(), "in-process jobs have no server id");
-        job.wait().await.unwrap();
-        assert_eq!(job.status().await.unwrap(), "finished");
-        assert_eq!(
-            read(&table, "doubled").await,
-            vec![Some(2), Some(4), Some(6)]
-        );
-    }
-
-    /// Bad input is reported by the call, not by the job.
-    #[tokio::test]
-    async fn test_refresh_async_rejects_bad_input_before_spawning() {
-        let table = table_with("refresh_async_bad", vec![1, 2, 3]).await;
-
-        let err = table.refresh_column_async("x").await.unwrap_err();
-        assert!(matches!(err, Error::NotAComputedColumn { name } if name == "x"));
-
-        let err = table.refresh_column_async("nope").await.unwrap_err();
-        assert!(matches!(err, Error::ColumnNotFound { name } if name == "nope"));
-    }
-
-    #[tokio::test]
-    async fn test_refresh_async_job_reports_success_to_every_waiter() {
-        let table = table_with("refresh_async_waiters", vec![1, 2]).await;
-        declare_doubled(&table).await.unwrap();
-
-        let job = table.refresh_column_async("doubled").await.unwrap();
-        job.wait().await.unwrap();
-        // A second wait after completion observes the same outcome.
-        job.wait().await.unwrap();
-        assert_eq!(job.status().await.unwrap(), "finished");
-    }
-
-    #[tokio::test]
-    async fn test_refresh_rejects_a_plain_column() {
-        let table = table_with("refresh_plain", vec![1, 2, 3]).await;
-        let err = table.refresh_column("x").await.unwrap_err();
-        assert!(matches!(err, Error::NotAComputedColumn { name } if name == "x"));
-    }
-
-    #[tokio::test]
-    async fn test_refresh_rejects_an_unknown_column() {
-        let table = table_with("refresh_missing", vec![1, 2, 3]).await;
-        let err = table.refresh_column("nope").await.unwrap_err();
-        assert!(matches!(err, Error::ColumnNotFound { name } if name == "nope"));
-    }
-
-    /// The gate's reproducer: a poison value in a deleted row must not
-    /// abort filling the live rows, since nobody can read it.
-    #[tokio::test]
-    async fn test_a_deleted_rows_value_is_never_evaluated() {
-        let table = table_with("refresh_deleted_poison", vec![1, 0]).await;
-        table
-            .add_columns()
-            .computed("quotient", "10 / x")
-            .execute()
-            .await
-            .unwrap();
-        table.delete("x = 0").await.unwrap();
-
-        let result = table.refresh_column("quotient").await.unwrap();
-        assert_eq!(result.rows_filled, 1);
-        assert_eq!(read(&table, "quotient").await, vec![Some(10)]);
-    }
-
-    /// The gate's reproducer: an already-filled row's value must not be
-    /// re-evaluated either -- its input may have mutated into one the
-    /// expression chokes on.
-    #[tokio::test]
-    async fn test_a_filled_rows_value_is_never_evaluated() {
-        let table = table_with("refresh_filled_poison", vec![1, 2]).await;
-        table
-            .add_columns()
-            .computed("quotient", "10 / x")
-            .execute()
-            .await
-            .unwrap();
-        table.refresh_column("quotient").await.unwrap();
-
-        table
-            .update()
-            .column("x", "0")
-            .only_if("x = 1")
-            .execute()
-            .await
-            .unwrap();
-        append(&table, vec![5]).await;
-
-        let result = table.refresh_column("quotient").await.unwrap();
-        assert_eq!(result.rows_filled, 1);
-        assert_eq!(
-            read(&table, "quotient").await,
-            vec![Some(2), Some(5), Some(10)]
-        );
-    }
-
-    /// The gate's reproducer: the old internal projection alias is an
-    /// ordinary column name; a computed column may use it.
-    #[tokio::test]
-    async fn test_refresh_a_column_named_like_the_old_alias() {
-        let table = table_with("refresh_alias_name", vec![1, 2]).await;
-        table
-            .add_columns()
-            .computed("__lancedb_computed", "x * 2")
-            .execute()
-            .await
-            .unwrap();
-
-        let result = table.refresh_column("__lancedb_computed").await.unwrap();
-        assert_eq!(result.rows_filled, 2);
-        assert_eq!(
-            read(&table, "__lancedb_computed").await,
-            vec![Some(2), Some(4)]
-        );
-    }
-
-    /// The gate's reproducer: a late-gain fragment (filled, then one null row
-    /// compacted onto the end) fills without the old probe's buffering, which
-    /// this pins behaviorally; the memory bound is structural -- the fill
-    /// stream retains no batches at all.
-    #[tokio::test]
-    async fn test_refresh_fills_a_late_gain_fragment() {
-        let values: Vec<i32> = (0..20_000).collect();
-        let table = table_with("refresh_late_gain", values).await;
-        declare_doubled(&table).await.unwrap();
-        table.refresh_column("doubled").await.unwrap();
-
-        append(&table, vec![2_000_000]).await;
-        table
-            .optimize(crate::table::OptimizeAction::Compact {
-                options: crate::table::CompactionOptions::default(),
-                remap_options: None,
-            })
-            .await
-            .unwrap();
-
-        let result = table.refresh_column("doubled").await.unwrap();
-        assert_eq!(result.rows_filled, 1);
-        let read_back = read(&table, "doubled").await;
-        assert_eq!(read_back.len(), 20_001);
-        assert_eq!(read_back.last().unwrap(), &Some(4_000_000));
-    }
-
-    /// The gate's reproducer: a nested input declares, refreshes, and guards
-    /// its root against invalidating schema changes.
-    #[tokio::test]
-    async fn test_a_nested_input_declares_and_refreshes() {
-        use arrow_array::{Int32Array, StructArray};
-        use arrow_schema::{DataType, Field, Fields};
-
-        let conn = connect("memory://").execute().await.unwrap();
-        let age = Arc::new(Int32Array::from(vec![30, 40]));
-        let fields = Fields::from(vec![Field::new("age", DataType::Int32, true)]);
-        let metadata = StructArray::new(fields.clone(), vec![age as _], None);
-        let schema = Arc::new(arrow_schema::Schema::new(vec![Field::new(
-            "metadata",
-            DataType::Struct(fields),
-            true,
-        )]));
-        let batch =
-            arrow_array::RecordBatch::try_new(schema, vec![Arc::new(metadata) as _]).unwrap();
-        let table = conn
-            .create_table("refresh_nested", batch)
-            .execute()
-            .await
-            .unwrap();
-
-        table
-            .add_columns()
-            .computed("next_age", "metadata.age + 1")
-            .execute()
-            .await
-            .unwrap();
-        let declaration =
-            &crate::table::computed_columns(table.schema().await.unwrap().as_ref())[0];
-        assert_eq!(declaration.inputs, vec!["metadata.age".to_string()]);
-
-        let result = table.refresh_column("next_age").await.unwrap();
-        assert_eq!(result.rows_filled, 2);
-        assert_eq!(read(&table, "next_age").await, vec![Some(31), Some(41)]);
-
-        // The dotted input guards its root.
-        let err = table.drop_columns(&["metadata"]).await.unwrap_err();
-        assert!(
-            matches!(&err, Error::InvalidInput { message } if message.contains("next_age")),
-            "{err:?}"
-        );
-
-        // Masking a struct input for a deleted row goes through the same
-        // nullif path as a primitive; a nested input plus deletions must not
-        // be the combination that breaks it.
-        table.delete("next_age = 31").await.unwrap();
-        append_struct_row(&table, 50).await;
-        let result = table.refresh_column("next_age").await.unwrap();
-        assert_eq!(result.rows_filled, 1);
-        assert_eq!(read(&table, "next_age").await, vec![Some(41), Some(51)]);
-    }
-
-    /// Append one `metadata: {age}` row to the nested-input table.
-    async fn append_struct_row(table: &Table, age: i32) {
-        use arrow_array::{Int32Array, StructArray};
-        use arrow_schema::{DataType, Field, Fields};
-
-        let ages = Arc::new(Int32Array::from(vec![age]));
-        let fields = Fields::from(vec![Field::new("age", DataType::Int32, true)]);
-        let metadata = StructArray::new(fields.clone(), vec![ages as _], None);
-        let schema = Arc::new(arrow_schema::Schema::new(vec![Field::new(
-            "metadata",
-            DataType::Struct(fields),
-            true,
-        )]));
-        let batch =
-            arrow_array::RecordBatch::try_new(schema, vec![Arc::new(metadata) as _]).unwrap();
-        table.add(batch).execute().await.unwrap();
-    }
-
-    /// Both orders of declare+spec are refused at the source (see the
-    /// schema_evolution tests); refresh's own check covers a dataset another
-    /// writer left in that state.
-    #[tokio::test]
-    async fn test_refresh_refuses_a_foreign_lsm_state() {
-        use crate::table::LsmWriteSpec;
-
-        let tmp_dir = tempfile::tempdir().unwrap();
-        let conn = connect(tmp_dir.path().to_str().unwrap())
-            .execute()
-            .await
-            .unwrap();
-        let schema = Arc::new(arrow_schema::Schema::new(vec![arrow_schema::Field::new(
-            "x",
-            arrow_schema::DataType::Int32,
-            false,
-        )]));
-        let batch =
-            arrow_array::RecordBatch::try_new(schema, vec![Arc::new(Int32Array::from(vec![1]))])
-                .unwrap();
-        let table = conn.create_table("lsm", batch).execute().await.unwrap();
-        table.set_unenforced_primary_key(["x"]).await.unwrap();
-        table
-            .set_lsm_write_spec(LsmWriteSpec::unsharded())
-            .await
-            .unwrap();
-        super::super::computed_columns::add_foreign_kind(&table, "doubled", "sql").await;
-
-        let err = table.refresh_column("doubled").await.unwrap_err();
-        assert!(
-            matches!(&err, Error::NotSupported { message } if message.contains("LSM")),
-            "{err:?}"
-        );
-        let err = table.refresh_column_async("doubled").await.unwrap_err();
-        assert!(matches!(err, Error::NotSupported { .. }));
-    }
-
-    /// After catch-up activation and unset, no spec remains but the catch-up
-    /// flag still marks retained SSTable rows; refresh refuses on the flag.
-    #[tokio::test]
-    async fn test_refresh_refuses_retained_catchup_state() {
-        use crate::table::LsmWriteSpec;
-
-        let tmp_dir = tempfile::tempdir().unwrap();
-        let conn = connect(tmp_dir.path().to_str().unwrap())
-            .execute()
-            .await
-            .unwrap();
-        let schema = Arc::new(arrow_schema::Schema::new(vec![arrow_schema::Field::new(
-            "x",
-            arrow_schema::DataType::Int32,
-            false,
-        )]));
-        let batch = arrow_array::RecordBatch::try_new(
-            schema.clone(),
-            vec![Arc::new(Int32Array::from(vec![1]))],
-        )
-        .unwrap();
-        let table = conn
-            .create_table("catchup", batch.clone())
-            .execute()
-            .await
-            .unwrap();
-        table.set_unenforced_primary_key(["x"]).await.unwrap();
-        table
-            .set_lsm_write_spec(LsmWriteSpec::unsharded())
-            .await
-            .unwrap();
-        table.require_mem_wal_index_catchup().await.unwrap();
-        let mut merge = table.merge_insert(&["x"]);
-        merge
-            .when_matched_update_all(None)
-            .when_not_matched_insert_all()
-            .use_lsm(true);
-        merge
-            .execute(Box::new(arrow_array::RecordBatchIterator::new(
-                vec![Ok(batch)],
-                schema,
-            )))
-            .await
-            .unwrap();
-        table.unset_lsm_write_spec().await.unwrap();
-        super::super::computed_columns::add_foreign_kind(&table, "doubled", "sql").await;
-
-        let err = table.refresh_column("doubled").await.unwrap_err();
-        assert!(
-            matches!(&err, Error::NotSupported { message } if message.contains("LSM")),
-            "{err:?}"
-        );
-    }
-
-    /// A declaration of a kind this version cannot evaluate is refused by
-    /// name, rather than mistaken for a plain column or fed to the SQL path.
-    #[tokio::test]
-    async fn test_refresh_rejects_a_kind_it_cannot_evaluate() {
-        let table = table_with("refresh_foreign", vec![1, 2, 3]).await;
-        super::super::computed_columns::add_foreign_kind(&table, "embedding", "udf").await;
-
-        let err = table.refresh_column("embedding").await.unwrap_err();
-        assert!(matches!(err, Error::NotSupported { message } if message.contains("udf")));
-    }
-}
@@ -8,14 +8,12 @@
 //! - [`alter_columns`](execute_alter_columns): Rename columns, change types, or modify nullability
 //! - [`drop_columns`](execute_drop_columns): Remove columns from the table

-use arrow_schema::Schema as ArrowSchema;
 use lance::dataset::{ColumnAlteration, NewColumnTransform};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;

-use super::computed_columns;
-use super::{BaseTable, NativeTable};
-use crate::{Error, Result};
+use super::NativeTable;
+use crate::Result;

 /// The result of an add columns operation.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
@@ -100,48 +98,6 @@ pub(crate) async fn execute_add_columns(
    table: &NativeTable,
    transforms: NewColumnTransform,
    read_columns: Option<Vec<String>>,
-) -> Result<AddColumnsResult> {
-    // Declarations are admitted only through [`execute_declare`].
-    match &transforms {
-        NewColumnTransform::AllNulls(schema) => {
-            computed_columns::ensure_no_foreign_declarations(schema.fields())?
-        }
-        NewColumnTransform::BatchUDF(udf) => {
-            computed_columns::ensure_no_foreign_declarations(udf.output_schema.fields())?
-        }
-        _ => {}
-    }
-    commit_add_columns(table, transforms, read_columns).await
-}
-
-/// Declare validated computed columns. The only admission path for
-/// declaration metadata.
-pub(crate) async fn execute_declare(
-    table: &NativeTable,
-    columns: &[(String, String)],
-) -> Result<AddColumnsResult> {
-    // An LSM write spec keeps visible rows in tiers refresh cannot reach;
-    // checked against latest committed state, not this handle's snapshot.
-    // The catch-up flag outlives unset and marks retained SSTable rows.
-    table.checkout_latest().await?;
-    let catchup = table.dataset.get().await?.manifest().reader_feature_flags
-        & lance_table::feature_flags::FLAG_MEM_WAL_INDEX_CATCHUP
-        != 0;
-    if catchup || table.get_lsm_write_spec().await?.is_some() {
-        return Err(Error::NotSupported {
-            message: "computed columns are not supported on a table with an LSM write \
-                      spec: rows in un-compacted tiers are invisible to refresh"
-                .into(),
-        });
-    }
-    let transform = computed_columns::declare(table.schema().await?, columns)?;
-    commit_add_columns(table, transform, None).await
-}
-
-pub(crate) async fn commit_add_columns(
-    table: &NativeTable,
-    transforms: NewColumnTransform,
-    read_columns: Option<Vec<String>>,
 ) -> Result<AddColumnsResult> {
    table.dataset.ensure_mutable()?;
    let mut dataset = (*table.dataset.get().await?).clone();
@@ -160,21 +116,6 @@ pub(crate) async fn execute_alter_columns(
 ) -> Result<AlterColumnsResult> {
    table.dataset.ensure_mutable()?;
    let mut dataset = (*table.dataset.get().await?).clone();
-    // Nullability is not part of what an expression resolves against, so only
-    // a rename or a retype can invalidate a binding.
-    let schema = std::sync::Arc::new(ArrowSchema::from(dataset.schema()));
-    let rebinding = alterations
-        .iter()
-        .filter(|alteration| alteration.rename.is_some() || alteration.data_type.is_some())
-        .map(|alteration| alteration.path.as_str())
-        .collect::<Vec<_>>();
-    computed_columns::ensure_not_an_input(&schema, &rebinding)?;
-    let retyped = alterations
-        .iter()
-        .filter(|alteration| alteration.data_type.is_some())
-        .map(|alteration| alteration.path.as_str())
-        .collect::<Vec<_>>();
-    computed_columns::ensure_not_retyped(schema.as_ref(), &retyped)?;
    dataset.alter_columns(alterations).await?;
    let version = dataset.version().version;
    table.dataset.update(dataset);
@@ -190,10 +131,6 @@ pub(crate) async fn execute_drop_columns(
 ) -> Result<DropColumnsResult> {
    table.dataset.ensure_mutable()?;
    let mut dataset = (*table.dataset.get().await?).clone();
-    computed_columns::ensure_not_an_input(
-        &std::sync::Arc::new(ArrowSchema::from(dataset.schema())),
-        columns,
-    )?;
    dataset.drop_columns(columns).await?;
    let version = dataset.version().version;
    table.dataset.update(dataset);
@@ -210,44 +147,6 @@ pub(crate) async fn execute_update_field_metadata(
    table.dataset.ensure_mutable()?;
    let mut dataset = (*table.dataset.get().await?).clone();

-    // A declaration is validated as a whole at declare time; editing its keys
-    // here would bypass that, fabricate one on a plain column, or move a
-    // binding out from under a refresh. A replace on a declared column would
-    // silently erase it.
-    let schema = ArrowSchema::from(dataset.schema());
-    let declared: Vec<String> = computed_columns::computed_columns(&schema)
-        .into_iter()
-        .map(|declaration| declaration.name)
-        .collect();
-    for update in updates {
-        if update
-            .metadata
-            .keys()
-            .any(|key| computed_columns::is_declaration_key(key))
-        {
-            return Err(Error::InvalidInput {
-                message: format!(
-                    "metadata keys of a computed-column declaration cannot be edited \
-                     (path '{}'); drop the column and declare it again",
-                    update.path
-                ),
-            });
-        }
-        if update.replace
-            && declared
-                .iter()
-                .any(|name| name == computed_columns::root(&update.path))
-        {
-            return Err(Error::InvalidInput {
-                message: format!(
-                    "replacing all metadata of computed column '{}' would erase its \
-                     declaration; drop the column and declare it again",
-                    update.path
-                ),
-            });
-        }
-    }
-
    let mut builder = dataset.update_field_metadata();
    for update in updates {
        let entries = update.metadata.iter().map(|(k, v)| (k.clone(), v.clone()));
@@ -82,10 +82,6 @@ pub(crate) async fn execute_update(

    // 1. Snapshot the current dataset
    let dataset = table.dataset.get().await?;
-    super::computed_columns::ensure_not_written(
-        &arrow_schema::Schema::from(dataset.schema()),
-        update.columns.iter().map(|(name, _)| name.as_str()),
-    )?;

    // 2. Initialize the Lance Core builder
    let mut builder = LanceUpdateBuilder::new(dataset);
@@ -10,7 +10,7 @@ use arrow_array::{
 use arrow_schema::{DataType, Field, Fields, Schema};
 use futures::TryStreamExt;
 use lance::Dataset;
-use lance_file::version::{ConcreteFileVersion, LanceFileVersion};
+use lance_file::version::LanceFileVersion;
 use lancedb::{
    Connection, Error, Result, Table,
    blob::{BlobRangeRequest, blob},
@@ -61,7 +61,7 @@ async fn create_inline_blob_table(
    Ok(table)
 }

-async fn storage_format_version(table: &Table) -> ConcreteFileVersion {
+async fn storage_format_version(table: &Table) -> LanceFileVersion {
    table
        .as_native()
        .unwrap()
@@ -69,14 +69,9 @@ async fn storage_format_version(table: &Table) -> ConcreteFileVersion {
        .await
        .unwrap()
        .data_storage_format
-        .lance_file_format()
-}
-
-fn supports_blob_v2(version: ConcreteFileVersion) -> bool {
-    matches!(
-        version,
-        ConcreteFileVersion::V2_2 | ConcreteFileVersion::V2_3
-    )
+        .lance_file_version()
+        .unwrap()
+        .resolve()
 }

 async fn uses_stable_row_ids(table: &Table) -> bool {
@@ -117,7 +112,7 @@ async fn declaring_blob_column_bumps_format_and_enables_stable_row_ids() -> Resu
        .execute()
        .await?;

-    assert!(supports_blob_v2(storage_format_version(&table).await));
+    assert!(storage_format_version(&table).await >= LanceFileVersion::V2_2);
    assert!(uses_stable_row_ids(&table).await);
    Ok(())
 }
@@ -132,7 +127,7 @@ async fn explicit_stable_row_id_setting_wins_over_blob_default() -> Result<()> {
        .execute()
        .await?;

-    assert!(supports_blob_v2(storage_format_version(&table).await));
+    assert!(storage_format_version(&table).await >= LanceFileVersion::V2_2);
    assert!(!uses_stable_row_ids(&table).await);
    Ok(())
 }
@@ -144,7 +139,7 @@ async fn non_blob_table_keeps_default_format_and_row_id_setting() -> Result<()>
    let schema = Arc::new(Schema::new(vec![Field::new("id", DataType::Int64, false)]));
    let table = db.create_empty_table("t", schema).execute().await?;

-    assert!(!supports_blob_v2(storage_format_version(&table).await));
+    assert!(storage_format_version(&table).await < LanceFileVersion::V2_2);
    assert!(!uses_stable_row_ids(&table).await);
    Ok(())
 }
@@ -176,7 +171,7 @@ async fn creating_with_blob_data_bumps_format() -> Result<()> {
    .unwrap();
    let table = db.create_table("t", batch).execute().await?;

-    assert!(supports_blob_v2(storage_format_version(&table).await));
+    assert!(storage_format_version(&table).await >= LanceFileVersion::V2_2);
    assert!(uses_stable_row_ids(&table).await);
    assert_eq!(table.count_rows(None).await?, 1);
    Ok(())
@@ -286,7 +281,7 @@ async fn connection_level_stable_row_id_setting_wins_over_blob_default() -> Resu
        .execute()
        .await?;

-    assert!(supports_blob_v2(storage_format_version(&table).await));
+    assert!(storage_format_version(&table).await >= LanceFileVersion::V2_2);
    assert!(!uses_stable_row_ids(&table).await);
    Ok(())
 }
@@ -302,7 +297,7 @@ async fn namespace_create_applies_blob_defaults() -> Result<()> {
        .execute()
        .await?;

-    assert!(supports_blob_v2(storage_format_version(&table).await));
+    assert!(storage_format_version(&table).await >= LanceFileVersion::V2_2);
    assert!(uses_stable_row_ids(&table).await);
    Ok(())
 }
@@ -479,7 +474,7 @@ async fn fetch_blobs_round_trips_nested_blob_column() -> Result<()> {
    let batch = RecordBatch::try_new(schema, vec![Arc::new(info_array) as ArrayRef]).unwrap();
    let table = db.create_table("t", batch).execute().await?;

-    assert!(supports_blob_v2(storage_format_version(&table).await));
+    assert!(storage_format_version(&table).await >= LanceFileVersion::V2_2);
    assert!(uses_stable_row_ids(&table).await);

    let ids = collect_row_ids(&table).await?;
@@ -1310,7 +1305,7 @@ async fn optimize_preserves_blob_v2_null_and_empty_distinction() -> Result<()> {
        .await?;
    table.add(null_empty_input_batch()).execute().await?;
    assert!(
-        supports_blob_v2(storage_format_version(&table).await),
+        storage_format_version(&table).await >= LanceFileVersion::V2_2,
        "blob v2 columns require storage >= 2.2"
    );
Author	SHA1	Message	Date
Xuanwo	fce9bfc3c7	fix(ci): allow recovery artifact downloads	2026-08-10 18:00:09 +08:00
Xuanwo	67fe08bf71	fix(ci): recover timed-out Windows release builds	2026-08-10 17:52:48 +08:00
Lance Release	b89f87f206	Bump version: 0.37.1-beta.3 → 0.37.1	2026-08-10 07:54:42 +00:00
Lance Release	a022d3bcb3	Bump version: 0.37.1-beta.2 → 0.37.1-beta.3	2026-08-10 07:53:53 +00:00
Lance Release	8268532d64	Bump version: 0.37.1-beta.1 → 0.37.1-beta.2	2026-08-10 06:30:45 +00:00
Xuanwo	f933ef9b21	fix(ci): tag releases after updating lockfiles	2026-08-10 14:23:41 +08:00
Xuanwo	e885e5dd00	fix(ci): validate stable Lance dependencies	2026-08-10 14:23:33 +08:00
Xuanwo	7c7efa9743	feat: update lance dependency to v10.0.0	2026-08-10 14:23:29 +08:00