@query-farm/vgi 0.42.0 → 0.44.0

package/dist/worker-cf-entry.js

@@ -1,4 +1,27 @@
 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);
@@ -1978,6 +2001,11 @@ var init_arrow = __esm(() => {
 });
 
 // src/functions/storage-cf-do.ts
+var exports_storage_cf_do = {};
+__export(exports_storage_cf_do, {
+  FunctionStorageCfDo: () => FunctionStorageCfDo
+});
+
 class FunctionStorageCfDo {
   _baseUrl;
   _token;
@@ -2423,7 +2451,7 @@ function resolveStorageFromEnv() {
     return new FunctionStorageSqlite;
   }
   if (backend === "cloudflare-do") {
-    init_storage_cf_do();
+    const { FunctionStorageCfDo } = (init_storage_cf_do(), __toCommonJS(exports_storage_cf_do));
     return FunctionStorageCfDo.fromEnv();
   }
   throw new Error(`Unknown VGI_WORKER_SHARED_STORAGE backend: '${backend}'. Supported: 'memory', 'sqlite', 'cloudflare-do'.`);
@@ -4138,6 +4166,135 @@ var VGI_RANGE_KEY = "vgi_range";
 var VGI_PATTERN_KEY = "vgi_pattern";
 var DEFAULT_MAX_WORKERS = 99999;
 
+// src/codec/conform.ts
+init_arrow();
+var OPTIONAL_ITEM_FIELDS = new Set(["argument_names"]);
+function children(type) {
+  return type.children ?? [];
+}
+function mapValueType(type) {
+  const entries = children(type)[0].type;
+  return children(entries)[1].type;
+}
+function mapPairs(raw) {
+  if (Array.isArray(raw))
+    return raw.map((e) => Array.isArray(e) ? [e[0], e[1]] : [e?.key, e?.value]);
+  if (raw instanceof Map)
+    return Array.from(raw.entries());
+  if (typeof raw[Symbol.iterator] === "function")
+    return Array.from(raw);
+  return Object.entries(raw);
+}
+function zeroValue(type) {
+  if (isUtf8(type) || isDictionary(type))
+    return "";
+  if (isBinary(type))
+    return new Uint8Array(0);
+  if (isBool(type))
+    return false;
+  if (isInt(type))
+    return type.bitWidth === 64 ? 0n : 0;
+  if (isFloat(type))
+    return 0;
+  if (isList(type) || isMap(type))
+    return [];
+  if (isStruct(type)) {
+    const out = {};
+    for (const c of children(type))
+      out[c.name] = c.nullable ? null : conformValue(c.type, undefined, false, c.name);
+    return out;
+  }
+  return null;
+}
+var HAS_CONTAINER = new WeakMap;
+function hasContainer(type) {
+  const cached = HAS_CONTAINER.get(type);
+  if (cached !== undefined)
+    return cached;
+  let has = isList(type) || isMap(type);
+  if (!has && isStruct(type))
+    has = children(type).some((c) => hasContainer(c.type));
+  HAS_CONTAINER.set(type, has);
+  return has;
+}
+function conformValue(type, value, nullable, name) {
+  if (value == null) {
+    if (nullable)
+      return value ?? null;
+    if (isList(type) || isMap(type))
+      return [];
+    return value;
+  }
+  if (!hasContainer(type))
+    return value;
+  if (isList(type)) {
+    const itemType = children(type)[0].type;
+    const itemsNullable = OPTIONAL_ITEM_FIELDS.has(name);
+    const items = Array.isArray(value) ? value : Array.from(value);
+    let changed = !Array.isArray(value);
+    const out = items.map((item) => {
+      const next = item == null && !itemsNullable ? zeroValue(itemType) : conformValue(itemType, item, true, name);
+      if (next !== item)
+        changed = true;
+      return next;
+    });
+    return changed ? out : value;
+  }
+  if (isMap(type)) {
+    const valueType = mapValueType(type);
+    const pairs = mapPairs(value);
+    let changed = false;
+    const out = pairs.map(([k, v]) => {
+      const next = v == null ? zeroValue(valueType) : conformValue(valueType, v, true, name);
+      if (next !== v)
+        changed = true;
+      return [k, next];
+    });
+    return changed ? out : value;
+  }
+  if (isStruct(type)) {
+    let out = null;
+    for (const c of children(type)) {
+      const v = value[c.name];
+      const next = conformValue(c.type, v, c.nullable, c.name);
+      if (next !== v) {
+        (out ??= { ...value })[c.name] = next;
+      }
+    }
+    return out ?? value;
+  }
+  return value;
+}
+function conformRecord(schema, obj) {
+  let out = null;
+  for (const f of schema.fields) {
+    const v = obj[f.name];
+    const next = conformValue(f.type, v, f.nullable, f.name);
+    if (next !== v) {
+      (out ??= { ...obj })[f.name] = next;
+    }
+  }
+  return out ?? obj;
+}
+function conformColumns(schema, columns) {
+  let out = null;
+  for (const f of schema.fields) {
+    const col = columns[f.name];
+    const rows = col ?? [undefined];
+    let changed = col === undefined;
+    const next = rows.map((v) => {
+      const c = conformValue(f.type, v, f.nullable, f.name);
+      if (c !== v)
+        changed = true;
+      return c;
+    });
+    if (changed) {
+      (out ??= { ...columns })[f.name] = next;
+    }
+  }
+  return out ?? columns;
+}
+
 // src/protocol/serializers/shared.ts
 function toUint8Array2(val) {
   if (typeof val === "string")
@@ -4675,8 +4832,1260 @@ var arrowStateSerializer = {
   }
 };
 
-// src/protocol/dispatch.ts
-import { Protocol as Protocol2 } from "@query-farm/vgi-rpc";
+// src/generated/vgi-service.ts
+init_arrow();
+import {
+  MethodNotImplementedError,
+  Protocol
+} from "@query-farm/vgi-rpc";
+var VGI_PROTOCOL_NAME = "vgi.v2";
+var VGI_PROTOCOL_VERSION = "2.1.0";
+function exchangeStream(callbacks) {
+  return { kind: "exchange", ...callbacks };
+}
+function producerStream(callbacks) {
+  return { kind: "producer", ...callbacks };
+}
+var VGI_V2_METHODS = [
+  {
+    name: "aggregate_bind",
+    key: "aggregateBind",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Bind an aggregate function, return output schema and execution_id."
+  },
+  {
+    name: "aggregate_combine",
+    key: "aggregateCombine",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Merge source states into target states."
+  },
+  {
+    name: "aggregate_destructor",
+    key: "aggregateDestructor",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Best-effort cleanup of aggregate states. Must not raise."
+  },
+  {
+    name: "aggregate_finalize",
+    key: "aggregateFinalize",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Produce results for a chunk of group_ids."
+  },
+  {
+    name: "aggregate_streaming_chunk",
+    key: "aggregateStreamingChunk",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Process one input chunk; returns one output row per input row."
+  },
+  {
+    name: "aggregate_streaming_close",
+    key: "aggregateStreamingClose",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "End the streaming session, free per-session state."
+  },
+  {
+    name: "aggregate_streaming_open",
+    key: "aggregateStreamingOpen",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Start a streaming-partitioned aggregate session."
+  },
+  {
+    name: "aggregate_update",
+    key: "aggregateUpdate",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Accumulate rows from a `DataChunk` into per-group state."
+  },
+  {
+    name: "aggregate_window",
+    key: "aggregateWindow",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Compute an aggregate value for one output row of the window."
+  },
+  {
+    name: "aggregate_window_batch",
+    key: "aggregateWindowBatch",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Compute ``count`` window output rows in one batched RPC."
+  },
+  {
+    name: "aggregate_window_destructor",
+    key: "aggregateWindowDestructor",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Evict a cached partition from storage."
+  },
+  {
+    name: "aggregate_window_init",
+    key: "aggregateWindowInit",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Ship a partition to the worker for windowed aggregation."
+  },
+  {
+    name: "bind",
+    key: "bind",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Resolve output schema and validate arguments."
+  },
+  {
+    name: "catalog_attach",
+    key: "catalogAttach",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Attach to a catalog with options."
+  },
+  {
+    name: "catalog_catalogs",
+    key: "catalogCatalogs",
+    type: "unary",
+    params: schema2([]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List available catalog names."
+  },
+  {
+    name: "catalog_contents",
+    key: "catalogContents",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("if_none_match", utf82(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Return every schema and all of its contents in one result."
+  },
+  {
+    name: "catalog_copy_from_formats",
+    key: "catalogCopyFromFormats",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List custom ``COPY ... FROM`` formats advertised by this catalog."
+  },
+  {
+    name: "catalog_create",
+    key: "catalogCreate",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Create a new catalog."
+  },
+  {
+    name: "catalog_detach",
+    key: "catalogDetach",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Detach from a catalog."
+  },
+  {
+    name: "catalog_drop",
+    key: "catalogDrop",
+    type: "unary",
+    params: schema2([
+      field2("name", utf82(), false)
+    ]),
+    result: schema2([]),
+    doc: "Drop a catalog."
+  },
+  {
+    name: "catalog_index_create",
+    key: "catalogIndexCreate",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Create a new index."
+  },
+  {
+    name: "catalog_index_drop",
+    key: "catalogIndexDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("cascade", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Drop an index."
+  },
+  {
+    name: "catalog_index_get",
+    key: "catalogIndexGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get information about an index. Returns 0 or 1 items."
+  },
+  {
+    name: "catalog_macro_create",
+    key: "catalogMacroCreate",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Create a new macro."
+  },
+  {
+    name: "catalog_macro_drop",
+    key: "catalogMacroDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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)
+    ]),
+    result: schema2([]),
+    doc: "Drop a macro."
+  },
+  {
+    name: "catalog_macro_get",
+    key: "catalogMacroGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get information about a macro. Returns 0 or 1 items."
+  },
+  {
+    name: "catalog_schema_contents_functions",
+    key: "catalogSchemaContentsFunctions",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("type", dictionary2(utf82(), int162()), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List functions in a schema (scalar or table)."
+  },
+  {
+    name: "catalog_schema_contents_indexes",
+    key: "catalogSchemaContentsIndexes",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List indexes in a schema."
+  },
+  {
+    name: "catalog_schema_contents_macros",
+    key: "catalogSchemaContentsMacros",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("type", dictionary2(utf82(), int162()), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List macros in a schema (scalar or table)."
+  },
+  {
+    name: "catalog_schema_contents_tables",
+    key: "catalogSchemaContentsTables",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List tables in a schema."
+  },
+  {
+    name: "catalog_schema_contents_views",
+    key: "catalogSchemaContentsViews",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List views in a schema."
+  },
+  {
+    name: "catalog_schema_create",
+    key: "catalogSchemaCreate",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Create a new schema."
+  },
+  {
+    name: "catalog_schema_drop",
+    key: "catalogSchemaDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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)
+    ]),
+    result: schema2([]),
+    doc: "Drop a schema."
+  },
+  {
+    name: "catalog_schema_get",
+    key: "catalogSchemaGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get information about a schema. Returns 0 or 1 items."
+  },
+  {
+    name: "catalog_schemas",
+    key: "catalogSchemas",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List schemas in the catalog."
+  },
+  {
+    name: "catalog_table_column_add",
+    key: "catalogTableColumnAdd",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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),
+      field2("if_column_not_exists", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Add a new column to a table."
+  },
+  {
+    name: "catalog_table_column_comment_set",
+    key: "catalogTableColumnCommentSet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_name", utf82(), false),
+      field2("comment", utf82(), true),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Set or clear the comment on a table column."
+  },
+  {
+    name: "catalog_table_column_default_drop",
+    key: "catalogTableColumnDefaultDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Remove the default value from a column."
+  },
+  {
+    name: "catalog_table_column_default_set",
+    key: "catalogTableColumnDefaultSet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_name", utf82(), false),
+      field2("expression", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Set the default value expression for a column."
+  },
+  {
+    name: "catalog_table_column_drop",
+    key: "catalogTableColumnDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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),
+      field2("if_column_exists", bool2(), false),
+      field2("cascade", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Drop a column from a table."
+  },
+  {
+    name: "catalog_table_column_rename",
+    key: "catalogTableColumnRename",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Rename a column."
+  },
+  {
+    name: "catalog_table_column_statistics_get",
+    key: "catalogTableColumnStatisticsGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), true)
+    ]),
+    doc: "Get column statistics for a table."
+  },
+  {
+    name: "catalog_table_column_type_change",
+    key: "catalogTableColumnTypeChange",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_definition", binary2(), false),
+      field2("expression", utf82(), true),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Change the type of a column."
+  },
+  {
+    name: "catalog_table_comment_set",
+    key: "catalogTableCommentSet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("comment", utf82(), true),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Set or clear the comment on a table."
+  },
+  {
+    name: "catalog_table_create",
+    key: "catalogTableCreate",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Create a new table."
+  },
+  {
+    name: "catalog_table_delete_function_get",
+    key: "catalogTableDeleteFunctionGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the delete function for a table. Returns `WriteFunctionResult` as IPC bytes."
+  },
+  {
+    name: "catalog_table_drop",
+    key: "catalogTableDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("cascade", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Drop a table."
+  },
+  {
+    name: "catalog_table_get",
+    key: "catalogTableGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("at_unit", utf82(), true),
+      field2("at_value", utf82(), true),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get information about a table. Returns 0 or 1 items."
+  },
+  {
+    name: "catalog_table_insert_function_get",
+    key: "catalogTableInsertFunctionGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the insert function for a table. Returns `WriteFunctionResult` as IPC bytes."
+  },
+  {
+    name: "catalog_table_not_null_drop",
+    key: "catalogTableNotNullDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Remove NOT NULL constraint from a column."
+  },
+  {
+    name: "catalog_table_not_null_set",
+    key: "catalogTableNotNullSet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Add NOT NULL constraint to a column."
+  },
+  {
+    name: "catalog_table_rename",
+    key: "catalogTableRename",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Rename a table."
+  },
+  {
+    name: "catalog_table_scan_branches_get",
+    key: "catalogTableScanBranchesGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("at_unit", utf82(), true),
+      field2("at_value", utf82(), true),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the list of scan branches for a multi-branch table. Returns `ScanBranchesResult` as IPC bytes."
+  },
+  {
+    name: "catalog_table_scan_function_get",
+    key: "catalogTableScanFunctionGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("at_unit", utf82(), true),
+      field2("at_value", utf82(), true),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the scan function for a table. Returns `ScanFunctionResult` as IPC bytes."
+  },
+  {
+    name: "catalog_table_update_function_get",
+    key: "catalogTableUpdateFunctionGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the update function for a table. Returns `WriteFunctionResult` as IPC bytes."
+  },
+  {
+    name: "catalog_transaction_begin",
+    key: "catalogTransactionBegin",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Begin a new transaction."
+  },
+  {
+    name: "catalog_transaction_commit",
+    key: "catalogTransactionCommit",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("transaction_opaque_data", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Commit a transaction."
+  },
+  {
+    name: "catalog_transaction_rollback",
+    key: "catalogTransactionRollback",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("transaction_opaque_data", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Rollback a transaction."
+  },
+  {
+    name: "catalog_version",
+    key: "catalogVersion",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the current catalog version."
+  },
+  {
+    name: "catalog_view_comment_set",
+    key: "catalogViewCommentSet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("comment", utf82(), true),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Set or clear the comment on a view."
+  },
+  {
+    name: "catalog_view_create",
+    key: "catalogViewCreate",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Create a new view."
+  },
+  {
+    name: "catalog_view_drop",
+    key: "catalogViewDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("cascade", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Drop a view."
+  },
+  {
+    name: "catalog_view_get",
+    key: "catalogViewGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get information about a view. Returns 0 or 1 items."
+  },
+  {
+    name: "catalog_view_rename",
+    key: "catalogViewRename",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), 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),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Rename a view."
+  },
+  {
+    name: "init",
+    key: "init",
+    type: "stream",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    header: schema2([
+      field2("execution_id", binary2(), false),
+      field2("opaque_data", binary2(), true),
+      field2("max_workers", int642(), false)
+    ]),
+    doc: "Initialize a function execution and return a processing stream."
+  },
+  {
+    name: "table_buffering_combine",
+    key: "tableBufferingCombine",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Once-per-query end-of-input signal. Returns finalize_state_ids."
+  },
+  {
+    name: "table_buffering_destructor",
+    key: "tableBufferingDestructor",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Best-effort end-of-query cleanup. Must not raise."
+  },
+  {
+    name: "table_buffering_process",
+    key: "tableBufferingProcess",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Sink one input batch; return the worker-chosen state_id."
+  },
+  {
+    name: "table_function_cardinality",
+    key: "tableFunctionCardinality",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Estimate the cardinality of a table function's output."
+  },
+  {
+    name: "table_function_dynamic_to_string",
+    key: "tableFunctionDynamicToString",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Return user-defined diagnostics for EXPLAIN ANALYZE Extra Info."
+  },
+  {
+    name: "table_function_plan",
+    key: "tableFunctionPlan",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Plan a table-function scan into named, independently redeemable splits."
+  },
+  {
+    name: "table_function_statistics",
+    key: "tableFunctionStatistics",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), true)
+    ]),
+    doc: "Return per-column statistics for a table function's output."
+  }
+];
+var UNIMPLEMENTED_VGI_SERVICE = Object.freeze({
+  aggregateBind: async () => {
+    throw notImplemented("aggregate_bind");
+  },
+  aggregateCombine: async () => {
+    throw notImplemented("aggregate_combine");
+  },
+  aggregateDestructor: async () => {
+    throw notImplemented("aggregate_destructor");
+  },
+  aggregateFinalize: async () => {
+    throw notImplemented("aggregate_finalize");
+  },
+  aggregateStreamingChunk: async () => {
+    throw notImplemented("aggregate_streaming_chunk");
+  },
+  aggregateStreamingClose: async () => {
+    throw notImplemented("aggregate_streaming_close");
+  },
+  aggregateStreamingOpen: async () => {
+    throw notImplemented("aggregate_streaming_open");
+  },
+  aggregateUpdate: async () => {
+    throw notImplemented("aggregate_update");
+  },
+  aggregateWindow: async () => {
+    throw notImplemented("aggregate_window");
+  },
+  aggregateWindowBatch: async () => {
+    throw notImplemented("aggregate_window_batch");
+  },
+  aggregateWindowDestructor: async () => {
+    throw notImplemented("aggregate_window_destructor");
+  },
+  aggregateWindowInit: async () => {
+    throw notImplemented("aggregate_window_init");
+  },
+  bind: async () => {
+    throw notImplemented("bind");
+  },
+  catalogAttach: async () => {
+    throw notImplemented("catalog_attach");
+  },
+  catalogCatalogs: async () => {
+    throw notImplemented("catalog_catalogs");
+  },
+  catalogContents: async () => {
+    throw notImplemented("catalog_contents");
+  },
+  catalogCopyFromFormats: async () => {
+    throw notImplemented("catalog_copy_from_formats");
+  },
+  catalogCreate: async () => {
+    throw notImplemented("catalog_create");
+  },
+  catalogDetach: async () => {
+    throw notImplemented("catalog_detach");
+  },
+  catalogDrop: async () => {
+    throw notImplemented("catalog_drop");
+  },
+  catalogIndexCreate: async () => {
+    throw notImplemented("catalog_index_create");
+  },
+  catalogIndexDrop: async () => {
+    throw notImplemented("catalog_index_drop");
+  },
+  catalogIndexGet: async () => {
+    throw notImplemented("catalog_index_get");
+  },
+  catalogMacroCreate: async () => {
+    throw notImplemented("catalog_macro_create");
+  },
+  catalogMacroDrop: async () => {
+    throw notImplemented("catalog_macro_drop");
+  },
+  catalogMacroGet: async () => {
+    throw notImplemented("catalog_macro_get");
+  },
+  catalogSchemaContentsFunctions: async () => {
+    throw notImplemented("catalog_schema_contents_functions");
+  },
+  catalogSchemaContentsIndexes: async () => {
+    throw notImplemented("catalog_schema_contents_indexes");
+  },
+  catalogSchemaContentsMacros: async () => {
+    throw notImplemented("catalog_schema_contents_macros");
+  },
+  catalogSchemaContentsTables: async () => {
+    throw notImplemented("catalog_schema_contents_tables");
+  },
+  catalogSchemaContentsViews: async () => {
+    throw notImplemented("catalog_schema_contents_views");
+  },
+  catalogSchemaCreate: async () => {
+    throw notImplemented("catalog_schema_create");
+  },
+  catalogSchemaDrop: async () => {
+    throw notImplemented("catalog_schema_drop");
+  },
+  catalogSchemaGet: async () => {
+    throw notImplemented("catalog_schema_get");
+  },
+  catalogSchemas: async () => {
+    throw notImplemented("catalog_schemas");
+  },
+  catalogTableColumnAdd: async () => {
+    throw notImplemented("catalog_table_column_add");
+  },
+  catalogTableColumnCommentSet: async () => {
+    throw notImplemented("catalog_table_column_comment_set");
+  },
+  catalogTableColumnDefaultDrop: async () => {
+    throw notImplemented("catalog_table_column_default_drop");
+  },
+  catalogTableColumnDefaultSet: async () => {
+    throw notImplemented("catalog_table_column_default_set");
+  },
+  catalogTableColumnDrop: async () => {
+    throw notImplemented("catalog_table_column_drop");
+  },
+  catalogTableColumnRename: async () => {
+    throw notImplemented("catalog_table_column_rename");
+  },
+  catalogTableColumnStatisticsGet: async () => {
+    throw notImplemented("catalog_table_column_statistics_get");
+  },
+  catalogTableColumnTypeChange: async () => {
+    throw notImplemented("catalog_table_column_type_change");
+  },
+  catalogTableCommentSet: async () => {
+    throw notImplemented("catalog_table_comment_set");
+  },
+  catalogTableCreate: async () => {
+    throw notImplemented("catalog_table_create");
+  },
+  catalogTableDeleteFunctionGet: async () => {
+    throw notImplemented("catalog_table_delete_function_get");
+  },
+  catalogTableDrop: async () => {
+    throw notImplemented("catalog_table_drop");
+  },
+  catalogTableGet: async () => {
+    throw notImplemented("catalog_table_get");
+  },
+  catalogTableInsertFunctionGet: async () => {
+    throw notImplemented("catalog_table_insert_function_get");
+  },
+  catalogTableNotNullDrop: async () => {
+    throw notImplemented("catalog_table_not_null_drop");
+  },
+  catalogTableNotNullSet: async () => {
+    throw notImplemented("catalog_table_not_null_set");
+  },
+  catalogTableRename: async () => {
+    throw notImplemented("catalog_table_rename");
+  },
+  catalogTableScanBranchesGet: async () => {
+    throw notImplemented("catalog_table_scan_branches_get");
+  },
+  catalogTableScanFunctionGet: async () => {
+    throw notImplemented("catalog_table_scan_function_get");
+  },
+  catalogTableUpdateFunctionGet: async () => {
+    throw notImplemented("catalog_table_update_function_get");
+  },
+  catalogTransactionBegin: async () => {
+    throw notImplemented("catalog_transaction_begin");
+  },
+  catalogTransactionCommit: async () => {
+    throw notImplemented("catalog_transaction_commit");
+  },
+  catalogTransactionRollback: async () => {
+    throw notImplemented("catalog_transaction_rollback");
+  },
+  catalogVersion: async () => {
+    throw notImplemented("catalog_version");
+  },
+  catalogViewCommentSet: async () => {
+    throw notImplemented("catalog_view_comment_set");
+  },
+  catalogViewCreate: async () => {
+    throw notImplemented("catalog_view_create");
+  },
+  catalogViewDrop: async () => {
+    throw notImplemented("catalog_view_drop");
+  },
+  catalogViewGet: async () => {
+    throw notImplemented("catalog_view_get");
+  },
+  catalogViewRename: async () => {
+    throw notImplemented("catalog_view_rename");
+  },
+  init: unimplementedStream("init"),
+  tableBufferingCombine: async () => {
+    throw notImplemented("table_buffering_combine");
+  },
+  tableBufferingDestructor: async () => {
+    throw notImplemented("table_buffering_destructor");
+  },
+  tableBufferingProcess: async () => {
+    throw notImplemented("table_buffering_process");
+  },
+  tableFunctionCardinality: async () => {
+    throw notImplemented("table_function_cardinality");
+  },
+  tableFunctionDynamicToString: async () => {
+    throw notImplemented("table_function_dynamic_to_string");
+  },
+  tableFunctionPlan: async () => {
+    throw notImplemented("table_function_plan");
+  },
+  tableFunctionStatistics: async () => {
+    throw notImplemented("table_function_statistics");
+  }
+});
+function unimplementedMessage(method) {
+  return `${method} is not implemented by this worker`;
+}
+function notImplemented(method) {
+  return new MethodNotImplementedError(unimplementedMessage(method));
+}
+function unimplementedStream(method) {
+  return producerStream({
+    outputSchema: schema2([]),
+    init: () => {
+      throw notImplemented(method);
+    },
+    produce: () => {}
+  });
+}
+function registerVgiService(protocol, service) {
+  for (const m of VGI_V2_METHODS) {
+    if (m.type === "unary") {
+      const handler = service[m.key];
+      protocol.unary(m.name, {
+        params: m.params,
+        result: m.result,
+        doc: m.doc,
+        handler: (params, ctx) => handler.call(service, params, ctx)
+      });
+      continue;
+    }
+    const stream = service[m.key];
+    const common = {
+      params: m.params,
+      outputSchema: stream.outputSchema,
+      headerSchema: m.header ?? undefined,
+      headerInit: stream.headerInit,
+      onCancel: stream.onCancel,
+      doc: m.doc
+    };
+    if (stream.kind === "exchange") {
+      protocol.exchange(m.name, {
+        ...common,
+        inputSchema: stream.inputSchema,
+        init: stream.init,
+        exchange: stream.exchange
+      });
+    } else {
+      protocol.producer(m.name, { ...common, init: stream.init, produce: stream.produce });
+    }
+  }
+  return protocol;
+}
+function createVgiProtocol(service) {
+  return registerVgiService(new Protocol(VGI_PROTOCOL_NAME, { protocolVersion: VGI_PROTOCOL_VERSION }), service);
+}
 
 // src/protocol/handlers/function.ts
 init_arrow();
@@ -5686,9 +7095,6 @@ var RESULT_BINARY_SCHEMA = schema2([
 var REQUEST_PARAMS_SCHEMA = schema2([
   field2("request", binary2(), false)
 ]);
-var RESULT_BINARY_NULLABLE_SCHEMA = schema2([
-  field2("result", binary2(), true)
-]);
 function unwrapRequest(requestBytes) {
   const bytes = toUint8Array(requestBytes);
   const innerBatch = deserializeBatch(bytes);
@@ -5704,7 +7110,8 @@ function normalizeRequestSchemaPaths(params) {
 }
 function wrapResult(values, innerSchema) {
   const a = innerSchema;
-  const batch = batchFromColumns(Object.fromEntries(a.fields.map((f) => [f.name, [values[f.name] ?? null]])), a);
+  const row = conformRecord(a, values);
+  const batch = batchFromColumns(Object.fromEntries(a.fields.map((f) => [f.name, [row[f.name] ?? null]])), a);
   return { result: serializeBatch(batch) };
 }
 function overloadContext(req, catalogInterface) {
@@ -5730,9 +7137,12 @@ init_arrow();
 
 // src/errors.ts
 class VgiError extends Error {
-  constructor(message) {
+  errorCode;
+  constructor(message, code) {
     super(message);
     this.name = "VgiError";
+    if (code !== undefined)
+      this.errorCode = code;
   }
 }
 
@@ -5745,27 +7155,27 @@ class RowCountMismatchError extends VgiError {
 
 class FunctionNotFoundError extends VgiError {
   constructor(name, available) {
-    super(`Unknown function '${name}'`);
+    super(`Unknown function '${name}'`, "NOT_FOUND");
     this.name = "FunctionNotFoundError";
   }
 }
 
 class CatalogReadOnlyError extends VgiError {
   constructor(operation) {
-    super(`catalog is read-only: ${operation} is not supported`);
+    super(`catalog is read-only: ${operation} is not supported`, "FAILED_PRECONDITION");
     this.name = "CatalogReadOnlyError";
   }
 }
 class ArgumentValidationError extends VgiError {
   constructor(message) {
-    super(message);
+    super(message, "INVALID_ARGUMENT");
     this.name = "ArgumentValidationError";
   }
 }
 
 class NoCatalogError extends VgiError {
   constructor() {
-    super("No catalog is configured for this worker");
+    super("No catalog is configured for this worker", "UNIMPLEMENTED");
     this.name = "NoCatalogError";
   }
 }
@@ -6600,20 +8010,16 @@ async function unwrapParamsOpaque(params, ctx, signingKey) {
     }
   }
 }
-function catalogUnary(protocol, signingKey, name, config) {
-  protocol.unary(name, {
-    params: config.params,
-    result: config.result,
-    doc: config.doc,
-    handler: async (params, ctx) => {
-      if (params.request != null && params.attach_opaque_data === undefined && params.name === undefined) {
-        params = unwrapRequest(params.request);
-      }
-      normalizeRequestSchemaPaths(params);
-      await unwrapParamsOpaque(params, ctx, signingKey);
-      return config.handler(params, ctx);
+function catalogHandler(signingKey, handler) {
+  return async (wire, ctx) => {
+    let params = wire;
+    if (params.request != null && params.attach_opaque_data === undefined && params.name === undefined) {
+      params = unwrapRequest(params.request);
     }
-  });
+    normalizeRequestSchemaPaths(params);
+    await unwrapParamsOpaque(params, ctx, signingKey);
+    return handler(params, ctx);
+  };
 }
 function makeGetCatalog(catalog) {
   return () => {
@@ -6634,7 +8040,6 @@ function decodeOptionsBatch(bytes) {
   const row = iterRows(batch).next().value;
   return row ?? {};
 }
-var emptyResultSchema = schema2([]);
 
 // src/request-auth.ts
 var scope;
@@ -6864,7 +8269,7 @@ async function resolveSplitPayloads(request, innerParams, opts) {
     }));
   }
 }
-function registerFunctionMethods(protocol, config) {
+function functionHandlers(config) {
   const { registry, signingKey, catalogInterface } = config;
   async function stripAttach(attach, ctx) {
     if (attach == null)
@@ -6883,26 +8288,20 @@ function registerFunctionMethods(protocol, config) {
     }
     return overloadContext({ ...bindCall, attach_opaque_data: attach }, catalogInterface);
   }
-  const initHeaderSchema = GLOBAL_INIT_RESPONSE_SCHEMA;
   const emptySchema = schema2([]);
   const dummyInputSchema = schema2([
     field2("_tick", binary2(), true)
   ]);
-  protocol.unary("bind", {
-    params: BindParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params, ctx) => {
-      const innerParams = unwrapRequest(params.request);
-      const request = deserializeBindRequest(innerParams);
-      request.attach_opaque_data = await stripAttach(request.attach_opaque_data, ctx);
-      const func = registry.get(request.function_name, overloadContext(request, catalogInterface));
-      const response = await func.bind(request);
-      const serialized = serializeBindResponse(response);
-      return wrapResult(serialized, BindResultSchema);
-    }
-  });
-  protocol.exchange("init", {
-    params: InitParamsSchema,
+  const bind = async (params, ctx) => {
+    const innerParams = unwrapRequest(params.request);
+    const request = deserializeBindRequest(innerParams);
+    request.attach_opaque_data = await stripAttach(request.attach_opaque_data, ctx);
+    const func = registry.get(request.function_name, overloadContext(request, catalogInterface));
+    const response = await func.bind(request);
+    const serialized = serializeBindResponse(response);
+    return wrapResult(serialized, BindResultSchema);
+  };
+  const init = exchangeStream({
     inputSchema: dummyInputSchema,
     outputSchema: emptySchema,
     init: async (params, ctx) => {
@@ -6995,7 +8394,6 @@ function registerFunctionMethods(protocol, config) {
       }
       state.filterHistory = handlerState?.filterHistory ?? null;
     },
-    headerSchema: initHeaderSchema,
     headerInit: (params, state, ctx) => {
       if (!state._initResponse) {
         throw new Error("headerInit called on deserialized state: _initResponse not available");
@@ -7003,83 +8401,75 @@ function registerFunctionMethods(protocol, config) {
       return serializeGlobalInitResponse(state._initResponse);
     }
   });
-  protocol.unary("table_function_cardinality", {
-    params: TableFunctionCardinalityParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const request = deserializeCardinalityRequest(innerParams);
-      const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
-      let cardResult;
-      if (func.cardinality) {
-        cardResult = serializeTableCardinality(await func.cardinality(request));
-      } else {
-        cardResult = { estimate: null, max: null };
-      }
-      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: TableFunctionStatisticsParamsSchema,
-    result: RESULT_BINARY_NULLABLE_SCHEMA,
-    handler: async (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const request = deserializeCardinalityRequest(innerParams);
-      const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
-      if (!func.statistics)
-        return { result: null };
-      const stats = func.statistics(request);
-      if (!stats || stats.length === 0)
-        return { result: null };
-      return { result: serializeColumnStatistics(stats) };
+  const tableFunctionCardinality = async (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const request = deserializeCardinalityRequest(innerParams);
+    const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
+    let cardResult;
+    if (func.cardinality) {
+      cardResult = serializeTableCardinality(await func.cardinality(request));
+    } else {
+      cardResult = { estimate: null, max: null };
     }
-  });
-  protocol.unary("table_function_dynamic_to_string", {
-    params: TableFunctionDynamicToStringParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const bindCallBytes = toUint8Array(innerParams.bind_call);
-      const bindCallBatch = deserializeBatch(bindCallBytes);
-      const bindParams = batchToScalarDict(bindCallBatch);
-      const bindCall = deserializeBindRequest(bindParams);
-      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 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);
+    return wrapResult(cardResult, TableFunctionCardinalityResultSchema);
+  };
+  const tableFunctionPlan = 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);
+  };
+  const tableFunctionStatistics = async (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const request = deserializeCardinalityRequest(innerParams);
+    const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
+    if (!func.statistics)
+      return { result: null };
+    const stats = func.statistics(request);
+    if (!stats || stats.length === 0)
+      return { result: null };
+    return { result: serializeColumnStatistics(stats) };
+  };
+  const tableFunctionDynamicToString = async (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const bindCallBytes = toUint8Array(innerParams.bind_call);
+    const bindCallBatch = deserializeBatch(bindCallBytes);
+    const bindParams = batchToScalarDict(bindCallBatch);
+    const bindCall = deserializeBindRequest(bindParams);
+    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 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);
+  };
+  return {
+    bind,
+    init,
+    tableFunctionCardinality,
+    tableFunctionPlan,
+    tableFunctionStatistics,
+    tableFunctionDynamicToString
+  };
 }
 
 // src/protocol/handlers/aggregate.ts
@@ -7457,7 +8847,7 @@ function defineAggregate(config) {
 }
 
 // src/protocol/handlers/aggregate.ts
-function registerAggregateMethods(protocol, registry) {
+function aggregateHandlers(registry) {
   function resolveAggregate(name, schemaPath) {
     const func = registry.get(name, {
       arguments: new Arguments,
@@ -7470,199 +8860,180 @@ function registerAggregateMethods(protocol, registry) {
     }
     return func.aggregateConfig;
   }
-  protocol.unary("aggregate_bind", {
-    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_path ?? null);
-      const argBytes = toUint8Array(innerParams.arguments);
-      const args = deserializeArguments(argBytes);
-      const inputSchema = innerParams.input_schema ? deserializeSchema(toUint8Array(innerParams.input_schema)) : null;
-      const secretsBytes = innerParams.secrets ? toUint8Array(innerParams.secrets) : null;
-      const secretsBatch = secretsBytes && secretsBytes.length > 0 ? deserializeBatch(secretsBytes) : null;
-      const secrets = secretsBatch ? batchToSecretDict(secretsBatch) : {};
-      const bindParams = {
-        args: extractArgMap(cfg, args),
-        arguments: args,
-        inputSchema,
-        settings: {},
-        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);
-      setExecutionState(executionId, {
-        states: new Map,
-        bindArgs: args,
-        bindParams
-      });
-      const outType = cfg.onBind ? await cfg.onBind(bindParams) : cfg.outputType;
-      const outSchema = schema2([field2("result", outType, true)]);
-      return wrapResult({ output_schema: serializeSchema(outSchema), execution_id: executionId }, AggregateBindResultSchema);
-    }
-  });
-  protocol.unary("aggregate_update", {
-    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_path ?? null);
-      const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
-      if (!batch || batch.numRows === 0)
-        return wrapResult({}, schema2([]));
-      const gidIdx = batch.schema.fields.findIndex((f) => f.name === GROUP_COLUMN_NAME);
-      if (gidIdx < 0) {
-        throw new Error(`aggregate_update: input batch missing ${GROUP_COLUMN_NAME} column`);
-      }
-      const gidCol = batch.getChildAt(gidIdx);
-      const groupIds = [];
-      const uniqueGids = new Set;
-      for (let i = 0;i < batch.numRows; i++) {
-        const v = gidCol.get(i);
-        const g = typeof v === "bigint" ? v : BigInt(v);
-        groupIds.push(g);
-        uniqueGids.add(g);
-      }
-      const exec = getExecutionState(executionId, uniqueGids);
-      if (!exec) {
-        throw new Error(`aggregate_update: unknown execution_id for '${functionName}' (bind missing or state dropped)`);
-      }
-      const columns = [];
-      for (let i = 0;i < batch.schema.fields.length; i++) {
-        if (i === gidIdx)
-          continue;
-        columns.push(batch.getChildAt(i));
-      }
-      const ensureState = (gid) => {
-        let s = exec.states.get(gid);
-        if (s === undefined) {
-          s = cfg.initialState(exec.bindParams);
-          exec.states.set(gid, s);
-        }
-        return s;
-      };
-      cfg.update({
-        states: exec.states,
-        groupIds,
-        columns,
-        args: exec.bindParams.args,
-        ensureState
-      });
-      persistGroupStates(executionId, uniqueGids);
+  const aggregateBind = async (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName = innerParams.function_name;
+    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;
+    const secretsBytes = innerParams.secrets ? toUint8Array(innerParams.secrets) : null;
+    const secretsBatch = secretsBytes && secretsBytes.length > 0 ? deserializeBatch(secretsBytes) : null;
+    const secrets = secretsBatch ? batchToSecretDict(secretsBatch) : {};
+    const bindParams = {
+      args: extractArgMap(cfg, args),
+      arguments: args,
+      inputSchema,
+      settings: {},
+      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);
+    setExecutionState(executionId, {
+      states: new Map,
+      bindArgs: args,
+      bindParams
+    });
+    const outType = cfg.onBind ? await cfg.onBind(bindParams) : cfg.outputType;
+    const outSchema = schema2([field2("result", outType, true)]);
+    return wrapResult({ output_schema: serializeSchema(outSchema), execution_id: executionId }, AggregateBindResultSchema);
+  };
+  const aggregateUpdate = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName = innerParams.function_name;
+    const executionId = toUint8Array(innerParams.execution_id);
+    const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
+    const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
+    if (!batch || batch.numRows === 0)
       return wrapResult({}, schema2([]));
+    const gidIdx = batch.schema.fields.findIndex((f) => f.name === GROUP_COLUMN_NAME);
+    if (gidIdx < 0) {
+      throw new Error(`aggregate_update: input batch missing ${GROUP_COLUMN_NAME} column`);
+    }
+    const gidCol = batch.getChildAt(gidIdx);
+    const groupIds = [];
+    const uniqueGids = new Set;
+    for (let i = 0;i < batch.numRows; i++) {
+      const v = gidCol.get(i);
+      const g = typeof v === "bigint" ? v : BigInt(v);
+      groupIds.push(g);
+      uniqueGids.add(g);
+    }
+    const exec = getExecutionState(executionId, uniqueGids);
+    if (!exec) {
+      throw new Error(`aggregate_update: unknown execution_id for '${functionName}' (bind missing or state dropped)`);
+    }
+    const columns = [];
+    for (let i = 0;i < batch.schema.fields.length; i++) {
+      if (i === gidIdx)
+        continue;
+      columns.push(batch.getChildAt(i));
     }
-  });
-  protocol.unary("aggregate_combine", {
-    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_path ?? null);
-      const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
-      if (!batch || batch.numRows === 0)
-        return wrapResult({}, schema2([]));
-      const srcCol = batch.getChild("source_group_id");
-      const tgtCol = batch.getChild("target_group_id");
-      const referencedGids = new Set;
-      const srcIds = [];
-      const tgtIds = [];
-      for (let i = 0;i < batch.numRows; i++) {
-        const src = BigInt(srcCol.get(i));
-        const tgt = BigInt(tgtCol.get(i));
-        srcIds.push(src);
-        tgtIds.push(tgt);
-        referencedGids.add(src);
-        referencedGids.add(tgt);
-      }
-      const exec = getExecutionState(executionId, referencedGids);
-      if (!exec) {
-        throw new Error(`aggregate_combine: unknown execution_id for '${functionName}' ` + `(context missing on disk — bind may have failed or been cleaned up)`);
-      }
-      const touchedTargets = new Set;
-      for (let i = 0;i < batch.numRows; i++) {
-        const src = srcIds[i];
-        const tgt = tgtIds[i];
-        const srcHas = exec.states.has(src);
-        const tgtHas = exec.states.has(tgt);
-        if (!srcHas && !tgtHas)
-          continue;
-        const srcState = srcHas ? exec.states.get(src) : cfg.initialState(exec.bindParams);
-        const tgtState = tgtHas ? exec.states.get(tgt) : cfg.initialState(exec.bindParams);
-        exec.states.set(tgt, cfg.combine(srcState, tgtState, exec.bindParams));
-        touchedTargets.add(tgt);
+    const ensureState = (gid) => {
+      let s = exec.states.get(gid);
+      if (s === undefined) {
+        s = cfg.initialState(exec.bindParams);
+        exec.states.set(gid, s);
       }
-      persistGroupStates(executionId, touchedTargets);
+      return s;
+    };
+    cfg.update({
+      states: exec.states,
+      groupIds,
+      columns,
+      args: exec.bindParams.args,
+      ensureState
+    });
+    persistGroupStates(executionId, uniqueGids);
+    return wrapResult({}, schema2([]));
+  };
+  const aggregateCombine = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName = innerParams.function_name;
+    const executionId = toUint8Array(innerParams.execution_id);
+    const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
+    const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
+    if (!batch || batch.numRows === 0)
       return wrapResult({}, schema2([]));
+    const srcCol = batch.getChild("source_group_id");
+    const tgtCol = batch.getChild("target_group_id");
+    const referencedGids = new Set;
+    const srcIds = [];
+    const tgtIds = [];
+    for (let i = 0;i < batch.numRows; i++) {
+      const src = BigInt(srcCol.get(i));
+      const tgt = BigInt(tgtCol.get(i));
+      srcIds.push(src);
+      tgtIds.push(tgt);
+      referencedGids.add(src);
+      referencedGids.add(tgt);
+    }
+    const exec = getExecutionState(executionId, referencedGids);
+    if (!exec) {
+      throw new Error(`aggregate_combine: unknown execution_id for '${functionName}' ` + `(context missing on disk — bind may have failed or been cleaned up)`);
+    }
+    const touchedTargets = new Set;
+    for (let i = 0;i < batch.numRows; i++) {
+      const src = srcIds[i];
+      const tgt = tgtIds[i];
+      const srcHas = exec.states.has(src);
+      const tgtHas = exec.states.has(tgt);
+      if (!srcHas && !tgtHas)
+        continue;
+      const srcState = srcHas ? exec.states.get(src) : cfg.initialState(exec.bindParams);
+      const tgtState = tgtHas ? exec.states.get(tgt) : cfg.initialState(exec.bindParams);
+      exec.states.set(tgt, cfg.combine(srcState, tgtState, exec.bindParams));
+      touchedTargets.add(tgt);
     }
-  });
-  protocol.unary("aggregate_finalize", {
-    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_path ?? null);
-      const outputSchema = deserializeSchema(toUint8Array(innerParams.output_schema));
-      const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
-      const groupIds = [];
-      const uniqueGids = new Set;
-      if (gidBatch) {
-        const col = gidBatch.getChild("group_id");
-        for (let i = 0;i < gidBatch.numRows; i++) {
-          const v = col.get(i);
-          const g = typeof v === "bigint" ? v : BigInt(v);
-          groupIds.push(g);
-          uniqueGids.add(g);
-        }
-      }
-      const exec = getExecutionState(executionId, uniqueGids);
-      if (!exec) {
-        throw new Error(`aggregate_finalize: unknown execution_id for '${functionName}'`);
-      }
-      const states = new Map;
-      for (const gid of groupIds) {
-        states.set(gid, exec.states.has(gid) ? exec.states.get(gid) : null);
-      }
-      const resultBatch = cfg.finalize({
-        groupIds,
-        states,
-        outputSchema,
-        args: exec.bindParams.args
-      });
-      return wrapResult({ result_batch: serializeBatchWithSchema(resultBatch) }, AggregateFinalizeResultSchema);
-    }
-  });
-  protocol.unary("aggregate_destructor", {
-    params: AggregateDestructorParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const executionId = toUint8Array(innerParams.execution_id);
-      const exec = getExecutionState(executionId);
-      if (!exec)
-        return wrapResult({}, schema2([]));
-      const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
-      if (!gidBatch || gidBatch.numRows === 0)
-        return wrapResult({}, schema2([]));
+    persistGroupStates(executionId, touchedTargets);
+    return wrapResult({}, schema2([]));
+  };
+  const aggregateFinalize = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName = innerParams.function_name;
+    const executionId = toUint8Array(innerParams.execution_id);
+    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 = [];
+    const uniqueGids = new Set;
+    if (gidBatch) {
       const col = gidBatch.getChild("group_id");
-      const toDrop = new Set;
       for (let i = 0;i < gidBatch.numRows; i++) {
         const v = col.get(i);
         const g = typeof v === "bigint" ? v : BigInt(v);
-        exec.states.delete(g);
-        toDrop.add(g);
+        groupIds.push(g);
+        uniqueGids.add(g);
       }
-      persistGroupStates(executionId, toDrop);
-      return wrapResult({}, schema2([]));
     }
-  });
+    const exec = getExecutionState(executionId, uniqueGids);
+    if (!exec) {
+      throw new Error(`aggregate_finalize: unknown execution_id for '${functionName}'`);
+    }
+    const states = new Map;
+    for (const gid of groupIds) {
+      states.set(gid, exec.states.has(gid) ? exec.states.get(gid) : null);
+    }
+    const resultBatch = cfg.finalize({
+      groupIds,
+      states,
+      outputSchema,
+      args: exec.bindParams.args
+    });
+    return wrapResult({ result_batch: serializeBatchWithSchema(resultBatch) }, AggregateFinalizeResultSchema);
+  };
+  const aggregateDestructor = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const executionId = toUint8Array(innerParams.execution_id);
+    const exec = getExecutionState(executionId);
+    if (!exec)
+      return wrapResult({}, schema2([]));
+    const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
+    if (!gidBatch || gidBatch.numRows === 0)
+      return wrapResult({}, schema2([]));
+    const col = gidBatch.getChild("group_id");
+    const toDrop = new Set;
+    for (let i = 0;i < gidBatch.numRows; i++) {
+      const v = col.get(i);
+      const g = typeof v === "bigint" ? v : BigInt(v);
+      exec.states.delete(g);
+      toDrop.add(g);
+    }
+    persistGroupStates(executionId, toDrop);
+    return wrapResult({}, schema2([]));
+  };
+  return { aggregateBind, aggregateUpdate, aggregateCombine, aggregateFinalize, aggregateDestructor };
 }
 function extractArgMap(cfg, args) {
   const out = {};
@@ -7792,7 +9163,7 @@ function splitLenPrefixed(buf, count) {
 }
 
 // src/protocol/handlers/table-buffering.ts
-function registerTableBufferingMethods(protocol, registry, signingKey) {
+function tableBufferingHandlers(registry, signingKey) {
   function resolveBuffering(name, schemaPath) {
     const func = registry.get(name, {
       arguments: new Arguments,
@@ -7837,55 +9208,44 @@ function registerTableBufferingMethods(protocol, registry, signingKey) {
     };
     return { func, params };
   }
-  protocol.unary("table_buffering_process", {
-    params: TableBufferingProcessParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (rpcParams, ctx) => {
-      const inner = unwrapRequest(rpcParams.request);
-      const clientLog = makeClientLog(ctx);
-      const { func, params } = await loadParams(inner, clientLog, ctx);
-      if (inner.batch_index != null) {
-        params.batchIndex = Number(inner.batch_index);
-      }
-      const batch = deserializeBatch(toUint8Array(inner.input_batch));
-      const stateId = await func.bufferingConfig.process(batch, params);
-      if (!(stateId instanceof Uint8Array)) {
-        throw new Error(`${func.meta.name}.process() must return Uint8Array (the opaque state_id)`);
-      }
-      return wrapResult({ state_id: stateId }, TableBufferingProcessResultSchema);
+  const tableBufferingProcess = async (rpcParams, ctx) => {
+    const inner = unwrapRequest(rpcParams.request);
+    const clientLog = makeClientLog(ctx);
+    const { func, params } = await loadParams(inner, clientLog, ctx);
+    if (inner.batch_index != null) {
+      params.batchIndex = Number(inner.batch_index);
     }
-  });
-  protocol.unary("table_buffering_combine", {
-    params: TableBufferingCombineParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (rpcParams, ctx) => {
-      const inner = unwrapRequest(rpcParams.request);
-      const clientLog = makeClientLog(ctx);
-      const { func, params } = await loadParams(inner, clientLog, ctx);
-      const stateIds = decodeBytesList(inner.state_ids);
-      const finalizeStateIds = await func.bufferingConfig.combine(stateIds, params);
-      const out = finalizeStateIds.map((fid, i) => {
-        if (!(fid instanceof Uint8Array)) {
-          throw new Error(`${func.meta.name}.combine() returned non-Uint8Array finalize_state_id at index ${i}`);
-        }
-        return fid;
-      });
-      return wrapResult({ finalize_state_ids: out }, TableBufferingCombineResultSchema);
+    const batch = deserializeBatch(toUint8Array(inner.input_batch));
+    const stateId = await func.bufferingConfig.process(batch, params);
+    if (!(stateId instanceof Uint8Array)) {
+      throw new Error(`${func.meta.name}.process() must return Uint8Array (the opaque state_id)`);
     }
-  });
-  protocol.unary("table_buffering_destructor", {
-    params: TableBufferingDestructorParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (rpcParams) => {
-      try {
-        const inner = unwrapRequest(rpcParams.request);
-        const executionId = toUint8Array(inner.execution_id);
-        const bound = new BoundStorage(storage, executionId);
-        await bound.executionClear();
-      } catch {}
-      return wrapResult({}, TableBufferingDestructorResultSchema);
-    }
-  });
+    return wrapResult({ state_id: stateId }, TableBufferingProcessResultSchema);
+  };
+  const tableBufferingCombine = async (rpcParams, ctx) => {
+    const inner = unwrapRequest(rpcParams.request);
+    const clientLog = makeClientLog(ctx);
+    const { func, params } = await loadParams(inner, clientLog, ctx);
+    const stateIds = decodeBytesList(inner.state_ids);
+    const finalizeStateIds = await func.bufferingConfig.combine(stateIds, params);
+    const out = finalizeStateIds.map((fid, i) => {
+      if (!(fid instanceof Uint8Array)) {
+        throw new Error(`${func.meta.name}.combine() returned non-Uint8Array finalize_state_id at index ${i}`);
+      }
+      return fid;
+    });
+    return wrapResult({ finalize_state_ids: out }, TableBufferingCombineResultSchema);
+  };
+  const tableBufferingDestructor = async (rpcParams) => {
+    try {
+      const inner = unwrapRequest(rpcParams.request);
+      const executionId = toUint8Array(inner.execution_id);
+      const bound = new BoundStorage(storage, executionId);
+      await bound.executionClear();
+    } catch {}
+    return wrapResult({}, TableBufferingDestructorResultSchema);
+  };
+  return { tableBufferingProcess, tableBufferingCombine, tableBufferingDestructor };
 }
 function makeClientLog(ctx) {
   if (ctx && typeof ctx.clientLog === "function") {
@@ -7912,7 +9272,7 @@ function hex(buf) {
 // src/codec/asd.ts
 init_arrow();
 function encodeASD(schema, obj) {
-  return serializeBatch(batchFromRows([sortMapsForSchema(schema, obj)], schema));
+  return serializeBatch(batchFromRows([sortMapsForSchema(schema, conformRecord(schema, obj))], schema));
 }
 function compareCodePoints(a, b) {
   const n = Math.min(a.length, b.length);
@@ -7929,7 +9289,7 @@ function compareCodePoints(a, b) {
   }
   return a.length - b.length;
 }
-function mapPairs(raw) {
+function mapPairs2(raw) {
   if (Array.isArray(raw))
     return raw.map((e) => Array.isArray(e) ? [e[0], e[1]] : [e?.key, e?.value]);
   if (raw instanceof Map)
@@ -7964,7 +9324,7 @@ function sortMapsForType(type, value) {
   if (isMap(type)) {
     const entries = type.children[0].type;
     const valueType = entries.children[1].type;
-    return mapPairs(value).map(([k, v]) => [k, sortMapsForType(valueType, v)]).sort((x, y) => compareKeys(x[0], y[0]));
+    return mapPairs2(value).map(([k, v]) => [k, sortMapsForType(valueType, v)]).sort((x, y) => compareKeys(x[0], y[0]));
   }
   if (isList(type)) {
     const child = type.children[0].type;
@@ -8222,12 +9582,12 @@ var encodeAttachCatalogInfo = (v) => encodeASD(AttachCatalogInfoSchema, {
   secret_ref: v.secret_ref ?? ""
 });
 function encodeScanFunctionResult(functionName, argumentsBytes, requiredExtensions = [], schemaPath = null) {
-  return serializeBatch(batchFromColumns({
+  return serializeBatch(batchFromColumns(conformColumns(ScanFunctionResultSchema, {
     function_name: [functionName],
     arguments: [argumentsBytes],
     required_extensions: [requiredExtensions],
     schema_path: [schemaPath]
-  }, ScanFunctionResultSchema));
+  }), ScanFunctionResultSchema));
 }
 function singleBranchResult(legacy) {
   return {
@@ -8242,7 +9602,7 @@ function singleBranchResult(legacy) {
   };
 }
 function encodeScanBranch(cols) {
-  return serializeBatch(batchFromColumns({
+  return serializeBatch(batchFromColumns(conformColumns(ScanBranchSchema, {
     function_name: [cols.function_name],
     arguments: [cols.arguments],
     branch_filter: [cols.branch_filter ?? null],
@@ -8254,7 +9614,7 @@ function encodeScanBranch(cols) {
     format_locations: [cols.format_locations ?? null],
     format_options: [cols.format_options ?? null],
     schema_path: [cols.schema_path ?? null]
-  }, ScanBranchSchema));
+  }), ScanBranchSchema));
 }
 function isPromise(v) {
   return v != null && typeof v.then === "function";
@@ -8427,7 +9787,7 @@ class CatalogInterface {
 // src/attach-ticket.ts
 init_arrow();
 import {
-  Protocol,
+  Protocol as Protocol2,
   badRequest,
   errorInfo,
   preconditionFailure
@@ -8563,7 +9923,7 @@ async function checkReservedAttachOptions(catalog) {
 var ATTACH_TICKET_PREFIX = "vgia1.";
 var ATTACH_TICKET_OPTION = RESERVED_ATTACH_OPTION;
 var ATTACH_TICKETS_PROTOCOL_NAME = "vgi.attach_tickets.v1";
-var ATTACH_TICKETS_PROTOCOL_VERSION = "1.0.0";
+var ATTACH_TICKETS_PROTOCOL_VERSION = "2.0.0";
 var TICKET_ENVELOPE_VERSION = 1;
 var MAX_OPTIONS_BYTES = 16 * 1024;
 var MAX_TICKET_CHARS = 32 * 1024;
@@ -8838,8 +10198,19 @@ var SEAL_ATTACH_REQUEST_SCHEMA = schema2([
 ]);
 var ATTACH_TICKET_SCHEMA = schema2([
   field2("ticket", utf82(), false),
-  field2("expires_at", float642(), false)
+  field2("expires_at", timestamp2(TimeUnit2.MICROSECOND, "UTC"), true)
 ]);
+function expiresAtMicros(value) {
+  if (value === null)
+    return null;
+  const ms = value.getTime();
+  if (!Number.isFinite(ms))
+    throw new TypeError("AttachTicket.expires_at must be a valid Date or null");
+  return BigInt(ms) * 1000n;
+}
+function encodeAttachTicket(ticket) {
+  return serializeBatch(batchFromColumns({ ticket: [ticket.ticket], expires_at: [expiresAtMicros(ticket.expires_at)] }, ATTACH_TICKET_SCHEMA));
+}
 function resolveTicketMaxTtl(grantKeys, env) {
   if (grantKeys)
     return Math.trunc(grantKeys.maxTtlSeconds);
@@ -8926,10 +10297,10 @@ async function sealAttach2(config, request, auth) {
   } catch (e) {
     throw new AttachTicketRequestError("seal_attach request is invalid", [["request", e.message]]);
   }
-  return { ticket: token, expires_at: expiresAt === 0 ? Number.POSITIVE_INFINITY : expiresAt };
+  return { ticket: token, expires_at: expiresAt === 0 ? null : new Date(expiresAt * 1000) };
 }
 function buildAttachTicketsProtocol(config) {
-  const p = new Protocol(ATTACH_TICKETS_PROTOCOL_NAME, { protocolVersion: ATTACH_TICKETS_PROTOCOL_VERSION });
+  const p = new Protocol2(ATTACH_TICKETS_PROTOCOL_NAME, { protocolVersion: ATTACH_TICKETS_PROTOCOL_VERSION });
   p.unary("seal_attach", {
     params: REQUEST_PARAMS_SCHEMA,
     result: RESULT_BINARY_SCHEMA,
@@ -8937,544 +10308,376 @@ function buildAttachTicketsProtocol(config) {
     handler: async (params, ctx) => {
       const request = unwrapRequest(params.request);
       const sealed = await sealAttach2(config, request, ctx?.auth);
-      const batch = batchFromColumns({ ticket: [sealed.ticket], expires_at: [sealed.expires_at] }, ATTACH_TICKET_SCHEMA);
-      return { result: serializeBatch(batch) };
+      return { result: encodeAttachTicket(sealed) };
     }
   });
   return p;
 }
 
 // src/protocol/handlers/catalog/admin.ts
-function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
-  catalogUnary(protocol, signingKey, "catalog_catalogs", {
-    params: CatalogCatalogsParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async () => {
-      const cat = getCatalog();
-      const infos = cat.catalogsInfo ? await cat.catalogsInfo() : cat.catalogs().map((name) => ({
-        name,
-        implementation_version: null,
-        data_version_spec: null,
-        attach_option_specs: [],
-        releases: []
-      }));
-      const items = infos.map((info) => encodeCatalogInfo(info));
-      return wrapResult({ items }, CatalogCatalogsResultSchema);
-    }
+function catalogAdminHandlers(getCatalog, signingKey) {
+  const catalogCatalogs = catalogHandler(signingKey, async () => {
+    const cat = getCatalog();
+    const infos = cat.catalogsInfo ? await cat.catalogsInfo() : cat.catalogs().map((name) => ({
+      name,
+      implementation_version: null,
+      data_version_spec: null,
+      attach_option_specs: [],
+      releases: []
+    }));
+    const items = infos.map((info) => encodeCatalogInfo(info));
+    return wrapResult({ items }, CatalogCatalogsResultSchema);
   });
-  protocol.unary("catalog_attach", {
-    params: CatalogAttachParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params, ctx) => {
-      const innerParams = unwrapRequest(params.request);
-      const cat = getCatalog();
-      let optionsDict = decodeOptionsBatch(innerParams.options);
-      const restored = await redeemAttachTicket(optionsDict, signingKey, ctx?.auth ?? currentRequestAuth());
-      if (restored !== null) {
-        innerParams.name = restored.name;
-        innerParams.options = restored.optionsIpc;
-        innerParams.data_version_spec = restored.dataVersionSpec;
-        innerParams.implementation_version = restored.implementationVersion;
-        optionsDict = restored.options;
-      }
-      const result = await cat.attach(innerParams.name, optionsDict, innerParams.data_version_spec ?? null, innerParams.implementation_version ?? null);
-      const sealedAttach = await sealAttach(toUint8Array(result.attach_opaque_data), ctx?.auth, signingKey);
-      return wrapResult(buildCatalogAttachResult({
-        ...result,
-        attach_opaque_data: sealedAttach,
-        supports_column_statistics: result.supports_column_statistics ?? true
-      }), CatalogAttachResultSchema);
-    }
+  const catalogAttach = async (params, ctx) => {
+    const innerParams = unwrapRequest(params.request);
+    const cat = getCatalog();
+    let optionsDict = decodeOptionsBatch(innerParams.options);
+    const restored = await redeemAttachTicket(optionsDict, signingKey, ctx?.auth ?? currentRequestAuth());
+    if (restored !== null) {
+      innerParams.name = restored.name;
+      innerParams.options = restored.optionsIpc;
+      innerParams.data_version_spec = restored.dataVersionSpec;
+      innerParams.implementation_version = restored.implementationVersion;
+      optionsDict = restored.options;
+    }
+    const result = await cat.attach(innerParams.name, optionsDict, innerParams.data_version_spec ?? null, innerParams.implementation_version ?? null);
+    const sealedAttach = await sealAttach(toUint8Array(result.attach_opaque_data), ctx?.auth, signingKey);
+    return wrapResult(buildCatalogAttachResult({
+      ...result,
+      attach_opaque_data: sealedAttach,
+      supports_column_statistics: result.supports_column_statistics ?? true
+    }), CatalogAttachResultSchema);
+  };
+  const catalogDetach = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    await cat.detach(toUint8Array(params.attach_opaque_data));
+    return {};
   });
-  catalogUnary(protocol, signingKey, "catalog_detach", {
-    params: CatalogDetachParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      await cat.detach(toUint8Array(params.attach_opaque_data));
-      return {};
-    }
+  const catalogCreate = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    await cat.create(params.name, params.on_conflict, params.options);
+    return {};
   });
-  catalogUnary(protocol, signingKey, "catalog_create", {
-    params: CatalogCreateParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      await cat.create(params.name, params.on_conflict, params.options);
-      return {};
-    }
+  const catalogDrop = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    await cat.drop(params.name);
+    return {};
   });
-  catalogUnary(protocol, signingKey, "catalog_drop", {
-    params: CatalogDropParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      await cat.drop(params.name);
-      return {};
-    }
+  const catalogVersion = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    const version = await cat.version(toUint8Array(params.attach_opaque_data), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+    return wrapResult({ version }, CatalogVersionResultSchema);
   });
-  catalogUnary(protocol, signingKey, "catalog_version", {
-    params: CatalogVersionParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      const version = await cat.version(toUint8Array(params.attach_opaque_data), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
-      return wrapResult({ version }, CatalogVersionResultSchema);
-    }
+  const catalogTransactionBegin = async (params, ctx) => {
+    const auth = ctx?.auth;
+    const sealedAttach = params.attach_opaque_data != null ? toUint8Array(params.attach_opaque_data) : new Uint8Array(0);
+    const attachPlain = await openAttach(sealedAttach, auth, signingKey);
+    const cat = getCatalog();
+    const txPlain = await cat.transactionBegin(attachPlain);
+    const transaction_opaque_data = txPlain != null ? await sealTransaction(toUint8Array(txPlain), sealedAttach, auth, signingKey) : null;
+    return wrapResult({ transaction_opaque_data }, CatalogTransactionBeginResultSchema);
+  };
+  const catalogTransactionCommit = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    await cat.transactionCommit(toUint8Array(params.attach_opaque_data), toUint8Array(params.transaction_opaque_data));
+    return {};
   });
-  protocol.unary("catalog_transaction_begin", {
-    params: CatalogTransactionBeginParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params, ctx) => {
-      const auth = ctx?.auth;
-      const sealedAttach = params.attach_opaque_data != null ? toUint8Array(params.attach_opaque_data) : new Uint8Array(0);
-      const attachPlain = await openAttach(sealedAttach, auth, signingKey);
-      const cat = getCatalog();
-      const txPlain = await cat.transactionBegin(attachPlain);
-      const transaction_opaque_data = txPlain != null ? await sealTransaction(toUint8Array(txPlain), sealedAttach, auth, signingKey) : null;
-      return wrapResult({ transaction_opaque_data }, CatalogTransactionBeginResultSchema);
-    }
+  const catalogTransactionRollback = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    await cat.transactionRollback(toUint8Array(params.attach_opaque_data), toUint8Array(params.transaction_opaque_data));
+    return {};
   });
-  catalogUnary(protocol, signingKey, "catalog_transaction_commit", {
-    params: CatalogTransactionCommitParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      await cat.transactionCommit(toUint8Array(params.attach_opaque_data), toUint8Array(params.transaction_opaque_data));
-      return {};
-    }
+  const catalogSchemas = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    const schemas = await cat.schemas(toUint8Array(params.attach_opaque_data), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+    return wrapResult({
+      items: schemas.map((s) => encodeSchemaInfo(s))
+    }, CatalogSchemasResultSchema);
   });
-  catalogUnary(protocol, signingKey, "catalog_transaction_rollback", {
-    params: CatalogTransactionRollbackParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      await cat.transactionRollback(toUint8Array(params.attach_opaque_data), toUint8Array(params.transaction_opaque_data));
-      return {};
-    }
+  const catalogContents = catalogHandler(signingKey, async (params) => {
+    const ifNoneMatch = params.if_none_match == null ? null : String(params.if_none_match);
+    return serveCatalogContents(getCatalog(), toUint8Array(params.attach_opaque_data), ifNoneMatch);
   });
-  catalogUnary(protocol, signingKey, "catalog_schemas", {
-    params: CatalogSchemasParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      const schemas = await cat.schemas(toUint8Array(params.attach_opaque_data), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
-      return wrapResult({
-        items: schemas.map((s) => encodeSchemaInfo(s))
-      }, CatalogSchemasResultSchema);
-    }
+  const catalogCopyFromFormats = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    const formats = await cat.copyFromFormats(toUint8Array(params.attach_opaque_data), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
+    return wrapResult({
+      items: formats.map((f) => encodeCopyFromFormatInfo(f))
+    }, CatalogCopyFromFormatsResultSchema);
   });
-  catalogUnary(protocol, signingKey, "catalog_contents", {
-    params: CatalogContentsParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const ifNoneMatch = params.if_none_match == null ? null : String(params.if_none_match);
-      return serveCatalogContents(getCatalog(), toUint8Array(params.attach_opaque_data), ifNoneMatch);
-    }
+  const catalogSchemaGet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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_copy_from_formats", {
-    params: CatalogCopyFromFormatsParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      const formats = await cat.copyFromFormats(toUint8Array(params.attach_opaque_data), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
-      return wrapResult({
-        items: formats.map((f) => encodeCopyFromFormatInfo(f))
-      }, CatalogCopyFromFormatsResultSchema);
-    }
-  });
-  catalogUnary(protocol, signingKey, "catalog_schema_get", {
-    params: CatalogSchemaGetParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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: CatalogSchemaCreateParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      await cat.schemaCreate(toUint8Array(params.attach_opaque_data), params.path, params.comment, null, params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
-      return {};
-    }
+  const catalogSchemaCreate = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogSchemaDropParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogSchemaDrop = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogSchemaContentsTablesParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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);
-    }
+  const catalogSchemaContentsTables = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogSchemaContentsViewsParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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);
-    }
+  const catalogSchemaContentsViews = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogSchemaContentsFunctionsParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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) => encodeFunctionInfoOnce(f))
-      }, CatalogSchemaContentsFunctionsResultSchema);
-    }
+  const catalogSchemaContentsFunctions = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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) => encodeFunctionInfoOnce(f))
+    }, CatalogSchemaContentsFunctionsResultSchema);
   });
+  return {
+    catalogCatalogs,
+    catalogAttach,
+    catalogDetach,
+    catalogCreate,
+    catalogDrop,
+    catalogVersion,
+    catalogTransactionBegin,
+    catalogTransactionCommit,
+    catalogTransactionRollback,
+    catalogSchemas,
+    catalogContents,
+    catalogCopyFromFormats,
+    catalogSchemaGet,
+    catalogSchemaCreate,
+    catalogSchemaDrop,
+    catalogSchemaContentsTables,
+    catalogSchemaContentsViews,
+    catalogSchemaContentsFunctions
+  };
 }
 
 // src/protocol/handlers/catalog/table.ts
-function registerCatalogTableMethods(protocol, getCatalog, signingKey) {
-  catalogUnary(protocol, signingKey, "catalog_table_get", {
-    params: CatalogTableGetParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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);
-    }
+function catalogTableHandlers(getCatalog, signingKey) {
+  const catalogTableGet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableCreateParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableCreate = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableDropParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableDrop = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableColumnStatisticsGetParamsSchema,
-    result: RESULT_BINARY_NULLABLE_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 };
-    }
+  const catalogTableColumnStatisticsGet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableScanFunctionGetParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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);
-    }
+  const catalogTableScanFunctionGet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableScanBranchesGetParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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);
-    }
+  const catalogTableScanBranchesGet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableCommentSetParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableCommentSet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableRenameParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableRename = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableColumnAddParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableColumnAdd = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableColumnDropParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableColumnDrop = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableColumnRenameParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableColumnRename = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableColumnDefaultSetParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableColumnDefaultSet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableColumnDefaultDropParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableColumnDefaultDrop = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableColumnTypeChangeParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableColumnTypeChange = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableNotNullSetParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableNotNullSet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogTableNotNullDropParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogTableNotNullDrop = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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 {};
   });
+  return {
+    catalogTableGet,
+    catalogTableCreate,
+    catalogTableDrop,
+    catalogTableColumnStatisticsGet,
+    catalogTableScanFunctionGet,
+    catalogTableScanBranchesGet,
+    catalogTableCommentSet,
+    catalogTableRename,
+    catalogTableColumnAdd,
+    catalogTableColumnDrop,
+    catalogTableColumnRename,
+    catalogTableColumnDefaultSet,
+    catalogTableColumnDefaultDrop,
+    catalogTableColumnTypeChange,
+    catalogTableNotNullSet,
+    catalogTableNotNullDrop
+  };
 }
 
 // src/protocol/handlers/catalog/view.ts
-function registerCatalogViewMethods(protocol, getCatalog, signingKey) {
-  catalogUnary(protocol, signingKey, "catalog_view_get", {
-    params: CatalogViewGetParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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);
-    }
+function catalogViewHandlers(getCatalog, signingKey) {
+  const catalogViewGet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogViewCreateParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogViewCreate = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogViewDropParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogViewDrop = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogViewRenameParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogViewRename = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogViewCommentSetParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogViewCommentSet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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 {};
   });
+  return { catalogViewGet, catalogViewCreate, catalogViewDrop, catalogViewRename, catalogViewCommentSet };
 }
 
 // src/protocol/handlers/catalog/macro.ts
-function registerCatalogMacroMethods(protocol, getCatalog, signingKey) {
-  catalogUnary(protocol, signingKey, "catalog_macro_get", {
-    params: CatalogMacroGetParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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);
-    }
+function catalogMacroHandlers(getCatalog, signingKey) {
+  const catalogMacroGet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogMacroCreateParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      const innerParams = params;
-      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 {};
-    }
+  const catalogMacroCreate = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    const innerParams = params;
+    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: CatalogMacroDropParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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 {};
-    }
+  const catalogMacroDrop = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogSchemaContentsMacrosParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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);
-    }
+  const catalogSchemaContentsMacros = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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);
   });
+  return { catalogMacroGet, catalogMacroCreate, catalogMacroDrop, catalogSchemaContentsMacros };
 }
 
 // src/protocol/handlers/catalog/index_methods.ts
-function registerCatalogIndexMethods(protocol, getCatalog, signingKey) {
-  catalogUnary(protocol, signingKey, "catalog_schema_contents_indexes", {
-    params: CatalogSchemaContentsIndexesParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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);
-    }
+function catalogIndexHandlers(getCatalog, signingKey) {
+  const catalogSchemaContentsIndexes = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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: CatalogIndexGetParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const cat = getCatalog();
-      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);
-    }
+  const catalogIndexGet = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    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);
   });
+  return { catalogSchemaContentsIndexes, catalogIndexGet };
 }
 
 // src/protocol/handlers/catalog/index.ts
-function registerCatalogMethods(protocol, catalog, _catalogName, signingKey) {
+function catalogHandlers(catalog, signingKey) {
   const getCatalog = makeGetCatalog(catalog);
-  registerCatalogAdminMethods(protocol, getCatalog, signingKey);
-  registerCatalogTableMethods(protocol, getCatalog, signingKey);
-  registerCatalogViewMethods(protocol, getCatalog, signingKey);
-  registerCatalogMacroMethods(protocol, getCatalog, signingKey);
-  registerCatalogIndexMethods(protocol, getCatalog, signingKey);
-}
-
-// src/protocol/handlers/unimplemented.ts
-import { MethodNotImplementedError } from "@query-farm/vgi-rpc";
-var UNIMPLEMENTED_METHODS = [
-  { name: "aggregate_streaming_open", params: REQUEST_PARAMS_SCHEMA, result: RESULT_BINARY_SCHEMA },
-  { name: "aggregate_streaming_chunk", params: REQUEST_PARAMS_SCHEMA, result: RESULT_BINARY_SCHEMA },
-  { name: "aggregate_streaming_close", params: REQUEST_PARAMS_SCHEMA, result: RESULT_BINARY_SCHEMA },
-  { name: "aggregate_window_init", params: REQUEST_PARAMS_SCHEMA, result: RESULT_BINARY_SCHEMA },
-  { name: "aggregate_window", params: REQUEST_PARAMS_SCHEMA, result: RESULT_BINARY_SCHEMA },
-  { name: "aggregate_window_batch", params: REQUEST_PARAMS_SCHEMA, result: RESULT_BINARY_SCHEMA },
-  { name: "aggregate_window_destructor", params: REQUEST_PARAMS_SCHEMA, result: RESULT_BINARY_SCHEMA },
-  { name: "catalog_index_create", params: CatalogIndexCreateParamsSchema, result: emptyResultSchema },
-  { name: "catalog_index_drop", params: CatalogIndexDropParamsSchema, result: emptyResultSchema },
-  { name: "catalog_table_column_comment_set", params: CatalogTableColumnCommentSetParamsSchema, result: emptyResultSchema },
-  { name: "catalog_table_insert_function_get", params: CatalogTableInsertFunctionGetParamsSchema, result: RESULT_BINARY_SCHEMA },
-  { name: "catalog_table_update_function_get", params: CatalogTableUpdateFunctionGetParamsSchema, result: RESULT_BINARY_SCHEMA },
-  { name: "catalog_table_delete_function_get", params: CatalogTableDeleteFunctionGetParamsSchema, result: RESULT_BINARY_SCHEMA }
-];
-function unimplementedMessage(method) {
-  return `${method} is not implemented by this worker`;
-}
-function registerUnimplementedMethods(protocol) {
-  for (const m of UNIMPLEMENTED_METHODS) {
-    protocol.unary(m.name, {
-      params: m.params,
-      result: m.result,
-      handler: async () => {
-        throw new MethodNotImplementedError(unimplementedMessage(m.name));
-      }
-    });
-  }
+  return {
+    ...catalogAdminHandlers(getCatalog, signingKey),
+    ...catalogTableHandlers(getCatalog, signingKey),
+    ...catalogViewHandlers(getCatalog, signingKey),
+    ...catalogMacroHandlers(getCatalog, signingKey),
+    ...catalogIndexHandlers(getCatalog, signingKey)
+  };
 }
 
 // src/protocol/dispatch.ts
-var VGI_PROTOCOL_NAME = "vgi.v2";
+function buildVgiService(config) {
+  return {
+    ...UNIMPLEMENTED_VGI_SERVICE,
+    ...functionHandlers({
+      registry: config.registry,
+      signingKey: config.signingKey,
+      catalogInterface: config.catalogInterface
+    }),
+    ...aggregateHandlers(config.registry),
+    ...tableBufferingHandlers(config.registry, config.signingKey),
+    ...catalogHandlers(config.catalogInterface, config.signingKey)
+  };
+}
 function buildVgiProtocol(config) {
-  const protocol = new Protocol2(VGI_PROTOCOL_NAME, { protocolVersion: "2.1.0" });
-  registerFunctionMethods(protocol, {
-    registry: config.registry,
-    signingKey: config.signingKey,
-    catalogInterface: config.catalogInterface
-  });
-  registerAggregateMethods(protocol, config.registry);
-  registerTableBufferingMethods(protocol, config.registry, config.signingKey);
-  registerCatalogMethods(protocol, config.catalogInterface, config.catalogName, config.signingKey);
-  registerUnimplementedMethods(protocol);
-  return protocol;
+  return createVgiProtocol(buildVgiService(config));
 }
 
 // src/http/landing-html.ts
@@ -9632,7 +10835,7 @@ function validatedHostedProtocols(hosting, primary) {
     }
     const name = p.name;
     if (name.startsWith(RESERVED_PREFIX)) {
-      throw new Error(`${owner} entry ${index} is named '${name}', which claims the reserved '${RESERVED_PREFIX}' prefix. ` + "Framework protocols are not supplied through this hook: reflection is hosted automatically, and " + "vgi_rpc.Identity.v1 is enabled by supplying resolveToken and/or mintGrant.");
+      throw new Error(`${owner} entry ${index} is named '${name}', which claims the reserved '${RESERVED_PREFIX}' prefix. ` + "Framework protocols are not supplied through this hook: reflection is hosted automatically, and " + "vgi_rpc.Identity.v2 is enabled by supplying resolveToken and/or mintGrant.");
     }
     if (!/^[A-Za-z_][A-Za-z0-9_.]*$/.test(name)) {
       throw new Error(`${owner} entry ${index}: protocol name '${name}' is not an identifier, optionally dot-qualified ` + "(e.g. 'acme.Reports.v1').");
@@ -9682,7 +10885,7 @@ function resolveIntrospectPrincipals(explicit, env) {
     principals = raw.split(",").map((p) => p.trim()).filter((p) => p !== "");
   }
   if (principals.length === 0) {
-    throw new Error("This worker supplies resolveToken, which hosts the vgi_rpc.Identity.v1 protocol, but no " + `introspector allowlist was configured. Set ${INTROSPECT_PRINCIPALS_ENV} (comma-separated) or pass ` + `introspectPrincipals.
+    throw new Error("This worker supplies resolveToken, which hosts the vgi_rpc.Identity.v2 protocol, but no " + `introspector allowlist was configured. Set ${INTROSPECT_PRINCIPALS_ENV} (comma-separated) or pass ` + `introspectPrincipals.
 
 ` + "There is no permissive default on purpose: introspection is a separate capability from " + "authentication, and allowing every authenticated caller lets any user resolve any other user's " + "credential to its owner. Remove resolveToken to leave the protocol unhosted entirely.");
   }
@@ -10968,7 +12171,7 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
   }
   attach(name, options, dataVersionSpec, implementationVersion) {
     if (!this.catalogs().includes(name)) {
-      throw new Error(`No worker handles catalog '${name}'`);
+      throw new VgiError(`No worker handles catalog '${name}'`, "NOT_FOUND");
     }
     validateRequiredAttachOptions(name, this.attachOptionSpecs(name), options ?? {});
     const attachOpaqueData = new Uint8Array(16);
@@ -11368,11 +12571,11 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
     validateAtParams(atUnit, atValue);
     const schema = this._descriptor.schemas.find((s) => schemaPathsEqual(schemaDescriptorPath(s), schemaPath));
     if (!schema || !schema.tables) {
-      throw new Error(`Table '${name}' not found in schema ${schemaPathDisplay(schemaPath)}`);
+      throw new VgiError(`Table '${name}' not found in schema ${schemaPathDisplay(schemaPath)}`, "NOT_FOUND");
     }
     const table = schema.tables.find((t) => t.name === name);
     if (!table) {
-      throw new Error(`Table '${name}' not found in schema ${schemaPathDisplay(schemaPath)}`);
+      throw new VgiError(`Table '${name}' not found in schema ${schemaPathDisplay(schemaPath)}`, "NOT_FOUND");
     }
     if (atUnit && !table.supportsTimeTravel) {
       throw new Error(`Table ${schemaPathDisplay(schemaPath)}.${name} does not support time travel queries`);
@@ -11457,12 +12660,12 @@ function resolveIndexGroups(schema, groups) {
 function serializeForeignKeys(fks, schemaPath) {
   if (!fks || fks.length === 0)
     return [];
-  return fks.map((fk) => serializeBatch(batchFromColumns({
+  return fks.map((fk) => serializeBatch(batchFromColumns(conformColumns(ForeignKeyInfoSchema, {
     fk_columns: [fk.columns],
     pk_columns: [fk.referencedColumns],
     referenced_table: [fk.referencedTable],
     referenced_schema_path: [fk.referencedSchemaPath ?? schemaPath ?? ["main"]]
-  }, ForeignKeyInfoSchema)));
+  }), ForeignKeyInfoSchema)));
 }
 function defaultToSql(value) {
   if (value === null || value === undefined)
@@ -11602,7 +12805,7 @@ function serializeArgsBatch(args, argSpecSchema) {
 }
 function validateAtParams(atUnit, atValue) {
   if (Boolean(atUnit) !== Boolean(atValue)) {
-    throw new Error("at_unit and at_value must both be provided or both be absent");
+    throw new VgiError("at_unit and at_value must both be provided or both be absent", "INVALID_ARGUMENT");
   }
 }
 function inferScalarType(val) {
@@ -11700,7 +12903,7 @@ class CompositeCatalogInterface extends CatalogInterface {
         return result;
       }
     }
-    throw new Error(`No worker handles catalog '${name}'`);
+    throw new VgiError(`No worker handles catalog '${name}'`, "NOT_FOUND");
   }
   async detach(attachOpaqueData) {
     await this._route(attachOpaqueData).detach(attachOpaqueData);
@@ -12024,7 +13227,7 @@ class FunctionRegistry {
       } else if (candidates && candidates.length > 0) {
         const schemas = this.schemasFor(name);
         if (schemas.length > 0) {
-          throw new Error(`Function '${name}' is not registered in schema ${schemaPathDisplay(schemaPath)}. ` + `It is available in: [${schemas.map(schemaPathDisplay).join(", ")}]`);
+          throw new VgiError(`Function '${name}' is not registered in schema ${schemaPathDisplay(schemaPath)}. ` + `It is available in: [${schemas.map(schemaPathDisplay).join(", ")}]`, "NOT_FOUND");
         }
       }
     }
@@ -12245,4 +13448,4 @@ export {
   utf82 as utf8
 };
 
-//# debugId=CA8AE11CB8003E9464756E2164756E21
+//# debugId=FC599621AC5B851964756E2164756E21