@query-farm/vgi 0.28.0 → 0.29.0

package/dist/worker-cf-entry.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -36,6 +37,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/arrow/predicates.ts
 function isNull(t) {
@@ -179,7 +181,9 @@ import {
   Float32 as A_Float32,
   Float64 as A_Float64,
   Utf8 as A_Utf8,
+  LargeUtf8 as A_LargeUtf8,
   Binary as A_Binary,
+  LargeBinary as A_LargeBinary,
   Decimal as A_Decimal,
   Date_ as A_Date,
   Time as A_Time,
@@ -267,7 +271,7 @@ function union(mode, children, typeIds) {
 function isField(x) {
   return typeof x.name === "string" && x.type != null;
 }
-var TimeUnit, DateUnit, IntervalUnit, UnionMode, nullType = () => new A_Null, bool = () => new A_Bool, int8 = () => new A_Int8, int16 = () => new A_Int16, int32 = () => new A_Int32, int64 = () => new A_Int64, uint8 = () => new A_Uint8, uint16 = () => new A_Uint16, uint32 = () => new A_Uint32, uint64 = () => new A_Uint64, float16 = () => new A_Float16, float32 = () => new A_Float32, float64 = () => new A_Float64, utf8 = () => new A_Utf8, binary = () => new A_Binary, fixedSizeBinary = (byteWidth) => new A_FixedSizeBinary(byteWidth), decimal128 = (precision, scale) => decimal(precision, scale, 128), decimal256 = (precision, scale) => decimal(precision, scale, 256), date = (unit = A_DateUnit.MILLISECOND) => new A_Date(unit), dateDay = () => date(A_DateUnit.DAY), dateMillisecond = () => date(A_DateUnit.MILLISECOND), timeSecond = () => time(A_TimeUnit.SECOND, 32), timeMillisecond = () => time(A_TimeUnit.MILLISECOND, 32), timeMicrosecond = () => time(A_TimeUnit.MICROSECOND, 64), timeNanosecond = () => time(A_TimeUnit.NANOSECOND, 64), timestamp = (unit = A_TimeUnit.MILLISECOND, timezone = null) => new A_Timestamp(unit, timezone), duration = (unit = A_TimeUnit.MILLISECOND) => new A_Duration(unit), interval = (unit = A_IntervalUnit.MONTH_DAY_NANO) => new A_Interval(unit), sparseUnion = (children, typeIds) => union(A_UnionMode.Sparse, children, typeIds), denseUnion = (children, typeIds) => union(A_UnionMode.Dense, children, typeIds);
+var TimeUnit, DateUnit, IntervalUnit, UnionMode, nullType = () => new A_Null, bool = () => new A_Bool, int8 = () => new A_Int8, int16 = () => new A_Int16, int32 = () => new A_Int32, int64 = () => new A_Int64, uint8 = () => new A_Uint8, uint16 = () => new A_Uint16, uint32 = () => new A_Uint32, uint64 = () => new A_Uint64, float16 = () => new A_Float16, float32 = () => new A_Float32, float64 = () => new A_Float64, utf8 = () => new A_Utf8, largeUtf8 = () => new A_LargeUtf8, binary = () => new A_Binary, largeBinary = () => new A_LargeBinary, fixedSizeBinary = (byteWidth) => new A_FixedSizeBinary(byteWidth), decimal128 = (precision, scale) => decimal(precision, scale, 128), decimal256 = (precision, scale) => decimal(precision, scale, 256), date = (unit = A_DateUnit.MILLISECOND) => new A_Date(unit), dateDay = () => date(A_DateUnit.DAY), dateMillisecond = () => date(A_DateUnit.MILLISECOND), timeSecond = () => time(A_TimeUnit.SECOND, 32), timeMillisecond = () => time(A_TimeUnit.MILLISECOND, 32), timeMicrosecond = () => time(A_TimeUnit.MICROSECOND, 64), timeNanosecond = () => time(A_TimeUnit.NANOSECOND, 64), timestamp = (unit = A_TimeUnit.MILLISECOND, timezone = null) => new A_Timestamp(unit, timezone), duration = (unit = A_TimeUnit.MILLISECOND) => new A_Duration(unit), interval = (unit = A_IntervalUnit.MONTH_DAY_NANO) => new A_Interval(unit), sparseUnion = (children, typeIds) => union(A_UnionMode.Sparse, children, typeIds), denseUnion = (children, typeIds) => union(A_UnionMode.Dense, children, typeIds);
 var init_schema = __esm(() => {
   TimeUnit = {
     SECOND: A_TimeUnit.SECOND,
@@ -1529,13 +1533,19 @@ function batchToSecretDict(batch) {
 }
 function safeNumber(value) {
   if (typeof value === "bigint") {
+    if (value > MAX_SAFE || value < MIN_SAFE) {
+      throw new RangeError(`${value} cannot be represented exactly as a JS number ` + `(|value| > Number.MAX_SAFE_INTEGER). Keep it as a bigint.`);
+    }
     return Number(value);
   }
   return value;
 }
+var MAX_SAFE, MIN_SAFE;
 var init_iterate = __esm(() => {
   init_registry();
   init_canonical();
+  MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+  MIN_SAFE = -MAX_SAFE;
 });
 
 // src/arrow/impl-arrowjs/filter.ts
@@ -1800,72 +1810,74 @@ var init_statistics = __esm(() => {
 // src/arrow/impl-arrowjs/index.ts
 var exports_impl_arrowjs = {};
 __export(exports_impl_arrowjs, {
-  withBatchMetadata: () => withBatchMetadata,
-  utf8: () => utf8,
-  union: () => union,
-  uint8: () => uint8,
-  uint64: () => uint64,
-  uint32: () => uint32,
-  uint16: () => uint16,
-  timestamp: () => timestamp,
-  timeSecond: () => timeSecond,
-  timeNanosecond: () => timeNanosecond,
-  timeMillisecond: () => timeMillisecond,
-  timeMicrosecond: () => timeMicrosecond,
-  time: () => time,
-  struct: () => struct,
-  sparseUnion: () => sparseUnion,
-  serializeSchema: () => serializeSchema,
-  serializeBatch: () => serializeBatch,
-  schema: () => schema,
-  safeNumber: () => safeNumber,
-  readCanonicalValue: () => readCanonicalValue,
-  projectSchema: () => projectSchema,
-  projectBatch: () => projectBatch,
-  nullType: () => nullType,
-  map: () => map,
-  list: () => list,
-  iterRows: () => iterRows,
-  interval: () => interval,
-  int8: () => int8,
-  int64: () => int64,
-  int32: () => int32,
-  int16: () => int16,
-  int: () => int,
-  float64: () => float64,
-  float32: () => float32,
-  float16: () => float16,
-  fixedSizeList: () => fixedSizeList,
-  fixedSizeBinary: () => fixedSizeBinary,
-  filterBatch: () => filterBatch,
-  field: () => field,
-  emptyBatch: () => emptyBatch,
-  duration: () => duration,
-  dictionary: () => dictionary,
-  deserializeSchema: () => deserializeSchema,
-  deserializeBatch: () => deserializeBatch,
-  denseUnion: () => denseUnion,
-  decodeDictValue: () => decodeDictValue,
-  decimal256: () => decimal256,
-  decimal128: () => decimal128,
-  decimal: () => decimal,
-  dateMillisecond: () => dateMillisecond,
-  dateDay: () => dateDay,
-  date: () => date,
-  columnFromArray: () => columnFromArray,
-  buildStatisticsBatch: () => buildStatisticsBatch,
-  bool: () => bool,
-  binary: () => binary,
-  batchToSecretDict: () => batchToSecretDict,
-  batchToScalarDict: () => batchToScalarDict,
-  batchFromRows: () => batchFromRows,
-  batchFromColumns: () => batchFromColumns,
-  backend: () => backend,
-  adoptArrowJsShape: () => adoptArrowJsShape,
-  UnionMode: () => UnionMode,
-  TimeUnit: () => TimeUnit,
+  DateUnit: () => DateUnit,
   IntervalUnit: () => IntervalUnit,
-  DateUnit: () => DateUnit
+  TimeUnit: () => TimeUnit,
+  UnionMode: () => UnionMode,
+  adoptArrowJsShape: () => adoptArrowJsShape,
+  backend: () => backend,
+  batchFromColumns: () => batchFromColumns,
+  batchFromRows: () => batchFromRows,
+  batchToScalarDict: () => batchToScalarDict,
+  batchToSecretDict: () => batchToSecretDict,
+  binary: () => binary,
+  bool: () => bool,
+  buildStatisticsBatch: () => buildStatisticsBatch,
+  columnFromArray: () => columnFromArray,
+  date: () => date,
+  dateDay: () => dateDay,
+  dateMillisecond: () => dateMillisecond,
+  decimal: () => decimal,
+  decimal128: () => decimal128,
+  decimal256: () => decimal256,
+  decodeDictValue: () => decodeDictValue,
+  denseUnion: () => denseUnion,
+  deserializeBatch: () => deserializeBatch,
+  deserializeSchema: () => deserializeSchema,
+  dictionary: () => dictionary,
+  duration: () => duration,
+  emptyBatch: () => emptyBatch,
+  field: () => field,
+  filterBatch: () => filterBatch,
+  fixedSizeBinary: () => fixedSizeBinary,
+  fixedSizeList: () => fixedSizeList,
+  float16: () => float16,
+  float32: () => float32,
+  float64: () => float64,
+  int: () => int,
+  int16: () => int16,
+  int32: () => int32,
+  int64: () => int64,
+  int8: () => int8,
+  interval: () => interval,
+  iterRows: () => iterRows,
+  largeBinary: () => largeBinary,
+  largeUtf8: () => largeUtf8,
+  list: () => list,
+  map: () => map,
+  nullType: () => nullType,
+  projectBatch: () => projectBatch,
+  projectSchema: () => projectSchema,
+  readCanonicalValue: () => readCanonicalValue,
+  safeNumber: () => safeNumber,
+  schema: () => schema,
+  serializeBatch: () => serializeBatch,
+  serializeSchema: () => serializeSchema,
+  sparseUnion: () => sparseUnion,
+  struct: () => struct,
+  time: () => time,
+  timeMicrosecond: () => timeMicrosecond,
+  timeMillisecond: () => timeMillisecond,
+  timeNanosecond: () => timeNanosecond,
+  timeSecond: () => timeSecond,
+  timestamp: () => timestamp,
+  uint16: () => uint16,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  uint8: () => uint8,
+  union: () => union,
+  utf8: () => utf8,
+  withBatchMetadata: () => withBatchMetadata
 });
 function adoptArrowJsShape(batch) {
   return batch;
@@ -1919,7 +1931,7 @@ function dictionary2(valueType, indexType, ordered, id) {
 function union2(mode, children, typeIds) {
   return union(mode, children, typeIds);
 }
-var TimeUnit2, DateUnit3, IntervalUnit2, UnionMode2, schema2, nullType2 = () => nullType(), bool2 = () => bool(), int82 = () => int8(), int162 = () => int16(), int322 = () => int32(), int642 = () => int64(), uint82 = () => uint8(), uint162 = () => uint16(), uint322 = () => uint32(), uint642 = () => uint64(), float162 = () => float16(), float322 = () => float32(), float642 = () => float64(), utf82 = () => utf8(), binary2 = () => binary(), fixedSizeBinary2 = (byteWidth) => fixedSizeBinary(byteWidth), decimal2 = (precision, scale, bitWidth) => decimal(precision, scale, bitWidth), decimal1282 = (precision, scale) => decimal128(precision, scale), decimal2562 = (precision, scale) => decimal256(precision, scale), date2 = (unit) => date(unit), dateDay2 = () => dateDay(), dateMillisecond2 = () => dateMillisecond(), timeSecond2 = () => timeSecond(), timeMillisecond2 = () => timeMillisecond(), timeMicrosecond2 = () => timeMicrosecond(), timeNanosecond2 = () => timeNanosecond(), UNIT_TO_TAG, timestampSeconds = (timezone) => timestamp(TimeUnit.SECOND, timezone ?? null), timestampMillis = (timezone) => timestamp(TimeUnit.MILLISECOND, timezone ?? null), timestampMicros = (timezone) => timestamp(TimeUnit.MICROSECOND, timezone ?? null), timestampNanos = (timezone) => timestamp(TimeUnit.NANOSECOND, timezone ?? null), durationSeconds = () => duration(TimeUnit.SECOND), durationMillis = () => duration(TimeUnit.MILLISECOND), durationMicros = () => duration(TimeUnit.MICROSECOND), durationNanos = () => duration(TimeUnit.NANOSECOND), interval2 = (unit) => interval(unit), sparseUnion2 = (children, typeIds) => sparseUnion(children, typeIds), denseUnion2 = (children, typeIds) => denseUnion(children, typeIds);
+var TimeUnit2, DateUnit3, IntervalUnit2, UnionMode2, schema2, nullType2 = () => nullType(), bool2 = () => bool(), int82 = () => int8(), int162 = () => int16(), int322 = () => int32(), int642 = () => int64(), uint82 = () => uint8(), uint162 = () => uint16(), uint322 = () => uint32(), uint642 = () => uint64(), float162 = () => float16(), float322 = () => float32(), float642 = () => float64(), utf82 = () => utf8(), largeUtf82 = () => largeUtf8(), binary2 = () => binary(), largeBinary2 = () => largeBinary(), fixedSizeBinary2 = (byteWidth) => fixedSizeBinary(byteWidth), decimal2 = (precision, scale, bitWidth) => decimal(precision, scale, bitWidth), decimal1282 = (precision, scale) => decimal128(precision, scale), decimal2562 = (precision, scale) => decimal256(precision, scale), date2 = (unit) => date(unit), dateDay2 = () => dateDay(), dateMillisecond2 = () => dateMillisecond(), timeSecond2 = () => timeSecond(), timeMillisecond2 = () => timeMillisecond(), timeMicrosecond2 = () => timeMicrosecond(), timeNanosecond2 = () => timeNanosecond(), UNIT_TO_TAG, timestampSeconds = (timezone) => timestamp(TimeUnit.SECOND, timezone ?? null), timestampMillis = (timezone) => timestamp(TimeUnit.MILLISECOND, timezone ?? null), timestampMicros = (timezone) => timestamp(TimeUnit.MICROSECOND, timezone ?? null), timestampNanos = (timezone) => timestamp(TimeUnit.NANOSECOND, timezone ?? null), durationSeconds = () => duration(TimeUnit.SECOND), durationMillis = () => duration(TimeUnit.MILLISECOND), durationMicros = () => duration(TimeUnit.MICROSECOND), durationNanos = () => duration(TimeUnit.NANOSECOND), interval2 = (unit) => interval(unit), sparseUnion2 = (children, typeIds) => sparseUnion(children, typeIds), denseUnion2 = (children, typeIds) => denseUnion(children, typeIds);
 var init_schema_types = __esm(() => {
   init_impl_arrowjs();
   ({ TimeUnit: TimeUnit2, DateUnit: DateUnit3, IntervalUnit: IntervalUnit2, UnionMode: UnionMode2, schema: schema2 } = exports_impl_arrowjs);
@@ -1978,123 +1990,125 @@ var init_branded = __esm(() => {
 // src/arrow/index.ts
 var exports_arrow = {};
 __export(exports_arrow, {
-  withBatchMetadata: () => withBatchMetadata,
-  utf8: () => utf82,
-  union: () => union2,
-  uint8: () => uint82,
-  uint64: () => uint642,
-  uint32: () => uint322,
-  uint16: () => uint162,
-  typeSignature: () => typeSignature,
-  timestampSeconds: () => timestampSeconds,
-  timestampNanos: () => timestampNanos,
-  timestampMillis: () => timestampMillis,
-  timestampMicros: () => timestampMicros,
-  timestamp: () => timestamp2,
-  timeSecond: () => timeSecond2,
-  timeNanosecond: () => timeNanosecond2,
-  timeMillisecond: () => timeMillisecond2,
-  timeMicrosecond: () => timeMicrosecond2,
-  time: () => time2,
-  struct: () => struct2,
-  sparseUnion: () => sparseUnion2,
-  serializeSchema: () => serializeSchema,
-  serializeBatch: () => serializeBatch,
-  schema: () => schema2,
-  safeNumber: () => safeNumber,
-  readCanonicalValue: () => readCanonicalValue,
-  projectSchema: () => projectSchema,
-  projectBatch: () => projectBatch,
-  nullType: () => nullType2,
-  map: () => map2,
-  list: () => list2,
-  iterRows: () => iterRows,
-  isUtf8: () => isUtf8,
-  isUnion: () => isUnion,
-  isTimestamp: () => isTimestamp,
-  isTime: () => isTime,
-  isStruct: () => isStruct,
-  isNull: () => isNull,
-  isMap: () => isMap,
-  isList: () => isList,
-  isInterval: () => isInterval,
-  isInt: () => isInt,
-  isFloat: () => isFloat,
-  isFixedSizeList: () => isFixedSizeList,
-  isFixedSizeBinary: () => isFixedSizeBinary,
-  isDuration: () => isDuration,
-  isDictionary: () => isDictionary,
-  isDecimal: () => isDecimal,
-  isDate: () => isDate,
-  isBool: () => isBool,
-  isBinary: () => isBinary,
-  isBatch: () => isBatch,
-  interval: () => interval2,
-  int8: () => int82,
-  int64: () => int642,
-  int32: () => int322,
-  int16: () => int162,
-  int: () => int2,
-  fromBrandedNumber: () => fromBrandedNumber,
-  fromBrandedBigInt: () => fromBrandedBigInt,
-  fromBranded: () => fromBranded,
-  float64: () => float642,
-  float32: () => float322,
-  float16: () => float162,
-  fixedSizeList: () => fixedSizeList2,
-  fixedSizeBinary: () => fixedSizeBinary2,
-  filterBatch: () => filterBatch,
-  field: () => field2,
-  emptyBatch: () => emptyBatch,
-  durationSeconds: () => durationSeconds,
-  durationNanos: () => durationNanos,
-  durationMillis: () => durationMillis,
-  durationMicros: () => durationMicros,
-  duration: () => duration2,
-  dictionary: () => dictionary2,
-  deserializeSchema: () => deserializeSchema,
-  deserializeBatch: () => deserializeBatch,
-  denseUnion: () => denseUnion2,
-  decodeDictValue: () => decodeDictValue,
-  decimal256: () => decimal2562,
-  decimal128: () => decimal1282,
-  decimal: () => decimal2,
-  dateMillisecond: () => dateMillisecond2,
-  dateDay: () => dateDay2,
-  date: () => date2,
-  columnFromArray: () => columnFromArray,
-  codecFor: () => codecFor,
-  buildStatisticsBatch: () => buildStatisticsBatch,
-  bool: () => bool2,
-  binary: () => binary2,
-  batchToSecretDict: () => batchToSecretDict,
-  batchToScalarDict: () => batchToScalarDict,
-  batchFromRows: () => batchFromRows,
-  batchFromColumns: () => batchFromColumns,
-  backend: () => backend,
-  asUnscaledDecimal: () => asUnscaledDecimal,
-  asUint64: () => asUint64,
-  asTimestampSeconds: () => asTimestampSeconds,
-  asTimestampNanos: () => asTimestampNanos,
-  asTimestampMillis: () => asTimestampMillis,
-  asTimestampMicros: () => asTimestampMicros,
-  asTime64Us: () => asTime64Us,
-  asTime64Ns: () => asTime64Ns,
-  asTime32S: () => asTime32S,
-  asTime32Ms: () => asTime32Ms,
-  asInt64: () => asInt64,
-  asDurationSeconds: () => asDurationSeconds,
-  asDurationNanos: () => asDurationNanos,
-  asDurationMillis: () => asDurationMillis,
-  asDurationMicros: () => asDurationMicros,
-  asDate64Ms: () => asDate64Ms,
-  asDate32: () => asDate32,
-  adoptArrowJsShape: () => adoptArrowJsShape,
-  UnionMode: () => UnionMode2,
-  TypeId: () => TypeId,
-  TimeUnit: () => TimeUnit2,
+  DateUnit: () => DateUnit3,
   IntervalUnit: () => IntervalUnit2,
-  DateUnit: () => DateUnit3
+  TimeUnit: () => TimeUnit2,
+  TypeId: () => TypeId,
+  UnionMode: () => UnionMode2,
+  adoptArrowJsShape: () => adoptArrowJsShape,
+  asDate32: () => asDate32,
+  asDate64Ms: () => asDate64Ms,
+  asDurationMicros: () => asDurationMicros,
+  asDurationMillis: () => asDurationMillis,
+  asDurationNanos: () => asDurationNanos,
+  asDurationSeconds: () => asDurationSeconds,
+  asInt64: () => asInt64,
+  asTime32Ms: () => asTime32Ms,
+  asTime32S: () => asTime32S,
+  asTime64Ns: () => asTime64Ns,
+  asTime64Us: () => asTime64Us,
+  asTimestampMicros: () => asTimestampMicros,
+  asTimestampMillis: () => asTimestampMillis,
+  asTimestampNanos: () => asTimestampNanos,
+  asTimestampSeconds: () => asTimestampSeconds,
+  asUint64: () => asUint64,
+  asUnscaledDecimal: () => asUnscaledDecimal,
+  backend: () => backend,
+  batchFromColumns: () => batchFromColumns,
+  batchFromRows: () => batchFromRows,
+  batchToScalarDict: () => batchToScalarDict,
+  batchToSecretDict: () => batchToSecretDict,
+  binary: () => binary2,
+  bool: () => bool2,
+  buildStatisticsBatch: () => buildStatisticsBatch,
+  codecFor: () => codecFor,
+  columnFromArray: () => columnFromArray,
+  date: () => date2,
+  dateDay: () => dateDay2,
+  dateMillisecond: () => dateMillisecond2,
+  decimal: () => decimal2,
+  decimal128: () => decimal1282,
+  decimal256: () => decimal2562,
+  decodeDictValue: () => decodeDictValue,
+  denseUnion: () => denseUnion2,
+  deserializeBatch: () => deserializeBatch,
+  deserializeSchema: () => deserializeSchema,
+  dictionary: () => dictionary2,
+  duration: () => duration2,
+  durationMicros: () => durationMicros,
+  durationMillis: () => durationMillis,
+  durationNanos: () => durationNanos,
+  durationSeconds: () => durationSeconds,
+  emptyBatch: () => emptyBatch,
+  field: () => field2,
+  filterBatch: () => filterBatch,
+  fixedSizeBinary: () => fixedSizeBinary2,
+  fixedSizeList: () => fixedSizeList2,
+  float16: () => float162,
+  float32: () => float322,
+  float64: () => float642,
+  fromBranded: () => fromBranded,
+  fromBrandedBigInt: () => fromBrandedBigInt,
+  fromBrandedNumber: () => fromBrandedNumber,
+  int: () => int2,
+  int16: () => int162,
+  int32: () => int322,
+  int64: () => int642,
+  int8: () => int82,
+  interval: () => interval2,
+  isBatch: () => isBatch,
+  isBinary: () => isBinary,
+  isBool: () => isBool,
+  isDate: () => isDate,
+  isDecimal: () => isDecimal,
+  isDictionary: () => isDictionary,
+  isDuration: () => isDuration,
+  isFixedSizeBinary: () => isFixedSizeBinary,
+  isFixedSizeList: () => isFixedSizeList,
+  isFloat: () => isFloat,
+  isInt: () => isInt,
+  isInterval: () => isInterval,
+  isList: () => isList,
+  isMap: () => isMap,
+  isNull: () => isNull,
+  isStruct: () => isStruct,
+  isTime: () => isTime,
+  isTimestamp: () => isTimestamp,
+  isUnion: () => isUnion,
+  isUtf8: () => isUtf8,
+  iterRows: () => iterRows,
+  largeBinary: () => largeBinary2,
+  largeUtf8: () => largeUtf82,
+  list: () => list2,
+  map: () => map2,
+  nullType: () => nullType2,
+  projectBatch: () => projectBatch,
+  projectSchema: () => projectSchema,
+  readCanonicalValue: () => readCanonicalValue,
+  safeNumber: () => safeNumber,
+  schema: () => schema2,
+  serializeBatch: () => serializeBatch,
+  serializeSchema: () => serializeSchema,
+  sparseUnion: () => sparseUnion2,
+  struct: () => struct2,
+  time: () => time2,
+  timeMicrosecond: () => timeMicrosecond2,
+  timeMillisecond: () => timeMillisecond2,
+  timeNanosecond: () => timeNanosecond2,
+  timeSecond: () => timeSecond2,
+  timestamp: () => timestamp2,
+  timestampMicros: () => timestampMicros,
+  timestampMillis: () => timestampMillis,
+  timestampNanos: () => timestampNanos,
+  timestampSeconds: () => timestampSeconds,
+  typeSignature: () => typeSignature,
+  uint16: () => uint162,
+  uint32: () => uint322,
+  uint64: () => uint642,
+  uint8: () => uint82,
+  union: () => union2,
+  utf8: () => utf82,
+  withBatchMetadata: () => withBatchMetadata
 });
 var init_arrow = __esm(() => {
   init_predicates();
@@ -2597,7 +2611,11 @@ var init_storage = __esm(() => {
 });
 
 // src/http/fetch.ts
-import { createHttpHandler, unpackStateToken } from "@query-farm/vgi-rpc";
+import {
+  AuthContext,
+  createHttpHandler,
+  unpackStateToken
+} from "@query-farm/vgi-rpc";
 
 // src/protocol/state-serializer.ts
 init_arrow();
@@ -2629,6 +2647,27 @@ var EXCHANGE_STATE_SCHEMA = schema2([
 ]);
 var TEXT_ENCODER = new TextEncoder;
 var TEXT_DECODER = new TextDecoder;
+var LIST_CHILD_NAME = "item";
+var emptyListElementType = () => utf82();
+function inferElementType(values) {
+  let elementType = null;
+  let elementSig = "";
+  for (const v of values) {
+    if (v === null || v === undefined)
+      continue;
+    const t = inferFieldType(v);
+    const sig = typeSignature(t);
+    if (elementType === null) {
+      elementType = t;
+      elementSig = sig;
+      continue;
+    }
+    if (sig !== elementSig) {
+      throw new Error(`inferFieldType: arrays in userState must be homogeneous; ` + `found both '${elementSig}' and '${sig}' in the same array ` + `(split the values into separate fields, or normalize them to one type)`);
+    }
+  }
+  return elementType ?? emptyListElementType();
+}
 function inferFieldType(value) {
   if (value === null || value === undefined)
     return nullType2();
@@ -2647,7 +2686,7 @@ function inferFieldType(value) {
       if (ArrayBuffer.isView(value))
         return binary2();
       if (Array.isArray(value)) {
-        throw new Error(`inferFieldType: arrays are not supported in userState (convert to a serializable form first)`);
+        return list2(field2(LIST_CHILD_NAME, inferElementType(value), true));
       }
       if (value instanceof Map) {
         throw new Error(`inferFieldType: Map is not supported in userState (use a plain object instead)`);
@@ -2925,10 +2964,19 @@ function toUint8Array2(val) {
 }
 
 // src/protocol/serializers/bind.ts
+var COPY_FROM_STRUCT_TYPE = struct2([
+  field2("format", utf82(), false),
+  field2("file_path", utf82(), false),
+  field2("expected_schema", binary2(), false)
+]);
+var COPY_TO_STRUCT_TYPE = struct2([
+  field2("format", utf82(), false),
+  field2("file_path", utf82(), false)
+]);
 var BIND_REQUEST_SCHEMA = schema2([
   field2("function_name", utf82(), false),
   field2("arguments", binary2(), false),
-  field2("function_type", utf82(), false),
+  field2("function_type", dictionary2(utf82(), int162()), false),
   field2("input_schema", binary2(), true),
   field2("settings", binary2(), true),
   field2("secrets", binary2(), true),
@@ -2937,26 +2985,10 @@ var BIND_REQUEST_SCHEMA = schema2([
   field2("resolved_secrets_provided", bool2(), false),
   field2("at_unit", utf82(), true),
   field2("at_value", utf82(), true),
+  field2("copy_from", COPY_FROM_STRUCT_TYPE, true),
+  field2("copy_to", COPY_TO_STRUCT_TYPE, true),
   field2("schema_name", utf82(), true)
 ]);
-var COPY_FROM_STRUCT_TYPE = struct2([
-  field2("format", utf82(), false),
-  field2("file_path", utf82(), false),
-  field2("expected_schema", binary2(), false)
-]);
-var COPY_FROM_FIELD = field2("copy_from", COPY_FROM_STRUCT_TYPE, true);
-var COPY_TO_STRUCT_TYPE = struct2([
-  field2("format", utf82(), false),
-  field2("file_path", utf82(), false)
-]);
-var COPY_TO_FIELD = field2("copy_to", COPY_TO_STRUCT_TYPE, true);
-var BIND_RESPONSE_SCHEMA = schema2([
-  field2("output_schema", binary2(), false),
-  field2("opaque_data", binary2(), true),
-  field2("lookup_secret_types", list2(field2("item", utf82(), true)), false),
-  field2("lookup_scopes", list2(field2("item", utf82(), true)), false),
-  field2("lookup_names", list2(field2("item", utf82(), true)), false)
-]);
 function parseCopyFromContext(raw) {
   if (raw == null)
     return null;
@@ -3027,20 +3059,22 @@ var INIT_REQUEST_SCHEMA = schema2([
   field2("bind_call", binary2(), false),
   field2("output_schema", binary2(), false),
   field2("bind_opaque_data", binary2(), true),
-  field2("projection_ids", list2(field2("item", int642(), false)), true),
-  field2("pushdown_filters", binary2(), true),
-  field2("join_keys", list2(field2("item", binary2(), true)), false),
-  field2("phase", utf82(), true),
+  field2("projection_ids", list2(field2("item", int642(), true)), true),
+  field2("pushdown_filters", largeBinary2(), true),
+  field2("join_keys", list2(field2("item", largeBinary2(), true)), true),
+  field2("split_tokens", list2(field2("item", largeBinary2(), true)), true),
+  field2("row_limit", int642(), true),
+  field2("phase", dictionary2(utf82(), int162()), true),
+  field2("finalize_state_id", binary2(), true),
   field2("execution_id", binary2(), true),
   field2("init_opaque_data", binary2(), true),
   field2("substream_id", binary2(), true),
   field2("order_by_column_name", utf82(), true),
-  field2("order_by_direction", utf82(), true),
-  field2("order_by_null_order", utf82(), true),
+  field2("order_by_direction", dictionary2(utf82(), int162()), true),
+  field2("order_by_null_order", dictionary2(utf82(), int162()), true),
   field2("order_by_limit", int642(), true),
   field2("tablesample_percentage", float642(), true),
-  field2("tablesample_seed", int642(), true),
-  field2("finalize_state_id", binary2(), true)
+  field2("tablesample_seed", int642(), true)
 ]);
 var GLOBAL_INIT_RESPONSE_SCHEMA = schema2([
   field2("execution_id", binary2(), false),
@@ -3092,10 +3126,19 @@ function deserializeInitRequest(params) {
     output_schema: deserializeSchema(toUint8Array2(params.output_schema)),
     bind_opaque_data: params.bind_opaque_data ? toUint8Array2(params.bind_opaque_data) : null,
     projection_ids: projectionIds,
+    row_limit: params.row_limit == null ? null : Number(params.row_limit),
     pushdown_filters: params.pushdown_filters ? deserializeBatch(toUint8Array2(params.pushdown_filters)) : null,
     join_keys: joinKeys,
     phase,
     finalize_state_id: params.finalize_state_id ? toUint8Array2(params.finalize_state_id) : null,
+    split_tokens: (() => {
+      const raw = params.split_tokens;
+      if (raw == null)
+        return null;
+      const iter = Array.isArray(raw) ? raw : typeof raw[Symbol.iterator] === "function" ? raw : [];
+      const tokens = [...iter].filter((e) => e != null).map((e) => toUint8Array2(e));
+      return tokens.length > 0 ? tokens : null;
+    })(),
     execution_id: params.execution_id ? toUint8Array2(params.execution_id) : null,
     init_opaque_data: params.init_opaque_data ? toUint8Array2(params.init_opaque_data) : null,
     substream_id: params.substream_id ? toUint8Array2(params.substream_id) : null,
@@ -3164,10 +3207,6 @@ function serializeGlobalInitResponse(resp) {
 }
 // src/protocol/serializers/cardinality.ts
 init_arrow();
-var TABLE_CARDINALITY_SCHEMA = schema2([
-  field2("estimate", int642(), true),
-  field2("max", int642(), true)
-]);
 var TABLE_FUNCTION_CARDINALITY_REQUEST_SCHEMA = schema2([
   field2("bind_call", binary2(), false),
   field2("bind_opaque_data", binary2(), true)
@@ -3201,7 +3240,7 @@ var CatalogInfoSchema = schema2([
   field2("implementation_version", utf82(), true),
   field2("data_version_spec", utf82(), true),
   field2("attach_option_specs", list2(field2("item", binary2(), true)), false),
-  field2("releases", list2(field2("item", struct2([field2("version", utf82(), false), field2("released_at", timestamp2(TimeUnit2.MICROSECOND, "UTC"), false), field2("summary", utf82(), false), field2("notes_url", utf82(), true)]), true)), false),
+  field2("releases", list2(field2("item", struct2([field2("version", utf82(), false), field2("released_at", timestamp2(TimeUnit2.MICROSECOND, "UTC"), true), field2("summary", utf82(), false), field2("notes_url", utf82(), true)]), true)), false),
   field2("source_url", utf82(), true)
 ]);
 var SchemaInfoSchema = schema2([
@@ -3227,14 +3266,14 @@ var TableInfoSchema = schema2([
   field2("supports_delete", bool2(), false),
   field2("supports_returning", bool2(), false),
   field2("supports_column_statistics", bool2(), false),
-  field2("scan_function", binary2(), false),
-  field2("insert_function", binary2(), false),
-  field2("update_function", binary2(), false),
-  field2("delete_function", binary2(), false),
-  field2("cardinality_estimate", int642(), false),
-  field2("cardinality_max", int642(), false),
-  field2("column_statistics", binary2(), false),
-  field2("bind_result", binary2(), false),
+  field2("scan_function", binary2(), true),
+  field2("insert_function", binary2(), true),
+  field2("update_function", binary2(), true),
+  field2("delete_function", binary2(), true),
+  field2("cardinality_estimate", int642(), true),
+  field2("cardinality_max", int642(), true),
+  field2("column_statistics", binary2(), true),
+  field2("bind_result", binary2(), true),
   field2("required_filters", list2(field2("item", list2(field2("item", utf82(), true)), true)), false)
 ]);
 var ViewInfoSchema = schema2([
@@ -3264,8 +3303,12 @@ var FunctionInfoSchema = schema2([
   field2("late_materialization", bool2(), true),
   field2("supported_expression_filters", list2(field2("item", utf82(), true)), false),
   field2("order_preservation", dictionary2(utf82(), int162()), true),
-  field2("max_workers", int322(), false),
+  field2("max_workers", int322(), true),
   field2("supports_batch_index", bool2(), false),
+  field2("supports_splits", bool2(), false),
+  field2("filters_exactly_applied", bool2(), false),
+  field2("supports_positions", bool2(), false),
+  field2("split_token_ttl_seconds", int642(), true),
   field2("partition_kind", dictionary2(utf82(), int162()), false),
   field2("order_dependent", dictionary2(utf82(), int162()), false),
   field2("distinct_dependent", dictionary2(utf82(), int162()), false),
@@ -3286,9 +3329,9 @@ var MacroInfoSchema = schema2([
   field2("schema_name", utf82(), false),
   field2("macro_type", dictionary2(utf82(), int162()), false),
   field2("parameters", list2(field2("item", utf82(), true)), false),
-  field2("parameter_default_values", binary2(), false),
+  field2("parameter_default_values", binary2(), true),
   field2("definition", utf82(), false),
-  field2("arguments_schema", binary2(), false)
+  field2("arguments_schema", binary2(), true)
 ]);
 var IndexInfoSchema = schema2([
   field2("comment", utf82(), true),
@@ -3327,7 +3370,22 @@ var ScanBranchSchema = schema2([
   field2("writable", bool2(), false),
   field2("source_catalog", utf82(), true),
   field2("source_schema", utf82(), true),
-  field2("source_table", utf82(), true)
+  field2("source_table", utf82(), true),
+  field2("format_name", utf82(), true),
+  field2("format_locations", list2(field2("item", utf82(), true)), true),
+  field2("format_options", binary2(), true)
+]);
+var ScanSplitSchema = schema2([
+  field2("payload", binary2(), false),
+  field2("token", binary2(), false),
+  field2("estimated_rows", int642(), true),
+  field2("rows_exact", bool2(), false),
+  field2("estimated_bytes", int642(), true),
+  field2("partition_bounds", binary2(), true),
+  field2("column_statistics", binary2(), true),
+  field2("location_ids", list2(field2("item", int642(), true)), true),
+  field2("start_position", binary2(), true),
+  field2("end_position", binary2(), true)
 ]);
 var AttachCatalogInfoSchema = schema2([
   field2("alias", utf82(), false),
@@ -3338,6 +3396,152 @@ var AttachCatalogInfoSchema = schema2([
   field2("required", bool2(), false),
   field2("secret_ref", utf82(), false)
 ]);
+var AggregateBindRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("arguments", binary2(), false),
+  field2("input_schema", binary2(), true),
+  field2("settings", binary2(), true),
+  field2("secrets", binary2(), true),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_name", utf82(), true)
+]);
+var AggregateCombineRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("merge_batch", binary2(), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_name", utf82(), true)
+]);
+var AggregateDestructorRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("group_ids_batch", binary2(), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_name", utf82(), true)
+]);
+var AggregateFinalizeRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("group_ids_batch", binary2(), false),
+  field2("output_schema", binary2(), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_name", utf82(), true)
+]);
+var AggregateUpdateRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("input_batch", binary2(), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_name", utf82(), true)
+]);
+var BindRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("arguments", binary2(), false),
+  field2("function_type", dictionary2(utf82(), int162()), false),
+  field2("input_schema", binary2(), true),
+  field2("settings", binary2(), true),
+  field2("secrets", binary2(), true),
+  field2("attach_opaque_data", binary2(), true),
+  field2("transaction_opaque_data", binary2(), true),
+  field2("resolved_secrets_provided", bool2(), false),
+  field2("at_unit", utf82(), true),
+  field2("at_value", utf82(), true),
+  field2("copy_from", struct2([field2("format", utf82(), false), field2("file_path", utf82(), false), field2("expected_schema", binary2(), false)]), true),
+  field2("copy_to", struct2([field2("format", utf82(), false), field2("file_path", utf82(), false)]), true),
+  field2("schema_name", utf82(), true)
+]);
+var CatalogAttachRequestSchema = schema2([
+  field2("name", utf82(), false),
+  field2("options", binary2(), true),
+  field2("data_version_spec", utf82(), true),
+  field2("implementation_version", utf82(), true),
+  field2("client_capabilities", binary2(), true)
+]);
+var CopyFromContextSchema = schema2([
+  field2("format", utf82(), false),
+  field2("file_path", utf82(), false),
+  field2("expected_schema", binary2(), false)
+]);
+var CopyToContextSchema = schema2([
+  field2("format", utf82(), false),
+  field2("file_path", utf82(), false)
+]);
+var GlobalInitResponseSchema = schema2([
+  field2("execution_id", binary2(), false),
+  field2("opaque_data", binary2(), true),
+  field2("max_workers", int642(), false)
+]);
+var InitRequestSchema = schema2([
+  field2("bind_call", binary2(), false),
+  field2("output_schema", binary2(), false),
+  field2("bind_opaque_data", binary2(), true),
+  field2("projection_ids", list2(field2("item", int642(), true)), true),
+  field2("pushdown_filters", largeBinary2(), true),
+  field2("join_keys", list2(field2("item", largeBinary2(), true)), true),
+  field2("split_tokens", list2(field2("item", largeBinary2(), true)), true),
+  field2("row_limit", int642(), true),
+  field2("phase", dictionary2(utf82(), int162()), true),
+  field2("finalize_state_id", binary2(), true),
+  field2("execution_id", binary2(), true),
+  field2("init_opaque_data", binary2(), true),
+  field2("substream_id", binary2(), true),
+  field2("order_by_column_name", utf82(), true),
+  field2("order_by_direction", dictionary2(utf82(), int162()), true),
+  field2("order_by_null_order", dictionary2(utf82(), int162()), true),
+  field2("order_by_limit", int642(), true),
+  field2("tablesample_percentage", float642(), true),
+  field2("tablesample_seed", int642(), true)
+]);
+var TableBufferingCombineRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("state_ids", list2(field2("item", binary2(), true)), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("transaction_id", binary2(), true),
+  field2("schema_name", utf82(), true)
+]);
+var TableBufferingDestructorRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("transaction_id", binary2(), true),
+  field2("schema_name", utf82(), true)
+]);
+var TableBufferingProcessRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("input_batch", binary2(), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("transaction_id", binary2(), true),
+  field2("batch_index", int642(), true),
+  field2("schema_name", utf82(), true)
+]);
+var TableFunctionCardinalityRequestSchema = schema2([
+  field2("bind_call", binary2(), false),
+  field2("bind_opaque_data", binary2(), true)
+]);
+var TableFunctionPlanRequestSchema = schema2([
+  field2("bind_call", binary2(), false),
+  field2("bind_opaque_data", binary2(), true),
+  field2("projection_ids", list2(field2("item", int642(), true)), true),
+  field2("pushdown_filters", largeBinary2(), true),
+  field2("join_keys", list2(field2("item", largeBinary2(), true)), true),
+  field2("row_limit", int642(), true),
+  field2("target_split_bytes", int642(), true),
+  field2("min_splits", int642(), true),
+  field2("max_splits_per_response", int642(), true),
+  field2("cursor", binary2(), true),
+  field2("refined_filters", largeBinary2(), true),
+  field2("filters_complete", bool2(), false),
+  field2("start_position", binary2(), true),
+  field2("end_position", binary2(), true),
+  field2("order_by_column_name", utf82(), true),
+  field2("order_by_direction", dictionary2(utf82(), int162()), true),
+  field2("order_by_null_order", dictionary2(utf82(), int162()), true),
+  field2("order_by_limit", int642(), true),
+  field2("tablesample_percentage", float642(), true),
+  field2("tablesample_seed", int642(), true)
+]);
 var AggregateBindResultSchema = schema2([
   field2("output_schema", binary2(), false),
   field2("execution_id", binary2(), false)
@@ -3365,7 +3569,7 @@ var AggregateWindowDestructorResultSchema = schema2([]);
 var AggregateWindowInitResultSchema = schema2([]);
 var BindResultSchema = schema2([
   field2("output_schema", binary2(), false),
-  field2("opaque_data", binary2(), false),
+  field2("opaque_data", binary2(), true),
   field2("lookup_secret_types", list2(field2("item", utf82(), true)), false),
   field2("lookup_scopes", list2(field2("item", utf82(), true)), false),
   field2("lookup_names", list2(field2("item", utf82(), true)), false)
@@ -3449,6 +3653,24 @@ var TableFunctionDynamicToStringResultSchema = schema2([
   field2("keys", list2(field2("item", utf82(), true)), false),
   field2("values", list2(field2("item", utf82(), true)), false)
 ]);
+var TableFunctionPlanResultSchema = schema2([
+  field2("splits", list2(field2("item", binary2(), true)), false),
+  field2("next_cursors", list2(field2("item", binary2(), true)), true),
+  field2("execution_id", binary2(), true),
+  field2("init_opaque_data", binary2(), true),
+  field2("max_workers", int642(), true),
+  field2("estimated_total_splits", int642(), true),
+  field2("estimated_total_rows", int642(), true),
+  field2("estimated_total_bytes", int642(), true),
+  field2("catalog_version", int642(), true),
+  field2("scope", utf82(), false),
+  field2("locations", list2(field2("item", utf82(), true)), true),
+  field2("partitioning", list2(field2("item", binary2(), true)), true),
+  field2("sort_order", list2(field2("item", binary2(), true)), true),
+  field2("cache_max_age_seconds", int642(), true),
+  field2("start_position", binary2(), true),
+  field2("end_position", binary2(), true)
+]);
 var AggregateBindParamsSchema = schema2([
   field2("request", binary2(), false)
 ]);
@@ -3815,6 +4037,9 @@ var TableFunctionCardinalityParamsSchema = schema2([
 var TableFunctionDynamicToStringParamsSchema = schema2([
   field2("request", binary2(), false)
 ]);
+var TableFunctionPlanParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
 var TableFunctionStatisticsParamsSchema = schema2([
   field2("request", binary2(), false)
 ]);
@@ -4770,57 +4995,235 @@ function decodeOptionsBatch(bytes) {
   return row ?? {};
 }
 var emptyResultSchema = schema2([]);
-var attachOpaqueDataParam = schema2([
-  field2("attach_opaque_data", binary2(), true)
-]);
-var attachOpaqueDataTxnParams = schema2([
-  field2("attach_opaque_data", binary2(), true),
-  field2("transaction_opaque_data", binary2(), true)
-]);
-var attachOpaqueDataNameTxnParams = schema2([
-  field2("attach_opaque_data", binary2(), true),
-  field2("name", utf82(), false),
-  field2("transaction_opaque_data", binary2(), true)
-]);
-var attachOpaqueDataSchemaNameTxnParams = schema2([
-  field2("attach_opaque_data", binary2(), true),
-  field2("schema_name", utf82(), false),
-  field2("name", utf82(), false),
-  field2("transaction_opaque_data", binary2(), true)
-]);
-var schemaNameIgnoreNotFoundTxnParams = schema2([
-  field2("attach_opaque_data", binary2(), true),
-  field2("schema_name", utf82(), false),
-  field2("name", utf82(), false),
-  field2("ignore_not_found", bool2(), true),
-  field2("transaction_opaque_data", binary2(), true)
-]);
-var schemaNameCommentParams = schema2([
-  field2("attach_opaque_data", binary2(), true),
-  field2("schema_name", utf82(), false),
-  field2("name", utf82(), false),
-  field2("comment", utf82(), true),
-  field2("ignore_not_found", bool2(), true),
-  field2("transaction_opaque_data", binary2(), true)
-]);
-var schemaNameRenameParams = schema2([
-  field2("attach_opaque_data", binary2(), true),
-  field2("schema_name", utf82(), false),
-  field2("name", utf82(), false),
-  field2("new_name", utf82(), false),
-  field2("ignore_not_found", bool2(), true),
-  field2("transaction_opaque_data", binary2(), true)
-]);
-var columnOpParams = schema2([
-  field2("attach_opaque_data", binary2(), true),
-  field2("schema_name", utf82(), false),
-  field2("name", utf82(), false),
-  field2("column_name", utf82(), false),
-  field2("ignore_not_found", bool2(), true),
-  field2("transaction_opaque_data", binary2(), true)
-]);
+
+// src/request-auth.ts
+var scope;
+function setRequestAuthScope(next) {
+  scope = next;
+}
+function currentRequestAuth() {
+  return scope?.getStore()?.auth;
+}
+
+// src/protocol/serializers/splits.ts
+var SCAN_SPLIT_SCHEMA = ScanSplitSchema;
+var PLAN_RESPONSE_SCHEMA = TableFunctionPlanResultSchema;
+function deserializePlanRequest(params) {
+  const bindCallBytes = toUint8Array2(params.bind_call);
+  const bindCall = deserializeBindRequest(batchToScalarDict(deserializeBatch(bindCallBytes)));
+  let projectionIds = null;
+  if (params.projection_ids != null) {
+    const raw = params.projection_ids;
+    if (Array.isArray(raw))
+      projectionIds = raw.map(Number);
+    else if (raw && typeof raw[Symbol.iterator] === "function")
+      projectionIds = [...raw].map(Number);
+  }
+  const asBigInt = (v) => v == null ? null : typeof v === "bigint" ? v : BigInt(Number(v));
+  return {
+    bind_call: bindCall,
+    bind_opaque_data: params.bind_opaque_data ? toUint8Array2(params.bind_opaque_data) : null,
+    projection_ids: projectionIds,
+    pushdown_filters: params.pushdown_filters ? toUint8Array2(params.pushdown_filters) : null,
+    target_split_bytes: asBigInt(params.target_split_bytes),
+    min_splits: asBigInt(params.min_splits),
+    cursor: params.cursor ? toUint8Array2(params.cursor) : null
+  };
+}
+function fingerprintInputs(bindCallBytes) {
+  const dict = batchToScalarDict(deserializeBatch(bindCallBytes));
+  return {
+    schemaName: dict.schema_name == null ? "" : String(dict.schema_name),
+    functionName: String(dict.function_name ?? ""),
+    args: dict.arguments ? toUint8Array2(dict.arguments) : new Uint8Array(0),
+    settings: dict.settings ? toUint8Array2(dict.settings) : new Uint8Array(0)
+  };
+}
+function scanSplitRow(split, token) {
+  const asBigInt = (v) => v == null ? null : typeof v === "bigint" ? v : BigInt(v);
+  return {
+    payload: new Uint8Array(0),
+    token,
+    estimated_rows: asBigInt(split.estimatedRows),
+    rows_exact: split.rowsExact === true,
+    estimated_bytes: asBigInt(split.estimatedBytes),
+    partition_bounds: split.partitionBounds ?? null,
+    column_statistics: split.columnStatistics ?? null,
+    location_ids: split.locationIds ?? null,
+    start_position: split.startPosition ?? null,
+    end_position: split.endPosition ?? null
+  };
+}
+function planResponseRow(result, splitBlobs) {
+  const asBigInt = (v) => v == null ? null : typeof v === "bigint" ? v : BigInt(v);
+  return {
+    splits: splitBlobs,
+    next_cursors: result.nextCursors ?? [],
+    execution_id: null,
+    init_opaque_data: new Uint8Array(0),
+    max_workers: asBigInt(result.maxWorkers),
+    estimated_total_splits: asBigInt(result.estimatedTotalSplits),
+    estimated_total_rows: asBigInt(result.estimatedTotalRows),
+    estimated_total_bytes: asBigInt(result.estimatedTotalBytes),
+    catalog_version: asBigInt(result.catalogVersion),
+    scope: result.scope ?? "catalog",
+    locations: null,
+    partitioning: [],
+    sort_order: [],
+    cache_max_age_seconds: asBigInt(result.cacheMaxAgeSeconds),
+    start_position: new Uint8Array(0),
+    end_position: new Uint8Array(0)
+  };
+}
+
+// src/split-token.ts
+var SPLIT_TOKEN_FORMAT_VERSION = 1;
+var FLAG_PAYLOAD_SEALED = 1;
+var RESERVED_FLAGS_MASK = 254;
+var FINGERPRINT_LEN = 16;
+var HEADER_LEN = 4 + FINGERPRINT_LEN;
+var SEAL_VERSION = 1;
+var AAD_PREFIX = new TextEncoder().encode("vgi.split_token.v1\x00");
+var SPLIT_TOKEN_INVALID = "SPLIT_TOKEN_INVALID";
+var SPLIT_SNAPSHOT_EXPIRED = "SPLIT_SNAPSHOT_EXPIRED";
+class SplitTokenError extends Error {
+  kind;
+  constructor(kind, message) {
+    super(`[${kind}] ${message}`);
+    this.name = "SplitTokenError";
+    this.kind = kind;
+  }
+}
+function concat2(...parts) {
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+function equalBytes2(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0;i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+async function bindFingerprint(schemaName, functionName, args, settings, projection) {
+  const enc = new TextEncoder;
+  const zero = Uint8Array.of(0);
+  const field3 = (label, value) => concat2(enc.encode(label), zero, value, zero);
+  const message = concat2(AAD_PREFIX, field3("schema_name", enc.encode(schemaName)), field3("function_name", enc.encode(functionName)), field3("arguments", args), field3("settings", settings), field3("projection_ids", projection));
+  const digest = await crypto.subtle.digest("SHA-256", message);
+  return new Uint8Array(digest).slice(0, FINGERPRINT_LEN);
+}
+function splitTokenAad(header, auth) {
+  return concat2(header, identityTail(auth));
+}
+function splitAnchor(catalogVersion) {
+  const out = new Uint8Array(8);
+  new DataView(out.buffer).setBigInt64(0, BigInt(catalogVersion), true);
+  return out;
+}
+async function buildSplitToken(opts) {
+  const { payload, fingerprint, anchor, signingKey, auth } = opts;
+  if (fingerprint.length !== FINGERPRINT_LEN) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, `bind_fingerprint must be ${FINGERPRINT_LEN} bytes, got ${fingerprint.length}`);
+  }
+  if (anchor.length > 65535) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, `consistency_anchor too long: ${anchor.length} bytes exceeds u16`);
+  }
+  const head = new Uint8Array(4);
+  head[0] = SPLIT_TOKEN_FORMAT_VERSION;
+  head[1] = signingKey ? FLAG_PAYLOAD_SEALED : 0;
+  new DataView(head.buffer).setUint16(2, anchor.length, true);
+  const body = concat2(head, fingerprint, anchor);
+  if (!signingKey)
+    return concat2(body, payload);
+  const sealed = await sealBytes(payload, signingKey, splitTokenAad(body, auth), SEAL_VERSION);
+  return concat2(body, sealed);
+}
+async function openSplitToken(token, opts = {}) {
+  const { signingKey, auth, expectedFingerprint, currentAnchor } = opts;
+  if (token.length < HEADER_LEN) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, `split token too short: ${token.length} bytes, need at least ${HEADER_LEN}`);
+  }
+  const version = token[0];
+  const flags = token[1];
+  const view = new DataView(token.buffer, token.byteOffset, token.byteLength);
+  const anchorLen = view.getUint16(2, true);
+  if (version !== SPLIT_TOKEN_FORMAT_VERSION) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, `unsupported split-token format_version ${version}; this worker speaks ` + `${SPLIT_TOKEN_FORMAT_VERSION}`);
+  }
+  if (flags & RESERVED_FLAGS_MASK) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, `split token sets reserved flag bits (flags=0x${flags.toString(16).padStart(2, "0")})`);
+  }
+  const sealed = (flags & FLAG_PAYLOAD_SEALED) !== 0;
+  if (signingKey && !sealed) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, "split token is unsealed but this worker holds a signing key; refusing. An unsealed " + "token cannot be authenticated, so accepting one here would let any caller forge a " + "split (alg:none).");
+  }
+  if (!signingKey && sealed) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, "split token is sealed but this worker holds no signing key; cannot open it");
+  }
+  const endOfAnchor = HEADER_LEN + anchorLen;
+  if (token.length < endOfAnchor) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, `split token truncated: anchor_len=${anchorLen} exceeds token length ${token.length}`);
+  }
+  const fingerprint = token.subarray(4, HEADER_LEN);
+  const anchor = token.subarray(HEADER_LEN, endOfAnchor);
+  const body = token.subarray(0, endOfAnchor);
+  const rest = token.subarray(endOfAnchor);
+  if (expectedFingerprint && !equalBytes2(fingerprint, expectedFingerprint)) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, "split token was minted for a different bind (fingerprint mismatch)");
+  }
+  if (currentAnchor && !equalBytes2(anchor, currentAnchor)) {
+    throw new SplitTokenError(SPLIT_SNAPSHOT_EXPIRED, "split snapshot expired; re-run the query");
+  }
+  if (!sealed)
+    return new Uint8Array(rest);
+  try {
+    return await openBytes(rest, signingKey, splitTokenAad(body, auth), SEAL_VERSION, "split token");
+  } catch (err2) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, `split token failed authentication: ${err2 instanceof Error ? err2.message : String(err2)}`);
+  }
+}
 
 // src/protocol/handlers/function.ts
+async function liveSplitAnchor(catalogInterface, bindCall, auth, signingKey) {
+  if (!catalogInterface?.version || bindCall.attach_opaque_data == null)
+    return;
+  const raw = toUint8Array(bindCall.attach_opaque_data);
+  const txn = bindCall.transaction_opaque_data ? toUint8Array(bindCall.transaction_opaque_data) : undefined;
+  const forms = [
+    async () => raw,
+    async () => openAttach(raw, auth, signingKey)
+  ];
+  for (const form of forms) {
+    try {
+      return splitAnchor(await catalogInterface.version(await form(), txn));
+    } catch {}
+  }
+  return;
+}
+async function resolveSplitPayloads(request, innerParams, opts) {
+  if (!request.split_tokens)
+    return;
+  const fp = fingerprintInputs(toUint8Array(innerParams.bind_call));
+  const expected = await bindFingerprint(fp.schemaName, fp.functionName, fp.args, fp.settings, new Uint8Array(0));
+  const currentAnchor = opts.checkAnchor ? await liveSplitAnchor(opts.catalogInterface, request.bind_call, opts.auth, opts.signingKey) : undefined;
+  request.split_payloads = [];
+  for (const token of request.split_tokens) {
+    request.split_payloads.push(await openSplitToken(token, {
+      signingKey: opts.signingKey,
+      auth: opts.auth,
+      expectedFingerprint: expected,
+      currentAnchor
+    }));
+  }
+}
 function registerFunctionMethods(protocol, config) {
   const { registry, signingKey, catalogInterface } = config;
   async function stripAttach(attach, ctx) {
@@ -4829,7 +5232,7 @@ function registerFunctionMethods(protocol, config) {
     const env = toUint8Array(attach);
     if (env.length === 0)
       return env;
-    return openAttach(env, ctx?.auth, signingKey);
+    return openAttach(env, ctx?.auth ?? currentRequestAuth(), signingKey);
   }
   async function strippedContext(bindCall, ctx) {
     let attach = null;
@@ -4840,17 +5243,13 @@ function registerFunctionMethods(protocol, config) {
     }
     return overloadContext({ ...bindCall, attach_opaque_data: attach }, catalogInterface);
   }
-  const initHeaderSchema = schema2([
-    field2("execution_id", binary2(), false),
-    field2("opaque_data", binary2(), true),
-    field2("max_workers", int642(), false)
-  ]);
+  const initHeaderSchema = GLOBAL_INIT_RESPONSE_SCHEMA;
   const emptySchema = schema2([]);
   const dummyInputSchema = schema2([
     field2("_tick", binary2(), true)
   ]);
   protocol.unary("bind", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: BindParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params, ctx) => {
       const innerParams = unwrapRequest(params.request);
@@ -4863,14 +5262,21 @@ function registerFunctionMethods(protocol, config) {
     }
   });
   protocol.exchange("init", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: InitParamsSchema,
     inputSchema: dummyInputSchema,
     outputSchema: emptySchema,
-    init: async (params) => {
+    init: async (params, ctx) => {
       const requestIpcBytes = toUint8Array(params.request);
       const innerParams = unwrapRequest(params.request);
       const request = deserializeInitRequest(innerParams);
-      request.bind_call.attach_opaque_data = await stripAttach(request.bind_call.attach_opaque_data, undefined);
+      const auth = ctx?.auth ?? currentRequestAuth();
+      request.bind_call.attach_opaque_data = await stripAttach(request.bind_call.attach_opaque_data, ctx);
+      await resolveSplitPayloads(request, innerParams, {
+        auth,
+        signingKey,
+        catalogInterface,
+        checkAnchor: true
+      });
       const func = registry.get(request.bind_call.function_name, overloadContext(request.bind_call, catalogInterface));
       const initResponse = await func.globalInit(request);
       const accumulatedState = recoverFinalizeState(request, config.recoverExchangeState);
@@ -4911,6 +5317,12 @@ function registerFunctionMethods(protocol, config) {
         const initRequestBatch = deserializeBatch(state.initRequestIpc);
         const initRequestDict = batchToScalarDict(initRequestBatch);
         const request = deserializeInitRequest(initRequestDict);
+        await resolveSplitPayloads(request, { bind_call: initRequestDict.bind_call }, {
+          auth: currentRequestAuth(),
+          signingKey,
+          catalogInterface,
+          checkAnchor: false
+        });
         const func = registry.get(state.functionName, await strippedContext(request.bind_call));
         const executionId = state.executionId;
         const opaqueData = state.opaqueData ?? null;
@@ -4954,7 +5366,7 @@ function registerFunctionMethods(protocol, config) {
     }
   });
   protocol.unary("table_function_cardinality", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: TableFunctionCardinalityParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const innerParams = unwrapRequest(params.request);
@@ -4969,8 +5381,36 @@ function registerFunctionMethods(protocol, config) {
       return wrapResult(cardResult, TableFunctionCardinalityResultSchema);
     }
   });
+  protocol.unary("table_function_plan", {
+    params: TableFunctionPlanParamsSchema,
+    result: RESULT_BINARY_SCHEMA,
+    handler: async (params, ctx) => {
+      const innerParams = unwrapRequest(params.request);
+      const request = deserializePlanRequest(innerParams);
+      const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
+      const plan = func.plan ? await func.plan(request) : { splits: [{ payload: new Uint8Array(0) }] };
+      const fp = fingerprintInputs(toUint8Array(innerParams.bind_call));
+      const fingerprint = await bindFingerprint(fp.schemaName, fp.functionName, fp.args, fp.settings, new Uint8Array(0));
+      const anchor = plan.catalogVersion != null ? splitAnchor(plan.catalogVersion) : await liveSplitAnchor(catalogInterface, request.bind_call, ctx?.auth, signingKey) ?? splitAnchor(0);
+      const blobs = [];
+      for (const split of plan.splits) {
+        const token = await buildSplitToken({
+          payload: split.payload,
+          fingerprint,
+          anchor,
+          signingKey,
+          auth: ctx?.auth
+        });
+        blobs.push(serializeBatch(batchFromColumns(Object.fromEntries(SCAN_SPLIT_SCHEMA.fields.map((f) => [
+          f.name,
+          [scanSplitRow(split, token)[f.name] ?? null]
+        ])), SCAN_SPLIT_SCHEMA)));
+      }
+      return wrapResult(planResponseRow(plan, blobs), PLAN_RESPONSE_SCHEMA);
+    }
+  });
   protocol.unary("table_function_statistics", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: TableFunctionStatisticsParamsSchema,
     result: RESULT_BINARY_NULLABLE_SCHEMA,
     handler: async (params) => {
       const innerParams = unwrapRequest(params.request);
@@ -4985,7 +5425,7 @@ function registerFunctionMethods(protocol, config) {
     }
   });
   protocol.unary("table_function_dynamic_to_string", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: TableFunctionDynamicToStringParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const innerParams = unwrapRequest(params.request);
@@ -5078,6 +5518,26 @@ function choiceEquals(choice, value) {
     return cn === vn;
   return choice === value;
 }
+function narrowArgValue(value) {
+  return typeof value === "bigint" ? Number(value) : value;
+}
+function assertArrowType(value, where) {
+  if (typeof value === "function") {
+    const name = value.name;
+    const call = name ? `${name}()` : "the factory";
+    throw new ArgumentValidationError(`${where} is a type factory, not an Arrow type — call it: ${call}. ` + `(Note that int, int32, float32 and bool are ready-made types on ` + `@query-farm/vgi but factories on @query-farm/vgi/worker-cf, so the ` + `same name may need parentheses on one entry point and not the other. ` + `int64(), float64(), utf8() and the rest are factories everywhere.)`);
+  }
+  if (value === null || value === undefined) {
+    throw new ArgumentValidationError(`${where} is ${String(value)}, not an Arrow type.`);
+  }
+}
+function assertArrowTypes(types, where) {
+  if (!types)
+    return;
+  for (const [name, type] of Object.entries(types)) {
+    assertArrowType(type, `${where}.${name}`);
+  }
+}
 function validateConstConstraints(name, constraints, value) {
   if (value === null || value === undefined)
     return;
@@ -5305,6 +5765,7 @@ function persistGroupStates(executionId, gids) {
   }
 }
 function defineAggregate(config) {
+  assertArrowTypes(config.args, `defineAggregate("${config.name}"): args`);
   const specs = [];
   let posIdx = 0;
   const varargsSet = new Set(config.varargs ?? []);
@@ -5369,7 +5830,7 @@ function registerAggregateMethods(protocol, registry) {
     return func.aggregateConfig;
   }
   protocol.unary("aggregate_bind", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: AggregateBindParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const innerParams = unwrapRequest(params.request);
@@ -5401,7 +5862,7 @@ function registerAggregateMethods(protocol, registry) {
     }
   });
   protocol.unary("aggregate_update", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: AggregateUpdateParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: (params) => {
       const innerParams = unwrapRequest(params.request);
@@ -5454,7 +5915,7 @@ function registerAggregateMethods(protocol, registry) {
     }
   });
   protocol.unary("aggregate_combine", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: AggregateCombineParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: (params) => {
       const innerParams = unwrapRequest(params.request);
@@ -5499,7 +5960,7 @@ function registerAggregateMethods(protocol, registry) {
     }
   });
   protocol.unary("aggregate_finalize", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: AggregateFinalizeParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: (params) => {
       const innerParams = unwrapRequest(params.request);
@@ -5537,7 +5998,7 @@ function registerAggregateMethods(protocol, registry) {
     }
   });
   protocol.unary("aggregate_destructor", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: AggregateDestructorParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: (params) => {
       const innerParams = unwrapRequest(params.request);
@@ -6353,7 +6814,7 @@ function registerTableBufferingMethods(protocol, registry, signingKey) {
     return { func, params };
   }
   protocol.unary("table_buffering_process", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: TableBufferingProcessParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (rpcParams, ctx) => {
       const inner = unwrapRequest(rpcParams.request);
@@ -6371,7 +6832,7 @@ function registerTableBufferingMethods(protocol, registry, signingKey) {
     }
   });
   protocol.unary("table_buffering_combine", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: TableBufferingCombineParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (rpcParams, ctx) => {
       const inner = unwrapRequest(rpcParams.request);
@@ -6389,7 +6850,7 @@ function registerTableBufferingMethods(protocol, registry, signingKey) {
     }
   });
   protocol.unary("table_buffering_destructor", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: TableBufferingDestructorParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (rpcParams) => {
       try {
@@ -6424,9 +6885,6 @@ function hex(buf) {
   return Array.from(buf, (b) => b.toString(16).padStart(2, "0")).join("");
 }
 
-// src/protocol/handlers/catalog/admin.ts
-init_arrow();
-
 // src/codec/asd.ts
 init_arrow();
 function encodeASD(schema3, obj) {
@@ -6461,21 +6919,35 @@ var encodeAttachCatalogInfo = (v) => encodeASD(AttachCatalogInfoSchema, {
   required: v.required ?? false,
   secret_ref: v.secret_ref ?? ""
 });
+function encodeScanFunctionResult(functionName, argumentsBytes, requiredExtensions = []) {
+  return serializeBatch(batchFromColumns({
+    function_name: [functionName],
+    arguments: [argumentsBytes],
+    required_extensions: [requiredExtensions]
+  }, ScanFunctionResultSchema));
+}
 function singleBranchResult(legacy) {
-  const branchBatch = batchFromColumns({
-    function_name: [legacy.function_name],
-    arguments: [toUint8Array(legacy.arguments)],
-    branch_filter: [null],
-    writable: [false],
-    source_catalog: [null],
-    source_schema: [null],
-    source_table: [null]
-  }, ScanBranchSchema);
   return {
-    branches: [serializeBatch(branchBatch)],
+    branches: [
+      encodeScanBranch({ function_name: legacy.function_name, arguments: toUint8Array(legacy.arguments) })
+    ],
     required_extensions: legacy.required_extensions ?? []
   };
 }
+function encodeScanBranch(cols) {
+  return serializeBatch(batchFromColumns({
+    function_name: [cols.function_name],
+    arguments: [cols.arguments],
+    branch_filter: [cols.branch_filter ?? null],
+    writable: [cols.writable ?? false],
+    source_catalog: [cols.source_catalog ?? null],
+    source_schema: [cols.source_schema ?? null],
+    source_table: [cols.source_table ?? null],
+    format_name: [cols.format_name ?? null],
+    format_locations: [cols.format_locations ?? null],
+    format_options: [cols.format_options ?? null]
+  }, ScanBranchSchema));
+}
 function isPromise(v) {
   return v != null && typeof v.then === "function";
 }
@@ -6608,7 +7080,7 @@ class CatalogInterface {
 // src/protocol/handlers/catalog/admin.ts
 function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
   catalogUnary(protocol, signingKey, "catalog_catalogs", {
-    params: emptyResultSchema,
+    params: CatalogCatalogsParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async () => {
       const cat = getCatalog();
@@ -6624,7 +7096,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   protocol.unary("catalog_attach", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: CatalogAttachParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params, ctx) => {
       const innerParams = unwrapRequest(params.request);
@@ -6654,7 +7126,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_detach", {
-    params: attachOpaqueDataParam,
+    params: CatalogDetachParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6663,11 +7135,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_create", {
-    params: schema2([
-      field2("name", utf82(), false),
-      field2("on_conflict", utf82(), false),
-      field2("options", binary2(), true)
-    ]),
+    params: CatalogCreateParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6676,7 +7144,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_drop", {
-    params: schema2([field2("name", utf82(), false)]),
+    params: CatalogDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6685,7 +7153,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_version", {
-    params: attachOpaqueDataTxnParams,
+    params: CatalogVersionParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6694,7 +7162,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   protocol.unary("catalog_transaction_begin", {
-    params: attachOpaqueDataParam,
+    params: CatalogTransactionBeginParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params, ctx) => {
       const auth = ctx?.auth;
@@ -6707,7 +7175,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_transaction_commit", {
-    params: attachOpaqueDataTxnParams,
+    params: CatalogTransactionCommitParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6716,7 +7184,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_transaction_rollback", {
-    params: attachOpaqueDataTxnParams,
+    params: CatalogTransactionRollbackParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6725,7 +7193,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_schemas", {
-    params: attachOpaqueDataTxnParams,
+    params: CatalogSchemasParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6736,7 +7204,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_copy_from_formats", {
-    params: attachOpaqueDataTxnParams,
+    params: CatalogCopyFromFormatsParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6747,7 +7215,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_schema_get", {
-    params: attachOpaqueDataNameTxnParams,
+    params: CatalogSchemaGetParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6758,13 +7226,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_schema_create", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("name", utf82(), false),
-      field2("comment", utf82(), true),
-      field2("tags", binary2(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogSchemaCreateParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6773,13 +7235,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_schema_drop", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("name", utf82(), false),
-      field2("ignore_not_found", bool2(), true),
-      field2("cascade", bool2(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogSchemaDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6788,7 +7244,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_schema_contents_tables", {
-    params: attachOpaqueDataNameTxnParams,
+    params: CatalogSchemaContentsTablesParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6799,7 +7255,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_schema_contents_views", {
-    params: attachOpaqueDataNameTxnParams,
+    params: CatalogSchemaContentsViewsParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6810,12 +7266,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_schema_contents_functions", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("name", utf82(), false),
-      field2("type", utf82(), false),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogSchemaContentsFunctionsParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6828,17 +7279,9 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
 }
 
 // src/protocol/handlers/catalog/table.ts
-init_arrow();
 function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
   catalogUnary(protocol, signingKey, "catalog_table_get", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("at_unit", utf82(), true),
-      field2("at_value", utf82(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogTableGetParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6849,17 +7292,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_create", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("columns", binary2(), false),
-      field2("on_conflict", utf82(), false),
-      field2("not_null_constraints", list2(field2("item", int322(), false)), true),
-      field2("unique_constraints", list2(field2("item", list2(field2("item", int322(), false)), false)), true),
-      field2("check_constraints", list2(field2("item", utf82(), false)), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogTableCreateParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6868,13 +7301,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_drop", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("ignore_not_found", bool2(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogTableDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6883,12 +7310,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_column_statistics_get", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogTableColumnStatisticsGetParamsSchema,
     result: RESULT_BINARY_NULLABLE_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6897,14 +7319,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_scan_function_get", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("at_unit", utf82(), true),
-      field2("at_value", utf82(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogTableScanFunctionGetParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6913,14 +7328,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_scan_branches_get", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("at_unit", utf82(), true),
-      field2("at_value", utf82(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogTableScanBranchesGetParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6929,7 +7337,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_comment_set", {
-    params: schemaNameCommentParams,
+    params: CatalogTableCommentSetParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6938,7 +7346,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_rename", {
-    params: schemaNameRenameParams,
+    params: CatalogTableRenameParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6947,16 +7355,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_column_add", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("column_name", utf82(), false),
-      field2("column_type", utf82(), false),
-      field2("default_value", utf82(), true),
-      field2("ignore_not_found", bool2(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogTableColumnAddParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6965,7 +7364,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_column_drop", {
-    params: columnOpParams,
+    params: CatalogTableColumnDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6974,15 +7373,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_column_rename", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("column_name", utf82(), false),
-      field2("new_name", utf82(), false),
-      field2("ignore_not_found", bool2(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogTableColumnRenameParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -6991,15 +7382,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_column_default_set", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("column_name", utf82(), false),
-      field2("default_value", utf82(), false),
-      field2("ignore_not_found", bool2(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogTableColumnDefaultSetParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7008,7 +7391,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_column_default_drop", {
-    params: columnOpParams,
+    params: CatalogTableColumnDefaultDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7017,15 +7400,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_column_type_change", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("column_name", utf82(), false),
-      field2("new_type", utf82(), false),
-      field2("ignore_not_found", bool2(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogTableColumnTypeChangeParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7034,7 +7409,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_not_null_set", {
-    params: columnOpParams,
+    params: CatalogTableNotNullSetParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7043,7 +7418,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_not_null_drop", {
-    params: columnOpParams,
+    params: CatalogTableNotNullDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7054,10 +7429,9 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
 }
 
 // src/protocol/handlers/catalog/view.ts
-init_arrow();
 function registerCatalogViewMethods(protocol, getCatalog, signingKey) {
   catalogUnary(protocol, signingKey, "catalog_view_get", {
-    params: attachOpaqueDataSchemaNameTxnParams,
+    params: CatalogViewGetParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7068,14 +7442,7 @@ function registerCatalogViewMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_view_create", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("definition", utf82(), false),
-      field2("on_conflict", utf82(), false),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogViewCreateParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7084,7 +7451,7 @@ function registerCatalogViewMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_view_drop", {
-    params: schemaNameIgnoreNotFoundTxnParams,
+    params: CatalogViewDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7093,7 +7460,7 @@ function registerCatalogViewMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_view_rename", {
-    params: schemaNameRenameParams,
+    params: CatalogViewRenameParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7102,7 +7469,7 @@ function registerCatalogViewMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_view_comment_set", {
-    params: schemaNameCommentParams,
+    params: CatalogViewCommentSetParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7113,10 +7480,9 @@ function registerCatalogViewMethods(protocol, getCatalog, signingKey) {
 }
 
 // src/protocol/handlers/catalog/macro.ts
-init_arrow();
 function registerCatalogMacroMethods(protocol, getCatalog, signingKey) {
   catalogUnary(protocol, signingKey, "catalog_macro_get", {
-    params: attachOpaqueDataSchemaNameTxnParams,
+    params: CatalogMacroGetParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7127,7 +7493,7 @@ function registerCatalogMacroMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_macro_create", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: CatalogMacroCreateParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7137,13 +7503,7 @@ function registerCatalogMacroMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_macro_drop", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("ignore_not_found", bool2(), true),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogMacroDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7152,12 +7512,7 @@ function registerCatalogMacroMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_schema_contents_macros", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("name", utf82(), false),
-      field2("type", utf82(), false),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogSchemaContentsMacrosParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7170,14 +7525,9 @@ function registerCatalogMacroMethods(protocol, getCatalog, signingKey) {
 }
 
 // src/protocol/handlers/catalog/index_methods.ts
-init_arrow();
 function registerCatalogIndexMethods(protocol, getCatalog, signingKey) {
   catalogUnary(protocol, signingKey, "catalog_schema_contents_indexes", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("name", utf82(), false),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogSchemaContentsIndexesParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7188,12 +7538,7 @@ function registerCatalogIndexMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_index_get", {
-    params: schema2([
-      field2("attach_opaque_data", binary2(), true),
-      field2("schema_name", utf82(), false),
-      field2("name", utf82(), false),
-      field2("transaction_opaque_data", binary2(), true)
-    ]),
+    params: CatalogIndexGetParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
@@ -7334,9 +7679,35 @@ function createLandingRoutes(info) {
 }
 
 // src/http/fetch.ts
+var requestAuthStorage;
+var requestAuthStoragePending;
+function ensureRequestAuthStorage() {
+  if (requestAuthStorage !== undefined)
+    return Promise.resolve(requestAuthStorage);
+  requestAuthStoragePending ??= import("node:async_hooks").then((mod) => {
+    const storage2 = new mod.AsyncLocalStorage;
+    requestAuthStorage = storage2;
+    setRequestAuthScope(storage2);
+    return storage2;
+  }).catch(() => {
+    requestAuthStorage = null;
+    return null;
+  });
+  return requestAuthStoragePending;
+}
+var REQUEST_AUTH_DISPATCH_HOOK = {
+  onDispatchStart(info) {
+    const holder = requestAuthStorage?.getStore();
+    if (holder) {
+      holder.auth = info.authenticated ? new AuthContext(info.authDomain ?? "", true, info.principal ?? "", info.claims ?? {}) : AuthContext.anonymous();
+    }
+    return;
+  },
+  onDispatchEnd() {}
+};
 function createVgiFetch(opts) {
   if (!opts.landingInfo) {
-    throw new Error("createVgiFetch requires `landingInfo` ({ name, doc, version }). Without it " + "GET / serves vgi-rpc's generic placeholder instead of the VGI landing page " + "and GET /vgi-client.js 404s.");
+    throw new Error("createVgiFetch requires `landingInfo` ({ name, doc, version }). Without it GET / serves vgi-rpc's generic placeholder instead of the VGI landing page and GET /vgi-client.js 404s.");
   }
   const tokenTtl = opts.tokenTtl ?? 3600;
   const prefix = opts.prefix ?? "/vgi";
@@ -7356,12 +7727,19 @@ function createVgiFetch(opts) {
     tokenKey: opts.signingKey,
     tokenTtl,
     stateSerializer: arrowStateSerializer,
+    dispatchHook: REQUEST_AUTH_DISPATCH_HOOK,
+    authenticate: opts.authenticate,
     corsOrigins: opts.corsOrigins === null ? undefined : opts.corsOrigins ?? "*",
     repositoryUrl: opts.repositoryUrl,
     extraRoutes: createLandingRoutes(opts.landingInfo),
     enableLandingPage: false
   });
-  return async (req) => handler(req);
+  return async (req) => {
+    const storage2 = await ensureRequestAuthStorage();
+    if (!storage2)
+      return handler(req);
+    return storage2.run({}, () => handler(req));
+  };
 }
 // src/cache-control.ts
 var CACHE_TTL_KEY = "vgi.cache.ttl";
@@ -7382,9 +7760,9 @@ var CACHE_SCOPE_CATALOG = "catalog";
 var CACHE_SCOPE_TRANSACTION = "transaction";
 var VALID_SCOPES = [CACHE_SCOPE_CATALOG, CACHE_SCOPE_TRANSACTION];
 function cacheControlMetadata(cc, extra) {
-  const scope = cc.scope ?? CACHE_SCOPE_CATALOG;
-  if (!VALID_SCOPES.includes(scope)) {
-    throw new Error(`CacheControl.scope must be one of ${VALID_SCOPES.join(", ")}, got ${JSON.stringify(scope)}`);
+  const scope2 = cc.scope ?? CACHE_SCOPE_CATALOG;
+  if (!VALID_SCOPES.includes(scope2)) {
+    throw new Error(`CacheControl.scope must be one of ${VALID_SCOPES.join(", ")}, got ${JSON.stringify(scope2)}`);
   }
   for (const name of ["ttl", "staleWhileRevalidate", "staleIfError"]) {
     const value = cc[name];
@@ -7399,7 +7777,7 @@ function cacheControlMetadata(cc, extra) {
     md.set(CACHE_EXPIRES_KEY, cc.expires);
   if (cc.noStore)
     md.set(CACHE_NO_STORE_KEY, "1");
-  md.set(CACHE_SCOPE_KEY, scope);
+  md.set(CACHE_SCOPE_KEY, scope2);
   if (cc.etag !== undefined)
     md.set(CACHE_ETAG_KEY, cc.etag);
   if (cc.lastModified !== undefined)
@@ -7421,6 +7799,14 @@ function cacheControlMetadata(cc, extra) {
 // src/functions/scalar.ts
 init_arrow();
 function defineScalarFunction(config) {
+  assertArrowTypes(config.params, `defineScalarFunction("${config.name}"): params`);
+  assertArrowTypes(config.constParams, `defineScalarFunction("${config.name}"): constParams`);
+  if (config.returns !== undefined) {
+    assertArrowType(config.returns, `defineScalarFunction("${config.name}"): returns`);
+  }
+  for (const p of config.parameters ?? []) {
+    assertArrowType(p.type, `defineScalarFunction("${config.name}"): parameters["${p.name}"].type`);
+  }
   const repr = config.repr ?? "rich";
   const specs = [];
   if (config.parameters) {
@@ -7636,6 +8022,7 @@ function makeProjectingCollector(inner, targetSchema) {
   });
 }
 function defineTableFunction(config) {
+  assertArrowTypes(config.args, `defineTableFunction("${config.name}"): args`);
   const specs = [];
   let posIdx = 0;
   if (config.args) {
@@ -7675,7 +8062,9 @@ function defineTableFunction(config) {
     orderDependent: config.orderDependent,
     distinctDependent: config.distinctDependent,
     supportsBatchIndex: config.supportsBatchIndex,
-    partitionKind: config.partitionKind
+    partitionKind: config.partitionKind,
+    supportsSplits: config.supportsSplits,
+    splitTokenTtlSeconds: config.splitTokenTtlSeconds
   };
   function extractArgs(request) {
     const args = {};
@@ -7687,8 +8076,7 @@ function defineTableFunction(config) {
       } catch {
         val = request.arguments.get(spec.name, defaultVal);
       }
-      if (typeof val === "bigint")
-        val = safeNumber(val);
+      val = narrowArgValue(val);
       const constraints = config.argConstraints?.[spec.name];
       if (constraints)
         validateConstConstraints(spec.name, constraints, val);
@@ -7722,6 +8110,22 @@ function defineTableFunction(config) {
     async globalInit(request) {
       const executionId = new Uint8Array(16);
       crypto.getRandomValues(executionId);
+      if (request.split_payloads) {
+        if (config.onSplit) {
+          await config.onSplit(request.split_payloads, {
+            args: extractArgs(request.bind_call),
+            bindCall: request.bind_call,
+            settings: batchToScalarDict(request.bind_call.settings),
+            secrets: batchToSecretDict(request.bind_call.secrets),
+            resolvedSecretsProvided: request.bind_call.resolved_secrets_provided ?? false
+          });
+        }
+        return {
+          max_workers: config.maxWorkers ?? 1,
+          execution_id: request.execution_id ?? executionId,
+          opaque_data: null
+        };
+      }
       if (request.execution_id) {
         return {
           max_workers: config.maxWorkers ?? 1,
@@ -7763,6 +8167,7 @@ function defineTableFunction(config) {
         settings,
         secrets,
         pushdownFilters,
+        splitPayloads: request.split_payloads ?? undefined,
         storage: boundStorage,
         atUnit: request.bind_call.at_unit ?? undefined,
         atValue: request.bind_call.at_value ?? undefined
@@ -7814,6 +8219,18 @@ function defineTableFunction(config) {
         resolvedSecretsProvided: request.bind_call.resolved_secrets_provided ?? false
       });
     } : undefined,
+    plan: config.plan ? (request) => {
+      const args = extractArgs(request.bind_call);
+      const settings = batchToScalarDict(request.bind_call.settings);
+      const secrets = batchToSecretDict(request.bind_call.secrets);
+      return config.plan({
+        args,
+        bindCall: request.bind_call,
+        settings,
+        secrets,
+        resolvedSecretsProvided: request.bind_call.resolved_secrets_provided ?? false
+      }, request);
+    } : undefined,
     statistics: config.statistics ? (request) => {
       const args = extractArgs(request.bind_call);
       const settings = batchToScalarDict(request.bind_call.settings);
@@ -7845,6 +8262,7 @@ function defineTableFunction(config) {
 init_arrow();
 init_storage();
 function defineTableInOutFunction(config) {
+  assertArrowTypes(config.args, `defineTableInOutFunction("${config.name}"): args`);
   const specs = [];
   let posIdx = 0;
   if (config.args) {
@@ -7893,8 +8311,7 @@ function defineTableInOutFunction(config) {
         continue;
       const defaultVal = config.argDefaults?.[spec.name] !== undefined ? config.argDefaults[spec.name] : undefined;
       let val = request.arguments.get(spec.position, defaultVal);
-      if (typeof val === "bigint")
-        val = Number(val);
+      val = narrowArgValue(val);
       args[spec.name] = val;
     }
     return args;
@@ -8171,8 +8588,7 @@ function defineRowTransformFunction(config) {
         continue;
       const defaultVal = config.argDefaults?.[spec.name] !== undefined ? config.argDefaults[spec.name] : undefined;
       let val = request.arguments.get(spec.position, defaultVal ?? null);
-      if (typeof val === "bigint")
-        val = Number(val);
+      val = narrowArgValue(val);
       args[spec.name] = val;
     }
     return args;
@@ -8680,6 +9096,10 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
       order_preservation: meta.preservesOrder,
       max_workers: meta.maxWorkers ?? DEFAULT_MAX_WORKERS,
       supports_batch_index: f.kind === "table_buffering" && f.meta.requiresInputBatchIndex === true || f.kind === "table" && f.meta.supportsBatchIndex === true,
+      supports_splits: f.kind === "table" && f.meta.supportsSplits === true,
+      filters_exactly_applied: f.kind === "table" && f.meta.filtersExactlyApplied === true,
+      supports_positions: f.kind === "table" && f.meta.supportsPositions === true,
+      split_token_ttl_seconds: f.kind === "table" ? f.meta.splitTokenTtlSeconds ?? null : null,
       partition_kind: f.kind === "table" && f.meta.partitionKind ? f.meta.partitionKind : "NOT_PARTITIONED",
       order_dependent: meta.orderDependent,
       distinct_dependent: meta.distinctDependent,
@@ -9030,17 +9450,7 @@ function inferScalarType(val) {
 function inlineScanFunction(func, args) {
   const argSchema = argumentSpecsToSchema(func.argumentSpecs);
   const argBytes = serializeArgsBatch(args ?? new Arguments, argSchema);
-  const scanSchema = schema2([
-    field2("function_name", utf82(), false),
-    field2("arguments", binary2(), false),
-    field2("required_extensions", list2(field2("item", utf82(), true)), false)
-  ]);
-  const batch = batchFromColumns({
-    function_name: [func.meta.name],
-    arguments: [argBytes],
-    required_extensions: [[]]
-  }, scanSchema);
-  return serializeBatch(batch);
+  return encodeScanFunctionResult(func.meta.name, argBytes);
 }
 // src/catalog/composite.ts
 var ROUTE_BYTE = 0;
@@ -9447,118 +9857,118 @@ class FunctionRegistry {
 }
 // src/worker-cf-entry.ts
 init_arrow();
-import { OutputCollector as OutputCollector2, AuthContext as AuthContext2 } from "@query-farm/vgi-rpc";
+import { OutputCollector as OutputCollector2, AuthContext as AuthContext3 } from "@query-farm/vgi-rpc";
 export {
-  utf82 as utf8,
-  union2 as union,
-  uint82 as uint8,
-  uint642 as uint64,
-  uint322 as uint32,
-  uint162 as uint16,
-  timestamp2 as timestamp,
-  timeSecond2 as timeSecond,
-  timeNanosecond2 as timeNanosecond,
-  timeMillisecond2 as timeMillisecond,
-  timeMicrosecond2 as timeMicrosecond,
-  time2 as time,
-  struct2 as struct,
-  sparseUnion2 as sparseUnion,
-  serializeSchema,
-  serializeColumnStatistics,
-  serializeBatch,
-  serializeAttachOptionSpecs,
-  serializeAttachOptionSpec,
-  schema2 as schema,
-  safeNumber,
-  projectSchema,
-  projectBatch,
-  parentRowsMetadata,
-  nullType2 as nullType,
-  map2 as map,
-  list2 as list,
-  iterRows,
-  isUtf8,
-  isUnion,
-  isTimestamp,
-  isTime,
-  isStruct,
-  isNull,
-  isMap,
-  isList,
-  isInterval,
-  isInt,
-  isFloat,
-  isFixedSizeList,
-  isFixedSizeBinary,
-  isDuration,
-  isDictionary,
-  isDecimal,
-  isDate,
-  isBool,
-  isBinary,
-  isBatch,
-  interval2 as interval,
-  int82 as int8,
-  int642 as int64,
-  int322 as int32,
-  int162 as int16,
-  int2 as int,
-  float642 as float64,
-  float322 as float32,
-  float162 as float16,
-  fixedSizeList2 as fixedSizeList,
-  fixedSizeBinary2 as fixedSizeBinary,
-  filterBatch,
-  field2 as field,
-  emptyBatch,
-  duration2 as duration,
-  dictionary2 as dictionary,
-  deserializeSchema,
-  deserializeBatch,
-  denseUnion2 as denseUnion,
-  defineTableInOutFunction,
-  defineTableFunction,
-  defineScalarFunction,
-  defineRowTransformFunction,
-  defineAggregate,
-  decodeDictValue,
-  decimal2562 as decimal256,
-  decimal1282 as decimal128,
-  decimal2 as decimal,
-  dateMillisecond2 as dateMillisecond,
-  dateDay2 as dateDay,
-  date2 as date,
-  createVgiFetch,
-  createLandingRoutes,
-  constraintSpecFields,
-  columnFromArray,
-  cacheControlMetadata,
-  buildStatisticsBatch,
-  bool2 as bool,
-  binary2 as binary,
-  batchToSecretDict,
-  batchToScalarDict,
-  batchFromRows,
-  batchFromColumns,
-  backend,
-  arrowStateSerializer,
-  UnionMode2 as UnionMode,
-  TypeId,
-  TimeUnit2 as TimeUnit,
-  ScanFunctionResultSchema,
-  ReadOnlyCatalogInterface,
-  PARENT_ROW_METADATA_KEY,
-  OutputCollector2 as OutputCollector,
-  IntervalUnit2 as IntervalUnit,
-  FunctionType,
-  FunctionRegistry,
-  EXCHANGE_STATE_SCHEMA,
-  DateUnit3 as DateUnit,
-  CompositeCatalogInterface,
-  CatalogInterface,
+  Arguments,
+  AuthContext3 as AuthContext,
   BindResultSchema,
-  AuthContext2 as AuthContext,
-  Arguments
+  CatalogInterface,
+  CompositeCatalogInterface,
+  DateUnit3 as DateUnit,
+  EXCHANGE_STATE_SCHEMA,
+  FunctionRegistry,
+  FunctionType,
+  IntervalUnit2 as IntervalUnit,
+  OutputCollector2 as OutputCollector,
+  PARENT_ROW_METADATA_KEY,
+  ReadOnlyCatalogInterface,
+  ScanFunctionResultSchema,
+  TimeUnit2 as TimeUnit,
+  TypeId,
+  UnionMode2 as UnionMode,
+  arrowStateSerializer,
+  backend,
+  batchFromColumns,
+  batchFromRows,
+  batchToScalarDict,
+  batchToSecretDict,
+  binary2 as binary,
+  bool2 as bool,
+  buildStatisticsBatch,
+  cacheControlMetadata,
+  columnFromArray,
+  constraintSpecFields,
+  createLandingRoutes,
+  createVgiFetch,
+  date2 as date,
+  dateDay2 as dateDay,
+  dateMillisecond2 as dateMillisecond,
+  decimal2 as decimal,
+  decimal1282 as decimal128,
+  decimal2562 as decimal256,
+  decodeDictValue,
+  defineAggregate,
+  defineRowTransformFunction,
+  defineScalarFunction,
+  defineTableFunction,
+  defineTableInOutFunction,
+  denseUnion2 as denseUnion,
+  deserializeBatch,
+  deserializeSchema,
+  dictionary2 as dictionary,
+  duration2 as duration,
+  emptyBatch,
+  field2 as field,
+  filterBatch,
+  fixedSizeBinary2 as fixedSizeBinary,
+  fixedSizeList2 as fixedSizeList,
+  float162 as float16,
+  float322 as float32,
+  float642 as float64,
+  int2 as int,
+  int162 as int16,
+  int322 as int32,
+  int642 as int64,
+  int82 as int8,
+  interval2 as interval,
+  isBatch,
+  isBinary,
+  isBool,
+  isDate,
+  isDecimal,
+  isDictionary,
+  isDuration,
+  isFixedSizeBinary,
+  isFixedSizeList,
+  isFloat,
+  isInt,
+  isInterval,
+  isList,
+  isMap,
+  isNull,
+  isStruct,
+  isTime,
+  isTimestamp,
+  isUnion,
+  isUtf8,
+  iterRows,
+  list2 as list,
+  map2 as map,
+  nullType2 as nullType,
+  parentRowsMetadata,
+  projectBatch,
+  projectSchema,
+  safeNumber,
+  schema2 as schema,
+  serializeAttachOptionSpec,
+  serializeAttachOptionSpecs,
+  serializeBatch,
+  serializeColumnStatistics,
+  serializeSchema,
+  sparseUnion2 as sparseUnion,
+  struct2 as struct,
+  time2 as time,
+  timeMicrosecond2 as timeMicrosecond,
+  timeMillisecond2 as timeMillisecond,
+  timeNanosecond2 as timeNanosecond,
+  timeSecond2 as timeSecond,
+  timestamp2 as timestamp,
+  uint162 as uint16,
+  uint322 as uint32,
+  uint642 as uint64,
+  uint82 as uint8,
+  union2 as union,
+  utf82 as utf8
 };
 
-//# debugId=A753E54332CCB1AB64756E2164756E21
+//# debugId=38EE66E6303DF6BF64756E2164756E21