@query-farm/vgi 0.41.0 → 0.43.0

package/dist/serve-entry.js

@@ -3173,8 +3173,1259 @@ var arrowStateSerializer = {
   }
 };
 
-// src/protocol/dispatch.ts
-import { Protocol as Protocol2 } from "@query-farm/vgi-rpc";
+// src/generated/vgi-service.ts
+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/util/statistics.ts
 function serializeColumnStatistics(stats, _cacheMaxAgeSeconds) {
@@ -4170,9 +5421,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);
@@ -5060,20 +6308,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 () => {
@@ -5094,7 +6338,6 @@ function decodeOptionsBatch(bytes) {
   const row = iterRows(batch).next().value;
   return row ?? {};
 }
-var emptyResultSchema = schema2([]);
 
 // src/request-auth.ts
 var scope;
@@ -5324,7 +6567,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)
@@ -5343,26 +6586,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) => {
@@ -5455,7 +6692,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");
@@ -5463,83 +6699,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/arguments/argument-spec.ts
@@ -5710,7 +6938,7 @@ function persistGroupStates(executionId, gids) {
 }
 
 // src/protocol/handlers/aggregate.ts
-function registerAggregateMethods(protocol, registry) {
+function aggregateHandlers(registry) {
   function resolveAggregate(name, schemaPath) {
     const func = registry.get(name, {
       arguments: new Arguments,
@@ -5723,199 +6951,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 \u2014 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 \u2014 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 = {};
@@ -6006,7 +7215,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,
@@ -6051,55 +7260,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") {
@@ -6415,7 +7613,7 @@ var encodeCopyFromFormatInfo = (v) => encodeASD(CopyFromFormatInfoSchema, {
 
 // src/attach-ticket.ts
 import {
-  Protocol,
+  Protocol as Protocol2,
   badRequest,
   errorInfo,
   preconditionFailure
@@ -6871,7 +8069,7 @@ async function sealAttach2(config, request, auth) {
   return { ticket: token, expires_at: expiresAt === 0 ? Number.POSITIVE_INFINITY : expiresAt };
 }
 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,
@@ -6887,503 +8085,369 @@ function buildAttachTicketsProtocol(config) {
 }
 
 // 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);
-    }
-  });
-  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);
-    }
-  });
-  catalogUnary(protocol, signingKey, "catalog_detach", {
-    params: CatalogDetachParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      await cat.detach(toUint8Array(params.attach_opaque_data));
-      return {};
-    }
+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);
   });
-  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 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_drop", {
-    params: CatalogDropParamsSchema,
-    result: emptyResultSchema,
-    handler: async (params) => {
-      const cat = getCatalog();
-      await cat.drop(params.name);
-      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_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 catalogDrop = catalogHandler(signingKey, async (params) => {
+    const cat = getCatalog();
+    await cat.drop(params.name);
+    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 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_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 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 {};
   });
-  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 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_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 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_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 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_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);
-    }
+  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_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);
-    }
+  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_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);
+  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);
-  return protocol;
+  return createVgiProtocol(buildVgiService(config));
 }
 
 // src/http/landing-html.ts
@@ -7826,4 +8890,4 @@ export {
   serveVgiWorker
 };
 
-//# debugId=9AD0D580690218C964756E2164756E21
+//# debugId=7D0DFE46FB512EAD64756E2164756E21