Bump version: 0.38.0-beta.3 → 0.38.0-beta.4

2026-09-04 12:38:38 +00:00 · 2026-08-22 16:38:08 +00:00
107 changed files with 1202 additions and 8010 deletions
@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.38.0-beta.10"
+current_version = "0.38.0-beta.4"
 parse = """(?x)
    (?P<major>0|[1-9]\\d*)\\.
    (?P<minor>0|[1-9]\\d*)\\.
@@ -3455,8 +3455,8 @@ checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"

 [[package]]
 name = "fsst"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-array",
 "rand 0.9.5",
@@ -4815,8 +4815,8 @@ checksum = "e037a2e1d8d5fdbd49b16a4ea09d5d6401c1f29eca5ff29d03d3824dba16256a"

 [[package]]
 name = "lance"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arc-swap",
 "arrow",
@@ -4888,8 +4888,8 @@ dependencies = [

 [[package]]
 name = "lance-arrow"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -4911,7 +4911,7 @@ dependencies = [
 [[package]]
 name = "lance-arrow-scalar"
 version = "58.0.0"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -4925,7 +4925,7 @@ dependencies = [
 [[package]]
 name = "lance-arrow-stats"
 version = "58.0.0"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-array",
 "arrow-schema",
@@ -4934,8 +4934,8 @@ dependencies = [

 [[package]]
 name = "lance-bitpacking"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrayref",
 "crunchy",
@@ -4945,8 +4945,8 @@ dependencies = [

 [[package]]
 name = "lance-core"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -4983,8 +4983,8 @@ dependencies = [

 [[package]]
 name = "lance-datafusion"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -5013,8 +5013,8 @@ dependencies = [

 [[package]]
 name = "lance-datagen"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -5031,8 +5031,8 @@ dependencies = [

 [[package]]
 name = "lance-derive"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -5041,8 +5041,8 @@ dependencies = [

 [[package]]
 name = "lance-encoding"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-arith",
 "arrow-array",
@@ -5075,8 +5075,8 @@ dependencies = [

 [[package]]
 name = "lance-file"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-arith",
 "arrow-array",
@@ -5107,8 +5107,8 @@ dependencies = [

 [[package]]
 name = "lance-index"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arc-swap",
 "arrow",
@@ -5172,8 +5172,8 @@ dependencies = [

 [[package]]
 name = "lance-index-core"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-array",
 "arrow-schema",
@@ -5195,8 +5195,8 @@ dependencies = [

 [[package]]
 name = "lance-io"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -5222,11 +5222,7 @@ dependencies = [
 "pin-project",
 "prost",
 "rand 0.9.5",
- "reqsign-core",
- "reqsign-file-read-tokio",
- "reqsign-google",
 "serde",
- "serde_json",
 "tempfile",
 "tokio",
 "tracing",
@@ -5236,8 +5232,8 @@ dependencies = [

 [[package]]
 name = "lance-linalg"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-array",
 "arrow-schema",
@@ -5251,8 +5247,8 @@ dependencies = [

 [[package]]
 name = "lance-namespace"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow",
 "async-trait",
@@ -5264,8 +5260,8 @@ dependencies = [

 [[package]]
 name = "lance-namespace-impls"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow",
 "arrow-ipc",
@@ -5318,8 +5314,8 @@ dependencies = [

 [[package]]
 name = "lance-select"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -5333,8 +5329,8 @@ dependencies = [

 [[package]]
 name = "lance-table"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -5374,8 +5370,8 @@ dependencies = [

 [[package]]
 name = "lance-testing"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "arrow-array",
 "arrow-schema",
@@ -5388,8 +5384,8 @@ dependencies = [

 [[package]]
 name = "lance-tokenizer"
-version = "12.0.0-beta.2"
-source = "git+https://github.com/lance-format/lance.git?tag=v12.0.0-beta.2#dafa4642658d996b3e31dde91e02f72db7860d7e"
+version = "11.0.0-beta.19"
+source = "git+https://github.com/lance-format/lance.git?tag=v11.0.0-beta.19#3128c0024427cb5bf8c04d492893ae45e78b0511"
 dependencies = [
 "frostem",
 "icu_segmenter",
@@ -5402,7 +5398,7 @@ dependencies = [

 [[package]]
 name = "lancedb"
-version = "0.38.0-beta.10"
+version = "0.38.0-beta.3"
 dependencies = [
 "ahash",
 "anyhow",
@@ -5490,7 +5486,7 @@ dependencies = [

 [[package]]
 name = "lancedb-nodejs"
-version = "0.38.0-beta.10"
+version = "0.38.0-beta.3"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -5515,7 +5511,7 @@ dependencies = [

 [[package]]
 name = "lancedb-python"
-version = "0.38.0-beta.10"
+version = "0.38.0-beta.3"
 dependencies = [
 "arrow",
 "async-trait",
@@ -13,20 +13,20 @@ categories = ["database-implementations"]
 rust-version = "1.91.0"

 [workspace.dependencies]
-lance = { "version" = "=12.0.0-beta.2", default-features = false, "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-core = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-datagen = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-file = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-io = { "version" = "=12.0.0-beta.2", default-features = false, "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-index = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-linalg = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-namespace = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-namespace-impls = { "version" = "=12.0.0-beta.2", default-features = false, "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-table = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-testing = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-datafusion = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-encoding = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
-lance-arrow = { "version" = "=12.0.0-beta.2", "tag" = "v12.0.0-beta.2", "git" = "https://github.com/lance-format/lance.git" }
+lance = { "version" = "=11.0.0-beta.19", default-features = false, "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-core = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-datagen = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-file = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-io = { "version" = "=11.0.0-beta.19", default-features = false, "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-index = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-linalg = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-namespace = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-namespace-impls = { "version" = "=11.0.0-beta.19", default-features = false, "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-table = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-testing = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-datafusion = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-encoding = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
+lance-arrow = { "version" = "=11.0.0-beta.19", "tag" = "v11.0.0-beta.19", "git" = "https://github.com/lance-format/lance.git" }
 lancedb = { path = "rust/lancedb", default-features = false }
 ahash = "0.8"
 # Note that this one does not include pyarrow
@@ -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.10</version>
+    <version>0.38.0-beta.4</version>
 </dependency>
 ```

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

 ***

-### listTables()
-
-#### listTables(options)
-
-```ts
-abstract listTables(options?): Promise<ListTablesResponse>
-```
-
-List a page of the tables in this database.
-
-To retrieve the tables after the page, pass the `pageToken` the response
-carries back in. A page can be shorter than `limit` without being the last
-one, so walk until a response carries no page token:
-
-```ts
-const names = [];
-let pageToken = undefined;
-do {
-  const page = await conn.listTables({ pageToken, limit: 100 });
-  names.push(...page.tables);
-  pageToken = page.pageToken;
-} while (pageToken);
-```
-
-##### Parameters
-
-* **options?**: `Partial`&lt;[`ListTablesOptions`](../interfaces/ListTablesOptions.md)&gt;
-    Pagination options
-    (`pageToken`, `limit`).
-
-##### Returns
-
-`Promise`&lt;[`ListTablesResponse`](../interfaces/ListTablesResponse.md)&gt;
-
-A page of table names and an
-  optional token for the tables after it.
-
-#### listTables(namespacePath, options)
-
-```ts
-abstract listTables(namespacePath?, options?): Promise<ListTablesResponse>
-```
-
-List a page of the tables in this database.
-
-##### Parameters
-
-* **namespacePath?**: `string`[]
-    The namespace path to list tables from
-    (defaults to root namespace)
-
-* **options?**: `Partial`&lt;[`ListTablesOptions`](../interfaces/ListTablesOptions.md)&gt;
-    Pagination options
-    (`pageToken`, `limit`).
-
-##### Returns
-
-`Promise`&lt;[`ListTablesResponse`](../interfaces/ListTablesResponse.md)&gt;
-
-A page of table names and an
-  optional token for the tables after it.
-
-***
-
 ### openMaterializedView()

 ```ts
@@ -724,7 +660,7 @@ a "not supported" error.

 ***

-### ~~tableNames()~~
+### tableNames()

 #### tableNames(options)

@@ -746,10 +682,6 @@ Tables will be returned in lexicographical order.

 `Promise`&lt;`string`[]&gt;

-##### Deprecated
-
-Use [Connection.listTables](Connection.md#listtables) instead.
-
 #### tableNames(namespacePath, options)

 ```ts
@@ -772,7 +704,3 @@ Tables will be returned in lexicographical order.
 ##### Returns

 `Promise`&lt;`string`[]&gt;
-
-##### Deprecated
-
-Use [Connection.listTables](Connection.md#listtables) instead.
@@ -942,7 +942,7 @@ Get the schema of the table.
 abstract search(
   query,
   queryType?,
-   ftsColumns?): Query | VectorQuery | AutoQuery
+   ftsColumns?): Query | VectorQuery
 ```

 Create a search query to find the nearest neighbors
@@ -964,7 +964,7 @@ of the given query

 #### Returns

-[`Query`](Query.md) \| [`VectorQuery`](VectorQuery.md) \| [`AutoQuery`](AutoQuery.md)
+[`Query`](Query.md) \| [`VectorQuery`](VectorQuery.md)

 ***

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

 ## Classes

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

 [@lancedb/lancedb](../globals.md) / TableNamesOptions

-# Interface: ~~TableNamesOptions~~
-
-## Deprecated
-
-Use [ListTablesOptions](ListTablesOptions.md) with [Connection.listTables](../classes/Connection.md#listtables)
-instead.
+# Interface: TableNamesOptions

 ## Properties

-### ~~limit?~~
+### limit?

 ```ts
 optional limit: number;
@@ -23,7 +18,7 @@ An optional limit to the number of results to return.

 ***

-### ~~startAfter?~~
+### startAfter?

 ```ts
 optional startAfter: string;
@@ -10,12 +10,16 @@
 function getRegistry(): EmbeddingFunctionRegistry
 ```

-Get the global embedding function registry.
-
-LanceDB built-in providers are initialized when this public API is first
-used, so importing the root package does not change automatic search
-selection for tables without embedding metadata.
+Utility function to get the global instance of the registry

 ## Returns

 [`EmbeddingFunctionRegistry`](../classes/EmbeddingFunctionRegistry.md)
+
+`EmbeddingFunctionRegistry` The global instance of the registry
+
+## Example
+
+```ts
+const registry = getRegistry();
+const openai = registry.get("openai").create();
@@ -261,8 +261,6 @@ instead of being materialized with the rest of the row.

 ::: lancedb.streaming.StreamingDataset

-::: lancedb.streaming.StreamingDataLoader
-
 ::: lancedb.permutation.permutation_builder

 ::: lancedb.permutation.PermutationBuilder
@@ -8,7 +8,7 @@
    <parent>
      <groupId>com.lancedb</groupId>
      <artifactId>lancedb-parent</artifactId>
-      <version>0.38.0-beta.10</version>
+      <version>0.38.0-beta.4</version>
      <relativePath>../pom.xml</relativePath>
    </parent>

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

    <groupId>com.lancedb</groupId>
    <artifactId>lancedb-parent</artifactId>
-    <version>0.38.0-beta.10</version>
+    <version>0.38.0-beta.4</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>12.0.0-beta.2</lance-core.version>
+        <lance-core.version>11.0.0-beta.19</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.10"
+version = "0.38.0-beta.4"
 publish = false
 license.workspace = true
 description.workspace = true
@@ -515,137 +515,6 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
        );
      });

-      it("will allow matching inferred types across records", function () {
-        expect(() =>
-          makeArrowTable([{ value: 1 }, { value: 2 }]),
-        ).not.toThrow();
-      });
-
-      it("will reject mismatched inferred types across records", function () {
-        expect(() => makeArrowTable([{ value: 1 }, { value: "two" }])).toThrow(
-          "Failed to infer schema for data. Previously inferred type Float64 but found Utf8 for field value at row 1. Consider providing an explicit schema.",
-        );
-      });
-
-      it("will ignore generated dictionary IDs when comparing inferred types", function () {
-        const table = makeArrowTable([{ str: "a" }, { str: "b" }], {
-          dictionaryEncodeStrings: true,
-        });
-
-        expect(table.getChild("str")?.toJSON()).toEqual(["a", "b"]);
-      });
-
-      it("will preserve null values without treating them as type mismatches", function () {
-        for (const records of [
-          [{ vector: [1, 2, 3] }, { vector: null }],
-          [{ vector: null }, { vector: [1, 2, 3] }],
-        ]) {
-          const table = makeArrowTable(records);
-
-          expect(table.numRows).toBe(2);
-          expect(table.getChild("vector")?.nullCount).toBe(1);
-        }
-      });
-
-      it("will preserve empty variable-size lists", function () {
-        for (const records of [
-          [{ items: [1] }, { items: [] }],
-          [{ items: [] }, { items: [1] }],
-        ]) {
-          const table = makeArrowTable(records);
-          expect(
-            table
-              .getChild("items")
-              ?.toJSON()
-              .map((value) => value.toJSON()),
-          ).toEqual(records.map((record) => record.items));
-        }
-      });
-
-      it("will propagate deferred evidence through nested lists", function () {
-        for (const records of [
-          [{ items: [1] }, { items: [null] }],
-          [{ items: [null] }, { items: [1] }],
-          [{ items: [null, 1] }, { items: [2, null] }],
-        ]) {
-          const table = makeArrowTable(records);
-          expect(
-            table
-              .getChild("items")
-              ?.toJSON()
-              .map((value) => value.toJSON()),
-          ).toEqual(records.map((record) => record.items));
-        }
-
-        const nestedRecords = [{ items: [[1]] }, { items: [[null]] }];
-        const nestedTable = makeArrowTable(nestedRecords);
-        expect(
-          nestedTable
-            .getChild("items")
-            ?.toJSON()
-            .map((value) =>
-              value
-                .toJSON()
-                .map((nestedValue: { toJSON: () => unknown[] }) =>
-                  nestedValue.toJSON(),
-                ),
-            ),
-        ).toEqual(nestedRecords.map((record) => record.items));
-      });
-
-      it("will reject incompatible deferred evidence within a list", function () {
-        for (const items of [
-          [[], 1],
-          [1, []],
-          [[null], 1],
-          [1, [null]],
-        ]) {
-          expect(() => makeArrowTable([{ items }])).toThrow(
-            "Failed to infer data type for field items at row 0.",
-          );
-        }
-      });
-
-      it("will reject empty fixed-size lists", function () {
-        expect(() =>
-          makeArrowTable([{ vector: [1, 2, 3] }, { vector: [] }]),
-        ).toThrow(
-          "Failed to infer schema for data. Previously inferred type FixedSizeList[3]<Float32> but found List[0] for field vector at row 1.",
-        );
-      });
-
-      it("will reject inferred leaf and branch shape changes", function () {
-        expect(() =>
-          makeArrowTable([{ value: 1 }, { value: { nested: 2 } }]),
-        ).toThrow(
-          "Failed to infer schema for data. Previously inferred type Float64 but found Struct for field value at row 1.",
-        );
-        expect(() =>
-          makeArrowTable([{ value: { nested: 1 } }, { value: 2 }]),
-        ).toThrow(
-          "Failed to infer schema for data. Previously inferred type Struct but found Float64 for field value at row 1.",
-        );
-      });
-
-      it("will allow null values around inferred struct values", function () {
-        for (const { records, nullIndex } of [
-          {
-            records: [{ value: null }, { value: { nested: 2 } }],
-            nullIndex: 0,
-          },
-          {
-            records: [{ value: { nested: 1 } }, { value: null }],
-            nullIndex: 1,
-          },
-        ]) {
-          const table = makeArrowTable(records);
-          const values = table.getChild("value");
-
-          expect(values?.nullCount).toBe(1);
-          expect(values?.get(nullIndex)).toBeNull();
-        }
-      });
-
      it("will allow a schema to be provided", async function () {
        await checkTableCreation(
          async (records, _, schema) =>
@@ -4,13 +4,7 @@
 import { readdirSync } from "fs";
 import { Field, Float64, Schema } from "apache-arrow";
 import * as tmp from "tmp";
-import {
-  Connection,
-  ListTablesResponse,
-  Table,
-  connect,
-  connectNamespace,
-} from "../lancedb";
+import { Connection, Table, connect, connectNamespace } from "../lancedb";
 import { LocalTable } from "../lancedb/table";

 describe("when connecting", () => {
@@ -53,7 +47,6 @@ describe("given a connection", () => {
    await db.close();
    expect(db.isOpen()).toBe(false);
    await expect(db.tableNames()).rejects.toThrow("Connection is closed");
-    await expect(db.listTables()).rejects.toThrow("Connection is closed");
    await expect(db.renameTable("a", "b")).rejects.toThrow(
      "Connection is closed",
    );
@@ -136,66 +129,6 @@ describe("given a connection", () => {
    expect(tables).toEqual(["b", "c"]);
  });

-  it("should respect limit and page token when listing tables", async () => {
-    const db = await connect(tmpDir.name);
-
-    await db.createTable("b", [{ id: 1 }]);
-    await db.createTable("a", [{ id: 1 }]);
-    await db.createTable("c", [{ id: 1 }]);
-
-    const all = await db.listTables();
-    expect(all.tables).toEqual(["a", "b", "c"]);
-    expect(all.pageToken).toBeUndefined();
-
-    const first = await db.listTables({ limit: 1 });
-    expect(first.tables).toEqual(["a"]);
-    expect(first.pageToken).toBeDefined();
-
-    const second = await db.listTables({
-      limit: 1,
-      pageToken: first.pageToken,
-    });
-    expect(second.tables).toEqual(["b"]);
-  });
-
-  it("should visit every table exactly once when walking pages", async () => {
-    const db = await connect(tmpDir.name);
-
-    const created = ["a", "b", "c", "d", "e"];
-    for (const name of created) {
-      await db.createTable(name, [{ id: 1 }]);
-    }
-
-    const seen: string[] = [];
-    let pageToken: string | undefined = undefined;
-    do {
-      const page: ListTablesResponse = await db.listTables({
-        limit: 2,
-        pageToken,
-      });
-      seen.push(...page.tables);
-      pageToken = page.pageToken;
-    } while (pageToken);
-
-    expect(seen).toEqual(created);
-  });
-
-  it("should list tables in a namespace", async () => {
-    const db = await connect(tmpDir.name, {
-      // biome-ignore lint/style/useNamingConvention: opaque backend property key, must match Rust
-      namespaceClientProperties: { manifest_enabled: "true" },
-    });
-    await db.createNamespace(["child"]);
-    await db.createTable("nested", [{ id: 1 }], ["child"]);
-
-    await expect(db.listTables(["child"])).resolves.toEqual(
-      expect.objectContaining({ tables: ["nested"] }),
-    );
-    await expect(db.listTables()).resolves.toEqual(
-      expect.objectContaining({ tables: [] }),
-    );
-  });
-
  it("should create tables in v2 mode", async () => {
    const db = await connect(tmpDir.name);
    const data = [...Array(10000).keys()].map((i) => ({ id: i }));
@@ -1,95 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-import { execFileSync } from "node:child_process";
-import { resolve } from "node:path";
-
-import type { OpenAIEmbeddingFunction } from "../lancedb/embedding/openai";
-import type { EmbeddingFunctionRegistry } from "../lancedb/embedding/registry";
-
-type EmbeddingModule = typeof import("../lancedb/embedding");
-type OpenAIModule = typeof import("../lancedb/embedding/openai");
-type RegistryModule = typeof import("../lancedb/embedding/registry");
-
-describe("embedding function registry", () => {
-  const registries: EmbeddingFunctionRegistry[] = [];
-
-  afterEach(() => {
-    for (const registry of registries) {
-      registry.reset();
-    }
-    registries.length = 0;
-  });
-
-  it("defers built-in providers until the public registry API is used", () => {
-    jest.isolateModules(() => {
-      const embedding = require("../lancedb/embedding") as EmbeddingModule;
-      const { getRegistry: getInternalRegistry } =
-        require("../lancedb/embedding/registry") as RegistryModule;
-      const registry = getInternalRegistry();
-      registries.push(registry);
-
-      expect(registry.length()).toBe(0);
-      expect(embedding.getRegistry()).toBe(registry);
-      expect(registry.get("openai")).toBeDefined();
-      expect(registry.get("huggingface")).toBeDefined();
-    });
-  });
-
-  it("preserves automatic FTS search in a fresh process", () => {
-    execFileSync(
-      process.execPath,
-      [resolve(__dirname, "fixtures", "auto_fts_search.cjs")],
-      { stdio: "pipe" },
-    );
-  });
-
-  it("shares registrations across duplicated provider module graphs", () => {
-    let registeringRegistry: EmbeddingFunctionRegistry | undefined;
-    let latestOpenAIConstructor: typeof OpenAIEmbeddingFunction | undefined;
-
-    jest.isolateModules(() => {
-      require("../lancedb/embedding/openai");
-      const { getRegistry } =
-        require("../lancedb/embedding/registry") as RegistryModule;
-      registeringRegistry = getRegistry();
-      registries.push(registeringRegistry);
-      expect(registeringRegistry.get("openai")).toBeDefined();
-    });
-
-    expect(() => {
-      jest.isolateModules(() => {
-        const { OpenAIEmbeddingFunction } =
-          require("../lancedb/embedding/openai") as OpenAIModule;
-        latestOpenAIConstructor = OpenAIEmbeddingFunction;
-        const { getRegistry } =
-          require("../lancedb/embedding/registry") as RegistryModule;
-        registries.push(getRegistry());
-      });
-    }).not.toThrow();
-
-    const previousApiKey = process.env.OPENAI_API_KEY;
-    process.env.OPENAI_API_KEY = "test";
-    try {
-      const latestOpenAI = registeringRegistry!
-        .get<OpenAIEmbeddingFunction>("openai")!
-        .create();
-      expect(latestOpenAI).toBeInstanceOf(latestOpenAIConstructor!);
-    } finally {
-      if (previousApiKey === undefined) {
-        delete process.env.OPENAI_API_KEY;
-      } else {
-        process.env.OPENAI_API_KEY = previousApiKey;
-      }
-    }
-
-    jest.isolateModules(() => {
-      const { getRegistry } =
-        require("../lancedb/embedding") as EmbeddingModule;
-      const publicRegistry = getRegistry();
-      registries.push(publicRegistry);
-      expect(publicRegistry).toBe(registeringRegistry);
-      expect(publicRegistry.get("openai")).toBeDefined();
-    });
-  });
-});
@@ -1,33 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-const assert = require("node:assert/strict");
-const tmp = require("tmp");
-const { connect, embedding, Index } = require("../../dist");
-const { getRegistry } = require("../../dist/embedding/registry");
-
-async function main() {
-  assert.equal(typeof embedding.getRegistry, "function");
-  assert.equal(getRegistry().length(), 0);
-  assert.equal(embedding.getRegistry(), getRegistry());
-  assert.equal(getRegistry().length(), 2);
-
-  const dir = tmp.dirSync({ unsafeCleanup: true });
-  let db;
-  try {
-    db = await connect(dir.name);
-    const table = await db.createTable("docs", [{ text: "hello world" }]);
-    await table.createIndex("text", { config: Index.fts() });
-
-    const rows = await table.search("hello").toArray();
-    assert.equal(rows[0].text, "hello world");
-  } finally {
-    db?.close();
-    dir.removeCallback();
-  }
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
@@ -11,13 +11,10 @@ import * as arrow17 from "apache-arrow-17";
 import * as arrow18 from "apache-arrow-18";

 import {
-  AutoQuery,
  Connection,
  MatchQuery,
  PhraseQuery,
-  Query,
  Table,
-  VectorQuery,
  connect,
  tokenize,
 } from "../lancedb";
@@ -685,56 +682,6 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
  },
 );

-// https://github.com/lancedb/lancedb/issues/1963
-it("should query documents with LangChain PDF metadata", async () => {
-  const tmpDir = tmp.dirSync({ unsafeCleanup: true });
-  try {
-    const db = await connect(tmpDir.name);
-    const documents = [
-      {
-        text: "first page",
-        vector: [1, 0],
-        source: "first.pdf",
-        loc: { pageNumber: 1, lines: { from: 1, to: 12 } },
-        pdf: {
-          version: "1.10.100",
-          info: {
-            format: "PDF 1.7",
-            producer: "pdf.js",
-            creator: "Writer",
-          },
-          totalPages: 2,
-        },
-      },
-      {
-        text: "second page",
-        vector: [0, 1],
-        source: "second.pdf",
-        loc: { pageNumber: 2, lines: { from: 13, to: 24 } },
-        pdf: {
-          version: "1.10.100",
-          info: {
-            format: "PDF 1.7",
-            producer: "pdf.js",
-            creator: "Writer",
-          },
-          totalPages: 2,
-        },
-      },
-    ];
-    const documentsTable = await db.createTable("documents", documents);
-
-    const results = await documentsTable.query().toArray();
-
-    expect(results).toHaveLength(2);
-    expect(results[0].source).toBe("first.pdf");
-    expect(results[0].pdf.info.producer).toBe("pdf.js");
-    expect(results[1].loc.pageNumber).toBe(2);
-  } finally {
-    tmpDir.removeCallback();
-  }
-});
-
 describe("merge insert", () => {
  let tmpDir: tmp.DirResult;
  let table: Table;
@@ -1830,194 +1777,6 @@ describe("Read consistency interval", () => {
  });
 });

-describe("automatic search schema consistency", () => {
-  let tmpDir: tmp.DirResult;
-
-  class SchemaRefreshEmbedding extends EmbeddingFunction<string> {
-    ndims() {
-      return 2;
-    }
-
-    embeddingDataType() {
-      return new Float32();
-    }
-
-    async computeSourceEmbeddings(data: string[]) {
-      return data.map((value) => [value.length, 1]);
-    }
-
-    async computeQueryEmbeddings(value: string) {
-      return [value.length, 1];
-    }
-  }
-
-  function embeddingSchema() {
-    const func = new SchemaRefreshEmbedding();
-    return LanceSchema({
-      text: func.sourceField(new Utf8()),
-      vector: func.vectorField(),
-    });
-  }
-
-  beforeEach(() => {
-    getRegistry().reset();
-    register("schema-refresh")(SchemaRefreshEmbedding);
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
-  });
-
-  afterEach(() => {
-    getRegistry().reset();
-    tmpDir.removeCallback();
-  });
-
-  it("uses the schema refreshed from another connection", async () => {
-    const first = await connect(tmpDir.name, { readConsistencyInterval: 0 });
-    const second = await connect(tmpDir.name, { readConsistencyInterval: 0 });
-
-    try {
-      const stale = await first.createTable("docs", [{ text: "before" }], {
-        schema: embeddingSchema(),
-      });
-      const replacement = await second.createTable(
-        "docs",
-        [{ text: "after hello" }],
-        { mode: "overwrite" },
-      );
-      await replacement.createIndex("text", { config: Index.fts() });
-
-      const search = stale.search("hello");
-      expect(search).toBeInstanceOf(AutoQuery);
-      expect(search).not.toBeInstanceOf(Query);
-      expect(search).not.toBeInstanceOf(VectorQuery);
-      expect("nprobes" in search).toBe(false);
-
-      const rows = await search.toArray();
-      expect(rows[0].text).toBe("after hello");
-      expect((await stale.schema()).metadata.has("embedding_functions")).toBe(
-        false,
-      );
-    } finally {
-      first.close();
-      second.close();
-    }
-  });
-
-  it("tracks embedding metadata across checkout and restore", async () => {
-    const first = await connect(tmpDir.name, { readConsistencyInterval: 0 });
-    const second = await connect(tmpDir.name, { readConsistencyInterval: 0 });
-
-    try {
-      await first.createTable("docs", [{ text: "before" }], {
-        schema: embeddingSchema(),
-      });
-      const table = await second.createTable(
-        "docs",
-        [{ text: "after hello" }],
-        { mode: "overwrite" },
-      );
-      await table.createIndex("text", { config: Index.fts() });
-
-      await table.checkout(1);
-      expect((await table.search("before").toArray())[0].text).toBe("before");
-
-      await table.checkoutLatest();
-      expect((await table.search("hello").toArray())[0].text).toBe(
-        "after hello",
-      );
-
-      await table.checkout(1);
-      await table.restore();
-      expect((await table.search("before").toArray())[0].text).toBe("before");
-    } finally {
-      first.close();
-      second.close();
-    }
-  });
-
-  it("pins automatic search while computing an embedding", async () => {
-    let markStarted!: () => void;
-    let releaseEmbedding!: () => void;
-    const started = new Promise<void>((resolve) => {
-      markStarted = resolve;
-    });
-    const released = new Promise<void>((resolve) => {
-      releaseEmbedding = resolve;
-    });
-
-    class BlockingEmbedding extends SchemaRefreshEmbedding {
-      async computeQueryEmbeddings(value: string) {
-        markStarted();
-        await released;
-        return [value.length, 1];
-      }
-    }
-
-    register("schema-refresh-blocking")(BlockingEmbedding);
-    const func = new BlockingEmbedding();
-    const schema = LanceSchema({
-      text: func.sourceField(new Utf8()),
-      vector: func.vectorField(),
-    });
-    const first = await connect(tmpDir.name, { readConsistencyInterval: 0 });
-    const second = await connect(tmpDir.name, { readConsistencyInterval: 0 });
-
-    try {
-      const table = await first.createTable(
-        "docs",
-        [{ text: "hello before" }],
-        { schema },
-      );
-      const pending = table.search("hello").toArray();
-      await started;
-
-      const replacement = await second.createTable(
-        "docs",
-        [{ text: "hello after" }],
-        { mode: "overwrite" },
-      );
-      await replacement.createIndex("text", { config: Index.fts() });
-      releaseEmbedding();
-
-      expect((await pending)[0].text).toBe("hello before");
-    } finally {
-      releaseEmbedding();
-      first.close();
-      second.close();
-    }
-  });
-
-  it("refreshes a reused automatic search for every execution", async () => {
-    const first = await connect(tmpDir.name, { readConsistencyInterval: 0 });
-    const second = await connect(tmpDir.name, { readConsistencyInterval: 0 });
-
-    try {
-      const table = await first.createTable("docs", [
-        { text: "hello before", marker: "before" },
-      ]);
-      await table.createIndex("text", { config: Index.fts() });
-      const search = table.search("hello").select(["text"]);
-
-      const before = (await search.toArray())[0];
-      expect(before.text).toBe("hello before");
-      expect(before.marker).toBeUndefined();
-
-      const replacement = await second.createTable(
-        "docs",
-        [{ text: "hello after", marker: "after" }],
-        { mode: "overwrite" },
-      );
-      await replacement.createIndex("text", { config: Index.fts() });
-
-      const after = (await search.toArray())[0];
-      expect(after.text).toBe("hello after");
-      expect(after.marker).toBeUndefined();
-    } finally {
-      first.close();
-      second.close();
-    }
-  });
-});
-
 describe("schema evolution", function () {
  let tmpDir: tmp.DirResult;
  beforeEach(() => {
@@ -5,6 +5,7 @@ import {
  Data as ArrowData,
  Table as ArrowTable,
  Binary,
+  Bool,
  BufferType,
  DataType,
  DateUnit,
@@ -17,7 +18,12 @@ import {
  FixedSizeList,
  Float,
  Float32,
+  Float64,
  Int,
+  Int8,
+  Int16,
+  Int32,
+  Int64,
  LargeBinary,
  List,
  Null,
@@ -30,16 +36,17 @@ import {
  Struct,
  Timestamp,
  Type,
+  Uint8,
+  Uint16,
+  Uint32,
  Utf8,
  Vector,
  makeVector as arrowMakeVector,
-  util as arrowUtil,
  vectorFromArray as badVectorFromArray,
  makeBuilder,
  makeData,
 } from "apache-arrow";
 import { Buffers } from "apache-arrow/data";
-import { typedArrayToArrowType } from "./arrow_type";
 import { type EmbeddingFunction } from "./embedding/embedding_function";
 import {
  EmbeddingFunctionConfig,
@@ -52,7 +59,14 @@ import {
  sanitizeTable,
  sanitizeType,
 } from "./sanitize";
-import { inferSchema } from "./schema";
+
+/**
+ * Check if a field name indicates a vector column.
+ */
+function nameSuggestsVectorColumn(fieldName: string): boolean {
+  const nameLower = fieldName.toLowerCase();
+  return nameLower.includes("vector") || nameLower.includes("embedding");
+}

 export * from "apache-arrow";
 export type SchemaLike =
@@ -445,6 +459,110 @@ export function makeArrowTable(
  return new ArrowTable(inferredSchema, finalColumns);
 }

+function inferSchema(
+  data: Array<Record<string, unknown>>,
+  schema: Schema | undefined,
+  opts: MakeArrowTableOptions,
+): Schema {
+  // We will collect all fields we see in the data.
+  const pathTree = new PathTree<DataType>();
+
+  for (const [rowI, row] of data.entries()) {
+    for (const [path, value] of rowPathsAndValues(row)) {
+      if (!pathTree.has(path)) {
+        // First time seeing this field.
+        if (schema !== undefined) {
+          const field = getFieldForPath(schema, path);
+          if (field === undefined) {
+            throw new Error(
+              `Found field not in schema: ${path.join(".")} at row ${rowI}`,
+            );
+          } else {
+            pathTree.set(path, field.type);
+          }
+        } else {
+          const inferredType = inferType(value, path, opts);
+          if (inferredType === undefined) {
+            throw new Error(`Failed to infer data type for field ${path.join(
+              ".",
+            )} at row ${rowI}. \
+                             Consider providing an explicit schema.`);
+          }
+          pathTree.set(path, inferredType);
+        }
+      } else if (schema === undefined) {
+        const currentType = pathTree.get(path);
+        const newType = inferType(value, path, opts);
+        if (currentType !== newType) {
+          new Error(`Failed to infer schema for data. Previously inferred type \
+                     ${currentType} but found ${newType} at row ${rowI}. Consider \
+                     providing an explicit schema.`);
+        }
+      }
+    }
+  }
+
+  if (schema === undefined) {
+    function fieldsFromPathTree(pathTree: PathTree<DataType>): Field[] {
+      const fields = [];
+      for (const [name, value] of pathTree.map.entries()) {
+        if (value instanceof PathTree) {
+          const children = fieldsFromPathTree(value);
+          fields.push(new Field(name, new Struct(children), true));
+        } else {
+          fields.push(new Field(name, value, true));
+        }
+      }
+      return fields;
+    }
+    const fields = fieldsFromPathTree(pathTree);
+    return new Schema(fields);
+  } else {
+    function takeMatchingFields(
+      fields: Field[],
+      pathTree: PathTree<DataType>,
+    ): Field[] {
+      const outFields = [];
+      for (const field of fields) {
+        if (pathTree.map.has(field.name)) {
+          const value = pathTree.get([field.name]);
+          if (value instanceof PathTree) {
+            const struct = field.type as Struct;
+            const children = takeMatchingFields(struct.children, value);
+            outFields.push(
+              new Field(field.name, new Struct(children), field.nullable),
+            );
+          } else {
+            outFields.push(
+              new Field(field.name, value as DataType, field.nullable),
+            );
+          }
+        }
+      }
+      return outFields;
+    }
+    const fields = takeMatchingFields(schema.fields, pathTree);
+    return new Schema(fields);
+  }
+}
+
+function* rowPathsAndValues(
+  row: Record<string, unknown>,
+  basePath: string[] = [],
+): Generator<[string[], unknown]> {
+  for (const [key, value] of Object.entries(row)) {
+    if (isObject(value)) {
+      yield* rowPathsAndValues(value, [...basePath, key]);
+    } else {
+      // Skip undefined values - they should be treated the same as missing fields
+      // for embedding function purposes
+      if (value !== undefined) {
+        yield [[...basePath, key], value];
+      }
+    }
+  }
+}
+
 function isObject(value: unknown): value is Record<string, unknown> {
  return (
    typeof value === "object" &&
@@ -459,19 +577,146 @@ function isObject(value: unknown): value is Record<string, unknown> {
  );
 }

-function valueAtPath(datum: Record<string, unknown>, path: string[]): unknown {
-  let current: unknown = datum;
+function getFieldForPath(schema: Schema, path: string[]): Field | undefined {
+  let current: Field | Schema = schema;
  for (const key of path) {
-    if (current == null) {
-      return null;
-    }
-    if (isObject(current) && (Object.hasOwn(current, key) || key in current)) {
-      current = current[key];
+    if (current instanceof Schema) {
+      const field: Field | undefined = current.fields.find(
+        (f) => f.name === key,
+      );
+      if (field === undefined) {
+        return undefined;
+      }
+      current = field;
+    } else if (current instanceof Field && DataType.isStruct(current.type)) {
+      const struct: Struct = current.type;
+      const field = struct.children.find((f) => f.name === key);
+      if (field === undefined) {
+        return undefined;
+      }
+      current = field;
    } else {
      return undefined;
    }
  }
-  return current;
+  if (current instanceof Field) {
+    return current;
+  } else {
+    return undefined;
+  }
+}
+
+/**
+ * Try to infer which Arrow type to use for a given value.
+ *
+ * May return undefined if the type cannot be inferred.
+ */
+function inferType(
+  value: unknown,
+  path: string[],
+  opts: MakeArrowTableOptions,
+): DataType | undefined {
+  if (typeof value === "bigint") {
+    return new Int64();
+  } else if (typeof value === "number") {
+    // Even if it's an integer, it's safer to assume Float64. Users can
+    // always provide an explicit schema or use BigInt if they mean integer.
+    return new Float64();
+  } else if (typeof value === "string") {
+    if (opts.dictionaryEncodeStrings) {
+      return new Dictionary(new Utf8(), new Int32());
+    } else {
+      return new Utf8();
+    }
+  } else if (typeof value === "boolean") {
+    return new Bool();
+  } else if (value instanceof Buffer) {
+    return new Binary();
+  } else if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+    const info = typedArrayToArrowType(value);
+    if (info !== undefined) {
+      const child = new Field("item", info.elementType, true);
+      return new FixedSizeList(info.length, child);
+    }
+    return undefined;
+  } else if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return undefined; // Without any values we can't infer the type
+    }
+    if (path.length === 1 && Object.hasOwn(opts.vectorColumns, path[0])) {
+      const floatType = sanitizeType(opts.vectorColumns[path[0]].type);
+      return new FixedSizeList(
+        value.length,
+        new Field("item", floatType, true),
+      );
+    }
+    const valueType = inferType(value[0], path, opts);
+    if (valueType === undefined) {
+      return undefined;
+    }
+    // Try to automatically detect embedding columns.
+    if (nameSuggestsVectorColumn(path[path.length - 1])) {
+      // Check if value is a Uint8Array for integer vector type determination
+      if (value instanceof Uint8Array) {
+        // For integer vectors, we default to Uint8 (matching Python implementation)
+        const child = new Field("item", new Uint8(), true);
+        return new FixedSizeList(value.length, child);
+      } else {
+        // For float vectors, we default to Float32
+        const child = new Field("item", new Float32(), true);
+        return new FixedSizeList(value.length, child);
+      }
+    } else {
+      const child = new Field("item", valueType, true);
+      return new List(child);
+    }
+  } else {
+    // TODO: timestamp
+    return undefined;
+  }
+}
+
+class PathTree<V> {
+  map: Map<string, V | PathTree<V>>;
+
+  constructor(entries?: [string[], V][]) {
+    this.map = new Map();
+    if (entries !== undefined) {
+      for (const [path, value] of entries) {
+        this.set(path, value);
+      }
+    }
+  }
+  has(path: string[]): boolean {
+    let ref: PathTree<V> = this;
+    for (const part of path) {
+      if (!(ref instanceof PathTree) || !ref.map.has(part)) {
+        return false;
+      }
+      ref = ref.map.get(part) as PathTree<V>;
+    }
+    return true;
+  }
+  get(path: string[]): V | undefined {
+    let ref: PathTree<V> = this;
+    for (const part of path) {
+      if (!(ref instanceof PathTree) || !ref.map.has(part)) {
+        return undefined;
+      }
+      ref = ref.map.get(part) as PathTree<V>;
+    }
+    return ref as V;
+  }
+  set(path: string[], value: V): void {
+    let ref: PathTree<V> = this;
+    for (const part of path.slice(0, path.length - 1)) {
+      if (!ref.map.has(part)) {
+        ref.map.set(part, new PathTree<V>());
+      }
+      ref = ref.map.get(part) as PathTree<V>;
+    }
+    ref.map.set(path[path.length - 1], value);
+  }
 }

 function transposeData(
@@ -479,26 +724,37 @@ function transposeData(
  field: Field,
  path: string[] = [],
 ): Vector {
-  const valuesPath = [...path, field.name];
-  const values = data.map((datum) => valueAtPath(datum, valuesPath));
  if (field.type instanceof Struct) {
    const childFields = field.type.children;
+    const fullPath = [...path, field.name];
    const childVectors = childFields.map((child) => {
-      return transposeData(data, child, valuesPath);
+      return transposeData(data, child, fullPath);
    });
-    const nullCount = values.filter((value) => value === null).length;
    const structData = makeData({
      type: field.type,
-      length: values.length,
-      nullCount,
-      nullBitmap:
-        nullCount > 0
-          ? arrowUtil.packBools(values.map((value) => value !== null))
-          : undefined,
      children: childVectors as unknown as ArrowData<DataType>[],
    });
    return arrowMakeVector(structData);
  } else {
+    const valuesPath = [...path, field.name];
+    const values = data.map((datum) => {
+      let current: unknown = datum;
+      for (const key of valuesPath) {
+        if (current == null) {
+          return null;
+        }
+
+        if (
+          isObject(current) &&
+          (Object.hasOwn(current, key) || key in current)
+        ) {
+          current = current[key];
+        } else {
+          return null;
+        }
+      }
+      return current;
+    });
    return makeVector(values, field.type, undefined, field.nullable);
  }
 }
@@ -541,6 +797,32 @@ function makeListVector(lists: unknown[][]): Vector<unknown> {
  return listBuilder.finish().toVector();
 }

+/**
+ * Map a JS TypedArray instance to the corresponding Arrow element DataType
+ * and its length. Returns undefined if the value is not a recognized TypedArray.
+ */
+function typedArrayToArrowType(
+  value: ArrayBufferView,
+): { elementType: DataType; length: number } | undefined {
+  if (value instanceof Float32Array)
+    return { elementType: new Float32(), length: value.length };
+  if (value instanceof Float64Array)
+    return { elementType: new Float64(), length: value.length };
+  if (value instanceof Uint8Array)
+    return { elementType: new Uint8(), length: value.length };
+  if (value instanceof Uint16Array)
+    return { elementType: new Uint16(), length: value.length };
+  if (value instanceof Uint32Array)
+    return { elementType: new Uint32(), length: value.length };
+  if (value instanceof Int8Array)
+    return { elementType: new Int8(), length: value.length };
+  if (value instanceof Int16Array)
+    return { elementType: new Int16(), length: value.length };
+  if (value instanceof Int32Array)
+    return { elementType: new Int32(), length: value.length };
+  return undefined;
+}
+
 /** Helper function to convert an Array of JS values to an Arrow Vector */
 function makeVector(
  values: unknown[],
@@ -1180,12 +1462,8 @@ export function ensureNestedFieldsExist(
          completeRow[field.name] = row[field.name];
        }
      } else {
-        // Keep a missing struct valid while filling each of its children with
-        // null. This is distinct from an explicitly null struct value.
-        completeRow[field.name] =
-          field.type.constructor.name === "Struct"
-            ? ensureStructFieldsExist({}, field.type as Struct)
-            : null;
+        // Field is missing from the data - set to null
+        completeRow[field.name] = null;
      }
    }

@@ -1220,12 +1498,8 @@ function ensureStructFieldsExist(
        completeStruct[childField.name] = data[childField.name];
      }
    } else {
-      // Keep a missing struct valid while filling each of its children with
-      // null. This is distinct from an explicitly null struct value.
-      completeStruct[childField.name] =
-        childField.type.constructor.name === "Struct"
-          ? ensureStructFieldsExist({}, childField.type as Struct)
-          : null;
+      // Field is missing - set to null
+      completeStruct[childField.name] = null;
    }
  }

@@ -1,40 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-import {
-  type DataType,
-  Float32,
-  Float64,
-  Int8,
-  Int16,
-  Int32,
-  Uint8,
-  Uint16,
-  Uint32,
-} from "apache-arrow";
-
-/**
- * Map a JS TypedArray instance to the corresponding Arrow element type and
- * length. Returns undefined when the view is not a supported TypedArray.
- */
-export function typedArrayToArrowType(
-  value: ArrayBufferView,
-): { elementType: DataType; length: number } | undefined {
-  if (value instanceof Float32Array)
-    return { elementType: new Float32(), length: value.length };
-  if (value instanceof Float64Array)
-    return { elementType: new Float64(), length: value.length };
-  if (value instanceof Uint8Array)
-    return { elementType: new Uint8(), length: value.length };
-  if (value instanceof Uint16Array)
-    return { elementType: new Uint16(), length: value.length };
-  if (value instanceof Uint32Array)
-    return { elementType: new Uint32(), length: value.length };
-  if (value instanceof Int8Array)
-    return { elementType: new Int8(), length: value.length };
-  if (value instanceof Int16Array)
-    return { elementType: new Int16(), length: value.length };
-  if (value instanceof Int32Array)
-    return { elementType: new Int32(), length: value.length };
-  return undefined;
-}
@@ -31,14 +31,12 @@ import type {
  JobDescription,
  JobInfo,
  ListNamespacesResponse,
-  ListTablesResponse,
 } from "./native";
 export type {
  CreateNamespaceResponse,
  DescribeNamespaceResponse,
  DropNamespaceResponse,
  ListNamespacesResponse,
-  ListTablesResponse,
 };
 import { sanitizeTable } from "./sanitize";
 import { LocalTable, Table } from "./table";
@@ -136,10 +134,6 @@ export interface OpenTableOptions {
  indexCacheSize?: number;
 }

-/**
- * @deprecated Use {@link ListTablesOptions} with {@link Connection.listTables}
- * instead.
- */
 export interface TableNamesOptions {
  /**
   * If present, only return names that come lexicographically after the
@@ -153,24 +147,6 @@ export interface TableNamesOptions {
  limit?: number;
 }

-export interface ListTablesOptions {
-  /**
-   * Token from a previous response, to resume listing where it left off.
-   *
-   * The token is opaque: it carries whatever the database needs to resume, and
-   * callers should not construct or interpret one.
-   */
-  pageToken?: string;
-  /**
-   * An upper bound on how many tables to return.
-   *
-   * A page may hold fewer than this and still not be the last one, so keep
-   * going while the response carries a page token rather than while pages are
-   * full.
-   */
-  limit?: number;
-}
-
 export interface ListNamespacesOptions {
  /** Token from a previous response for pagination. */
  pageToken?: string;
@@ -255,7 +231,6 @@ export abstract class Connection {
   * @param {Partial<TableNamesOptions>} options - options to control the
   * paging / start point (backwards compatibility)
   *
-   * @deprecated Use {@link Connection.listTables} instead.
   */
  abstract tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
  /**
@@ -266,53 +241,12 @@ export abstract class Connection {
   * @param {Partial<TableNamesOptions>} options - options to control the
   * paging / start point
   *
-   * @deprecated Use {@link Connection.listTables} instead.
   */
  abstract tableNames(
    namespacePath?: string[],
    options?: Partial<TableNamesOptions>,
  ): Promise<string[]>;

-  /**
-   * List a page of the tables in this database.
-   *
-   * To retrieve the tables after the page, pass the `pageToken` the response
-   * carries back in. A page can be shorter than `limit` without being the last
-   * one, so walk until a response carries no page token:
-   *
-   * ```ts
-   * const names = [];
-   * let pageToken = undefined;
-   * do {
-   *   const page = await conn.listTables({ pageToken, limit: 100 });
-   *   names.push(...page.tables);
-   *   pageToken = page.pageToken;
-   * } while (pageToken);
-   * ```
-   *
-   * @param {Partial<ListTablesOptions>} options - Pagination options
-   *   (`pageToken`, `limit`).
-   * @returns {Promise<ListTablesResponse>} A page of table names and an
-   *   optional token for the tables after it.
-   */
-  abstract listTables(
-    options?: Partial<ListTablesOptions>,
-  ): Promise<ListTablesResponse>;
-  /**
-   * List a page of the tables in this database.
-   *
-   * @param {string[]} namespacePath - The namespace path to list tables from
-   *   (defaults to root namespace)
-   * @param {Partial<ListTablesOptions>} options - Pagination options
-   *   (`pageToken`, `limit`).
-   * @returns {Promise<ListTablesResponse>} A page of table names and an
-   *   optional token for the tables after it.
-   */
-  abstract listTables(
-    namespacePath?: string[],
-    options?: Partial<ListTablesOptions>,
-  ): Promise<ListTablesResponse>;
-
  /**
   * Open a table in the database.
   * @param {string} name - The name of the table
@@ -667,25 +601,6 @@ export class LocalConnection extends Connection {
    return await this.inner.listMaterializedViews();
  }

-  async listTables(
-    namespacePathOrOptions?: string[] | Partial<ListTablesOptions>,
-    options?: Partial<ListTablesOptions>,
-  ): Promise<ListTablesResponse> {
-    // Detect if first argument is namespacePath array or options object
-    const namespacePath = Array.isArray(namespacePathOrOptions)
-      ? namespacePathOrOptions
-      : undefined;
-    const listTablesOptions = Array.isArray(namespacePathOrOptions)
-      ? options
-      : namespacePathOrOptions;
-
-    return this.inner.listTables(
-      namespacePath ?? [],
-      listTablesOptions?.pageToken,
-      listTablesOptions?.limit,
-    );
-  }
-
  async openTable(
    name: string,
    namespacePath?: string[],
@@ -4,15 +4,7 @@
 import { Field, Schema } from "../arrow";
 import { sanitizeType } from "../sanitize";
 import { EmbeddingFunction } from "./embedding_function";
-import {
-  EmbeddingFunctionConfig,
-  EmbeddingFunctionRegistry,
-  getRegistry as getGlobalRegistry,
-  registerBuiltIn,
-} from "./registry";
-
-type OpenAIModule = typeof import("./openai");
-type TransformersModule = typeof import("./transformers");
+import { EmbeddingFunctionConfig, getRegistry } from "./registry";

 export {
  FieldOptions,
@@ -22,39 +14,7 @@ export {
  EmbeddingFunctionConstructor,
 } from "./embedding_function";

-export {
-  EmbeddingFunctionRegistry,
-  parseEmbeddingMetadata,
-  register,
-} from "./registry";
-export type {
-  CreateReturnType,
-  EmbeddingFunctionConfig,
-  EmbeddingFunctionCreate,
-  EmbeddingMetadataEntry,
-  ResolvedEmbeddingFunctionConfig,
-} from "./registry";
-
-function initializeBuiltInProviders() {
-  const { OpenAIEmbeddingFunction } = require("./openai") as OpenAIModule;
-  const { TransformersEmbeddingFunction } =
-    require("./transformers") as TransformersModule;
-
-  registerBuiltIn("openai", OpenAIEmbeddingFunction);
-  registerBuiltIn("huggingface", TransformersEmbeddingFunction);
-}
-
-/**
- * Get the global embedding function registry.
- *
- * LanceDB built-in providers are initialized when this public API is first
- * used, so importing the root package does not change automatic search
- * selection for tables without embedding metadata.
- */
-export function getRegistry(): EmbeddingFunctionRegistry {
-  initializeBuiltInProviders();
-  return getGlobalRegistry();
-}
+export * from "./registry";

 /**
 * Create a schema with embedding functions.
@@ -5,13 +5,14 @@ import type OpenAI from "openai";
 import type { EmbeddingCreateParams } from "openai/resources/index";
 import { Float, Float32 } from "../arrow";
 import { EmbeddingFunction } from "./embedding_function";
-import { registerBuiltIn } from "./registry";
+import { register } from "./registry";

 export type OpenAIOptions = {
  apiKey: string;
  model: EmbeddingCreateParams["model"];
 };

+@register("openai")
 export class OpenAIEmbeddingFunction extends EmbeddingFunction<
  string,
  Partial<OpenAIOptions>
@@ -99,5 +100,3 @@ export class OpenAIEmbeddingFunction extends EmbeddingFunction<
    return response.data[0].embedding;
  }
 }
-
-registerBuiltIn("openai", OpenAIEmbeddingFunction);
@@ -7,10 +7,6 @@ import {
 } from "./embedding_function";
 import "reflect-metadata";

-const builtInFunctionsKey = Symbol.for(
-  "@lancedb/lancedb::embedding-built-in-functions::v1",
-);
-
 export type CreateReturnType<T> = T extends { init: () => Promise<void> }
  ? Promise<T>
  : T;
@@ -63,15 +59,6 @@ export class EmbeddingFunctionRegistry {
    };
  }

-  /** @ignore */
-  setBuiltIn<
-    T extends EmbeddingFunctionConstructor = EmbeddingFunctionConstructor,
-  >(name: string, ctor: T): T {
-    this.#functions.set(name, ctor);
-    Reflect.defineMetadata("lancedb::embedding::name", name, ctor);
-    return ctor;
-  }
-
  get<T extends EmbeddingFunction<unknown>>(
    name: string,
  ): EmbeddingFunctionCreate<T> | undefined;
@@ -109,7 +96,6 @@ export class EmbeddingFunctionRegistry {
   */
  reset(this: EmbeddingFunctionRegistry) {
    this.#functions.clear();
-    getBuiltInFunctions(this).clear();
  }

  /**
@@ -197,56 +183,12 @@ export class EmbeddingFunctionRegistry {
  }
 }

-function getBuiltInFunctions(registry: EmbeddingFunctionRegistry): Set<string> {
-  const registryWithBuiltIns = registry as EmbeddingFunctionRegistry & {
-    [key: symbol]: Set<string> | undefined;
-  };
-  let builtInFunctions = registryWithBuiltIns[builtInFunctionsKey];
-  if (builtInFunctions === undefined) {
-    builtInFunctions = new Set<string>();
-    registryWithBuiltIns[builtInFunctionsKey] = builtInFunctions;
-  }
-  return builtInFunctions;
-}
-
-// Server bundlers can load the side-effect embedding entry points and the public
-// embedding API from separate module graphs. Keep their registry shared.
-const registryKey = Symbol.for(
-  "@lancedb/lancedb::embedding-function-registry::v1",
-);
-const registryGlobal = globalThis as typeof globalThis & {
-  [key: symbol]: EmbeddingFunctionRegistry | undefined;
-};
-
-function getGlobalRegistry(): EmbeddingFunctionRegistry {
-  const existingRegistry = registryGlobal[registryKey];
-  if (existingRegistry !== undefined) {
-    return existingRegistry;
-  }
-  const registry = new EmbeddingFunctionRegistry();
-  registryGlobal[registryKey] = registry;
-  return registry;
-}
-
-const _REGISTRY = getGlobalRegistry();
+const _REGISTRY = new EmbeddingFunctionRegistry();

 export function register(name?: string) {
  return _REGISTRY.register(name);
 }

-/** @ignore */
-export function registerBuiltIn<
-  T extends EmbeddingFunctionConstructor = EmbeddingFunctionConstructor,
->(name: string, ctor: T): T {
-  const builtInFunctions = getBuiltInFunctions(_REGISTRY);
-  if (builtInFunctions.has(name)) {
-    return _REGISTRY.setBuiltIn(name, ctor);
-  }
-  _REGISTRY.register(name)(ctor);
-  builtInFunctions.add(name);
-  return ctor;
-}
-
 /**
 * Utility function to get the global instance of the registry
 * @returns `EmbeddingFunctionRegistry` The global instance of the registry
@@ -3,7 +3,7 @@

 import { Float, Float32 } from "../arrow";
 import { EmbeddingFunction } from "./embedding_function";
-import { registerBuiltIn } from "./registry";
+import { register } from "./registry";

 export type XenovaTransformerOptions = {
  /** The wasm compatible model to use */
@@ -31,6 +31,7 @@ export type XenovaTransformerOptions = {
  };
 };

+@register("huggingface")
 export class TransformersEmbeddingFunction extends EmbeddingFunction<
  string,
  Partial<XenovaTransformerOptions>
@@ -157,8 +158,6 @@ export class TransformersEmbeddingFunction extends EmbeddingFunction<
  }
 }

-registerBuiltIn("huggingface", TransformersEmbeddingFunction);
-
 const tensorDiv = (
  src: import("@huggingface/transformers").Tensor,
  divBy: number,
@@ -81,13 +81,11 @@ export {
  Connection,
  CreateTableOptions,
  TableNamesOptions,
-  ListTablesOptions,
  OpenTableOptions,
  ListNamespacesOptions,
  CreateNamespaceOptions,
  DropNamespaceOptions,
  ListNamespacesResponse,
-  ListTablesResponse,
  CreateNamespaceResponse,
  DropNamespaceResponse,
  DescribeNamespaceResponse,
@@ -103,7 +101,6 @@ export {
 } from "./native.js";

 export {
-  AutoQuery,
  ExecutableQuery,
  Query,
  QueryBase,
@@ -111,15 +111,13 @@ export class QueryBase<
  NativeQueryType extends NativeQuery | NativeVectorQuery | NativeTakeQuery,
 > implements AsyncIterable<RecordBatch>
 {
-  protected inner!: NativeQueryType | Promise<NativeQueryType>;
-
  /**
   * @hidden
   */
-  protected constructor(inner?: NativeQueryType | Promise<NativeQueryType>) {
-    if (inner !== undefined) {
-      this.inner = inner;
-    }
+  protected constructor(
+    protected inner: NativeQueryType | Promise<NativeQueryType>,
+  ) {
+    // intentionally empty
  }

  // call a function on the inner (either a promise or the actual object)
@@ -137,15 +135,6 @@ export class QueryBase<
    }
  }

-  /**
-   * Return the native query used by the next terminal operation.
-   *
-   * @hidden
-   */
-  protected async getInner(): Promise<NativeQueryType> {
-    return this.inner;
-  }
-
  /**
   * Return only the specified columns.
   *
@@ -218,11 +207,16 @@ export class QueryBase<
  /**
   * @hidden
   */
-  protected async nativeExecute(
+  protected nativeExecute(
    options?: Partial<QueryExecutionOptions>,
  ): Promise<NativeBatchIterator> {
-    const inner = await this.getInner();
-    return inner.execute(options?.maxBatchLength, options?.timeoutMs);
+    if (this.inner instanceof Promise) {
+      return this.inner.then((inner) =>
+        inner.execute(options?.maxBatchLength, options?.timeoutMs),
+      );
+    } else {
+      return this.inner.execute(options?.maxBatchLength, options?.timeoutMs);
+    }
  }

  /**
@@ -251,7 +245,12 @@ export class QueryBase<
  /** Collect the results as an Arrow @see {@link ArrowTable}. */
  async toArrow(options?: Partial<QueryExecutionOptions>): Promise<ArrowTable> {
    const batches = [];
-    const inner = await this.getInner();
+    let inner;
+    if (this.inner instanceof Promise) {
+      inner = await this.inner;
+    } else {
+      inner = this.inner;
+    }
    for await (const batch of new RecordBatchIterable(inner, options)) {
      batches.push(batch);
    }
@@ -280,8 +279,11 @@ export class QueryBase<
   * @returns A Promise that resolves to a string containing the query execution plan explanation.
   */
  async explainPlan(verbose = false): Promise<string> {
-    const inner = await this.getInner();
-    return inner.explainPlan(verbose);
+    if (this.inner instanceof Promise) {
+      return this.inner.then((inner) => inner.explainPlan(verbose));
+    } else {
+      return this.inner.explainPlan(verbose);
+    }
  }

  /**
@@ -319,8 +321,13 @@ export class QueryBase<
    distributedMetrics?: AnalyzePlanDistributedMetrics,
  ): Promise<string> {
    const distributedMetricsMode = distributedMetrics ?? "aggregate";
-    const inner = await this.getInner();
-    return inner.analyzePlan(distributedMetricsMode);
+    if (this.inner instanceof Promise) {
+      return this.inner.then((inner) =>
+        inner.analyzePlan(distributedMetricsMode),
+      );
+    } else {
+      return this.inner.analyzePlan(distributedMetricsMode);
+    }
  }

  /**
@@ -332,8 +339,12 @@ export class QueryBase<
   * @returns An Arrow Schema describing the output columns.
   */
  async outputSchema(): Promise<import("./arrow").Schema> {
-    const inner = await this.getInner();
-    const schemaBuffer = await inner.outputSchema();
+    let schemaBuffer: Buffer;
+    if (this.inner instanceof Promise) {
+      schemaBuffer = await this.inner.then((inner) => inner.outputSchema());
+    } else {
+      schemaBuffer = await this.inner.outputSchema();
+    }
    const schema = tableFromIPC(schemaBuffer).schema;
    return schema;
  }
@@ -345,7 +356,7 @@ export class StandardQueryBase<
  extends QueryBase<NativeQueryType>
  implements ExecutableQuery
 {
-  constructor(inner?: NativeQueryType | Promise<NativeQueryType>) {
+  constructor(inner: NativeQueryType | Promise<NativeQueryType>) {
    super(inner);
  }

@@ -777,51 +788,6 @@ export class TakeQuery extends QueryBase<NativeTakeQuery> {
  }
 }

-/**
- * A builder for automatic string searches.
- *
- * Automatic search determines whether to use full-text or vector search from
- * the table revision selected for each execution. This builder exposes the
- * common operations supported by both query families.
- *
- * @hideconstructor
- */
-export class AutoQuery extends StandardQueryBase<
-  NativeQuery | NativeVectorQuery
-> {
-  private readonly calls: Array<
-    (inner: NativeQuery | NativeVectorQuery) => void
-  > = [];
-
-  /** @hidden */
-  constructor(
-    private readonly createInner: () => Promise<
-      NativeQuery | NativeVectorQuery
-    >,
-  ) {
-    super();
-  }
-
-  /** @hidden */
-  protected override doCall(
-    fn: (inner: NativeQuery | NativeVectorQuery) => void,
-  ) {
-    this.calls.push(fn);
-  }
-
-  /** @hidden */
-  protected override async getInner(): Promise<
-    NativeQuery | NativeVectorQuery
-  > {
-    const calls = [...this.calls];
-    const inner = await this.createInner();
-    for (const call of calls) {
-      call(inner);
-    }
-    return inner;
-  }
-}
-
 /** A builder for LanceDB queries.
 *
 * @see {@link Table#query}, {@link Table#search}
@@ -836,37 +802,6 @@ export class Query extends StandardQueryBase<NativeQuery> {
    super(tbl.query());
  }

-  /** @hidden */
-  static autoSearch(
-    tbl: () => Promise<NativeTable>,
-    query: string,
-    vector: (tbl: NativeTable) => Promise<Awaited<IntoVector> | undefined>,
-    columns?: string[],
-  ): AutoQuery {
-    const nativeQuery = async () => {
-      const snapshot = await Promise.resolve(tbl());
-      const resolved = await vector(snapshot);
-      const inner = snapshot.query();
-      if (resolved === undefined) {
-        inner.fullTextSearch({
-          query,
-          columns: columns ?? null,
-        });
-        return inner;
-      }
-
-      const raw = Array.isArray(resolved)
-        ? null
-        : extractVectorBuffer(resolved);
-      if (raw) {
-        return inner.nearestToRaw(raw.data, raw.dtype);
-      }
-      return inner.nearestTo(Float32Array.from(resolved as number[]));
-    };
-
-    return new AutoQuery(nativeQuery);
-  }
-
  /**
   * Find the nearest vectors to the given query vector.
   *
@@ -1,566 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-import {
-  Binary,
-  Bool,
-  DataType,
-  Dictionary,
-  Field,
-  FixedSizeList,
-  Float32,
-  Float64,
-  Int32,
-  Int64,
-  List,
-  Schema,
-  Struct,
-  Utf8,
-  util as arrowUtil,
-} from "apache-arrow";
-import { typedArrayToArrowType } from "./arrow_type";
-import { sanitizeType } from "./sanitize";
-
-type InferenceOptions = {
-  dictionaryEncodeStrings: boolean;
-  vectorColumns: Record<string, { type: unknown }>;
-};
-
-/**
- * Infer the Arrow schema represented by a set of records.
- *
- * This is the intentionally small interface to schema inference. The stateful
- * details of combining partial type evidence are encapsulated below so callers
- * only need to provide records, an optional schema, and inference options.
- */
-export function inferSchema(
-  data: Array<Record<string, unknown>>,
-  schema: Schema | undefined,
-  options: InferenceOptions,
-): Schema {
-  return new SchemaInferrer(schema, options).infer(data);
-}
-
-class SchemaInferrer {
-  private readonly fields = new FieldTree();
-
-  constructor(
-    private readonly providedSchema: Schema | undefined,
-    private readonly options: InferenceOptions,
-  ) {}
-
-  infer(data: Array<Record<string, unknown>>): Schema {
-    for (const [row, record] of data.entries()) {
-      for (const [path, value] of recordPathsAndValues(record)) {
-        this.observe(path, value, row);
-      }
-    }
-
-    return this.providedSchema === undefined
-      ? new Schema(fieldsFromTree(this.fields))
-      : new Schema(matchingFields(this.providedSchema.fields, this.fields));
-  }
-
-  private observe(path: string[], value: unknown, row: number): void {
-    const current = this.fields.get(path);
-    if (current === undefined) {
-      this.addField(path, value, row);
-    } else if (this.providedSchema === undefined) {
-      this.updateInferredField(path, value, row, current);
-    }
-  }
-
-  private addField(path: string[], value: unknown, row: number): void {
-    if (this.providedSchema !== undefined) {
-      this.addSchemaField(this.providedSchema, path, row);
-      return;
-    }
-
-    const evidence =
-      this.inferType(value, path) ?? DeferredTypeEvidence.from(value, row);
-    if (evidence === undefined) {
-      throw typeInferenceError(path, row);
-    }
-
-    const conflict = this.fields.set(
-      path,
-      evidence,
-      (existing) =>
-        existing instanceof DeferredTypeEvidence && existing.isOnlyNulls(),
-    );
-    if (conflict !== undefined) {
-      throw branchConflictError(conflict, row, "Struct");
-    }
-  }
-
-  private addSchemaField(schema: Schema, path: string[], row: number): void {
-    const field = fieldAtPath(schema, path);
-    if (field === undefined) {
-      throw new Error(
-        `Found field not in schema: ${path.join(".")} at row ${row}`,
-      );
-    }
-
-    const conflict = this.fields.set(path, field.type);
-    if (conflict !== undefined) {
-      throw branchConflictError(conflict, row, "Struct");
-    }
-  }
-
-  private updateInferredField(
-    path: string[],
-    value: unknown,
-    row: number,
-    current: FieldNode,
-  ): void {
-    const newType = this.inferType(value, path);
-    const deferred = DeferredTypeEvidence.from(value, row);
-
-    if (current instanceof FieldTree) {
-      if (deferred?.isOnlyNulls()) {
-        return;
-      }
-      throw schemaInferenceError(
-        path,
-        row,
-        "Struct",
-        describeEvidence(newType ?? deferred),
-      );
-    }
-
-    if (current instanceof DeferredTypeEvidence) {
-      this.resolveDeferredField(path, row, current, newType, deferred);
-      return;
-    }
-
-    if (newType !== undefined) {
-      if (!inferredTypesEqual(current, newType)) {
-        throw schemaInferenceError(
-          path,
-          row,
-          describeEvidence(current),
-          describeEvidence(newType),
-        );
-      }
-      return;
-    }
-
-    if (deferred === undefined || !deferred.matches(current)) {
-      throw schemaInferenceError(
-        path,
-        row,
-        describeEvidence(current),
-        describeEvidence(deferred),
-      );
-    }
-  }
-
-  private resolveDeferredField(
-    path: string[],
-    row: number,
-    current: DeferredTypeEvidence,
-    newType: DataType | undefined,
-    deferred: DeferredTypeEvidence | undefined,
-  ): void {
-    if (newType !== undefined) {
-      if (!current.matches(newType)) {
-        throw schemaInferenceError(
-          path,
-          row,
-          current.describe(),
-          describeEvidence(newType),
-        );
-      }
-      this.fields.set(path, newType);
-      return;
-    }
-
-    if (deferred !== undefined) {
-      this.fields.set(path, current.merge(deferred));
-      return;
-    }
-
-    throw schemaInferenceError(
-      path,
-      row,
-      current.describe(),
-      describeEvidence(newType),
-    );
-  }
-
-  private inferType(value: unknown, path: string[]): DataType | undefined {
-    if (typeof value === "bigint") {
-      return new Int64();
-    }
-    if (typeof value === "number") {
-      return new Float64();
-    }
-    if (typeof value === "string") {
-      return this.options.dictionaryEncodeStrings
-        ? new Dictionary(new Utf8(), new Int32())
-        : new Utf8();
-    }
-    if (typeof value === "boolean") {
-      return new Bool();
-    }
-    if (value instanceof Buffer) {
-      return new Binary();
-    }
-    if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
-      const typedArray = typedArrayToArrowType(value);
-      return typedArray === undefined
-        ? undefined
-        : new FixedSizeList(
-            typedArray.length,
-            new Field("item", typedArray.elementType, true),
-          );
-    }
-    if (!Array.isArray(value) || value.length === 0) {
-      return undefined;
-    }
-
-    const configuredVector =
-      path.length === 1 ? this.options.vectorColumns[path[0]] : undefined;
-    if (configuredVector !== undefined) {
-      return new FixedSizeList(
-        value.length,
-        new Field("item", sanitizeType(configuredVector.type), true),
-      );
-    }
-
-    const itemType = this.inferArrayItemType(value, path);
-    if (itemType === undefined) {
-      return undefined;
-    }
-
-    return nameSuggestsVectorColumn(path[path.length - 1])
-      ? new FixedSizeList(value.length, new Field("item", new Float32(), true))
-      : new List(new Field("item", itemType, true));
-  }
-
-  private inferArrayItemType(
-    values: unknown[],
-    path: string[],
-  ): DataType | undefined {
-    let itemType: DataType | undefined;
-    const deferredItems: unknown[] = [];
-
-    for (const value of values) {
-      const candidate = this.inferType(value, path);
-      if (candidate === undefined) {
-        if (!isDeferredValue(value)) {
-          return undefined;
-        }
-        deferredItems.push(value);
-      } else if (itemType === undefined) {
-        itemType = candidate;
-      } else if (!inferredTypesEqual(itemType, candidate)) {
-        return undefined;
-      }
-    }
-
-    if (itemType === undefined) {
-      return undefined;
-    }
-    return deferredItems.every((value) =>
-      deferredValueMatchesType(value, itemType),
-    )
-      ? itemType
-      : undefined;
-  }
-}
-
-/** Nulls and empty/all-null lists that do not determine a type by themselves. */
-class DeferredTypeEvidence {
-  private constructor(
-    private readonly values: Array<{ value: unknown; row: number }>,
-  ) {}
-
-  static from(value: unknown, row: number): DeferredTypeEvidence | undefined {
-    return isDeferredValue(value)
-      ? new DeferredTypeEvidence([{ value, row }])
-      : undefined;
-  }
-
-  isOnlyNulls(): boolean {
-    return this.values.every(({ value }) => value == null);
-  }
-
-  matches(type: DataType): boolean {
-    return this.values.every(({ value }) =>
-      deferredValueMatchesType(value, type),
-    );
-  }
-
-  merge(other: DeferredTypeEvidence): DeferredTypeEvidence {
-    return new DeferredTypeEvidence([...this.values, ...other.values]);
-  }
-
-  describe(): string {
-    const list = this.values.find(({ value }) => Array.isArray(value));
-    return list === undefined
-      ? "null"
-      : `List[${(list.value as unknown[]).length}]`;
-  }
-
-  firstRow(): number {
-    return this.values[0].row;
-  }
-}
-
-type FieldNode = DataType | DeferredTypeEvidence | FieldTree;
-type LeafNode = Exclude<FieldNode, FieldTree>;
-type FieldConflict = { path: string[]; value: FieldNode };
-
-/** Nested field state, kept separate from Arrow's eventual Struct types. */
-class FieldTree {
-  private readonly children = new Map<string, FieldNode>();
-
-  get(path: string[]): FieldNode | undefined {
-    let current: FieldNode = this;
-    for (const part of path) {
-      if (!(current instanceof FieldTree)) {
-        return undefined;
-      }
-      const child = current.children.get(part);
-      if (child === undefined) {
-        return undefined;
-      }
-      current = child;
-    }
-    return current;
-  }
-
-  set(
-    path: string[],
-    value: LeafNode,
-    canReplaceLeaf: (value: LeafNode) => boolean = () => false,
-  ): FieldConflict | undefined {
-    let branch: FieldTree = this;
-    for (const [index, part] of path.slice(0, -1).entries()) {
-      const child = branch.children.get(part);
-      if (child === undefined || (isLeaf(child) && canReplaceLeaf(child))) {
-        const nextBranch = new FieldTree();
-        branch.children.set(part, nextBranch);
-        branch = nextBranch;
-      } else if (child instanceof FieldTree) {
-        branch = child;
-      } else {
-        return { path: path.slice(0, index + 1), value: child };
-      }
-    }
-
-    const name = path[path.length - 1];
-    const current = branch.children.get(name);
-    if (current instanceof FieldTree) {
-      return { path, value: current };
-    }
-    branch.children.set(name, value);
-    return undefined;
-  }
-
-  entries(): IterableIterator<[string, FieldNode]> {
-    return this.children.entries();
-  }
-
-  has(name: string): boolean {
-    return this.children.has(name);
-  }
-}
-
-function isLeaf(value: FieldNode): value is LeafNode {
-  return !(value instanceof FieldTree);
-}
-
-function fieldsFromTree(tree: FieldTree, path: string[] = []): Field[] {
-  const fields: Field[] = [];
-  for (const [name, value] of tree.entries()) {
-    if (value instanceof FieldTree) {
-      fields.push(
-        new Field(
-          name,
-          new Struct(fieldsFromTree(value, [...path, name])),
-          true,
-        ),
-      );
-    } else if (value instanceof DeferredTypeEvidence) {
-      throw typeInferenceError([...path, name], value.firstRow());
-    } else {
-      fields.push(new Field(name, value, true));
-    }
-  }
-  return fields;
-}
-
-function matchingFields(fields: Field[], tree: FieldTree): Field[] {
-  const matches: Field[] = [];
-  for (const field of fields) {
-    if (!tree.has(field.name)) {
-      continue;
-    }
-    const value = tree.get([field.name]);
-    if (value instanceof FieldTree) {
-      const struct = field.type as Struct;
-      matches.push(
-        new Field(
-          field.name,
-          new Struct(matchingFields(struct.children, value)),
-          field.nullable,
-        ),
-      );
-    } else {
-      matches.push(new Field(field.name, value as DataType, field.nullable));
-    }
-  }
-  return matches;
-}
-
-function* recordPathsAndValues(
-  record: Record<string, unknown>,
-  path: string[] = [],
-): Generator<[string[], unknown]> {
-  for (const [name, value] of Object.entries(record)) {
-    if (isRecord(value)) {
-      yield* recordPathsAndValues(value, [...path, name]);
-    } else if (value !== undefined) {
-      yield [[...path, name], value];
-    }
-  }
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    !Array.isArray(value) &&
-    !(value instanceof RegExp) &&
-    !(value instanceof Date) &&
-    !(value instanceof Set) &&
-    !(value instanceof Map) &&
-    !(value instanceof Buffer) &&
-    !ArrayBuffer.isView(value)
-  );
-}
-
-function fieldAtPath(schema: Schema, path: string[]): Field | undefined {
-  let fields = schema.fields;
-  let field: Field | undefined;
-  for (const [index, name] of path.entries()) {
-    field = fields.find((candidate) => candidate.name === name);
-    if (field === undefined || index === path.length - 1) {
-      return field;
-    }
-    if (!DataType.isStruct(field.type)) {
-      return undefined;
-    }
-    fields = field.type.children;
-  }
-  return field;
-}
-
-function isDeferredValue(value: unknown): boolean {
-  return (
-    value == null || (Array.isArray(value) && value.every(isDeferredValue))
-  );
-}
-
-function deferredValueMatchesType(value: unknown, type: DataType): boolean {
-  if (value == null) {
-    return true;
-  }
-  if (!Array.isArray(value)) {
-    return false;
-  }
-  if (DataType.isList(type)) {
-    return value.every((item) =>
-      deferredValueMatchesType(item, type.valueType),
-    );
-  }
-  if (DataType.isFixedSizeList(type)) {
-    return (
-      value.length === type.listSize &&
-      value.every((item) => deferredValueMatchesType(item, type.valueType))
-    );
-  }
-  return false;
-}
-
-function inferredTypesEqual(current: DataType, candidate: DataType): boolean {
-  if (DataType.isDictionary(current)) {
-    return (
-      DataType.isDictionary(candidate) &&
-      current.isOrdered === candidate.isOrdered &&
-      inferredTypesEqual(current.indices, candidate.indices) &&
-      inferredTypesEqual(current.dictionary, candidate.dictionary)
-    );
-  }
-  if (DataType.isList(current)) {
-    return (
-      DataType.isList(candidate) &&
-      current.valueField.name === candidate.valueField.name &&
-      current.valueField.nullable === candidate.valueField.nullable &&
-      inferredTypesEqual(current.valueType, candidate.valueType)
-    );
-  }
-  if (DataType.isFixedSizeList(current)) {
-    return (
-      DataType.isFixedSizeList(candidate) &&
-      current.listSize === candidate.listSize &&
-      current.valueField.name === candidate.valueField.name &&
-      current.valueField.nullable === candidate.valueField.nullable &&
-      inferredTypesEqual(current.valueType, candidate.valueType)
-    );
-  }
-  return arrowUtil.compareTypes(current, candidate);
-}
-
-function describeEvidence(
-  evidence: DataType | DeferredTypeEvidence | undefined,
-): string {
-  if (evidence === undefined) {
-    return "an unsupported value";
-  }
-  return evidence instanceof DeferredTypeEvidence
-    ? evidence.describe()
-    : evidence.toString();
-}
-
-function branchConflictError(
-  conflict: FieldConflict,
-  row: number,
-  candidate: string,
-): Error {
-  return schemaInferenceError(
-    conflict.path,
-    row,
-    conflict.value instanceof FieldTree
-      ? "Struct"
-      : describeEvidence(conflict.value),
-    candidate,
-  );
-}
-
-function schemaInferenceError(
-  path: string[],
-  row: number,
-  currentType: string,
-  newType: string,
-): Error {
-  return new Error(
-    `Failed to infer schema for data. Previously inferred type ${currentType} ` +
-      `but found ${newType} for field ${path.join(".")} at row ${row}. ` +
-      "Consider providing an explicit schema.",
-  );
-}
-
-function typeInferenceError(path: string[], row: number): Error {
-  return new Error(
-    `Failed to infer data type for field ${path.join(".")} at row ${row}. ` +
-      "Consider providing an explicit schema.",
-  );
-}
-
-function nameSuggestsVectorColumn(name: string): boolean {
-  const normalized = name.toLowerCase();
-  return normalized.includes("vector") || normalized.includes("embedding");
-}
@@ -43,7 +43,6 @@ import {
  Table as _NativeTable,
 } from "./native";
 import {
-  AutoQuery,
  FullTextQuery,
  Query,
  TakeQuery,
@@ -524,7 +523,7 @@ export abstract class Table {
    query: string | IntoVector | MultiVector | FullTextQuery,
    queryType?: string,
    ftsColumns?: string | string[],
-  ): VectorQuery | Query | AutoQuery;
+  ): VectorQuery | Query;
  /**
   * Search the table with a given query vector.
   *
@@ -976,11 +975,10 @@ export class LocalTable extends Table {
    return this.inner.display();
  }

-  private async getEmbeddingFunctions(
-    inner: _NativeTable = this.inner,
-  ): Promise<Map<string, EmbeddingFunctionConfig>> {
-    const schemaBuf = await inner.schema();
-    const schema = tableFromIPC(schemaBuf).schema;
+  private async getEmbeddingFunctions(): Promise<
+    Map<string, EmbeddingFunctionConfig>
+  > {
+    const schema = await this.schema();
    const registry = getRegistry();
    return registry.parseFunctions(schema.metadata);
  }
@@ -1162,7 +1160,7 @@ export class LocalTable extends Table {
    query: string | IntoVector | MultiVector | FullTextQuery,
    queryType: string = "auto",
    ftsColumns?: string | string[],
-  ): VectorQuery | Query | AutoQuery {
+  ): VectorQuery | Query {
    if (typeof query !== "string" && !instanceOfFullTextQuery(query)) {
      if (queryType === "fts") {
        throw new Error("Cannot perform full text search on a vector query");
@@ -1177,35 +1175,17 @@ export class LocalTable extends Table {
      });
    }

-    if (queryType === "auto" && typeof query !== "string") {
+    // The query type is auto or vector
+    // fall back to full text search if no embedding functions are defined and the query is a string
+    if (
+      queryType === "auto" &&
+      (getRegistry().length() === 0 || instanceOfFullTextQuery(query))
+    ) {
      return this.query().fullTextSearch(query, {
        columns: ftsColumns,
      });
    }

-    if (queryType === "auto" && typeof query === "string") {
-      const vector = async (snapshot: _NativeTable) => {
-        const functions = await this.getEmbeddingFunctions(snapshot);
-        // TODO: Support multiple embedding functions
-        const embeddingFunc: EmbeddingFunctionConfig | undefined = functions
-          .values()
-          .next().value;
-        if (embeddingFunc === undefined) {
-          return undefined;
-        }
-        return await embeddingFunc.function.computeQueryEmbeddings(query);
-      };
-
-      const columns =
-        typeof ftsColumns === "string" ? [ftsColumns] : ftsColumns;
-      return Query.autoSearch(
-        () => this.inner.checkoutCurrent(),
-        query,
-        vector,
-        columns,
-      );
-    }
-
    const queryPromise = this.getEmbeddingFunctions().then(
      async (functions) => {
        // TODO: Support multiple embedding functions
@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-darwin-arm64",
-	"version": "0.38.0-beta.10",
+	"version": "0.38.0-beta.4",
 	"os": ["darwin"],
 	"cpu": ["arm64"],
 	"main": "lancedb.darwin-arm64.node",
@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-arm64-gnu",
-	"version": "0.38.0-beta.10",
+	"version": "0.38.0-beta.4",
 	"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.10",
+	"version": "0.38.0-beta.4",
 	"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.10",
+	"version": "0.38.0-beta.4",
 	"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.10",
+	"version": "0.38.0-beta.4",
 	"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.10",
+  "version": "0.38.0-beta.4",
  "os": [
    "win32"
  ],
@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-win32-x64-msvc",
-	"version": "0.38.0-beta.10",
+	"version": "0.38.0-beta.4",
 	"os": ["win32"],
 	"cpu": ["x64"],
 	"main": "lancedb.win32-x64-msvc.node",
@@ -1,12 +1,12 @@
 {
  "name": "@lancedb/lancedb",
-  "version": "0.38.0-beta.10",
+  "version": "0.38.0-beta.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@lancedb/lancedb",
-      "version": "0.38.0-beta.10",
+      "version": "0.38.0-beta.3",
      "cpu": [
        "x64",
        "arm64"
@@ -11,7 +11,7 @@
    "ann"
  ],
  "private": false,
-  "version": "0.38.0-beta.10",
+  "version": "0.38.0-beta.4",
  "main": "dist/index.js",
  "exports": {
    ".": "./dist/index.js",
@@ -17,7 +17,6 @@ use lancedb::connection::{ConnectBuilder, Connection as LanceDBConnection, conne

 use lance_namespace::models::{
    CreateNamespaceRequest, DescribeNamespaceRequest, DropNamespaceRequest, ListNamespacesRequest,
-    ListTablesRequest,
 };
 use lancedb::ipc::{ipc_file_to_batches, ipc_file_to_schema};

@@ -37,12 +36,6 @@ pub struct ListNamespacesResponse {
    pub page_token: Option<String>,
 }

-#[napi(object)]
-pub struct ListTablesResponse {
-    pub tables: Vec<String>,
-    pub page_token: Option<String>,
-}
-
 #[napi(object)]
 pub struct CreateNamespaceResponse {
    pub properties: Option<HashMap<String, String>>,
@@ -213,33 +206,6 @@ impl Connection {
        op.execute().await.default_error()
    }

-    /// List a page of tables in the database.
-    #[napi(catch_unwind)]
-    pub async fn list_tables(
-        &self,
-        namespace_path: Option<Vec<String>>,
-        page_token: Option<String>,
-        limit: Option<u32>,
-    ) -> napi::Result<ListTablesResponse> {
-        let request = ListTablesRequest {
-            // The root namespace is an empty path, not an absent one: a namespace-backed
-            // database rejects a request that names no namespace.
-            id: Some(namespace_path.unwrap_or_default()),
-            page_token,
-            limit: limit.map(|limit| i32::try_from(limit).unwrap_or(i32::MAX)),
-            ..Default::default()
-        };
-        let response = self
-            .get_inner()?
-            .list_tables(request)
-            .await
-            .default_error()?;
-        Ok(ListTablesResponse {
-            tables: response.tables,
-            page_token: response.page_token,
-        })
-    }
-
    /// Create table from a Apache Arrow IPC (file) buffer.
    ///
    /// Parameters:
@@ -14,12 +14,9 @@ pub struct Job {
 }

 impl Job {
-    pub(crate) fn new<T>(inner: lancedb::Job<T>) -> Self
-    where
-        T: Clone + Send + Sync + 'static,
-    {
+    pub(crate) fn new(inner: lancedb::Job) -> Self {
        Self {
-            inner: Arc::new(inner.map(|_| ())),
+            inner: Arc::new(inner),
        }
    }
 }
@@ -554,12 +554,6 @@ impl Table {
            .default_error()
    }

-    #[napi(catch_unwind)]
-    pub async fn checkout_current(&self) -> napi::Result<Self> {
-        let table = self.inner_ref()?.checkout_current().await.default_error()?;
-        Ok(Self::new(table))
-    }
-
    #[napi(catch_unwind)]
    pub async fn checkout(&self, version: i64) -> napi::Result<()> {
        self.inner_ref()?
@@ -1,6 +1,6 @@
 [package]
 name = "lancedb-python"
-version = "0.38.0-beta.10"
+version = "0.38.0-beta.4"
 publish = false
 edition.workspace = true
 description = "Python bindings for LanceDB"
@@ -101,12 +101,9 @@ azure = ["adlfs>=2024.2.0"]
 [tool.maturin]
 python-source = "python"
 module-name = "lancedb._lancedb"
-# uv installs the project as an editable package before `uv run`, so keep that
-# bootstrap build consistent with `maturin develop`.
-editable-profile = "dev"

 [build-system]
-requires = ["maturin>=1.10"]
+requires = ["maturin>=1.9.4"]
 build-backend = "maturin"

 [tool.ruff.lint]
@@ -29,7 +29,6 @@ from .functions import (
    FunctionRegistrationRequest as FunctionRegistrationRequest,
    FunctionVersion as FunctionVersion,
    PythonRuntimeSpec as PythonRuntimeSpec,
-    RefreshColumnResult as RefreshColumnResult,
    UdfDefinition as UdfDefinition,
    udf as udf,
 )
@@ -179,18 +178,6 @@ def connect(
    ...     },
    ... )

-    For Azure Blob Storage, credentials can be passed directly without setting
-    environment variables:
-
-    >>> azure_storage_options = {
-    ...     "account_name": "some-account",
-    ...     "account_key": "some-key",
-    ... }
-    >>> db = lancedb.connect(  # doctest: +SKIP
-    ...     "az://my-container/my-database",
-    ...     storage_options=azure_storage_options,
-    ... )
-
    For tests and temporary data, use an in-memory database:

    >>> db = lancedb.connect("memory://")
@@ -477,10 +464,6 @@ async def connect_async(
    --------

    >>> import lancedb
-    >>> azure_storage_options = {
-    ...     "account_name": "some-account",
-    ...     "account_key": "some-key",
-    ... }
    >>> async def doctest_example():
    ...     # For a local directory, provide a path to the database
    ...     db = await lancedb.connect_async("~/.lancedb")
@@ -488,11 +471,6 @@ async def connect_async(
    ...     db = await lancedb.connect_async("s3://my-bucket/lancedb",
    ...                                      storage_options={
    ...                                          "aws_access_key_id": "***"})
-    ...     # Azure credentials can also be passed directly
-    ...     db = await lancedb.connect_async(
-    ...         "az://my-container/my-database",
-    ...         storage_options=azure_storage_options,
-    ...     )
    ...     # For tests and temporary data, use an in-memory database
    ...     db = await lancedb.connect_async("memory://")
    ...     # Connect to LanceDB cloud
@@ -147,7 +147,7 @@ class Connection(object):
        limit: Optional[int],
    ) -> list[str]: ...  # Deprecated: Use list_tables instead
    def job(self, job_id: str) -> Job: ...
-    async def create_function_async(self, request_json: str) -> Job: ...
+    async def create_function_async(self, request_json: str) -> FunctionJob: ...
    async def get_function(self, name: str, version: str) -> str: ...
    async def list_jobs(self) -> List[JobInfo]: ...
    async def get_job(self, job_id: str) -> Optional[JobDescription]: ...
@@ -234,7 +234,14 @@ class Job:
    @property
    def id(self) -> Optional[str]: ...
    async def status(self) -> str: ...
-    async def wait(self) -> Optional[str]: ...
+    async def wait(self) -> None: ...
+    async def cancel(self) -> None: ...
+
+class FunctionJob:
+    @property
+    def id(self) -> Optional[str]: ...
+    async def status(self) -> str: ...
+    async def wait(self) -> str: ...
    async def cancel(self) -> None: ...

 class JobInfo:
@@ -283,7 +290,6 @@ class Table:
        mode: Literal["append", "overwrite"],
        progress: Optional[Any] = None,
        write_parallelism: Optional[int] = None,
-        allow_external_blob_outside_bases: bool = False,
    ) -> AddResult: ...
    async def update(
        self, updates: Dict[str, str], where: Optional[str]
@@ -46,7 +46,7 @@ from lance_namespace.errors import NamespaceNotEmptyError, TableNotFoundError
 from . import __version__
 from ._lancedb import connect as lancedb_connect  # type: ignore
 from .functions import FunctionVersion, UdfDefinition
-from .job import AsyncJob, Job, _typed_job
+from .job import AsyncJob, Job, _function_job
 from .materialized_view import (
    AsyncMaterializedView,
    MaterializedView,
@@ -2237,7 +2237,7 @@ class AsyncConnection(object):
        inner = await self._inner.create_function_async(
            definition.registration_request.to_canonical_json()
        )
-        return _typed_job(inner, FunctionVersion.from_json)
+        return _function_job(inner)

    async def get_function(self, name: str, *, version: str) -> FunctionVersion:
        """Open one exact immutable Function version from the remote catalog."""
@@ -1,30 +1,26 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright The LanceDB Authors

-"""Canonical Function values exchanged with LanceDB Enterprise services.
+"""Canonical values exchanged with LanceDB Enterprise Function services.

 These immutable models contain client/wire state only. Catalog persistence,
-environment bake, and execution are owned by Sophon.
-``RefreshColumnResult`` is also the backend-neutral result of a local
-expression-backed refresh job.
+environment bake, secret resolution, and execution are owned by Sophon.
 """

 from __future__ import annotations

 import ast
-import builtins
 import base64
 import functools
 import hashlib
-import importlib
 import inspect
-import symtable
 import json
 import math
 import re
 import sys
 import textwrap
 import types
+import uuid
 from collections.abc import Mapping
 from datetime import date, datetime
 from typing import (
@@ -228,7 +224,7 @@ class PythonEnvironmentSpec(_RemoteValue):


 class PythonRuntimeSpec(_RemoteValue):
-    """Remote runtime definition with environment values.
+    """Remote runtime definition with non-secret environment values.

    V1 supports ``kind="python"``. Newer runtime kinds remain readable, while
    their unknown payload fields are intentionally not retained by the client.
@@ -267,6 +263,7 @@ class FunctionVersion(_RemoteValue):
    runtime: PythonRuntimeSpec
    runtime_digest: str
    environment_digest: str
+    required_secrets: tuple[str, ...] = ()
    created_at: str

    def __call__(self, **inputs: Any) -> FunctionApplication:
@@ -274,7 +271,7 @@ class FunctionVersion(_RemoteValue):

        Every input must be a direct [lancedb.col][lancedb.expr.col]
        reference. The returned application is immutable and retains a
-        named-struct output as one binding, so every row's sibling values
+        named-struct output as one sibling group, so every row's sibling values
        come from one logical Function evaluation. Map result fields to table
        columns with
        [FunctionApplication.rename][lancedb.functions.FunctionApplication.rename],
@@ -324,16 +321,22 @@ class FunctionVersion(_RemoteValue):
            function=FunctionVersionRef(name=self.name, version=self.version),
            inputs=tuple(bindings),
            output=self.signature.output,
+            group_id=f"fg_{uuid.uuid4().hex}",
        )


 class FunctionRegistrationRequest(_RemoteValue):
-    """Stable remote registration envelope produced by :func:`udf`."""
+    """Stable remote registration envelope produced by :func:`udf`.
+
+    Only secret names are represented. Secret values are resolved inside the
+    remote service and have no client request field.
+    """

    name: str
    artifact: FunctionArtifactRequest
    signature: FunctionSignature
    runtime: PythonRuntimeSpec
+    required_secrets: tuple[str, ...] = ()


 class FunctionVersionRef(_OpenRemoteValue):
@@ -362,7 +365,7 @@ class ApplicationInput(_OpenRemoteValue):
 class FunctionApplication(_OpenRemoteValue):
    """Immutable pre-declaration application of an exact Function version.

-    A named-struct output remains one application through table
+    A named-struct output remains one grouped application through table
    declaration and execution.
    [FunctionApplication.rename][lancedb.functions.FunctionApplication.rename]
    records the result-field to table-column mapping without splitting sibling
@@ -372,6 +375,7 @@ class FunctionApplication(_OpenRemoteValue):
    function: FunctionVersionRef
    inputs: tuple[ApplicationInput, ...]
    output: FunctionOutput
+    group_id: str
    columns: Mapping[str, str] = Field(default_factory=dict)

    def _known_dict(self) -> dict[str, Any]:
@@ -443,10 +447,12 @@ class OutputMapping(_RemoteValue):


 class FunctionBinding(_RemoteValue):
-    """Immutable Function binding persisted by the Enterprise table service."""
+    """Immutable grouped binding persisted by the Enterprise table service."""

    binding_id: str
+    revision: _UInt64
    function: FunctionVersionRef
+    group_id: str
    inputs: tuple[InputBinding, ...]
    outputs: tuple[OutputMapping, ...]
    input_schema: Optional[Mapping[str, Any]] = None
@@ -454,11 +460,7 @@ class FunctionBinding(_RemoteValue):


 class RefreshColumnResult(_RemoteValue):
-    """Terminal result of an expression-backed or Function-backed refresh Job.
-
-    Local jobs produce this value in process. LanceDB Cloud and Enterprise
-    decode the same value from the durable server-job terminal payload.
-    """
+    """Terminal result of a remote Function-column refresh Job."""

    rows_assigned: _UInt64
    rows_failed: _UInt64
@@ -478,60 +480,62 @@ class RefreshColumnResult(_RemoteValue):


 _FUNCTION_NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_.-]*$")
-
-
-_GRAMMAR_PRIMITIVES = (
-    (pa.bool_(), "bool"),
-    (pa.int8(), "int8"),
-    (pa.int16(), "int16"),
-    (pa.int32(), "int32"),
-    (pa.int64(), "int64"),
-    (pa.uint8(), "uint8"),
-    (pa.uint16(), "uint16"),
-    (pa.uint32(), "uint32"),
-    (pa.uint64(), "uint64"),
-    (pa.float16(), "float16"),
-    (pa.float32(), "float32"),
-    (pa.float64(), "float64"),
-    (pa.string(), "utf8"),
-    (pa.binary(), "binary"),
-    (pa.date32(), "date32"),
-    (pa.date64(), "date64"),
-)
+_SECRET_NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")


 def _canonical_arrow_type(data_type: pa.DataType) -> str:
-    """The server's V1 Function type grammar. Anything outside it is rejected
-    here rather than at registration."""
-    for candidate, name in _GRAMMAR_PRIMITIVES:
+    primitive_types = (
+        (pa.bool_(), "bool"),
+        (pa.int8(), "int8"),
+        (pa.int16(), "int16"),
+        (pa.int32(), "int32"),
+        (pa.int64(), "int64"),
+        (pa.uint8(), "uint8"),
+        (pa.uint16(), "uint16"),
+        (pa.uint32(), "uint32"),
+        (pa.uint64(), "uint64"),
+        (pa.float16(), "float16"),
+        (pa.float32(), "float32"),
+        (pa.float64(), "float64"),
+        (pa.string(), "utf8"),
+        (pa.large_utf8(), "large_utf8"),
+        (pa.binary(), "binary"),
+        (pa.large_binary(), "large_binary"),
+        (pa.date32(), "date32"),
+        (pa.date64(), "date64"),
+    )
+    for candidate, name in primitive_types:
        if data_type == candidate:
            return name
-    if pa.types.is_list(data_type) or pa.types.is_large_list(data_type):
-        prefix = "list" if pa.types.is_list(data_type) else "large_list"
-        return f"{prefix}<{_canonical_list_item(data_type)}>"
-    if pa.types.is_fixed_size_list(data_type) and data_type.list_size > 0:
+    if pa.types.is_fixed_size_binary(data_type):
+        return f"fixed_size_binary[{data_type.byte_width}]"
+    if pa.types.is_list(data_type):
+        return f"list<{_canonical_arrow_type(data_type.value_type)}>"
+    if pa.types.is_large_list(data_type):
+        return f"large_list<{_canonical_arrow_type(data_type.value_type)}>"
+    if pa.types.is_fixed_size_list(data_type):
        return (
-            f"fixed_size_list<{_canonical_list_item(data_type)}, {data_type.list_size}>"
+            f"fixed_size_list<{_canonical_arrow_type(data_type.value_type)}>"
+            f"[{data_type.list_size}]"
        )
+    if pa.types.is_struct(data_type):
+        fields = ",".join(
+            f"{field.name}:{_canonical_arrow_type(field.type)}" for field in data_type
+        )
+        return f"struct<{fields}>"
+    if pa.types.is_timestamp(data_type):
+        timezone = f",tz={data_type.tz}" if data_type.tz is not None else ""
+        return f"timestamp[{data_type.unit}{timezone}]"
+    if pa.types.is_time32(data_type) or pa.types.is_time64(data_type):
+        return f"time[{data_type.unit}]"
+    if pa.types.is_duration(data_type):
+        return f"duration[{data_type.unit}]"
+    if pa.types.is_decimal(data_type):
+        bit_width = data_type.bit_width
+        return f"decimal{bit_width}({data_type.precision},{data_type.scale})"
    raise TypeError(f"unsupported Arrow type for Function signature: {data_type}")


-def _canonical_list_item(data_type: pa.DataType) -> str:
-    """The grammar names only the item type; it always means a non-nullable
-    child called `item`, so any other child metadata cannot be represented."""
-    child = data_type.value_field
-    if child.name != "item" or child.nullable or child.metadata:
-        raise TypeError(
-            "unsupported Arrow type for Function signature: list items must be a "
-            f"non-nullable field named 'item', got {child}"
-        )
-    return _canonical_arrow_type(child.type)
-
-
-def _list_of(item: pa.DataType) -> pa.DataType:
-    return pa.list_(pa.field("item", item, nullable=False))
-
-
 def _annotation_type(annotation: Any) -> tuple[pa.DataType, bool]:
    nullable = False
    origin = get_origin(annotation)
@@ -579,7 +583,7 @@ def _annotation_type(annotation: Any) -> tuple[pa.DataType, bool]:
        value_type, value_nullable = _annotation_type(arguments[0])
        if value_nullable:
            raise TypeError("nullable Function list elements are not supported")
-        return _list_of(value_type), nullable
+        return pa.list_(value_type), nullable
    raise TypeError(f"unsupported Function annotation: {annotation!r}")


@@ -726,104 +730,6 @@ def _literal_source(value: Any) -> str:
    )


-_DYNAMIC_NAMESPACE_ACCESS = frozenset(
-    {"globals", "locals", "vars", "eval", "exec", "compile", "__import__"}
-)
-# Modules that hand out namespaces (`sys.modules`, `builtins`, importers,
-# introspection). The artifact's module namespace holds only the names it was
-# packaged with, so reaching around it cannot be represented.
-_NAMESPACE_MODULES = frozenset(
-    {"sys", "builtins", "importlib", "inspect", "gc", "ctypes", "types"}
-)
-
-
-def _namespace_acquisition(
-    definition: ast.FunctionDef, references: set[str]
-) -> list[str]:
-    found = set(references & _DYNAMIC_NAMESPACE_ACCESS)
-    for node in ast.walk(definition):
-        if isinstance(node, ast.Import):
-            found.update(
-                alias.name
-                for alias in node.names
-                if alias.name.split(".")[0] in _NAMESPACE_MODULES
-            )
-        elif isinstance(node, ast.ImportFrom) and node.module:
-            if node.module.split(".")[0] in _NAMESPACE_MODULES:
-                found.add(node.module)
-    return sorted(found)
-
-
-def _module_references(module_source: str) -> set[str]:
-    """Names any scope in `module_source` binds or loads at module scope.
-    Python's own scope analysis on the exact text that ships: free variables
-    belong to an enclosing scope inside the function, and postponed
-    annotations are not runtime loads."""
-
-    def visit(table: symtable.SymbolTable, found: set[str]) -> None:
-        for symbol in table.get_symbols():
-            if symbol.is_global() and (
-                symbol.is_referenced() or symbol.is_declared_global()
-            ):
-                found.add(symbol.get_name())
-        for child in table.get_children():
-            visit(child, found)
-
-    found: set[str] = set()
-    for table in symtable.symtable(module_source, "<udf>", "exec").get_children():
-        visit(table, found)
-    return found
-
-
-def _global_source(name: str, value: Any) -> str:
-    """One module-level line that rebinds `name` to `value` in the artifact:
-    an import for modules and importable classes/functions, a literal otherwise."""
-    if isinstance(value, types.ModuleType):
-        if value.__name__.split(".")[0] in _NAMESPACE_MODULES:
-            raise ValueError(
-                f"@udf cannot package dynamic namespace access: {value.__name__!r}"
-            )
-        try:
-            imported = importlib.import_module(value.__name__)
-        except ImportError:
-            imported = None
-        if imported is not value:
-            raise TypeError(
-                f"Function source references module {name!r} that does not import "
-                f"as {value.__name__!r}"
-            )
-        return f"import {value.__name__} as {name}"
-    module_name = getattr(value, "__module__", None)
-    qualname = getattr(value, "__qualname__", None)
-    if (
-        isinstance(module_name, str)
-        and isinstance(qualname, str)
-        and module_name != "__main__"
-        and "." not in qualname
-        and "<" not in qualname
-    ):
-        try:
-            imported = getattr(importlib.import_module(module_name), qualname)
-        except (ImportError, AttributeError):
-            imported = None
-        if imported is value:
-            return f"from {module_name} import {qualname} as {name}"
-    return f"{name} = {_literal_source(value)}"
-
-
-def _is_recursive_reference(function: Callable[..., Any], name: str) -> bool:
-    """`name` inside the body means the function itself unless the module has
-    since bound it to something else."""
-    if name != function.__name__:
-        return False
-    bound = function.__globals__.get(name, function)
-    if bound is function:
-        return True
-    # The decorator's own result is the one wrapper known to call `function`
-    # unchanged; any other binding may behave differently from a self-call.
-    return type(bound) is UdfDefinition and bound._function is function
-
-
 def _package_source(function: Callable[..., Any]) -> bytes:
    if not inspect.isfunction(function) or inspect.iscoroutinefunction(function):
        raise TypeError("@udf requires a synchronous Python function")
@@ -848,46 +754,23 @@ def _package_source(function: Callable[..., Any]) -> bytes:
    closure = inspect.getclosurevars(function)
    if closure.nonlocals:
        raise ValueError("@udf cannot package functions that capture closure values")
-    function_source = ast.unparse(definition)
-    module_header = "from __future__ import annotations"
-    references = _module_references(f"{module_header}\n\n{function_source}\n")
-    dynamic = _namespace_acquisition(definition, references)
-    if dynamic:
-        raise ValueError(f"@udf cannot package dynamic namespace access: {dynamic!r}")
-    # Resolve every module-scope reference the way the interpreter would: the
-    # function's own globals first (a module global may shadow a builtin, and
-    # nested scopes are not visible to getclosurevars), then its builtins.
-    # The artifact runs under the standard builtins; only the exact mapping is
-    # provably equivalent (a subclass or copy can change lookups and hooks).
-    if function.__builtins__ is not vars(builtins):
-        raise ValueError("@udf cannot package a non-standard builtins environment")
-    globals_source = []
-    unresolved = []
-    for name in sorted(references):
-        if name == function.__name__:
-            if not _is_recursive_reference(function, name):
-                raise ValueError(
-                    f"@udf cannot package {name!r}: the module binds that name to "
-                    "another value, which the artifact's own definition would shadow"
-                )
-            continue
-        if name in function.__globals__:
-            globals_source.append(_global_source(name, function.__globals__[name]))
-        elif hasattr(builtins, name):
-            pass
-        else:
-            unresolved.append(name)
-    if unresolved:
+    if closure.unbound:
        raise ValueError(
-            f"@udf source contains unresolved global names: {unresolved!r}"
+            f"@udf source contains unresolved global names: {sorted(closure.unbound)!r}"
        )
+    globals_source = []
+    for name, value in sorted(closure.globals.items()):
+        if isinstance(value, types.ModuleType):
+            globals_source.append(f"import {value.__name__} as {name}")
+        else:
+            globals_source.append(f"{name} = {_literal_source(value)}")

-    parts = [module_header]
+    function_source = ast.unparse(definition)
+    parts = ["from __future__ import annotations"]
    if globals_source:
        parts.extend(["", *globals_source])
    parts.extend(["", function_source, ""])
-    packaged = "\n".join(parts)
-    return packaged.encode("utf-8")
+    return "\n".join(parts).encode("utf-8")


 class UdfDefinition:
@@ -908,6 +791,7 @@ class UdfDefinition:
        output_schema: Optional[pa.DataType | pa.Field | pa.Schema],
        pip: tuple[str, ...],
        env: Mapping[str, str],
+        secrets: tuple[str, ...],
        python_version: Optional[str],
    ):
        function_name = name or function.__name__
@@ -922,6 +806,18 @@ class UdfDefinition:
            for key, value in environment.items()
        ):
            raise TypeError("Function env keys and values must be strings")
+        required_secrets = tuple(sorted(set(secrets)))
+        invalid_secrets = [
+            secret for secret in required_secrets if not _SECRET_NAME.fullmatch(secret)
+        ]
+        if invalid_secrets:
+            raise ValueError(f"invalid Function secret names: {invalid_secrets!r}")
+        overlap = set(environment) & set(required_secrets)
+        if overlap:
+            raise ValueError(
+                f"Function env and secret names must be disjoint: {sorted(overlap)!r}"
+            )
+
        signature = _infer_signature(function, input_schema, output_schema)
        source = _package_source(function)
        digest = f"sha256:{hashlib.sha256(source).hexdigest()}"
@@ -950,6 +846,7 @@ class UdfDefinition:
            ),
            signature=signature,
            runtime=runtime,
+            required_secrets=required_secrets,
        )
        functools.update_wrapper(self, function)

@@ -975,6 +872,7 @@ def udf(
    output_schema: Optional[pa.DataType | pa.Field | pa.Schema] = None,
    pip: tuple[str, ...] | list[str] = (),
    env: Optional[Mapping[str, str]] = None,
+    secrets: tuple[str, ...] | list[str] = (),
    python_version: Optional[str] = None,
 ) -> Callable[[Callable[..., Any]], UdfDefinition]: ...

@@ -987,6 +885,7 @@ def udf(
    output_schema: Optional[pa.DataType | pa.Field | pa.Schema] = None,
    pip: tuple[str, ...] | list[str] = (),
    env: Optional[Mapping[str, str]] = None,
+    secrets: tuple[str, ...] | list[str] = (),
    python_version: Optional[str] = None,
 ):
    """Prepare a scalar Python callable for remote Function registration.
@@ -1011,17 +910,13 @@ def udf(
    pip : sequence of str, optional
        Pip requirements for the remote environment.
    env : mapping of str to str, optional
-        Environment variables included in the Function definition.
+        Non-secret environment variables. Use ``secrets`` for credentials.
+    secrets : sequence of str, optional
+        Names of secrets resolved by the remote service. Secret values are not
+        accepted by this API or included in the registration request.
    python_version : str, optional
        Remote Python major/minor version. Defaults to the client version.

-    The packaged artifact is a snapshot: the function source plus exactly
-    the module-level names it references (modules as imports, importable
-    classes and functions as imports, literals inline). Code that reaches the
-    module namespace another way -- ``globals()``/``eval``, ``sys.modules``,
-    ``builtins`` -- is rejected where it can be seen and otherwise
-    unsupported; closures and a non-standard ``__builtins__`` are rejected.
-
    Returns
    -------
    UdfDefinition
@@ -1033,7 +928,7 @@ def udf(
    Examples
    --------
    >>> from lancedb import udf
-    >>> @udf(pip=["numpy==2.2.0"])
+    >>> @udf(pip=["numpy==2.2.0"], secrets=["MODEL_TOKEN"])
    ... def score(value: float) -> float:
    ...     return value * 2
    >>> score(1.5)
@@ -1048,6 +943,7 @@ def udf(
            output_schema=output_schema,
            pip=tuple(pip),
            env={} if env is None else env,
+            secrets=tuple(secrets),
            python_version=python_version,
        )

@@ -5,11 +5,12 @@

 import asyncio
 from datetime import timedelta
-from typing import Any, Callable, Generic, Optional, TypeVar, cast
+from typing import Any, Generic, Optional, TypeVar, cast

 from lancedb.background_loop import LOOP

 from . import _lancedb
+from .functions import FunctionVersion

 T = TypeVar("T")

@@ -17,18 +18,11 @@ T = TypeVar("T")
 class AsyncJob(Generic[T]):
    """A handle to an operation that may still be running.

-    The operation may already be complete when the handle is created. ``T``
-    is the endpoint's terminal result type; unit-result jobs resolve to
-    ``None``.
+    The operation may already be complete when the handle is created.
    """

-    def __init__(
-        self,
-        inner: Optional[Any],
-        result_decoder: Optional[Callable[[Any], T]] = None,
-    ):
+    def __init__(self, inner: Optional[Any]):
        self._inner = inner
-        self._result_decoder = result_decoder

    @property
    def id(self) -> Optional[str]:
@@ -56,21 +50,17 @@ class AsyncJob(Generic[T]):
    async def wait(self, timeout: Optional[timedelta] = None) -> T:
        """Wait until the operation reaches a terminal state.

-        Returns the endpoint's typed result, or ``None`` for a unit-result
-        job.
-
        Raises `JobFailedError` if the operation failed, `JobCancelledError`
        if it was cancelled, and `TimeoutError` if `timeout` elapses first.
        """
        if self._inner is None:
            return cast(T, None)
        if timeout is None:
-            result = await self._inner.wait()
-        else:
-            result = await asyncio.wait_for(self._inner.wait(), timeout.total_seconds())
-        if self._result_decoder is not None:
-            return self._result_decoder(result)
-        return cast(T, result)
+            return cast(T, await self._inner.wait())
+        return cast(
+            T,
+            await asyncio.wait_for(self._inner.wait(), timeout.total_seconds()),
+        )

    async def cancel(self):
        """Request cancellation. Cancelling a finished operation is a no-op."""
@@ -80,7 +70,7 @@ class AsyncJob(Generic[T]):


 class Job(Generic[T]):
-    """Synchronous counterpart of `AsyncJob` with the same result type."""
+    """Synchronous counterpart of `AsyncJob`."""

    def __init__(self, inner: Optional[AsyncJob[T]]):
        self._inner = inner
@@ -106,9 +96,6 @@ class Job(Generic[T]):
    def wait(self, timeout: Optional[timedelta] = None) -> T:
        """Block until the operation reaches a terminal state.

-        Returns the endpoint's typed result, or ``None`` for a unit-result
-        job.
-
        Raises `JobFailedError` if the operation failed, `JobCancelledError`
        if it was cancelled, and `TimeoutError` if `timeout` elapses first.
        """
@@ -123,8 +110,23 @@ class Job(Generic[T]):
        LOOP.run(self._inner.cancel())


-def _typed_job(
-    inner: "_lancedb.Job", result_decoder: Callable[[str], T]
-) -> AsyncJob[T]:
-    """Bind an internal JSON-producing job to its public result model."""
-    return AsyncJob(inner, result_decoder)
+class _FunctionJobAdapter:
+    def __init__(self, inner: "_lancedb.FunctionJob"):
+        self._inner = inner
+
+    @property
+    def id(self) -> Optional[str]:
+        return self._inner.id
+
+    async def status(self) -> str:
+        return await self._inner.status()
+
+    async def wait(self) -> FunctionVersion:
+        return FunctionVersion.from_json(await self._inner.wait())
+
+    async def cancel(self):
+        await self._inner.cancel()
+
+
+def _function_job(inner: "_lancedb.FunctionJob") -> AsyncJob[FunctionVersion]:
+    return AsyncJob(_FunctionJobAdapter(inner))
@@ -391,15 +391,6 @@ def _table_to_pickle_state(table: Table) -> dict[str, Any]:
    }


-def _drop_base_version(permutation_data: pa.Table) -> pa.Table:
-    """Strip the recorded base version so the reader leaves the base table unpinned."""
-    metadata = dict(permutation_data.schema.metadata or {})
-    if metadata.pop(b"base_version", None) is None:
-        return permutation_data
-    metadata.pop(b"base_branch", None)
-    return permutation_data.replace_schema_metadata(metadata)
-
-
 def _table_from_pickle_state(state: dict[str, Any]) -> Table:
    from . import connect

@@ -688,15 +679,11 @@ class Permutation:
        from . import connect

        connection_factory = state["connection_factory"]
-        rebuilt_base = False
        if connection_factory is not None:
            base_table = connection_factory(state["base_table_name"])
        elif "base_table_state" in state:
-            base_state = state["base_table_state"]
-            rebuilt_base = base_state["kind"] == "memory"
-            base_table = _table_from_pickle_state(base_state)
+            base_table = _table_from_pickle_state(state["base_table_state"])
        elif "base_table_data" in state:
-            rebuilt_base = True
            # In-memory base table inlined into the pickle; rebuild the same
            # way we rebuild the in-memory permutation table.
            mem_db = connect("memory://")
@@ -714,14 +701,11 @@ class Permutation:
            )

        permutation_table: Optional[Table] = None
-        permutation_data = state["permutation_data"]
-        if permutation_data is not None:
-            if rebuilt_base:
-                # The base table was materialized from Arrow, so it is a fresh
-                # single-version dataset and the recorded pin cannot resolve on it.
-                permutation_data = _drop_base_version(permutation_data)
+        if state["permutation_data"] is not None:
            mem_db = connect("memory://")
-            permutation_table = mem_db.create_table("permutation", permutation_data)
+            permutation_table = mem_db.create_table(
+                "permutation", state["permutation_data"]
+            )

        self.base_table = base_table
        self.permutation_table = permutation_table
@@ -49,7 +49,7 @@ from lancedb.index import (
    LabelList,
 )
 from lancedb.job import Job
-from lancedb.functions import FunctionApplication, RefreshColumnResult
+from lancedb.functions import FunctionApplication
 from lancedb.remote.db import LOOP
 from lancedb.table import IndexConfigType, KNOWN_METRICS
 import pyarrow as pa
@@ -610,7 +610,6 @@ class RemoteTable(Table):
        fill_value: float = 0.0,
        progress: Optional[Union[bool, Callable, Any]] = None,
        write_parallelism: Optional[int] = None,
-        allow_external_blob_outside_bases: bool = False,
    ) -> AddResult:
        """Add more data to the [Table][lancedb.table.Table].

@@ -643,8 +642,6 @@ class RemoteTable(Table):
            data in flight. Defaults to an estimate based on the data size,
            capped at the number of CPU cores. Lower this if bulk ingestion is
            using too much memory.
-        allow_external_blob_outside_bases: bool, default False
-            Not supported on LanceDB Cloud. Setting this raises.

        Returns
        -------
@@ -661,7 +658,6 @@ class RemoteTable(Table):
                    fill_value=fill_value,
                    progress=progress,
                    write_parallelism=write_parallelism,
-                    allow_external_blob_outside_bases=allow_external_blob_outside_bases,
                )
            )
        finally:
@@ -976,7 +972,7 @@ class RemoteTable(Table):
    def refresh_column(self, column: str):
        return LOOP.run(self._table.refresh_column(column))

-    def refresh_column_async(self, column: str) -> Job[RefreshColumnResult]:
+    def refresh_column_async(self, column: str) -> Job:
        return Job(LOOP.run(self._table.refresh_column_async(column)))

    def alter_columns(
@@ -40,7 +40,7 @@ from ._blob import (
 from .types import BlobMode
 from lancedb.arrow import peek_reader
 from lancedb.background_loop import LOOP, embedding_executor
-from lancedb.job import AsyncJob, Job, _typed_job
+from lancedb.job import AsyncJob, Job
 from .dependencies import (
    _check_for_hugging_face,
    _check_for_lance,
@@ -72,10 +72,7 @@ from .index import (
    FTS,
 )
 from .expr import Expr
-from .functions import (
-    FunctionApplication,
-    RefreshColumnResult as RefreshColumnJobResult,
-)
+from .functions import FunctionApplication
 from .merge import LanceMergeInsertBuilder
 from .pydantic import LanceModel, model_to_dict
 from .query import (
@@ -1269,7 +1266,6 @@ class Table(ABC):
        fill_value: float = 0.0,
        progress: Optional[Union[bool, Callable, Any]] = None,
        write_parallelism: Optional[int] = None,
-        allow_external_blob_outside_bases: bool = False,
    ) -> AddResult:
        """Add more data to the [Table][lancedb.table.Table].

@@ -1321,10 +1317,6 @@ class Table(ABC):
            data in flight. Defaults to an estimate based on the data size,
            capped at the number of CPU cores. Lower this if bulk ingestion is
            using too much memory.
-        allow_external_blob_outside_bases: bool, default False
-            Store blob URIs that sit outside registered blob bases. The row
-            keeps a reference, so the object has to stay readable. Local
-            tables only.

        Returns
        -------
@@ -1977,7 +1969,7 @@ class Table(ABC):
            A mapping with one ``FunctionApplication`` value keeps its scalar
            or named-struct result in the named table column. A bare
            named-struct application expands its ordered result fields as one
-            atomic binding; aliases come from ``rename(columns=...)``.
+            atomic sibling group; aliases come from ``rename(columns=...)``.
            Function columns are supported only on LanceDB Cloud and
            Enterprise.
        computed: Dict[str, str], optional
@@ -2047,7 +2039,7 @@ class Table(ABC):
        """

    @abstractmethod
-    def refresh_column_async(self, column: str) -> Job[RefreshColumnJobResult]:
+    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.
@@ -2058,12 +2050,6 @@ class Table(ABC):
        than failing the job. On local tables the job runs in-process; on
        LanceDB Cloud and Enterprise it is the server's backfill job.

-        Returns
-        -------
-        Job[RefreshColumnResult]
-            A job whose successful ``wait`` returns row counts plus the source
-            and published table versions.
-
        Examples
        --------
        >>> import lancedb
@@ -2072,9 +2058,7 @@ class Table(ABC):
        >>> table.add_columns(computed={"doubled": "x * 2"})
        AddColumnsResult(version=2)
        >>> job = table.refresh_column_async("doubled")
-        >>> result = job.wait()
-        >>> result.rows_assigned
-        2
+        >>> job.wait()
        >>> job.status()
        'finished'
        """
@@ -3414,7 +3398,6 @@ class LanceTable(Table):
        fill_value: float = 0.0,
        progress: Optional[Union[bool, Callable, Any]] = None,
        write_parallelism: Optional[int] = None,
-        allow_external_blob_outside_bases: bool = False,
    ) -> AddResult:
        """Add data to the table.
        If vector columns are missing and the table
@@ -3442,9 +3425,6 @@ class LanceTable(Table):
            data in flight. Defaults to an estimate based on the data size,
            capped at the number of CPU cores. Lower this if bulk ingestion is
            using too much memory.
-        allow_external_blob_outside_bases: bool, default False
-            Allow blob URIs outside registered bases. See :meth:`Table.add`.
-            Local tables only.

        Returns
        -------
@@ -3461,7 +3441,6 @@ class LanceTable(Table):
                    fill_value=fill_value,
                    progress=progress,
                    write_parallelism=write_parallelism,
-                    allow_external_blob_outside_bases=allow_external_blob_outside_bases,
                )
            )
        finally:
@@ -4103,7 +4082,7 @@ class LanceTable(Table):
        [`AsyncTable.refresh_column`][lancedb.AsyncTable.refresh_column]."""
        return LOOP.run(self._table.refresh_column(column))

-    def refresh_column_async(self, column: str) -> Job[RefreshColumnJobResult]:
+    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].
@@ -5375,7 +5354,6 @@ class AsyncTable:
        fill_value: Optional[float] = None,
        progress: Optional[Union[bool, Callable, Any]] = None,
        write_parallelism: Optional[int] = None,
-        allow_external_blob_outside_bases: bool = False,
    ) -> AddResult:
        """Add more data to the [AsyncTable][lancedb.table.AsyncTable].

@@ -5406,9 +5384,6 @@ class AsyncTable:
            data in flight. Defaults to an estimate based on the data size,
            capped at the number of CPU cores. Lower this if bulk ingestion is
            using too much memory.
-        allow_external_blob_outside_bases: bool, default False
-            Allow blob URIs outside registered bases. See :meth:`Table.add`.
-            Local tables only.

        """
        schema = await self.schema()
@@ -5445,7 +5420,6 @@ class AsyncTable:
                mode or "append",
                progress=progress,
                write_parallelism=write_parallelism,
-                allow_external_blob_outside_bases=allow_external_blob_outside_bases,
            )
        except RuntimeError as e:
            if "Cast error" in str(e):
@@ -6053,7 +6027,7 @@ class AsyncTable:
            A mapping with one ``FunctionApplication`` value keeps its scalar
            or named-struct result in the named table column. A bare
            named-struct application expands its ordered result fields as one
-            atomic binding; aliases come from ``rename(columns=...)``.
+            atomic sibling group; aliases come from ``rename(columns=...)``.
            Function columns are supported only on LanceDB Cloud and
            Enterprise.
        computed: Dict[str, str], optional
@@ -6090,7 +6064,7 @@ class AsyncTable:
                isinstance(value, FunctionApplication) for value in transforms.values()
            ):
                raise ValueError(
-                    "one add_columns call declares exactly one Function binding"
+                    "one add_columns call declares exactly one Function sibling group"
                )
            function_output_name, function_application = next(iter(transforms.items()))

@@ -6148,9 +6122,7 @@ class AsyncTable:
        """
        return await self._inner.refresh_column(column)

-    async def refresh_column_async(
-        self, column: str
-    ) -> AsyncJob[RefreshColumnJobResult]:
+    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.
@@ -6162,12 +6134,6 @@ class AsyncTable:
        in-process; on LanceDB Cloud and Enterprise it is the server's
        backfill job.

-        Returns
-        -------
-        AsyncJob[RefreshColumnResult]
-            A job whose successful ``wait`` returns row counts plus the source
-            and published table versions.
-
        Examples
        --------
        >>> import asyncio
@@ -6177,16 +6143,12 @@ class AsyncTable:
        ...     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")
-        ...     result = await job.wait()
-        ...     assert result.rows_assigned == 1
+        ...     await job.wait()
        ...     return await job.status()
        >>> asyncio.run(refresh_in_background())
        'finished'
        """
-        return _typed_job(
-            await self._inner.refresh_column_async(column),
-            RefreshColumnJobResult.from_json,
-        )
+        return AsyncJob(await self._inner.refresh_column_async(column))

    async def alter_columns(
        self, *alterations: Iterable[dict[str, Any]]
@@ -617,71 +617,3 @@ def test_fetch_blobs_nested_path_survives_sort_after_query():
 def _identifiable_payload(size: int) -> bytes:
    block = 256
    return b"".join(bytes([i % 256]) * block for i in range(size // block))
-
-
-def _external_uri_blob_array(uris):
-    blob_type = lancedb.blob("image").type
-    storage_type = blob_type.storage_type
-    child_names = [field.name for field in storage_type]
-    assert "uri" in child_names, "blob layout no longer has a uri child"
-    children = [
-        pa.array(uris if field.name == "uri" else [None] * len(uris), type=field.type)
-        for field in storage_type
-    ]
-    storage = pa.StructArray.from_arrays(children, fields=list(storage_type))
-    return pa.ExtensionArray.from_storage(blob_type, storage)
-
-
-def _external_uri_table_and_rows(name, uris):
-    db = lancedb.connect("memory:///")
-    schema = pa.schema([pa.field("id", pa.int64()), lancedb.blob("image")])
-    table = db.create_table(name, schema=schema)
-    rows = pa.Table.from_arrays(
-        [
-            pa.array(range(len(uris)), type=pa.int64()),
-            _external_uri_blob_array(uris),
-        ],
-        schema=schema,
-    )
-    return table, rows
-
-
-def test_add_external_uri_struct_round_trips_with_flag(tmp_path):
-    payload = b"external-uri-bytes"
-    blob_path = tmp_path / "payload.bin"
-    blob_path.write_bytes(payload)
-
-    table, rows = _external_uri_table_and_rows("external_struct", [blob_path.as_uri()])
-    table.add(rows, allow_external_blob_outside_bases=True)
-
-    hits = table.search().to_arrow()
-    blobs = table.fetch_blobs("image", hits)
-    assert blobs[0].as_py() == payload
-
-
-def test_add_external_uri_without_flag_raises(tmp_path):
-    blob_path = tmp_path / "payload.bin"
-    blob_path.write_bytes(b"unreachable")
-
-    table, rows = _external_uri_table_and_rows("external_no_flag", [blob_path.as_uri()])
-    with pytest.raises(ValueError, match="allow_external_blob_outside_bases"):
-        table.add(rows)
-    assert table.count_rows() == 0
-
-
-def test_add_external_uri_string_round_trips_with_flag(tmp_path):
-    payload = b"external-uri-bytes"
-    blob_path = tmp_path / "payload.bin"
-    blob_path.write_bytes(payload)
-
-    db = lancedb.connect("memory:///")
-    schema = pa.schema([pa.field("id", pa.int64()), lancedb.blob("image")])
-    table = db.create_table("external_string", schema=schema)
-    table.add(
-        [{"id": 1, "image": blob_path.as_uri()}],
-        allow_external_blob_outside_bases=True,
-    )
-
-    hits = table.search().to_arrow()
-    blobs = table.fetch_blobs("image", hits)
-    assert blobs[0].as_py() == payload
@@ -774,7 +774,7 @@ def test_drop_table_async(tmp_db: lancedb.DBConnection):
    job = tmp_db.drop_table_async("test")
    assert job.id is None
    assert job.status() == "finished"
-    assert job.wait() is None
+    job.wait()
    assert tmp_db.table_names() == []

    tmp_db.create_table("test", data=data)
@@ -790,7 +790,7 @@ async def test_drop_table_async_connection(tmp_db_async: lancedb.AsyncConnection
    job = await tmp_db_async.drop_table_async("test")
    assert job.id is None
    assert await job.status() == "finished"
-    assert await job.wait() is None
+    await job.wait()
    assert await tmp_db_async.table_names() == []


@@ -37,6 +37,21 @@ def job_result(name: str) -> dict:
    return json.loads(fixture(name))["result"]


+def assert_no_secret_values(value):
+    if isinstance(value, dict):
+        for key, child in value.items():
+            assert key not in {
+                "secret_value",
+                "secret_values",
+                "resolved_secret",
+                "resolved_secrets",
+            }
+            assert_no_secret_values(child)
+    elif isinstance(value, list):
+        for child in value:
+            assert_no_secret_values(child)
+
+
 def test_public_function_values_are_in_api_reference():
    docs = Path(__file__).parents[3] / "docs" / "src" / "python" / "python.md"
    rendered = docs.read_text()
@@ -94,6 +109,7 @@ def test_function_version_identity_is_immutable_and_exact():
    version = FunctionVersion.from_json(json.dumps(value))
    assert version.name == "embed"
    assert version.version == "fv_01K3EXACT"
+    assert version.required_secrets == ("HF_TOKEN",)

    with pytest.raises((TypeError, ValueError)):
        version.version = "fv_changed"
@@ -105,7 +121,7 @@ def test_function_version_identity_is_immutable_and_exact():
    assert FunctionVersion(**changed) != version


-def test_function_version_binds_named_columns_as_one_immutable_application():
+def test_function_version_binds_named_columns_as_one_immutable_group():
    version = FunctionVersion.from_json(
        json.dumps(job_result("remote_function_job.json"))
    )
@@ -115,10 +131,13 @@ def test_function_version_binds_named_columns_as_one_immutable_application():
    assert application.function.name == version.name
    assert application.function.version == version.version
    assert application.output is version.signature.output
+    assert application.group_id.startswith("fg_")
    assert [
        (value.parameter, value.kind, value.value["path"])
        for value in application.inputs
    ] == [("text", "column", "documents.body")]
+    with pytest.raises((TypeError, ValueError)):
+        application.group_id = "fg_changed"


 def test_function_version_binding_validates_names_and_direct_columns():
@@ -137,7 +156,7 @@ def test_function_version_binding_validates_names_and_direct_columns():
 def test_function_version_keeps_named_struct_outputs_in_one_application():
    value = job_result("remote_function_job.json")
    value["name"] = "text_features"
-    value["version"] = "fv_multi_output"
+    value["version"] = "fv_grouped"
    value["signature"] = {
        "inputs": [
            {"name": "title", "arrow_type": "utf8", "nullable": True},
@@ -202,6 +221,7 @@ def test_function_application_uses_rename_columns_only():
    assert application.columns["normalized_text"] == "search_text"
    assert renamed.columns["normalized_text"] == "body_normalized"
    assert renamed.function == application.function
+    assert renamed.group_id == application.group_id
    assert not hasattr(application, "rename_outputs")
    with pytest.raises(TypeError, match="immutable"):
        renamed.columns["normalized_text"] = "changed"
@@ -222,6 +242,7 @@ def test_function_application_uses_rename_columns_only():

 def test_binding_and_refresh_result_keep_stable_remote_fields():
    binding = FunctionBinding.from_json(fixture("remote_function_binding.json"))
+    assert binding.revision == 3
    assert binding.function.version == "fv_01K3TEXT"
    assert [output.output_ordinal for output in binding.outputs] == [0, 1]
    assert binding.input_schema is not None
@@ -276,6 +297,15 @@ def test_refresh_result_rejects_non_u64_values(field):
        RefreshColumnResult.from_json(json.dumps(value))


+def test_canonical_client_values_contain_secret_names_only():
+    version = FunctionVersion.from_json(
+        json.dumps(job_result("remote_function_job.json"))
+    )
+    canonical = json.loads(version.to_canonical_json())
+    assert canonical["required_secrets"] == ["HF_TOKEN"]
+    assert_no_secret_values(canonical)
+
+
 class _FunctionDeclarationInner:
    def __init__(self):
        self.calls = []
@@ -292,7 +322,7 @@ def known_application() -> FunctionApplication:


@pytest.mark.asyncio
-async def test_add_columns_routes_struct_as_one_and_multi_output_binding_atomically():
+async def test_add_columns_routes_struct_as_one_and_grouped_expansion_atomically():
    inner = _FunctionDeclarationInner()
    table = AsyncTable(inner)
    application = known_application()
@@ -313,12 +343,12 @@ async def test_add_columns_routes_struct_as_one_and_multi_output_binding_atomica


@pytest.mark.asyncio
-async def test_add_columns_rejects_multiple_bindings_and_unknown_newer_application():
+async def test_add_columns_rejects_mixed_groups_and_unknown_newer_application():
    inner = _FunctionDeclarationInner()
    table = AsyncTable(inner)
    application = known_application()

-    with pytest.raises(ValueError, match="exactly one Function binding"):
+    with pytest.raises(ValueError, match="exactly one Function sibling group"):
        await table.add_columns({"a": application, "b": application})

    future = json.loads(fixture("remote_function_application.json"))
@@ -346,6 +376,7 @@ def test_rename_requires_named_struct_and_keeps_partial_mapping_immutable():
                    "arrow_type": "list<float32>",
                    "nullable": False,
                },
+                "group_id": "fg_scalar",
            }
        )
    )
@@ -3,12 +3,7 @@

 from __future__ import annotations

-import base64
 import contextlib
-import functools
-import importlib.util
-import types
-from datetime import date
 import http.server
 import json
 from pathlib import Path
@@ -21,9 +16,6 @@ import pytest
 import lancedb
 from lancedb.functions import UdfDefinition, udf

-THRESHOLD = 20
-_CACHE = None
-

 FIXTURES = (
    Path(__file__).parents[3]
@@ -39,12 +31,28 @@ FIXTURES = (
@udf(
    pip=["numpy>=2"],
    env={"MODE": "test"},
+    secrets=["API_TOKEN"],
    python_version="3.12",
 )
 def normalize_score(value: float) -> float:
    return value / 100.0


+def _assert_no_secret_values(value):
+    if isinstance(value, dict):
+        for key, child in value.items():
+            assert key not in {
+                "secret_value",
+                "secret_values",
+                "resolved_secret",
+                "resolved_secrets",
+            }
+            _assert_no_secret_values(child)
+    elif isinstance(value, list):
+        for child in value:
+            _assert_no_secret_values(child)
+
+
 def test_scalar_udf_matches_shared_registration_golden_and_remains_callable():
    assert isinstance(normalize_score, UdfDefinition)
    assert normalize_score(25.0) == 0.25
@@ -59,397 +67,13 @@ def test_scalar_udf_matches_shared_registration_golden_and_remains_callable():
        "kind": "scalar_to_arrow_batch",
        "version": 1,
    }
-
-
-def _run_packaged(definition, *args):
-    """Execute the shipped artifact in a fresh namespace, as a worker would."""
-    source = base64.b64decode(definition.registration_request.artifact.content.data)
-    namespace: dict = {}
-    exec(compile(source, "<udf>", "exec"), namespace)
-    return namespace[definition.registration_request.artifact.entrypoint](*args)
-
-
-def test_udf_packages_attribute_access_and_body_imports():
-    @udf
-    def word_norm(body: str) -> float:
-        import numpy as np
-
-        try:
-            words = body.split()
-        except AttributeError as error:
-            raise ValueError(str(error)) from error
-        return float(np.linalg.norm([len(w) for w in words]))
-
-    assert _run_packaged(word_norm, "aa bb") == pytest.approx(8**0.5)
-
-
-def test_udf_packages_module_globals_and_global_caches():
-    @udf
-    def label(value: int) -> str:
-        return "big" if value >= THRESHOLD else "small"
-
-    assert _run_packaged(label, 21) == "big"
-
-    @udf
-    def cached(value: int) -> int:
-        global _CACHE
-        if _CACHE is None:
-            _CACHE = 40
-        return _CACHE + value
-
-    assert _run_packaged(cached, 2) == 42
-
-
-def test_udf_annotations_are_not_runtime_names():
-    @udf
-    def identity(value: date) -> date:
-        return value
-
-    assert _run_packaged(identity, date(2026, 8, 25)) == date(2026, 8, 25)
-
-
-def test_udf_nested_scopes_resolve_lexically():
-    @udf
-    def score(value: int) -> int:
-        offset = 2
-
-        def add_offset() -> int:
-            return value + offset
-
-        return add_offset() + sum(v for v in [0])
-
-    assert _run_packaged(score, 3) == 5
-
-
-def test_udf_resolves_module_globals_before_builtins(tmp_path):
-    module_path = tmp_path / "shadowing_udfs.py"
-    module_path.write_text(
-        "max = 7\n"
-        "len = lambda _: 99\n"
-        "\n"
-        "def uses_literal_shadow(value: int) -> int:\n"
-        "    def nested() -> int:\n"
-        "        return max\n"
-        "    return nested() + value\n"
-        "\n"
-        "def uses_callable_shadow(value: int) -> int:\n"
-        "    def nested() -> int:\n"
-        "        return len([1])\n"
-        "    return nested() + value\n"
-    )
-    spec = importlib.util.spec_from_file_location("shadowing_udfs", module_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-
-    # The module's `max = 7` is what the interpreter would use, so it ships.
-    assert _run_packaged(udf(module.uses_literal_shadow), 1) == 8
-    # A callable global cannot ship; it must not be silently swapped for the builtin.
-    with pytest.raises(TypeError, match="unsupported global value of type function"):
-        udf(module.uses_callable_shadow)
-
-
-def test_canonical_arrow_type_is_exactly_the_grammar():
-    from lancedb.functions import _GRAMMAR_PRIMITIVES, _canonical_arrow_type
-
-    golden = json.loads(
-        (
-            Path(__file__).parents[3]
-            / "rust/lancedb/tests/fixtures/first_class_functions/v1/arrow_types.json"
-        ).read_text()
-    )
-    primitives = [
-        case["arrow_type"] for case in golden["valid"] if "<" not in case["arrow_type"]
-    ]
-    assert [name for _, name in _GRAMMAR_PRIMITIVES] == primitives
-    for outside in [
-        pa.timestamp("us"),
-        pa.decimal128(10, 2),
-        pa.large_string(),
-        pa.large_binary(),
-        pa.binary(4),
-        pa.duration("s"),
-        pa.struct([pa.field("a", pa.int32())]),
-        pa.list_(pa.float32(), 0),
-        pa.list_(pa.timestamp("us")),
-    ]:
-        with pytest.raises(TypeError, match="unsupported Arrow type"):
-            _canonical_arrow_type(outside)
-
-
-def test_udf_nested_annotations_are_postponed_in_the_artifact():
-    @udf
-    def score(value: int) -> int:
-        def identity(item: date) -> date:
-            return item
-
-        identity(date(2026, 8, 25))
-        return value
-
-    assert _run_packaged(score, 3) == 3
-
-
-def test_udf_ships_globals_the_body_deletes():
-    @udf
-    def clear(value: int) -> int:
-        global _CACHE
-        del _CACHE
-        return value
-
-    assert _run_packaged(clear, 3) == 3
-
-
-def test_udf_rejects_a_module_global_that_does_not_import_as_itself(tmp_path):
-    module_path = tmp_path / "fake_module_udfs.py"
-    module_path.write_text(
-        "import types\n"
-        "np = types.ModuleType('numpy')\n"
-        "np.sqrt = lambda x: 0\n"
-        "\n"
-        "def score(value: int) -> int:\n"
-        "    return int(np.sqrt(value))\n"
-    )
-    spec = importlib.util.spec_from_file_location("fake_module_udfs", module_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    with pytest.raises(TypeError, match="does not import as 'numpy'"):
-        udf(module.score)
-
-
-def test_udf_rejects_a_module_level_namespace_alias(tmp_path):
-    module_path = tmp_path / "aliasing_udfs.py"
-    module_path.write_text(
-        "import builtins as b\n"
-        "THRESHOLD = 5\n"
-        "\n"
-        "def score(value: int) -> int:\n"
-        "    return value + b.vars(b.__import__('aliasing_udfs'))['THRESHOLD']\n"
-    )
-    spec = importlib.util.spec_from_file_location("aliasing_udfs", module_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    with pytest.raises(ValueError, match="dynamic namespace access"):
-        udf(module.score)
-
-
-@pytest.mark.parametrize(
-    "access",
-    [
-        "globals()['THRESHOLD']",
-        "eval('THRESHOLD')",
-        "(lambda g: g()['THRESHOLD'])(globals)",
-        "__import__('sys').modules[__name__].THRESHOLD",
-        "sys.modules[__name__].THRESHOLD",
-    ],
-)
-def test_udf_rejects_dynamic_namespace_access(access):
-    namespace: dict = {}
-    exec(
-        f"def score(value: int) -> int:\n    return value + {access}\n",
-        {"THRESHOLD": 5},
-        namespace,
-    )
-    with pytest.raises(ValueError, match="dynamic namespace access"):
-        _package_from_text(
-            "def score(value: int) -> int:\n"
-            "    import sys\n"
-            f"    return value + {access}\n"
-        )
-
-
-def _package_from_text(source: str, module_globals: dict | None = None):
-    """Load `source` as a real module file so the packager can inspect it."""
-    import tempfile
-
-    directory = tempfile.mkdtemp()
-    path = Path(directory) / "generated_udf_module.py"
-    path.write_text(source)
-    spec = importlib.util.spec_from_file_location(f"generated_udf_{id(source)}", path)
-    module = importlib.util.module_from_spec(spec)
-    if module_globals:
-        module.__dict__.update(module_globals)
-    spec.loader.exec_module(module)
-    functions = [
-        value
-        for value in vars(module).values()
-        if callable(value) and getattr(value, "__module__", None) == module.__name__
-    ]
-    return udf(functions[0])
-
-
-def test_udf_rejects_a_non_standard_builtins_environment():
-    def score(value: int) -> int:
-        return len([1]) + value
-
-    score.__globals__  # noqa: B018 -- real function, real globals
-    import builtins
-
-    patched = types.FunctionType(
-        score.__code__,
-        {"__builtins__": {**vars(builtins), "len": lambda _: 99}},
-        "score",
-    )
-    patched.__annotations__ = score.__annotations__
-    assert patched(3) == 102
-    with pytest.raises(ValueError, match="non-standard builtins environment"):
-        udf(patched)
-
-    class ReportingDict(dict):  # reports standard entries, resolves differently
-        def __missing__(self, key):
-            return vars(builtins)[key]
-
-    disguised = types.FunctionType(
-        score.__code__, {"__builtins__": ReportingDict(len=lambda _: 99)}, "score"
-    )
-    disguised.__annotations__ = score.__annotations__
-    assert disguised(3) == 102
-    with pytest.raises(ValueError, match="non-standard builtins environment"):
-        udf(disguised)
-
-    hooked = types.FunctionType(
-        score.__code__,
-        {"__builtins__": {**vars(builtins), "__import__": lambda *a, **k: None}},
-        "score",
-    )
-    hooked.__annotations__ = score.__annotations__
-    with pytest.raises(ValueError, match="non-standard builtins environment"):
-        udf(hooked)
-
-
-def test_udf_recursion_versus_a_rebound_module_name(tmp_path):
-    module_path = tmp_path / "rebound_udfs.py"
-    module_path.write_text(
-        "def fact(value: int) -> int:\n"
-        "    return 1 if value <= 1 else value * fact(value - 1)\n"
-        "\n"
-        "def score(value: int) -> int:\n"
-        "    return score + value\n"
-    )
-    spec = importlib.util.spec_from_file_location("rebound_udfs", module_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    assert _run_packaged(udf(module.fact), 5) == 120
-    raw = module.score
-    module.score = 10
-    with pytest.raises(ValueError, match="binds that name to another value"):
-        udf(raw)
-    # A wrapper that merely exposes __wrapped__ is not the function.
-    module.score = functools.wraps(raw)(lambda value: 41)
-    with pytest.raises(ValueError, match="binds that name to another value"):
-        udf(raw)
-    # The decorator's own result is; a subclass of it is not.
-    module.fact = udf(module.fact)
-    assert _run_packaged(module.fact, 4) == 24
-
-    class Twisted(UdfDefinition):
-        def __call__(self, *args, **kwargs):
-            return 41
-
-    raw_fact = module.fact._function
-    module.fact = Twisted(
-        raw_fact,
-        name=None,
-        input_schema=None,
-        output_schema=None,
-        pip=(),
-        env={},
-        python_version=None,
-    )
-    with pytest.raises(ValueError, match="binds that name to another value"):
-        udf(raw_fact)
-
-
-def test_canonical_arrow_type_rejects_unrepresentable_list_children():
-    from lancedb.functions import _canonical_arrow_type
-
-    for outside in [
-        pa.list_(pa.float32()),  # pyarrow default: nullable child
-        pa.list_(pa.field("custom", pa.float32(), nullable=False)),
-        pa.list_(pa.field("item", pa.float32(), nullable=False, metadata={"k": "v"})),
-        pa.list_(pa.field("item", pa.float32(), nullable=False), 0),
-    ]:
-        with pytest.raises(TypeError, match="unsupported Arrow type"):
-            _canonical_arrow_type(outside)
-    assert (
-        _canonical_arrow_type(
-            pa.list_(pa.field("item", pa.float32(), nullable=False), 3)
-        )
-        == "fixed_size_list<float32, 3>"
-    )
-
-
-def _calls_missing(value: int) -> int:
-    return missing(value)  # noqa: F821
-
-
-def _shadows_missing_in_a_comprehension(value: int) -> int:
-    return missing(value) + sum(missing for missing in ())  # noqa: F821
-
-
-def _shadows_missing_in_a_lambda(value: int) -> int:
-    return (lambda missing: missing)(value) + missing  # noqa: F821
-
-
-@pytest.mark.parametrize(
-    "function",
-    [_calls_missing, _shadows_missing_in_a_comprehension, _shadows_missing_in_a_lambda],
-)
-def test_udf_rejects_a_truly_unresolved_global(function):
-    with pytest.raises(ValueError, match=r"unresolved global names: \['missing'\]"):
-        udf(function)
-
-
-def _arrow_type_from_golden(spec: dict) -> pa.DataType:
-    kind = spec["type"]
-    if kind in ("list", "large_list", "fixed_size_list"):
-        item = _arrow_type_from_golden(spec["fields"][0]["type"])
-        field = pa.field("item", item, nullable=False)
-        if kind == "list":
-            return pa.list_(field)
-        if kind == "large_list":
-            return pa.large_list(field)
-        return pa.list_(field, spec["length"])
-    return {
-        "null": pa.null(),
-        "bool": pa.bool_(),
-        "utf8": pa.string(),
-        "binary": pa.binary(),
-        "float16": pa.float16(),
-        "float32": pa.float32(),
-        "float64": pa.float64(),
-        "date32": pa.date32(),
-        "date64": pa.date64(),
-    }.get(kind) or getattr(pa, kind)()
-
-
-def test_arrow_type_grammar_matches_the_shared_golden():
-    golden = json.loads(
-        (
-            Path(__file__).parents[3]
-            / "rust/lancedb/tests/fixtures/first_class_functions/v1/arrow_types.json"
-        ).read_text()
-    )
-    from lancedb.functions import _canonical_arrow_type
-
-    emitted = {
-        case["arrow_type"]: _canonical_arrow_type(_arrow_type_from_golden(case["json"]))
-        for case in golden["valid"]
-    }
-    assert emitted == {
-        case["arrow_type"]: case["arrow_type"] for case in golden["valid"]
-    }
-    assert not set(emitted) & set(golden["invalid"])
-    for case in golden["server_only"]:
-        with pytest.raises(TypeError, match="unsupported Arrow type"):
-            _canonical_arrow_type(_arrow_type_from_golden(case["json"]))
+    assert request["required_secrets"] == ["API_TOKEN"]
+    _assert_no_secret_values(request)


 def test_explicit_arrow_schema_is_deterministic():
    input_schema = pa.schema([pa.field("value", pa.float32(), nullable=True)])
-    output_schema = pa.field(
-        "embedding",
-        pa.list_(pa.field("item", pa.float32(), nullable=False), 3),
-        nullable=False,
-    )
+    output_schema = pa.field("embedding", pa.list_(pa.float32(), 3), nullable=False)

    @udf(input_schema=input_schema, output_schema=output_schema)
    def explicit(value):
@@ -458,7 +82,7 @@ def test_explicit_arrow_schema_is_deterministic():
    signature = explicit.registration_request.signature
    assert signature.inputs[0].arrow_type == "float32"
    assert signature.inputs[0].nullable is True
-    assert signature.output.arrow_type == "fixed_size_list<float32, 3>"
+    assert signature.output.arrow_type == "fixed_size_list<float32>[3]"
    assert signature.output.nullable is False


@@ -506,6 +130,14 @@ def test_annotation_and_explicit_schema_validation_fail_closed():
            return value


+def test_environment_rejects_secret_value_overlap():
+    with pytest.raises(ValueError, match="must be disjoint"):
+
+        @udf(env={"TOKEN": "plaintext"}, secrets=["TOKEN"])
+        def overlapping(value: int) -> int:
+            return value
+
+
 def test_local_function_catalog_operations_are_not_supported(tmp_path):
    db = lancedb.connect(tmp_path)
    message = "Function catalog operations are not supported by this database"
@@ -542,6 +174,7 @@ def _mock_remote_function_catalog():
                    "runtime": body["runtime"],
                    "runtime_digest": "sha256:runtime",
                    "environment_digest": "sha256:environment",
+                    "required_secrets": body.get("required_secrets", []),
                    "created_at": "2026-08-21T00:00:00Z",
                }
                response = {"job_id": "job-register"}
@@ -554,7 +187,7 @@ def _mock_remote_function_catalog():
                    "job_state": "DONE",
                    "result": state["version"],
                }
-            elif self.path == "/v1/functions/describe":
+            elif self.path == "/v1/functions/get":
                assert body == {
                    "name": "normalize_score",
                    "version": "fv_exact",
@@ -600,6 +233,7 @@ def test_remote_registration_job_and_exact_version_reopen_round_trip():
    assert create_request == json.loads(
        normalize_score.registration_request.to_canonical_json()
    )
+    _assert_no_secret_values(create_request)


 def test_blocking_remote_registration_returns_function_version():
@@ -88,7 +88,7 @@ async def binary_table(db_async):
 async def test_create_index_async_returns_done_job(some_table: AsyncTable):
    job = await some_table.create_index_async("id", config=BTree())
    assert job.id is None
-    assert await job.wait() is None
+    await job.wait()
    assert len(await some_table.list_indices()) == 1
    await job.cancel()

@@ -56,31 +56,6 @@ def test_execute_does_not_reenter_background_loop(tmp_path, monkeypatch):
    assert permutation_tbl._conn.read_consistency_interval is None


-def test_pickled_permutation_reads_pinned_version(tmp_path):
-    """An unpickled copy must still read the pinned version, which also covers the
-    version surviving the ``to_arrow()`` round trip in ``__getstate__``."""
-    import pickle
-
-    db = connect(tmp_path)
-    tbl = db.create_table("base", pa.table({"idx": range(20)}))
-    permutation_tbl = permutation_builder(tbl).execute()
-    perm = Permutation.from_tables(tbl, permutation_tbl)
-
-    payload = pickle.dumps(perm)
-
-    # Compact so the stored row addresses no longer describe these rows at latest.
-    tbl.delete("true")
-    tbl.optimize()
-    assert tbl.count_rows() == 0
-
-    # Unpickle after the mutation: __setstate__ reopens at latest, so this only
-    # passes if the recorded version is applied on reopen.
-    restored = pickle.loads(payload)
-    assert len(restored) == 20
-    rows = restored.__getitems__(list(range(20)))
-    assert sorted(row["idx"] for row in rows) == list(range(20))
-
-
 def test_split_random_counts(mem_db):
    """Test random splitting with absolute counts."""
    tbl = mem_db.create_table(
@@ -875,85 +875,11 @@ def test_remote_create_index_async_returns_job():
        table = db.create_table("test", [{"id": 1}])
        job = table.create_index_async("id", config=BTree())
        assert job.id == "job-1"
-        assert job.wait(timeout=timedelta(seconds=30)) is None
+        job.wait(timeout=timedelta(seconds=30))
        assert len(describe_calls) == 2
        job.cancel()


-def test_remote_refresh_async_returns_typed_terminal_result():
-    terminal_result = {
-        "rows_assigned": 12,
-        "rows_failed": 0,
-        "rows_remaining": 0,
-        "source_version": 7,
-        "published_version": 8,
-    }
-
-    def handler(request):
-        content_len = int(request.headers.get("Content-Length", 0))
-        body = request.rfile.read(content_len) if content_len > 0 else b""
-        if request.path == "/v1/table/test/backfill_column":
-            assert json.loads(body)["column"] == "derived"
-            request.send_response(202)
-            request.send_header("Content-Type", "application/json")
-            request.end_headers()
-            request.wfile.write(b'{"job_id": "refresh-1"}')
-        elif request.path == "/v1/jobs/describe":
-            assert json.loads(body)["job_id"] == "refresh-1"
-            request.send_response(200)
-            request.send_header("Content-Type", "application/json")
-            request.end_headers()
-            request.wfile.write(
-                json.dumps(
-                    {
-                        "job_id": "refresh-1",
-                        "job_type": "function_refresh",
-                        "job_state": "DONE",
-                        "result": terminal_result,
-                    }
-                ).encode()
-            )
-        elif request.path == "/v1/table/test/create/?mode=create":
-            request.send_response(200)
-            request.send_header("Content-Type", "application/json")
-            request.end_headers()
-            request.wfile.write(b"{}")
-        elif request.path == "/v1/table/test/describe/":
-            request.send_response(200)
-            request.send_header("Content-Type", "application/json")
-            request.end_headers()
-            request.wfile.write(
-                json.dumps(
-                    {
-                        "version": 1,
-                        "schema": {
-                            "fields": [
-                                {
-                                    "name": "id",
-                                    "type": {"type": "int64"},
-                                    "nullable": False,
-                                }
-                            ]
-                        },
-                    }
-                ).encode()
-            )
-        else:
-            request.send_response(404)
-            request.end_headers()
-
-    with mock_lancedb_connection(handler) as db:
-        table = db.create_table("test", [{"id": 1}])
-        job = table.refresh_column_async("derived")
-        assert job.id == "refresh-1"
-        result = job.wait(timeout=timedelta(seconds=30))
-
-    assert isinstance(result, lancedb.RefreshColumnResult)
-    assert result.model_dump() == terminal_result
-    assert result.rows_filled == 12
-    assert result.version == 8
-
-
 def test_remote_job_wait_raises_on_failure():
    from lancedb.exceptions import JobFailedError
    from lancedb.index import BTree
@@ -1467,7 +1467,7 @@ def test_create_index_async_returns_done_job(mem_db: DBConnection):
    table = mem_db.create_table("job_test", [{"id": i} for i in range(10)])
    job = table.create_index_async("id", config=BTree())
    assert job.id is None
-    assert job.wait() is None
+    job.wait()
    assert len(table.list_indices()) == 1
    job.cancel()

@@ -3947,21 +3947,10 @@ def test_refresh_column_async_returns_job(tmp_path):

    job = table.refresh_column_async("doubled")
    assert job.id is None  # in-process jobs have no server id
-    result = job.wait()
-    assert isinstance(result, lancedb.RefreshColumnResult)
-    assert result.rows_assigned == 2
-    assert result.rows_failed == 0
-    assert result.rows_remaining == 0
-    assert result.source_version == 2
-    assert result.published_version == 3
+    assert job.wait() is None
    assert job.status() == "finished"
    assert sorted(table.to_arrow()["doubled"].to_pylist()) == [2, 4]

-    no_op = table.refresh_column_async("doubled").wait()
-    assert no_op.rows_assigned == 0
-    assert no_op.source_version == 3
-    assert no_op.published_version is None
-
    # Bad input raises at the call, not through the job.
    with pytest.raises(Exception, match="not a computed column"):
        table.refresh_column_async("x")
@@ -3974,10 +3963,6 @@ async def test_refresh_column_async_job_async_table(tmp_path):
    await table.add_columns(computed={"tripled": "x * 3"})

    job = await table.refresh_column_async("tripled")
-    result = await job.wait()
-    assert isinstance(result, lancedb.RefreshColumnResult)
-    assert result.rows_assigned == 1
-    assert result.source_version == 2
-    assert result.published_version == 3
+    assert await job.wait() is None
    assert await job.status() == "finished"
    assert (await table.to_arrow())["tripled"].to_pylist() == [9]
@@ -609,7 +609,7 @@ impl Connection {
                .create_function_async(request)
                .await
                .infer_error()
-                .map(crate::job::Job::new_typed)
+                .map(crate::job::FunctionJob::new)
        })
    }

@@ -5,33 +5,72 @@ use std::sync::Arc;

 use crate::runtime::future_into_py;
 use pyo3::{Bound, PyAny, PyRef, PyResult, pyclass, pymethods};
-use serde::Serialize;

 use crate::error::PythonErrorExt;

 #[pyclass]
 pub struct Job {
-    inner: Arc<lancedb::Job<std::result::Result<Option<String>, String>>>,
+    inner: Arc<lancedb::Job>,
+}
+
+/// Python bridge for a typed remote Function registration job.
+///
+/// The public Python layer decodes the canonical JSON returned by `wait`
+/// into its immutable `FunctionVersion` model.
+#[pyclass]
+pub struct FunctionJob {
+    inner: Arc<lancedb::Job<lancedb::function::FunctionVersion>>,
+}
+
+impl FunctionJob {
+    pub(crate) fn new(inner: lancedb::Job<lancedb::function::FunctionVersion>) -> Self {
+        Self {
+            inner: Arc::new(inner),
+        }
+    }
 }

 impl Job {
    pub(crate) fn new(inner: lancedb::Job) -> Self {
        Self {
-            inner: Arc::new(inner.map(|()| Ok(None))),
+            inner: Arc::new(inner),
        }
    }
+}

-    pub(crate) fn new_typed<T>(inner: lancedb::Job<T>) -> Self
-    where
-        T: Clone + Serialize + Send + Sync + 'static,
-    {
-        Self {
-            inner: Arc::new(inner.map(|result| {
-                serde_json::to_string(&result)
-                    .map(Some)
-                    .map_err(|error| format!("failed to serialize typed job result: {error}"))
-            })),
-        }
+#[pymethods]
+impl FunctionJob {
+    #[getter]
+    pub fn id(&self) -> Option<String> {
+        self.inner.id().map(str::to_string)
+    }
+
+    pub fn status(self_: PyRef<'_, Self>) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.inner.clone();
+        future_into_py(
+            self_.py(),
+            async move { inner.status().await.infer_error() },
+        )
+    }
+
+    pub fn wait(self_: PyRef<'_, Self>) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.inner.clone();
+        future_into_py(self_.py(), async move {
+            inner
+                .wait()
+                .await
+                .infer_error()?
+                .to_canonical_json()
+                .infer_error()
+        })
+    }
+
+    pub fn cancel(self_: PyRef<'_, Self>) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.inner.clone();
+        future_into_py(self_.py(), async move {
+            inner.cancel().await.infer_error()?;
+            Ok(())
+        })
    }
 }

@@ -53,10 +92,8 @@ impl Job {
    pub fn wait(self_: PyRef<'_, Self>) -> PyResult<Bound<'_, PyAny>> {
        let inner = self_.inner.clone();
        future_into_py(self_.py(), async move {
-            let result = inner.wait().await.infer_error()?;
-            result
-                .map_err(|message| lancedb::Error::Runtime { message })
-                .infer_error()
+            inner.wait().await.infer_error()?;
+            Ok(None::<()>)
        })
    }

@@ -47,6 +47,7 @@ pub fn _lancedb(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_class::<Session>()?;
    m.add_class::<Table>()?;
    m.add_class::<crate::job::Job>()?;
+    m.add_class::<crate::job::FunctionJob>()?;
    m.add_class::<crate::job::JobInfo>()?;
    m.add_class::<crate::job::JobDescription>()?;
    m.add_class::<crate::job::JobFailureInfo>()?;
@@ -780,19 +780,15 @@ impl Table {
        })
    }

-    #[pyo3(signature = (data, mode, progress=None, write_parallelism=None, allow_external_blob_outside_bases=false))]
+    #[pyo3(signature = (data, mode, progress=None, write_parallelism=None))]
    pub fn add<'a>(
        self_: PyRef<'a, Self>,
        data: PyScannable,
        mode: String,
        progress: Option<Py<PyAny>>,
        write_parallelism: Option<usize>,
-        allow_external_blob_outside_bases: bool,
    ) -> PyResult<Bound<'a, PyAny>> {
-        let mut op = self_
-            .inner_ref()?
-            .add(data)
-            .allow_external_blob_outside_bases(allow_external_blob_outside_bases);
+        let mut op = self_.inner_ref()?.add(data);
        if mode == "append" {
            op = op.mode(AddDataMode::Append);
        } else if mode == "overwrite" {
@@ -1623,7 +1619,7 @@ impl Table {
        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_typed(job))
+            Ok(crate::job::Job::new(job))
        })
    }

@@ -1,6 +1,6 @@
 [package]
 name = "lancedb"
-version = "0.38.0-beta.10"
+version = "0.38.0-beta.4"
 edition.workspace = true
 description = "LanceDB: A serverless, low-latency vector database for AI applications"
 license.workspace = true
@@ -1679,50 +1679,6 @@ mod tests {
        assert_eq!(tables, names[..7]);
    }

-    #[tokio::test]
-    async fn test_list_tables_walks_page_boundaries() {
-        let tc = new_test_connection().await.unwrap();
-        if tc.is_remote {
-            // What resumes a page is the server's to decide, and asserting it here would be
-            // asserting the server's contract rather than this one.
-            return;
-        }
-        let db = tc.connection;
-        let schema = Arc::new(Schema::new(vec![Field::new("x", DataType::Int32, false)]));
-        let mut names = Vec::with_capacity(5);
-        for _ in 0..5 {
-            let name = uuid::Uuid::new_v4().to_string();
-            names.push(name.clone());
-            db.create_empty_table(name, schema.clone())
-                .execute()
-                .await
-                .unwrap();
-        }
-        names.sort();
-
-        // Walking in pages has to reach every table exactly once, with nothing lost at a
-        // page boundary.
-        let mut seen = Vec::with_capacity(names.len());
-        let mut page_token = None;
-        loop {
-            let page = db
-                .list_tables(ListTablesRequest {
-                    id: Some(Vec::new()),
-                    limit: Some(2),
-                    page_token,
-                    ..Default::default()
-                })
-                .await
-                .unwrap();
-            seen.extend(page.tables);
-            page_token = page.page_token.filter(|token| !token.is_empty());
-            if page_token.is_none() {
-                break;
-            }
-        }
-        assert_eq!(seen, names);
-    }
-
    #[tokio::test]
    async fn test_open_table() {
        let tc = new_test_connection().await.unwrap();
@@ -974,15 +974,17 @@ impl Database for ListingDatabase {
            f.drain(0..index);
        }

-        // Determine if there's a next page. The token is the last name of this page,
-        // not the first of the next one: the next page resumes strictly after the
-        // token, so naming the next page's first entry would skip it.
-        let next_page_token = match request.limit {
-            Some(limit) if f.len() > limit as usize => {
+        // Determine if there's a next page
+        let next_page_token = if let Some(limit) = request.limit {
+            if f.len() > limit as usize {
+                let token = f[limit as usize].clone();
                f.truncate(limit as usize);
-                f.last().cloned()
+                Some(token)
+            } else {
+                None
            }
-            _ => None,
+        } else {
+            None
        };

        Ok(ListTablesResponse {
@@ -27,12 +27,6 @@ pub const SRC_ROW_ID_COL: &str = "row_id";

 pub const SPLIT_NAMES_CONFIG_KEY: &str = "split_names";

-/// Base table version the permutation was built against.
-pub const BASE_VERSION_CONFIG_KEY: &str = "base_version";
-
-/// Base table branch the permutation was built against.  Absent means main.
-pub const BASE_BRANCH_CONFIG_KEY: &str = "base_branch";
-
 pub const DEFAULT_MEMORY_LIMIT: usize = 100 * 1024 * 1024;

 /// Where to store the permutation table
@@ -220,11 +214,21 @@ impl PermutationBuilder {
        Ok(Box::pin(SimpleRecordBatchStream { schema, stream }))
    }

-    fn add_config_metadata(
+    fn add_split_names(
        data: SendableRecordBatchStream,
-        metadata: HashMap<String, String>,
+        split_names: &[String],
    ) -> Result<SendableRecordBatchStream> {
-        let schema = data.schema().as_ref().clone().with_metadata(metadata);
+        let schema = data
+            .schema()
+            .as_ref()
+            .clone()
+            .with_metadata(HashMap::from([(
+                SPLIT_NAMES_CONFIG_KEY.to_string(),
+                serde_json::to_string(split_names).map_err(|e| Error::Other {
+                    message: format!("Failed to serialize split names: {}", e),
+                    source: Some(e.into()),
+                })?,
+            )]));
        let schema = Arc::new(schema);
        let schema_clone = schema.clone();
        let stream = data.map_ok(move |batch| batch.with_schema(schema.clone()).unwrap());
@@ -235,20 +239,7 @@ impl PermutationBuilder {
    }

    /// Builds the permutation table and stores it in the given database.
-    pub async fn build(mut self) -> Result<Table> {
-        // Remote tables resolve latest independently for each request. Use a
-        // separate pinned handle so count, projection, and scan all refer to one
-        // snapshot without changing the caller's table checkout state. Native
-        // tables return `None` here and retain their existing behavior.
-        if let Some(snapshot) = self
-            .base_table
-            .base_table()
-            .snapshot_at_current_version()
-            .await?
-        {
-            self.base_table = Table::from(snapshot);
-        }
-
+    pub async fn build(self) -> Result<Table> {
        // Unflushed rows have no row id, so a permutation cannot address them.
        match self.base_table.base_table().get_lsm_write_spec().await {
            Ok(Some(_)) => {
@@ -265,14 +256,9 @@ impl PermutationBuilder {
            Err(err) => return Err(err),
        }

-        // The handle above is already pinned to one version.  Record which one, so a
-        // reader -- in a DataLoader worker, against a table that has since moved --
-        // resolves these row addresses against the same snapshot.
-        let base_version = self.base_table.version().await?;
-        let base_branch = self.base_table.current_branch();
-
        // First pass, apply filter and load row ids.  `Shuffler` permutes positions, so
        // every rank must scan the rows in the same order to build the same permutation.
+        // TODO: pin the version resolved here; remote does not implement Lazy.
        let mut rows = self.base_table.query().select(Select::columns(&[ROW_ID]));

        if let Some(filter) = &self.config.filter {
@@ -332,24 +318,11 @@ impl PermutationBuilder {
        // Rename _rowid to row_id
        let renamed = rename_column(sorted, ROW_ID, SRC_ROW_ID_COL)?;

-        let mut metadata = HashMap::from([(
-            BASE_VERSION_CONFIG_KEY.to_string(),
-            base_version.to_string(),
-        )]);
-        // Version numbers are per-branch, so the branch is part of the coordinate.
-        if let Some(branch) = &base_branch {
-            metadata.insert(BASE_BRANCH_CONFIG_KEY.to_string(), branch.clone());
-        }
-        if let Some(split_names) = &self.config.split_names {
-            metadata.insert(
-                SPLIT_NAMES_CONFIG_KEY.to_string(),
-                serde_json::to_string(split_names).map_err(|e| Error::Other {
-                    message: format!("Failed to serialize split names: {}", e),
-                    source: Some(e.into()),
-                })?,
-            );
-        }
-        let streaming_data = Self::add_config_metadata(renamed, metadata)?;
+        let streaming_data = if let Some(split_names) = &self.config.split_names {
+            Self::add_split_names(renamed, split_names)?
+        } else {
+            renamed
+        };

        let (name, database) = match &self.config.destination {
            PermutationDestination::Permanent(database, table_name) => {
@@ -436,253 +409,6 @@ mod tests {
        assert!(table.base_table().scan_order_is_deterministic());
    }

-    #[cfg(feature = "remote")]
-    #[tokio::test]
-    async fn test_remote_permutation_builder_pins_snapshot() {
-        use std::sync::{
-            Mutex,
-            atomic::{AtomicU64, Ordering},
-        };
-
-        use arrow_array::{RecordBatch, UInt64Array};
-        use arrow_schema::{DataType, Field, Schema};
-
-        let row_ids = RecordBatch::try_new(
-            Arc::new(Schema::new(vec![Field::new(
-                ROW_ID,
-                DataType::UInt64,
-                false,
-            )])),
-            vec![Arc::new(UInt64Array::from(vec![100]))],
-        )
-        .unwrap();
-        let mut query_body = Vec::new();
-        {
-            let mut writer =
-                arrow_ipc::writer::FileWriter::try_new(&mut query_body, &row_ids.schema()).unwrap();
-            writer.write(&row_ids).unwrap();
-            writer.finish().unwrap();
-        }
-
-        let latest = Arc::new(AtomicU64::new(7));
-        let expected_snapshot = Arc::new(AtomicU64::new(7));
-        let planning_versions = Arc::new(Mutex::new(Vec::new()));
-        let latest_ref = latest.clone();
-        let expected_snapshot_ref = expected_snapshot.clone();
-        let planning_versions_ref = planning_versions.clone();
-        let table = Table::new_with_handler("remote_base", move |request| {
-            let path = request.url().path();
-            let body = request
-                .body()
-                .and_then(|body| body.as_bytes())
-                .map(|body| serde_json::from_slice::<serde_json::Value>(body).unwrap());
-
-            match path {
-                "/v1/table/remote_base/describe/" => {
-                    let requested = body.as_ref().and_then(|body| body["version"].as_u64());
-                    let version = requested.unwrap_or_else(|| latest_ref.load(Ordering::SeqCst));
-                    http::Response::builder()
-                        .status(200)
-                        .body(
-                            format!(r#"{{"version":{version},"schema":{{"fields":[]}}}}"#)
-                                .into_bytes(),
-                        )
-                        .unwrap()
-                }
-                "/v1/table/remote_base/get_lsm_write_spec/" => http::Response::builder()
-                    .status(200)
-                    .body(br#"{"lsm_write_spec":null}"#.to_vec())
-                    .unwrap(),
-                "/v1/table/remote_base/count_rows/" => {
-                    let body = body.unwrap();
-                    let version = body["version"].as_u64().unwrap();
-                    assert_eq!(version, expected_snapshot_ref.load(Ordering::SeqCst));
-                    assert_eq!(body["predicate"], "value > 0");
-                    planning_versions_ref.lock().unwrap().push(version);
-
-                    // Simulate a concurrent append after count_rows. An unpinned
-                    // scan would now resolve version 8 and include different rows.
-                    latest_ref.store(8, Ordering::SeqCst);
-                    http::Response::builder()
-                        .status(200)
-                        .body(b"1".to_vec())
-                        .unwrap()
-                }
-                "/v1/table/remote_base/query/" => {
-                    let body = body.unwrap();
-                    let version = body["version"].as_u64().unwrap();
-                    assert_eq!(version, expected_snapshot_ref.load(Ordering::SeqCst));
-                    assert_eq!(body["filter"], "value > 0");
-                    assert_eq!(body["columns"], serde_json::json!([ROW_ID]));
-                    planning_versions_ref.lock().unwrap().push(version);
-                    http::Response::builder()
-                        .status(200)
-                        .header("content-type", "application/vnd.apache.arrow.file")
-                        .body(query_body.clone())
-                        .unwrap()
-                }
-                _ => panic!("unexpected request: {path}"),
-            }
-        });
-
-        let permutation = PermutationBuilder::new(table.clone())
-            .with_filter("value > 0".to_string())
-            .build()
-            .await
-            .unwrap();
-        assert_eq!(permutation.count_rows(None).await.unwrap(), 1);
-
-        // Building uses a separate handle and must not pin the caller's table.
-        assert_eq!(table.version().await.unwrap(), 8);
-
-        // An explicit checkout is copied as-is and remains checked out afterward.
-        expected_snapshot.store(6, Ordering::SeqCst);
-        table.checkout(6).await.unwrap();
-        let permutation = PermutationBuilder::new(table.clone())
-            .with_filter("value > 0".to_string())
-            .build()
-            .await
-            .unwrap();
-        assert_eq!(permutation.count_rows(None).await.unwrap(), 1);
-        assert_eq!(table.version().await.unwrap(), 6);
-        assert_eq!(*planning_versions.lock().unwrap(), vec![7, 7, 6, 6]);
-    }
-
-    #[tokio::test]
-    async fn test_permutation_records_base_version() {
-        let temp_dir = tempfile::tempdir().unwrap();
-
-        let db = connect(temp_dir.path().to_str().unwrap())
-            .execute()
-            .await
-            .unwrap();
-
-        let initial_data = lance_datagen::gen_batch()
-            .col("col_a", lance_datagen::array::step::<Int32Type>())
-            .into_ldb_stream(RowCount::from(100), BatchCount::from(2));
-        let data_table = db
-            .create_table("base_tbl", initial_data)
-            .execute()
-            .await
-            .unwrap();
-
-        let build_version = data_table.version().await.unwrap();
-        let permutation_table = PermutationBuilder::new(data_table.clone())
-            .build()
-            .await
-            .unwrap();
-
-        let recorded = permutation_table
-            .schema()
-            .await
-            .unwrap()
-            .metadata
-            .get(BASE_VERSION_CONFIG_KEY)
-            .expect("permutation should record the base version")
-            .parse::<u64>()
-            .unwrap();
-        assert_eq!(recorded, build_version);
-
-        // Advancing the base table must not move the recorded version.
-        let more_data = lance_datagen::gen_batch()
-            .col("col_a", lance_datagen::array::step::<Int32Type>())
-            .into_ldb_stream(RowCount::from(50), BatchCount::from(1));
-        data_table.add(more_data).execute().await.unwrap();
-        assert!(data_table.version().await.unwrap() > recorded);
-        assert_eq!(
-            permutation_table
-                .schema()
-                .await
-                .unwrap()
-                .metadata
-                .get(BASE_VERSION_CONFIG_KEY)
-                .unwrap()
-                .parse::<u64>()
-                .unwrap(),
-            recorded,
-        );
-    }
-
-    /// Version numbers are per-branch, so a permutation built on a branch must record
-    /// it -- a worker reopens by name and lands on main at the same number.
-    #[tokio::test]
-    async fn test_permutation_records_base_branch() {
-        let temp_dir = tempfile::tempdir().unwrap();
-        let db = connect(temp_dir.path().to_str().unwrap())
-            .execute()
-            .await
-            .unwrap();
-
-        let initial_data = lance_datagen::gen_batch()
-            .col("col_a", lance_datagen::array::step::<Int32Type>())
-            .into_ldb_stream(RowCount::from(10), BatchCount::from(1));
-        let data_table = db
-            .create_table("base_tbl", initial_data)
-            .execute()
-            .await
-            .unwrap();
-
-        let branch = data_table
-            .create_branch("exp", lance::dataset::refs::Ref::from(("main", 1)))
-            .await
-            .unwrap();
-        let permutation_table = PermutationBuilder::new(branch.clone())
-            .build()
-            .await
-            .unwrap();
-
-        let metadata = permutation_table.schema().await.unwrap().metadata.clone();
-        assert_eq!(
-            metadata.get(BASE_BRANCH_CONFIG_KEY).map(String::as_str),
-            Some("exp")
-        );
-
-        // Main records nothing, so an absent key keeps meaning main.
-        let main_permutation = PermutationBuilder::new(data_table.clone())
-            .build()
-            .await
-            .unwrap();
-        assert!(
-            !main_permutation
-                .schema()
-                .await
-                .unwrap()
-                .metadata
-                .contains_key(BASE_BRANCH_CONFIG_KEY)
-        );
-    }
-
-    #[tokio::test]
-    async fn test_build_does_not_pin_the_callers_table() {
-        let temp_dir = tempfile::tempdir().unwrap();
-
-        let db = connect(temp_dir.path().to_str().unwrap())
-            .execute()
-            .await
-            .unwrap();
-
-        let initial_data = lance_datagen::gen_batch()
-            .col("col_a", lance_datagen::array::step::<Int32Type>())
-            .into_ldb_stream(RowCount::from(100), BatchCount::from(1));
-        let data_table = db
-            .create_table("base_tbl", initial_data)
-            .execute()
-            .await
-            .unwrap();
-
-        PermutationBuilder::new(data_table.clone())
-            .build()
-            .await
-            .unwrap();
-
-        // The builder pins its own handle; the caller's must still track latest.
-        let more_data = lance_datagen::gen_batch()
-            .col("col_a", lance_datagen::array::step::<Int32Type>())
-            .into_ldb_stream(RowCount::from(50), BatchCount::from(1));
-        data_table.add(more_data).execute().await.unwrap();
-        assert_eq!(data_table.count_rows(None).await.unwrap(), 150);
-    }
-
    #[tokio::test]
    async fn test_permutation_builder() {
        let temp_dir = tempfile::tempdir().unwrap();
@@ -8,9 +8,7 @@
 //! the rows from a source table that correspond to row IDs stored in a separate table.

 use crate::arrow::{SendableRecordBatchStream, SimpleRecordBatchStream};
-use crate::dataloader::permutation::builder::{
-    BASE_BRANCH_CONFIG_KEY, BASE_VERSION_CONFIG_KEY, SRC_ROW_ID_COL,
-};
+use crate::dataloader::permutation::builder::SRC_ROW_ID_COL;
 use crate::dataloader::permutation::split::SPLIT_ID_COLUMN;
 use crate::error::Error;
 use crate::query::{
@@ -25,7 +23,6 @@ use arrow_array::{RecordBatch, UInt64Array};
 use arrow_schema::SchemaRef;
 use datafusion_expr::{Expr, col, lit};
 use futures::{StreamExt, TryStreamExt};
-use lance::dataset::refs::MAIN_BRANCH;
 use lance::dataset::scanner::DatasetRecordBatchStream;
 use lance::io::RecordBatchStream;
 use lance_arrow::RecordBatchExt;
@@ -72,10 +69,6 @@ impl PermutationReader {
        permutation_table: Option<Arc<dyn BaseTable>>,
        split: u64,
    ) -> Result<Self> {
-        let base_table = match &permutation_table {
-            Some(permutation_table) => Self::pin_base_table(base_table, permutation_table).await?,
-            None => base_table,
-        };
        let mut slf = Self {
            base_table,
            permutation_table,
@@ -96,34 +89,6 @@ impl PermutationReader {
        Ok(slf)
    }

-    /// Pins the base table to the version the permutation was built against.
-    /// Permutations written before that was recorded carry no key and stay unpinned.
-    async fn pin_base_table(
-        base_table: Arc<dyn BaseTable>,
-        permutation_table: &Arc<dyn BaseTable>,
-    ) -> Result<Arc<dyn BaseTable>> {
-        let schema = permutation_table.schema().await?;
-        let Some(raw) = schema.metadata.get(BASE_VERSION_CONFIG_KEY) else {
-            return Ok(base_table);
-        };
-        let version = raw.parse::<u64>().map_err(|e| Error::InvalidInput {
-            message: format!(
-                "Permutation table has an unreadable {} of {:?}: {}",
-                BASE_VERSION_CONFIG_KEY, raw, e
-            ),
-        })?;
-        // The recorded branch, not the handle's: a worker reopens by name and lands
-        // on main, and version numbers are per-branch.
-        let branch = schema
-            .metadata
-            .get(BASE_BRANCH_CONFIG_KEY)
-            .map(String::as_str)
-            .unwrap_or(MAIN_BRANCH);
-        base_table
-            .checkout_branch_version(branch, Some(version))
-            .await
-    }
-
    pub async fn try_from_tables(
        base_table: Arc<dyn BaseTable>,
        permutation_table: Arc<dyn BaseTable>,
@@ -546,13 +511,9 @@ mod tests {
    use lance_datagen::{BatchCount, RowCount};
    use rand::seq::SliceRandom;

-    // Aliased: `test_utils::datagen` exports a trait of the same name.
-    use crate::arrow::LanceDbDatagenExt as _;
    use crate::{
        Table,
        arrow::SendableRecordBatchStream,
-        connect,
-        dataloader::permutation::builder::PermutationBuilder,
        query::{ExecutableQuery, QueryBase},
        test_utils::datagen::{LanceDbDatagenExt, virtual_table},
    };
@@ -584,58 +545,6 @@ mod tests {
        .await
    }

-    /// Compaction moves row addresses, so the reader must read the pinned version.
-    #[tokio::test]
-    async fn test_reader_pins_base_version() {
-        let temp_dir = tempfile::tempdir().unwrap();
-        let db = connect(temp_dir.path().to_str().unwrap())
-            .execute()
-            .await
-            .unwrap();
-
-        let data = lance_datagen::gen_batch()
-            .col("idx", lance_datagen::array::step::<Int32Type>())
-            .into_ldb_stream(RowCount::from(20), BatchCount::from(1));
-        let base_table = db.create_table("base_tbl", data).execute().await.unwrap();
-
-        let permutation_table = PermutationBuilder::new(base_table.clone())
-            .build()
-            .await
-            .unwrap();
-
-        base_table.delete("true").await.unwrap();
-        base_table
-            .optimize(crate::table::OptimizeAction::All)
-            .await
-            .unwrap();
-        assert_eq!(base_table.count_rows(None).await.unwrap(), 0);
-
-        let reader = PermutationReader::try_from_tables(
-            base_table.base_table().clone(),
-            permutation_table.base_table().clone(),
-            0,
-        )
-        .await
-        .unwrap();
-
-        let values = collect_from_stream::<Int32Type>(
-            reader
-                .read(
-                    Select::Columns(vec!["idx".to_string()]),
-                    QueryExecutionOptions::default(),
-                )
-                .await
-                .unwrap(),
-            "idx",
-        )
-        .await;
-        assert_eq!(
-            values.len(),
-            20,
-            "reader should still see the pinned version"
-        );
-    }
-
    #[tokio::test]
    async fn test_permutation_reader() {
        let base_table = lance_datagen::gen_batch()
@@ -1,11 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright The LanceDB Authors

-//! Canonical Function values exchanged with the Enterprise service, plus the
-//! backend-neutral terminal result of a computed-column refresh.
+//! Canonical values exchanged with the Enterprise Function service.
 //!
 //! This module contains client/wire values only. Catalog persistence,
-//! environment bake, and execution are owned by Sophon.
+//! environment bake, secret resolution, and execution are owned by Sophon.

 use std::collections::BTreeMap;

@@ -195,6 +194,9 @@ pub struct PythonEnvironmentSpec {
 }

 /// Reproducible Python runtime definition understood by Sophon.
+///
+/// `env` contains non-secret values. Secret values have no client model;
+/// [`FunctionVersion::required_secrets`] contains names only.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum PythonRuntimeSpec {
@@ -236,7 +238,7 @@ impl PythonRuntimeSpec {
        }
    }

-    /// Environment variables, or `None` for an unknown kind.
+    /// Non-secret environment variables, or `None` for an unknown kind.
    pub fn env(&self) -> Option<&BTreeMap<String, String>> {
        match self {
            Self::Python { env, .. } => Some(env),
@@ -321,6 +323,8 @@ pub struct FunctionVersion {
    runtime: PythonRuntimeSpec,
    runtime_digest: String,
    environment_digest: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    required_secrets: Vec<String>,
    created_at: String,
 }

@@ -353,6 +357,11 @@ impl FunctionVersion {
        &self.environment_digest
    }

+    /// Required secret names. Resolved values exist only inside Sophon.
+    pub fn required_secrets(&self) -> &[String] {
+        &self.required_secrets
+    }
+
    pub fn created_at(&self) -> &str {
        &self.created_at
    }
@@ -394,12 +403,18 @@ pub struct FunctionArtifactRequest {
 }

 /// Stable request envelope for remote immutable Function registration.
+///
+/// Secret values deliberately have no field in this model. The only secret
+/// material the client may send is the ordered set of names Sophon resolves
+/// inside the remote runtime.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct FunctionRegistrationRequest {
    pub name: String,
    pub artifact: FunctionArtifactRequest,
    pub signature: FunctionSignature,
    pub runtime: PythonRuntimeSpec,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub required_secrets: Vec<String>,
 }

 impl_json!(FunctionRegistrationRequest);
@@ -430,6 +445,7 @@ pub struct FunctionApplication {
    function: FunctionVersionRef,
    inputs: Vec<ApplicationInput>,
    output: FunctionOutput,
+    group_id: String,
    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
    columns: BTreeMap<String, String>,
    #[serde(default, flatten, skip_serializing)]
@@ -451,6 +467,10 @@ impl FunctionApplication {
        &self.output
    }

+    pub fn group_id(&self) -> &str {
+        &self.group_id
+    }
+
    pub fn columns(&self) -> &BTreeMap<String, String> {
        &self.columns
    }
@@ -492,7 +512,7 @@ pub struct InputBinding {
    pub nullable: bool,
 }

-/// Ordered result-field to table-field mapping for a Function binding.
+/// Ordered result-field to table-field mapping for a grouped binding.
 ///
 /// Assignment state is not part of the Slice 1 client contract. During the
 /// NULL transition there is no public Lance cell-flag identifier to persist.
@@ -506,18 +526,20 @@ pub struct OutputMapping {
    pub nullable: bool,
 }

-/// Immutable Function binding persisted by the Enterprise table service.
+/// Immutable grouped binding persisted by the Enterprise table service.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct FunctionBinding {
    binding_id: String,
+    revision: u64,
    function: FunctionVersionRef,
+    group_id: String,
    inputs: Vec<InputBinding>,
    outputs: Vec<OutputMapping>,
    /// Exact Arrow schema presented to the Function, encoded with the Lance
    /// Namespace Arrow JSON representation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    input_schema: Option<Value>,
-    /// Exact physical Arrow schema of the binding's table outputs.
+    /// Exact physical Arrow schema of the grouped table outputs.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    output_schema: Option<Value>,
 }
@@ -527,10 +549,18 @@ impl FunctionBinding {
        &self.binding_id
    }

+    pub fn revision(&self) -> u64 {
+        self.revision
+    }
+
    pub fn function(&self) -> &FunctionVersionRef {
        &self.function
    }

+    pub fn group_id(&self) -> &str {
+        &self.group_id
+    }
+
    pub fn inputs(&self) -> &[InputBinding] {
        &self.inputs
    }
@@ -550,22 +580,13 @@ impl FunctionBinding {

 impl_json!(FunctionBinding);

-/// Stable terminal result of an expression-backed or Function-backed column
-/// refresh [`crate::Job`].
-///
-/// Local refresh jobs produce this value in process. LanceDB Cloud and
-/// Enterprise decode the same value from the durable job's terminal payload.
+/// Stable terminal result of a remote Function-column refresh Job.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct RefreshColumnResult {
-    /// Rows assigned a value by this refresh.
    pub rows_assigned: u64,
-    /// Rows whose computation failed.
    pub rows_failed: u64,
-    /// Rows that still need a value when the job completes.
    pub rows_remaining: u64,
-    /// Exact table version the refresh read.
    pub source_version: u64,
-    /// Table version made visible by the refresh, when one was published.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published_version: Option<u64>,
 }
@@ -10,7 +10,7 @@ use lance::io::WrappingObjectStore;
 use object_store::{
    CopyOptions, Error, GetOptions, GetResult, ListResult, MultipartUpload, ObjectMeta,
    ObjectStore, ObjectStoreExt, PutMultipartOptions, PutOptions, PutPayload, PutResult, Result,
-    UploadPart, list::PaginatedListStore, path::Path,
+    UploadPart, path::Path,
 };

 use async_trait::async_trait;
@@ -187,14 +187,6 @@ impl WrappingObjectStore for MirroringObjectStoreWrapper {
            secondary: self.secondary.clone(),
        })
    }
-
-    fn wrap_paginated(
-        &self,
-        _store_prefix: &str,
-        original: Arc<dyn PaginatedListStore>,
-    ) -> Option<Arc<dyn PaginatedListStore>> {
-        Some(original)
-    }
 }

 // windows pathing can't be simply concatenated
@@ -12,7 +12,7 @@ use lance::io::WrappingObjectStore;
 use object_store::{
    CopyOptions, GetOptions, GetResult, ListResult, MultipartUpload, ObjectMeta, ObjectStore,
    PutMultipartOptions, PutOptions, PutPayload, PutResult, RenameOptions, Result as OSResult,
-    UploadPart, list::PaginatedListStore, path::Path,
+    UploadPart, path::Path,
 };

 #[derive(Debug, Default)]
@@ -57,14 +57,6 @@ impl WrappingObjectStore for IoStatsHolder {
            stats: self.0.clone(),
        })
    }
-
-    fn wrap_paginated(
-        &self,
-        _store_prefix: &str,
-        original: Arc<dyn PaginatedListStore>,
-    ) -> Option<Arc<dyn PaginatedListStore>> {
-        Some(original)
-    }
 }

 impl IoTrackingStore {
@@ -6,7 +6,7 @@
 use std::sync::Arc;

 use async_trait::async_trait;
-use serde::{Serialize, de::DeserializeOwned};
+use serde::de::DeserializeOwned;
 use serde_json::Value;
 use tokio::sync::watch;
 use tokio::task::{AbortHandle, JoinHandle};
@@ -26,16 +26,20 @@ pub(crate) trait JobHandle: Send + Sync {
 }

 /// A backend-neutral successful terminal result.
-#[derive(Clone)]
+///
+/// Local operations do not carry a value. Remote operations may carry JSON
+/// that the public [`Job`] decodes according to its result type.
 pub(crate) struct TerminalResult {
+    #[allow(dead_code)] // Typed remote submit endpoints consume this after Slice 1.
    value: Option<Value>,
+    #[allow(dead_code)] // Preserved so typed decode errors retain request correlation.
    request_id: Option<String>,
 }

 impl TerminalResult {
-    fn local(value: Value) -> Self {
+    pub(crate) fn local() -> Self {
        Self {
-            value: Some(value),
+            value: None,
            request_id: None,
        }
    }
@@ -47,31 +51,23 @@ impl TerminalResult {
        }
    }

+    #[allow(dead_code)] // Exercised by the remote typed-result fixtures in Slice 1.
    fn decode<T: DeserializeOwned>(self) -> Result<T> {
-        let value = self.value.ok_or_else(|| match &self.request_id {
-            Some(request_id) => Error::Http {
-                source: "successful typed job response did not contain a result".into(),
-                request_id: request_id.clone(),
-                status_code: None,
-            },
-            None => Error::Runtime {
-                message: "successful typed job did not contain a result".to_string(),
-            },
+        let request_id = self.request_id.unwrap_or_default();
+        let value = self.value.ok_or_else(|| Error::Http {
+            source: "successful typed job response did not contain a result".into(),
+            request_id: request_id.clone(),
+            status_code: None,
        })?;
-        serde_json::from_value(value).map_err(|error| match self.request_id {
-            Some(request_id) => Error::Http {
-                source: format!("failed to parse typed job result: {error}").into(),
-                request_id,
-                status_code: None,
-            },
-            None => Error::Runtime {
-                message: format!("failed to parse typed job result: {error}"),
-            },
+        serde_json::from_value(value).map_err(|error| Error::Http {
+            source: format!("failed to parse typed job result: {error}").into(),
+            request_id,
+            status_code: None,
        })
    }
 }

-type ResultDecoder<T> = Arc<dyn Fn(TerminalResult) -> Result<T> + Send + Sync>;
+type ResultDecoder<T> = fn(TerminalResult) -> Result<T>;

 enum JobInner<T> {
    Handle {
@@ -83,9 +79,7 @@ enum JobInner<T> {

 /// A handle to an operation that may still be running.
 ///
-/// The operation may already be complete when the handle is created. `T` is
-/// the endpoint's successful terminal result; unit-result operations use the
-/// default `Job<()>`.
+/// The operation may already be complete when the handle is created.
 pub struct Job<T = ()>
 where
    T: Clone + Send + Sync + 'static,
@@ -117,10 +111,15 @@ impl Job<()> {
        Self {
            inner: JobInner::Handle {
                handle,
-                decode: Arc::new(|_| Ok(())),
+                decode: |_| Ok(()),
            },
        }
    }
+
+    /// A unit-result job running as a task in this process.
+    pub(crate) fn spawned(task: JoinHandle<Result<()>>) -> Self {
+        Self::new(Box::new(SpawnedJob::new(task)))
+    }
 }

 impl<T> Job<T>
@@ -132,22 +131,12 @@ where
        Self {
            inner: JobInner::Handle {
                handle,
-                decode: Arc::new(TerminalResult::decode::<T>),
+                decode: TerminalResult::decode::<T>,
            },
        }
    }
 }

-impl<T> Job<T>
-where
-    T: Clone + Serialize + DeserializeOwned + Send + Sync + 'static,
-{
-    /// A typed job running as a task in this process.
-    pub(crate) fn spawned(task: JoinHandle<Result<T>>) -> Self {
-        Self::new_typed(Box::new(SpawnedJob::new(task)))
-    }
-}
-
 impl<T> Job<T>
 where
    T: Clone + Send + Sync + 'static,
@@ -180,13 +169,11 @@ where

    /// Waits until the operation reaches a terminal state.
    ///
-    /// Returns the endpoint's typed result. Unit-result jobs return `()`.
-    ///
    /// Returns [`crate::Error::JobFailed`] if the operation failed and
    /// [`crate::Error::JobCancelled`] if it was cancelled.
    pub async fn wait(&self) -> Result<T> {
        match &self.inner {
-            JobInner::Handle { handle, decode } => (decode)(handle.wait().await?),
+            JobInner::Handle { handle, decode } => decode(handle.wait().await?),
            JobInner::Completed(result) => Ok(result.clone()),
        }
    }
@@ -200,53 +187,21 @@ where
            JobInner::Completed(_) => Ok(()),
        }
    }
-
-    /// Maps a successful terminal result without changing the job lifecycle.
-    /// The mapping may run once for each call to [`Job::wait`], so it should
-    /// be deterministic and free of externally visible side effects.
-    ///
-    /// ```
-    /// use lancedb::{Job, function::RefreshColumnResult};
-    ///
-    /// # async fn rows_assigned(
-    /// #     job: Job<RefreshColumnResult>,
-    /// # ) -> lancedb::Result<u64> {
-    /// let job = job.map(|result| result.rows_assigned);
-    /// job.wait().await
-    /// # }
-    /// ```
-    pub fn map<U, F>(self, map: F) -> Job<U>
-    where
-        U: Clone + Send + Sync + 'static,
-        F: Fn(T) -> U + Send + Sync + 'static,
-    {
-        match self.inner {
-            JobInner::Handle { handle, decode } => Job {
-                inner: JobInner::Handle {
-                    handle,
-                    decode: Arc::new(move |result| Ok(map((decode)(result)?))),
-                },
-            },
-            JobInner::Completed(result) => Job {
-                inner: JobInner::Completed(map(result)),
-            },
-        }
-    }
 }

 /// How an in-process operation ended. Cloneable so every waiter can be given
 /// the outcome; [`Error`] is not, so failures share one behind an [`Arc`].
 #[derive(Clone)]
 enum Outcome {
-    Succeeded(TerminalResult),
+    Succeeded,
    Failed(Arc<Error>),
    Cancelled,
 }

 impl Outcome {
-    fn into_result(self) -> Result<TerminalResult> {
+    fn into_result(self) -> Result<()> {
        match self {
-            Self::Succeeded(result) => Ok(result),
+            Self::Succeeded => Ok(()),
            Self::Failed(source) => Err(Error::JobFailed {
                job_id: None,
                failure: JobFailure::from_source(source),
@@ -265,20 +220,12 @@ struct SpawnedJob {
 }

 impl SpawnedJob {
-    fn new<T>(task: JoinHandle<Result<T>>) -> Self
-    where
-        T: Serialize + Send + 'static,
-    {
+    fn new(task: JoinHandle<Result<()>>) -> Self {
        let abort = task.abort_handle();
        let (tx, outcome) = watch::channel(None);
        tokio::spawn(async move {
            let outcome = match task.await {
-                Ok(Ok(result)) => match serde_json::to_value(result) {
-                    Ok(value) => Outcome::Succeeded(TerminalResult::local(value)),
-                    Err(err) => Outcome::Failed(Arc::new(Error::Runtime {
-                        message: format!("failed to serialize job result: {err}"),
-                    })),
-                },
+                Ok(Ok(())) => Outcome::Succeeded,
                Ok(Err(err)) => Outcome::Failed(Arc::new(err)),
                Err(err) if err.is_cancelled() => Outcome::Cancelled,
                Err(err) => Outcome::Failed(Arc::new(Error::Runtime {
@@ -296,7 +243,7 @@ impl JobHandle for SpawnedJob {
    async fn status(&self) -> Result<String> {
        let label = match &*self.outcome.borrow() {
            None => "running",
-            Some(Outcome::Succeeded(_)) => "finished",
+            Some(Outcome::Succeeded) => "finished",
            Some(Outcome::Failed(_)) => "failed",
            Some(Outcome::Cancelled) => "cancelled",
        };
@@ -309,11 +256,12 @@ impl JobHandle for SpawnedJob {
            .wait_for(|outcome| outcome.is_some())
            .await
            .map_err(|_| Error::Runtime {
-                message: "job outcome was dropped before it completed".to_string(),
+                message: "index job outcome was dropped before it completed".to_string(),
            })?
            .clone()
            .expect("wait_for returns once an outcome is set");
-        settled.into_result()
+        settled.into_result()?;
+        Ok(TerminalResult::local())
    }

    async fn cancel(&self) -> Result<()> {
@@ -321,29 +269,3 @@ impl JobHandle for SpawnedJob {
        Ok(())
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use std::future::pending;
-
-    use super::*;
-
-    #[tokio::test]
-    async fn mapped_spawned_job_reuses_outcome() {
-        let job = Job::spawned(tokio::spawn(async { Ok(41_u64) })).map(|value| value + 1);
-
-        assert_eq!(job.wait().await.unwrap(), 42);
-        assert_eq!(job.wait().await.unwrap(), 42);
-        assert_eq!(job.status().await.unwrap(), "finished");
-    }
-
-    #[tokio::test]
-    async fn mapped_spawned_job_preserves_cancellation() {
-        let job = Job::spawned(tokio::spawn(async { pending::<Result<u64>>().await }))
-            .map(|value| value.to_string());
-
-        job.cancel().await.unwrap();
-        assert!(matches!(job.wait().await, Err(Error::JobCancelled { .. })));
-        assert_eq!(job.status().await.unwrap(), "cancelled");
-    }
-}
@@ -37,13 +37,6 @@ pub use refresh::{RefreshMaterializedViewResult, RefreshMode};
 /// Schema metadata key holding the view definition, as kind-tagged JSON.
 pub const DEFINITION_META_KEY: &str = "mv.definition";

-/// Schema metadata key holding the view's incarnation: a token minted at each
-/// physical creation of a view table, so a view dropped and recreated under
-/// the same name and definition is still told apart from the one a caller
-/// captured. A view whose metadata was replaced wholesale, or one declared
-/// before tokens existed, carries none until its next refresh mints one.
-pub const INCARNATION_META_KEY: &str = "mv.incarnation";
-
 /// Schema metadata key holding the source table version the view was last
 /// refreshed to. Absent until the first refresh.
 pub const SOURCE_VERSION_META_KEY: &str = "mv.source_version";
@@ -619,17 +612,8 @@ impl PreparedDeclaration {
    pub async fn create(self, name: &str) -> Result<MaterializedView> {
        let empty: Vec<std::result::Result<arrow_array::RecordBatch, arrow_schema::ArrowError>> =
            vec![];
-        // Minted here, not at preparation: a declaration can be cloned and
-        // create more than one physical table, and each needs its own token.
-        let incarnation = uuid::Uuid::new_v4().to_string();
-        let mut metadata = self.schema.metadata().clone();
-        metadata.insert(INCARNATION_META_KEY.to_string(), incarnation.clone());
-        let schema = Arc::new(ArrowSchema::new_with_metadata(
-            self.schema.fields().clone(),
-            metadata,
-        ));
        let reader: Box<dyn arrow_array::RecordBatchReader + Send> =
-            Box::new(arrow_array::RecordBatchIterator::new(empty, schema));
+            Box::new(arrow_array::RecordBatchIterator::new(empty, self.schema));
        let mut request = CreateTableRequest::new(name.to_string(), Box::new(reader));
        let write_params = request
            .write_options
@@ -664,7 +648,6 @@ impl PreparedDeclaration {
        Ok(MaterializedView {
            table,
            definition: self.definition,
-            incarnation: Some(incarnation),
        })
    }
 }
@@ -895,7 +878,6 @@ impl CreateMaterializedViewBuilder {
 pub struct MaterializedView {
    table: Table,
    definition: MaterializedViewDefinition,
-    incarnation: Option<String>,
 }

 impl MaterializedView {
@@ -911,13 +893,8 @@ impl MaterializedView {
            });
        }
        let schema = table.schema().await?;
-        let incarnation = schema.metadata().get(INCARNATION_META_KEY).cloned();
        match materialized_view_kind(schema.metadata())? {
-            Some(MaterializedViewKind::Select(definition)) => Ok(Self {
-                table,
-                definition,
-                incarnation,
-            }),
+            Some(MaterializedViewKind::Select(definition)) => Ok(Self { table, definition }),
            Some(MaterializedViewKind::Unrecognized { kind }) => Err(Error::NotSupported {
                message: format!(
                    "materialized view '{}' is defined by '{kind}', which this version of \
@@ -946,13 +923,6 @@ impl MaterializedView {
        &self.definition
    }

-    /// The view's incarnation token as of when this handle was opened; see
-    /// [`RefreshMaterializedViewBuilder::expect_incarnation`]. `None` for a
-    /// view that has none yet (see [`INCARNATION_META_KEY`]).
-    pub fn incarnation(&self) -> Option<&str> {
-        self.incarnation.as_deref()
-    }
-
    /// Recompute the view from its source.
    ///
    /// By default the refresh is incremental when the source's changes can be
@@ -973,7 +943,6 @@ impl MaterializedView {
            view: self.clone(),
            full: false,
            source_version: None,
-            expected_incarnation: None,
        }
    }
 }
@@ -983,7 +952,6 @@ pub struct RefreshMaterializedViewBuilder {
    view: MaterializedView,
    full: bool,
    source_version: Option<u64>,
-    expected_incarnation: Option<String>,
 }

 impl RefreshMaterializedViewBuilder {
@@ -999,28 +967,8 @@ impl RefreshMaterializedViewBuilder {
        self
    }

-    /// Refresh only if the view is still the incarnation that minted `token`
-    /// (see [`MaterializedView::incarnation`]): a refresh requested against
-    /// one declaration must not land in a view dropped and recreated since,
-    /// even under the same name and definition.
-    ///
-    /// Best effort. The token is read from the latest stored manifest before
-    /// planning and again immediately before every commit, but it is not part
-    /// of the commit's own condition, so a recreation that lands between that
-    /// final read and the commit is not caught.
-    pub fn expect_incarnation(mut self, token: impl Into<String>) -> Self {
-        self.expected_incarnation = Some(token.into());
-        self
-    }
-
    pub async fn execute(self) -> Result<RefreshMaterializedViewResult> {
-        refresh::execute_refresh(
-            &self.view.table,
-            self.full,
-            self.source_version,
-            self.expected_incarnation.as_deref(),
-        )
-        .await
+        refresh::execute_refresh(&self.view.table, self.full, self.source_version).await
    }
 }

@@ -46,8 +46,8 @@ use lance_table::format::Fragment;
 use serde::{Deserialize, Serialize};

 use super::{
-    INCARNATION_META_KEY, MaterializedViewDefinition, REFRESHED_AT_MS_META_KEY,
-    SOURCE_ROW_ID_COLUMN, SOURCE_VERSION_META_KEY,
+    MaterializedViewDefinition, REFRESHED_AT_MS_META_KEY, SOURCE_ROW_ID_COLUMN,
+    SOURCE_VERSION_META_KEY,
 };
 use crate::database::OpenTableRequest;
 use crate::table::{NativeTable, NativeTableExt, Table};
@@ -108,7 +108,6 @@ pub(crate) async fn execute_refresh(
    view: &Table,
    full: bool,
    pinned: Option<u64>,
-    expected_incarnation: Option<&str>,
 ) -> Result<RefreshMaterializedViewResult> {
    let view_native = view.as_native().ok_or_else(|| Error::NotSupported {
        message: "materialized views are supported only on local tables".into(),
@@ -123,8 +122,6 @@ pub(crate) async fn execute_refresh(
    view_native.dataset.reload().await?;
    let view_ds = view_native.dataset.get().await?.as_ref().clone();

-    ensure_incarnation(&view_ds, expected_incarnation, view.name()).await?;
-
    // The definition a handle cached at open may since have been replaced;
    // what refresh executes and what it stamps must be one generation.
    let definition = match super::materialized_view_kind(&view_ds.schema().metadata)? {
@@ -243,7 +240,6 @@ pub(crate) async fn execute_refresh(
                increment,
                definition,
                watermark,
-                expected_incarnation,
            )
            .await?;
            match reconciled {
@@ -257,7 +253,6 @@ pub(crate) async fn execute_refresh(
                        source_version,
                        source_ts,
                        definition,
-                        expected_incarnation,
                    )
                    .await
                }
@@ -271,7 +266,6 @@ pub(crate) async fn execute_refresh(
                source_version,
                source_ts,
                definition,
-                expected_incarnation,
            )
            .await
        }
@@ -601,7 +595,6 @@ async fn incremental(
    increment: Increment,
    definition: &MaterializedViewDefinition,
    watermark: Option<u64>,
-    expected_incarnation: Option<&str>,
 ) -> Result<Option<RefreshMaterializedViewResult>> {
    let new_fragments = increment.appended;
    let watermark_version = watermark.unwrap_or(0);
@@ -678,35 +671,15 @@ async fn incremental(
    };
    let nothing_to_add = (new_fragments.is_empty() && !updated_rows) || remaining == Some(0);
    if nothing_to_add && eviction.is_none() {
-        result.version = stamp_watermark(
-            view_native,
-            view_ds.clone(),
-            source_version,
-            source_ts,
-            expected_incarnation,
-        )
-        .await?;
+        result.version =
+            stamp_watermark(view_native, view_ds.clone(), source_version, source_ts).await?;
        return Ok(Some(result));
    }
    // Rows left but none arrive: the removals still have to be published.
    if nothing_to_add {
        let filter = refresh_filter(&empty_keys(view_ds)?)?;
-        let published = publish(
-            view_ds,
-            eviction,
-            Vec::new(),
-            Some(filter),
-            expected_incarnation,
-        )
-        .await?;
-        result.version = stamp_watermark(
-            view_native,
-            published,
-            source_version,
-            source_ts,
-            expected_incarnation,
-        )
-        .await?;
+        let published = publish(view_ds, eviction, Vec::new(), Some(filter)).await?;
+        result.version = stamp_watermark(view_native, published, source_version, source_ts).await?;
        return Ok(Some(result));
    }

@@ -764,20 +737,12 @@ async fn incremental(
                eviction,
                Vec::new(),
                Some(refresh_filter(&empty_keys(view_ds)?)?),
-                expected_incarnation,
            )
            .await?
        } else {
            view_ds.clone()
        };
-        result.version = stamp_watermark(
-            view_native,
-            published,
-            source_version,
-            source_ts,
-            expected_incarnation,
-        )
-        .await?;
+        result.version = stamp_watermark(view_native, published, source_version, source_ts).await?;
        return Ok(Some(result));
    };
    let stream: SendableRecordBatchStream = Box::pin(RecordBatchStreamAdapter::new(
@@ -810,23 +775,9 @@ async fn incremental(
        });
    };
    let filter = refresh_filter(&keys)?;
-    let appended = publish(
-        view_ds,
-        eviction,
-        new_fragments,
-        Some(filter),
-        expected_incarnation,
-    )
-    .await?;
+    let appended = publish(view_ds, eviction, new_fragments, Some(filter)).await?;
    result.rows_written = rows_written.load(Ordering::Relaxed);
-    result.version = stamp_watermark(
-        view_native,
-        appended,
-        source_version,
-        source_ts,
-        expected_incarnation,
-    )
-    .await?;
+    result.version = stamp_watermark(view_native, appended, source_version, source_ts).await?;
    Ok(Some(result))
 }

@@ -837,7 +788,6 @@ async fn rebuild(
    source_version: u64,
    source_ts: u128,
    definition: &MaterializedViewDefinition,
-    expected_incarnation: Option<&str>,
 ) -> Result<RefreshMaterializedViewResult> {
    let rows_written = Arc::new(AtomicU64::new(0));
    let schema = Arc::new(ArrowSchema::from(view_ds.schema()));
@@ -860,16 +810,8 @@ async fn rebuild(
    // carries no schema metadata, so it cannot erase a definition update
    // that raced in the way an overwrite (which adopts its stream's schema)
    // durably would -- and it must land on the planned generation or abort.
-    let replaced =
-        replace_retaining_indices(view_ds.clone(), stream, keys, expected_incarnation).await?;
-    let version = stamp_watermark(
-        view_native,
-        replaced,
-        source_version,
-        source_ts,
-        expected_incarnation,
-    )
-    .await?;
+    let replaced = replace_retaining_indices(view_ds.clone(), stream, keys).await?;
+    let version = stamp_watermark(view_native, replaced, source_version, source_ts).await?;
    Ok(RefreshMaterializedViewResult {
        mode: RefreshMode::Rebuild,
        rows_written: rows_written.load(Ordering::Relaxed),
@@ -886,13 +828,11 @@ async fn replace_retaining_indices(
    view_ds: Dataset,
    stream: SendableRecordBatchStream,
    keys: Arc<StdMutex<KeyExistenceFilterBuilder>>,
-    expected_incarnation: Option<&str>,
 ) -> Result<Dataset> {
    let ds = Arc::new(view_ds);
    let read_version = ds.version().version;
    #[cfg(test)]
    tests::hold_before_publish(ds.uri()).await;
-    ensure_incarnation(&ds, expected_incarnation, ds.uri()).await?;
    let removed_fragment_ids: Vec<u64> = ds.get_fragments().iter().map(|f| f.id() as u64).collect();

    let write_txn = InsertBuilder::new(WriteDestination::Dataset(ds.clone()))
@@ -946,32 +886,6 @@ async fn replace_retaining_indices(
 }

 /// Record that the view now reflects `source_version`, including the view
-/// Refuse to act on a view that is not `expected`'s incarnation, judged from
-/// the latest stored manifest. Not a commit condition; see
-/// `RefreshMaterializedViewBuilder::expect_incarnation`.
-async fn ensure_incarnation(view_ds: &Dataset, expected: Option<&str>, what: &str) -> Result<()> {
-    let Some(expected) = expected else {
-        return Ok(());
-    };
-    let mut latest = view_ds.clone();
-    latest.checkout_latest().await?;
-    match latest.schema().metadata.get(INCARNATION_META_KEY) {
-        Some(actual) if actual == expected => Ok(()),
-        Some(_) => Err(Error::Runtime {
-            message: format!(
-                "materialized view '{what}' is not the incarnation this refresh was \
-                 requested for: it was dropped and recreated"
-            ),
-        }),
-        None => Err(Error::Runtime {
-            message: format!(
-                "materialized view '{what}' carries no incarnation token: its schema \
-                 metadata was replaced since the token was captured"
-            ),
-        }),
-    }
-}
-
 /// version this very commit produces. The version is predicted and then
 /// verified; on a mismatch another commit raced in between, and the stamp
 /// ABORTS rather than certify that commit as the refresh's own generation.
@@ -981,21 +895,10 @@ async fn stamp_watermark(
    mut dataset: Dataset,
    source_version: u64,
    source_ts: u128,
-    expected_incarnation: Option<&str>,
 ) -> Result<u64> {
-    ensure_incarnation(&dataset, expected_incarnation, dataset.uri()).await?;
    let predicted = dataset.version().version + 1;
-    // A view with no token (declared before tokens existed, or its metadata
-    // replaced wholesale) starts a new incarnation here.
-    let incarnation = dataset
-        .schema()
-        .metadata
-        .get(INCARNATION_META_KEY)
-        .cloned()
-        .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
    dataset
        .update_schema_metadata([
-            (INCARNATION_META_KEY.to_string(), Some(incarnation)),
            (
                SOURCE_VERSION_META_KEY.to_string(),
                Some(source_version.to_string()),
@@ -1149,14 +1052,12 @@ async fn publish(
    eviction: Option<(Vec<Fragment>, Vec<u64>)>,
    new_fragments: Vec<Fragment>,
    keys: Option<KeyExistenceFilter>,
-    expected_incarnation: Option<&str>,
 ) -> Result<Dataset> {
    let planned = view_ds.version().version;
    #[cfg(test)]
    tests::hold_before_publish(view_ds.uri()).await;
    #[cfg(test)]
    tests::hold_until_peers_planned();
-    ensure_incarnation(view_ds, expected_incarnation, view_ds.uri()).await?;
    let (updated_fragments, removed_fragment_ids) = eviction.unwrap_or_default();
    let committed = CommitBuilder::new(WriteDestination::Dataset(Arc::new(view_ds.clone())))
        .execute(Transaction::new(
@@ -1929,9 +1830,7 @@ mod tests {
        );
        let staged = eviction.finish().await.unwrap();
        assert!(staged.is_some(), "four ids over a chunk of two stage twice");
-        publish(&view_ds, staged, Vec::new(), None, None)
-            .await
-            .unwrap();
+        publish(&view_ds, staged, Vec::new(), None).await.unwrap();
        native.dataset.reload().await.unwrap();

        assert_eq!(read(view.table(), "x").await, vec![5, 6]);
@@ -2587,144 +2486,6 @@ mod tests {
        assert_eq!(read(view.table(), "twice").await, vec![14]);
    }

-    /// A refresh bound to an incarnation refuses a view dropped and recreated
-    /// since, even under the same name and definition; the recreated view's
-    /// own token is accepted, and the token survives a refresh's stamp.
-    #[tokio::test]
-    async fn test_refresh_refuses_a_recreated_view_incarnation() {
-        let (conn, _, view) = refreshed_doubled(vec![1]).await;
-        let token = view.incarnation().unwrap().to_string();
-        view.refresh()
-            .expect_incarnation(&token)
-            .execute()
-            .await
-            .unwrap();
-        let reopened = conn.open_materialized_view("doubled").await.unwrap();
-        assert_eq!(reopened.incarnation(), Some(token.as_str()));
-
-        conn.drop_table("doubled", &[]).await.unwrap();
-        let recreated = doubled_view(&conn).await;
-        assert_ne!(recreated.incarnation(), Some(token.as_str()));
-
-        let err = recreated
-            .refresh()
-            .expect_incarnation(&token)
-            .execute()
-            .await
-            .unwrap_err();
-        assert!(err.to_string().contains("dropped and recreated"), "{err}");
-        assert_eq!(read(recreated.table(), "twice").await, Vec::<i32>::new());
-
-        recreated
-            .refresh()
-            .expect_incarnation(recreated.incarnation().unwrap())
-            .execute()
-            .await
-            .unwrap();
-        assert_eq!(read(recreated.table(), "twice").await, vec![2]);
-    }
-
-    /// A cloned declaration creates two physical tables; each gets its own
-    /// token.
-    #[tokio::test]
-    async fn test_cloned_declaration_mints_a_fresh_incarnation_per_create() {
-        let (conn, source) = db_with_source(vec![1]).await;
-        let prepared = crate::materialized_view::prepare_declaration(
-            &source,
-            &[("x".into(), "x".into()), ("twice".into(), "x * 2".into())],
-            None,
-            None,
-        )
-        .await
-        .unwrap();
-        let replacement = prepared.clone();
-        let first = prepared.create("cloned").await.unwrap();
-        let first_token = first.incarnation().unwrap().to_string();
-
-        conn.drop_table("cloned", &[]).await.unwrap();
-        let second = replacement.create("cloned").await.unwrap();
-        assert_ne!(second.incarnation(), Some(first_token.as_str()));
-    }
-
-    /// A recreation that lands after planning but before publication is
-    /// caught by the pre-commit read: the stale refresh fails and the
-    /// replacement stays empty under its own token.
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_bound_refresh_cannot_publish_into_a_raced_recreation() {
-        let _serial = DRIFT_LOCK.lock().await;
-        let (conn, _) = db_with_source(vec![1]).await;
-        let view = doubled_view(&conn).await;
-        let token = view.incarnation().unwrap().to_string();
-        let uri = view
-            .table()
-            .as_native()
-            .unwrap()
-            .dataset
-            .get()
-            .await
-            .unwrap()
-            .uri()
-            .to_string();
-
-        *DRIFT_TARGET.lock().unwrap() = Some(uri);
-        let refreshing =
-            tokio::spawn(async move { view.refresh().expect_incarnation(token).execute().await });
-        tokio::time::timeout(std::time::Duration::from_secs(30), DRIFT_PLANNED.notified())
-            .await
-            .expect("refresh never reached publication");
-
-        conn.drop_table("doubled", &[]).await.unwrap();
-        let replacement = doubled_view(&conn).await;
-        let replacement_token = replacement.incarnation().unwrap().to_string();
-        DRIFT_RELEASED.notify_one();
-
-        let result = refreshing.await.unwrap();
-        assert!(result.is_err(), "the stale refresh unexpectedly succeeded");
-        let reopened = conn.open_materialized_view("doubled").await.unwrap();
-        assert_eq!(reopened.incarnation(), Some(replacement_token.as_str()));
-        assert_eq!(read(reopened.table(), "twice").await, Vec::<i32>::new());
-    }
-
-    /// Replacing the schema metadata wholesale drops the token. A refresh
-    /// bound to the old token is refused for that reason, not as a
-    /// recreation; an unbound refresh mints the view a fresh one.
-    #[tokio::test]
-    async fn test_a_view_whose_metadata_was_replaced_starts_a_new_incarnation() {
-        let (conn, _, view) = refreshed_doubled(vec![1]).await;
-        let token = view.incarnation().unwrap().to_string();
-        let mut metadata = HashMap::new();
-        metadata.insert(
-            crate::materialized_view::DEFINITION_META_KEY.to_string(),
-            crate::materialized_view::definition_to_metadata(view.definition()).unwrap(),
-        );
-        view.table()
-            .as_native()
-            .unwrap()
-            .replace_schema_metadata(metadata)
-            .await
-            .unwrap();
-        assert_eq!(
-            conn.open_materialized_view("doubled")
-                .await
-                .unwrap()
-                .incarnation(),
-            None
-        );
-
-        let err = view
-            .refresh()
-            .expect_incarnation(&token)
-            .execute()
-            .await
-            .unwrap_err();
-        assert!(err.to_string().contains("no incarnation token"), "{err}");
-
-        view.refresh().execute().await.unwrap();
-        let reopened = conn.open_materialized_view("doubled").await.unwrap();
-        assert!(reopened.incarnation().is_some());
-        assert_ne!(reopened.incarnation(), Some(token.as_str()));
-    }
-
    /// In-process refreshes of one view serialize: the loser of the race
    /// observes the winner's watermark instead of appending the same rows.
    #[tokio::test(flavor = "multi_thread")]
@@ -2767,7 +2528,7 @@ mod tests {
        let stale = view_native.dataset.get().await.unwrap().as_ref().clone();
        view.table().delete("x = 1").await.unwrap();

-        let err = stamp_watermark(view_native, stale, 99, 99, None).await;
+        let err = stamp_watermark(view_native, stale, 99, 99).await;
        assert!(err.is_err());

        let result = view.refresh().execute().await.unwrap();
@@ -1774,14 +1774,11 @@ mod tests {
            .postfilter();
        let result = query.execute().await;
        let mut stream = result.expect("should have result");
-        let mut num_rows = 0;
+        // should only have one batch
        while let Some(batch) = stream.next().await {
-            let batch = batch.expect("should be Ok");
-            let ids: &Int32Array = batch["id"].as_primitive();
-            assert!(ids.iter().all(|id| id.unwrap() % 2 == 0));
-            num_rows += batch.num_rows();
+            // post filter should have removed some rows
+            assert!(batch.expect("should be Ok").num_rows() < 10);
        }
-        assert!(num_rows <= 10);

        let query = table
            .query()
@@ -344,62 +344,6 @@ impl<S: HttpSend> RemoteDatabase<S> {
        self.table_cache.remove(&cache_key).await;
        Ok((request_id, resp))
    }
-
-    /// Collect the tables of a namespace in name order, for `table_names`.
-    ///
-    /// `table_names` promises name order and resumes after a table name, but the namespace
-    /// route's `page_token` is opaque -- it belongs to the store the listing walks, and a
-    /// token this client invented would resume from the wrong place. So the whole namespace is
-    /// walked by handing each response's token straight back, and the name semantics are
-    /// applied here. Constructing no token is what makes this work against a server on either
-    /// side of the change: it only ever repeats what the server said.
-    ///
-    /// This is the cost `table_names` already paid -- the server used to enumerate and sort the
-    /// namespace on every request -- and it is why `list_tables` replaces it.
-    async fn table_names_in_namespace(
-        &self,
-        request: &TableNamesRequest,
-    ) -> Result<(Vec<String>, ServerVersion)> {
-        let namespace_id =
-            build_namespace_identifier(&request.namespace_path, &self.client.id_delimiter);
-        let path = format!("/v1/namespace/{}/table/list", namespace_id);
-
-        let mut names = Vec::new();
-        // Every page reports the same server, so keep the first page's version.
-        let mut version: Option<ServerVersion> = None;
-        let mut page_token: Option<String> = None;
-        loop {
-            let mut req = self.client.get(&path);
-            if let Some(ref token) = page_token {
-                req = req.query(&[("page_token", token)]);
-            }
-            let (request_id, rsp) = self.client.send_with_retry(req, None, true).await?;
-            let rsp = self.client.check_response(&request_id, rsp).await?;
-            if version.is_none() {
-                version = Some(parse_server_version(&request_id, &rsp)?);
-            }
-            let response: ListTablesResponse = rsp.json().await.err_to_http(request_id)?;
-            names.extend(response.tables);
-            // An empty token is the end of the listing, not a token to send back: a server
-            // that reads an empty token as "start from the beginning" would hand back the
-            // first page again.
-            match response.page_token.filter(|token| !token.is_empty()) {
-                // A server that repeated a token would never finish; treat that as the end
-                // rather than looping on it.
-                Some(token) if Some(&token) != page_token.as_ref() => page_token = Some(token),
-                _ => break,
-            }
-        }
-
-        names.sort();
-        if let Some(ref start_after) = request.start_after {
-            names.retain(|name| name > start_after);
-        }
-        if let Some(limit) = request.limit {
-            names.truncate(limit as usize);
-        }
-        Ok((names, version.unwrap_or_default()))
-    }
 }

 #[cfg(all(test, feature = "remote"))]
@@ -569,7 +513,7 @@ impl<S: HttpSend> Database for RemoteDatabase<S> {
    async fn get_function(&self, name: &str, version: &str) -> Result<FunctionVersion> {
        let req = self
            .client
-            .post("/v1/functions/describe")
+            .post("/v1/functions/get")
            .json(&serde_json::json!({
                "name": name,
                "version": version,
@@ -677,29 +621,29 @@ impl<S: HttpSend> Database for RemoteDatabase<S> {
    }

    async fn table_names(&self, request: TableNamesRequest) -> Result<Vec<String>> {
-        let (tables, version) = if request.namespace_path.is_empty() {
-            // The flat route resumes after a table name and orders by name, which is exactly
-            // what `start_after` means, so the server does the paging.
-            let mut req = self.client.get("/v1/table/");
-            if let Some(limit) = request.limit {
-                req = req.query(&[("limit", limit)]);
-            }
-            if let Some(ref start_after) = request.start_after {
-                req = req.query(&[("page_token", start_after)]);
-            }
-            let (request_id, rsp) = self.client.send_with_retry(req, None, true).await?;
-            let rsp = self.client.check_response(&request_id, rsp).await?;
-            let version = parse_server_version(&request_id, &rsp)?;
-            let tables = rsp
-                .json::<ListTablesResponse>()
-                .await
-                .err_to_http(request_id)?
-                .tables;
-            (tables, version)
+        let mut req = if !request.namespace_path.is_empty() {
+            let namespace_id =
+                build_namespace_identifier(&request.namespace_path, &self.client.id_delimiter);
+            self.client
+                .get(&format!("/v1/namespace/{}/table/list", namespace_id))
        } else {
-            self.table_names_in_namespace(&request).await?
+            self.client.get("/v1/table/")
        };

+        if let Some(limit) = request.limit {
+            req = req.query(&[("limit", limit)]);
+        }
+        if let Some(start_after) = request.start_after {
+            req = req.query(&[("page_token", start_after)]);
+        }
+        let (request_id, rsp) = self.client.send_with_retry(req, None, true).await?;
+        let rsp = self.client.check_response(&request_id, rsp).await?;
+        let version = parse_server_version(&request_id, &rsp)?;
+        let tables = rsp
+            .json::<ListTablesResponse>()
+            .await
+            .err_to_http(request_id)?
+            .tables;
        for table in &tables {
            let table_identifier =
                build_table_identifier(table, &request.namespace_path, &self.client.id_delimiter);
@@ -1283,101 +1227,6 @@ mod tests {
        assert_eq!(names, vec!["table1", "table2"]);
    }

-    #[tokio::test]
-    async fn test_table_names_in_a_namespace_never_invents_a_page_token() {
-        // The namespace route's token belongs to the store, so `table_names` cannot build one
-        // from `start_after`. It walks the namespace on the server's own tokens and applies the
-        // name semantics itself, which is what keeps it working either side of the change.
-        let page = Arc::new(AtomicUsize::new(0));
-        let conn = Connection::new_with_handler(move |request| {
-            assert_eq!(request.url().path(), "/v1/namespace/ns/table/list");
-            let query = request.url().query().unwrap_or("");
-            assert!(
-                !query.contains("page_token=users"),
-                "a table name must never be sent as a page token: {query}"
-            );
-            match page.fetch_add(1, Ordering::SeqCst) {
-                0 => {
-                    assert!(
-                        !query.contains("page_token"),
-                        "the walk starts with no token"
-                    );
-                    http::Response::builder()
-                        .status(200)
-                        .body(r#"{"tables": ["users", "orders"], "page_token": "opaque-1"}"#)
-                        .unwrap()
-                }
-                _ => {
-                    assert!(query.contains("page_token=opaque-1"));
-                    http::Response::builder()
-                        .status(200)
-                        .body(r#"{"tables": ["widgets"]}"#)
-                        .unwrap()
-                }
-            }
-        });
-
-        let names = conn
-            .table_names()
-            .namespace(vec!["ns".to_string()])
-            .start_after("users")
-            .execute()
-            .await
-            .unwrap();
-        // Name order, resumed after "users": "orders" sorts before it and is dropped.
-        assert_eq!(names, vec!["widgets"]);
-    }
-
-    #[tokio::test]
-    async fn test_table_names_in_a_namespace_stops_on_a_repeated_token() {
-        // A server that handed back the token it was given would never finish the walk.
-        let conn = Connection::new_with_handler(|_request| {
-            http::Response::builder()
-                .status(200)
-                .body(r#"{"tables": ["a"], "page_token": "same"}"#)
-                .unwrap()
-        });
-
-        let names = conn
-            .table_names()
-            .namespace(vec!["ns".to_string()])
-            .execute()
-            .await
-            .unwrap();
-        // The guard bounds the walk instead of letting it run forever. The repeat is the
-        // server breaking the token contract and is not papered over here.
-        assert_eq!(names, vec!["a", "a"]);
-    }
-
-    #[tokio::test]
-    async fn test_table_names_in_a_namespace_stops_on_an_empty_token() {
-        // An empty token ends the listing. Sending it back would ask a server that reads it
-        // as "start from the beginning" for the first page a second time, and every name on
-        // that page would be collected twice.
-        let requests = Arc::new(AtomicUsize::new(0));
-        let seen = requests.clone();
-        let conn = Connection::new_with_handler(move |request| {
-            seen.fetch_add(1, Ordering::SeqCst);
-            assert!(
-                !request.url().query().unwrap_or("").contains("page_token"),
-                "an empty token must never be sent back"
-            );
-            http::Response::builder()
-                .status(200)
-                .body(r#"{"tables": ["a"], "page_token": ""}"#)
-                .unwrap()
-        });
-
-        let names = conn
-            .table_names()
-            .namespace(vec!["ns".to_string()])
-            .execute()
-            .await
-            .unwrap();
-        assert_eq!(names, vec!["a"]);
-        assert_eq!(requests.load(Ordering::SeqCst), 1);
-    }
-
    #[tokio::test]
    async fn test_table_names_pagination() {
        let conn = Connection::new_with_handler(|request| {
@@ -2671,7 +2520,7 @@ mod tests {
        );
        let conn = Connection::new_with_handler(|request| {
            assert_eq!(request.method(), &reqwest::Method::POST);
-            assert_eq!(request.url().path(), "/v1/functions/describe");
+            assert_eq!(request.url().path(), "/v1/functions/get");
            let body: serde_json::Value =
                serde_json::from_slice(request.body().unwrap().as_bytes().unwrap()).unwrap();
            assert_eq!(
@@ -1725,22 +1725,6 @@ impl<S: HttpSend> BaseTable for RemoteTable<S> {
    async fn version(&self) -> Result<u64> {
        self.describe().await.map(|desc| desc.version)
    }
-
-    async fn checkout_current(&self) -> Result<Arc<dyn BaseTable>> {
-        let description = self.describe().await?;
-        let TableDescription {
-            version,
-            schema,
-            location,
-        } = description;
-        let schema = Arc::new(arrow_schema::Schema::try_from(schema)?);
-        let snapshot = self.with_branch(self.branch.clone());
-        *snapshot.version.write().await = Some(version);
-        *snapshot.location.write().await = location;
-        snapshot.schema_cache.seed(schema);
-        Ok(Arc::new(snapshot))
-    }
-
    async fn checkout(&self, version: u64) -> Result<()> {
        // Validate the version exists. The describe is sent without freshness
        // headers so a stale `min_version` from a previous write doesn't ride
@@ -1791,18 +1775,6 @@ impl<S: HttpSend> BaseTable for RemoteTable<S> {

        Ok(())
    }
-    async fn snapshot_at_current_version(&self) -> Result<Option<Arc<dyn BaseTable>>> {
-        // A checked-out handle already names its snapshot. Otherwise resolve
-        // latest exactly once before creating the independent pinned handle.
-        let version = match self.current_version().await {
-            Some(version) => version,
-            None => self.describe().await?.version,
-        };
-
-        let snapshot = self.with_branch(self.branch.clone());
-        *snapshot.version.write().await = Some(version);
-        Ok(Some(Arc::new(snapshot)))
-    }
    async fn restore(&self) -> Result<()> {
        let mut request = self
            .client
@@ -2177,15 +2149,6 @@ impl<S: HttpSend> BaseTable for RemoteTable<S> {
    async fn add(&self, mut add: AddDataBuilder) -> Result<AddResult> {
        self.check_mutable().await?;

-        if add.allow_external_blob_outside_bases {
-            return Err(Error::NotSupported {
-                message: "allow_external_blob_outside_bases is only supported on local tables"
-                    .to_string(),
-            });
-        }
-        // String blob values still coerce to the uri child in into_plan.
-        // Remote and local share that input shape.
-
        let table_schema = self.schema().await?;
        crate::table::computed_columns::ensure_supported_function_metadata(table_schema.as_ref())?;
        let table_def = TableDefinition::try_from_rich_schema(table_schema.clone())?;
@@ -2901,10 +2864,7 @@ impl<S: HttpSend> BaseTable for RemoteTable<S> {
        })
    }

-    async fn refresh_column_async(
-        &self,
-        column: &str,
-    ) -> Result<Job<crate::function::RefreshColumnResult>> {
+    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);
@@ -2925,7 +2885,7 @@ impl<S: HttpSend> BaseTable for RemoteTable<S> {
            status_code: None,
        })?;

-        Ok(Job::new_typed(Box::new(FreshnessJob {
+        Ok(Job::new(Box::new(FreshnessJob {
            inner: RemoteJob::new(self.client.clone(), response.job_id),
            freshness: self.freshness.clone(),
            version: self.version.clone(),
@@ -3294,10 +3254,7 @@ mod tests {
    use arrow::{array::AsArray, compute::concat_batches, datatypes::Int32Type};
    use arrow_array::Array;
    use arrow_array::builder::LargeBinaryBuilder;
-    use arrow_array::{
-        BinaryArray, Int32Array, Int64Array, RecordBatch, RecordBatchIterator, StringArray,
-        StructArray, record_batch,
-    };
+    use arrow_array::{BinaryArray, Int32Array, RecordBatch, RecordBatchIterator, record_batch};
    use arrow_schema::{DataType, Field, Schema};
    use chrono::{DateTime, Utc};
    use futures::{StreamExt, TryFutureExt, future::BoxFuture};
@@ -3323,21 +3280,6 @@ mod tests {
        },
    };

-    fn refresh_done(job_id: &str) -> String {
-        json!({
-            "job_id": job_id,
-            "job_state": "DONE",
-            "result": {
-                "rows_assigned": 12,
-                "rows_failed": 0,
-                "rows_remaining": 0,
-                "source_version": 7,
-                "published_version": 8,
-            }
-        })
-        .to_string()
-    }
-
    #[tokio::test]
    async fn test_not_found() {
        let table = Table::new_with_handler("my_table", |_| {
@@ -3649,88 +3591,6 @@ mod tests {
        assert_eq!(&body, &expected_body);
    }

-    #[tokio::test]
-    async fn add_rejects_external_blob_flag_before_any_request() {
-        let table = Table::new_with_handler::<String>("my_table", |request| {
-            panic!("Unexpected request: {}", request.url().path())
-        });
-        let data = RecordBatch::try_new(
-            Arc::new(Schema::new(vec![Field::new("a", DataType::Int32, false)])),
-            vec![Arc::new(Int32Array::from(vec![1]))],
-        )
-        .unwrap();
-
-        let err = table
-            .add(data)
-            .allow_external_blob_outside_bases(true)
-            .execute()
-            .await
-            .unwrap_err();
-
-        assert!(matches!(err, Error::NotSupported { .. }), "got {err:?}");
-        assert!(err.to_string().contains("local tables"));
-    }
-
-    #[tokio::test]
-    async fn add_string_blob_becomes_uri_struct_without_the_local_flag() {
-        let table_schema = Schema::new(vec![
-            Field::new("id", DataType::Int64, false),
-            crate::blob("image", true),
-        ]);
-        let describe_body = describe_response(&table_schema);
-        let input = RecordBatch::try_new(
-            Arc::new(Schema::new(vec![
-                Field::new("id", DataType::Int64, false),
-                Field::new("image", DataType::Utf8, true),
-            ])),
-            vec![
-                Arc::new(Int64Array::from(vec![1])),
-                Arc::new(StringArray::from(vec![Some("s3://bucket/key")])),
-            ],
-        )
-        .unwrap();
-
-        let (sender, receiver) = std::sync::mpsc::channel();
-        let table =
-            Table::new_with_handler("my_table", move |mut request| match request.url().path() {
-                "/v1/table/my_table/describe/" => http::Response::builder()
-                    .status(200)
-                    .body(describe_body.clone())
-                    .unwrap(),
-                "/v1/table/my_table/insert/" => {
-                    let mut body_out = reqwest::Body::from(Vec::new());
-                    std::mem::swap(request.body_mut().as_mut().unwrap(), &mut body_out);
-                    sender.send(body_out).unwrap();
-                    http::Response::builder()
-                        .status(200)
-                        .body(r#"{"version": 2}"#.to_string())
-                        .unwrap()
-                }
-                path => panic!("Unexpected path: {path}"),
-            });
-
-        table.add(input).execute().await.unwrap();
-
-        let body = collect_body(receiver.recv().unwrap()).await;
-        let mut reader =
-            arrow_ipc::reader::StreamReader::try_new(std::io::Cursor::new(body), None).unwrap();
-        let batch = reader.next().unwrap().unwrap();
-        let image = batch
-            .column_by_name("image")
-            .unwrap()
-            .as_any()
-            .downcast_ref::<StructArray>()
-            .expect("remote add should send the coerced blob struct");
-        let uri: &StringArray = image
-            .column_by_name("uri")
-            .unwrap()
-            .as_any()
-            .downcast_ref()
-            .unwrap();
-        assert_eq!(uri.value(0), "s3://bucket/key");
-        assert!(image.column_by_name("data").unwrap().is_null(0));
-    }
-
    #[rstest]
    #[case(true)]
    #[case(false)]
@@ -4459,43 +4319,6 @@ mod tests {
        assert!(!table.base_table().scan_order_is_deterministic());
    }

-    #[tokio::test]
-    async fn test_checkout_branch_pins_without_touching_the_original() {
-        let seen = Arc::new(std::sync::Mutex::new(Vec::new()));
-        let recorder = seen.clone();
-        let table = Table::new_with_handler_version(
-            "my_table",
-            semver::Version::new(0, 5, 0),
-            move |request| match request.url().path() {
-                "/v1/table/my_table/describe/" => http::Response::builder()
-                    .status(200)
-                    .body(br#"{"version": 42, "schema": {"fields": []}}"#.to_vec())
-                    .unwrap(),
-                "/v1/table/my_table/count_rows/" => {
-                    let body = request_body_json(&request);
-                    recorder.lock().unwrap().push(body["version"].clone());
-                    http::Response::builder()
-                        .status(200)
-                        .body(b"0".to_vec())
-                        .unwrap()
-                }
-                path => panic!("unexpected request path: {path}"),
-            },
-        );
-
-        let pinned = table.checkout_branch("main", Some(42)).await.unwrap();
-        pinned.count_rows(None).await.unwrap();
-        table.count_rows(None).await.unwrap();
-
-        let seen = seen.lock().unwrap();
-        assert_eq!(seen[0], 42, "the pinned handle must send its version");
-        assert!(
-            seen[1].is_null(),
-            "the original handle must still track latest, got {:?}",
-            seen[1]
-        );
-    }
-
    #[tokio::test]
    async fn test_fetch_blobs_sends_the_checked_out_version() {
        let ipc = one_row_blob_ipc_stream("image");
@@ -6897,7 +6720,8 @@ mod tests {
            r#"{
                "function":{"name":"embed","version":"fv_01K3EXACT"},
                "inputs":[{"parameter":"text","kind":"column","value":{"path":"description"}}],
-                "output":{"kind":"scalar","arrow_type":"list<float32>","nullable":false}
+                "output":{"kind":"scalar","arrow_type":"list<float32>","nullable":false},
+                "group_id":"fg_scalar"
            }"#,
        )
        .unwrap();
@@ -6912,53 +6736,7 @@ mod tests {
    }

    #[tokio::test]
-    async fn test_add_fixed_size_list_function_column_declares_the_vector_type() {
-        let table = Table::new_with_handler("my_table", |request| {
-            match request.url().path() {
-            "/v1/table/my_table/describe/" => http::Response::builder()
-                .status(200)
-                .body(
-                    r#"{"version":1,"schema":{"fields":[{"name":"description","nullable":true,"type":{"type":"string"}}]}}"#,
-                )
-                .unwrap(),
-            "/v1/table/my_table/add_columns/" => {
-                let actual: serde_json::Value = serde_json::from_slice(
-                    request.body().unwrap().as_bytes().unwrap(),
-                )
-                .unwrap();
-                let expected: serde_json::Value = serde_json::from_str(include_str!(
-                    "../../tests/fixtures/first_class_functions/v1/remote_fixed_size_declaration_request.json"
-                ))
-                .unwrap();
-                assert_eq!(actual, expected);
-                http::Response::builder()
-                    .status(200)
-                    .body(r#"{"version":8}"#)
-                    .unwrap()
-            }
-            path => panic!("Unexpected path: {path}"),
-        }
-        });
-        let application = crate::function::FunctionApplication::from_json(
-            r#"{
-                "function":{"name":"embed","version":"fv_01K3EXACT"},
-                "inputs":[{"parameter":"text","kind":"column","value":{"path":"description"}}],
-                "output":{"kind":"scalar","arrow_type":"fixed_size_list<float32, 3>","nullable":false}
-            }"#,
-        )
-        .unwrap();
-
-        let result = table
-            .add_columns()
-            .function_as("embedding", application)
-            .execute()
-            .await
-            .unwrap();
-        assert_eq!(result.version, 8);
-    }
-
-    #[tokio::test]
-    async fn test_add_named_struct_function_expands_one_atomic_binding() {
+    async fn test_add_named_struct_function_expands_one_atomic_sibling_group() {
        let table = Table::new_with_handler("my_table", |request| match request.url().path() {
            "/v1/table/my_table/describe/" => http::Response::builder()
                .status(200)
@@ -6973,7 +6751,7 @@ mod tests {
                let actual: serde_json::Value =
                    serde_json::from_slice(request.body().unwrap().as_bytes().unwrap()).unwrap();
                let expected: serde_json::Value = serde_json::from_str(include_str!(
-                    "../../tests/fixtures/first_class_functions/v1/remote_multi_output_declaration_request.json"
+                    "../../tests/fixtures/first_class_functions/v1/remote_grouped_declaration_request.json"
                ))
                .unwrap();
                assert_eq!(actual, expected);
@@ -6995,6 +6773,7 @@ mod tests {
                    {"name":"normalized_text","arrow_type":"utf8","nullable":false},
                    {"name":"token_count","arrow_type":"int64","nullable":false}
                ]},
+                "group_id":"fg_01K3TEXT",
                "columns":{"normalized_text":"search_text"}
            }"#,
        )
@@ -7113,7 +6892,7 @@ mod tests {
                    .unwrap(),
                "/v1/jobs/describe" => http::Response::builder()
                    .status(200)
-                    .body(refresh_done("j-7"))
+                    .body(r#"{"job_id": "j-7", "job_state": "DONE"}"#.to_string())
                    .unwrap(),
                "/v1/table/my_table/count_rows/" => {
                    saw.store(
@@ -7129,9 +6908,7 @@ mod tests {
            });

        let job = table.refresh_column_async("doubled").await.unwrap();
-        let result = job.wait().await.unwrap();
-        assert_eq!(result.rows_assigned, 12);
-        assert_eq!(result.published_version, Some(8));
+        job.wait().await.unwrap();
        table.count_rows(None).await.unwrap();
        assert!(
            saw_min_timestamp.load(std::sync::atomic::Ordering::SeqCst),
@@ -7153,7 +6930,7 @@ mod tests {
                    .unwrap(),
                "/v1/jobs/describe" => http::Response::builder()
                    .status(200)
-                    .body(refresh_done("j-8"))
+                    .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)]);
@@ -7199,7 +6976,7 @@ mod tests {
                    .unwrap(),
                "/v1/jobs/describe" => http::Response::builder()
                    .status(200)
-                    .body(refresh_done("j-9"))
+                    .body(r#"{"job_id": "j-9", "job_state": "DONE"}"#.to_string())
                    .unwrap(),
                "/v1/table/my_table/tags/version/" => http::Response::builder()
                    .status(200)
@@ -7263,7 +7040,7 @@ mod tests {
                }
                "/v1/jobs/describe" => http::Response::builder()
                    .status(200)
-                    .body(refresh_done("j-10"))
+                    .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)]);
@@ -7336,7 +7113,7 @@ mod tests {
                }
                "/v1/jobs/describe" => http::Response::builder()
                    .status(200)
-                    .body(refresh_done("j-11"))
+                    .body(r#"{"job_id": "j-11", "job_state": "DONE"}"#.to_string())
                    .unwrap(),
                "/v1/table/my_table/count_rows/" => {
                    *saw.lock().unwrap() = request
@@ -8755,28 +8532,6 @@ mod tests {
        }
    }

-    /// A pinned snapshot should reuse the version and schema returned by its
-    /// initial describe instead of issuing two more describe requests.
-    #[tokio::test]
-    async fn test_checkout_current_seeds_schema_from_single_describe() {
-        let describe_calls = Arc::new(AtomicUsize::new(0));
-        let calls = describe_calls.clone();
-        let table = Table::new_with_handler("my_table", move |request| {
-            assert_eq!(request.url().path(), "/v1/table/my_table/describe/");
-            calls.fetch_add(1, Ordering::SeqCst);
-            http::Response::builder()
-                .status(200)
-                .body(
-                    r#"{"version":42,"schema":{"fields":[{"name":"a","type":{"type":"int32"},"nullable":false}]}}"#,
-                )
-                .unwrap()
-        });
-
-        let snapshot = table.checkout_current().await.unwrap();
-        assert_eq!(snapshot.schema().await.unwrap().fields().len(), 1);
-        assert_eq!(describe_calls.load(Ordering::SeqCst), 1);
-    }
-
    /// Test that schema cache is invalidated after checkout
    #[tokio::test]
    async fn test_schema_cache_invalidation_on_checkout() {
@@ -751,7 +751,7 @@ pub trait BaseTable: std::fmt::Display + std::fmt::Debug + Send + Sync {
            message: "computed columns are not supported on this table type".into(),
        })
    }
-    /// Declare one immutable registered-Function binding.
+    /// Declare one immutable registered-Function output group.
    async fn add_function_columns(
        &self,
        _application: &crate::function::FunctionApplication,
@@ -771,10 +771,7 @@ pub trait BaseTable: std::fmt::Display + std::fmt::Debug + Send + Sync {
    }
    /// Fill a computed column's unfilled rows, returning a [`Job`] tracking
    /// the operation.
-    async fn refresh_column_async(
-        &self,
-        _column: &str,
-    ) -> Result<Job<crate::function::RefreshColumnResult>> {
+    async fn refresh_column_async(&self, _column: &str) -> Result<Job> {
        Err(Error::NotSupported {
            message: "computed columns are supported only on local tables".into(),
        })
@@ -785,12 +782,6 @@ pub trait BaseTable: std::fmt::Display + std::fmt::Debug + Send + Sync {
    async fn drop_columns(&self, columns: &[&str]) -> Result<DropColumnsResult>;
    /// Get the version of the table.
    async fn version(&self) -> Result<u64>;
-    /// Return a new table handle pinned to the exact revision currently visible.
-    async fn checkout_current(&self) -> Result<Arc<dyn BaseTable>> {
-        Err(Error::NotSupported {
-            message: "checkout_current is not supported on this table type".into(),
-        })
-    }
    /// Checkout a specific version of the table.
    async fn checkout(&self, version: u64) -> Result<()>;
    /// Checkout a table version referenced by a tag.
@@ -798,14 +789,6 @@ pub trait BaseTable: std::fmt::Display + std::fmt::Debug + Send + Sync {
    async fn checkout_tag(&self, tag: &str) -> Result<()>;
    /// Checkout the latest version of the table.
    async fn checkout_latest(&self) -> Result<()>;
-    /// Return an independent handle pinned to the version currently selected.
-    ///
-    /// Backends that can advance between requests should override this for
-    /// multi-request operations that need snapshot consistency. Backends whose
-    /// existing handles already provide the desired behavior return `None`.
-    async fn snapshot_at_current_version(&self) -> Result<Option<Arc<dyn BaseTable>>> {
-        Ok(None)
-    }
    /// Whether repeated identical scans return rows in the same order.
    ///
    /// Callers that assign meaning to a row's position must order the results
@@ -1725,9 +1708,7 @@ impl Table {
    /// 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. A successful
-    /// wait returns the durable [`crate::function::RefreshColumnResult`] for
-    /// both expression-backed and Function-backed columns. Invalid input
+    /// 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
@@ -1738,15 +1719,11 @@ impl 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?);
-    /// let result = job.wait().await?;
-    /// println!("assigned {} rows", result.rows_assigned);
+    /// job.wait().await?;
    /// # Ok(())
    /// # }
    /// ```
-    pub async fn refresh_column_async(
-        &self,
-        column: impl AsRef<str>,
-    ) -> Result<Job<crate::function::RefreshColumnResult>> {
+    pub async fn refresh_column_async(&self, column: impl AsRef<str>) -> Result<Job> {
        self.inner.refresh_column_async(column.as_ref()).await
    }

@@ -1950,20 +1927,6 @@ impl Table {
        self.inner.version().await
    }

-    /// Return a new table handle pinned to the exact revision currently visible.
-    ///
-    /// This is used when asynchronous preparation must remain consistent with
-    /// the revision used for a later read.
-    #[doc(hidden)]
-    pub async fn checkout_current(&self) -> Result<Self> {
-        let inner = self.inner.checkout_current().await?;
-        Ok(Self {
-            inner,
-            database: self.database.clone(),
-            embedding_registry: self.embedding_registry.clone(),
-        })
-    }
-
    /// Checks out a specific version of the Table
    ///
    /// Any read operation on the table will now access the data at the checked out version.
@@ -3063,18 +3026,6 @@ impl BaseTable for NativeTable {
        Ok(self.dataset.get().await?.version().version)
    }

-    async fn checkout_current(&self) -> Result<Arc<dyn BaseTable>> {
-        let current = self.dataset.get().await?;
-        let dataset = dataset::DatasetConsistencyWrapper::new_time_travel(
-            current.as_ref().clone(),
-            self.read_consistency_interval,
-        );
-        Ok(Arc::new(Self {
-            dataset,
-            ..self.clone()
-        }))
-    }
-
    async fn checkout(&self, version: u64) -> Result<()> {
        self.dataset.as_time_travel(version).await
    }
@@ -3240,7 +3191,7 @@ impl BaseTable for NativeTable {

        let output = add.into_plan(&table_schema, &table_def)?;

-        let mut lance_params = output
+        let lance_params = output
            .write_options
            .lance_write_params
            .unwrap_or(WriteParams {
@@ -3250,9 +3201,6 @@ impl BaseTable for NativeTable {
                },
                ..Default::default()
            });
-        if output.allow_external_blob_outside_bases {
-            lance_params.allow_external_blob_outside_bases = true;
-        }

        // Repartition for write parallelism if beneficial.
        let plan = if num_partitions > 1 {
@@ -3477,10 +3425,7 @@ impl BaseTable for NativeTable {
        Ok(result)
    }

-    async fn refresh_column_async(
-        &self,
-        column: &str,
-    ) -> Result<Job<crate::function::RefreshColumnResult>> {
+    async fn refresh_column_async(&self, column: &str) -> Result<Job> {
        refresh::execute_refresh_column_async(self, column).await
    }

@@ -4118,14 +4063,6 @@ mod tests {
                parent_list_calls: self.parent_list_calls.clone(),
            })
        }
-
-        fn wrap_paginated(
-            &self,
-            _store_prefix: &str,
-            _original: Arc<dyn object_store::list::PaginatedListStore>,
-        ) -> Option<Arc<dyn object_store::list::PaginatedListStore>> {
-            None
-        }
    }

    #[tokio::test]
@@ -4229,14 +4166,6 @@ mod tests {
            self.called.store(true, Ordering::Relaxed);
            original
        }
-
-        fn wrap_paginated(
-            &self,
-            _store_prefix: &str,
-            original: Arc<dyn object_store::list::PaginatedListStore>,
-        ) -> Option<Arc<dyn object_store::list::PaginatedListStore>> {
-            Some(original)
-        }
    }

    #[tokio::test]
@@ -88,7 +88,7 @@ impl AddColumnsBuilder {
    }

    /// Declare every field of a named-struct Function result as one atomic
-    /// binding. Result-field aliases come from
+    /// sibling group. Result-field aliases come from
    /// [`FunctionApplication::columns`](crate::function::FunctionApplication::columns).
    ///
    /// ```
@@ -60,7 +60,6 @@ pub struct AddDataBuilder {
    pub(crate) embedding_registry: Option<Arc<dyn EmbeddingRegistry>>,
    pub(crate) progress_callback: Option<ProgressCallback>,
    pub(crate) write_parallelism: Option<usize>,
-    pub(crate) allow_external_blob_outside_bases: bool,
 }

 impl std::fmt::Debug for AddDataBuilder {
@@ -88,7 +87,6 @@ impl AddDataBuilder {
            embedding_registry,
            progress_callback: None,
            write_parallelism: None,
-            allow_external_blob_outside_bases: false,
        }
    }

@@ -143,16 +141,6 @@ impl AddDataBuilder {
        self
    }

-    /// Store blob URIs that sit outside registered blob bases.
-    ///
-    /// The row keeps a reference, so the object has to stay readable.
-    /// [`crate::table::Table::fetch_blobs`] reads from that location.
-    /// Defaults to `false`. Local tables only.
-    pub fn allow_external_blob_outside_bases(mut self, allow: bool) -> Self {
-        self.allow_external_blob_outside_bases = allow;
-        self
-    }
-
    pub async fn execute(self) -> Result<AddResult> {
        if self.write_parallelism.map(|p| p == 0).unwrap_or(false) {
            return Err(Error::InvalidInput {
@@ -211,7 +199,6 @@ impl AddDataBuilder {
            write_options: self.write_options,
            mode: self.mode,
            tracker,
-            allow_external_blob_outside_bases: self.allow_external_blob_outside_bases,
        })
    }
 }
@@ -225,7 +212,6 @@ pub struct PreprocessingOutput {
    pub write_options: WriteOptions,
    pub mode: AddDataMode,
    pub tracker: Option<Arc<WriteProgressTracker>>,
-    pub allow_external_blob_outside_bases: bool,
 }

 /// Check that the input schema is valid for insert.
@@ -13,7 +13,7 @@
 //! self-describing -- both are derived from the expression, so a caller writes
 //! neither -- while a kind resolved through a registry cannot be typed without
 //! consulting it. Registered Functions use an exact remote version plus a
-//! schema-level Function binding; unknown newer kinds remain readable and fail
+//! schema-level grouped binding; unknown newer kinds remain readable and fail
 //! closed before mutation.
 //!
 //! [`computed_columns`] and [`computed_column_from_field`] read declarations
@@ -22,7 +22,7 @@
 use std::collections::{BTreeSet, HashMap};
 use std::sync::Arc;

-use arrow_schema::{DataType, Field as ArrowField, Fields, Schema as ArrowSchema, SchemaRef};
+use arrow_schema::{DataType, Field as ArrowField, Schema as ArrowSchema, SchemaRef};
 use datafusion_common::tree_node::TreeNode;
 use datafusion_physical_plan::PhysicalExpr;
 use lance::dataset::NewColumnTransform;
@@ -46,16 +46,16 @@ pub const EXPRESSION_META_KEY: &str = "computed_column.expression";
 /// Field metadata key holding the column's inputs, as a JSON array of names.
 pub const INPUTS_META_KEY: &str = "computed_column.inputs";

-/// Field metadata key holding the Function binding identity.
+/// Field metadata key holding the grouped Function binding identity.
 pub const FUNCTION_BINDING_ID_META_KEY: &str = "computed_column.function.binding_id";

 /// Field metadata key holding this sibling's ordered Function output ordinal.
 pub const FUNCTION_OUTPUT_ORDINAL_META_KEY: &str = "computed_column.function.output_ordinal";

-/// Schema metadata key holding all immutable Function bindings.
+/// Schema metadata key holding all immutable grouped Function bindings.
 pub const FUNCTION_BINDINGS_META_KEY: &str = "lancedb::function_bindings";

-/// Version of the schema-level Function binding envelope.
+/// Version of the schema-level grouped Function binding envelope.
 pub const FUNCTION_BINDINGS_VERSION: u32 = 1;

 /// Value of [`KIND_META_KEY`] for a column defined by a SQL expression.
@@ -81,7 +81,7 @@ pub enum ComputedColumnKind {
        /// The expression.
        expression: String,
    },
-    /// One physical output in an immutable registered-Function
+    /// One physical output in an immutable grouped registered-Function
    /// binding. The full binding lives in schema metadata.
    Function {
        /// Shared immutable binding identity.
@@ -159,7 +159,7 @@ struct FunctionBindingEnvelope {
    bindings: Vec<Value>,
 }

-/// Encode immutable Function bindings for schema-level persistence.
+/// Encode immutable grouped bindings for schema-level persistence.
 pub fn function_bindings_metadata(bindings: &[FunctionBinding]) -> Result<String> {
    let bindings = bindings
        .iter()
@@ -177,7 +177,7 @@ pub fn function_bindings_metadata(bindings: &[FunctionBinding]) -> Result<String
    })
 }

-/// Decode known Function bindings without rewriting their raw schema
+/// Decode known grouped Function bindings without rewriting their raw schema
 /// metadata. Unknown envelope versions fail closed.
 pub fn function_bindings(schema: &ArrowSchema) -> Result<Vec<FunctionBinding>> {
    let Some(envelope) = function_binding_envelope(schema)? else {
@@ -238,15 +238,21 @@ pub(crate) fn ensure_supported_function_metadata(schema: &ArrowSchema) -> Result
                message: format!("duplicate Function binding '{}'", binding.binding_id()),
            });
        }
-        if binding.outputs().is_empty() {
-            return Err(Error::InvalidInput {
-                message: format!("Function binding '{}' has no outputs", binding.binding_id()),
-            });
-        }
-        if binding.function().name.is_empty() || binding.function().version.is_empty() {
+        if binding.revision() == 0 || binding.outputs().is_empty() {
            return Err(Error::InvalidInput {
                message: format!(
-                    "Function binding '{}' has no exact version",
+                    "Function binding '{}' has no immutable revision or outputs",
+                    binding.binding_id()
+                ),
+            });
+        }
+        if binding.function().name.is_empty()
+            || binding.function().version.is_empty()
+            || binding.group_id().is_empty()
+        {
+            return Err(Error::InvalidInput {
+                message: format!(
+                    "Function binding '{}' has no exact version or group identity",
                    binding.binding_id()
                ),
            });
@@ -487,7 +493,9 @@ fn ensure_known_binding_shape(value: &Value) -> Result<()> {
        value,
        &[
            "binding_id",
+            "revision",
            "function",
+            "group_id",
            "inputs",
            "outputs",
            "input_schema",
@@ -578,25 +586,6 @@ fn canonical_input_arrow_type(field: &JsonArrowField) -> Result<String> {
    }
 }

-/// `fixed_size_list<item, size>` -> (`item`, `size`); the comma must sit outside
-/// any nested `<...>`.
-fn split_fixed_size_list(raw: &str) -> Option<(&str, i32)> {
-    let inner = raw.strip_prefix("fixed_size_list<")?.strip_suffix('>')?;
-    let mut depth = 0_u32;
-    let mut separator = None;
-    for (index, byte) in inner.bytes().enumerate() {
-        match byte {
-            b'<' => depth += 1,
-            b'>' => depth = depth.checked_sub(1)?,
-            b',' if depth == 0 => separator = Some(index),
-            _ => {}
-        }
-    }
-    let (item, size) = inner.split_at(separator?);
-    let size: i32 = size[1..].trim().parse().ok()?;
-    (size > 0).then_some((item.trim(), size))
-}
-
 fn parse_output_arrow_type(raw: &str) -> Result<JsonArrowDataType> {
    fn parse(raw: &str) -> Result<JsonArrowDataType> {
        let raw = raw.trim();
@@ -629,16 +618,6 @@ fn parse_output_arrow_type(raw: &str) -> Result<JsonArrowDataType> {
            )]);
            return Ok(data_type);
        }
-        if let Some((inner, size)) = split_fixed_size_list(raw) {
-            let mut data_type = JsonArrowDataType::new("fixed_size_list".to_string());
-            data_type.fields = Some(vec![JsonArrowField::new(
-                "item".to_string(),
-                false,
-                parse(inner)?,
-            )]);
-            data_type.length = Some(i64::from(size));
-            return Ok(data_type);
-        }
        let normalized = match raw {
            "boolean" => "bool",
            "string" => "utf8",
@@ -778,9 +757,12 @@ pub(crate) fn plan_function_application(
            message: "Function application contains fields from a newer contract".into(),
        });
    }
-    if application.function().name.is_empty() || application.function().version.is_empty() {
+    if application.function().name.is_empty()
+        || application.function().version.is_empty()
+        || application.group_id().is_empty()
+    {
        return Err(invalid_function(
-            "Function application requires an exact version",
+            "Function application requires an exact version and group identity",
        ));
    }

@@ -1273,11 +1255,6 @@ pub(crate) fn bind(schema: SchemaRef, column: &str, expression: &str) -> Result<
 /// refresh time: that the expression parses, that every column it reads
 /// exists, and that the target name is free. A declaration that survives this
 /// is one a refresh can always act on.
-///
-/// Each accepted column joins the schema the next one resolves against, so a
-/// batch may declare `a` and then `b = a + 1` in one commit. Refresh order
-/// then matters, and refresh enforces it: `b` is refused while `a` still has
-/// unfilled rows.
 pub(crate) fn plan(schema: SchemaRef, columns: &[(String, String)]) -> Result<Vec<ArrowField>> {
    if columns.is_empty() {
        return Err(Error::InvalidInput {
@@ -1285,11 +1262,11 @@ pub(crate) fn plan(schema: SchemaRef, columns: &[(String, String)]) -> Result<Ve
        });
    }

-    let mut schema = schema;
    let mut fields = Vec::with_capacity(columns.len());
+    let mut declared: Vec<&str> = Vec::with_capacity(columns.len());

    for (name, expression) in columns {
-        if schema.field_with_name(name).is_ok() {
+        if schema.field_with_name(name).is_ok() || declared.contains(&name.as_str()) {
            return Err(Error::ColumnAlreadyExists { name: name.clone() });
        }

@@ -1297,50 +1274,16 @@ pub(crate) fn plan(schema: SchemaRef, columns: &[(String, String)]) -> Result<Ve

        // Declared columns start entirely null, so nullability is a property
        // of the declaration rather than of what the expression yields.
-        let field = ArrowField::new(name, bound.data_type, true)
-            .with_metadata(computed_column_metadata(expression, &bound.inputs));
-        schema = Arc::new(ArrowSchema::new_with_metadata(
-            schema
-                .fields()
-                .iter()
-                .cloned()
-                .chain(std::iter::once(Arc::new(field.clone())))
-                .collect::<Fields>(),
-            schema.metadata().clone(),
-        ));
-        fields.push(field);
+        fields.push(
+            ArrowField::new(name, bound.data_type, true)
+                .with_metadata(computed_column_metadata(expression, &bound.inputs)),
+        );
+        declared.push(name);
    }

    Ok(fields)
 }

-/// Run the schema-level checks of
-/// [`AddColumnsBuilder::computed`](super::AddColumnsBuilder::computed) against
-/// `schema` without committing: the Function-binding guard and the planning of
-/// every declaration. For callers that stage declarations behind other work
-/// and need those rejections before any of it lands.
-///
-/// Only the schema is consulted. Declaring also refuses a table with an LSM
-/// write spec or retained SSTables; that is table state, checked at commit.
-///
-/// ```
-/// # use std::sync::Arc;
-/// # use arrow_schema::{DataType, Field, Schema};
-/// use lancedb::table::computed_columns::validate_declarations;
-///
-/// let schema = Arc::new(Schema::new(vec![Field::new("x", DataType::Int32, false)]));
-/// let declarations = vec![
-///     ("a".to_string(), "x + 1".to_string()),
-///     ("b".to_string(), "a * 2".to_string()),
-/// ];
-/// assert!(validate_declarations(schema.clone(), &declarations).is_ok());
-/// assert!(validate_declarations(schema, &[("c".into(), "random()".into())]).is_err());
-/// ```
-pub fn validate_declarations(schema: SchemaRef, columns: &[(String, String)]) -> Result<()> {
-    ensure_no_function_bindings_for_mutation(schema.as_ref(), "schema evolution")?;
-    plan(schema, columns).map(drop)
-}
-
 /// Build the transform that declares `columns` against `schema`.
 ///
 /// An all-null column is how a binding with no values yet is carried into a
@@ -1379,48 +1322,6 @@ pub(super) async fn add_foreign_kind(table: &crate::Table, name: &str, kind: &st

 #[cfg(test)]
 mod tests {
-    /// The gate's reproducer: the validator applies the same schema-level
-    /// guard declaring does, so a staging caller is refused before it commits
-    /// anything else.
-    #[test]
-    fn test_validate_declarations_matches_schema_admission_barriers() {
-        let schema = Arc::new(ArrowSchema::new_with_metadata(
-            vec![ArrowField::new("x", DataType::Int32, true)],
-            HashMap::from([(
-                FUNCTION_BINDINGS_META_KEY.to_string(),
-                "not valid binding metadata".to_string(),
-            )]),
-        ));
-        let declarations = vec![("a".to_string(), "x + 1".to_string())];
-        assert!(super::validate_declarations(schema, &declarations).is_err());
-    }
-
-    #[test]
-    fn output_arrow_type_grammar_matches_the_shared_golden() {
-        let golden: serde_json::Value = serde_json::from_str(include_str!(
-            "../../tests/fixtures/first_class_functions/v1/arrow_types.json"
-        ))
-        .unwrap();
-        let valid = golden["valid"].as_array().unwrap().iter();
-        for case in valid.chain(golden["server_only"].as_array().unwrap()) {
-            let raw = case["arrow_type"].as_str().unwrap();
-            let parsed = super::parse_output_arrow_type(raw)
-                .unwrap_or_else(|error| panic!("{raw}: {error}"));
-            assert_eq!(
-                serde_json::to_value(&parsed).unwrap(),
-                case["json"],
-                "{raw}"
-            );
-        }
-        for raw in golden["invalid"].as_array().unwrap() {
-            let raw = raw.as_str().unwrap();
-            assert!(
-                super::parse_output_arrow_type(raw).is_err(),
-                "{raw:?} should be rejected"
-            );
-        }
-    }
-
    use arrow_array::record_batch;
    use arrow_schema::DataType;
    use futures::TryStreamExt;
@@ -1637,40 +1538,6 @@ mod tests {
        assert!(declared(&table).await.is_empty());
    }

-    /// A batch may build on itself: one commit, and the later entry's inputs
-    /// name the earlier one.
-    #[tokio::test]
-    async fn test_a_declaration_may_read_one_declared_before_it() {
-        let table = table_with_ints("chain").await;
-        let before = table.version().await.unwrap();
-        add_computed(
-            &table,
-            &[("a".into(), "x + 1".into()), ("b".into(), "a * 2".into())],
-        )
-        .await
-        .unwrap();
-        assert_eq!(table.version().await.unwrap(), before + 1);
-        let declared = declared(&table).await;
-        assert_eq!(declared[1].name, "b");
-        assert_eq!(declared[1].inputs, vec!["a".to_string()]);
-
-        // Order is the dependency order; reading ahead is still unknown.
-        let err = add_computed(
-            &table,
-            &[("c".into(), "d + 1".into()), ("d".into(), "x + 1".into())],
-        )
-        .await
-        .unwrap_err();
-        assert!(matches!(err, Error::InvalidExpression { column, .. } if column == "c"));
-        assert!(
-            validate_declarations(
-                table.schema().await.unwrap(),
-                &[("e".into(), "random()".into())]
-            )
-            .is_err()
-        );
-    }
-
    /// A column added by an ordinary transform is materialized, not bound, so
    /// it carries no declaration to report.
    #[tokio::test]
@@ -2339,6 +2206,7 @@ mod tests {
                    {{"name":"normalized_text","arrow_type":"utf8","nullable":false}},
                    {{"name":"token_count","arrow_type":"int64","nullable":false}}
                ]}},
+                "group_id":"fg_exact",
                "columns":{columns}
            }}"#
        ))
@@ -2519,7 +2387,8 @@ mod tests {
            r#"{
                "function":{"name":"f","version":"fv"},
                "inputs":[{"parameter":"title","kind":"future_source","value":{"path":"title"}}],
-                "output":{"kind":"scalar","arrow_type":"int64","nullable":false}
+                "output":{"kind":"scalar","arrow_type":"int64","nullable":false},
+                "group_id":"fg"
            }"#,
        )
        .unwrap();
@@ -2532,6 +2401,7 @@ mod tests {
                "function":{"name":"f","version":"fv"},
                "inputs":[],
                "output":{"kind":"scalar","arrow_type":"int64","nullable":false},
+                "group_id":"fg",
                "future_declaration":{"mode":"managed"}
            }"#,
        )
@@ -2545,7 +2415,8 @@ mod tests {
            r#"{
                "function":{"name":"f","version":"fv"},
                "inputs":[],
-                "output":{"kind":"scalar","arrow_type":"int64","nullable":false,"assignment":"cell_flag"}
+                "output":{"kind":"scalar","arrow_type":"int64","nullable":false,"assignment":"cell_flag"},
+                "group_id":"fg"
            }"#,
        )
        .unwrap();
@@ -7,7 +7,7 @@

 use std::sync::Arc;

-use arrow_schema::{DataType, Field, FieldRef, Fields};
+use arrow_schema::{DataType, Field, FieldRef};
 use datafusion::functions::core::{get_field, named_struct};
 use datafusion_common::ScalarValue;
 use datafusion_common::config::ConfigOptions;
@@ -35,9 +35,8 @@ pub(super) fn coerce_blob_expr(
        });
    };

-    let input_shape = match input_field.data_type() {
-        DataType::Binary | DataType::LargeBinary | DataType::BinaryView => BlobInputShape::Bytes,
-        DataType::Utf8 | DataType::LargeUtf8 | DataType::Utf8View => BlobInputShape::String,
+    let input_struct_children = match input_field.data_type() {
+        DataType::Binary | DataType::LargeBinary | DataType::BinaryView => None,
        DataType::Struct(children) => {
            if !children
                .iter()
@@ -50,15 +49,13 @@ pub(super) fn coerce_blob_expr(
                    ),
                });
            }
-            BlobInputShape::Struct(children)
+            Some(children)
        }
        other => {
            return Err(Error::InvalidInput {
                message: format!(
                    "cannot coerce column '{}' with type {} into a blob v2 struct. \
-                     expected binary bytes (Binary, LargeBinary, BinaryView), \
-                     strings (Utf8, LargeUtf8, Utf8View), \
-                     or a Struct with a 'data' or 'uri' child",
+                     expected Binary, LargeBinary, BinaryView, or a Struct with a 'data' or 'uri' child",
                    table_field.name(),
                    other,
                ),
@@ -72,8 +69,9 @@ pub(super) fn coerce_blob_expr(
            declared.name().as_str(),
        ))));

-        let value: Arc<dyn PhysicalExpr> = match &input_shape {
-            BlobInputShape::Bytes => {
+        let value: Arc<dyn PhysicalExpr> = match input_struct_children {
+            // Raw binary lands in `data` and everything else is a typed null.
+            None => {
                if declared.name() == "data" {
                    Arc::new(CastExpr::new(
                        input_expr.clone(),
@@ -84,43 +82,30 @@ pub(super) fn coerce_blob_expr(
                    typed_null(declared.data_type())?
                }
            }
-            BlobInputShape::String => {
-                if declared.name() == "uri" {
-                    Arc::new(CastExpr::new(
-                        input_expr.clone(),
-                        declared.data_type().clone(),
-                        None,
-                    ))
-                } else {
-                    typed_null(declared.data_type())?
-                }
-            }
-            BlobInputShape::Struct(children) => {
-                match children.iter().find(|c| c.name() == declared.name()) {
-                    Some(child) => {
-                        let field_expr: Arc<dyn PhysicalExpr> = Arc::new(ScalarFunctionExpr::new(
-                            &format!("get_field({})", declared.name()),
-                            get_field(),
-                            vec![
-                                input_expr.clone(),
-                                Arc::new(Literal::new(ScalarValue::from(declared.name().as_str()))),
-                            ],
-                            Arc::new(child.as_ref().clone()),
-                            config.clone(),
-                        ));
-                        if child.data_type() == declared.data_type() {
-                            field_expr
-                        } else {
-                            Arc::new(CastExpr::new(
-                                field_expr,
-                                declared.data_type().clone(),
-                                None,
-                            ))
-                        }
+            Some(children) => match children.iter().find(|c| c.name() == declared.name()) {
+                Some(child) => {
+                    let field_expr: Arc<dyn PhysicalExpr> = Arc::new(ScalarFunctionExpr::new(
+                        &format!("get_field({})", declared.name()),
+                        get_field(),
+                        vec![
+                            input_expr.clone(),
+                            Arc::new(Literal::new(ScalarValue::from(declared.name().as_str()))),
+                        ],
+                        Arc::new(child.as_ref().clone()),
+                        config.clone(),
+                    ));
+                    if child.data_type() == declared.data_type() {
+                        field_expr
+                    } else {
+                        Arc::new(CastExpr::new(
+                            field_expr,
+                            declared.data_type().clone(),
+                            None,
+                        ))
                    }
-                    None => typed_null(declared.data_type())?,
                }
-            }
+                None => typed_null(declared.data_type())?,
+            },
        };
        ns_args.push(value);
    }
@@ -135,12 +120,6 @@ pub(super) fn coerce_blob_expr(
    Ok((expr, table_field.clone()))
 }

-enum BlobInputShape<'a> {
-    Bytes,
-    String,
-    Struct(&'a Fields),
-}
-
 fn typed_null(data_type: &DataType) -> Result<Arc<dyn PhysicalExpr>> {
    let scalar = ScalarValue::try_from(data_type).map_err(|e| Error::InvalidInput {
        message: format!("cannot build null literal for blob child type {data_type}: {e}"),
@@ -155,7 +134,7 @@ mod tests {
    use crate::blob::blob;
    use arrow_array::{
        Array, ArrayRef, BinaryArray, BinaryViewArray, Int32Array, Int64Array, LargeBinaryArray,
-        RecordBatch, StringArray, StringViewArray, StructArray, UInt8Array, UInt64Array,
+        RecordBatch, StringArray, StructArray, UInt8Array, UInt64Array,
    };
    use arrow_schema::Schema;
    use datafusion::prelude::SessionContext;
@@ -457,78 +436,14 @@ mod tests {
    #[tokio::test]
    async fn unsupported_input_type_is_rejected_with_column_name() {
        let batch = batch_with_image(
-            Field::new("image", DataType::Int64, true),
-            Arc::new(Int64Array::from(vec![42])),
+            Field::new("image", DataType::Utf8, true),
+            Arc::new(StringArray::from(vec!["not bytes"])),
        );
        let err = coerce_err(batch, &blob_table_schema()).await;
        assert!(matches!(err, Error::InvalidInput { .. }), "got {err:?}");
        assert!(err.to_string().contains("image"));
    }

-    #[tokio::test]
-    async fn utf8_string_coerces_to_uri_child() {
-        let batch = batch_with_image(
-            Field::new("image", DataType::Utf8, true),
-            Arc::new(StringArray::from(vec![Some("s3://bucket/key"), None])),
-        );
-        let coerced = coerce(batch, &blob_table_schema()).await;
-        let image = image_struct(&coerced);
-        let uri: &StringArray = image
-            .column_by_name("uri")
-            .unwrap()
-            .as_any()
-            .downcast_ref()
-            .unwrap();
-        assert_eq!(uri.value(0), "s3://bucket/key");
-        assert!(image.column_by_name("data").unwrap().is_null(0));
-        assert!(uri.is_null(1));
-    }
-
-    #[tokio::test]
-    async fn large_utf8_string_coerces_into_four_child_blob_layout() {
-        use arrow_array::LargeStringArray;
-
-        let table_schema = Schema::new(vec![
-            Field::new("id", DataType::Int64, false),
-            wide_blob_field("image"),
-        ]);
-        let batch = batch_with_image(
-            Field::new("image", DataType::LargeUtf8, true),
-            Arc::new(LargeStringArray::from(vec!["file:///tmp/blob.bin"])),
-        );
-        let coerced = coerce(batch, &table_schema).await;
-        let image = image_struct(&coerced);
-        assert_eq!(image.num_columns(), 4);
-        let uri: &StringArray = image
-            .column_by_name("uri")
-            .unwrap()
-            .as_any()
-            .downcast_ref()
-            .unwrap();
-        assert_eq!(uri.value(0), "file:///tmp/blob.bin");
-        assert!(image.column_by_name("data").unwrap().is_null(0));
-        assert!(image.column_by_name("position").unwrap().is_null(0));
-        assert!(image.column_by_name("size").unwrap().is_null(0));
-    }
-
-    #[tokio::test]
-    async fn utf8_view_string_coerces_to_uri_child() {
-        let batch = batch_with_image(
-            Field::new("image", DataType::Utf8View, true),
-            Arc::new(StringViewArray::from(vec![Some("s3://bucket/view-key")])),
-        );
-        let coerced = coerce(batch, &blob_table_schema()).await;
-        let image = image_struct(&coerced);
-        let uri: &StringArray = image
-            .column_by_name("uri")
-            .unwrap()
-            .as_any()
-            .downcast_ref()
-            .unwrap();
-        assert_eq!(uri.value(0), "s3://bucket/view-key");
-        assert!(image.column_by_name("data").unwrap().is_null(0));
-    }
-
    #[tokio::test]
    async fn blob_metadata_survives_cast_of_sibling_column() {
        let batch = RecordBatch::try_new(
@@ -70,9 +70,6 @@ async fn can_execute_namespace_query(table: &NativeTable, query: &AnyQuery) -> R
        .contains(&NamespaceClientPushdownOperation::QueryTable)
        && table.namespace_client.is_some()
        && table.dataset.current_branch().is_none()
-        // NsQueryTableRequest has no version field, so a pushed-down query would
-        // read latest and ignore the pin.
-        && table.dataset.time_travel_version().is_none()
        && !requires_local_namespace_execution(query))
    {
        return Ok(false);
@@ -697,7 +694,6 @@ mod tests {

    use super::*;
    use crate::query::{QueryExecutionOptions, QueryRequest};
-    use crate::table::BaseTable;

    fn fixed_size_list_array(values: Vec<f32>, dimension: i32) -> FixedSizeListArray {
        FixedSizeListArray::try_new_from_values(Float32Array::from(values), dimension).unwrap()
@@ -890,56 +886,10 @@ mod tests {

        async fn query_table(&self, _request: NsQueryTableRequest) -> lance::Result<bytes::Bytes> {
            self.query_table_calls.fetch_add(1, Ordering::SeqCst);
-            panic!("query must not be pushed down to namespace query_table");
+            panic!("approx_mode queries must not be pushed down to namespace query_table");
        }
    }

-    #[tokio::test]
-    async fn test_execute_query_pinned_snapshot_with_namespace_pushdown_runs_locally() {
-        use crate::connect;
-        use arrow_array::{Int32Array, RecordBatch};
-        use arrow_schema::{DataType, Field, Schema};
-
-        let conn = connect("memory://").execute().await.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, 2, 3, 4, 5]))],
-        )
-        .unwrap();
-        let table = conn
-            .create_table("test_pinned_namespace_fallback", vec![batch])
-            .execute()
-            .await
-            .unwrap();
-
-        let namespace_client = Arc::new(CountingNamespaceClient::default());
-        let mut native_table = table.as_native().unwrap().clone();
-        native_table.namespace_client = Some(namespace_client.clone());
-        native_table
-            .pushdown_operations
-            .insert(NamespaceClientPushdownOperation::QueryTable);
-
-        let snapshot = native_table.checkout_current().await.unwrap();
-        let snapshot = snapshot.as_any().downcast_ref::<NativeTable>().unwrap();
-        assert!(snapshot.dataset.time_travel_version().is_some());
-
-        let query = AnyQuery::Query(QueryRequest {
-            filter: Some(QueryFilter::Sql("id > 3".to_string())),
-            ..Default::default()
-        });
-        let stream = execute_query(snapshot, &query, QueryExecutionOptions::default())
-            .await
-            .unwrap();
-        let batches = stream.try_collect::<Vec<_>>().await.unwrap();
-
-        assert_eq!(
-            batches.iter().map(|batch| batch.num_rows()).sum::<usize>(),
-            2
-        );
-        assert_eq!(namespace_client.query_table_calls.load(Ordering::SeqCst), 0);
-    }
-
    #[tokio::test]
    async fn test_execute_query_approx_mode_with_namespace_pushdown_runs_locally() {
        use crate::connect;
@@ -298,7 +298,7 @@ async fn build_read_context(
    for shard_id in shard_ids {
        let manifest_store =
            ShardManifestStore::new(store.clone(), &base_path, shard_id, scan_batch_size);
-        if let Some(manifest) = manifest_store.latest().await? {
+        if let Some(manifest) = manifest_store.read_latest().await? {
            snapshots.push(snapshot_from_manifest(shard_id, &manifest, &exclude));
        }
    }
@@ -7,16 +7,6 @@
 //! therefore idempotent and does not observe input mutation -- once a row is
 //! filled, changing what the expression reads leaves the stored result alone.
 //!
-//! A column's computed inputs are filled first -- the dependency graph is
-//! walked once, each reachable column filled once in dependency order, each
-//! fill its own commit. Every fill in the pass, the requested column's
-//! included, covers only the fragments of the snapshot the pass started
-//! from: a commit may rebase over a concurrent append, and the fragment that
-//! admits carries placeholder nulls no earlier fill covered, so it waits for
-//! a later refresh rather than being read as values. Two concurrent fills of
-//! one input collide on its field in lance's conflict check, so a dependent
-//! fill can only commit over inputs that were durable when it read them.
-//!
 //! 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
@@ -51,8 +41,7 @@ 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, in the requested column only; inputs
-    /// filled on its behalf are not counted.
+    /// Rows that had a value computed.
    #[serde(default)]
    pub rows_filled: u64,
    /// The commit version associated with the operation.
@@ -60,38 +49,18 @@ pub struct RefreshColumnResult {
    pub version: u64,
 }

-struct RefreshExecution {
-    result: RefreshColumnResult,
-    source_version: u64,
-    published_version: Option<u64>,
-}
-
 /// Internal implementation of the refresh logic.
 pub(crate) async fn execute_refresh_column(
    table: &NativeTable,
    column: &str,
 ) -> Result<RefreshColumnResult> {
-    Ok(execute_refresh_column_with_source(table, column)
-        .await?
-        .result)
-}
-
-async fn execute_refresh_column_with_source(
-    table: &NativeTable,
-    column: &str,
-) -> Result<RefreshExecution> {
    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.clone(),
-        column,
-        &expression,
-    )?);
-    ensure_inputs_filled(&dataset, &schema, column, &bound).await?;
+    let bound = Arc::new(super::computed_columns::bind(schema, column, &expression)?);
    let field = dataset
        .schema()
        .field(column)
@@ -117,25 +86,21 @@ async fn execute_refresh_column_with_source(
        replacements.push(fragment.write_columns(values, &column_schema).await?);
    }

-    let source_version = dataset.version().version;
    if replacements.is_empty() {
-        return Ok(RefreshExecution {
-            result: RefreshColumnResult {
-                rows_filled: 0,
-                version: source_version,
-            },
-            source_version,
-            published_version: None,
+        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(source_version),
+        Some(read_version),
        None,
        None,
        session,
@@ -145,62 +110,14 @@ async fn execute_refresh_column_with_source(

    let version = new_dataset.version().version;
    table.dataset.update(new_dataset);
-    Ok(RefreshExecution {
-        result: RefreshColumnResult {
-            rows_filled,
-            version,
-        },
-        source_version,
-        published_version: Some(version),
+    Ok(RefreshColumnResult {
+        rows_filled,
+        version,
    })
 }

-/// Refuse while a computed input still has rows a refresh of it would fill:
-/// read now, its placeholder null would be evaluated as a value and kept.
-async fn ensure_inputs_filled(
-    dataset: &Dataset,
-    schema: &Arc<ArrowSchema>,
-    column: &str,
-    bound: &BoundExpression,
-) -> Result<()> {
-    for input in &bound.roots {
-        let Some(declaration) = schema
-            .field_with_name(input)
-            .ok()
-            .and_then(computed_column_from_field)
-        else {
-            continue;
-        };
-        let ComputedColumnKind::Sql { expression } = &declaration.kind else {
-            return Err(Error::NotSupported {
-                message: format!(
-                    "computed column '{column}' reads '{input}', whose fill state this \
-                     refresh cannot check; refresh '{input}' first"
-                ),
-            });
-        };
-        let input_bound = super::computed_columns::bind(schema.clone(), input, expression)?;
-        let mut unfilled = 0u64;
-        for fragment in dataset.get_fragments() {
-            unfilled += count_fragment_gains(dataset, &fragment, &input_bound, input).await?;
-        }
-        if unfilled > 0 {
-            return Err(Error::InvalidInput {
-                message: format!(
-                    "computed column '{column}' reads '{input}', which has {unfilled} unfilled \
-                     rows; refresh '{input}' first"
-                ),
-            });
-        }
-    }
-    Ok(())
-}
-
 /// Run the refresh as a [`Job`] in this process.
-pub(crate) async fn execute_refresh_column_async(
-    table: &NativeTable,
-    column: &str,
-) -> Result<Job<crate::function::RefreshColumnResult>> {
+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()?;
@@ -212,15 +129,9 @@ pub(crate) async fn execute_refresh_column_async(
    let table = table.clone();
    let column = column.to_string();
    Ok(Job::spawned(tokio::spawn(async move {
-        let execution = execute_refresh_column_with_source(&table, &column).await?;
+        execute_refresh_column(&table, &column).await?;
        table.bump_freshness();
-        Ok(crate::function::RefreshColumnResult {
-            rows_assigned: execution.result.rows_filled,
-            rows_failed: 0,
-            rows_remaining: 0,
-            source_version: execution.source_version,
-            published_version: execution.published_version,
-        })
+        Ok(())
    })))
 }

@@ -442,8 +353,7 @@ mod tests {
            .version)
    }

-    async fn read(table: &Table, column: &str) -> Vec<Option<i64>> {
-        use arrow_array::{Array, Int64Array};
+    async fn read(table: &Table, column: &str) -> Vec<Option<i32>> {
        let batches = table
            .query()
            .select(Select::columns(&[column]))
@@ -453,19 +363,15 @@ mod tests {
            .try_collect::<Vec<_>>()
            .await
            .unwrap();
-        let mut values: Vec<Option<i64>> = batches
+        let mut values: Vec<Option<i32>> = batches
            .iter()
            .flat_map(|batch| {
-                let array = &batch[column];
-                match array.as_any().downcast_ref::<Int32Array>() {
-                    Some(ints) => ints.iter().map(|v| v.map(i64::from)).collect::<Vec<_>>(),
-                    None => array
-                        .as_any()
-                        .downcast_ref::<Int64Array>()
-                        .unwrap()
-                        .iter()
-                        .collect::<Vec<_>>(),
-                }
+                batch[column]
+                    .as_any()
+                    .downcast_ref::<Int32Array>()
+                    .unwrap()
+                    .iter()
+                    .collect::<Vec<_>>()
            })
            .collect();
        values.sort();
@@ -477,98 +383,6 @@ mod tests {
        table.add(batch).execute().await.unwrap();
    }

-    /// The gate's reproducer: `b = coalesce(a, 0)` refreshed before `a`
-    /// must not bake zeros from `a`'s placeholder null. It is refused, and
-    /// names the input, until `a` is filled -- after every append too.
-    #[tokio::test]
-    async fn test_dependent_refresh_refuses_an_unfilled_input() {
-        let table = table_with("dependent_refresh_order", vec![1, 2, 3]).await;
-        table
-            .add_columns()
-            .computed("a", "x + 1")
-            .computed("b", "coalesce(a, 0)")
-            .execute()
-            .await
-            .unwrap();
-
-        let err = table.refresh_column("b").await.unwrap_err();
-        assert!(
-            matches!(&err, Error::InvalidInput { message } if message.contains("refresh 'a' first")),
-            "{err}"
-        );
-        assert_eq!(read(&table, "b").await, vec![None, None, None]);
-
-        assert_eq!(table.refresh_column("a").await.unwrap().rows_filled, 3);
-        assert_eq!(table.refresh_column("b").await.unwrap().rows_filled, 3);
-        assert_eq!(read(&table, "b").await, vec![Some(2), Some(3), Some(4)]);
-
-        append(&table, vec![10]).await;
-        assert!(table.refresh_column("b").await.is_err());
-        table.refresh_column("a").await.unwrap();
-        assert_eq!(table.refresh_column("b").await.unwrap().rows_filled, 1);
-        assert_eq!(
-            table.count_rows(Some("b = 0".to_string())).await.unwrap(),
-            0
-        );
-    }
-
-    /// Names that need quoting, and a nested input, survive the trip through
-    /// declaration metadata and the dependency check: the recorded inputs
-    /// are matched by name, never re-parsed as SQL.
-    #[tokio::test]
-    async fn test_dependent_refresh_handles_awkward_column_names() {
-        use arrow_array::{Int32Array, StructArray};
-        use arrow_schema::{DataType, Field, Fields};
-
-        let conn = connect("memory://").execute().await.unwrap();
-        let age_fields = Fields::from(vec![Field::new("age", DataType::Int32, true)]);
-        let meta = StructArray::new(
-            age_fields.clone(),
-            vec![Arc::new(Int32Array::from(vec![10, 20])) as _],
-            None,
-        );
-        let schema = Arc::new(arrow_schema::Schema::new(vec![
-            Field::new("camelCase", DataType::Int32, true),
-            Field::new("with-hyphen", DataType::Int32, true),
-            Field::new("meta", DataType::Struct(age_fields), true),
-        ]));
-        let batch = arrow_array::RecordBatch::try_new(
-            schema,
-            vec![
-                Arc::new(Int32Array::from(vec![1, 2])) as _,
-                Arc::new(Int32Array::from(vec![100, 200])) as _,
-                Arc::new(meta) as _,
-            ],
-        )
-        .unwrap();
-        let table = conn
-            .create_table("awkward_names", batch)
-            .execute()
-            .await
-            .unwrap();
-
-        table
-            .add_columns()
-            .computed("y", "`camelCase` * 2")
-            .computed("z", "coalesce(y, 0) + `with-hyphen` + meta.age")
-            .execute()
-            .await
-            .unwrap();
-        let z = crate::table::computed_columns::computed_columns(
-            table.schema().await.unwrap().as_ref(),
-        )
-        .into_iter()
-        .find(|c| c.name == "z")
-        .unwrap();
-        assert_eq!(z.inputs, vec!["meta.age", "with-hyphen", "y"]);
-
-        let err = table.refresh_column("z").await.unwrap_err();
-        assert!(err.to_string().contains("refresh 'y' first"), "{err}");
-        assert_eq!(table.refresh_column("y").await.unwrap().rows_filled, 2);
-        assert_eq!(table.refresh_column("z").await.unwrap().rows_filled, 2);
-        assert_eq!(read(&table, "z").await, vec![Some(112), Some(224)]);
-    }
-
    #[tokio::test]
    async fn test_refresh_fills_a_declared_column() {
        let table = table_with("refresh_fills", vec![1, 2, 3]).await;
@@ -582,17 +396,6 @@ mod tests {
            read(&table, "doubled").await,
            vec![Some(2), Some(4), Some(6)]
        );
-
-        let no_op = table
-            .refresh_column_async("doubled")
-            .await
-            .unwrap()
-            .wait()
-            .await
-            .unwrap();
-        assert_eq!(no_op.rows_assigned, 0);
-        assert_eq!(no_op.source_version, 3);
-        assert_eq!(no_op.published_version, None);
    }

    /// Values written after the last refresh must be reachable by another one.
@@ -806,8 +609,7 @@ mod tests {

        let read_back = read(&table, "doubled").await;
        assert_eq!(read_back.len(), 20_000);
-        let mut expected: Vec<Option<i64>> =
-            values.iter().map(|v| Some(i64::from(v * 2))).collect();
+        let mut expected: Vec<Option<i32>> = values.iter().map(|v| Some(v * 2)).collect();
        expected.sort();
        assert_eq!(read_back, expected);
    }
@@ -844,12 +646,7 @@ mod tests {

        let job = table.refresh_column_async("doubled").await.unwrap();
        assert!(job.id().is_none(), "in-process jobs have no server id");
-        let result = job.wait().await.unwrap();
-        assert_eq!(result.rows_assigned, 3);
-        assert_eq!(result.rows_failed, 0);
-        assert_eq!(result.rows_remaining, 0);
-        assert_eq!(result.source_version, 2);
-        assert_eq!(result.published_version, Some(3));
+        job.wait().await.unwrap();
        assert_eq!(job.status().await.unwrap(), "finished");
        assert_eq!(
            read(&table, "doubled").await,
@@ -875,9 +672,9 @@ mod tests {
        declare_doubled(&table).await.unwrap();

        let job = table.refresh_column_async("doubled").await.unwrap();
-        let first = job.wait().await.unwrap();
+        job.wait().await.unwrap();
        // A second wait after completion observes the same outcome.
-        assert_eq!(job.wait().await.unwrap(), first);
+        job.wait().await.unwrap();
        assert_eq!(job.status().await.unwrap(), "finished");
    }

@@ -5,14 +5,12 @@ use std::sync::Arc;

 use arrow_array::{
    Array, ArrayRef, BinaryArray, Int64Array, LargeBinaryArray, RecordBatch, StringArray,
-    StructArray, UInt64Array, new_null_array,
+    StructArray, UInt64Array,
 };
 use arrow_schema::{DataType, Field, Fields, Schema};
 use futures::TryStreamExt;
 use lance::Dataset;
-use lance::dataset::WriteParams;
 use lance_file::version::{ConcreteFileVersion, LanceFileVersion};
-use lance_table::format::BasePath;
 use lancedb::{
    Connection, Error, Result, Table,
    blob::{BlobRangeRequest, blob},
@@ -21,7 +19,7 @@ use lancedb::{
        ListingDatabaseOptions, NewTableConfig, OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS,
    },
    query::{ExecutableQuery, QueryBase},
-    table::{AddDataMode, CompactionOptions, OptimizeAction, OptimizeStats, WriteOptions},
+    table::{AddDataMode, CompactionOptions, OptimizeAction, OptimizeStats},
 };
 use tempfile::tempdir;

@@ -263,11 +261,11 @@ async fn add_rejects_uncoercible_blob_input() -> Result<()> {
    let batch = RecordBatch::try_new(
        Arc::new(Schema::new(vec![
            Field::new("id", DataType::Int64, false),
-            Field::new("image", DataType::Int64, true),
+            Field::new("image", DataType::Utf8, true),
        ])),
        vec![
            Arc::new(Int64Array::from(vec![1])),
-            Arc::new(Int64Array::from(vec![42])),
+            Arc::new(StringArray::from(vec!["not bytes"])),
        ],
    )
    .unwrap();
@@ -1334,223 +1332,3 @@ async fn optimize_preserves_blob_v2_null_and_empty_distinction() -> Result<()> {
    );
    Ok(())
 }
-
-fn uri_struct_batch(id: i64, uri: &str) -> RecordBatch {
-    let image_field = blob("image", true);
-    let DataType::Struct(child_fields) = image_field.data_type().clone() else {
-        unreachable!("blob field is a struct");
-    };
-    let children: Vec<ArrayRef> = child_fields
-        .iter()
-        .map(|field| match field.name().as_str() {
-            "uri" => Arc::new(StringArray::from(vec![Some(uri)])) as ArrayRef,
-            _ => new_null_array(field.data_type(), 1),
-        })
-        .collect();
-    let image = StructArray::new(child_fields, children, None);
-    RecordBatch::try_new(
-        Arc::new(Schema::new(vec![
-            Field::new("id", DataType::Int64, false),
-            image_field,
-        ])),
-        vec![Arc::new(Int64Array::from(vec![id])), Arc::new(image)],
-    )
-    .unwrap()
-}
-
-fn uri_string_batch(id: i64, uri: &str) -> RecordBatch {
-    RecordBatch::try_new(
-        Arc::new(Schema::new(vec![
-            Field::new("id", DataType::Int64, false),
-            Field::new("image", DataType::Utf8, true),
-        ])),
-        vec![
-            Arc::new(Int64Array::from(vec![id])),
-            Arc::new(StringArray::from(vec![Some(uri)])),
-        ],
-    )
-    .unwrap()
-}
-
-fn write_payload_file_uri(dir: &std::path::Path, name: &str, payload: &[u8]) -> String {
-    let path = dir.join(name);
-    std::fs::write(&path, payload).unwrap();
-    url::Url::from_file_path(&path).unwrap().to_string()
-}
-
-#[tokio::test]
-async fn external_uri_struct_round_trips_with_flag() -> Result<()> {
-    let tmp = tempdir().unwrap();
-    let db = connect(tmp.path().join("db").to_str().unwrap())
-        .execute()
-        .await?;
-    let payload: &[u8] = b"external-struct-payload";
-    let uri = write_payload_file_uri(tmp.path(), "payload.bin", payload);
-    let table = db
-        .create_empty_table("t", blob_table_schema())
-        .execute()
-        .await?;
-
-    table
-        .add(uri_struct_batch(1, &uri))
-        .allow_external_blob_outside_bases(true)
-        .execute()
-        .await?;
-
-    let ids = collect_row_ids(&table).await?;
-    let bytes = table.fetch_blobs("image", &ids).await?;
-    assert_eq!(bytes.value(0), payload);
-    Ok(())
-}
-
-#[tokio::test]
-async fn external_uri_add_requires_opt_in() -> Result<()> {
-    let tmp = tempdir().unwrap();
-    let db = connect(tmp.path().join("db").to_str().unwrap())
-        .execute()
-        .await?;
-    let uri = write_payload_file_uri(tmp.path(), "payload.bin", b"unreachable");
-    let table = db
-        .create_empty_table("t", blob_table_schema())
-        .execute()
-        .await?;
-
-    let err = table
-        .add(uri_struct_batch(1, &uri))
-        .execute()
-        .await
-        .unwrap_err();
-
-    assert!(
-        err.to_string()
-            .contains("allow_external_blob_outside_bases"),
-        "got: {err}"
-    );
-    assert_eq!(table.count_rows(None).await?, 0);
-    Ok(())
-}
-
-#[tokio::test]
-async fn string_uri_input_round_trips_as_external_reference() -> Result<()> {
-    let tmp = tempdir().unwrap();
-    let db = connect(tmp.path().join("db").to_str().unwrap())
-        .execute()
-        .await?;
-    let payload: &[u8] = b"external-string-payload";
-    let uri = write_payload_file_uri(tmp.path(), "payload.bin", payload);
-    let table = db
-        .create_empty_table("t", blob_table_schema())
-        .execute()
-        .await?;
-
-    table
-        .add(uri_string_batch(1, &uri))
-        .allow_external_blob_outside_bases(true)
-        .execute()
-        .await?;
-
-    let ids = collect_row_ids(&table).await?;
-    let bytes = table.fetch_blobs("image", &ids).await?;
-    assert_eq!(bytes.value(0), payload);
-
-    let files = table.fetch_blob_files("image", &ids).await?;
-    let file = files[0].as_ref().expect("missing blob file");
-    assert_eq!(file.uri(), Some(uri.as_str()));
-    Ok(())
-}
-
-#[tokio::test]
-async fn string_uri_inside_registered_base_does_not_need_the_flag() -> Result<()> {
-    let tmp = tempdir().unwrap();
-    let db_path = tmp.path().join("db");
-    let external_base = tmp.path().join("external_base");
-    let object_dir = external_base.join("objects");
-    std::fs::create_dir_all(&object_dir).unwrap();
-    let payload: &[u8] = b"mapped-in-base";
-    let object_path = object_dir.join("mapped.bin");
-    std::fs::write(&object_path, payload).unwrap();
-    let object_uri = url::Url::from_file_path(&object_path).unwrap().to_string();
-    let base_uri = url::Url::from_file_path(&external_base)
-        .unwrap()
-        .to_string();
-
-    let db = connect(db_path.to_str().unwrap()).execute().await?;
-    let table = db
-        .create_empty_table("t", blob_table_schema())
-        .write_options(WriteOptions {
-            lance_write_params: Some(WriteParams {
-                initial_bases: Some(vec![BasePath {
-                    id: 1,
-                    name: Some("external".to_string()),
-                    path: base_uri,
-                    is_dataset_root: false,
-                }]),
-                ..Default::default()
-            }),
-        })
-        .execute()
-        .await?;
-
-    table
-        .add(uri_string_batch(1, &object_uri))
-        .execute()
-        .await?;
-
-    let ids = collect_row_ids(&table).await?;
-    let bytes = table.fetch_blobs("image", &ids).await?;
-    assert_eq!(bytes.value(0), payload);
-    Ok(())
-}
-
-#[tokio::test]
-async fn external_uri_rows_mix_with_inline_rows() -> Result<()> {
-    let tmp = tempdir().unwrap();
-    let db = connect(tmp.path().join("db").to_str().unwrap())
-        .execute()
-        .await?;
-    let external_payload: &[u8] = b"external-bytes";
-    let uri = write_payload_file_uri(tmp.path(), "payload.bin", external_payload);
-    let table =
-        create_inline_blob_table(&db, "t", &[1], &[Some(b"inline-bytes".as_slice())]).await?;
-
-    table
-        .add(uri_string_batch(2, &uri))
-        .allow_external_blob_outside_bases(true)
-        .execute()
-        .await?;
-
-    let pairs = collect_id_rowid(&table).await?;
-    let row_ids: Vec<u64> = pairs.iter().map(|(_, r)| *r).collect();
-    let bytes = table.fetch_blobs("image", &row_ids).await?;
-    for (i, (id, _)) in pairs.iter().enumerate() {
-        match id {
-            1 => assert_eq!(bytes.value(i), b"inline-bytes"),
-            2 => assert_eq!(bytes.value(i), external_payload),
-            _ => unreachable!(),
-        }
-    }
-    Ok(())
-}
-
-#[tokio::test]
-async fn malformed_string_uri_is_rejected_at_write() -> Result<()> {
-    let tmp = tempdir().unwrap();
-    let db = connect(tmp.path().join("db").to_str().unwrap())
-        .execute()
-        .await?;
-    let table = db
-        .create_empty_table("t", blob_table_schema())
-        .execute()
-        .await?;
-
-    let err = table
-        .add(uri_string_batch(1, "not a uri"))
-        .allow_external_blob_outside_bases(true)
-        .execute()
-        .await
-        .unwrap_err();
-
-    assert!(err.to_string().contains("not a uri"), "got: {err}");
-    assert_eq!(table.count_rows(None).await?, 0);
-    Ok(())
-}
@@ -20,6 +20,25 @@ fn job_result(name: &str) -> Value {
    serde_json::from_str::<Value>(&fixture(name)).expect("remote Job fixture")["result"].clone()
 }

+fn assert_no_secret_values(value: &Value) {
+    match value {
+        Value::Object(values) => {
+            for (key, value) in values {
+                assert!(
+                    !matches!(
+                        key.as_str(),
+                        "secret_value" | "secret_values" | "resolved_secret" | "resolved_secrets"
+                    ),
+                    "client canonical value must not model resolved secret material"
+                );
+                assert_no_secret_values(value);
+            }
+        }
+        Value::Array(values) => values.iter().for_each(assert_no_secret_values),
+        _ => {}
+    }
+}
+
 #[test]
 fn function_version_job_result_matches_shared_canonical_golden() {
    let result = job_result("remote_function_job.json");
@@ -28,6 +47,7 @@ fn function_version_job_result_matches_shared_canonical_golden() {
    assert_eq!(version.name(), "embed");
    assert_eq!(version.version(), "fv_01K3EXACT");
    assert_eq!(version.runtime_digest(), "sha256:runtime");
+    assert_eq!(version.required_secrets(), &["HF_TOKEN"]);
    assert_eq!(
        version.to_canonical_json().expect("canonical JSON"),
        fixture("remote_function_version.canonical.json").trim()
@@ -64,6 +84,7 @@ fn application_and_binding_match_shared_remote_goldens() {

    let binding = FunctionBinding::from_json(&fixture("remote_function_binding.json"))
        .expect("binding fixture");
+    assert_eq!(binding.revision(), 3);
    assert_eq!(binding.function().version, "fv_01K3TEXT");
    assert_eq!(binding.outputs()[0].output_ordinal, 0);
    assert_eq!(binding.outputs()[1].output_ordinal, 1);
@@ -142,3 +163,21 @@ fn floating_point_application_literals_are_rejected_consistently() {
            .contains("floating-point Function literals")
    );
 }
+
+#[test]
+fn canonical_client_values_contain_secret_names_only() {
+    let result = job_result("remote_function_job.json");
+    let version = FunctionVersion::from_json(&result.to_string()).expect("FunctionVersion result");
+    let canonical: Value = serde_json::from_str(
+        &version
+            .to_canonical_json()
+            .expect("canonical FunctionVersion"),
+    )
+    .expect("canonical JSON");
+
+    assert_eq!(
+        canonical["required_secrets"],
+        serde_json::json!(["HF_TOKEN"])
+    );
+    assert_no_secret_values(&canonical);
+}
@@ -6,6 +6,7 @@ use std::path::PathBuf;

 use lancedb::Error;
 use lancedb::function::FunctionRegistrationRequest;
+use serde_json::Value;

 fn fixture(name: &str) -> String {
    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
@@ -14,6 +15,25 @@ fn fixture(name: &str) -> String {
    fs::read_to_string(path).expect("fixture must be readable")
 }

+fn assert_no_secret_values(value: &Value) {
+    match value {
+        Value::Object(values) => {
+            for (key, value) in values {
+                assert!(
+                    !matches!(
+                        key.as_str(),
+                        "secret_value" | "secret_values" | "resolved_secret" | "resolved_secrets"
+                    ),
+                    "registration requests must not model resolved secret material"
+                );
+                assert_no_secret_values(value);
+            }
+        }
+        Value::Array(values) => values.iter().for_each(assert_no_secret_values),
+        _ => {}
+    }
+}
+
 #[test]
 fn registration_request_matches_shared_canonical_golden() {
    let request = FunctionRegistrationRequest::from_json(&fixture(
@@ -22,10 +42,16 @@ fn registration_request_matches_shared_canonical_golden() {
    .expect("registration request");
    assert_eq!(request.name, "normalize_score");
    assert_eq!(request.artifact.adapter.kind, "scalar_to_arrow_batch");
+    assert_eq!(request.required_secrets, ["API_TOKEN"]);
    assert_eq!(
        request.to_canonical_json().expect("canonical request"),
        fixture("remote_function_registration_request.canonical.json").trim()
    );
+
+    let value: Value =
+        serde_json::from_str(&request.to_canonical_json().expect("canonical request"))
+            .expect("request JSON");
+    assert_no_secret_values(&value);
 }

 #[tokio::test]
@@ -1,333 +0,0 @@
-{
-  "valid": [
-    {
-      "arrow_type": "bool",
-      "json": {
-        "type": "bool"
-      }
-    },
-    {
-      "arrow_type": "int8",
-      "json": {
-        "type": "int8"
-      }
-    },
-    {
-      "arrow_type": "int16",
-      "json": {
-        "type": "int16"
-      }
-    },
-    {
-      "arrow_type": "int32",
-      "json": {
-        "type": "int32"
-      }
-    },
-    {
-      "arrow_type": "int64",
-      "json": {
-        "type": "int64"
-      }
-    },
-    {
-      "arrow_type": "uint8",
-      "json": {
-        "type": "uint8"
-      }
-    },
-    {
-      "arrow_type": "uint16",
-      "json": {
-        "type": "uint16"
-      }
-    },
-    {
-      "arrow_type": "uint32",
-      "json": {
-        "type": "uint32"
-      }
-    },
-    {
-      "arrow_type": "uint64",
-      "json": {
-        "type": "uint64"
-      }
-    },
-    {
-      "arrow_type": "float16",
-      "json": {
-        "type": "float16"
-      }
-    },
-    {
-      "arrow_type": "float32",
-      "json": {
-        "type": "float32"
-      }
-    },
-    {
-      "arrow_type": "float64",
-      "json": {
-        "type": "float64"
-      }
-    },
-    {
-      "arrow_type": "utf8",
-      "json": {
-        "type": "utf8"
-      }
-    },
-    {
-      "arrow_type": "binary",
-      "json": {
-        "type": "binary"
-      }
-    },
-    {
-      "arrow_type": "date32",
-      "json": {
-        "type": "date32"
-      }
-    },
-    {
-      "arrow_type": "date64",
-      "json": {
-        "type": "date64"
-      }
-    },
-    {
-      "arrow_type": "list<float32>",
-      "json": {
-        "type": "list",
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "float32"
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "large_list<float32>",
-      "json": {
-        "type": "large_list",
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "float32"
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "list<int64>",
-      "json": {
-        "type": "list",
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "int64"
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "large_list<int64>",
-      "json": {
-        "type": "large_list",
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "int64"
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "list<utf8>",
-      "json": {
-        "type": "list",
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "utf8"
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "large_list<utf8>",
-      "json": {
-        "type": "large_list",
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "utf8"
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "fixed_size_list<float32, 384>",
-      "json": {
-        "type": "fixed_size_list",
-        "length": 384,
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "float32"
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "fixed_size_list<float16, 8>",
-      "json": {
-        "type": "fixed_size_list",
-        "length": 8,
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "float16"
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "fixed_size_list<uint8, 1>",
-      "json": {
-        "type": "fixed_size_list",
-        "length": 1,
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "uint8"
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "list<list<float32>>",
-      "json": {
-        "type": "list",
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "list",
-              "fields": [
-                {
-                  "name": "item",
-                  "nullable": false,
-                  "type": {
-                    "type": "float32"
-                  }
-                }
-              ]
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "fixed_size_list<list<int32>, 2>",
-      "json": {
-        "type": "fixed_size_list",
-        "length": 2,
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "list",
-              "fields": [
-                {
-                  "name": "item",
-                  "nullable": false,
-                  "type": {
-                    "type": "int32"
-                  }
-                }
-              ]
-            }
-          }
-        ]
-      }
-    },
-    {
-      "arrow_type": "list<fixed_size_list<float32, 3>>",
-      "json": {
-        "type": "list",
-        "fields": [
-          {
-            "name": "item",
-            "nullable": false,
-            "type": {
-              "type": "fixed_size_list",
-              "length": 3,
-              "fields": [
-                {
-                  "name": "item",
-                  "nullable": false,
-                  "type": {
-                    "type": "float32"
-                  }
-                }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  ],
-  "server_only": [
-    {
-      "arrow_type": "null",
-      "json": {
-        "type": "null"
-      }
-    }
-  ],
-  "invalid": [
-    "",
-    "list<>",
-    "list<float32",
-    "fixed_size_list<float32>[3]",
-    "fixed_size_list<float32>",
-    "fixed_size_list<float32, 0>",
-    "fixed_size_list<float32, x>",
-    "map<utf8, int32>",
-    "decimal128(10, 2)",
-    "timestamp[us]",
-    "struct<a: int32>"
-  ]
-}
@@ -1,78 +0,0 @@
-{
-  "new_columns": [
-    {
-      "name": "embedding",
-      "all_null": true
-    }
-  ],
-  "function": {
-    "application": {
-      "function": {
-        "name": "embed",
-        "version": "fv_01K3EXACT"
-      },
-      "inputs": [
-        {
-          "parameter": "text",
-          "kind": "column",
-          "value": {
-            "path": "description"
-          }
-        }
-      ],
-      "output": {
-        "kind": "scalar",
-        "arrow_type": "fixed_size_list<float32, 3>",
-        "nullable": false
-      }
-    },
-    "binding_metadata_version": 1,
-    "input_bindings": [
-      {
-        "parameter": "text",
-        "field_path": "description",
-        "arrow_type": "utf8",
-        "nullable": true
-      }
-    ],
-    "input_schema": {
-      "fields": [
-        {
-          "name": "text",
-          "nullable": true,
-          "type": {
-            "type": "utf8"
-          }
-        }
-      ]
-    },
-    "output_schema": {
-      "fields": [
-        {
-          "name": "embedding",
-          "nullable": true,
-          "type": {
-            "type": "fixed_size_list",
-            "length": 3,
-            "fields": [
-              {
-                "name": "item",
-                "nullable": false,
-                "type": {
-                  "type": "float32"
-                }
-              }
-            ]
-          }
-        }
-      ]
-    },
-    "outputs": [
-      {
-        "result_field": "$value",
-        "output_name": "embedding",
-        "output_ordinal": 0
-      }
-    ]
-  }
-}
@@ -1 +1 @@
-{"columns":{"normalized_text":"search_text","token_count":"search_token_count"},"function":{"name":"text_features","version":"fv_01K3TEXT"},"inputs":[{"kind":"column","parameter":"title","value":{"path":"title"}},{"kind":"column","parameter":"body","value":{"path":"body"}}],"output":{"fields":[{"arrow_type":"utf8","name":"normalized_text","nullable":false},{"arrow_type":"int64","name":"token_count","nullable":false}],"kind":"named_struct"}}
+{"columns":{"normalized_text":"search_text","token_count":"search_token_count"},"function":{"name":"text_features","version":"fv_01K3TEXT"},"group_id":"fg_01K3TEXT","inputs":[{"kind":"column","parameter":"title","value":{"path":"title"}},{"kind":"column","parameter":"body","value":{"path":"body"}}],"output":{"fields":[{"arrow_type":"utf8","name":"normalized_text","nullable":false},{"arrow_type":"int64","name":"token_count","nullable":false}],"kind":"named_struct"}}
@@ -11,6 +11,7 @@
      {"name": "token_count", "arrow_type": "int64", "nullable": false}
    ]
  },
+  "group_id": "fg_01K3TEXT",
  "columns": {
    "normalized_text": "search_text",
    "token_count": "search_token_count"
@@ -3,5 +3,6 @@
  "inputs": [
    {"parameter": "threshold", "kind": "literal", "value": 1e-7}
  ],
-  "output": {"kind": "scalar", "arrow_type": "bool", "nullable": false}
+  "output": {"kind": "scalar", "arrow_type": "bool", "nullable": false},
+  "group_id": "fg_01K3FLOAT"
 }
@@ -1 +1 @@
-{"binding_id":"fb_01K3TEXT","function":{"name":"text_features","version":"fv_01K3TEXT"},"input_schema":{"fields":[{"name":"title","nullable":true,"type":{"type":"utf8"}},{"name":"body","nullable":true,"type":{"type":"utf8"}}]},"inputs":[{"arrow_type":"utf8","field_id":11,"field_path":"title","nullable":true,"parameter":"title"},{"arrow_type":"utf8","field_id":12,"field_path":"body","nullable":true,"parameter":"body"}],"output_schema":{"fields":[{"name":"search_text","nullable":true,"type":{"type":"utf8"}},{"name":"search_token_count","nullable":true,"type":{"type":"int64"}}]},"outputs":[{"arrow_type":"utf8","nullable":false,"output_field_id":21,"output_name":"search_text","output_ordinal":0,"result_field":"normalized_text"},{"arrow_type":"int64","nullable":false,"output_field_id":22,"output_name":"search_token_count","output_ordinal":1,"result_field":"token_count"}]}
+{"binding_id":"fb_01K3TEXT","function":{"name":"text_features","version":"fv_01K3TEXT"},"group_id":"fg_01K3TEXT","input_schema":{"fields":[{"name":"title","nullable":true,"type":{"type":"utf8"}},{"name":"body","nullable":true,"type":{"type":"utf8"}}]},"inputs":[{"arrow_type":"utf8","field_id":11,"field_path":"title","nullable":true,"parameter":"title"},{"arrow_type":"utf8","field_id":12,"field_path":"body","nullable":true,"parameter":"body"}],"output_schema":{"fields":[{"name":"search_text","nullable":true,"type":{"type":"utf8"}},{"name":"search_token_count","nullable":true,"type":{"type":"int64"}}]},"outputs":[{"arrow_type":"utf8","nullable":false,"output_field_id":21,"output_name":"search_text","output_ordinal":0,"result_field":"normalized_text"},{"arrow_type":"int64","nullable":false,"output_field_id":22,"output_name":"search_token_count","output_ordinal":1,"result_field":"token_count"}],"revision":3}
@@ -1,6 +1,8 @@
 {
  "binding_id": "fb_01K3TEXT",
+  "revision": 3,
  "function": {"name": "text_features", "version": "fv_01K3TEXT"},
+  "group_id": "fg_01K3TEXT",
  "inputs": [
    {"parameter": "title", "field_id": 11, "field_path": "title", "arrow_type": "utf8", "nullable": true},
    {"parameter": "body", "field_id": 12, "field_path": "body", "arrow_type": "utf8", "nullable": true}
@@ -21,5 +23,5 @@
      {"name": "search_token_count", "nullable": true, "type": {"type": "int64"}}
    ]
  },
-  "future_binding": {"mode": "managed"}
+  "future_binding": {"metadata_revision": 1}
 }
--- a/Show More
+++ b/Show More