@query-farm/vgi 0.28.0 → 0.29.0

package/dist/serve-entry.js

@@ -37,6 +37,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
 
 // src/functions/storage-cf-do.ts
 var exports_storage_cf_do = {};
@@ -531,7 +532,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/arrow/predicates.ts
 var TypeId = {
@@ -560,75 +565,113 @@ var TypeId = {
 function isDecimal(t) {
   return t.typeId === TypeId.Decimal;
 }
+function typeSignature(t) {
+  if (t == null)
+    return "null";
+  const a = t;
+  const kids = () => Array.isArray(a.children) ? a.children.map((c) => `${c?.name ?? ""}:${typeSignature(c?.type ?? c)}`).join(",") : "";
+  switch (t.typeId) {
+    case TypeId.Int:
+      return `int${a.bitWidth}${a.isSigned ?? a.signed ?? true ? "" : "u"}`;
+    case TypeId.Float:
+      return `float${a.precision}`;
+    case TypeId.Decimal:
+      return `decimal${a.bitWidth ?? 128}(${a.precision},${a.scale})`;
+    case TypeId.Date:
+    case TypeId.Time:
+    case TypeId.Duration:
+      return `${t.typeId}[${a.unit}]`;
+    case TypeId.Timestamp:
+      return `ts[${a.unit},${a.timezone ?? ""}]`;
+    case TypeId.Interval:
+      return `iv[${a.unit}]`;
+    case TypeId.FixedSizeBinary:
+      return `fsb(${a.byteWidth ?? a.stride})`;
+    case TypeId.FixedSizeList:
+      return `fsl(${a.listSize ?? a.stride},${kids()})`;
+    case TypeId.List:
+    case TypeId.Struct:
+    case TypeId.Map:
+      return `${t.typeId}<${kids()}>`;
+    case TypeId.Union:
+      return `union(${a.mode},${kids()})`;
+    case TypeId.Dictionary:
+      return `dict(${typeSignature(a.dictionary)},${typeSignature(a.indices)},${a.ordered ?? a.isOrdered ?? false})`;
+    default:
+      return Array.isArray(a.children) ? `${t.typeId}<${kids()}>` : String(t.typeId);
+  }
+}
 // 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
 });
 
 // src/arrow/impl-arrowjs/schema.ts
@@ -649,7 +692,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,
@@ -734,7 +779,9 @@ var float16 = () => new A_Float16;
 var float32 = () => new A_Float32;
 var float64 = () => new A_Float64;
 var utf8 = () => new A_Utf8;
+var largeUtf8 = () => new A_LargeUtf8;
 var binary = () => new A_Binary;
+var largeBinary = () => new A_LargeBinary;
 var fixedSizeBinary = (byteWidth) => new A_FixedSizeBinary(byteWidth);
 function decimal(precision, scale, bitWidth = 128) {
   return new A_Decimal(scale, precision, bitWidth);
@@ -2013,8 +2060,13 @@ function batchToSecretDict(batch) {
   }
   return result;
 }
+var MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+var MIN_SAFE = -MAX_SAFE;
 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;
@@ -2277,6 +2329,7 @@ var int642 = () => int64();
 var float642 = () => float64();
 var utf82 = () => utf8();
 var binary2 = () => binary();
+var largeBinary2 = () => largeBinary();
 var UNIT_TO_TAG = {
   [TimeUnit.SECOND]: "s",
   [TimeUnit.MILLISECOND]: "ms",
@@ -2324,6 +2377,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();
@@ -2342,7 +2416,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)`);
@@ -2583,10 +2657,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),
@@ -2595,26 +2678,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;
@@ -2684,20 +2751,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),
@@ -2749,10 +2818,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,
@@ -2820,10 +2898,6 @@ function serializeGlobalInitResponse(resp) {
   };
 }
 // src/protocol/serializers/cardinality.ts
-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)
@@ -2855,7 +2929,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([
@@ -2881,14 +2955,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([
@@ -2918,8 +2992,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),
@@ -2940,9 +3018,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),
@@ -2981,7 +3059,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),
@@ -2992,6 +3085,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)
@@ -3019,7 +3258,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)
@@ -3103,6 +3342,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)
 ]);
@@ -3469,6 +3726,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)
 ]);
@@ -4399,57 +4659,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) {
@@ -4458,7 +4896,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;
@@ -4469,17 +4907,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);
@@ -4492,14 +4926,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);
@@ -4540,6 +4981,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;
@@ -4583,7 +5030,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);
@@ -4598,8 +5045,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);
@@ -4614,7 +5089,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);
@@ -4815,7 +5290,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);
@@ -4847,7 +5322,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);
@@ -4900,7 +5375,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);
@@ -4945,7 +5420,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);
@@ -4983,7 +5458,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);
@@ -5142,7 +5617,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);
@@ -5160,7 +5635,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);
@@ -5178,7 +5653,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 {
@@ -5242,7 +5717,7 @@ var encodeCopyFromFormatInfo = (v) => encodeASD(CopyFromFormatInfoSchema, {
 // 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();
@@ -5258,7 +5733,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);
@@ -5288,7 +5763,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_detach", {
-    params: attachOpaqueDataParam,
+    params: CatalogDetachParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -5297,11 +5772,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();
@@ -5310,7 +5781,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();
@@ -5319,7 +5790,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();
@@ -5328,7 +5799,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;
@@ -5341,7 +5812,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_transaction_commit", {
-    params: attachOpaqueDataTxnParams,
+    params: CatalogTransactionCommitParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -5350,7 +5821,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_transaction_rollback", {
-    params: attachOpaqueDataTxnParams,
+    params: CatalogTransactionRollbackParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -5359,7 +5830,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();
@@ -5370,7 +5841,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();
@@ -5381,7 +5852,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();
@@ -5392,13 +5863,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();
@@ -5407,13 +5872,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();
@@ -5422,7 +5881,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();
@@ -5433,7 +5892,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();
@@ -5444,12 +5903,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();
@@ -5464,14 +5918,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
 // src/protocol/handlers/catalog/table.ts
 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();
@@ -5482,17 +5929,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();
@@ -5501,13 +5938,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();
@@ -5516,12 +5947,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();
@@ -5530,14 +5956,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();
@@ -5546,14 +5965,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();
@@ -5562,7 +5974,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();
@@ -5571,7 +5983,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_rename", {
-    params: schemaNameRenameParams,
+    params: CatalogTableRenameParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -5580,16 +5992,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();
@@ -5598,7 +6001,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();
@@ -5607,15 +6010,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();
@@ -5624,15 +6019,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();
@@ -5641,7 +6028,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();
@@ -5650,15 +6037,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();
@@ -5667,7 +6046,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();
@@ -5676,7 +6055,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();
@@ -5689,7 +6068,7 @@ function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
 // src/protocol/handlers/catalog/view.ts
 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();
@@ -5700,14 +6079,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();
@@ -5716,7 +6088,7 @@ function registerCatalogViewMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_view_drop", {
-    params: schemaNameIgnoreNotFoundTxnParams,
+    params: CatalogViewDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -5725,7 +6097,7 @@ function registerCatalogViewMethods(protocol, getCatalog, signingKey) {
     }
   });
   catalogUnary(protocol, signingKey, "catalog_view_rename", {
-    params: schemaNameRenameParams,
+    params: CatalogViewRenameParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
@@ -5734,7 +6106,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();
@@ -5747,7 +6119,7 @@ function registerCatalogViewMethods(protocol, getCatalog, signingKey) {
 // src/protocol/handlers/catalog/macro.ts
 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();
@@ -5758,7 +6130,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();
@@ -5768,13 +6140,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();
@@ -5783,12 +6149,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();
@@ -5803,11 +6164,7 @@ function registerCatalogMacroMethods(protocol, getCatalog, signingKey) {
 // src/protocol/handlers/catalog/index_methods.ts
 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();
@@ -5818,12 +6175,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();
@@ -5964,9 +6316,35 @@ function createLandingRoutes(info) {
 }
 
 // src/http/fetch.ts
+var requestAuthStorage;
+var requestAuthStoragePending;
+function ensureRequestAuthStorage() {
+  if (requestAuthStorage !== undefined)
+    return Promise.resolve(requestAuthStorage);
+  requestAuthStoragePending ??= import("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";
@@ -5986,12 +6364,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/serve-entry.ts
@@ -6063,7 +6448,8 @@ function createVgiWorkerFetch(opts) {
     serverId: opts.serverId ?? opts.name,
     corsOrigins,
     repositoryUrl: opts.repositoryUrl,
-    landingInfo: { name: opts.name, doc: opts.doc, version: opts.version }
+    landingInfo: { name: opts.name, doc: opts.doc, version: opts.version },
+    authenticate: opts.authenticate
   });
 }
 function serveVgiWorker(opts) {
@@ -6086,13 +6472,13 @@ function serveVgiWorker(opts) {
   return server;
 }
 export {
-  serveVgiWorker,
-  resolveSigningKey,
-  parseSigningKeyHex,
-  createVgiWorkerFetch,
-  SIGNING_KEY_BYTES,
+  DEFAULT_PORT,
   DEFAULT_TOKEN_TTL,
-  DEFAULT_PORT
+  SIGNING_KEY_BYTES,
+  createVgiWorkerFetch,
+  parseSigningKeyHex,
+  resolveSigningKey,
+  serveVgiWorker
 };
 
-//# debugId=AF152B2CA425E9C164756E2164756E21
+//# debugId=09DDD8782DD92B2764756E2164756E21