@query-farm/vgi 0.28.0 → 0.29.1

package/dist/serve-entry.js

@@ -1,28 +1,5 @@
 // @bun
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -36,14 +13,19 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
 
 // src/functions/storage-cf-do.ts
-var exports_storage_cf_do = {};
-__export(exports_storage_cf_do, {
-  FunctionStorageCfDo: () => FunctionStorageCfDo
-});
-
 class FunctionStorageCfDo {
   _baseUrl;
   _token;
@@ -184,8 +166,8 @@ class FunctionStorageCfDo {
       let resp;
       try {
         resp = await this._fetch(url, { method: "POST", headers, body: payload });
-      } catch (err2) {
-        lastErr = err2;
+      } catch (err) {
+        lastErr = err;
         continue;
       }
       let data;
@@ -230,16 +212,16 @@ function int64FromKey(b) {
   return Number(new DataView(b.buffer, b.byteOffset, 8).getBigInt64(0, false));
 }
 function bytesToB64(buf) {
-  let binary3 = "";
+  let binary = "";
   for (let i = 0;i < buf.length; i++)
-    binary3 += String.fromCharCode(buf[i]);
-  return btoa(binary3);
+    binary += String.fromCharCode(buf[i]);
+  return btoa(binary);
 }
 function b64ToBytes(b64) {
-  const binary3 = atob(b64);
-  const out = new Uint8Array(binary3.length);
-  for (let i = 0;i < binary3.length; i++)
-    out[i] = binary3.charCodeAt(i);
+  const binary = atob(b64);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++)
+    out[i] = binary.charCodeAt(i);
   return out;
 }
 var NS_WORKER;
@@ -481,18 +463,18 @@ class BoundStorage {
   }
 }
 function resolveStorageFromEnv() {
-  const backend2 = (process.env.VGI_WORKER_SHARED_STORAGE ?? "sqlite").toLowerCase();
-  if (backend2 === "memory") {
+  const backend = (process.env.VGI_WORKER_SHARED_STORAGE ?? "sqlite").toLowerCase();
+  if (backend === "memory") {
     return new FunctionStorageSqlite(":memory:");
   }
-  if (backend2 === "sqlite") {
+  if (backend === "sqlite") {
     return new FunctionStorageSqlite;
   }
-  if (backend2 === "cloudflare-do") {
-    const { FunctionStorageCfDo: FunctionStorageCfDo2 } = (init_storage_cf_do(), __toCommonJS(exports_storage_cf_do));
-    return FunctionStorageCfDo2.fromEnv();
+  if (backend === "cloudflare-do") {
+    init_storage_cf_do();
+    return FunctionStorageCfDo.fromEnv();
   }
-  throw new Error(`Unknown VGI_WORKER_SHARED_STORAGE backend: '${backend2}'. Supported: 'memory', 'sqlite', 'cloudflare-do'.`);
+  throw new Error(`Unknown VGI_WORKER_SHARED_STORAGE backend: '${backend}'. Supported: 'memory', 'sqlite', 'cloudflare-do'.`);
 }
 function getDefaultStorage() {
   if (_resolved == null)
@@ -530,8 +512,20 @@ var init_storage = __esm(() => {
   });
 });
 
+// src/serve-entry.ts
+import {
+  irohForwardedHeaderIdentityProvider,
+  IROH_FORWARDED_ENDPOINT_HEADER,
+  observePeerIdentity,
+  peerIdentityPrimary
+} from "@query-farm/vgi-rpc";
+
 // 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 +554,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 +681,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 +768,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);
@@ -793,8 +829,8 @@ import {
   DataType,
   makeData
 } from "@query-farm/apache-arrow";
-function emptyData(field2) {
-  const type = field2.type;
+function emptyData(field) {
+  const type = field.type;
   if (DataType.isList(type)) {
     const childField = type.children[0];
     return makeData({
@@ -821,8 +857,8 @@ function emptyData(field2) {
   }
   return makeData({ type, length: 0, nullCount: 0 });
 }
-function emptyBatch(schema2) {
-  const a = schema2;
+function emptyBatch(schema) {
+  const a = schema;
   const children = a.fields.map((f) => emptyData(f));
   const structType = new Struct(a.fields);
   const data = makeData({
@@ -1829,8 +1865,8 @@ function readUnion(type, col, data, index) {
   const children = type.children;
   const typeIds = data?.typeIds;
   const tcode = typeIds ? typeIds[index] : children.length > 0 ? 0 : -1;
-  const map2 = type.typeIdToChildIndex;
-  const childIdx = map2 && map2[tcode] !== undefined ? map2[tcode] : tcode;
+  const map = type.typeIdToChildIndex;
+  const childIdx = map && map[tcode] !== undefined ? map[tcode] : tcode;
   const childField = children[childIdx];
   if (!childField)
     return { tag: null, value: null };
@@ -1892,19 +1928,19 @@ function readDictionary(type, col, data, index) {
 function columnFromArray(values, type) {
   return vectorFromArray2(values, type).data[0];
 }
-function batchFromRows(rows, schema2) {
-  const a = schema2;
+function batchFromRows(rows, schema) {
+  const a = schema;
   if (rows.length === 0) {
     return emptyBatch(a);
   }
   const columns = {};
-  for (const field2 of a.fields) {
-    columns[field2.name] = rows.map((r) => r[field2.name] ?? null);
+  for (const field of a.fields) {
+    columns[field.name] = rows.map((r) => r[field.name] ?? null);
   }
   return batchFromColumns(columns, a);
 }
-function batchFromColumns(columns, schema2, repr = "rich") {
-  const a = schema2;
+function batchFromColumns(columns, schema, repr = "rich") {
+  const a = schema;
   const numRows = a.fields.length > 0 ? columns[a.fields[0].name]?.length ?? 0 : 0;
   const children = a.fields.map((f) => {
     const values = columns[f.name];
@@ -1932,15 +1968,15 @@ function* iterRows(batch, repr = "rich") {
   for (let i = 0;i < a.numRows; i++) {
     const row = {};
     for (let fi = 0;fi < a.schema.fields.length; fi++) {
-      const field2 = a.schema.fields[fi];
-      const col = a.getChild(field2.name);
+      const field = a.schema.fields[fi];
+      const col = a.getChild(field.name);
       if (!col) {
-        row[field2.name] = null;
+        row[field.name] = null;
         continue;
       }
-      const canonical = readCanonicalValue(field2.type, col, i);
+      const canonical = readCanonicalValue(field.type, col, i);
       const codec = codecs[fi];
-      row[field2.name] = repr === "raw" ? codec.canonicalToRaw(canonical) : codec.canonicalToRich(canonical);
+      row[field.name] = repr === "raw" ? codec.canonicalToRaw(canonical) : codec.canonicalToRich(canonical);
     }
     yield row;
   }
@@ -1952,12 +1988,12 @@ function batchToScalarDict(batch) {
   if (a.numRows === 0)
     return {};
   const result = {};
-  for (const field2 of a.schema.fields) {
-    const col = a.getChild(field2.name);
+  for (const field of a.schema.fields) {
+    const col = a.getChild(field.name);
     if (col) {
-      const type = field2.type;
+      const type = field.type;
       const canonical = readCanonicalValue(type, col, 0);
-      result[field2.name] = codecFor(type).canonicalToRich(canonical);
+      result[field.name] = codecFor(type).canonicalToRich(canonical);
     }
   }
   return result;
@@ -1983,18 +2019,18 @@ function batchToSecretDict(batch) {
   if (a.numRows === 0)
     return {};
   const result = {};
-  for (const field2 of a.schema.fields) {
-    const col = a.getChild(field2.name);
+  for (const field of a.schema.fields) {
+    const col = a.getChild(field.name);
     if (col) {
-      const type = field2.type;
+      const type = field.type;
       const val = codecFor(type).canonicalToRich(readCanonicalValue(type, col, 0));
-      let key = field2.name;
+      let key = field.name;
       let scope;
-      if (field2.name.startsWith("secret_")) {
-        const secretType = field2.metadata?.get?.("secret_type");
+      if (field.name.startsWith("secret_")) {
+        const secretType = field.metadata?.get?.("secret_type");
         if (secretType) {
           key = secretType;
-          scope = field2.metadata?.get?.("scope") ?? undefined;
+          scope = field.metadata?.get?.("scope") ?? undefined;
         }
       }
       if (val && typeof val === "object" && !ArrayBuffer.isView(val)) {
@@ -2013,8 +2049,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;
@@ -2038,11 +2079,11 @@ function filterBatch(batch, mask) {
       indices.push(i);
   }
   const columns = {};
-  for (const field2 of a.schema.fields) {
-    const col = a.getChild(field2.name);
-    const type = field2.type;
+  for (const field of a.schema.fields) {
+    const col = a.getChild(field.name);
+    const type = field.type;
     const codec = codecFor(type);
-    columns[field2.name] = indices.map((i) => codec.canonicalToRich(readCanonicalValue(type, col, i)));
+    columns[field.name] = indices.map((i) => codec.canonicalToRich(readCanonicalValue(type, col, i)));
   }
   return batchFromColumns(columns, a.schema);
 }
@@ -2064,8 +2105,8 @@ function validateProjectionIds(caller, projectionIds, fieldCount) {
   }
   return projectionIds.filter((i) => i >= 0 && i < fieldCount);
 }
-function projectSchema(projectionIds, schema2) {
-  const a = schema2;
+function projectSchema(projectionIds, schema) {
+  const a = schema;
   if (!projectionIds)
     return a;
   const validIds = validateProjectionIds("projectSchema", projectionIds, a.fields.length);
@@ -2106,9 +2147,9 @@ import {
   RecordBatchStreamWriter,
   RecordBatchReader
 } from "@query-farm/apache-arrow";
-function serializeSchema(schema2) {
+function serializeSchema(schema) {
   const writer = new RecordBatchStreamWriter;
-  writer.reset(undefined, schema2);
+  writer.reset(undefined, schema);
   writer.close();
   return writer.toUint8Array(true);
 }
@@ -2176,20 +2217,20 @@ function buildTypedColumnData(values, type) {
 function buildStatisticsBatch(stats) {
   if (stats.length === 0) {
     const nullField = new Field3("0", new Null, true);
-    const unionType2 = new SparseUnion([0], [nullField]);
-    const minData2 = makeData5({
-      type: unionType2,
+    const unionType = new SparseUnion([0], [nullField]);
+    const minData = makeData5({
+      type: unionType,
       length: 0,
       typeIds: new Int8Array(0),
       children: [makeData5({ type: new Null, length: 0, nullCount: 0 })]
     });
-    const maxData2 = makeData5({
-      type: unionType2,
+    const maxData = makeData5({
+      type: unionType,
       length: 0,
       typeIds: new Int8Array(0),
       children: [makeData5({ type: new Null, length: 0, nullCount: 0 })]
     });
-    return assemble([], minData2, maxData2, [], [], [], [], [], unionType2);
+    return assemble([], minData, maxData, [], [], [], [], [], unionType);
   }
   const typeOrder = [];
   const typeIdMap = new Map;
@@ -2233,7 +2274,7 @@ function buildStatisticsBatch(stats) {
   return assemble(stats.map((s) => s.columnName), minData, maxData, stats.map((s) => s.hasNull), stats.map((s) => s.hasNotNull), stats.map((s) => s.distinctCount == null ? null : BigInt(s.distinctCount)), stats.map((s) => s.containsUnicode), stats.map((s) => s.maxStringLength == null ? null : BigInt(s.maxStringLength)), unionType);
 }
 function assemble(columnNames, minData, maxData, hasNull, hasNotNull, distinctCount, containsUnicode, maxStringLength, unionType) {
-  const schema2 = new Schema5([
+  const schema = new Schema5([
     new Field3("column_name", new Utf8, false),
     new Field3("min", unionType, true),
     new Field3("max", unionType, true),
@@ -2254,9 +2295,9 @@ function assemble(columnNames, minData, maxData, hasNull, hasNotNull, distinctCo
     buildTypedColumnData(containsUnicode, new Bool),
     buildTypedColumnData(maxStringLength, new Uint64)
   ];
-  const structType = new Struct5(schema2.fields);
+  const structType = new Struct5(schema.fields);
   const data = makeData5({ type: structType, length: n, children, nullCount: 0 });
-  return new RecordBatch6(schema2, data);
+  return new RecordBatch6(schema, data);
 }
 
 // src/arrow/impl-arrowjs/index.ts
@@ -2274,9 +2315,11 @@ var bool2 = () => bool();
 var int162 = () => int16();
 var int322 = () => int32();
 var int642 = () => int64();
+var uint642 = () => uint64();
 var float642 = () => float64();
 var utf82 = () => utf8();
 var binary2 = () => binary();
+var largeBinary2 = () => largeBinary();
 var UNIT_TO_TAG = {
   [TimeUnit.SECOND]: "s",
   [TimeUnit.MILLISECOND]: "ms",
@@ -2324,6 +2367,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 +2406,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 +2647,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,25 +2668,10 @@ var BIND_REQUEST_SCHEMA = schema2([
   field2("resolved_secrets_provided", bool2(), false),
   field2("at_unit", utf82(), true),
   field2("at_value", utf82(), 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)
+  field2("copy_from", COPY_FROM_STRUCT_TYPE, true),
+  field2("copy_to", COPY_TO_STRUCT_TYPE, true),
+  field2("schema_path", list2(field2("item", utf82(), true)), true),
+  field2("argument_names", list2(field2("item", utf82(), true)), true)
 ]);
 function parseCopyFromContext(raw) {
   if (raw == null)
@@ -2665,7 +2723,8 @@ function deserializeBindRequest(params) {
     resolved_secrets_provided: params.resolved_secrets_provided ?? false,
     at_unit: params.at_unit ? String(params.at_unit) : null,
     at_value: params.at_value ? String(params.at_value) : null,
-    schema_name: params.schema_name ? String(params.schema_name) : null,
+    schema_path: params.schema_path ? (Array.isArray(params.schema_path) ? params.schema_path : [...params.schema_path]).map(String) : null,
+    argument_names: params.argument_names ? (Array.isArray(params.argument_names) ? params.argument_names : [...params.argument_names]).map((value) => value == null ? null : String(value)) : null,
     copy_from: parseCopyFromContext(params.copy_from),
     copy_to: parseCopyToContext(params.copy_to)
   };
@@ -2684,20 +2743,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 +2810,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 +2890,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,21 +2921,21 @@ 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([
   field2("comment", utf82(), true),
   field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
   field2("attach_opaque_data", binary2(), false),
-  field2("name", utf82(), false),
+  field2("path", list2(field2("item", utf82(), true)), false),
   field2("estimated_object_count", map2(field2("key", utf82(), false), field2("value", int642(), true), false), true)
 ]);
 var TableInfoSchema = schema2([
   field2("comment", utf82(), true),
   field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
   field2("name", utf82(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("columns", binary2(), false),
   field2("not_null_constraints", list2(field2("item", int322(), true)), false),
   field2("unique_constraints", list2(field2("item", list2(field2("item", int322(), true)), true)), false),
@@ -2881,21 +2947,21 @@ 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([
   field2("comment", utf82(), true),
   field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
   field2("name", utf82(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("definition", utf82(), false),
   field2("column_comments", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false)
 ]);
@@ -2903,12 +2969,14 @@ var FunctionInfoSchema = schema2([
   field2("comment", utf82(), true),
   field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
   field2("name", utf82(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("function_type", dictionary2(utf82(), int162()), false),
   field2("arguments", binary2(), false),
   field2("output_schema", binary2(), false),
+  field2("parameter_default_values", binary2(), true),
   field2("stability", dictionary2(utf82(), int162()), true),
   field2("null_handling", dictionary2(utf82(), int162()), true),
+  field2("argument_monotonicity", list2(field2("item", utf82(), true)), true),
   field2("description", utf82(), false),
   field2("examples", list2(field2("item", struct2([field2("sql", utf82(), false), field2("description", utf82(), false), field2("expected_output", utf82(), true)]), true)), false),
   field2("categories", list2(field2("item", utf82(), true)), false),
@@ -2916,10 +2984,17 @@ var FunctionInfoSchema = schema2([
   field2("filter_pushdown", bool2(), true),
   field2("sampling_pushdown", bool2(), true),
   field2("late_materialization", bool2(), true),
-  field2("supported_expression_filters", list2(field2("item", utf82(), true)), false),
+  field2("filter_semantic_profiles", list2(field2("item", utf82(), true)), false),
+  field2("additional_filter_functions", list2(field2("item", struct2([field2("namespace", utf82(), false), field2("name", utf82(), false), field2("version", uint642(), false)]), true)), false),
+  field2("runtime_filter_algorithms", list2(field2("item", struct2([field2("namespace", utf82(), false), field2("name", utf82(), false), field2("version", uint642(), false)]), true)), false),
+  field2("filter_evaluation_contexts", list2(field2("item", struct2([field2("profile", utf82(), false), field2("provider_fingerprint", utf82(), true)]), 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),
@@ -2937,18 +3012,18 @@ var MacroInfoSchema = schema2([
   field2("comment", utf82(), true),
   field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
   field2("name", utf82(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), 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),
   field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
   field2("name", utf82(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("table_name", utf82(), false),
   field2("index_type", utf82(), false),
   field2("constraint_type", dictionary2(utf82(), int162()), false),
@@ -2968,7 +3043,8 @@ var CopyFromFormatInfoSchema = schema2([
 var ScanFunctionResultSchema = schema2([
   field2("function_name", utf82(), false),
   field2("arguments", binary2(), false),
-  field2("required_extensions", list2(field2("item", utf82(), true)), false)
+  field2("required_extensions", list2(field2("item", utf82(), true)), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), true)
 ]);
 var ScanBranchesResultSchema = schema2([
   field2("branches", list2(field2("item", binary2(), true)), false),
@@ -2980,8 +3056,24 @@ var ScanBranchSchema = schema2([
   field2("branch_filter", utf82(), true),
   field2("writable", bool2(), false),
   field2("source_catalog", utf82(), true),
-  field2("source_schema", utf82(), true),
-  field2("source_table", utf82(), true)
+  field2("source_schema_path", list2(field2("item", utf82(), true)), 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),
+  field2("schema_path", list2(field2("item", utf82(), true)), 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 +3084,285 @@ var AttachCatalogInfoSchema = schema2([
   field2("required", bool2(), false),
   field2("secret_ref", utf82(), false)
 ]);
+var ForeignKeyInfoSchema = schema2([
+  field2("fk_columns", list2(field2("item", utf82(), true)), false),
+  field2("pk_columns", list2(field2("item", utf82(), true)), false),
+  field2("referenced_table", utf82(), false),
+  field2("referenced_schema_path", list2(field2("item", utf82(), true)), 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_path", list2(field2("item", utf82(), true)), true),
+  field2("argument_names", list2(field2("item", utf82(), true)), 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_path", list2(field2("item", utf82(), true)), 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_path", list2(field2("item", utf82(), true)), 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_path", list2(field2("item", utf82(), true)), true)
+]);
+var AggregateStreamingChunkRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("input_batch", binary2(), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_path", list2(field2("item", utf82(), true)), true)
+]);
+var AggregateStreamingCloseRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_path", list2(field2("item", utf82(), true)), true)
+]);
+var AggregateStreamingOpenRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("arguments", binary2(), false),
+  field2("input_schema", binary2(), false),
+  field2("partition_key_count", int642(), false),
+  field2("order_key_count", int642(), false),
+  field2("output_schema", binary2(), false),
+  field2("settings", binary2(), true),
+  field2("secrets", binary2(), true),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_path", list2(field2("item", utf82(), true)), 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_path", list2(field2("item", utf82(), true)), true)
+]);
+var AggregateWindowBatchRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("partition_id", int642(), false),
+  field2("row_idx", int642(), false),
+  field2("count", int642(), false),
+  field2("frames_per_row", list2(field2("item", int642(), true)), false),
+  field2("frame_starts", list2(field2("item", int642(), true)), false),
+  field2("frame_ends", list2(field2("item", int642(), true)), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_path", list2(field2("item", utf82(), true)), true)
+]);
+var AggregateWindowDestructorRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("partition_id", int642(), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_path", list2(field2("item", utf82(), true)), true)
+]);
+var AggregateWindowInitRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("partition_id", int642(), false),
+  field2("row_count", int642(), false),
+  field2("partition_batch", binary2(), false),
+  field2("output_schema", binary2(), false),
+  field2("filter_mask", binary2(), false),
+  field2("frame_stats", binary2(), false),
+  field2("all_valid", binary2(), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_path", list2(field2("item", utf82(), true)), true)
+]);
+var AggregateWindowRequestSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("execution_id", binary2(), false),
+  field2("partition_id", int642(), false),
+  field2("rid", int642(), false),
+  field2("frame_starts", list2(field2("item", int642(), true)), false),
+  field2("frame_ends", list2(field2("item", int642(), true)), false),
+  field2("attach_opaque_data", binary2(), true),
+  field2("schema_path", list2(field2("item", utf82(), true)), 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_path", list2(field2("item", utf82(), true)), true),
+  field2("argument_names", list2(field2("item", utf82(), true)), 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 CatalogCreateRequestSchema = schema2([
+  field2("name", utf82(), false),
+  field2("on_conflict", dictionary2(utf82(), int162()), false),
+  field2("options", binary2(), true)
+]);
+var ClientCapabilitiesSchema = schema2([
+  field2("engine", utf82(), false),
+  field2("native_formats", list2(field2("item", utf82(), true)), false),
+  field2("catalogs", list2(field2("item", utf82(), true)), false),
+  field2("can_stream", bool2(), false),
+  field2("filter_encodings", list2(field2("item", utf82(), true)), false)
+]);
+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 IndexCreateRequestSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
+  field2("name", utf82(), false),
+  field2("table_name", utf82(), false),
+  field2("index_type", utf82(), false),
+  field2("constraint_type", dictionary2(utf82(), int162()), false),
+  field2("expressions", list2(field2("item", utf82(), true)), false),
+  field2("on_conflict", dictionary2(utf82(), int162()), false),
+  field2("options", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+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 MacroCreateRequestSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
+  field2("name", utf82(), false),
+  field2("macro_type", dictionary2(utf82(), int162()), false),
+  field2("parameters", list2(field2("item", utf82(), true)), false),
+  field2("definition", utf82(), false),
+  field2("on_conflict", dictionary2(utf82(), int162()), false),
+  field2("parameter_default_values", binary2(), true),
+  field2("arguments_schema", binary2(), true),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var TableCreateRequestSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
+  field2("name", utf82(), false),
+  field2("columns", binary2(), false),
+  field2("on_conflict", dictionary2(utf82(), int162()), false),
+  field2("not_null_constraints", list2(field2("item", int322(), true)), false),
+  field2("unique_constraints", list2(field2("item", list2(field2("item", int322(), true)), true)), false),
+  field2("check_constraints", list2(field2("item", utf82(), true)), false),
+  field2("primary_key_constraints", list2(field2("item", list2(field2("item", int322(), true)), true)), false),
+  field2("foreign_key_constraints", list2(field2("item", binary2(), true)), false),
+  field2("transaction_opaque_data", binary2(), 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_path", list2(field2("item", utf82(), true)), 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_path", list2(field2("item", utf82(), true)), 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_path", list2(field2("item", utf82(), true)), true)
+]);
+var TableFunctionCardinalityRequestSchema = schema2([
+  field2("bind_call", binary2(), false),
+  field2("bind_opaque_data", binary2(), true)
+]);
+var TableFunctionDynamicToStringRequestSchema = schema2([
+  field2("bind_call", binary2(), false),
+  field2("bind_opaque_data", binary2(), true),
+  field2("global_execution_id", binary2(), false)
+]);
+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 TableFunctionStatisticsRequestSchema = schema2([
+  field2("bind_call", binary2(), false),
+  field2("bind_opaque_data", binary2(), true)
+]);
 var AggregateBindResultSchema = schema2([
   field2("output_schema", binary2(), false),
   field2("execution_id", binary2(), false)
@@ -3019,7 +3390,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 +3474,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)
 ]);
@@ -3164,7 +3553,7 @@ var CatalogIndexCreateParamsSchema = schema2([
 ]);
 var CatalogIndexDropParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("ignore_not_found", bool2(), false),
   field2("cascade", bool2(), false),
@@ -3172,7 +3561,7 @@ var CatalogIndexDropParamsSchema = schema2([
 ]);
 var CatalogIndexGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
@@ -3181,47 +3570,47 @@ var CatalogMacroCreateParamsSchema = schema2([
 ]);
 var CatalogMacroDropParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("ignore_not_found", bool2(), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogMacroGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogSchemaContentsFunctionsParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("name", utf82(), false),
+  field2("path", list2(field2("item", utf82(), true)), false),
   field2("type", dictionary2(utf82(), int162()), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogSchemaContentsIndexesParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("name", utf82(), false),
+  field2("path", list2(field2("item", utf82(), true)), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogSchemaContentsMacrosParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("name", utf82(), false),
+  field2("path", list2(field2("item", utf82(), true)), false),
   field2("type", dictionary2(utf82(), int162()), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogSchemaContentsTablesParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("name", utf82(), false),
+  field2("path", list2(field2("item", utf82(), true)), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogSchemaContentsViewsParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("name", utf82(), false),
+  field2("path", list2(field2("item", utf82(), true)), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogSchemaCreateParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("name", utf82(), false),
+  field2("path", list2(field2("item", utf82(), true)), false),
   field2("on_conflict", dictionary2(utf82(), int162()), false),
   field2("comment", utf82(), true),
   field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), true),
@@ -3229,14 +3618,14 @@ var CatalogSchemaCreateParamsSchema = schema2([
 ]);
 var CatalogSchemaDropParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("name", utf82(), false),
+  field2("path", list2(field2("item", utf82(), true)), false),
   field2("ignore_not_found", bool2(), false),
   field2("cascade", bool2(), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogSchemaGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("name", utf82(), false),
+  field2("path", list2(field2("item", utf82(), true)), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogSchemasParamsSchema = schema2([
@@ -3245,7 +3634,7 @@ var CatalogSchemasParamsSchema = schema2([
 ]);
 var CatalogTableColumnAddParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("column_definition", binary2(), false),
   field2("ignore_not_found", bool2(), false),
@@ -3254,7 +3643,7 @@ var CatalogTableColumnAddParamsSchema = schema2([
 ]);
 var CatalogTableColumnCommentSetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("column_name", utf82(), false),
   field2("comment", utf82(), true),
@@ -3263,7 +3652,7 @@ var CatalogTableColumnCommentSetParamsSchema = schema2([
 ]);
 var CatalogTableColumnDefaultDropParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("column_name", utf82(), false),
   field2("ignore_not_found", bool2(), false),
@@ -3271,7 +3660,7 @@ var CatalogTableColumnDefaultDropParamsSchema = schema2([
 ]);
 var CatalogTableColumnDefaultSetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("column_name", utf82(), false),
   field2("expression", utf82(), false),
@@ -3280,7 +3669,7 @@ var CatalogTableColumnDefaultSetParamsSchema = schema2([
 ]);
 var CatalogTableColumnDropParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("column_name", utf82(), false),
   field2("ignore_not_found", bool2(), false),
@@ -3290,7 +3679,7 @@ var CatalogTableColumnDropParamsSchema = schema2([
 ]);
 var CatalogTableColumnRenameParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("column_name", utf82(), false),
   field2("new_column_name", utf82(), false),
@@ -3299,13 +3688,13 @@ var CatalogTableColumnRenameParamsSchema = schema2([
 ]);
 var CatalogTableColumnStatisticsGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogTableColumnTypeChangeParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("column_definition", binary2(), false),
   field2("expression", utf82(), true),
@@ -3314,7 +3703,7 @@ var CatalogTableColumnTypeChangeParamsSchema = schema2([
 ]);
 var CatalogTableCommentSetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("comment", utf82(), true),
   field2("ignore_not_found", bool2(), false),
@@ -3325,13 +3714,13 @@ var CatalogTableCreateParamsSchema = schema2([
 ]);
 var CatalogTableDeleteFunctionGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogTableDropParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("ignore_not_found", bool2(), false),
   field2("cascade", bool2(), false),
@@ -3339,7 +3728,7 @@ var CatalogTableDropParamsSchema = schema2([
 ]);
 var CatalogTableGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("at_unit", utf82(), true),
   field2("at_value", utf82(), true),
@@ -3347,14 +3736,14 @@ var CatalogTableGetParamsSchema = schema2([
 ]);
 var CatalogTableInsertFunctionGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("transaction_opaque_data", binary2(), true),
   field2("writable_branch_function_name", utf82(), true)
 ]);
 var CatalogTableNotNullDropParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("column_name", utf82(), false),
   field2("ignore_not_found", bool2(), false),
@@ -3362,7 +3751,7 @@ var CatalogTableNotNullDropParamsSchema = schema2([
 ]);
 var CatalogTableNotNullSetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("column_name", utf82(), false),
   field2("ignore_not_found", bool2(), false),
@@ -3370,7 +3759,7 @@ var CatalogTableNotNullSetParamsSchema = schema2([
 ]);
 var CatalogTableRenameParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("new_name", utf82(), false),
   field2("ignore_not_found", bool2(), false),
@@ -3378,7 +3767,7 @@ var CatalogTableRenameParamsSchema = schema2([
 ]);
 var CatalogTableScanBranchesGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("at_unit", utf82(), true),
   field2("at_value", utf82(), true),
@@ -3386,7 +3775,7 @@ var CatalogTableScanBranchesGetParamsSchema = schema2([
 ]);
 var CatalogTableScanFunctionGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("at_unit", utf82(), true),
   field2("at_value", utf82(), true),
@@ -3394,7 +3783,7 @@ var CatalogTableScanFunctionGetParamsSchema = schema2([
 ]);
 var CatalogTableUpdateFunctionGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
@@ -3415,7 +3804,7 @@ var CatalogVersionParamsSchema = schema2([
 ]);
 var CatalogViewCommentSetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("comment", utf82(), true),
   field2("ignore_not_found", bool2(), false),
@@ -3423,7 +3812,7 @@ var CatalogViewCommentSetParamsSchema = schema2([
 ]);
 var CatalogViewCreateParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("definition", utf82(), false),
   field2("on_conflict", dictionary2(utf82(), int162()), false),
@@ -3431,7 +3820,7 @@ var CatalogViewCreateParamsSchema = schema2([
 ]);
 var CatalogViewDropParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("ignore_not_found", bool2(), false),
   field2("cascade", bool2(), false),
@@ -3439,13 +3828,13 @@ var CatalogViewDropParamsSchema = schema2([
 ]);
 var CatalogViewGetParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("transaction_opaque_data", binary2(), true)
 ]);
 var CatalogViewRenameParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
-  field2("schema_name", utf82(), false),
+  field2("schema_path", list2(field2("item", utf82(), true)), false),
   field2("name", utf82(), false),
   field2("new_name", utf82(), false),
   field2("ignore_not_found", bool2(), false),
@@ -3469,10 +3858,18 @@ var TableFunctionCardinalityParamsSchema = schema2([
 var TableFunctionDynamicToStringParamsSchema = schema2([
   field2("request", binary2(), false)
 ]);
+var TableFunctionPlanParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
 var TableFunctionStatisticsParamsSchema = schema2([
   field2("request", binary2(), false)
 ]);
 
+// src/schema-path.ts
+function normalizeSchemaPath(path) {
+  return typeof path === "string" ? [path] : Array.from(path, String);
+}
+
 // src/protocol/handlers/shared.ts
 var RESULT_BINARY_SCHEMA = schema2([
   field2("result", binary2(), false)
@@ -3486,7 +3883,15 @@ var RESULT_BINARY_NULLABLE_SCHEMA = schema2([
 function unwrapRequest(requestBytes) {
   const bytes = toUint8Array(requestBytes);
   const innerBatch = deserializeBatch(bytes);
-  return batchToScalarDict(innerBatch);
+  const params = batchToScalarDict(innerBatch);
+  normalizeRequestSchemaPaths(params);
+  return params;
+}
+function normalizeRequestSchemaPaths(params) {
+  if (params.path != null)
+    params.path = normalizeSchemaPath(params.path);
+  if (params.schema_path != null)
+    params.schema_path = normalizeSchemaPath(params.schema_path);
 }
 function wrapResult(values, innerSchema) {
   const a = innerSchema;
@@ -3506,7 +3911,7 @@ function overloadContext(req, catalogInterface) {
     arguments: req.arguments,
     inputSchema: req.input_schema,
     isScalar: String(req.function_type).toLowerCase() === "scalar",
-    schemaName: req.schema_name ?? null,
+    schemaPath: req.schema_path ?? null,
     catalogName
   };
 }
@@ -3694,14 +4099,14 @@ function getOutput(expectedLength, out, onlyAligned = true) {
     throw new Error("invalid output, must be aligned");
   return out;
 }
-function u64Lengths(dataLength, aadLength, isLE2) {
+function u64Lengths(dataLength, aadLength, isLE) {
   anumber(dataLength);
   anumber(aadLength);
-  abool(isLE2);
+  abool(isLE);
   const num = new Uint8Array(16);
   const view = createView(num);
-  view.setBigUint64(0, BigInt(aadLength), isLE2);
-  view.setBigUint64(8, BigInt(dataLength), isLE2);
+  view.setBigUint64(0, BigInt(aadLength), isLE);
+  view.setBigUint64(8, BigInt(dataLength), isLE);
   return num;
 }
 function isAligned32(bytes) {
@@ -4268,8 +4673,8 @@ var ATTACH_AAD_PREFIX = _UTF8.encode("vgi.attach_opaque_data.v1\x00");
 var TRANSACTION_AAD_PREFIX = _UTF8.encode("vgi.transaction_opaque_data.v1\x00");
 
 class OpaqueDataRejectedError extends Error {
-  constructor(field3 = "opaque data") {
-    super(`${field3} not recognized`);
+  constructor(field = "opaque data") {
+    super(`${field} not recognized`);
     this.name = "OpaqueDataRejectedError";
   }
 }
@@ -4312,16 +4717,16 @@ async function sealBytes(payload, key, aad, version) {
   out.set(ciphertext, 1 + NONCE_LEN);
   return out;
 }
-async function openBytes(token, key, aad, version, field3 = "opaque data") {
+async function openBytes(token, key, aad, version, field = "opaque data") {
   if (token.length < MIN_ENVELOPE_LEN || token[0] !== (version & 255)) {
-    throw new OpaqueDataRejectedError(field3);
+    throw new OpaqueDataRejectedError(field);
   }
   const nonce = token.subarray(1, 1 + NONCE_LEN);
   const ciphertext = token.subarray(1 + NONCE_LEN);
   try {
     return xchacha20poly1305(await normalizeKey(key), nonce, aad).decrypt(ciphertext);
   } catch {
-    throw new OpaqueDataRejectedError(field3);
+    throw new OpaqueDataRejectedError(field);
   }
 }
 
@@ -4374,6 +4779,7 @@ function catalogUnary(protocol, signingKey, name, config) {
     result: config.result,
     doc: config.doc,
     handler: async (params, ctx) => {
+      normalizeRequestSchemaPaths(params);
       await unwrapParamsOpaque(params, ctx, signingKey);
       return config.handler(params, ctx);
     }
@@ -4399,57 +4805,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 {
+    schemaPath: dict.schema_path == null ? [] : (Array.isArray(dict.schema_path) ? dict.schema_path : [...dict.schema_path]).map(String),
+    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(schemaPath, functionName, args, settings, projection) {
+  const enc = new TextEncoder;
+  const zero = Uint8Array.of(0);
+  const field = (label, value) => concat2(enc.encode(label), zero, value, zero);
+  const message = concat2(AAD_PREFIX, field("schema_path", enc.encode(JSON.stringify(schemaPath))), field("function_name", enc.encode(functionName)), field("arguments", args), field("settings", settings), field("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 (err) {
+    throw new SplitTokenError(SPLIT_TOKEN_INVALID, `split token failed authentication: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
 
 // 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.schemaPath, 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 +5042,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 +5053,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 +5072,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 +5127,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 +5176,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 +5191,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.schemaPath, 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 +5235,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);
@@ -4625,9 +5246,9 @@ function registerFunctionMethods(protocol, config) {
       const globalExecutionId = toUint8Array(innerParams.global_execution_id);
       const bindOpaqueData = innerParams.bind_opaque_data ? toUint8Array(innerParams.bind_opaque_data) : null;
       const func = registry.get(bindCall.function_name, await strippedContext(bindCall));
-      const map3 = func.dynamicToString ? await func.dynamicToString({ bindCall, bindOpaqueData, globalExecutionId }) : {};
-      const keys = Object.keys(map3);
-      const values = keys.map((k) => map3[k] ?? "");
+      const map = func.dynamicToString ? await func.dynamicToString({ bindCall, bindOpaqueData, globalExecutionId }) : {};
+      const keys = Object.keys(map);
+      const values = keys.map((k) => map[k] ?? "");
       return wrapResult({ keys, values }, TableFunctionDynamicToStringResultSchema);
     }
   });
@@ -4802,12 +5423,12 @@ function persistGroupStates(executionId, gids) {
 
 // src/protocol/handlers/aggregate.ts
 function registerAggregateMethods(protocol, registry) {
-  function resolveAggregate(name, schemaName) {
+  function resolveAggregate(name, schemaPath) {
     const func = registry.get(name, {
       arguments: new Arguments,
       inputSchema: null,
       isScalar: false,
-      schemaName: schemaName ?? null
+      schemaPath: schemaPath ?? null
     });
     if (!func || func.kind !== "aggregate") {
       throw new Error(`Function '${name}' is not an aggregate function`);
@@ -4815,12 +5436,12 @@ 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);
       const functionName = innerParams.function_name;
-      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const argBytes = toUint8Array(innerParams.arguments);
       const args = deserializeArguments(argBytes);
       const inputSchema = innerParams.input_schema ? deserializeSchema(toUint8Array(innerParams.input_schema)) : null;
@@ -4832,7 +5453,8 @@ function registerAggregateMethods(protocol, registry) {
         arguments: args,
         inputSchema,
         settings: {},
-        secrets
+        secrets,
+        argumentNames: innerParams.argument_names ? (Array.isArray(innerParams.argument_names) ? innerParams.argument_names : [...innerParams.argument_names]).map((value) => value == null ? null : String(value)) : null
       };
       const executionId = new Uint8Array(16);
       crypto.getRandomValues(executionId);
@@ -4847,13 +5469,13 @@ 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);
       const functionName = innerParams.function_name;
       const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
       if (!batch || batch.numRows === 0)
         return wrapResult({}, schema2([]));
@@ -4900,13 +5522,13 @@ 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);
       const functionName = innerParams.function_name;
       const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
       if (!batch || batch.numRows === 0)
         return wrapResult({}, schema2([]));
@@ -4945,13 +5567,13 @@ 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);
       const functionName = innerParams.function_name;
       const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const outputSchema = deserializeSchema(toUint8Array(innerParams.output_schema));
       const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
       const groupIds = [];
@@ -4983,7 +5605,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);
@@ -5021,9 +5643,9 @@ function extractArgMap(cfg, args) {
     let v;
     try {
       v = args.get(i);
-      const field3 = args.argumentsSchema?.fields.find((f) => f.name === `positional_${i}`);
-      if (field3 && isDecimal(field3.type)) {
-        const scale = field3.type.scale;
+      const field = args.argumentsSchema?.fields.find((f) => f.name === `positional_${i}`);
+      if (field && isDecimal(field.type)) {
+        const scale = field.type.scale;
         if (typeof v === "bigint")
           v = Number(v) / Math.pow(10, scale);
         else if (typeof v === "number")
@@ -5097,12 +5719,12 @@ function splitLenPrefixed(buf, count) {
 
 // src/protocol/handlers/table-buffering.ts
 function registerTableBufferingMethods(protocol, registry, signingKey) {
-  function resolveBuffering(name, schemaName) {
+  function resolveBuffering(name, schemaPath) {
     const func = registry.get(name, {
       arguments: new Arguments,
       inputSchema: null,
       isScalar: false,
-      schemaName: schemaName ?? null
+      schemaPath: schemaPath ?? null
     });
     if (!func || func.kind !== "table_buffering") {
       throw new Error(`Function '${name}' is not a table_buffering function`);
@@ -5115,7 +5737,7 @@ function registerTableBufferingMethods(protocol, registry, signingKey) {
     const rawAttach = inner.attach_opaque_data ? toUint8Array(inner.attach_opaque_data) : null;
     const attach = rawAttach && rawAttach.length > 0 ? await openAttach(rawAttach, ctx?.auth, signingKey) : rawAttach;
     const transactionId = inner.transaction_id ? toUint8Array(inner.transaction_id) : null;
-    const func = resolveBuffering(functionName, inner.schema_name ?? null);
+    const func = resolveBuffering(functionName, inner.schema_path ?? null);
     const bound = new BoundStorage(storage, executionId);
     const payload = await bound.stateGet(FrameworkNS.BUFFERING_INIT, BoundStorage.packIntKey(-1));
     if (payload == null) {
@@ -5142,7 +5764,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 +5782,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 +5800,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 {
@@ -5214,8 +5836,8 @@ function hex(buf) {
 }
 
 // src/codec/asd.ts
-function encodeASD(schema3, obj) {
-  return serializeBatch(batchFromRows([obj], schema3));
+function encodeASD(schema, obj) {
+  return serializeBatch(batchFromRows([obj], schema));
 }
 
 // src/generated/vgi-client.ts
@@ -5242,7 +5864,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 +5880,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 +5910,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 +5919,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 +5928,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 +5937,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 +5946,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 +5959,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 +5968,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 +5977,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 +5988,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,79 +5999,62 @@ 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();
-      const info = await cat.schemaGet(toUint8Array(params.attach_opaque_data), params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const info = await cat.schemaGet(toUint8Array(params.attach_opaque_data), params.path, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
         items: info ? [encodeSchemaInfo(info)] : []
       }, CatalogSchemaGetResultSchema);
     }
   });
   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();
-      await cat.schemaCreate(toUint8Array(params.attach_opaque_data), params.name, params.comment, null, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.schemaCreate(toUint8Array(params.attach_opaque_data), params.path, params.comment, null, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   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();
-      await cat.schemaDrop(toUint8Array(params.attach_opaque_data), params.name, params.ignore_not_found, params.cascade, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.schemaDrop(toUint8Array(params.attach_opaque_data), params.path, params.ignore_not_found, params.cascade, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   catalogUnary(protocol, signingKey, "catalog_schema_contents_tables", {
-    params: attachOpaqueDataNameTxnParams,
+    params: CatalogSchemaContentsTablesParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
-      const tables = await cat.schemaContentsTables(toUint8Array(params.attach_opaque_data), params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const tables = await cat.schemaContentsTables(toUint8Array(params.attach_opaque_data), params.path, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
         items: tables.map((t) => encodeTableInfo(t))
       }, CatalogSchemaContentsTablesResultSchema);
     }
   });
   catalogUnary(protocol, signingKey, "catalog_schema_contents_views", {
-    params: attachOpaqueDataNameTxnParams,
+    params: CatalogSchemaContentsViewsParamsSchema,
     result: RESULT_BINARY_SCHEMA,
     handler: async (params) => {
       const cat = getCatalog();
-      const views = await cat.schemaContentsViews(toUint8Array(params.attach_opaque_data), params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const views = await cat.schemaContentsViews(toUint8Array(params.attach_opaque_data), params.path, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
         items: views.map((v) => encodeViewInfo(v))
       }, CatalogSchemaContentsViewsResultSchema);
     }
   });
   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();
-      const funcs = await cat.schemaContentsFunctions(toUint8Array(params.attach_opaque_data), params.name, decodeDictValue(params.type), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const funcs = await cat.schemaContentsFunctions(toUint8Array(params.attach_opaque_data), params.path, decodeDictValue(params.type), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
         items: funcs.map((f) => encodeFunctionInfo(f))
       }, CatalogSchemaContentsFunctionsResultSchema);
@@ -5464,223 +6065,148 @@ 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();
-      const info = await cat.tableGet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.at_unit, params.at_value, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const info = await cat.tableGet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.at_unit, params.at_value, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
         items: info ? [encodeTableInfo(info)] : []
       }, CatalogTableGetResultSchema);
     }
   });
   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();
-      await cat.tableCreate(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, toUint8Array(params.columns), params.on_conflict, params.not_null_constraints ?? [], params.unique_constraints ?? [], params.check_constraints ?? [], params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableCreate(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, toUint8Array(params.columns), params.on_conflict, params.not_null_constraints ?? [], params.unique_constraints ?? [], params.check_constraints ?? [], params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   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();
-      await cat.tableDrop(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableDrop(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   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();
-      const stats = await cat.tableColumnStatisticsGet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const stats = await cat.tableColumnStatisticsGet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return { result: stats?.bytes ?? null };
     }
   });
   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();
-      const scanResult = await cat.tableScanFunctionGet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.at_unit, params.at_value, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const scanResult = await cat.tableScanFunctionGet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.at_unit, params.at_value, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult(scanResult, ScanFunctionResultSchema);
     }
   });
   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();
-      const branchesResult = await cat.tableScanBranchesGet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.at_unit, params.at_value, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const branchesResult = await cat.tableScanBranchesGet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.at_unit, params.at_value, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult(branchesResult, ScanBranchesResultSchema);
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_comment_set", {
-    params: schemaNameCommentParams,
+    params: CatalogTableCommentSetParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
-      await cat.tableCommentSet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.comment, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableCommentSet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.comment, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_rename", {
-    params: schemaNameRenameParams,
+    params: CatalogTableRenameParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
-      await cat.tableRename(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.new_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableRename(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.new_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   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();
-      await cat.tableColumnAdd(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.column_name, params.column_type, params.default_value, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableColumnAdd(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.column_name, params.column_type, params.default_value, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_column_drop", {
-    params: columnOpParams,
+    params: CatalogTableColumnDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
-      await cat.tableColumnDrop(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.column_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableColumnDrop(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.column_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   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();
-      await cat.tableColumnRename(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.column_name, params.new_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableColumnRename(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.column_name, params.new_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   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();
-      await cat.tableColumnDefaultSet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.column_name, params.default_value, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableColumnDefaultSet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.column_name, params.default_value, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_column_default_drop", {
-    params: columnOpParams,
+    params: CatalogTableColumnDefaultDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
-      await cat.tableColumnDefaultDrop(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.column_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableColumnDefaultDrop(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.column_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   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();
-      await cat.tableColumnTypeChange(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.column_name, params.new_type, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableColumnTypeChange(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.column_name, params.new_type, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_not_null_set", {
-    params: columnOpParams,
+    params: CatalogTableNotNullSetParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
-      await cat.tableNotNullSet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.column_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableNotNullSet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.column_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   catalogUnary(protocol, signingKey, "catalog_table_not_null_drop", {
-    params: columnOpParams,
+    params: CatalogTableNotNullDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
-      await cat.tableNotNullDrop(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.column_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.tableNotNullDrop(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.column_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
@@ -5689,56 +6215,49 @@ 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();
-      const info = await cat.viewGet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const info = await cat.viewGet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
         items: info ? [encodeViewInfo(info)] : []
       }, CatalogViewGetResultSchema);
     }
   });
   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();
-      await cat.viewCreate(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.definition, params.on_conflict, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.viewCreate(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.definition, params.on_conflict, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   catalogUnary(protocol, signingKey, "catalog_view_drop", {
-    params: schemaNameIgnoreNotFoundTxnParams,
+    params: CatalogViewDropParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
-      await cat.viewDrop(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.viewDrop(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   catalogUnary(protocol, signingKey, "catalog_view_rename", {
-    params: schemaNameRenameParams,
+    params: CatalogViewRenameParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
-      await cat.viewRename(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.new_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.viewRename(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.new_name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   catalogUnary(protocol, signingKey, "catalog_view_comment_set", {
-    params: schemaNameCommentParams,
+    params: CatalogViewCommentSetParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
-      await cat.viewCommentSet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.comment, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.viewCommentSet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.comment, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
@@ -5747,52 +6266,41 @@ 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();
-      const info = await cat.macroGet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const info = await cat.macroGet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
         items: info ? [encodeMacroInfo(info)] : []
       }, CatalogMacroGetResultSchema);
     }
   });
   catalogUnary(protocol, signingKey, "catalog_macro_create", {
-    params: REQUEST_PARAMS_SCHEMA,
+    params: CatalogMacroCreateParamsSchema,
     result: emptyResultSchema,
     handler: async (params) => {
       const cat = getCatalog();
       const innerParams = unwrapRequest(params.request);
-      await cat.macroCreate(toUint8Array(innerParams.attach_opaque_data), innerParams.schema_name, innerParams.name, innerParams.macro_type, innerParams.parameters ? Array.isArray(innerParams.parameters) ? innerParams.parameters : [...innerParams.parameters] : [], innerParams.definition, innerParams.on_conflict, innerParams.parameter_default_values ? toUint8Array(innerParams.parameter_default_values) : null, innerParams.arguments_schema ? toUint8Array(innerParams.arguments_schema) : null, innerParams.transaction_opaque_data ? toUint8Array(innerParams.transaction_opaque_data) : undefined);
+      await cat.macroCreate(toUint8Array(innerParams.attach_opaque_data), innerParams.schema_path, innerParams.name, innerParams.macro_type, innerParams.parameters ? Array.isArray(innerParams.parameters) ? innerParams.parameters : [...innerParams.parameters] : [], innerParams.definition, innerParams.on_conflict, innerParams.parameter_default_values ? toUint8Array(innerParams.parameter_default_values) : null, innerParams.arguments_schema ? toUint8Array(innerParams.arguments_schema) : null, innerParams.transaction_opaque_data ? toUint8Array(innerParams.transaction_opaque_data) : undefined);
       return {};
     }
   });
   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();
-      await cat.macroDrop(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      await cat.macroDrop(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.ignore_not_found, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return {};
     }
   });
   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();
-      const macros = await cat.schemaContentsMacros(toUint8Array(params.attach_opaque_data), params.name, decodeDictValue(params.type), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const macros = await cat.schemaContentsMacros(toUint8Array(params.attach_opaque_data), params.path, decodeDictValue(params.type), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
         items: macros.map((m) => encodeMacroInfo(m))
       }, CatalogSchemaContentsMacrosResultSchema);
@@ -5803,31 +6311,22 @@ 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();
-      const indexes = await cat.schemaContentsIndexes(toUint8Array(params.attach_opaque_data), params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const indexes = await cat.schemaContentsIndexes(toUint8Array(params.attach_opaque_data), params.path, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
         items: indexes.map((i) => encodeIndexInfo(i))
       }, CatalogSchemaContentsIndexesResultSchema);
     }
   });
   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();
-      const info = await cat.indexGet(toUint8Array(params.attach_opaque_data), params.schema_name, params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+      const info = await cat.indexGet(toUint8Array(params.attach_opaque_data), params.schema_path, params.name, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
         items: info ? [encodeIndexInfo(info)] : []
       }, CatalogIndexGetResultSchema);
@@ -5847,7 +6346,7 @@ function registerCatalogMethods(protocol, catalog, _catalogName, signingKey) {
 
 // src/protocol/dispatch.ts
 function buildVgiProtocol(config) {
-  const protocol = new Protocol("vgi");
+  const protocol = new Protocol("vgi", { protocolVersion: "2.0.0" });
   registerFunctionMethods(protocol, {
     registry: config.registry,
     recoverExchangeState: config.recoverExchangeState,
@@ -5909,9 +6408,9 @@ function notModified(request, etag, extra) {
 }
 function createLandingRoutes(info) {
   return (request, ctx) => {
-    const path2 = ctx.url.pathname;
+    const path = ctx.url.pathname;
     const { prefix } = ctx;
-    if (path2 === prefix || path2 === `${prefix}/`) {
+    if (path === prefix || path === `${prefix}/`) {
       const accept = request.headers.get("Accept") ?? "";
       const wantJson = ctx.url.searchParams.get("format") === "json" || accept.includes("application/json") && !accept.includes("text/html");
       if (wantJson) {
@@ -5926,9 +6425,9 @@ function createLandingRoutes(info) {
           oauth: ctx.oauthActive,
           cupola_base: info.cupolaBase ?? DEFAULT_CUPOLA_BASE
         });
-        const headers2 = new Headers({ "Content-Type": "application/json" });
-        ctx.addCorsHeaders(headers2);
-        return new Response(body, { status: 200, headers: headers2 });
+        const headers = new Headers({ "Content-Type": "application/json" });
+        ctx.addCorsHeaders(headers);
+        return new Response(body, { status: 200, headers });
       }
       landingEtag ??= etagFor(LANDING_HTML_BYTES);
       const conditional = notModified(request, landingEtag);
@@ -5944,7 +6443,7 @@ function createLandingRoutes(info) {
       ctx.addCorsHeaders(headers);
       return new Response(LANDING_HTML_BYTES, { status: 200, headers });
     }
-    if (path2 === `${prefix}/vgi-client.js`) {
+    if (path === `${prefix}/vgi-client.js`) {
       bundleEtag ??= etagFor(CLIENT_BUNDLE_BYTES);
       const conditional = notModified(request, bundleEtag);
       if (conditional) {
@@ -5964,9 +6463,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 storage = new mod.AsyncLocalStorage;
+    requestAuthStorage = storage;
+    setRequestAuthScope(storage);
+    return storage;
+  }).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,20 +6511,30 @@ function createVgiFetch(opts) {
     tokenKey: opts.signingKey,
     tokenTtl,
     stateSerializer: arrowStateSerializer,
+    dispatchHook: REQUEST_AUTH_DISPATCH_HOOK,
+    authenticate: opts.authenticate,
+    peerIdentityProviders: opts.peerIdentityProviders,
+    peerAuthenticationPolicy: opts.peerAuthenticationPolicy,
+    peerResolutionContext: opts.peerResolutionContext,
     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 storage = await ensureRequestAuthStorage();
+    if (!storage)
+      return handler(req);
+    return storage.run({}, () => handler(req));
+  };
 }
 
 // src/serve-entry.ts
 var DEFAULT_PORT = 8787;
 var DEFAULT_TOKEN_TTL = 3600;
 var SIGNING_KEY_BYTES = 32;
-function parseSigningKeyHex(hex2) {
-  const cleaned = hex2.trim();
+function parseSigningKeyHex(hex) {
+  const cleaned = hex.trim();
   const expected = SIGNING_KEY_BYTES * 2;
   if (cleaned.length !== expected || !/^[0-9a-fA-F]+$/.test(cleaned)) {
     throw new Error(`VGI_SIGNING_KEY must be exactly ${expected} hex characters ` + `(${SIGNING_KEY_BYTES} bytes); got ${cleaned.length}. ` + `Generate one with: openssl rand -hex ${SIGNING_KEY_BYTES}`);
@@ -6055,6 +6590,11 @@ function createVgiWorkerFetch(opts) {
   const signingKey = resolveSigningKey(opts.signingKey, env);
   const tokenTtl = resolveTokenTtl(opts.tokenTtl, env);
   const corsOrigins = opts.corsOrigins === null ? null : opts.corsOrigins ?? env.CORS_ORIGINS;
+  const bridge = opts.irohBridge;
+  if (bridge && !bridge.peerResolutionContext) {
+    throw new Error("irohBridge requires a peerResolutionContext when createVgiWorkerFetch is used without serveVgiWorker");
+  }
+  const trustedProxyAddresses = bridge?.trustedProxyAddresses ?? ["127.0.0.1"];
   return createVgiFetch({
     protocol: { registry: opts.registry, catalogInterface: opts.catalogInterface },
     signingKey,
@@ -6063,7 +6603,11 @@ 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,
+    peerIdentityProviders: bridge ? [irohForwardedHeaderIdentityProvider({ issuer: bridge.issuer, trustedProxyAddresses })] : undefined,
+    peerAuthenticationPolicy: bridge ? bridge.authenticate === false ? observePeerIdentity : peerIdentityPrimary("iroh") : undefined,
+    peerResolutionContext: bridge?.peerResolutionContext
   });
 }
 function serveVgiWorker(opts) {
@@ -6073,8 +6617,24 @@ function serveVgiWorker(opts) {
   }
   const env = opts.env ?? process.env;
   const port = resolvePort(opts.port, env);
-  const fetch2 = createVgiWorkerFetch(opts);
-  const server = runtime.serve({ port, fetch: fetch2 });
+  const hostname = opts.hostname ?? (opts.irohBridge ? "127.0.0.1" : undefined);
+  if (opts.irohBridge && !["127.0.0.1", "::1", "localhost"].includes(hostname ?? "")) {
+    throw new Error("an Iroh HTTP bridge upstream must bind loopback");
+  }
+  let server;
+  const bridge = opts.irohBridge && !opts.irohBridge.peerResolutionContext ? {
+    ...opts.irohBridge,
+    peerResolutionContext(request) {
+      const immediatePeer = server.requestIP?.(request)?.address;
+      const forwarded = request.headers.get(IROH_FORWARDED_ENDPOINT_HEADER);
+      return {
+        immediatePeer,
+        headers: forwarded === null ? {} : { [IROH_FORWARDED_ENDPOINT_HEADER]: [forwarded] }
+      };
+    }
+  } : opts.irohBridge;
+  const fetch2 = createVgiWorkerFetch({ ...opts, irohBridge: bridge });
+  server = runtime.serve({ port, hostname, fetch: fetch2 });
   if (!opts.quiet) {
     const base = `http://localhost:${server.port}`;
     console.log(`${opts.name} VGI HTTP worker listening on ${base}`);
@@ -6086,13 +6646,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=3C4394ABF730E98C64756E2164756E21