fix: update browser catalog discovery; release 0.37.2

Author: rustyconover

.github/workflows/ci.yml

@@ -35,6 +35,11 @@ jobs:
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
 
+      - name: Install Bun for browser discovery regression tests
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.14"
+
       - name: Install dependencies
         run: uv sync --all-extras
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vgi-python"
-version = "0.37.1"
+version = "0.37.2"
 description = "Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow"
 readme = "README.md"
 keywords = [

tests/test_landing_discovery.py

@@ -0,0 +1,81 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Exercise the vendored browser client against the Python HTTP server."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import threading
+from pathlib import Path
+from wsgiref.simple_server import make_server
+
+import pyarrow as pa
+import pytest
+
+from vgi.scalar_function import ScalarFunction
+from vgi.serve import create_app
+from vgi.worker import Worker
+
+
+class _Double(ScalarFunction):
+    class Meta:
+        name = "double"
+
+    def compute(self, x: pa.Int64Array) -> pa.Int64Array:
+        return pa.compute.multiply(x, 2)
+
+
+class _LandingWorker(Worker):
+    functions = [_Double]
+
+
+@pytest.mark.skipif(shutil.which("bun") is None, reason="Bun is required to execute the shipped browser client")
+def test_served_browser_client_discovers_catalog(tmp_path: Path) -> None:
+    """A successful asset GET is insufficient: the bundle must speak the current RPC protocol."""
+    script = tmp_path / "discover.mjs"
+    script.write_text("""
+const url = process.argv[2];
+let rpc;
+try {
+  const response = await fetch(url + '/vgi-client.js');
+  if (!response.ok) throw new Error('bundle HTTP ' + response.status);
+  const path = new URL('./client.mjs', import.meta.url);
+  await Bun.write(path, await response.arrayBuffer());
+  const browser = await import(path.href);
+  rpc = browser.httpConnect(url);
+  const client = new browser.VgiClient(rpc);
+  const infos = await client.catalogsInfo();
+  if (!infos.length) throw new Error('No catalogs discovered');
+  const attached = await client.catalogAttach(infos[0].name);
+  const schemas = await client.schemas(attached.attach_opaque_data);
+  const names = [];
+  for (const schema of schemas) {
+    const functions = await client.schemaContentsFunctions(attached.attach_opaque_data, schema.path, 'SCALAR_FUNCTION');
+    names.push(...functions.map(f => f.name));
+  }
+  console.log(JSON.stringify(names));
+} catch (error) {
+  console.error(error.stack || String(error));
+  process.exitCode = 1;
+} finally {
+  rpc?.close();
+}
+""")
+    app = create_app(_LandingWorker, signing_key=b"landing-discovery-test-key")
+    with make_server("127.0.0.1", 0, app) as server:
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        try:
+            result = subprocess.run(
+                ["bun", str(script), f"http://127.0.0.1:{server.server_port}"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            assert result.returncode == 0, result.stderr
+            assert "double" in json.loads(result.stdout)
+        finally:
+            server.shutdown()
+            thread.join(timeout=5)

uv.lock

@@ -280,7 +280,7 @@
 </style>
 </head>
 <body>
-<!-- vgi-landing-asset v4 -->
+<!-- vgi-landing-asset v5 -->
 
 <a class="skip" href="#contents">Skip to contents</a>
 
@@ -362,7 +362,7 @@ <h1 id="worker-name">—</h1>
 import {
   VgiClient, httpConnect, deserializeAttachOptionSpecs, deserializeSchema,
   schemaToArgumentSpecs, TypeId
-} from './vgi-client.js';
+} 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
@@ -417,7 +417,7 @@ <h1 id="worker-name">—</h1>
 // JSON endpoint — the difference is where the bytes come from.
 const columnCache = new Map();
 async function fetchColumns(catName, schema, table){
-  const key = catName+'
+  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:[]};
@@ -480,13 +480,13 @@ <h1 id="worker-name">—</h1>
 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.name, kind).catch(()=>[]);
+  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.name),
-    client.schemaContentsViews(aod, si.name),
-    client.schemaContentsFunctions(aod, si.name, 'SCALAR_FUNCTION'),
-    client.schemaContentsFunctions(aod, si.name, 'TABLE_FUNCTION'),
-    client.schemaContentsFunctions(aod, si.name, 'AGGREGATE_FUNCTION'),
+    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')
   ]);
@@ -522,7 +522,7 @@ <h1 id="worker-name">—</h1>
     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.name, tables, views, functions};
+  const entry = {name: si.path.join('.'), path: si.path, tables, views, functions};
   if (si.comment) entry.doc = si.comment;
   return entry;
 }
@@ -563,7 +563,7 @@ <h1 id="worker-name">—</h1>
   cat.tags = mapTags(attach.tags || {});
 
   const schemaInfos = (await client.schemas(cat._aod)).slice()
-    .sort((a,b)=>a.name<b.name?-1:a.name>b.name?1:0);
+    .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
@@ -754,7 +754,7 @@ <h1 id="worker-name">—</h1>
   // 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.name+'.'+t.name;
+  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);
@@ -843,7 +843,7 @@ <h1 id="worker-name">—</h1>
 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(s.name)+'" data-table="'+esc(t.name)+'">'+
+  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">'+
@@ -948,7 +948,7 @@ <h1 id="worker-name">—</h1>
   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, d.dataset.schema, d.dataset.table).then(info=>{
+  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('');