@a2uicatalog/mcp 0.1.0

package/demo.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * demo.mjs — the GAS-first MCP loop, narrated end to end.
+ *
+ * Proves (and storyboards) what an agent does through the MCP server:
+ *   browse vocabulary → author → validate → DEPLOY to a live Apps Script app.
+ *
+ * Run:  BUILD_API_URL=… BUILD_API_TOKEN=… node demo.mjs
+ * (BYO: your own Apps Script deployment + token.)
+ */
+import { validate, buildApp } from "./server.mjs";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const DATA = join(dirname(fileURLToPath(import.meta.url)), "data");
+const step = (n, t) => console.log(`\n\x1b[36m● ${n}\x1b[0m ${t}`);
+
+step("1", "browse the vocabulary  (list_atoms / get_atom_schema)");
+const idx = JSON.parse(readFileSync(join(DATA, "atoms-index.json"), "utf8"));
+const st = JSON.parse(readFileSync(join(DATA, "a2ui-state-v1.json"), "utf8"));
+const primitiveCount = Object.keys(st.components || {}).length + Object.keys(st.functions || {}).length;
+console.log(`   ${idx.atomCount} atoms (a2ui-atoms-v1) + ${primitiveCount} state primitives (a2ui-state-v1)`);
+console.log(`   the agent speaks these — visual vocabulary + behavioral vocabulary`);
+
+step("2", "author a wired surface  (agent composes A2UI)");
+const md = `---
+id: mcp-demo-live
+domain: training
+name: "Built by an agent, over MCP"
+source: "gas-first mcp launch demo"
+license: MIT
+---
+An interactive Apps Script web app — authored by an agent, validated, deployed.
+# Steps
+## 1. Speak the vocabulary
+cmd: list_atoms
+verify: atoms returned
+## 2. Validate before deploy
+cmd: validate_payload
+verify: hallucination = parse error, not broken UI
+## 3. Ship it
+cmd: build_app
+verify: live Apps Script URL
+`;
+console.log("   composed a training.md (doc → app)");
+
+step("3", "validate  (parser catches mistakes — hallucination = parse error)");
+const good = { type: "a2ui_wired_surface", title: "demo",
+  state_primitives: [{ id: "q", primitive: "ValueStore", props: {} }],
+  actions: [], layout: [{ id: "t", atom: "data_table", wire: { rows: "#q.value" } }] };
+console.log("   valid wired surface →", JSON.stringify(validate(good).ok ? "OK" : validate(good).errors));
+const bad = { ...good, layout: [{ id: "x", atom: "totally_made_up_atom" }] };
+console.log("   hallucinated atom  → REJECTED:", validate(bad).errors[0]);
+
+step("4", "DEPLOY  (build_app → live Apps Script web app)");
+if (!process.env.BUILD_API_URL || !process.env.BUILD_API_TOKEN) {
+  console.log("   [skipped — set BUILD_API_URL + BUILD_API_TOKEN to deploy live]");
+} else {
+  const r = await buildApp(md);
+  console.log(r.ok ? `   ✅ LIVE: ${r.url}` : `   build failed`);
+}
+console.log("\n\x1b[32mThat's the loop.\x1b[0m Author → validate → live GAS app, over MCP. No code.\n");

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@a2uicatalog/mcp",
+  "version": "0.1.0",
+  "description": "Local MCP server for the A2UI Atomic Catalog: browse the 474-atom vocabulary, validate a payload (hallucinated atom = parse error, not a broken screen), get a shareable preview URL, and deploy a training.md to your own Google Apps Script. Pure-local for browsing/validation — no network, no secret, no account.",
+  "type": "module",
+  "bin": { "a2uicatalog-mcp": "server.mjs" },
+  "engines": { "node": ">=18" },
+  "license": "MIT",
+  "author": "Curtis Krygier",
+  "homepage": "https://a2uicatalog.ai",
+  "repository": { "type": "git", "url": "git+https://github.com/a2uicatalog/a2ui.git", "directory": "mcp" },
+  "bugs": "https://github.com/a2uicatalog/a2ui/issues",
+  "keywords": ["mcp", "model-context-protocol", "a2ui", "ui-generation", "claude", "agent", "google-apps-script"],
+  "files": ["server.mjs", "demo.mjs", "test.mjs", "scripts", "data", "README.md"],
+  "scripts": {
+    "test": "node test.mjs",
+    "demo": "node demo.mjs",
+    "sync-data": "node scripts/sync-data.mjs",
+    "prepublishOnly": "npm run sync-data && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  }
+}

package/scripts/sync-data.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * sync-data.mjs — refresh mcp/data/, the bundled catalog snapshot @a2uicatalog/mcp
+ * ships with.
+ *
+ * server.mjs used to read these files via a relative "../" path straight out
+ * of the a2ui-catalogue repo tree (public/atoms/index.json, public/spec.json,
+ * public/catalogue/a2ui-state-v1.json, payloads/*.json). That works from a
+ * git checkout but breaks the moment this package is actually published and
+ * installed standalone (`npm install @a2uicatalog/mcp`): only mcp/'s own files ship
+ * in the tarball, so "../public/..." would resolve to node_modules/@a2uicatalog/'s
+ * parent, not this repo — a crash on first run for every real installer,
+ * caught here (2026-07-31) before ever publishing. Fetching the same data
+ * live from a2uicatalog.ai at runtime was the other option; deliberately
+ * NOT taken, because list_atoms/get_atom_schema/validate_payload/encode_url
+ * are documented and designed as pure-local, no-network tools (see README's
+ * Security section) — bundling a point-in-time snapshot keeps that promise.
+ *
+ * Run after any atom-change / state-catalog change, and always before
+ * `npm publish` (also wired as this package's own prepublishOnly hook —
+ * belt + braces, matches the repo's own "declare it, don't improvise it"
+ * discipline: see ops/project-ops.yaml's mcp-sdk-sync-data process).
+ */
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const MCP_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const REPO_ROOT = join(MCP_ROOT, "..");
+const DATA_DIR = join(MCP_ROOT, "data");
+
+const FILES = [
+  ["public/atoms/index.json", "atoms-index.json"],
+  ["public/spec.json", "spec.json"],
+  ["public/catalogue/a2ui-state-v1.json", "a2ui-state-v1.json"],
+  ["payloads/expenses-demo.json", "expenses-demo.json"],
+  ["payloads/artemis-roadmap.json", "artemis-roadmap.json"],
+];
+
+mkdirSync(DATA_DIR, { recursive: true });
+for (const [src, dest] of FILES) {
+  const content = readFileSync(join(REPO_ROOT, src), "utf8");
+  JSON.parse(content); // fail loudly on a malformed source rather than bundle garbage
+  writeFileSync(join(DATA_DIR, dest), content);
+  console.log(`  ${src} -> mcp/data/${dest} (${(content.length / 1024).toFixed(0)} KB)`);
+}
+console.log(`synced ${FILES.length} files into mcp/data/`);

package/server.mjs

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+/**
+ * a2uicatalog-mcp — local MCP server for the A2UI Atomic Catalog.
+ *
+ * Implements the official A2UI-over-MCP pattern (a2ui.org/guides/a2ui_over_mcp):
+ * an agent browses the atom vocabulary, authors a wired surface, validates it
+ * (a hallucinated atom is a parse error, not a broken screen), and either gets
+ * a shareable preview URL or deploys straight to its own Google Apps Script.
+ *
+ * list_atoms / get_atom_schema / validate_payload / encode_url / get_ui are
+ * pure-local: bundled catalog data (mcp/data/, see scripts/sync-data.mjs),
+ * no secret, no network. build_app is the one tool that calls out — to the
+ * caller's OWN Apps Script deployment, with the caller's own token (BYO,
+ * never a shared secret; see README's Security section). stdio transport.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { gzipSync } from "zlib";
+
+// Bundled inside THIS package (mcp/data/, synced by scripts/sync-data.mjs)
+// rather than read via "../public/..." out of the wider a2ui-catalogue repo
+// tree — that relative path only resolves in a git checkout of the whole
+// monorepo, and breaks the moment this package is installed standalone
+// (`npm install @a2uicatalog/mcp` ships only mcp/'s own files). See sync-data.mjs's
+// header for why bundling a snapshot, not a live fetch, is the fix.
+const DATA = join(dirname(fileURLToPath(import.meta.url)), "data");
+const A2UI_MIME = "application/a2ui+json";
+
+// ── bundled, public, read-only ──────────────────────────────────────────────
+const index = JSON.parse(readFileSync(join(DATA, "atoms-index.json"), "utf8"));
+const ATOMS = new Map(index.atoms.map((a) => [a.type, a]));
+// Full field contracts (for get_atom_schema) from the published spec.
+const SPEC = JSON.parse(readFileSync(join(DATA, "spec.json"), "utf8"));
+const ATOM_SPEC = new Map(SPEC.atoms.map((a) => [a.type, a]));
+for (const a of SPEC.atoms) for (const al of a.aliases || []) ATOM_SPEC.set(al, a);
+// Resolve published aliases (data_table -> data_table_sortable) from the catalog.
+for (const a of index.atoms) for (const al of a.aliases || []) ATOMS.set(al, a);
+// The a2ui-state catalog: the behavioral vocabulary a wired surface also speaks.
+// Migrated to the A2UI-v1.0 catalog shape (components/functions objects keyed
+// by name) since this file was last touched — the old flat `primitives` array
+// with `.id` fields no longer exists (confirmed broken here, 2026-07-31: this
+// package's own test.mjs threw on startup). STATE_PRIMITIVES is the union of
+// both — a wired surface's state_primitives can reference either a stateful
+// component (ValueStore, ...) or a derived-value function (elapsed_seconds, ...).
+const stateCatalog = JSON.parse(readFileSync(join(DATA, "a2ui-state-v1.json"), "utf8"));
+const STATE_PRIMITIVE_DOCS = new Map([
+  ...Object.entries(stateCatalog.components || {}),
+  ...Object.entries(stateCatalog.functions || {}),
+]);
+const STATE_PRIMITIVES = new Set(STATE_PRIMITIVE_DOCS.keys());
+// Reference wired UIs served over MCP (public payloads only).
+const UIS = {
+  "expenses-demo": "expenses-demo.json",
+  "artemis-roadmap": "artemis-roadmap.json",
+};
+function loadUI(name) {
+  return JSON.parse(readFileSync(join(DATA, UIS[name]), "utf8"));
+}
+
+// Structural layout wrappers (not atoms). Atom aliases now resolve from the
+// PUBLISHED catalog (ATOMS includes them), so the earlier harvest hack is gone —
+// the validator references the real a2ui-atoms-v1 + a2ui-state-v1 catalogs.
+const WIRED_ATOMS = new Set(["row_open", "row_close", "subheading", "body", "divider", "jump_nav"]);
+// carry over any layout atoms used in reference UIs not yet promoted to schema
+for (const name of Object.keys(UIS)) {
+  for (const el of loadUI(name).layout || []) {
+    const t = el.atom || el.type;
+    if (t && !ATOMS.has(t)) WIRED_ATOMS.add(t);
+  }
+}
+
+// Structural validation: every layout atom's type must be a known atom, and a
+// wired surface's wires must reference declared nodes. (No execution.)
+function validate(payload) {
+  const errors = [];
+  const layout = payload.layout || [];
+  const nodeIds = new Set([
+    ...(payload.state_primitives || []).map((p) => p.id),
+    ...(payload.actions || []).map((a) => a.id),
+    ...layout.map((el) => el.id).filter(Boolean),
+  ]);
+  const known = (t) => ATOMS.has(t) || WIRED_ATOMS.has(t);
+  // state_primitives validate against the a2ui-state catalog (the behavioral half)
+  for (const p of payload.state_primitives || []) {
+    if (p.primitive && !STATE_PRIMITIVES.has(p.primitive)) {
+      errors.push(`unknown state primitive: ${p.primitive} (id ${p.id || "?"})`);
+    }
+  }
+  for (const el of layout) {
+    const t = el.atom || el.type;
+    if (t && !known(t)) errors.push(`unknown atom type: ${t} (id ${el.id || "?"})`);
+    for (const expr of Object.values(el.wire || {})) {
+      const m = /^#(\w+)\./.exec(String(expr));
+      if (m && !nodeIds.has(m[1])) errors.push(`wire references undeclared node #${m[1]} (id ${el.id || "?"})`);
+    }
+  }
+  const wired = payload.type === "a2ui_wired_surface";
+  return {
+    ok: errors.length === 0,
+    wired,
+    counts: { atoms: layout.length, state: (payload.state_primitives || []).length, actions: (payload.actions || []).length },
+    errors,
+  };
+}
+
+function encodeUrl(payload, base = "<public_exec>") {
+  const enc = gzipSync(Buffer.from(JSON.stringify(payload))).toString("base64url");
+  return `${base}/exec?p=${enc}`;
+}
+
+const MAX_INPUT = 256 * 1024; // 256KB cap on agent-supplied payloads/docs
+// Never let a token surface in any response/error text (query-param token leak guard).
+function redact(text) {
+  let t = String(text);
+  if (process.env.BUILD_API_TOKEN) t = t.split(process.env.BUILD_API_TOKEN).join("***");
+  return t.replace(/([?&]token=)[^&\s"']+/gi, "$1***");
+}
+function tooBig(s) { return typeof s === "string" && s.length > MAX_INPUT; }
+
+const server = new McpServer({ name: "a2uicatalog-mcp", version: "0.1.0" });
+
+// ── OFFICIAL SERVING PATTERN: A2UI as MCP Resource (application/a2ui+json) ──
+for (const name of Object.keys(UIS)) {
+  server.registerResource(
+    name,
+    `a2ui://${name}`,
+    { title: `A2UI: ${name}`, description: `Wired A2UI surface (${name})`, mimeType: A2UI_MIME },
+    async (uri) => ({
+      contents: [{ uri: uri.href, mimeType: A2UI_MIME, text: JSON.stringify(loadUI(name)) }],
+    })
+  );
+}
+
+// ── OFFICIAL SERVING PATTERN: dynamic UI via Tool -> EmbeddedResource ──
+server.registerTool(
+  "get_ui",
+  { title: "Get A2UI surface", description: "Return a wired A2UI surface as an EmbeddedResource (application/a2ui+json).",
+    inputSchema: { name: z.enum(Object.keys(UIS)) } },
+  async ({ name }) => {
+    const payload = loadUI(name);
+    return {
+      content: [{ type: "resource", resource: { uri: `a2ui://${name}`, mimeType: A2UI_MIME, text: JSON.stringify(payload) } }],
+    };
+  }
+);
+
+// ── AUTHORING TOOLS: vocabulary + validation (the wired-authoring surface) ──
+server.registerTool(
+  "list_atoms",
+  { title: "List A2UI atoms", description: "Browse the atom vocabulary (compact descriptions).",
+    inputSchema: { query: z.string().optional() } },
+  async ({ query }) => {
+    let atoms = index.atoms;
+    if (query) atoms = atoms.filter((a) => (a.type + " " + a.compact).toLowerCase().includes(query.toLowerCase()));
+    return { content: [{ type: "text", text: JSON.stringify(atoms.slice(0, 40).map((a) => ({ type: a.type, compact: a.compact })), null, 1) }] };
+  }
+);
+
+server.registerTool(
+  "get_atom_schema",
+  { title: "Get an atom's field contract",
+    description: "Full field contract + surfaces for one atom (or state primitive), from the published catalogs.",
+    inputSchema: { type: z.string().describe("atom type or state primitive id") } },
+  async ({ type }) => {
+    const atom = ATOM_SPEC.get(type);
+    if (atom) return { content: [{ type: "text", text: JSON.stringify(atom, null, 1) }] };
+    const prim = STATE_PRIMITIVE_DOCS.get(type);
+    if (prim) return { content: [{ type: "text", text: JSON.stringify({ id: type, ...prim, catalog: "a2ui-state-v1" }, null, 1) }] };
+    return { isError: true, content: [{ type: "text", text: `unknown type: ${type} — not in a2ui-atoms-v1 or a2ui-state-v1` }] };
+  }
+);
+
+server.registerTool(
+  "validate_payload",
+  { title: "Validate an A2UI payload", description: "Structural validation of an authored A2UI payload (atom types + wire references). No execution.",
+    inputSchema: { payload: z.any() } },
+  async ({ payload }) => {
+    if (tooBig(JSON.stringify(payload))) return { isError: true, content: [{ type: "text", text: `payload too large (max ${MAX_INPUT} bytes)` }] };
+    return { content: [{ type: "text", text: JSON.stringify(validate(payload), null, 1) }] };
+  }
+);
+
+server.registerTool(
+  "encode_url",
+  { title: "Encode preview URL", description: "gzip+base64url an A2UI payload into a renderer ?p= URL.",
+    inputSchema: { payload: z.any() } },
+  async ({ payload }) => ({ content: [{ type: "text", text: encodeUrl(payload) }] })
+);
+
+// ── THE KILLER TOOL: build_app — author -> Build API -> LIVE Apps Script URL ──
+// BYO-local: BUILD_API_URL + BUILD_API_TOKEN come from the dev's own env; this
+// deploys to the DEV's own Apps Script, never a shared surface. Token never in code.
+server.registerTool(
+  "build_app",
+  { title: "Build a live Apps Script web app",
+    description: "Deploy a training.md document to YOUR Apps Script via the A2UI Build API — returns a live GAS web app URL. Requires env BUILD_API_URL and BUILD_API_TOKEN (BYO, local).",
+    inputSchema: { training_md: z.string().describe("A compliant training.md document") } },
+  async ({ training_md }) => {
+    const url = process.env.BUILD_API_URL, token = process.env.BUILD_API_TOKEN;
+    if (!url || !token) {
+      return { isError: true, content: [{ type: "text", text: "Set BUILD_API_URL and BUILD_API_TOKEN in your environment (BYO Apps Script). The build tool never carries a token in code." }] };
+    }
+    if (tooBig(training_md)) return { isError: true, content: [{ type: "text", text: `training_md too large (max ${MAX_INPUT} bytes)` }] };
+    try {
+      const res = await fetch(`${url}?api=training&token=${encodeURIComponent(token)}`, {
+        method: "POST", headers: { "Content-Type": "text/plain" }, body: training_md,
+      });
+      const body = await res.json();
+      if (!body.ok) return { isError: true, content: [{ type: "text", text: redact("Build failed: " + (body.error || JSON.stringify(body))) }] };
+      return { content: [{ type: "text", text: JSON.stringify({ ok: true, url: body.url, coverage: body.coverage, steps: body.steps, warnings: body.warnings }, null, 1) }] };
+    } catch (e) {
+      return { isError: true, content: [{ type: "text", text: redact("build_app error: " + (e.message || String(e))) }] };
+    }
+  }
+);
+
+export async function buildApp(training_md) {
+  const url = process.env.BUILD_API_URL, token = process.env.BUILD_API_TOKEN;
+  const res = await fetch(`${url}?api=training&token=${encodeURIComponent(token)}`,
+    { method: "POST", headers: { "Content-Type": "text/plain" }, body: training_md });
+  return res.json();
+}
+
+// Export internals for the test harness (when imported, not run over stdio).
+export { validate, encodeUrl, loadUI, ATOMS };
+
+if (process.argv[1] && process.argv[1].endsWith("server.mjs")) {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("a2uicatalog-mcp test harness on stdio");
+}

package/test.mjs

@@ -0,0 +1,70 @@
+import { validate, encodeUrl, loadUI, ATOMS } from './server.mjs';
+import { gunzipSync } from 'zlib';
+
+let fails = 0;
+const ok = (c, m) => { console.log((c ? '✅' : '❌') + ' ' + m); if (!c) fails++; };
+
+console.log('=== TEST 1: does WIRED state survive the official MCP carry? ===');
+// Serve a wired payload the way get_ui does: wrap as EmbeddedResource(application/a2ui+json)
+const original = loadUI('expenses-demo');
+const embedded = { type: 'resource', resource: { uri: 'a2ui://expenses-demo', mimeType: 'application/a2ui+json', text: JSON.stringify(original) } };
+// Client side: unwrap and re-parse
+const carried = JSON.parse(embedded.resource.text);
+ok(embedded.resource.mimeType === 'application/a2ui+json', 'carried with the A2UI content type');
+ok(carried.type === 'a2ui_wired_surface', 'payload is a WIRED surface after carry');
+ok(carried.state_primitives.length === original.state_primitives.length && carried.state_primitives.length === 6, 'state_primitives intact through EmbeddedResource (6)');
+ok(carried.actions.length === 2, 'actions intact (2)');
+const wiresIn = original.layout.filter(el => el.wire).length;
+const wiresOut = carried.layout.filter(el => el.wire).length;
+ok(wiresIn === wiresOut && wiresIn > 0, `wire graph intact (${wiresOut} wired atoms)`);
+ok(JSON.stringify(carried) === JSON.stringify(original), 'byte-identical: MCP carried the full wired substrate, lost nothing');
+
+console.log('\n=== TEST 2: can an agent AUTHOR a valid wired surface from the vocabulary? ===');
+// Act as the agent: compose a NEW wired surface using atoms + a ValueStore + an ArrayFilter,
+// wiring a text input -> filter -> table. (The catalogue-as-vocabulary authoring path.)
+const authored = {
+  type: 'a2ui_wired_surface',
+  title: 'Authored: filterable list',
+  state_primitives: [
+    { id: 'q', primitive: 'ValueStore', props: { defaultValue: '' } },
+    { id: 'flt', primitive: 'ArrayFilter', props: { source: '#load.result', field: 'name', match: '#q.value' } }
+  ],
+  actions: [ { id: 'load', type: 'gas:store_read', trigger: 'onLoad', props: { agent_id: 'demo', store: 'items' } } ],
+  layout: [
+    { id: 'h', atom: 'subheading', props: { text: 'Items' } },
+    { id: 'search', atom: 'form_input', props: { label: 'Filter' }, wire: { onChange: '#q.setValue' } },
+    { id: 'tbl', atom: 'data_table', props: { columns: ['name', 'qty'] }, wire: { rows: '#flt.result' } }
+  ]
+};
+const v = validate(authored);
+ok(v.wired, 'authored payload is a wired surface');
+ok(v.ok, 'authored wired surface VALIDATES: ' + (v.ok ? 'clean' : JSON.stringify(v.errors)));
+ok(v.counts.state === 2 && v.counts.actions === 1, `agent wired 2 state primitives + 1 action`);
+
+console.log('\n=== TEST 2b: does the validator CATCH a hallucinated atom / bad wire? ===');
+const bad = JSON.parse(JSON.stringify(authored));
+bad.layout.push({ id: 'x', atom: 'quantum_flux_capacitor', props: {} });      // hallucinated atom
+bad.layout.push({ id: 'y', atom: 'body', wire: { text: '#nonexistent.value' } }); // dangling wire
+const vb = validate(bad);
+ok(!vb.ok, 'invalid payload REJECTED (hallucination = parse error, not broken UI)');
+ok(vb.errors.some(e => e.includes('quantum_flux_capacitor')), 'caught the hallucinated atom by name');
+ok(vb.errors.some(e => e.includes('#nonexistent')), 'caught the dangling wire reference');
+
+console.log('\nencoded preview URL sample:', encodeUrl(authored).slice(0, 70) + '…');
+
+console.log('\n=== TEST 3: catalogs closed — validator resolves alias + state primitive from PUBLISHED artifacts ===');
+import { validate as v3 } from './server.mjs';
+// data_table (alias) + ArrayFilter/ValueStore (state catalog) — all from published catalogs now
+const both = {
+  type: 'a2ui_wired_surface', title: 'both catalogs',
+  state_primitives: [ { id: 'q', primitive: 'ValueStore', props: {} }, { id: 'f', primitive: 'ArrayFilter', props: { source: '#a.result', field: 'x', match: '#q.value' } } ],
+  actions: [ { id: 'a', type: 'gas:store_read', props: {} } ],
+  layout: [ { id: 't', atom: 'data_table', wire: { rows: '#f.result' } } ]  // data_table = published alias
+};
+const rb = v3(both);
+ok3(rb.ok, 'data_table (alias) + ValueStore/ArrayFilter (state catalog) all validate from PUBLISHED catalogs: ' + (rb.ok ? 'clean' : JSON.stringify(rb.errors)));
+const badState = { ...both, state_primitives: [ { id: 'z', primitive: 'QuantumStore', props: {} } ] };
+const rz = v3(badState);
+ok3(!rz.ok && rz.errors.some(e => e.includes('QuantumStore')), 'unknown state primitive REJECTED by name (state catalog enforced)');
+function ok3(c, m){ console.log((c?'✅':'❌')+' '+m); if(!c) process.exitCode = 1; }
+process.exit(fails || process.exitCode || 0);