@query-farm/vgi 0.41.0 → 0.43.0

package/dist/index.js

@@ -11034,8 +11034,1260 @@ function arrowToMetadatas(batch) {
   }
   return results;
 }
-// src/protocol/dispatch.ts
-import { Protocol as Protocol2 } from "@query-farm/vgi-rpc";
+// src/generated/vgi-service.ts
+init_arrow();
+import {
+  MethodNotImplementedError,
+  Protocol
+} from "@query-farm/vgi-rpc";
+var VGI_PROTOCOL_NAME = "vgi.v2";
+var VGI_PROTOCOL_VERSION = "2.1.0";
+function exchangeStream(callbacks) {
+  return { kind: "exchange", ...callbacks };
+}
+function producerStream(callbacks) {
+  return { kind: "producer", ...callbacks };
+}
+var VGI_V2_METHODS = [
+  {
+    name: "aggregate_bind",
+    key: "aggregateBind",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Bind an aggregate function, return output schema and execution_id."
+  },
+  {
+    name: "aggregate_combine",
+    key: "aggregateCombine",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Merge source states into target states."
+  },
+  {
+    name: "aggregate_destructor",
+    key: "aggregateDestructor",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Best-effort cleanup of aggregate states. Must not raise."
+  },
+  {
+    name: "aggregate_finalize",
+    key: "aggregateFinalize",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Produce results for a chunk of group_ids."
+  },
+  {
+    name: "aggregate_streaming_chunk",
+    key: "aggregateStreamingChunk",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Process one input chunk; returns one output row per input row."
+  },
+  {
+    name: "aggregate_streaming_close",
+    key: "aggregateStreamingClose",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "End the streaming session, free per-session state."
+  },
+  {
+    name: "aggregate_streaming_open",
+    key: "aggregateStreamingOpen",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Start a streaming-partitioned aggregate session."
+  },
+  {
+    name: "aggregate_update",
+    key: "aggregateUpdate",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Accumulate rows from a `DataChunk` into per-group state."
+  },
+  {
+    name: "aggregate_window",
+    key: "aggregateWindow",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Compute an aggregate value for one output row of the window."
+  },
+  {
+    name: "aggregate_window_batch",
+    key: "aggregateWindowBatch",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Compute ``count`` window output rows in one batched RPC."
+  },
+  {
+    name: "aggregate_window_destructor",
+    key: "aggregateWindowDestructor",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Evict a cached partition from storage."
+  },
+  {
+    name: "aggregate_window_init",
+    key: "aggregateWindowInit",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Ship a partition to the worker for windowed aggregation."
+  },
+  {
+    name: "bind",
+    key: "bind",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Resolve output schema and validate arguments."
+  },
+  {
+    name: "catalog_attach",
+    key: "catalogAttach",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Attach to a catalog with options."
+  },
+  {
+    name: "catalog_catalogs",
+    key: "catalogCatalogs",
+    type: "unary",
+    params: schema2([]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List available catalog names."
+  },
+  {
+    name: "catalog_contents",
+    key: "catalogContents",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("if_none_match", utf82(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Return every schema and all of its contents in one result."
+  },
+  {
+    name: "catalog_copy_from_formats",
+    key: "catalogCopyFromFormats",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List custom ``COPY ... FROM`` formats advertised by this catalog."
+  },
+  {
+    name: "catalog_create",
+    key: "catalogCreate",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Create a new catalog."
+  },
+  {
+    name: "catalog_detach",
+    key: "catalogDetach",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Detach from a catalog."
+  },
+  {
+    name: "catalog_drop",
+    key: "catalogDrop",
+    type: "unary",
+    params: schema2([
+      field2("name", utf82(), false)
+    ]),
+    result: schema2([]),
+    doc: "Drop a catalog."
+  },
+  {
+    name: "catalog_index_create",
+    key: "catalogIndexCreate",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Create a new index."
+  },
+  {
+    name: "catalog_index_drop",
+    key: "catalogIndexDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("cascade", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Drop an index."
+  },
+  {
+    name: "catalog_index_get",
+    key: "catalogIndexGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get information about an index. Returns 0 or 1 items."
+  },
+  {
+    name: "catalog_macro_create",
+    key: "catalogMacroCreate",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Create a new macro."
+  },
+  {
+    name: "catalog_macro_drop",
+    key: "catalogMacroDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Drop a macro."
+  },
+  {
+    name: "catalog_macro_get",
+    key: "catalogMacroGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get information about a macro. Returns 0 or 1 items."
+  },
+  {
+    name: "catalog_schema_contents_functions",
+    key: "catalogSchemaContentsFunctions",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("type", dictionary2(utf82(), int162()), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List functions in a schema (scalar or table)."
+  },
+  {
+    name: "catalog_schema_contents_indexes",
+    key: "catalogSchemaContentsIndexes",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List indexes in a schema."
+  },
+  {
+    name: "catalog_schema_contents_macros",
+    key: "catalogSchemaContentsMacros",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("type", dictionary2(utf82(), int162()), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List macros in a schema (scalar or table)."
+  },
+  {
+    name: "catalog_schema_contents_tables",
+    key: "catalogSchemaContentsTables",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List tables in a schema."
+  },
+  {
+    name: "catalog_schema_contents_views",
+    key: "catalogSchemaContentsViews",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List views in a schema."
+  },
+  {
+    name: "catalog_schema_create",
+    key: "catalogSchemaCreate",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("on_conflict", dictionary2(utf82(), int162()), false),
+      field2("comment", utf82(), true),
+      field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), true),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Create a new schema."
+  },
+  {
+    name: "catalog_schema_drop",
+    key: "catalogSchemaDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("cascade", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Drop a schema."
+  },
+  {
+    name: "catalog_schema_get",
+    key: "catalogSchemaGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("path", list2(field2("item", utf82(), true)), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get information about a schema. Returns 0 or 1 items."
+  },
+  {
+    name: "catalog_schemas",
+    key: "catalogSchemas",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "List schemas in the catalog."
+  },
+  {
+    name: "catalog_table_column_add",
+    key: "catalogTableColumnAdd",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_definition", binary2(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("if_column_not_exists", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Add a new column to a table."
+  },
+  {
+    name: "catalog_table_column_comment_set",
+    key: "catalogTableColumnCommentSet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_name", utf82(), false),
+      field2("comment", utf82(), true),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Set or clear the comment on a table column."
+  },
+  {
+    name: "catalog_table_column_default_drop",
+    key: "catalogTableColumnDefaultDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Remove the default value from a column."
+  },
+  {
+    name: "catalog_table_column_default_set",
+    key: "catalogTableColumnDefaultSet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_name", utf82(), false),
+      field2("expression", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Set the default value expression for a column."
+  },
+  {
+    name: "catalog_table_column_drop",
+    key: "catalogTableColumnDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("if_column_exists", bool2(), false),
+      field2("cascade", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Drop a column from a table."
+  },
+  {
+    name: "catalog_table_column_rename",
+    key: "catalogTableColumnRename",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_name", utf82(), false),
+      field2("new_column_name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Rename a column."
+  },
+  {
+    name: "catalog_table_column_statistics_get",
+    key: "catalogTableColumnStatisticsGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), true)
+    ]),
+    doc: "Get column statistics for a table."
+  },
+  {
+    name: "catalog_table_column_type_change",
+    key: "catalogTableColumnTypeChange",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_definition", binary2(), false),
+      field2("expression", utf82(), true),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Change the type of a column."
+  },
+  {
+    name: "catalog_table_comment_set",
+    key: "catalogTableCommentSet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("comment", utf82(), true),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Set or clear the comment on a table."
+  },
+  {
+    name: "catalog_table_create",
+    key: "catalogTableCreate",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Create a new table."
+  },
+  {
+    name: "catalog_table_delete_function_get",
+    key: "catalogTableDeleteFunctionGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the delete function for a table. Returns `WriteFunctionResult` as IPC bytes."
+  },
+  {
+    name: "catalog_table_drop",
+    key: "catalogTableDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("cascade", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Drop a table."
+  },
+  {
+    name: "catalog_table_get",
+    key: "catalogTableGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("at_unit", utf82(), true),
+      field2("at_value", utf82(), true),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get information about a table. Returns 0 or 1 items."
+  },
+  {
+    name: "catalog_table_insert_function_get",
+    key: "catalogTableInsertFunctionGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true),
+      field2("writable_branch_function_name", utf82(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the insert function for a table. Returns `WriteFunctionResult` as IPC bytes."
+  },
+  {
+    name: "catalog_table_not_null_drop",
+    key: "catalogTableNotNullDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Remove NOT NULL constraint from a column."
+  },
+  {
+    name: "catalog_table_not_null_set",
+    key: "catalogTableNotNullSet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("column_name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Add NOT NULL constraint to a column."
+  },
+  {
+    name: "catalog_table_rename",
+    key: "catalogTableRename",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("new_name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Rename a table."
+  },
+  {
+    name: "catalog_table_scan_branches_get",
+    key: "catalogTableScanBranchesGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("at_unit", utf82(), true),
+      field2("at_value", utf82(), true),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the list of scan branches for a multi-branch table. Returns `ScanBranchesResult` as IPC bytes."
+  },
+  {
+    name: "catalog_table_scan_function_get",
+    key: "catalogTableScanFunctionGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("at_unit", utf82(), true),
+      field2("at_value", utf82(), true),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the scan function for a table. Returns `ScanFunctionResult` as IPC bytes."
+  },
+  {
+    name: "catalog_table_update_function_get",
+    key: "catalogTableUpdateFunctionGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the update function for a table. Returns `WriteFunctionResult` as IPC bytes."
+  },
+  {
+    name: "catalog_transaction_begin",
+    key: "catalogTransactionBegin",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Begin a new transaction."
+  },
+  {
+    name: "catalog_transaction_commit",
+    key: "catalogTransactionCommit",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("transaction_opaque_data", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Commit a transaction."
+  },
+  {
+    name: "catalog_transaction_rollback",
+    key: "catalogTransactionRollback",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("transaction_opaque_data", binary2(), false)
+    ]),
+    result: schema2([]),
+    doc: "Rollback a transaction."
+  },
+  {
+    name: "catalog_version",
+    key: "catalogVersion",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get the current catalog version."
+  },
+  {
+    name: "catalog_view_comment_set",
+    key: "catalogViewCommentSet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("comment", utf82(), true),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Set or clear the comment on a view."
+  },
+  {
+    name: "catalog_view_create",
+    key: "catalogViewCreate",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("definition", utf82(), false),
+      field2("on_conflict", dictionary2(utf82(), int162()), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Create a new view."
+  },
+  {
+    name: "catalog_view_drop",
+    key: "catalogViewDrop",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("cascade", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Drop a view."
+  },
+  {
+    name: "catalog_view_get",
+    key: "catalogViewGet",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Get information about a view. Returns 0 or 1 items."
+  },
+  {
+    name: "catalog_view_rename",
+    key: "catalogViewRename",
+    type: "unary",
+    params: schema2([
+      field2("attach_opaque_data", binary2(), false),
+      field2("schema_path", list2(field2("item", utf82(), true)), false),
+      field2("name", utf82(), false),
+      field2("new_name", utf82(), false),
+      field2("ignore_not_found", bool2(), false),
+      field2("transaction_opaque_data", binary2(), true)
+    ]),
+    result: schema2([]),
+    doc: "Rename a view."
+  },
+  {
+    name: "init",
+    key: "init",
+    type: "stream",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    header: schema2([
+      field2("execution_id", binary2(), false),
+      field2("opaque_data", binary2(), true),
+      field2("max_workers", int642(), false)
+    ]),
+    doc: "Initialize a function execution and return a processing stream."
+  },
+  {
+    name: "table_buffering_combine",
+    key: "tableBufferingCombine",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Once-per-query end-of-input signal. Returns finalize_state_ids."
+  },
+  {
+    name: "table_buffering_destructor",
+    key: "tableBufferingDestructor",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Best-effort end-of-query cleanup. Must not raise."
+  },
+  {
+    name: "table_buffering_process",
+    key: "tableBufferingProcess",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Sink one input batch; return the worker-chosen state_id."
+  },
+  {
+    name: "table_function_cardinality",
+    key: "tableFunctionCardinality",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Estimate the cardinality of a table function's output."
+  },
+  {
+    name: "table_function_dynamic_to_string",
+    key: "tableFunctionDynamicToString",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Return user-defined diagnostics for EXPLAIN ANALYZE Extra Info."
+  },
+  {
+    name: "table_function_plan",
+    key: "tableFunctionPlan",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), false)
+    ]),
+    doc: "Plan a table-function scan into named, independently redeemable splits."
+  },
+  {
+    name: "table_function_statistics",
+    key: "tableFunctionStatistics",
+    type: "unary",
+    params: schema2([
+      field2("request", binary2(), false)
+    ]),
+    result: schema2([
+      field2("result", binary2(), true)
+    ]),
+    doc: "Return per-column statistics for a table function's output."
+  }
+];
+var UNIMPLEMENTED_VGI_SERVICE = Object.freeze({
+  aggregateBind: async () => {
+    throw notImplemented("aggregate_bind");
+  },
+  aggregateCombine: async () => {
+    throw notImplemented("aggregate_combine");
+  },
+  aggregateDestructor: async () => {
+    throw notImplemented("aggregate_destructor");
+  },
+  aggregateFinalize: async () => {
+    throw notImplemented("aggregate_finalize");
+  },
+  aggregateStreamingChunk: async () => {
+    throw notImplemented("aggregate_streaming_chunk");
+  },
+  aggregateStreamingClose: async () => {
+    throw notImplemented("aggregate_streaming_close");
+  },
+  aggregateStreamingOpen: async () => {
+    throw notImplemented("aggregate_streaming_open");
+  },
+  aggregateUpdate: async () => {
+    throw notImplemented("aggregate_update");
+  },
+  aggregateWindow: async () => {
+    throw notImplemented("aggregate_window");
+  },
+  aggregateWindowBatch: async () => {
+    throw notImplemented("aggregate_window_batch");
+  },
+  aggregateWindowDestructor: async () => {
+    throw notImplemented("aggregate_window_destructor");
+  },
+  aggregateWindowInit: async () => {
+    throw notImplemented("aggregate_window_init");
+  },
+  bind: async () => {
+    throw notImplemented("bind");
+  },
+  catalogAttach: async () => {
+    throw notImplemented("catalog_attach");
+  },
+  catalogCatalogs: async () => {
+    throw notImplemented("catalog_catalogs");
+  },
+  catalogContents: async () => {
+    throw notImplemented("catalog_contents");
+  },
+  catalogCopyFromFormats: async () => {
+    throw notImplemented("catalog_copy_from_formats");
+  },
+  catalogCreate: async () => {
+    throw notImplemented("catalog_create");
+  },
+  catalogDetach: async () => {
+    throw notImplemented("catalog_detach");
+  },
+  catalogDrop: async () => {
+    throw notImplemented("catalog_drop");
+  },
+  catalogIndexCreate: async () => {
+    throw notImplemented("catalog_index_create");
+  },
+  catalogIndexDrop: async () => {
+    throw notImplemented("catalog_index_drop");
+  },
+  catalogIndexGet: async () => {
+    throw notImplemented("catalog_index_get");
+  },
+  catalogMacroCreate: async () => {
+    throw notImplemented("catalog_macro_create");
+  },
+  catalogMacroDrop: async () => {
+    throw notImplemented("catalog_macro_drop");
+  },
+  catalogMacroGet: async () => {
+    throw notImplemented("catalog_macro_get");
+  },
+  catalogSchemaContentsFunctions: async () => {
+    throw notImplemented("catalog_schema_contents_functions");
+  },
+  catalogSchemaContentsIndexes: async () => {
+    throw notImplemented("catalog_schema_contents_indexes");
+  },
+  catalogSchemaContentsMacros: async () => {
+    throw notImplemented("catalog_schema_contents_macros");
+  },
+  catalogSchemaContentsTables: async () => {
+    throw notImplemented("catalog_schema_contents_tables");
+  },
+  catalogSchemaContentsViews: async () => {
+    throw notImplemented("catalog_schema_contents_views");
+  },
+  catalogSchemaCreate: async () => {
+    throw notImplemented("catalog_schema_create");
+  },
+  catalogSchemaDrop: async () => {
+    throw notImplemented("catalog_schema_drop");
+  },
+  catalogSchemaGet: async () => {
+    throw notImplemented("catalog_schema_get");
+  },
+  catalogSchemas: async () => {
+    throw notImplemented("catalog_schemas");
+  },
+  catalogTableColumnAdd: async () => {
+    throw notImplemented("catalog_table_column_add");
+  },
+  catalogTableColumnCommentSet: async () => {
+    throw notImplemented("catalog_table_column_comment_set");
+  },
+  catalogTableColumnDefaultDrop: async () => {
+    throw notImplemented("catalog_table_column_default_drop");
+  },
+  catalogTableColumnDefaultSet: async () => {
+    throw notImplemented("catalog_table_column_default_set");
+  },
+  catalogTableColumnDrop: async () => {
+    throw notImplemented("catalog_table_column_drop");
+  },
+  catalogTableColumnRename: async () => {
+    throw notImplemented("catalog_table_column_rename");
+  },
+  catalogTableColumnStatisticsGet: async () => {
+    throw notImplemented("catalog_table_column_statistics_get");
+  },
+  catalogTableColumnTypeChange: async () => {
+    throw notImplemented("catalog_table_column_type_change");
+  },
+  catalogTableCommentSet: async () => {
+    throw notImplemented("catalog_table_comment_set");
+  },
+  catalogTableCreate: async () => {
+    throw notImplemented("catalog_table_create");
+  },
+  catalogTableDeleteFunctionGet: async () => {
+    throw notImplemented("catalog_table_delete_function_get");
+  },
+  catalogTableDrop: async () => {
+    throw notImplemented("catalog_table_drop");
+  },
+  catalogTableGet: async () => {
+    throw notImplemented("catalog_table_get");
+  },
+  catalogTableInsertFunctionGet: async () => {
+    throw notImplemented("catalog_table_insert_function_get");
+  },
+  catalogTableNotNullDrop: async () => {
+    throw notImplemented("catalog_table_not_null_drop");
+  },
+  catalogTableNotNullSet: async () => {
+    throw notImplemented("catalog_table_not_null_set");
+  },
+  catalogTableRename: async () => {
+    throw notImplemented("catalog_table_rename");
+  },
+  catalogTableScanBranchesGet: async () => {
+    throw notImplemented("catalog_table_scan_branches_get");
+  },
+  catalogTableScanFunctionGet: async () => {
+    throw notImplemented("catalog_table_scan_function_get");
+  },
+  catalogTableUpdateFunctionGet: async () => {
+    throw notImplemented("catalog_table_update_function_get");
+  },
+  catalogTransactionBegin: async () => {
+    throw notImplemented("catalog_transaction_begin");
+  },
+  catalogTransactionCommit: async () => {
+    throw notImplemented("catalog_transaction_commit");
+  },
+  catalogTransactionRollback: async () => {
+    throw notImplemented("catalog_transaction_rollback");
+  },
+  catalogVersion: async () => {
+    throw notImplemented("catalog_version");
+  },
+  catalogViewCommentSet: async () => {
+    throw notImplemented("catalog_view_comment_set");
+  },
+  catalogViewCreate: async () => {
+    throw notImplemented("catalog_view_create");
+  },
+  catalogViewDrop: async () => {
+    throw notImplemented("catalog_view_drop");
+  },
+  catalogViewGet: async () => {
+    throw notImplemented("catalog_view_get");
+  },
+  catalogViewRename: async () => {
+    throw notImplemented("catalog_view_rename");
+  },
+  init: unimplementedStream("init"),
+  tableBufferingCombine: async () => {
+    throw notImplemented("table_buffering_combine");
+  },
+  tableBufferingDestructor: async () => {
+    throw notImplemented("table_buffering_destructor");
+  },
+  tableBufferingProcess: async () => {
+    throw notImplemented("table_buffering_process");
+  },
+  tableFunctionCardinality: async () => {
+    throw notImplemented("table_function_cardinality");
+  },
+  tableFunctionDynamicToString: async () => {
+    throw notImplemented("table_function_dynamic_to_string");
+  },
+  tableFunctionPlan: async () => {
+    throw notImplemented("table_function_plan");
+  },
+  tableFunctionStatistics: async () => {
+    throw notImplemented("table_function_statistics");
+  }
+});
+function unimplementedMessage(method) {
+  return `${method} is not implemented by this worker`;
+}
+function notImplemented(method) {
+  return new MethodNotImplementedError(unimplementedMessage(method));
+}
+function unimplementedStream(method) {
+  return producerStream({
+    outputSchema: schema2([]),
+    init: () => {
+      throw notImplemented(method);
+    },
+    produce: () => {}
+  });
+}
+function registerVgiService(protocol, service) {
+  for (const m of VGI_V2_METHODS) {
+    if (m.type === "unary") {
+      const handler = service[m.key];
+      protocol.unary(m.name, {
+        params: m.params,
+        result: m.result,
+        doc: m.doc,
+        handler: (params, ctx) => handler.call(service, params, ctx)
+      });
+      continue;
+    }
+    const stream = service[m.key];
+    const common = {
+      params: m.params,
+      outputSchema: stream.outputSchema,
+      headerSchema: m.header ?? undefined,
+      headerInit: stream.headerInit,
+      onCancel: stream.onCancel,
+      doc: m.doc
+    };
+    if (stream.kind === "exchange") {
+      protocol.exchange(m.name, {
+        ...common,
+        inputSchema: stream.inputSchema,
+        init: stream.init,
+        exchange: stream.exchange
+      });
+    } else {
+      protocol.producer(m.name, { ...common, init: stream.init, produce: stream.produce });
+    }
+  }
+  return protocol;
+}
+function createVgiProtocol(service) {
+  return registerVgiService(new Protocol(VGI_PROTOCOL_NAME, { protocolVersion: VGI_PROTOCOL_VERSION }), service);
+}
 
 // src/protocol/handlers/function.ts
 init_arrow();
@@ -11048,9 +12300,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);
@@ -11131,20 +12380,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 () => {
@@ -11165,7 +12410,6 @@ function decodeOptionsBatch(bytes) {
   const row = iterRows(batch).next().value;
   return row ?? {};
 }
-var emptyResultSchema = schema2([]);
 
 // src/request-auth.ts
 var scope;
@@ -11392,7 +12636,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)
@@ -11411,26 +12655,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) => {
@@ -11523,7 +12761,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");
@@ -11531,88 +12768,80 @@ function registerFunctionMethods(protocol, config) {
       return serializeGlobalInitResponse(state._initResponse);
     }
   });
-  protocol.unary("table_function_cardinality", {
-    params: TableFunctionCardinalityParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const request = deserializeCardinalityRequest(innerParams);
-      const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
-      let cardResult;
-      if (func.cardinality) {
-        cardResult = serializeTableCardinality(await func.cardinality(request));
-      } else {
-        cardResult = { estimate: null, max: null };
-      }
-      return wrapResult(cardResult, TableFunctionCardinalityResultSchema);
-    }
-  });
-  protocol.unary("table_function_plan", {
-    params: TableFunctionPlanParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params, ctx) => {
-      const innerParams = unwrapRequest(params.request);
-      const request = deserializePlanRequest(innerParams);
-      const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
-      const plan = func.plan ? await func.plan(request) : { splits: [{ payload: new Uint8Array(0) }] };
-      const fp = fingerprintInputs(toUint8Array(innerParams.bind_call));
-      const fingerprint = await bindFingerprint(fp.schemaPath, fp.functionName, fp.args, fp.settings, new Uint8Array(0));
-      const anchor = plan.catalogVersion != null ? splitAnchor(plan.catalogVersion) : await liveSplitAnchor(catalogInterface, request.bind_call, ctx?.auth, signingKey) ?? splitAnchor(0);
-      const blobs = [];
-      for (const split of plan.splits) {
-        const token = await buildSplitToken({
-          payload: split.payload,
-          fingerprint,
-          anchor,
-          signingKey,
-          auth: ctx?.auth
-        });
-        blobs.push(serializeBatch(batchFromColumns(Object.fromEntries(SCAN_SPLIT_SCHEMA.fields.map((f) => [
-          f.name,
-          [scanSplitRow(split, token)[f.name] ?? null]
-        ])), SCAN_SPLIT_SCHEMA)));
-      }
-      return wrapResult(planResponseRow(plan, blobs), PLAN_RESPONSE_SCHEMA);
-    }
-  });
-  protocol.unary("table_function_statistics", {
-    params: TableFunctionStatisticsParamsSchema,
-    result: RESULT_BINARY_NULLABLE_SCHEMA,
-    handler: async (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const request = deserializeCardinalityRequest(innerParams);
-      const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
-      if (!func.statistics)
-        return { result: null };
-      const stats = func.statistics(request);
-      if (!stats || stats.length === 0)
-        return { result: null };
-      return { result: serializeColumnStatistics(stats) };
+  const tableFunctionCardinality = async (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const request = deserializeCardinalityRequest(innerParams);
+    const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
+    let cardResult;
+    if (func.cardinality) {
+      cardResult = serializeTableCardinality(await func.cardinality(request));
+    } else {
+      cardResult = { estimate: null, max: null };
     }
-  });
-  protocol.unary("table_function_dynamic_to_string", {
-    params: TableFunctionDynamicToStringParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const bindCallBytes = toUint8Array(innerParams.bind_call);
-      const bindCallBatch = deserializeBatch(bindCallBytes);
-      const bindParams = batchToScalarDict(bindCallBatch);
-      const bindCall = deserializeBindRequest(bindParams);
-      const globalExecutionId = toUint8Array(innerParams.global_execution_id);
-      const bindOpaqueData = innerParams.bind_opaque_data ? toUint8Array(innerParams.bind_opaque_data) : null;
-      const func = registry.get(bindCall.function_name, await strippedContext(bindCall));
-      const map = func.dynamicToString ? await func.dynamicToString({ bindCall, bindOpaqueData, globalExecutionId }) : {};
-      const keys = Object.keys(map);
-      const values = keys.map((k) => map[k] ?? "");
-      return wrapResult({ keys, values }, TableFunctionDynamicToStringResultSchema);
+    return wrapResult(cardResult, TableFunctionCardinalityResultSchema);
+  };
+  const tableFunctionPlan = async (params, ctx) => {
+    const innerParams = unwrapRequest(params.request);
+    const request = deserializePlanRequest(innerParams);
+    const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
+    const plan = func.plan ? await func.plan(request) : { splits: [{ payload: new Uint8Array(0) }] };
+    const fp = fingerprintInputs(toUint8Array(innerParams.bind_call));
+    const fingerprint = await bindFingerprint(fp.schemaPath, fp.functionName, fp.args, fp.settings, new Uint8Array(0));
+    const anchor = plan.catalogVersion != null ? splitAnchor(plan.catalogVersion) : await liveSplitAnchor(catalogInterface, request.bind_call, ctx?.auth, signingKey) ?? splitAnchor(0);
+    const blobs = [];
+    for (const split of plan.splits) {
+      const token = await buildSplitToken({
+        payload: split.payload,
+        fingerprint,
+        anchor,
+        signingKey,
+        auth: ctx?.auth
+      });
+      blobs.push(serializeBatch(batchFromColumns(Object.fromEntries(SCAN_SPLIT_SCHEMA.fields.map((f) => [
+        f.name,
+        [scanSplitRow(split, token)[f.name] ?? null]
+      ])), SCAN_SPLIT_SCHEMA)));
     }
-  });
+    return wrapResult(planResponseRow(plan, blobs), PLAN_RESPONSE_SCHEMA);
+  };
+  const tableFunctionStatistics = async (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const request = deserializeCardinalityRequest(innerParams);
+    const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
+    if (!func.statistics)
+      return { result: null };
+    const stats = func.statistics(request);
+    if (!stats || stats.length === 0)
+      return { result: null };
+    return { result: serializeColumnStatistics(stats) };
+  };
+  const tableFunctionDynamicToString = async (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const bindCallBytes = toUint8Array(innerParams.bind_call);
+    const bindCallBatch = deserializeBatch(bindCallBytes);
+    const bindParams = batchToScalarDict(bindCallBatch);
+    const bindCall = deserializeBindRequest(bindParams);
+    const globalExecutionId = toUint8Array(innerParams.global_execution_id);
+    const bindOpaqueData = innerParams.bind_opaque_data ? toUint8Array(innerParams.bind_opaque_data) : null;
+    const func = registry.get(bindCall.function_name, await strippedContext(bindCall));
+    const map = func.dynamicToString ? await func.dynamicToString({ bindCall, bindOpaqueData, globalExecutionId }) : {};
+    const keys = Object.keys(map);
+    const values = keys.map((k) => map[k] ?? "");
+    return wrapResult({ keys, values }, TableFunctionDynamicToStringResultSchema);
+  };
+  return {
+    bind,
+    init,
+    tableFunctionCardinality,
+    tableFunctionPlan,
+    tableFunctionStatistics,
+    tableFunctionDynamicToString
+  };
 }
 
 // src/protocol/handlers/aggregate.ts
 init_arrow();
-function registerAggregateMethods(protocol, registry) {
+function aggregateHandlers(registry) {
   function resolveAggregate(name, schemaPath) {
     const func = registry.get(name, {
       arguments: new Arguments,
@@ -11625,199 +12854,180 @@ function registerAggregateMethods(protocol, registry) {
     }
     return func.aggregateConfig;
   }
-  protocol.unary("aggregate_bind", {
-    params: AggregateBindParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: async (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const functionName = innerParams.function_name;
-      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
-      const argBytes = toUint8Array(innerParams.arguments);
-      const args = deserializeArguments(argBytes);
-      const inputSchema = innerParams.input_schema ? deserializeSchema(toUint8Array(innerParams.input_schema)) : null;
-      const secretsBytes = innerParams.secrets ? toUint8Array(innerParams.secrets) : null;
-      const secretsBatch = secretsBytes && secretsBytes.length > 0 ? deserializeBatch(secretsBytes) : null;
-      const secrets = secretsBatch ? batchToSecretDict(secretsBatch) : {};
-      const bindParams = {
-        args: extractArgMap(cfg, args),
-        arguments: args,
-        inputSchema,
-        settings: {},
-        secrets,
-        argumentNames: innerParams.argument_names ? (Array.isArray(innerParams.argument_names) ? innerParams.argument_names : [...innerParams.argument_names]).map((value) => value == null ? null : String(value)) : null
-      };
-      const executionId = new Uint8Array(16);
-      crypto.getRandomValues(executionId);
-      setExecutionState(executionId, {
-        states: new Map,
-        bindArgs: args,
-        bindParams
-      });
-      const outType = cfg.onBind ? await cfg.onBind(bindParams) : cfg.outputType;
-      const outSchema = schema2([field2("result", outType, true)]);
-      return wrapResult({ output_schema: serializeSchema(outSchema), execution_id: executionId }, AggregateBindResultSchema);
-    }
-  });
-  protocol.unary("aggregate_update", {
-    params: AggregateUpdateParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const functionName = innerParams.function_name;
-      const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
-      const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
-      if (!batch || batch.numRows === 0)
-        return wrapResult({}, schema2([]));
-      const gidIdx = batch.schema.fields.findIndex((f) => f.name === GROUP_COLUMN_NAME);
-      if (gidIdx < 0) {
-        throw new Error(`aggregate_update: input batch missing ${GROUP_COLUMN_NAME} column`);
-      }
-      const gidCol = batch.getChildAt(gidIdx);
-      const groupIds = [];
-      const uniqueGids = new Set;
-      for (let i = 0;i < batch.numRows; i++) {
-        const v = gidCol.get(i);
-        const g = typeof v === "bigint" ? v : BigInt(v);
-        groupIds.push(g);
-        uniqueGids.add(g);
-      }
-      const exec = getExecutionState(executionId, uniqueGids);
-      if (!exec) {
-        throw new Error(`aggregate_update: unknown execution_id for '${functionName}' (bind missing or state dropped)`);
-      }
-      const columns = [];
-      for (let i = 0;i < batch.schema.fields.length; i++) {
-        if (i === gidIdx)
-          continue;
-        columns.push(batch.getChildAt(i));
-      }
-      const ensureState = (gid) => {
-        let s = exec.states.get(gid);
-        if (s === undefined) {
-          s = cfg.initialState(exec.bindParams);
-          exec.states.set(gid, s);
-        }
-        return s;
-      };
-      cfg.update({
-        states: exec.states,
-        groupIds,
-        columns,
-        args: exec.bindParams.args,
-        ensureState
-      });
-      persistGroupStates(executionId, uniqueGids);
+  const aggregateBind = async (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName = innerParams.function_name;
+    const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
+    const argBytes = toUint8Array(innerParams.arguments);
+    const args = deserializeArguments(argBytes);
+    const inputSchema = innerParams.input_schema ? deserializeSchema(toUint8Array(innerParams.input_schema)) : null;
+    const secretsBytes = innerParams.secrets ? toUint8Array(innerParams.secrets) : null;
+    const secretsBatch = secretsBytes && secretsBytes.length > 0 ? deserializeBatch(secretsBytes) : null;
+    const secrets = secretsBatch ? batchToSecretDict(secretsBatch) : {};
+    const bindParams = {
+      args: extractArgMap(cfg, args),
+      arguments: args,
+      inputSchema,
+      settings: {},
+      secrets,
+      argumentNames: innerParams.argument_names ? (Array.isArray(innerParams.argument_names) ? innerParams.argument_names : [...innerParams.argument_names]).map((value) => value == null ? null : String(value)) : null
+    };
+    const executionId = new Uint8Array(16);
+    crypto.getRandomValues(executionId);
+    setExecutionState(executionId, {
+      states: new Map,
+      bindArgs: args,
+      bindParams
+    });
+    const outType = cfg.onBind ? await cfg.onBind(bindParams) : cfg.outputType;
+    const outSchema = schema2([field2("result", outType, true)]);
+    return wrapResult({ output_schema: serializeSchema(outSchema), execution_id: executionId }, AggregateBindResultSchema);
+  };
+  const aggregateUpdate = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName = innerParams.function_name;
+    const executionId = toUint8Array(innerParams.execution_id);
+    const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
+    const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
+    if (!batch || batch.numRows === 0)
       return wrapResult({}, schema2([]));
+    const gidIdx = batch.schema.fields.findIndex((f) => f.name === GROUP_COLUMN_NAME);
+    if (gidIdx < 0) {
+      throw new Error(`aggregate_update: input batch missing ${GROUP_COLUMN_NAME} column`);
+    }
+    const gidCol = batch.getChildAt(gidIdx);
+    const groupIds = [];
+    const uniqueGids = new Set;
+    for (let i = 0;i < batch.numRows; i++) {
+      const v = gidCol.get(i);
+      const g = typeof v === "bigint" ? v : BigInt(v);
+      groupIds.push(g);
+      uniqueGids.add(g);
+    }
+    const exec = getExecutionState(executionId, uniqueGids);
+    if (!exec) {
+      throw new Error(`aggregate_update: unknown execution_id for '${functionName}' (bind missing or state dropped)`);
+    }
+    const columns = [];
+    for (let i = 0;i < batch.schema.fields.length; i++) {
+      if (i === gidIdx)
+        continue;
+      columns.push(batch.getChildAt(i));
     }
-  });
-  protocol.unary("aggregate_combine", {
-    params: AggregateCombineParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const functionName = innerParams.function_name;
-      const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
-      const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
-      if (!batch || batch.numRows === 0)
-        return wrapResult({}, schema2([]));
-      const srcCol = batch.getChild("source_group_id");
-      const tgtCol = batch.getChild("target_group_id");
-      const referencedGids = new Set;
-      const srcIds = [];
-      const tgtIds = [];
-      for (let i = 0;i < batch.numRows; i++) {
-        const src = BigInt(srcCol.get(i));
-        const tgt = BigInt(tgtCol.get(i));
-        srcIds.push(src);
-        tgtIds.push(tgt);
-        referencedGids.add(src);
-        referencedGids.add(tgt);
-      }
-      const exec = getExecutionState(executionId, referencedGids);
-      if (!exec) {
-        throw new Error(`aggregate_combine: unknown execution_id for '${functionName}' ` + `(context missing on disk — bind may have failed or been cleaned up)`);
-      }
-      const touchedTargets = new Set;
-      for (let i = 0;i < batch.numRows; i++) {
-        const src = srcIds[i];
-        const tgt = tgtIds[i];
-        const srcHas = exec.states.has(src);
-        const tgtHas = exec.states.has(tgt);
-        if (!srcHas && !tgtHas)
-          continue;
-        const srcState = srcHas ? exec.states.get(src) : cfg.initialState(exec.bindParams);
-        const tgtState = tgtHas ? exec.states.get(tgt) : cfg.initialState(exec.bindParams);
-        exec.states.set(tgt, cfg.combine(srcState, tgtState, exec.bindParams));
-        touchedTargets.add(tgt);
+    const ensureState = (gid) => {
+      let s = exec.states.get(gid);
+      if (s === undefined) {
+        s = cfg.initialState(exec.bindParams);
+        exec.states.set(gid, s);
       }
-      persistGroupStates(executionId, touchedTargets);
+      return s;
+    };
+    cfg.update({
+      states: exec.states,
+      groupIds,
+      columns,
+      args: exec.bindParams.args,
+      ensureState
+    });
+    persistGroupStates(executionId, uniqueGids);
+    return wrapResult({}, schema2([]));
+  };
+  const aggregateCombine = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName = innerParams.function_name;
+    const executionId = toUint8Array(innerParams.execution_id);
+    const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
+    const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
+    if (!batch || batch.numRows === 0)
       return wrapResult({}, schema2([]));
+    const srcCol = batch.getChild("source_group_id");
+    const tgtCol = batch.getChild("target_group_id");
+    const referencedGids = new Set;
+    const srcIds = [];
+    const tgtIds = [];
+    for (let i = 0;i < batch.numRows; i++) {
+      const src = BigInt(srcCol.get(i));
+      const tgt = BigInt(tgtCol.get(i));
+      srcIds.push(src);
+      tgtIds.push(tgt);
+      referencedGids.add(src);
+      referencedGids.add(tgt);
+    }
+    const exec = getExecutionState(executionId, referencedGids);
+    if (!exec) {
+      throw new Error(`aggregate_combine: unknown execution_id for '${functionName}' ` + `(context missing on disk — bind may have failed or been cleaned up)`);
+    }
+    const touchedTargets = new Set;
+    for (let i = 0;i < batch.numRows; i++) {
+      const src = srcIds[i];
+      const tgt = tgtIds[i];
+      const srcHas = exec.states.has(src);
+      const tgtHas = exec.states.has(tgt);
+      if (!srcHas && !tgtHas)
+        continue;
+      const srcState = srcHas ? exec.states.get(src) : cfg.initialState(exec.bindParams);
+      const tgtState = tgtHas ? exec.states.get(tgt) : cfg.initialState(exec.bindParams);
+      exec.states.set(tgt, cfg.combine(srcState, tgtState, exec.bindParams));
+      touchedTargets.add(tgt);
     }
-  });
-  protocol.unary("aggregate_finalize", {
-    params: AggregateFinalizeParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const functionName = innerParams.function_name;
-      const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
-      const outputSchema = deserializeSchema(toUint8Array(innerParams.output_schema));
-      const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
-      const groupIds = [];
-      const uniqueGids = new Set;
-      if (gidBatch) {
-        const col = gidBatch.getChild("group_id");
-        for (let i = 0;i < gidBatch.numRows; i++) {
-          const v = col.get(i);
-          const g = typeof v === "bigint" ? v : BigInt(v);
-          groupIds.push(g);
-          uniqueGids.add(g);
-        }
-      }
-      const exec = getExecutionState(executionId, uniqueGids);
-      if (!exec) {
-        throw new Error(`aggregate_finalize: unknown execution_id for '${functionName}'`);
-      }
-      const states = new Map;
-      for (const gid of groupIds) {
-        states.set(gid, exec.states.has(gid) ? exec.states.get(gid) : null);
-      }
-      const resultBatch = cfg.finalize({
-        groupIds,
-        states,
-        outputSchema,
-        args: exec.bindParams.args
-      });
-      return wrapResult({ result_batch: serializeBatchWithSchema(resultBatch) }, AggregateFinalizeResultSchema);
-    }
-  });
-  protocol.unary("aggregate_destructor", {
-    params: AggregateDestructorParamsSchema,
-    result: RESULT_BINARY_SCHEMA,
-    handler: (params) => {
-      const innerParams = unwrapRequest(params.request);
-      const executionId = toUint8Array(innerParams.execution_id);
-      const exec = getExecutionState(executionId);
-      if (!exec)
-        return wrapResult({}, schema2([]));
-      const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
-      if (!gidBatch || gidBatch.numRows === 0)
-        return wrapResult({}, schema2([]));
+    persistGroupStates(executionId, touchedTargets);
+    return wrapResult({}, schema2([]));
+  };
+  const aggregateFinalize = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const functionName = innerParams.function_name;
+    const executionId = toUint8Array(innerParams.execution_id);
+    const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
+    const outputSchema = deserializeSchema(toUint8Array(innerParams.output_schema));
+    const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
+    const groupIds = [];
+    const uniqueGids = new Set;
+    if (gidBatch) {
       const col = gidBatch.getChild("group_id");
-      const toDrop = new Set;
       for (let i = 0;i < gidBatch.numRows; i++) {
         const v = col.get(i);
         const g = typeof v === "bigint" ? v : BigInt(v);
-        exec.states.delete(g);
-        toDrop.add(g);
+        groupIds.push(g);
+        uniqueGids.add(g);
       }
-      persistGroupStates(executionId, toDrop);
-      return wrapResult({}, schema2([]));
     }
-  });
+    const exec = getExecutionState(executionId, uniqueGids);
+    if (!exec) {
+      throw new Error(`aggregate_finalize: unknown execution_id for '${functionName}'`);
+    }
+    const states = new Map;
+    for (const gid of groupIds) {
+      states.set(gid, exec.states.has(gid) ? exec.states.get(gid) : null);
+    }
+    const resultBatch = cfg.finalize({
+      groupIds,
+      states,
+      outputSchema,
+      args: exec.bindParams.args
+    });
+    return wrapResult({ result_batch: serializeBatchWithSchema(resultBatch) }, AggregateFinalizeResultSchema);
+  };
+  const aggregateDestructor = (params) => {
+    const innerParams = unwrapRequest(params.request);
+    const executionId = toUint8Array(innerParams.execution_id);
+    const exec = getExecutionState(executionId);
+    if (!exec)
+      return wrapResult({}, schema2([]));
+    const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
+    if (!gidBatch || gidBatch.numRows === 0)
+      return wrapResult({}, schema2([]));
+    const col = gidBatch.getChild("group_id");
+    const toDrop = new Set;
+    for (let i = 0;i < gidBatch.numRows; i++) {
+      const v = col.get(i);
+      const g = typeof v === "bigint" ? v : BigInt(v);
+      exec.states.delete(g);
+      toDrop.add(g);
+    }
+    persistGroupStates(executionId, toDrop);
+    return wrapResult({}, schema2([]));
+  };
+  return { aggregateBind, aggregateUpdate, aggregateCombine, aggregateFinalize, aggregateDestructor };
 }
 function extractArgMap(cfg, args) {
   const out = {};
@@ -11876,7 +13086,7 @@ function serializeBatchWithSchema(batch) {
 // src/protocol/handlers/table-buffering.ts
 init_arrow();
 init_storage();
-function registerTableBufferingMethods(protocol, registry, signingKey) {
+function tableBufferingHandlers(registry, signingKey) {
   function resolveBuffering(name, schemaPath) {
     const func = registry.get(name, {
       arguments: new Arguments,
@@ -11921,55 +13131,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);
-    }
-  });
-  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 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_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);
+    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 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") {
@@ -12124,7 +13323,7 @@ async function serveCatalogContents(cat, attach, ifNoneMatch) {
 // src/attach-ticket.ts
 init_arrow();
 import {
-  Protocol,
+  Protocol as Protocol2,
   badRequest,
   errorInfo,
   preconditionFailure
@@ -12498,7 +13697,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,
@@ -12514,503 +13713,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
 var LANDING_HTML_B64 = "<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>VGI Worker</title>
<meta name="vgi-landing-version" content="2">
<link rel="icon" href="data:image/png;base64,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">
<style>
  :root {
    --bg: #f7f5ee; --panel: #ffffff; --ink: #2c2c1e; --muted: #6b6b5a;
    --line: #e6e2d5; --line-strong: #d8d3c2;
    --accent: #8b0000; --accent-soft: #f0e7e0; --chip: #f2efe4;
    --accent-2: #a52121; --on-accent: #fdf6ef; --ai: #256b3c; --ai-soft: #d6e7db; --on-ai: #f2faf4;
    --cup-soft: #e6f1ea; --cup: #2f8f4e; --cup-2: #27713f; --on-cup: #f2faf4;
    --code-bg: #1f1e18; --code-ink: #f3efe2; --ok: #3f9142; --hit: #fff4c2;
    --k-table:#0e7c86; --k-view:#7a4fd0; --k-scalar:#2f8f4e; --k-tablefn:#9a6500; --k-agg:#c05a2a; --k-tio:#b03a6e; --k-macro:#2b6cb0; --type-color:#0e7c86;
    --tint:6%; --tint-hover:11%; --tint-open:15%; --edge:24%; --edge-hover:46%; --edge-open:56%;
    --radius: 14px; --row-radius: 9px;
    --mono: ui-monospace, "SF Mono", Menlo, monospace;
    --sans: "Inter", system-ui, -apple-system, sans-serif;
  }
  @media (prefers-color-scheme: dark) {
    :root {
      --bg: #16150f; --panel: #201f17; --ink: #ece7d6; --muted: #9a9482;
      --line: #322f24; --line-strong: #423e2e;
      --accent: #e2857f; --accent-soft: #2c211f; --chip: #2a2820;
      --accent-2: #ee9a94; --on-accent: #1a120f; --ai: #5cba74; --ai-soft: #16231a; --on-ai: #0f1a10;
      --cup-soft: #1b271e; --cup: #6fce87; --cup-2: #82d897; --on-cup: #10200f;
      --code-bg: #100f0a; --code-ink: #ece7d6; --hit: #4a4222;
      --k-table:#4fc7d0; --k-view:#b39ae8; --k-scalar:#6fce87; --k-tablefn:#e0b055; --k-agg:#e69264; --k-tio:#e084ad; --k-macro:#7fb3e8; --type-color:#5bbfc7;
      --tint:12%; --tint-hover:20%; --tint-open:26%; --edge:32%; --edge-hover:56%; --edge-open:68%;
    }
  }
  * { box-sizing: border-box; }
  html, body { margin: 0; }
  body { background: var(--bg); color: var(--ink); font-family: var(--sans); line-height: 1.5; -webkit-font-smoothing: antialiased; padding: 0 20px 80px; }
  a { color: inherit; }
  :focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; border-radius: 4px; }
  .ic { width: 16px; height: 16px; flex: none; }

  .skip { position: absolute; left: -999px; top: 8px; background: var(--panel); border: 1px solid var(--line-strong); border-radius: 8px; padding: 6px 12px; z-index: 100; }
  .skip:focus { left: 12px; }

  #vgi-user-info { display: flex; align-items: center; gap: 9px; width: fit-content; max-width: 100%; margin: 14px 0 0 auto; background: var(--panel); border: 1px solid var(--line-strong); border-radius: 22px; padding: 5px 14px 5px 6px; box-shadow: 0 2px 10px rgba(0,0,0,0.07); font-size: 13.5px; }
  #vgi-user-info:empty { display: none; }
  #vgi-user-info .avatar { width: 26px; height: 26px; border-radius: 50%; flex: none; background: linear-gradient(135deg, #b7523f, #6b1d15); color: #fff; font-weight: 600; font-size: 11px; display: flex; align-items: center; justify-content: center; }
  #vgi-user-info .email { font-weight: 550; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
  #vgi-user-info a.act { color: var(--muted); text-decoration: none; margin-left: 3px; flex: none; }
  #vgi-user-info a.act:hover { color: var(--accent); }
  #vgi-user-info.signin .avatar { background: var(--chip); color: var(--muted); }

  .wrap { max-width: 820px; margin: 0 auto; }
  header.hero { text-align: center; padding: 26px 0 20px; }
  .logo { width: 150px; height: auto; display: block; margin: 2px auto 16px; }
  .logo-link { display: inline-block; line-height: 0; }
  .logo-link:hover { opacity: .9; }
  h1 { font-size: 30px; margin: 0 0 6px; letter-spacing: -0.02em; }
  .hero .doc { color: var(--muted); font-size: 15.5px; margin: 0 0 12px; }
  .hero .meta { color: var(--muted); font-size: 12.5px; font-family: var(--mono); }
  .hero .meta code { background: var(--chip); padding: 1px 6px; border-radius: 5px; }

  .label { font-size: 12.5px; letter-spacing: 0; text-transform: none; color: var(--muted); font-weight: 650; margin: 0 0 9px; }
  .panel { background: var(--panel); border: 1px solid var(--line); border-radius: var(--radius); padding: 18px; }

  .catbar { margin: 22px 0 12px; display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
  .catbar .label { margin: 0; }
  .cat-tabs { display: flex; gap: 7px; flex-wrap: wrap; }
  .cat-tab { display: inline-flex; align-items: baseline; gap: 7px; padding: 6px 13px; border: 1px solid var(--line-strong); border-radius: 10px; font-size: 13.5px; cursor: pointer; background: var(--panel); color: var(--ink); font-family: var(--sans); }
  .cat-tab:hover { border-color: var(--accent); }
  .cat-tab.active { background: var(--accent-soft); color: var(--accent); border-color: var(--accent); font-weight: 600; }
  .cat-tab .cv { font-size: 11px; color: var(--muted); font-family: var(--mono); font-variant-numeric: tabular-nums; }
  .cat-tab.active .cv { color: var(--accent); }

  /* catalog metadata card (vgi.* tags) */
  .cat-card { margin-bottom: 18px; }
  .cat-card .cc-title { display: flex; align-items: center; gap: 9px; font-size: 18px; font-weight: 650; letter-spacing: -0.01em; }
  .cat-card .cc-title .ic { width: 19px; height: 19px; color: var(--accent); }
  .cat-card .cc-doc { color: var(--muted); font-size: 13.5px; margin-top: 5px; }
  .cat-card .cc-doc .md-h { font-size: 14px; font-weight: 650; color: var(--ink); margin: 8px 0 4px; }
  .cat-card .cc-doc .md-p { margin: 4px 0; }
  .cat-card .cc-doc .md-p:first-child { margin-top: 0; }
  .cat-card .cc-doc .md-ul { margin: 4px 0; padding-left: 18px; }
  .cat-card .cc-doc code { font-family: var(--mono); background: var(--chip); padding: 1px 5px; border-radius: 4px; font-size: .92em; }
  .cat-card .cc-doc a { color: var(--accent); }
  .badges { display: flex; gap: 8px; flex-wrap: wrap; margin-top: 13px; }
  .badge { display: inline-flex; align-items: center; gap: 6px; font-size: 12.5px; padding: 5px 11px; border: 1px solid var(--line-strong); border-radius: 8px; text-decoration: none; color: var(--ink); background: var(--panel); }
  .badge:hover { border-color: var(--accent); color: var(--accent); }
  .badge .ic { width: 15px; height: 15px; color: var(--muted); }
  .badge:hover .ic { color: var(--accent); }
  .badge b { font-weight: 600; }
  .badge.license .ic { color: var(--ok); }
  .cc-kw { display: flex; gap: 6px; flex-wrap: wrap; margin-top: 11px; align-items: center; }
  .cc-kw .ic { width: 14px; height: 14px; color: var(--muted); }
  .cc-kw .k { font-size: 11.5px; padding: 2px 10px; border-radius: 20px; background: var(--chip); color: var(--muted); }
  .cc-by { color: var(--muted); font-size: 11.5px; margin-top: 11px; }

  .start { display: flex; flex-direction: column; margin: 0 0 24px; }
  .start > div { display: flex; flex-direction: column; margin-bottom: 16px; }
  .start > div:last-child { margin-bottom: 0; }
  .start > div:nth-child(1) { order: 2; margin-bottom: 0; }   /* Connect */
  .start > div:nth-child(2) { order: 1; margin-bottom: 16px; } /* Explore first */

  .attach { position: relative; background: var(--code-bg); color: var(--code-ink); border-radius: 10px; padding: 15px 16px; font-family: var(--mono); font-size: 12.5px; overflow-x: auto; white-space: pre; }
  .connect-top { display: flex; align-items: center; justify-content: space-between; gap: 10px; flex-wrap: wrap; margin-bottom: 11px; }
  .tabs { display: flex; gap: 5px; flex-wrap: wrap; }
  .tab { display: inline-flex; align-items: center; gap: 7px; padding: 5px 13px; border: 1px solid var(--line-strong); border-radius: 8px; font-size: 12.5px; cursor: pointer; background: var(--panel); color: var(--muted); font-family: var(--sans); }
  .tab-logo { width: 15px; height: 15px; flex: none; }
  .tab-logo.pyl { fill: #3776AB; }
  .tab-logo.ndl { fill: #5FA04E; }
  .tab:hover { border-color: var(--accent); color: var(--accent); }
  .tab.active { background: var(--accent-soft); color: var(--accent); border-color: var(--accent); font-weight: 600; }
  details.attach-opts { margin-top: 15px; }
  details.attach-opts > summary { list-style: none; cursor: pointer; display: flex; align-items: center; gap: 8px; padding: 4px 0; }
  details.attach-opts > summary::-webkit-details-marker { display: none; }
  details.attach-opts .tri { color: var(--muted); transition: transform .15s; }
  details.attach-opts[open] > summary .tri { transform: rotate(90deg); }
  .ao-count { font-family: var(--mono); font-size: 11px; color: var(--muted); background: var(--chip); border-radius: 10px; padding: 1px 7px; font-weight: 600; }
  table.opts { width: 100%; border-collapse: collapse; font-size: 12.5px; margin-top: 10px; }
  table.opts th { text-align: left; font-size: 10.5px; letter-spacing: .05em; text-transform: uppercase; color: var(--muted); font-weight: 700; padding: 0 12px 6px 0; border-bottom: 1px solid var(--line); }
  table.opts td { padding: 7px 12px 7px 0; border-bottom: 1px solid var(--line); vertical-align: top; }
  table.opts tr:last-child td { border-bottom: none; }
  .o-name { font-family: var(--mono); font-weight: 550; }
  .o-req { font-family: var(--sans); font-size: 10px; font-weight: 600; letter-spacing: .02em;
           text-transform: uppercase; margin-left: 6px; padding: 1px 5px; border-radius: 4px;
           background: var(--warn-bg, #fdf0e3); color: var(--warn-fg, #8a4b08);
           border: 1px solid var(--warn-bd, #f0d5b4); vertical-align: 1px; }
  .o-type, .o-def { font-family: var(--mono); color: var(--type-color); white-space: nowrap; }
  .o-desc { color: var(--muted); }
  .attach .kw { color: #d9a441; } .attach .str { color: #7fb98a; } .attach .opt { color: #86b8d6; }
  .copy { position: absolute; top: 10px; right: 10px; background: rgba(255,255,255,0.08); color: #d8d3c2; border: 1px solid rgba(255,255,255,0.15); border-radius: 7px; padding: 4px 10px; font-size: 11.5px; cursor: pointer; font-family: var(--sans); }
  .copy:hover { background: rgba(255,255,255,0.16); }
  .connect-row { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; margin-top: 12px; font-size: 13px; color: var(--muted); }
  .chip-badge { background: var(--accent-soft); color: var(--accent); border-radius: 6px; padding: 2px 9px; font-size: 12px; font-weight: 600; white-space: nowrap; }

  .dvmenu { position: relative; }
  .dvmenu > summary { list-style: none; cursor: pointer; display: inline-flex; align-items: center; gap: 7px; border: 1px solid var(--line-strong); border-radius: 8px; padding: 5px 11px; font-size: 12.5px; background: var(--panel); color: var(--ink); }
  .dvmenu > summary::-webkit-details-marker { display: none; }
  .dvmenu > summary:hover { border-color: var(--accent); }
  .dvmenu .dv-cur { font-family: var(--mono); font-weight: 600; }
  .dvmenu .caret { color: var(--muted); }
  .dvlist { position: absolute; z-index: 30; top: calc(100% + 5px); left: 0; min-width: 290px; background: var(--panel); border: 1px solid var(--line-strong); border-radius: 11px; box-shadow: 0 8px 26px rgba(0,0,0,0.14); padding: 5px; }
  .dvitem { display: block; width: 100%; text-align: left; border: none; background: none; cursor: pointer; border-radius: 8px; padding: 8px 10px; color: var(--ink); font-family: var(--sans); font-size: 13px; }
  .dvitem:hover { background: var(--chip); }
  .dvitem.sel { background: var(--accent-soft); }
  .dvitem .row1 { display: flex; align-items: center; gap: 8px; }
  .dvitem .spec { font-family: var(--mono); font-weight: 600; font-size: 12.5px; }
  .dvitem .tag { font-size: 10px; letter-spacing: .04em; text-transform: uppercase; background: var(--ok); color: #fff; border-radius: 5px; padding: 1px 6px; }
  .dvitem .tag.pin { background: var(--muted); }
  .dvitem .check { margin-left: auto; color: var(--accent); }
  .dvitem .lbl { display: block; color: var(--muted); font-size: 11.5px; margin-top: 2px; }

  /* Two-tier Cupola CTA: visual rail on top, AI sub-rail beneath */
  .cup-tier { display: flex; flex-direction: column; border-radius: var(--radius); box-shadow: 0 2px 8px rgba(0,0,0,0.06); transition: box-shadow .14s, transform .12s; }
  .cup-tier:hover { box-shadow: 0 8px 22px rgba(0,0,0,0.12); transform: translateY(-1px); }
  a.cup-rail { display: flex; flex-direction: row; align-items: center; gap: 14px; text-decoration: none; background: linear-gradient(135deg, var(--cup-soft), var(--panel)); border: 1px solid var(--line-strong); border-radius: var(--radius) var(--radius) 0 0; padding: 15px 18px; color: var(--ink); }
  a.cup-rail .clogo { width: 42px; height: 42px; border-radius: 9px; flex: none; box-shadow: 0 1px 5px rgba(0,0,0,0.18); object-fit: cover; }
  a.cup-rail .cup-txt { display: flex; flex-direction: column; justify-content: center; min-width: 0; }
  a.cup-rail .cup-title { font-weight: 650; font-size: 15.5px; letter-spacing: -.01em; }
  a.cup-rail .cup-sub { color: var(--muted); font-size: 12.5px; margin-top: 3px; }
  a.cup-rail .cup-go { margin-left: auto; flex: none; width: 36px; height: 36px; border-radius: 999px; background: var(--cup); color: var(--on-cup); display: grid; place-items: center; transition: transform .14s ease, background .12s; }
  a.cup-rail .cup-go .ic { width: 18px; height: 18px; }
  a.cup-rail:hover .cup-go { transform: translateX(2px); background: var(--cup-2); }
  a.cup-airow { display: flex; align-items: center; gap: 9px; text-decoration: none; color: var(--ai); font-size: 12.5px; font-weight: 600; padding: 11px 18px 11px 22px; border: 1px solid var(--line-strong); border-top: 0; border-radius: 0 0 var(--radius) var(--radius); background: linear-gradient(135deg, var(--ai-soft), var(--panel)); position: relative; overflow: hidden; transition: background .12s; }
  a.cup-airow::before { content: ""; position: absolute; left: 0; top: 0; bottom: 0; width: 4px; background: var(--ai); }
  a.cup-airow:hover { background: linear-gradient(135deg, color-mix(in srgb, var(--ai) 22%, var(--panel)), var(--panel)); }
  a.cup-airow .ic { width: 17px; height: 17px; flex: none; }
  a.cup-airow .aitext { flex: 1; min-width: 0; }
  a.cup-airow .cup-arr { margin-left: auto; opacity: .8; transition: transform .14s ease; }
  a.cup-airow:hover .cup-arr { transform: translateX(3px); }

  .contents-head { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; margin-bottom: 10px; }
  .contents-head .label { margin: 0; }
  .filter { flex: 1; min-width: 160px; position: relative; display: flex; align-items: center; }
  .filter .ic { position: absolute; left: 10px; color: var(--muted); width: 14px; height: 14px; }
  .filter input { width: 100%; font-size: 13.5px; padding: 7px 11px 7px 32px; border: 1px solid var(--line-strong); border-radius: 9px; background: var(--panel); color: var(--ink); }
  .filter .count { position: absolute; right: 11px; font-size: 11.5px; color: var(--muted); font-family: var(--mono); font-variant-numeric: tabular-nums; }
  .bulk { font-size: 12px; color: var(--muted); background: none; border: 1px solid var(--line-strong); border-radius: 8px; padding: 6px 10px; cursor: pointer; }
  .bulk:hover { border-color: var(--accent); color: var(--accent); }
  .cat-sub { color: var(--muted); font-size: 12.5px; font-family: var(--mono); font-variant-numeric: tabular-nums; padding: 0 2px 12px; }
  .cat-sub .asof { color: var(--accent); }

  /* level 1: schema card */
  details.schema { border: 1px solid var(--line); border-radius: var(--radius); background: var(--panel); margin: 10px 0; }
  details.schema > summary { list-style: none; cursor: pointer; display: flex; align-items: center; gap: 9px; padding: 12px 14px; line-height: 1.3; }
  details.schema[open] > summary { border-bottom: 1px solid var(--line); background: color-mix(in srgb, var(--ink) 3%, var(--panel)); border-radius: var(--radius) var(--radius) 0 0; }
  summary::-webkit-details-marker { display: none; }
  .tri { color: var(--muted); transition: transform .15s; flex: none; width: 12px; height: 12px; }
  details[open] > summary .tri { transform: rotate(90deg); }
  .schema > summary .ic.type { color: var(--k-view); width: 17px; height: 17px; }
  .schema-name { font-weight: 650; font-size: 15px; }
  .schema-sub { color: var(--muted); font-size: 12px; font-family: var(--mono); font-variant-numeric: tabular-nums; margin-left: auto; }

  /* level 2: type group */
  .grp { margin: 4px 8px 6px 14px; padding: 2px 10px 8px 13px; border-left: 2px solid color-mix(in srgb, var(--kc, var(--line-strong)) 40%, transparent); }
  .grp .glabel { display: flex; align-items: center; gap: 7px; font-size: 11px; letter-spacing: .06em; text-transform: uppercase; color: var(--kc, var(--muted)); font-weight: 700; margin: 12px 0 7px; }
  .grp .glabel .ic { width: 15px; height: 15px; color: var(--kc, var(--muted)); }
  .grp .glabel:first-child { margin-top: 6px; }
  .grp .tri { color: var(--muted); }
  .k-table { --kc: var(--k-table); } .k-view { --kc: var(--k-view); } .k-scalar { --kc: var(--k-scalar); }
  .k-tablefn { --kc: var(--k-tablefn); } .k-agg { --kc: var(--k-agg); } .k-tio { --kc: var(--k-tio); }
  .k-macro { --kc: var(--k-macro); }

  /* level 3: object rows as tinted cards */
  details.tbl, details.fn {
    border: 1px solid color-mix(in srgb, var(--kc) var(--edge), var(--line));
    border-radius: var(--row-radius);
    background: color-mix(in srgb, var(--kc) var(--tint), var(--panel));
    margin: 5px 0;
  }
  details.tbl > summary, details.fn > summary { list-style: none; cursor: pointer; display: flex; align-items: center; gap: 8px; padding: 8px 11px; line-height: 1.3; }
  details.tbl:hover, details.fn:hover { border-color: color-mix(in srgb, var(--kc) var(--edge-hover), var(--line)); background: color-mix(in srgb, var(--kc) var(--tint-hover), var(--panel)); }
  details.tbl[open], details.fn[open] { border-color: color-mix(in srgb, var(--kc) var(--edge-open), var(--line)); background: color-mix(in srgb, var(--kc) var(--tint-open), var(--panel)); }
  details.tbl[open] > summary, details.fn[open] > summary { border-bottom: 1px solid color-mix(in srgb, var(--kc) 25%, var(--line)); }
  .row-icon { width: 16px; height: 16px; flex: none; color: var(--kc); }
  .t-name, .fn-name { font-family: var(--mono); font-size: 12.5px; font-weight: 550; }
  .t-meta { color: var(--muted); font-size: 11.5px; font-family: var(--mono); font-variant-numeric: tabular-nums; flex: none; }
  /* The signature is the one item here that has no bounded length: a function
     with a dozen named arguments runs many times the card's width. It must be
     the item that gives, so it shrinks (`1 1 auto`) rather than refusing to
     (`flex: none`, which overflowed the container), and `min-width: 0` is what
     actually lets a flex item shrink below its content. `anywhere` breaks
     inside a long type or identifier as a last resort, since the text is a
     single unbroken run of mono with few spaces to wrap at. */
  .fn-sig { color: var(--muted); font-size: 12px; font-family: var(--mono); flex: 1 1 auto; min-width: 0; overflow-wrap: anywhere; }
  .fn-name { flex: none; }
  /* Once the signature wraps to several lines, centring pushes the caret and
     the icon to the middle of that block; top-align keeps them on the first
     line, next to the name. */
  details.fn > summary { align-items: flex-start; }
  .fn-sig .sig-type { color: color-mix(in srgb, var(--kc) 55%, var(--muted)); }

  /* level 4: body inset */
  .t-body, .fn-body { padding: 9px 13px 12px; background: color-mix(in srgb, var(--kc) 4%, var(--bg)); border-radius: 0 0 var(--row-radius) var(--row-radius); }
  .t-desc { color: var(--ink); font-size: 12.5px; line-height: 1.5; margin: 0 0 11px; }
  .t-desc .md-h { font-size: 13px; font-weight: 650; margin: 8px 0 4px; }
  .t-desc .md-p { margin: 4px 0; }
  .t-desc .md-p:first-child { margin-top: 0; }
  .t-desc .md-ul { margin: 4px 0; padding-left: 18px; }
  .t-desc code { font-family: var(--mono); background: var(--chip); padding: 1px 5px; border-radius: 4px; font-size: .92em; }
  .t-desc a { color: var(--accent); }
  .schema-desc { margin: 13px 14px 18px; padding: 13px 16px; border: 1px solid var(--line); border-radius: 8px; background: color-mix(in srgb, var(--muted) 4%, var(--panel)); }
  .schema-desc .md-p:last-child, .schema-desc .md-ul:last-child, .schema-desc .md-tablewrap:last-child { margin-bottom: 0; }
  /* Markdown tables (catalog/table/view/function descriptions) */
  .md-tablewrap { overflow-x: auto; margin: 9px 0; -webkit-overflow-scrolling: touch; }
  .md-table { border-collapse: collapse; font-size: 12px; line-height: 1.45; }
  .md-table th, .md-table td { border: 1px solid var(--line); padding: 5px 10px; text-align: left; vertical-align: top; }
  .md-table th { background: var(--chip); font-weight: 650; color: var(--ink); white-space: nowrap; }
  .md-table tbody tr:nth-child(even) td { background: color-mix(in srgb, var(--muted) 6%, transparent); }
  .md-table code { font-family: var(--mono); background: var(--chip); padding: 1px 5px; border-radius: 4px; font-size: .92em; }
  .md-table a { color: var(--accent); }
  .args-label { font-size: 10.5px; letter-spacing: .06em; text-transform: uppercase; color: var(--muted); font-weight: 700; margin: 0 0 6px; }
  .cols { display: flex; flex-direction: column; gap: 6px; }
  .col-item { border: 1px solid color-mix(in srgb, var(--kc) 22%, var(--line)); border-radius: 7px; padding: 7px 10px; background: color-mix(in srgb, var(--kc) 4%, var(--panel)); }
  .col-item:hover { border-color: color-mix(in srgb, var(--kc) 50%, var(--line)); background: color-mix(in srgb, var(--kc) 9%, var(--panel)); }
  .col { display: flex; justify-content: space-between; align-items: baseline; gap: 16px; }
  .col-name { font-family: var(--mono); font-size: 12.5px; font-weight: 550; }
  .col-type { font-family: var(--mono); font-size: 12px; color: var(--type-color); white-space: nowrap; }
  .col-comment { color: var(--muted); font-size: 11.5px; margin: 4px 0 0; }
  .arg-kind { color: var(--muted); font-family: var(--mono); font-weight: 400; }
  .arg-def { font-family: var(--mono); color: var(--type-color); }
  .fn-noargs { color: var(--muted); font-size: 12.5px; font-style: italic; }
  .fn-returns { margin-top: 11px; font-size: 12.5px; color: var(--muted); font-family: var(--mono); }
  .fn-returns b { color: var(--ink); font-weight: 700; font-family: var(--sans); letter-spacing: .06em; text-transform: uppercase; font-size: 10.5px; margin-right: 7px; }
  .fn-returns .rtype { color: var(--type-color); }
  .view-sql { font-family: var(--mono); font-size: 12px; line-height: 1.5; background: var(--code-bg); color: var(--code-ink); border-radius: 8px; padding: 10px 12px; margin: 0 0 12px; white-space: pre-wrap; overflow-x: auto; }
  .view-sql .kw { color: #d9a441; }
  .skeleton { color: var(--muted); font-size: 12.5px; font-family: var(--mono); padding: 4px 6px; }

  mark { background: var(--hit); color: inherit; border-radius: 3px; }
  .hidden { display: none !important; }
  .noresults { color: var(--muted); font-size: 13.5px; padding: 16px 4px; }

  footer { text-align: center; margin-top: 40px; padding-top: 20px; border-top: 1px solid var(--line); color: var(--muted); font-size: 13px; }
  footer a { color: var(--muted); text-decoration: none; }
  footer a:hover { color: var(--accent); }
  footer .dot { margin: 0 9px; opacity: .5; }
  footer .foot-meta { margin-top: 8px; font-size: 11.5px; opacity: .75; }
  footer code { font-family: var(--mono); background: var(--chip); padding: 1px 5px; border-radius: 5px; font-size: .92em; }
</style>
</head>
<body>
<!-- vgi-landing-asset v5 -->

<a class="skip" href="#contents">Skip to contents</a>

<div class="wrap">
  <div id="vgi-user-info"></div>
  <header class="hero">
    <a class="logo-link" href="https://query.farm" target="_blank" rel="noopener"><img class="logo" src="data:image/png;base64,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" alt="Vector Gateway Interface — Query.Farm"></a>
    <h1 id="worker-name">—</h1>
    <p class="doc" id="worker-doc"></p>
  </header>

  <div class="catbar" id="catbar"></div>
  <div class="panel cat-card" id="cat-card"></div>

  <div class="start">
    <div>
      <p class="label">Connect</p>
      <div class="panel" id="connect" style="flex:1"></div>
    </div>
    <div>
      <p class="label">Explore / Analyze Visually</p>
      <div class="cup-tier">
        <a class="cup-rail" id="cupola-cta" href="#" target="_blank" rel="noopener">
          <img class="clogo" src="data:image/png;base64,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" alt="Cupola" width="42" height="42">
          <span class="cup-txt">
            <span class="cup-title">Explore in Cupola</span>
            <span class="cup-sub">SQL shell, pivot tables &amp; charts</span>
          </span>
          <span class="cup-go"><svg class="ic" viewBox="0 0 256 256" fill="currentColor" aria-hidden="true"><path d="M221.66,133.66l-72,72a8,8,0,0,1-11.32-11.32L196.69,136H40a8,8,0,0,1,0-16H196.69L138.34,61.66a8,8,0,0,1,11.32-11.32l72,72A8,8,0,0,1,221.66,133.66Z"/></svg></span>
        </a>
        <a class="cup-airow" id="cupola-ai-cta" href="#" target="_blank" rel="noopener">
          <svg class="ic" viewBox="0 0 256 256" fill="currentColor" aria-hidden="true"><path d="M208,144a15.78,15.78,0,0,1-10.42,14.94l-51.65,19-19,51.61a15.92,15.92,0,0,1-29.88,0L78,178l-51.62-19a15.92,15.92,0,0,1,0-29.88L78,110.05l19-51.61a15.92,15.92,0,0,1,29.88,0l19,51.65,51.61,19A15.78,15.78,0,0,1,208,144Z" opacity="0.2"/><path d="M197.58,129.06,146,110l-19-51.62a15.92,15.92,0,0,0-29.88,0L78,110,26.42,129a15.92,15.92,0,0,0,0,29.88L78,178l19,51.62a15.92,15.92,0,0,0,29.88,0L146,178l51.62-19a15.92,15.92,0,0,0,0-29.88ZM137,164a15.9,15.9,0,0,0-9.44,9.45L112,215.66,96.49,173.4A15.9,15.9,0,0,0,87,164L44.79,148.5,87,133a15.9,15.9,0,0,0,9.45-9.44L112,81.34l15.51,42.22A15.9,15.9,0,0,0,137,133l42.22,15.5Z"/></svg>
          <span class="aitext">Prefer plain English? Ask AI about this data</span>
          <svg class="ic cup-arr" viewBox="0 0 256 256" fill="currentColor" aria-hidden="true"><path d="M221.66,133.66l-72,72a8,8,0,0,1-11.32-11.32L196.69,136H40a8,8,0,0,1,0-16H196.69L138.34,61.66a8,8,0,0,1,11.32-11.32l72,72A8,8,0,0,1,221.66,133.66Z"/></svg>
        </a>
      </div>
    </div>
  </div>

  <section id="contents">
    <div class="contents-head">
      <p class="label">Contents</p>
      <div class="filter" id="filter-wrap">
        <input id="filter" type="search" placeholder="Filter schemas, tables, functions…" aria-label="Filter contents" autocomplete="off">
        <span class="count" id="filter-count" aria-live="polite"></span>
      </div>
      <button class="bulk" id="expand-all">Expand all</button>
      <button class="bulk" id="collapse-all">Collapse all</button>
    </div>
    <div id="cat-sub" class="cat-sub"></div>
    <div id="catalogs"></div>
  </section>

  <footer id="footer"></footer>
</div>

<script type="module">
const ICONS = {
  'impl': '<path d="M223.68,66.15,135.68,18h0a15.88,15.88,0,0,0-15.36,0l-88,48.17a16,16,0,0,0-8.32,14v95.64a16,16,0,0,0,8.32,14l88,48.17a15.88,15.88,0,0,0,15.36,0l88-48.17a16,16,0,0,0,8.32-14V80.18A16,16,0,0,0,223.68,66.15ZM128,32h0l80.34,44L128,120,47.66,76ZM40,90l80,43.78v85.79L40,175.82Zm96,129.57V133.82L216,90v85.78Z"/>',
  'catalog': '<path d="M216,80c0,26.51-39.4,48-88,48S40,106.51,40,80s39.4-48,88-48S216,53.49,216,80Z" opacity="0.2"/><path d="M128,24C74.17,24,32,48.6,32,80v96c0,31.4,42.17,56,96,56s96-24.6,96-56V80C224,48.6,181.83,24,128,24Zm80,104c0,9.62-7.88,19.43-21.61,26.92C170.93,163.35,150.19,168,128,168s-42.93-4.65-58.39-13.08C55.88,147.43,48,137.62,48,128V111.36c17.06,15,46.23,24.64,80,24.64s62.94-9.68,80-24.64ZM69.61,53.08C85.07,44.65,105.81,40,128,40s42.93,4.65,58.39,13.08C200.12,60.57,208,70.38,208,80s-7.88,19.43-21.61,26.92C170.93,115.35,150.19,120,128,120s-42.93-4.65-58.39-13.08C55.88,99.43,48,89.62,48,80S55.88,60.57,69.61,53.08ZM186.39,202.92C170.93,211.35,150.19,216,128,216s-42.93-4.65-58.39-13.08C55.88,195.43,48,185.62,48,176V159.36c17.06,15,46.23,24.64,80,24.64s62.94-9.68,80-24.64V176C208,185.62,200.12,195.43,186.39,202.92Z"/>',
  'schema': '<path d="M128,80H32V56a8,8,0,0,1,8-8H92.69a8,8,0,0,1,5.65,2.34Z" opacity="0.2"/><path d="M216,72H131.31L104,44.69A15.86,15.86,0,0,0,92.69,40H40A16,16,0,0,0,24,56V200.62A15.4,15.4,0,0,0,39.38,216H216.89A15.13,15.13,0,0,0,232,200.89V88A16,16,0,0,0,216,72ZM92.69,56l16,16H40V56ZM216,200H40V88H216Z"/>',
  'table': '<path d="M88,104v96H32V104Z" opacity="0.2"/><path d="M224,48H32a8,8,0,0,0-8,8V192a16,16,0,0,0,16,16H216a16,16,0,0,0,16-16V56A8,8,0,0,0,224,48ZM40,112H80v32H40Zm56,0H216v32H96ZM216,64V96H40V64ZM40,160H80v32H40Zm176,32H96V160H216v32Z"/>',
  'view': '<path d="M128,56C48,56,16,128,16,128s32,72,112,72,112-72,112-72S208,56,128,56Zm0,112a40,40,0,1,1,40-40A40,40,0,0,1,128,168Z" opacity="0.2"/><path d="M247.31,124.76c-.35-.79-8.82-19.58-27.65-38.41C194.57,61.26,162.88,48,128,48S61.43,61.26,36.34,86.35C17.51,105.18,9,124,8.69,124.76a8,8,0,0,0,0,6.5c.35.79,8.82,19.57,27.65,38.4C61.43,194.74,93.12,208,128,208s66.57-13.26,91.66-38.34c18.83-18.83,27.3-37.61,27.65-38.4A8,8,0,0,0,247.31,124.76ZM128,192c-30.78,0-57.67-11.19-79.93-33.25A133.47,133.47,0,0,1,25,128,133.33,133.33,0,0,1,48.07,97.25C70.33,75.19,97.22,64,128,64s57.67,11.19,79.93,33.25A133.46,133.46,0,0,1,231.05,128C223.84,141.46,192.43,192,128,192Zm0-112a48,48,0,1,0,48,48A48.05,48.05,0,0,0,128,80Zm0,80a32,32,0,1,1,32-32A32,32,0,0,1,128,160Z"/>',
  'function': '<path d="M200,40V200a16,16,0,0,1-16,16H56V56A16,16,0,0,1,72,40Z" opacity="0.2"/><path d="M208,40a8,8,0,0,1-8,8H170.71a24,24,0,0,0-23.62,19.71L137.59,120H184a8,8,0,0,1,0,16H134.68l-10,55.16A40,40,0,0,1,85.29,224H56a8,8,0,0,1,0-16H85.29a24,24,0,0,0,23.62-19.71l9.5-52.29H72a8,8,0,0,1,0-16h49.32l10-55.16A40,40,0,0,1,170.71,32H200A8,8,0,0,1,208,40Z"/>',
  'aggregate': '<path d="M192,48V208H64l64-80L64,48Z" opacity="0.2"/><path d="M184,72V56H80.65l53.6,67a8,8,0,0,1,0,10l-53.6,67H184V184a8,8,0,0,1,16,0v24a8,8,0,0,1-8,8H64a8,8,0,0,1-6.25-13l60-75-60-75A8,8,0,0,1,64,40H192a8,8,0,0,1,8,8V72a8,8,0,0,1-16,0Z"/>',
  'tio': '<path d="M221.9,61.38,152,136v58.65a8,8,0,0,1-3.56,6.66l-32,21.33A8,8,0,0,1,104,216V136L34.1,61.38A8,8,0,0,1,40,48H216A8,8,0,0,1,221.9,61.38Z" opacity="0.2"/><path d="M230.6,49.53A15.81,15.81,0,0,0,216,40H40A16,16,0,0,0,28.19,66.76l.08.09L96,139.17V216a16,16,0,0,0,24.87,13.32l32-21.34A16,16,0,0,0,160,194.66V139.17l67.74-72.32.08-.09A15.8,15.8,0,0,0,230.6,49.53ZM40,56h0Zm106.18,74.58A8,8,0,0,0,144,136v58.66L112,216V136a8,8,0,0,0-2.16-5.47L40,56H216Z"/>',
  'caret': '<path d="M181.66,133.66l-80,80a8,8,0,0,1-11.32-11.32L164.69,128,90.34,53.66a8,8,0,0,1,11.32-11.32l80,80A8,8,0,0,1,181.66,133.66Z"/>',
  'search': '<path d="M229.66,218.34l-50.07-50.06a88.11,88.11,0,1,0-11.31,11.31l50.06,50.07a8,8,0,0,0,11.32-11.32ZM40,112a72,72,0,1,1,72,72A72.08,72.08,0,0,1,40,112Z"/>',
  'repo': '<path d="M232,64a32,32,0,1,0-40,31v17a8,8,0,0,1-8,8H96a23.84,23.84,0,0,0-8,1.38V95a32,32,0,1,0-16,0v66a32,32,0,1,0,16,0V144a8,8,0,0,1,8-8h88a24,24,0,0,0,24-24V95A32.06,32.06,0,0,0,232,64ZM64,64A16,16,0,1,1,80,80,16,16,0,0,1,64,64ZM96,192a16,16,0,1,1-16-16A16,16,0,0,1,96,192ZM200,80a16,16,0,1,1,16-16A16,16,0,0,1,200,80Z"/>',
  'license': '<path d="M239.43,133l-32-80h0a8,8,0,0,0-9.16-4.84L136,62V40a8,8,0,0,0-16,0V65.58L54.26,80.19A8,8,0,0,0,48.57,85h0v.06L16.57,165a7.92,7.92,0,0,0-.57,3c0,23.31,24.54,32,40,32s40-8.69,40-32a7.92,7.92,0,0,0-.57-3L66.92,93.77,120,82V208H104a8,8,0,0,0,0,16h48a8,8,0,0,0,0-16H136V78.42L187,67.1,160.57,133a7.92,7.92,0,0,0-.57,3c0,23.31,24.54,32,40,32s40-8.69,40-32A7.92,7.92,0,0,0,239.43,133ZM56,184c-7.53,0-22.76-3.61-23.93-14.64L56,109.54l23.93,59.82C78.76,180.39,63.53,184,56,184Zm144-32c-7.53,0-22.76-3.61-23.93-14.64L200,77.54l23.93,59.82C222.76,148.39,207.53,152,200,152Z"/>',
  'support': '<path d="M128,24A104,104,0,1,0,232,128,104.11,104.11,0,0,0,128,24Zm39.1,131.79a47.84,47.84,0,0,0,0-55.58l28.5-28.49a87.83,87.83,0,0,1,0,112.56ZM96,128a32,32,0,1,1,32,32A32,32,0,0,1,96,128Zm88.28-67.6L155.79,88.9a47.84,47.84,0,0,0-55.58,0L71.72,60.4a87.83,87.83,0,0,1,112.56,0ZM60.4,71.72l28.5,28.49a47.84,47.84,0,0,0,0,55.58L60.4,184.28a87.83,87.83,0,0,1,0-112.56ZM71.72,195.6l28.49-28.5a47.84,47.84,0,0,0,55.58,0l28.49,28.5a87.83,87.83,0,0,1-112.56,0Z"/>',
  'policy': '<path d="M208,40H48A16,16,0,0,0,32,56v56c0,52.72,25.52,84.67,46.93,102.19,23.06,18.86,46,25.26,47,25.53a8,8,0,0,0,4.2,0c1-.27,23.91-6.67,47-25.53C198.48,196.67,224,164.72,224,112V56A16,16,0,0,0,208,40Zm0,72c0,37.07-13.66,67.16-40.6,89.42A129.3,129.3,0,0,1,128,223.62a128.25,128.25,0,0,1-38.92-21.81C61.82,179.51,48,149.3,48,112l0-56,160,0ZM82.34,141.66a8,8,0,0,1,11.32-11.32L112,148.69l50.34-50.35a8,8,0,0,1,11.32,11.32l-56,56a8,8,0,0,1-11.32,0Z"/>',
  'keyword': '<path d="M243.31,136,144,36.69A15.86,15.86,0,0,0,132.69,32H40a8,8,0,0,0-8,8v92.69A15.86,15.86,0,0,0,36.69,144L136,243.31a16,16,0,0,0,22.63,0l84.68-84.68a16,16,0,0,0,0-22.63Zm-96,96L48,132.69V48h84.69L232,147.31ZM96,84A12,12,0,1,1,84,72,12,12,0,0,1,96,84Z"/>',
  'sparkle': '<path d="M208,144a15.78,15.78,0,0,1-10.42,14.94l-51.65,19-19,51.61a15.92,15.92,0,0,1-29.88,0L78,178l-51.62-19a15.92,15.92,0,0,1,0-29.88L78,110.05l19-51.61a15.92,15.92,0,0,1,29.88,0l19,51.65,51.61,19A15.78,15.78,0,0,1,208,144Z" opacity="0.2"/><path d="M197.58,129.06,146,110l-19-51.62a15.92,15.92,0,0,0-29.88,0L78,110,26.42,129a15.92,15.92,0,0,0,0,29.88L78,178l19,51.62a15.92,15.92,0,0,0,29.88,0L146,178l51.62-19a15.92,15.92,0,0,0,0-29.88ZM137,164a15.9,15.9,0,0,0-9.44,9.45L112,215.66,96.49,173.4A15.9,15.9,0,0,0,87,164L44.79,148.5,87,133a15.9,15.9,0,0,0,9.45-9.44L112,81.34l15.51,42.22A15.9,15.9,0,0,0,137,133l42.22,15.5Z"/>',
  'arrow': '<path d="M221.66,133.66l-72,72a8,8,0,0,1-11.32-11.32L196.69,136H40a8,8,0,0,1,0-16H196.69L138.34,61.66a8,8,0,0,1,11.32-11.32l72,72A8,8,0,0,1,221.66,133.66Z"/>'
};
function icon(name, cls){ return '<svg class="ic '+(cls||'')+'" viewBox="0 0 256 256" fill="currentColor" aria-hidden="true">'+(ICONS[name]||'')+'</svg>'; }

import {
  VgiClient, httpConnect, deserializeAttachOptionSpecs, deserializeSchema,
  schemaToArgumentSpecs, TypeId
} from './vgi-client.js?v=5';

// ── Catalog metadata, read straight off the VGI wire protocol ────────────────────
// The page speaks the protocol the DuckDB extension speaks, through the JS
// client the worker serves next to this file. There is no worker-side
// document to keep in sync and no second contract to version: one client
// replaces what used to be a per-language `describe.json` producer.
let describe = null;
let client = null;
const CUPOLA_BASE = 'https://cupola.query-farm.services';

// Arrow DataType -> the SQL type name a DuckDB user would recognize. The page's
// whole call to action is ATTACH-and-query, so SQL names read better here than
// Arrow's own spelling.
function typeStr(t){
  if (!t) return '';
  const a = t;
  switch (t.typeId) {
    case TypeId.Null: return 'NULL';
    case TypeId.Bool: return 'BOOLEAN';
    case TypeId.Int: {
      const signed = a.signed ?? a.isSigned ?? true;
      const name = {8:'TINYINT',16:'SMALLINT',32:'INTEGER',64:'BIGINT'}[a.bitWidth] || 'INTEGER';
      return signed ? name : 'U'+name;
    }
    case TypeId.Float: return {1:'FLOAT',2:'DOUBLE'}[a.precision] || 'DOUBLE';
    case TypeId.Utf8: case TypeId.LargeUtf8: return 'VARCHAR';
    case TypeId.Binary: case TypeId.LargeBinary: case TypeId.FixedSizeBinary: return 'BLOB';
    case TypeId.Decimal: return 'DECIMAL('+a.precision+','+a.scale+')';
    case TypeId.Date: return 'DATE';
    case TypeId.Time: return 'TIME';
    case TypeId.Timestamp: return a.timezone ? 'TIMESTAMP WITH TIME ZONE' : 'TIMESTAMP';
    case TypeId.Interval: return 'INTERVAL';
    case TypeId.Duration: return 'INTERVAL';
    case TypeId.List: case TypeId.FixedSizeList:
      return typeStr((a.children && a.children[0] && a.children[0].type) || null)+'[]';
    case TypeId.Struct:
      return 'STRUCT('+(a.children||[]).map(c=>c.name+' '+typeStr(c.type)).join(', ')+')';
    case TypeId.Map: {
      const kids = (a.children && a.children[0] && a.children[0].type && a.children[0].type.children) || [];
      return 'MAP('+kids.map(c=>typeStr(c.type)).join(', ')+')';
    }
    default: return 'ANY';
  }
}

function readSchema(bytes){
  if (!bytes || !bytes.length) return null;
  try { return deserializeSchema(bytes); } catch (e) { return null; }
}

// Column detail stays lazy, exactly as it was when it came from a per-object
// JSON endpoint — the difference is where the bytes come from.
const columnCache = new Map();
async function fetchColumns(catName, schema, table){
  const key = JSON.stringify([catName, schema, table]);
  if (columnCache.has(key)) return columnCache.get(key);
  const cat = describe.catalogs.find(c=>c.name===catName);
  if (!cat || !cat._aod) return {columns:[]};
  try {
    const tables = await client.schemaContentsTables(cat._aod, schema);
    const t = tables.find(x=>x.name===table);
    if (t) {
      const s = readSchema(t.columns);
      const cols = s ? s.fields.map(f=>({
        name: f.name, type: typeStr(f.type),
        comment: (f.metadata && (f.metadata.get('comment') || f.metadata.get('vgi_doc'))) || ''
      })) : [];
      const out = {columns: cols};
      columnCache.set(key, out);
      return out;
    }
    const views = await client.schemaContentsViews(cat._aod, schema);
    const v = views.find(x=>x.name===table);
    if (v) {
      // A view's column types are only known once its SQL is bound, which the
      // worker does not do here; the declared comments are what exist.
      const out = {columns: Object.entries(v.column_comments||{}).map(([n,c])=>({name:n, type:'', comment:c}))};
      columnCache.set(key, out);
      return out;
    }
  } catch (e) { /* fall through to empty */ }
  return {columns:[]};
}

function fnDisplayType(f){
  if (f.function_type === 'SCALAR' || f.function_type === 0) return 'scalar';
  if (f.function_type === 'AGGREGATE' || f.function_type === 2) return 'aggregate';
  return f.has_finalize ? 'table_in_out' : 'table';
}

function fnReturns(f){
  const s = readSchema(f.output_schema);
  if (!s || !s.fields.length) return null;
  const t = fnDisplayType(f);
  if (t === 'scalar' || t === 'aggregate') return typeStr(s.fields[0].type);
  return 'TABLE('+s.fields.map(x=>x.name+' '+typeStr(x.type)).join(', ')+')';
}

function fnArgs(f){
  const s = readSchema(f.arguments);
  if (!s) return [];
  return schemaToArgumentSpecs(s)
    // The piped input relation of a table-in-out function is not a
    // user-supplied argument.
    .filter(a=>!a.isTableInput)
    .map(a=>{
      const arg = {name: a.name, type: a.isAnyType ? 'ANY' : typeStr(a.arrowType)};
      if (typeof a.position === 'string') arg.named = true;
      if (a.doc) arg.desc = a.doc;
      if (a.defaultJson != null) arg.default = a.defaultJson;
      return arg;
    });
}

async function schemaEntry(aod, si){
  // A VGI worker commonly exposes its callable surface as declarative macros,
  // so they fold into the same scalar/table buckets as functions.
  const macros = (kind)=> client.schemaContentsMacros(aod, si.path, kind).catch(()=>[]);
  const [tablesRaw, viewsRaw, scalarFns, tableFns, aggFns, scalarMacros, tableMacros] = await Promise.all([
    client.schemaContentsTables(aod, si.path),
    client.schemaContentsViews(aod, si.path),
    client.schemaContentsFunctions(aod, si.path, 'SCALAR_FUNCTION'),
    client.schemaContentsFunctions(aod, si.path, 'TABLE_FUNCTION'),
    client.schemaContentsFunctions(aod, si.path, 'AGGREGATE_FUNCTION'),
    macros('SCALAR_MACRO'),
    macros('TABLE_MACRO')
  ]);
  const macrosRaw = [].concat(scalarMacros, tableMacros);
  const byName = (a,b)=>a.name<b.name?-1:a.name>b.name?1:0;
  const tables = tablesRaw.slice().sort(byName).map(t=>{
    const s = readSchema(t.columns);
    return {name: t.name, cols: s ? s.fields.length : 0, comment: t.comment || ''};
  });
  const views = viewsRaw.slice().sort(byName).map(v=>({
    name: v.name, cols: Object.keys(v.column_comments||{}).length,
    comment: v.comment || '', def: v.definition
  }));
  const functions = [].concat(scalarFns, tableFns, aggFns).map(f=>{
    const out = {name: f.name, type: fnDisplayType(f), doc: f.description || '', args: fnArgs(f)};
    const r = fnReturns(f);
    if (r) out.returns = r;
    return out;
  // Macros get their own buckets rather than folding into scalar/table. They
  // are a different thing to call: DuckDB expands them inline as SQL, so they
  // cost no RPC round-trip and run identically on every transport. Merging
  // them also misreported the catalog — vgi-open-meteo has six scalar macros
  // and zero scalar functions, and the page listed all six under "Scalar
  // functions".
  //
  // Their parameters carry names only. A DuckDB macro is untyped, so the
  // protocol has no type to send and this used to invent `ANY` for each one —
  // which reads as "accepts any type" when it means "no type exists". Leaving
  // it unset lets the signature and the argument card omit it, and keeps ANY
  // meaning what it says on a genuinely polymorphic function argument.
  }).concat((macrosRaw||[]).map(m=>({
    name: m.name, type: String(m.macro_type).startsWith('TABLE') ? 'table_macro' : 'scalar_macro',
    doc: m.comment || '', args: (m.parameters||[]).map(p=>({name:p}))
  })));
  functions.sort((a,b)=> a.type===b.type ? byName(a,b) : (a.type<b.type?-1:1));
  const entry = {name: si.path.join('.'), path: si.path, tables, views, functions};
  if (si.comment) entry.doc = si.comment;
  return entry;
}

async function buildCatalog(info){
  const cat = {
    name: info.name,
    implementation_version: info.implementation_version ?? null,
    data_version_spec: info.data_version_spec ?? null,
    data_versions: (info.releases||[]).map(r=>Object.assign({spec:r.version}, r.summary?{label:r.summary}:{})),
    attach_options: [],
    tags: {},
    counts: {schemas:0,tables:0,views:0,functions:0,macros:0},
    schemas: [],
    _aod: null
  };
  try {
    cat.attach_options = deserializeAttachOptionSpecs(info.attach_option_specs||[]).map(s=>({
      name: s.name, type: typeStr(s.type),
      default: s.default == null ? '' : String(s.default),
      description: s.description || '',
      required: !!s.required
    }));
  } catch (e) { /* keep the card; drop unreadable specs */ }

  let attach;
  try {
    attach = await client.catalogAttach(info.name);
  } catch (e) {
    // The real reason, not an empty-looking catalog: a required option that
    // wasn't supplied, an unsupported version, an unreachable backend.
    cat.attach_error = String((e && e.message) || e);
    return cat;
  }
  cat._aod = attach.attach_opaque_data;
  if (attach.resolved_implementation_version) cat.implementation_version = attach.resolved_implementation_version;
  if (attach.resolved_data_version) cat.data_version_spec = attach.resolved_data_version;
  cat.tags = mapTags(attach.tags || {});

  const schemaInfos = (await client.schemas(cat._aod)).slice()
    .sort((a,b)=>a.path.join('.').localeCompare(b.path.join('.')));
  cat.schemas = await Promise.all(schemaInfos.map(si=>schemaEntry(cat._aod, si)));
  // `s.functions` holds both, so macros are counted apart rather than inflating
  // the function count — vgi-open-meteo reads "13 functions · 6 macros", not
  // "19 functions" when it has no scalar functions at all.
  const isMacro = f => f.type === 'scalar_macro' || f.type === 'table_macro';
  cat.counts = {
    schemas: cat.schemas.length,
    tables: cat.schemas.reduce((n,s)=>n+s.tables.length,0),
    views: cat.schemas.reduce((n,s)=>n+s.views.length,0),
    functions: cat.schemas.reduce((n,s)=>n+s.functions.filter(f=>!isMacro(f)).length,0),
    macros: cat.schemas.reduce((n,s)=>n+s.functions.filter(isMacro).length,0)
  };
  return cat;
}

// Reserved `vgi.*` catalog tags (see the extension's TAGS.md) surfaced on the card.
const STRING_TAGS = {
  title:'vgi.title', doc_md:'vgi.doc_md', source_url:'vgi.source_url',
  license:'vgi.license', author:'vgi.author', copyright:'vgi.copyright',
  support_contact:'vgi.support_contact', support_policy_url:'vgi.support_policy_url'
};
function mapTags(tags){
  const out = {};
  for (const [k, tag] of Object.entries(STRING_TAGS)) if (tags[tag]) out[k] = tags[tag];
  if (tags['vgi.keywords']) {
    try { const kw = JSON.parse(tags['vgi.keywords']); if (Array.isArray(kw)) out.keywords = kw.map(String); }
    catch (e) { /* leave keywords off */ }
  }
  return out;
}

const origin = location.origin;
const basePath = location.pathname.endsWith('/') ? location.pathname : location.pathname + '/';
const prefix = basePath.replace(/\/$/, '');
const serviceUrl = origin + basePath;
const esc = s => String(s).replace(/[&<>"]/g, c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]));
const sqlHi = s => esc(s).replace(/\b(SELECT|FROM|WHERE|GROUP BY|ORDER BY|INTERVAL|AND|OR|AS|JOIN|ON|YEAR)\b/g, m=>'<span class="kw">'+m+'</span>');

function mdToHtml(src){
  if(!src) return '';
  var lines = String(src).replace(/\r\n?/g,'\n').split('\n'), out=[], i=0;
  function inl(t){
    t = esc(t);
    t = t.replace(/`([^`]+)`/g,'<code>$1</code>');
    t = t.replace(/\*\*([^*]+)\*\*/g,'<strong>$1</strong>');
    t = t.replace(/(^|[^*])\*([^*]+)\*/g,'$1<em>$2</em>');
    t = t.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g,'<a href="$2" target="_blank" rel="noopener">$1</a>');
    return t;
  }
  // A GFM table = a row containing '|' immediately followed by a delimiter row
  // (pipes of dashes with optional alignment colons).
  var isDelim = function(s){ return s!=null && /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/.test(s) && s.indexOf('-')>=0; };
  var isTableStart = function(idx){ return idx<lines.length && lines[idx].indexOf('|')>=0 && isDelim(lines[idx+1]); };
  var splitRow = function(r){ return r.trim().replace(/^\|/,'').replace(/\|$/,'').split('|').map(function(c){return c.trim();}); };
  while(i<lines.length){
    var ln=lines[i];
    if(/^\s*$/.test(ln)){ i++; continue; }
    var h=ln.match(/^(#{1,6})\s+(.*)$/);
    if(h){ var lv=Math.min(h[1].length,6); out.push('<h'+lv+' class="md-h">'+inl(h[2])+'</h'+lv+'>'); i++; continue; }
    if(isTableStart(i)){
      var heads=splitRow(ln);
      var aligns=splitRow(lines[i+1]).map(function(s){ var l=s.charAt(0)===':', r=s.charAt(s.length-1)===':'; return (l&&r)?'center':r?'right':l?'left':''; });
      i+=2;
      var rows=[];
      while(i<lines.length && lines[i].indexOf('|')>=0 && !/^\s*$/.test(lines[i])){ rows.push(splitRow(lines[i])); i++; }
      var cell=function(tag,txt,ci){ var a=aligns[ci]?' style="text-align:'+aligns[ci]+'"':''; return '<'+tag+a+'>'+inl(txt||'')+'</'+tag+'>'; };
      var thead='<tr>'+heads.map(function(c,ci){return cell('th',c,ci);}).join('')+'</tr>';
      var tbody=rows.map(function(row){return '<tr>'+heads.map(function(_,ci){return cell('td',row[ci],ci);}).join('')+'</tr>';}).join('');
      out.push('<div class="md-tablewrap"><table class="md-table"><thead>'+thead+'</thead><tbody>'+tbody+'</tbody></table></div>');
      continue;
    }
    if(/^\s*[-*+]\s+/.test(ln)){
      var items=[];
      while(i<lines.length && /^\s*[-*+]\s+/.test(lines[i])){ items.push('<li>'+inl(lines[i].replace(/^\s*[-*+]\s+/,''))+'</li>'); i++; }
      out.push('<ul class="md-ul">'+items.join('')+'</ul>'); continue;
    }
    var para=[ln]; i++;
    while(i<lines.length && !/^\s*$/.test(lines[i]) && !/^(#{1,6}\s|\s*[-*+]\s)/.test(lines[i]) && !isTableStart(i)){ para.push(lines[i]); i++; }
    out.push('<p class="md-p">'+inl(para.join(' '))+'</p>');
  }
  return out.join('');
}
var _DDB_TYPES = {int8:'TINYINT',int16:'SMALLINT',int32:'INTEGER',int64:'BIGINT',
  uint8:'UTINYINT',uint16:'USMALLINT',uint32:'UINTEGER',uint64:'UBIGINT',
  halffloat:'FLOAT',float:'FLOAT',float32:'FLOAT',double:'DOUBLE',float64:'DOUBLE',
  bool:'BOOLEAN',boolean:'BOOLEAN',string:'VARCHAR',large_string:'VARCHAR',utf8:'VARCHAR',large_utf8:'VARCHAR',
  binary:'BLOB',large_binary:'BLOB',date32:'DATE','date32[day]':'DATE',date64:'DATE',null:'NULL',
  month_day_nano_interval:'INTERVAL'};
function duckdbType(t){
  if(!t) return t; t=String(t); var lt=t.toLowerCase();
  if(_DDB_TYPES[lt]) return _DDB_TYPES[lt];
  var d=t.match(/^dictionary<values=([^,>]+)/i); if(d) return duckdbType(d[1].trim());
  var l=t.match(/^(?:large_)?list<(?:item:\s*)?(.+)>$/i); if(l) return duckdbType(l[1].trim())+'[]';
  if(/^fixed_size_binary/i.test(t)) return 'BLOB';
  var ts=t.match(/^timestamp\[([^,\]]+)(?:,\s*tz=([^\]]+))?\]$/i); if(ts) return ts[2]?'TIMESTAMPTZ':'TIMESTAMP';
  if(/^time(32|64)\[/i.test(t)) return 'TIME';
  if(/^duration\[/i.test(t)) return 'INTERVAL';
  var dec=t.match(/^decimal(?:128|256)\((\d+),\s*(\d+)\)$/i); if(dec) return 'DECIMAL('+dec[1]+','+dec[2]+')';
  if(/^struct</i.test(t)) return 'STRUCT';
  if(/^map</i.test(t)) return 'MAP';
  return t;
}


// ── identity pill ────────────────────────────────────────────────────────────────
function renderIdentity(){
  if (!describe.oauth) return;
  const el = document.getElementById('vgi-user-info');
  const m = document.cookie.match('(^|;)\\s*_vgi_identity=([^;]+)');
  if (!m) { el.classList.add('signin'); el.innerHTML = '<span class="avatar">?</span><a class="act" href="'+prefix+'/_oauth/login">Sign in</a>'; return; }
  let p={}; try { p = JSON.parse(atob(m[2].replace(/-/g,'+').replace(/_/g,'/'))); } catch(e){}
  const display = p.email || p.preferred_username || p.name || p.sub || '';
  const src = (p.name || p.email || '?').trim();
  const initials = (src.split(/[\s@._-]+/).filter(Boolean).slice(0,2).map(w=>w[0]).join('') || '?').toUpperCase();
  el.innerHTML = (p.picture ? '<img class="avatar" src="'+esc(p.picture)+'" alt="">' : '<span class="avatar">'+esc(initials)+'</span>') +
    '<span class="email" title="'+esc(display)+'">'+esc(display)+'</span><a class="act" href="'+prefix+'/_oauth/logout">Sign out</a>';
}

// ── header ───────────────────────────────────────────────────────────────────────
function renderHeader(){
  document.title = describe.worker.name + ' \u00b7 VGI';
  document.getElementById('worker-name').textContent = describe.worker.name;
  document.getElementById('worker-doc').textContent = describe.worker.doc || '';
}

// ── state ────────────────────────────────────────────────────────────────────────
let active = 0;
const selected = {};
const cat = () => describe.catalogs[active];
const latestSpec = c => (c.data_versions && c.data_versions[0]) ? c.data_versions[0].spec : null;
const currentSpec = c => selected[c.name];
function cupolaUrl(hash){
  const c = cat(); let u = describe.cupola_base+"/?service="+encodeURIComponent(serviceUrl);
  const v = currentSpec(c); if (v) u += "&data_version_spec="+encodeURIComponent(v);
  return u + (hash||"");
}

// ── catalog picker ───────────────────────────────────────────────────────────────
function renderCatBar(){
  const bar = document.getElementById('catbar');
  if (describe.catalogs.length < 2){ bar.style.display='none'; return; }
  bar.innerHTML = '<span class="label">Catalogs</span><div class="cat-tabs">' +
    describe.catalogs.map((c,i)=>{
      const nv = (c.data_versions && c.data_versions.length) ? c.data_versions.length+' versions' : 'unversioned';
      return '<button class="cat-tab'+(i===active?' active':'')+'" data-i="'+i+'">'+esc(c.name)+' <span class="cv">'+nv+'</span></button>';
    }).join('') + '</div>';
  bar.querySelectorAll('.cat-tab').forEach(b=>b.addEventListener('click',()=>{ active=+b.dataset.i; renderAll(); }));
}

// ── catalog metadata card (vgi.* tags) ───────────────────────────────────────────
function renderCatCard(){
  const c = cat(), t = c.tags || {};
  const badge = (href, ic, label, val) => {
    const inner = icon(ic)+'<span>'+label+(val?' <b>'+esc(val)+'</b>':'')+'</span>';
    return href ? '<a class="badge'+(ic==='license'?' license':'')+'" href="'+esc(href)+'" target="_blank" rel="noopener">'+inner+'</a>'
                : '<span class="badge'+(ic==='license'?' license':'')+'">'+inner+'</span>';
  };
  let badges = '';
  if (t.source_url) badges += badge(t.source_url, 'repo', 'Repository');
  if (t.license) badges += badge(null, 'license', 'License', t.license);
  if (t.support_contact) badges += badge(t.support_contact, 'support', 'Support');
  if (t.support_policy_url) badges += badge(t.support_policy_url, 'policy', 'Support policy');
  if (c.implementation_version) badges += '<span class="badge" title="Version of the catalog implementation — the worker code serving this catalog, independent of the data version below.">'+icon('impl')+'<span>Implementation <b>v'+esc(c.implementation_version)+'</b></span></span>';
  const kw = (t.keywords && t.keywords.length)
    ? '<div class="cc-kw">'+icon('keyword')+t.keywords.map(k=>'<span class="k">'+esc(k)+'</span>').join('')+'</div>' : '';
  const by = (t.author || t.copyright)
    ? '<div class="cc-by">'+[t.author?'by '+esc(t.author):'', t.copyright?esc(t.copyright):''].filter(Boolean).join(' · ')+'</div>' : '';
  document.getElementById('cat-card').innerHTML =
    '<div class="cc-title">'+icon('catalog')+esc(t.title || c.name)+'</div>' +
    (t.doc_md ? '<div class="cc-doc">'+mdToHtml(t.doc_md)+'</div>' : '') +
    (badges ? '<div class="badges">'+badges+'</div>' : '') + kw + by;
}

// ── connect: tabbed DuckDB / Python / Node.js + data-version + attach options ─────
let connectTab = 0;
const CONNECT_TABS = [['sql','DuckDB','tab_duckdb'],['python','Python','tab_python'],['js','Node.js','tab_node']];
const TABICONS = {
  tab_duckdb: '<img class="tab-logo" src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBpZD0iRWJlbmVfMSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB2ZXJzaW9uPSIxLjEiIHZpZXdCb3g9IjAgMCA1MDAgNTAwIj4KICA8IS0tIEdlbmVyYXRvcjogQWRvYmUgSWxsdXN0cmF0b3IgMjkuMC4wLCBTVkcgRXhwb3J0IFBsdWctSW4gLiBTVkcgVmVyc2lvbjogMi4xLjAgQnVpbGQgMTg2KSAgLS0+CiAgPGRlZnM+CiAgICA8c3R5bGU+CiAgICAgIC5zdDAgewogICAgICAgIGZpbGw6ICNmZmYxMDA7CiAgICAgIH0KCiAgICAgIC5zdDEgewogICAgICAgIGZpbGw6ICMxYTFhMWE7CiAgICAgIH0KICAgIDwvc3R5bGU+CiAgPC9kZWZzPgogIDxwYXRoIGNsYXNzPSJzdDEiIGQ9Ik0yNDkuOTk5NjczNyw1MDBDMTExLjkzMjAyNjcsNTAwLDAsMzg4LjA2ODQyNSwwLDI1MC4wMDAwMjUxLDAsMTExLjkzMTgyNTksMTExLjM2MzczNzIsMCwyNDkuOTk5NjczNywwLDM4OC42MzY3MTQ1LDAsNTAwLDExMS45MzE4MjU5LDUwMCwyNTAuMDAwMDI1MWMwLDEzOC4wNjgzOTk5LTExMS45MzE3NTA2LDI0OS45OTk5NzQ5LTI1MC4wMDAzMjYzLDI0OS45OTk5NzQ5WiIvPgogIDxnPgogICAgPHBhdGggY2xhc3M9InN0MCIgZD0iTTE5MC4wNTQ1MDQ1LDE0Ni41OTA3NzI0Yy01Ni44MTg0NzI3LDAtMTAzLjQwODk4MjksNDYuNTkwODQyNy0xMDMuNDA4OTgyOSwxMDMuNDA5MjI3NiwwLDU3LjM4Njg1MDEsNDYuNTkwNTEwMiwxMDMuNDA5MjQwMSwxMDMuNDA4OTgyOSwxMDMuNDA5MjQwMSw1Ni44MTgzOTc0LDAsMTAzLjQwOTE1MjMtNDYuNTkwODU1MiwxMDMuNDA5MTUyMy0xMDMuNDA5MjQwMXMtNDYuNTkwNzU0OS0xMDMuNDA5MjQwMS0xMDMuNDA5MTUyMy0xMDMuNDA5MjI3NloiLz4KICAgIDxwYXRoIGNsYXNzPSJzdDAiIGQ9Ik0zNzYuMTM4MDU5NywyMTIuNzgzNTg3NmgtNDkuMTQ2Nzc3N3Y3NC40MzI4NzVoNDkuMTQ2Nzc3N2MyMC41NTQwMTU1LDAsMzcuMjE2NDM3NS0xNi42NjIzNDY3LDM3LjIxNjQzNzUtMzcuMjE2NDM3NXYtLjAwMDA3NTNjMC0yMC41NTQwMTU1LTE2LjY2MjQyMi0zNy4yMTYzNjIyLTM3LjIxNjQzNzUtMzcuMjE2MzYyMloiLz4KICA8L2c+Cjwvc3ZnPg==" alt="" width="15" height="15">',
  tab_python: '<svg class="tab-logo pyl" viewBox="0 0 24 24" aria-hidden="true"><title>Python</title><path d="M14.25.18l.9.2.73.26.59.3.45.32.34.34.25.34.16.33.1.3.04.26.02.2-.01.13V8.5l-.05.63-.13.55-.21.46-.26.38-.3.31-.33.25-.35.19-.35.14-.33.1-.3.07-.26.04-.21.02H8.77l-.69.05-.59.14-.5.22-.41.27-.33.32-.27.35-.2.36-.15.37-.1.35-.07.32-.04.27-.02.21v3.06H3.17l-.21-.03-.28-.07-.32-.12-.35-.18-.36-.26-.36-.36-.35-.46-.32-.59-.28-.73-.21-.88-.14-1.05-.05-1.23.06-1.22.16-1.04.24-.87.32-.71.36-.57.4-.44.42-.33.42-.24.4-.16.36-.1.32-.05.24-.01h.16l.06.01h8.16v-.83H6.18l-.01-2.75-.02-.37.05-.34.11-.31.17-.28.25-.26.31-.23.38-.2.44-.18.51-.15.58-.12.64-.1.71-.06.77-.04.84-.02 1.27.05zm-6.3 1.98l-.23.33-.08.41.08.41.23.34.33.22.41.09.41-.09.33-.22.23-.34.08-.41-.08-.41-.23-.33-.33-.22-.41-.09-.41.09zm13.09 3.95l.28.06.32.12.35.18.36.27.36.35.35.47.32.59.28.73.21.88.14 1.04.05 1.23-.06 1.23-.16 1.04-.24.86-.32.71-.36.57-.4.45-.42.33-.42.24-.4.16-.36.09-.32.05-.24.02-.16-.01h-8.22v.82h5.84l.01 2.76.02.36-.05.34-.11.31-.17.29-.25.25-.31.24-.38.2-.44.17-.51.15-.58.13-.64.09-.71.07-.77.04-.84.01-1.27-.04-1.07-.14-.9-.2-.73-.25-.59-.3-.45-.33-.34-.34-.25-.34-.16-.33-.1-.3-.04-.25-.02-.2.01-.13v-5.34l.05-.64.13-.54.21-.46.26-.38.3-.32.33-.24.35-.2.35-.14.33-.1.3-.06.26-.04.21-.02.13-.01h5.84l.69-.05.59-.14.5-.21.41-.28.33-.32.27-.35.2-.36.15-.36.1-.35.07-.32.04-.28.02-.21V6.07h2.09l.14.01zm-6.47 14.25l-.23.33-.08.41.08.41.23.33.33.23.41.08.41-.08.33-.23.23-.33.08-.41-.08-.41-.23-.33-.33-.23-.41-.08-.41.08z"/></svg>',
  tab_node: '<svg class="tab-logo ndl" viewBox="0 0 24 24" aria-hidden="true"><title>Node.js</title><path d="M11.998,24c-0.321,0-0.641-0.084-0.922-0.247l-2.936-1.737c-0.438-0.245-0.224-0.332-0.08-0.383 c0.585-0.203,0.703-0.25,1.328-0.604c0.065-0.037,0.151-0.023,0.218,0.017l2.256,1.339c0.082,0.045,0.197,0.045,0.272,0l8.795-5.076 c0.082-0.047,0.134-0.141,0.134-0.238V6.921c0-0.099-0.053-0.192-0.137-0.242l-8.791-5.072c-0.081-0.047-0.189-0.047-0.271,0 L3.075,6.68C2.99,6.729,2.936,6.825,2.936,6.921v10.15c0,0.097,0.054,0.189,0.139,0.235l2.409,1.392 c1.307,0.654,2.108-0.116,2.108-0.89V7.787c0-0.142,0.114-0.253,0.256-0.253h1.115c0.139,0,0.255,0.112,0.255,0.253v10.021 c0,1.745-0.95,2.745-2.604,2.745c-0.508,0-0.909,0-2.026-0.551L2.28,18.675c-0.57-0.329-0.922-0.945-0.922-1.604V6.921 c0-0.659,0.353-1.275,0.922-1.603l8.795-5.082c0.557-0.315,1.296-0.315,1.848,0l8.794,5.082c0.57,0.329,0.924,0.944,0.924,1.603 v10.15c0,0.659-0.354,1.273-0.924,1.604l-8.794,5.078C12.643,23.916,12.324,24,11.998,24z M19.099,13.993 c0-1.9-1.284-2.406-3.987-2.763c-2.731-0.361-3.009-0.548-3.009-1.187c0-0.528,0.235-1.233,2.258-1.233 c1.807,0,2.473,0.389,2.747,1.607c0.024,0.115,0.129,0.199,0.247,0.199h1.141c0.071,0,0.138-0.031,0.186-0.081 c0.048-0.054,0.074-0.123,0.067-0.196c-0.177-2.098-1.571-3.076-4.388-3.076c-2.508,0-4.004,1.058-4.004,2.833 c0,1.925,1.488,2.457,3.895,2.695c2.88,0.282,3.103,0.703,3.103,1.269c0,0.983-0.789,1.402-2.642,1.402 c-2.327,0-2.839-0.584-3.011-1.742c-0.02-0.124-0.126-0.215-0.253-0.215h-1.137c-0.141,0-0.254,0.112-0.254,0.253 c0,1.482,0.806,3.248,4.655,3.248C17.501,17.007,19.099,15.91,19.099,13.993z"/></svg>'
};
function attachParen(c, pinned){
  const loc = "TYPE vgi, LOCATION '"+serviceUrl+"'";
  return pinned ? loc+", DATA_VERSION '"+pinned+"'" : loc;
}
function exampleTable(c){
  // A catalog that could not be attached (a required option withheld, an
  // unsupported version) has no schemas to draw an example from.
  const s = c.schemas[0]; if (!s) return 'main.my_table';
  const t = (s.tables[0]||s.views[0]||{name:'my_table'});
  return s.path.concat(t.name).map(n=>/^[a-z_][a-z0-9_]*$/i.test(n) ? n : '"'+n.replace(/"/g,'""')+'"').join('.');
}
function connectCode(c, pinned, lang){
  const q=c.name, ex=exampleTable(c), P=attachParen(c,pinned);
  if (lang==='sql') return "INSTALL vgi FROM community;\nLOAD vgi;\n" +
    "ATTACH '"+q+"' AS "+q+"\n  ("+P+");\n\n" +
    "SELECT * FROM "+q+"."+ex+" LIMIT 10;";
  if (lang==='python') return "import haybarn as duckdb\n\n" +
    "con = duckdb.connect()\n" +
    "con.execute(\"INSTALL vgi FROM community\")\n" +
    "con.execute(\"LOAD vgi\")\n" +
    "con.execute(\"ATTACH '"+q+"' AS "+q+" ("+P+")\")\n" +
    "con.sql(\"SELECT * FROM "+q+"."+ex+" LIMIT 10\").show()";
  return "import { DuckDBInstance } from \"@haybarn/node-api\";\n\n" +
    "const db = await DuckDBInstance.create();\n" +
    "const con = await db.connect();\n" +
    "await con.run(\"INSTALL vgi FROM community\");\n" +
    "await con.run(\"LOAD vgi\");\n" +
    "await con.run(\"ATTACH '"+q+"' AS "+q+" ("+P+")\");\n" +
    "const result = await con.runAndReadAll(\"SELECT * FROM "+q+"."+ex+" LIMIT 10\");\n" +
    "console.table(result.getRows());";
}
function hlCode(code, lang){
  let h = esc(code);
  h = h.replace(/&quot;([^&]*)&quot;/g, '<span class="str">&quot;$1&quot;</span>');
  h = h.replace(/'([^']*)'/g, '<span class="str">&#39;$1&#39;</span>');
  const KW = { sql:['INSTALL','LOAD','ATTACH','AS','TYPE','LOCATION','DATA_VERSION','SELECT','FROM','LIMIT'], python:['import'], js:['import','const','await','new'] };
  (KW[lang]||[]).forEach(k=> h = h.replace(new RegExp('\\b'+k+'\\b','g'), '<span class="kw">'+k+'</span>'));
  return h;
}
function attachOptionsHtml(c){
  const opts = c.attach_options||[];
  if(!opts.length) return '';
  return '<details class="attach-opts"><summary class="ao-summary">'+icon('caret','tri')+
    '<span class="args-label" style="margin:0">Attach options</span><span class="ao-count">'+opts.length+'</span></summary>'+
    '<table class="opts"><thead><tr><th>Option</th><th>Type</th><th>Default</th><th>Description</th></tr></thead><tbody>'+
    opts.map(o=>'<tr><td class="o-name">'+esc(o.name)+
      (o.required?'<span class="o-req" title="Must be supplied at ATTACH time">required</span>':'')+
      '</td><td class="o-type">'+esc(o.type)+'</td><td class="o-def">'+esc(o.default||'—')+'</td><td class="o-desc">'+esc(o.description||'')+'</td></tr>').join('')+
    '</tbody></table></details>';
}
function renderConnect(){
  const c = cat();
  const pinned = currentSpec(c);
  const lang = CONNECT_TABS[connectTab][0];
  const code = connectCode(c, pinned, lang);
  const tabs = CONNECT_TABS.map(([k,lbl,ic],i)=>'<button class="tab'+(i===connectTab?' active':'')+'" data-i="'+i+'">'+(TABICONS[ic]||'')+esc(lbl)+'</button>').join('');
  let dv = '';
  if (c.data_versions && c.data_versions.length){
    const curLabel = pinned ? pinned : 'latest · '+latestSpec(c);
    const items = ['<button class="dvitem'+(!pinned?' sel':'')+'" data-spec="">'+
        '<span class="row1"><span class="spec">latest</span><span class="tag">tracking</span>'+(!pinned?'<span class="check">✓</span>':'')+'</span>'+
        '<span class="lbl">Always the newest version ('+esc(latestSpec(c))+')</span></button>']
      .concat(c.data_versions.map((v,i)=>
        '<button class="dvitem'+(pinned===v.spec?' sel':'')+'" data-spec="'+esc(v.spec)+'">'+
          '<span class="row1"><span class="spec">'+esc(v.spec)+'</span>'+
          (i===0?'<span class="tag">latest</span>':'<span class="tag pin">pinned</span>')+
          (pinned===v.spec?'<span class="check">✓</span>':'')+'</span>'+
          (v.label?'<span class="lbl">'+esc(v.label)+'</span>':'')+'</button>')).join('');
    dv = '<details class="dvmenu" id="dvmenu"><summary>Data version: <span class="dv-cur">'+esc(curLabel)+'</span> <span class="caret">▾</span></summary>'+
         '<div class="dvlist">'+items+'</div></details>';
  }
  document.getElementById('connect').innerHTML =
    '<div class="connect-top"><div class="tabs">'+tabs+'</div>'+dv+'</div>'+
    '<div class="attach"><button class="copy" id="copy-btn" aria-label="Copy code">Copy</button>'+hlCode(code, lang)+'</div>'+
    attachOptionsHtml(c);
  const cp = document.getElementById('copy-btn');
  cp.addEventListener('click', ()=>{
    const done=()=>{ cp.textContent='Copied'; setTimeout(()=>cp.textContent='Copy',1500); };
    if (navigator.clipboard) navigator.clipboard.writeText(code).then(done,done);
    else { const t=document.createElement('textarea'); t.value=code; document.body.appendChild(t); t.select(); try{document.execCommand('copy');}catch(e){} t.remove(); done(); }
  });
  document.querySelectorAll('#connect .tab').forEach(b=>b.addEventListener('click',()=>{ connectTab=+b.dataset.i; renderConnect(); }));
  const menu = document.getElementById('dvmenu');
  if (menu) menu.querySelectorAll('.dvitem').forEach(b=>b.addEventListener('click',()=>{
    const spec=b.dataset.spec; if(spec) selected[c.name]=spec; else delete selected[c.name];
    renderConnect(); updateCupola(); renderContents();
  }));
}
document.addEventListener('click', e=>{
  const menu = document.getElementById('dvmenu');
  if (menu && menu.open && !menu.contains(e.target)) menu.open=false;
});
function updateCupola(){ const u = cupolaUrl(""); document.getElementById('cupola-cta').href = u; const ai = document.getElementById('cupola-ai-cta'); if (ai) ai.href = u; }

// ── object rows ──────────────────────────────────────────────────────────────────
function tableRow(catName, s, t, kind){       // kind: 'table' | 'view'
  const iconName = kind==='view' ? 'view' : 'table';
  const kcls = kind==='view' ? ' view k-view' : '';
  return '<details class="tbl'+kcls+'" data-name="'+esc(t.name.toLowerCase())+'" data-kind="'+kind+'" data-catalog="'+esc(catName)+'" data-schema="'+esc(JSON.stringify(s.path))+'" data-table="'+esc(t.name)+'">'+
    '<summary>'+icon('caret','tri')+icon(iconName,'row-icon')+
      '<span class="t-name">'+esc(t.name)+'</span><span class="t-meta">'+t.cols+' cols</span></summary>'+
    '<div class="t-body">'+
      (t.comment ? '<div class="t-desc">'+mdToHtml(t.comment)+'</div>' : '')+
      (kind==='view' && t.def ? '<div class="args-label">Definition</div><pre class="view-sql">'+sqlHi(t.def)+'</pre>' : '')+
      '<div class="args-label">Columns</div><div class="cols"><div class="skeleton">Loading columns…</div></div></div></details>';
}

const FN_TYPES = [['scalar','Scalar functions','function','k-scalar'],
                  ['table','Table functions','function','k-tablefn'],
                  ['aggregate','Aggregate functions','aggregate','k-agg'],
                  ['table_in_out','Table in-out functions','tio','k-tio'],
                  ['scalar_macro','Scalar macros','function','k-macro'],
                  ['table_macro','Table macros','function','k-macro']];
function argCard(a){
  const def = (a.default!==undefined && a.default!==null) ? '<span class="arg-def">default '+esc(a.default)+'</span>' : '';
  const desc = a.desc ? esc(a.desc) : '';
  const meta = (desc||def) ? '<div class="col-comment">'+desc+(desc&&def?' · ':'')+def+'</div>' : '';
  // A macro parameter has no type at all, and `duckdbType(undefined)` returns
  // undefined — printed, that renders the literal string "undefined".
  const type = a.type ? '<span class="col-type">'+esc(duckdbType(a.type))+'</span>' : '';
  return '<div class="col-item"><div class="col"><span class="col-name">'+esc(a.name)+(a.named?'<span class="arg-kind"> :=</span>':'')+'</span>'+type+'</div>'+meta+'</div>';
}
function fnRow(f, iconName){
  const pos = f.args.filter(a=>!a.named), named = f.args.filter(a=>a.named);
  // The type is the useful half of a signature — `flood_daily(latitude,
  // longitude, forecast_days :=, past_days :=)` says nothing about what to
  // pass. `fnArgs` has resolved it all along; only this line dropped it, so
  // reading a type meant expanding the row to reach the argument cards.
  // Built as HTML rather than a string because the type carries its own span,
  // so each part is escaped individually instead of the whole line at render.
  const sigPart = a => esc(a.name) + (a.named ? ' :=' : '') +
    (a.type ? ' <span class="sig-type">' + esc(duckdbType(a.type)) + '</span>' : '');
  const sigHtml = '(' + pos.concat(named).map(sigPart).join(', ') + ')';
  let argsGrid;
  if (!f.args.length) argsGrid = '<div class="fn-noargs">No arguments</div>';
  else if (!named.length) argsGrid = '<div class="args-label">Arguments</div><div class="cols">'+pos.map(argCard).join('')+'</div>';
  else argsGrid = (pos.length ? '<div class="args-label">Positional arguments</div><div class="cols">'+pos.map(argCard).join('')+'</div>' : '')+
                  '<div class="args-label" style="margin-top:12px">Named arguments</div><div class="cols">'+named.map(argCard).join('')+'</div>';
  const ret = f.returns ? '<div class="fn-returns"><b>Returns</b><span class="rtype">'+esc(f.returns)+'</span></div>' : '';
  return '<details class="fn" data-name="'+esc(f.name.toLowerCase())+'">'+
    '<summary>'+icon('caret','tri')+icon(iconName,'row-icon')+'<span class="fn-name">'+esc(f.name)+'</span><span class="fn-sig">'+sigHtml+'</span></summary>'+
    '<div class="fn-body">'+(f.doc? '<div class="t-desc">'+mdToHtml(f.doc)+'</div>':'')+argsGrid+ret+'</div></details>';
}
function fnGroups(fns){
  if (!fns.length) return '';
  const known = FN_TYPES.map(x=>x[0]);
  let out = '';
  FN_TYPES.forEach(([t,lbl,ic,cls])=>{
    const g = fns.filter(f=>f.type===t);
    if (!g.length) return;
    out += '<div class="grp '+cls+'"><div class="glabel">'+icon(ic)+lbl+'</div>' + g.map(f=>fnRow(f,ic)).join('') + '</div>';
  });
  const other = fns.filter(f=>!known.includes(f.type));
  if (other.length) out += '<div class="grp"><div class="glabel">'+icon('function')+'Other functions</div>'+other.map(f=>fnRow(f,'function')).join('')+'</div>';
  return out;
}

// ── contents ─────────────────────────────────────────────────────────────────────
function renderContents(){
  const c = cat(), root = document.getElementById('catalogs'), cc = c.counts;
  const asof = (c.data_versions && c.data_versions.length)
    ? ' · <span class="asof">as of '+esc(currentSpec(c) || 'latest ('+latestSpec(c)+')')+'</span>' : '';
  document.getElementById('cat-sub').innerHTML =
    cc.schemas+' schemas · '+cc.tables+' tables · '+cc.views+' views · '+cc.functions+' functions'+
    (cc.macros?' · '+cc.macros+' macro'+(cc.macros!==1?'s':''):'')+asof;

  if (c.attach_error){
    // Say why the catalog could not be listed. An empty tree here would read
    // as "this catalog is empty", which is a different and wrong statement.
    root.innerHTML = '<div class="noresults">Could not list this catalog: '+esc(c.attach_error)+'</div>';
    return;
  }

  const single = c.schemas.length===1;
  root.innerHTML = c.schemas.map(s=>{
    const sMacros = s.functions.filter(f=>f.type==='scalar_macro'||f.type==='table_macro').length;
    const sFns = s.functions.length - sMacros;
    const sub = [ s.tables.length+' table'+(s.tables.length!==1?'s':''),
                  s.views.length? s.views.length+' view'+(s.views.length!==1?'s':''):null,
                  sFns? sFns+' function'+(sFns!==1?'s':''):null,
                  sMacros? sMacros+' macro'+(sMacros!==1?'s':''):null
                ].filter(Boolean).join(' · ');
    const openAttr = (single && s.tables.length<=8) ? ' open' : '';
    const tblGrp = s.tables.length ? '<div class="grp k-table"><div class="glabel">'+icon('table')+'Tables</div>'+
      s.tables.map(t=>tableRow(c.name,s,t,'table')).join('')+'</div>' : '';
    const viewGrp = s.views.length ? '<div class="grp k-view"><div class="glabel">'+icon('view')+'Views</div>'+
      s.views.map(v=>tableRow(c.name,s,v,'view')).join('')+'</div>' : '';
    const fnGrp = fnGroups(s.functions);
    const sdesc = s.doc ? '<div class="t-desc schema-desc">'+mdToHtml(s.doc)+'</div>' : '';
    return '<details class="schema" data-name="'+esc(s.name.toLowerCase())+'"'+openAttr+'>'+
      '<summary>'+icon('caret','tri')+icon('schema','type')+
        '<span class="schema-name">'+esc(s.name)+'</span><span class="schema-sub">'+sub+'</span></summary>'+
      sdesc+tblGrp+viewGrp+fnGrp+'</details>';
  }).join('');
  const f = document.getElementById('filter'); if (f.value) applyFilter();
}

// lazy-load columns on first table/view expand
document.getElementById('catalogs').addEventListener('toggle', e=>{
  const d = e.target;
  if (!d.classList || !d.classList.contains('tbl') || !d.open || d.dataset.loaded) return;
  d.dataset.loaded = '1';
  const body = d.querySelector('.cols');
  fetchColumns(d.dataset.catalog, JSON.parse(d.dataset.schema), d.dataset.table).then(info=>{
    body.innerHTML = info.columns.map(col=>
      '<div class="col-item"><div class="col"><span class="col-name">'+esc(col.name)+'</span><span class="col-type">'+esc(duckdbType(col.type))+'</span></div>'+
      (col.comment? '<div class="col-comment">'+esc(col.comment)+'</div>':'')+'</div>').join('');
  });
}, true);

// ── filter + expand/collapse all ─────────────────────────────────────────────────
function applyFilter(){
  const q = document.getElementById('filter').value.trim().toLowerCase();
  const root = document.getElementById('catalogs');
  const total = root.querySelectorAll('details.tbl, details.fn').length;
  let shown = 0;
  root.querySelectorAll('details.schema').forEach(sc=>{
    let hit = false;
    sc.querySelectorAll('details.tbl, details.fn').forEach(row=>{
      const m = !q || row.dataset.name.includes(q);
      row.classList.toggle('hidden', !m); if (m){ shown++; hit=true; }
    });
    sc.querySelectorAll('.grp').forEach(g=>{
      const any = [...g.querySelectorAll('details.tbl, details.fn')].some(x=>!x.classList.contains('hidden'));
      g.classList.toggle('hidden', q && !any);
    });
    const nameHit = !q || sc.dataset.name.includes(q);
    sc.classList.toggle('hidden', !hit && !nameHit);
    if (q && (hit || nameHit)) sc.open = true;
  });
  document.getElementById('filter-count').textContent = q ? shown+' of '+total : '';
  let nr = root.querySelector('.noresults');
  if (q && shown===0){ if(!nr){ nr=document.createElement('div'); nr.className='noresults'; nr.textContent='No matching objects.'; root.appendChild(nr);} }
  else if (nr) nr.remove();
}
document.getElementById('filter').addEventListener('input', applyFilter);
document.getElementById('expand-all').addEventListener('click', ()=>document.getElementById('catalogs').querySelectorAll('details').forEach(d=>d.open=true));
document.getElementById('collapse-all').addEventListener('click', ()=>document.getElementById('catalogs').querySelectorAll('details').forEach(d=>d.open=false));

// ── footer + first render ────────────────────────────────────────────────────────
function renderFooter(){
document.getElementById('filter-wrap').insertAdjacentHTML('afterbegin', icon('search'));
document.getElementById('footer').innerHTML =
  '<a href="'+prefix+'/describe">RPC API</a>'+
  '<div class="foot-meta">vgi-rpc (<code>'+esc(describe.worker.lang)+'</code>) · v'+esc(describe.worker.version)+' · <code>'+esc(describe.server_id)+'</code></div>'+
  '<div class="foot-meta foot-copy">&copy; 2026 \uD83D\uDE9C Query Farm LLC - <a href="https://query.farm" target="_blank" rel="noopener">https://query.farm</a></div>';
}

function renderAll(){ renderCatBar(); renderCatCard(); renderConnect(); updateCupola(); renderContents(); }
async function boot(){
  try {
    // Worker identity is not catalog data, so it comes from the worker's own
    // status document rather than the protocol.
    const res = await fetch('./?format=json', {headers:{'Accept':'application/json'}});
    if (!res.ok) throw new Error('HTTP '+res.status);
    const status = await res.json();

    // Trailing slash stripped: the client joins `base + "/" + method`, and a
    // base that already ends in "/" yields "//method" — tolerated by Python's
    // and Go's routers, a 404 from axum.
    client = new VgiClient(httpConnect(serviceUrl.replace(/\/$/, '')));
    const infos = await client.catalogsInfo();
    const catalogs = await Promise.all(infos.map(buildCatalog));

    describe = {
      worker: {
        name: status.worker || 'VGI Worker',
        doc: status.doc || '',
        version: status.version || '',
        lang: status.lang || ''
      },
      server_id: status.server_id || '',
      oauth: !!status.oauth,
      cupola_base: status.cupola_base || CUPOLA_BASE,
      catalogs
    };
  } catch (e) {
    document.getElementById('catalogs').innerHTML =
      '<div class="noresults">Could not load worker metadata (' + e + ').</div>';
    return;
  }
  renderIdentity(); renderHeader(); renderFooter(); renderAll();
}
boot();
</script>
</body>
</html>
";
@@ -14767,4 +15832,4 @@ export {
   utf82 as utf8
 };
 
-//# debugId=121A6A9C9B24594A64756E2164756E21
+//# debugId=4A48D657E6B1E41464756E2164756E21