api_binding_ui 3.0.0 → 3.2.0

package/dist/app/index.html

@@ -2,6 +2,6 @@
 <html lang="en">
 <head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>Bind API</title>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=JetBrains+Mono:wght@500;600&display=swap" />
-<style>html, body, #root { height: 100%; margin: 0; overflow: hidden; background: #f8fafc; }</style><link rel="stylesheet" crossorigin href="./index-aaxy714b.css"><script type="module" crossorigin src="./index-0n23yy5r.js"></script></head>
+<style>html, body, #root { height: 100%; margin: 0; overflow: hidden; background: #f8fafc; }</style><link rel="stylesheet" crossorigin href="./index-aaxy714b.css"><script type="module" crossorigin src="./index-xww2x0kd.js"></script></head>
 <body><div id="root"></div></body>
 </html>

package/dist/cli/scan.d.ts

@@ -0,0 +1,2 @@
+import type { BindingsFile, ValidationIssue } from "../framework/contract";
+export declare function scanIds(dir: string, file: BindingsFile): Promise<ValidationIssue[]>;

package/dist/cli.js

@@ -2,98 +2,11 @@
 
 // src/cli/cli.ts
 import { createServer } from "node:http";
-import { promises as fs2 } from "node:fs";
-import path2 from "node:path";
-import { fileURLToPath } from "node:url";
-
-// src/framework/names.ts
-function humanize(id) {
-  const s = id.replace(/^\$\.?/, "").replace(/\[\*\]/g, "").split(/[./]/).filter(Boolean).pop() ?? id;
-  const w = s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase().trim();
-  return w ? w[0].toUpperCase() + w.slice(1) : id;
-}
+import path4 from "node:path";
 
-// src/framework/file.ts
-var ID = /^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/;
-var BINDING_TYPES = new Set(["operation", "expression", "steps", "none"]);
-function parseBindingsFile(text) {
-  let data;
-  try {
-    data = JSON.parse(text);
-  } catch {
-    throw new Error("The bindings file is not valid JSON.");
-  }
-  const f = data;
-  if (!f || typeof f !== "object")
-    throw new Error("The bindings file must be a JSON object.");
-  if (f.version !== 3)
-    throw new Error(`The bindings file must have "version": 3.`);
-  if (typeof f.openapi !== "string" || !f.openapi)
-    throw new Error(`The bindings file needs "openapi": the docs URL or a path.`);
-  for (const k of ["kinds", "screens", "components", "bindings"])
-    if (!Array.isArray(f[k]))
-      throw new Error(`"${k}" must be a list.`);
-  f.bindings.forEach((b, i) => {
-    const x = b;
-    if (!x || typeof x.component !== "string" || typeof x.slot !== "string" || !BINDING_TYPES.has(x.type))
-      throw new Error(`Binding ${i + 1} needs "component", "slot" and a known "type".`);
-  });
-  if (f.output && (typeof f.output.dir !== "string" || typeof f.output.client !== "string"))
-    throw new Error(`"output" needs "dir" and "client".`);
-  return f;
-}
-function screenOf(id, screens) {
-  let best;
-  for (const s of screens)
-    if (id.startsWith(s + ".") && (!best || s.length > best.length))
-      best = s;
-  return best;
-}
-function productLabel(seg, catalog) {
-  const names = new Set(catalog.operations.map((o) => o.product).filter((p) => !!p));
-  return [...names].find((n) => n.toLowerCase().replace(/[^a-z0-9]+/g, "-") === seg) ?? humanize(seg);
-}
-function fromFile(file, catalog) {
-  const issues = [];
-  const ids = file.screens.map((s) => s.id);
-  const screens = file.screens.map((s) => ({
-    id: s.id,
-    label: s.label,
-    description: s.description,
-    context: s.context ?? [],
-    components: [],
-    path: [productLabel(s.id.split(".")[0], catalog)],
-    parent: screenOf(s.id, ids)
-  }));
-  const byId = new Map(screens.map((s) => [s.id, s]));
-  const screenIds = new Set(ids);
-  for (const c of file.components) {
-    if (screenIds.has(c.id)) {
-      issues.push({ severity: "error", screen: c.id, component: c.id, code: "registry.id-clash", message: `"${c.id}" is both a screen and a component id.` });
-      continue;
-    }
-    const s = screenOf(c.id, ids);
-    if (!s) {
-      issues.push({ severity: "error", screen: "", component: c.id, code: "registry.no-screen", message: `"${c.id}" starts with no registered screen id.` });
-      continue;
-    }
-    byId.get(s).components.push({ bindId: c.id, kind: c.kind, label: c.label, parent: c.parent, info: c.info });
-  }
-  const index = {};
-  for (const b of file.bindings) {
-    const s = screenOf(b.component, ids);
-    if (!s) {
-      issues.push({ severity: "error", screen: "", component: b.component, slot: b.slot, code: "binding.no-screen", message: `Binding for "${b.component}" fits no screen.` });
-      continue;
-    }
-    (index[s] ??= []).push(b);
-  }
-  return {
-    fw: { descriptors: file.kinds, registry: { registryVersion: 1, screens }, catalog, glossaries: file.glossaries },
-    index,
-    issues
-  };
-}
+// src/codegen/write.ts
+import { promises as fs3 } from "node:fs";
+import path3 from "node:path";
 
 // src/framework/loadCatalog.ts
 import { parse } from "yaml";
@@ -270,6 +183,140 @@ function parse2(expr) {
   return parsed;
 }
 
+// src/framework/names.ts
+function humanize(id) {
+  const s = id.replace(/^\$\.?/, "").replace(/\[\*\]/g, "").split(/[./]/).filter(Boolean).pop() ?? id;
+  const w = s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase().trim();
+  return w ? w[0].toUpperCase() + w.slice(1) : id;
+}
+
+// src/framework/file.ts
+var ID = /^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/;
+var BINDING_TYPES = new Set(["operation", "expression", "steps", "none"]);
+function parseBindingsFile(text) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new Error("The bindings file is not valid JSON.");
+  }
+  return checkBindingsFile(data);
+}
+function checkBindingsFile(data) {
+  const f = data;
+  if (!f || typeof f !== "object")
+    throw new Error("The bindings file must be a JSON object.");
+  if (f.version !== 3)
+    throw new Error(`The bindings file must have "version": 3.`);
+  if (typeof f.openapi !== "string" || !f.openapi)
+    throw new Error(`The bindings file needs "openapi": the docs URL or a path.`);
+  for (const k of ["kinds", "screens", "components", "bindings"])
+    if (!Array.isArray(f[k]))
+      throw new Error(`"${k}" must be a list.`);
+  f.bindings.forEach((b, i) => {
+    const x = b;
+    if (!x || typeof x.component !== "string" || typeof x.slot !== "string" || !BINDING_TYPES.has(x.type))
+      throw new Error(`Binding ${i + 1} needs "component", "slot" and a known "type".`);
+  });
+  if (f.output && (typeof f.output.dir !== "string" || typeof f.output.client !== "string"))
+    throw new Error(`"output" needs "dir" and "client".`);
+  return f;
+}
+var REGISTRY_KEYS = ["kinds", "screens", "components"];
+function parseRegistry(text) {
+  let r;
+  try {
+    r = JSON.parse(text);
+  } catch {
+    throw new Error("The registry file is not valid JSON.");
+  }
+  if (!r || r.version !== 1)
+    throw new Error(`The registry file must have "version": 1.`);
+  if (!Array.isArray(r.kinds) || !Array.isArray(r.screens))
+    throw new Error(`The registry file needs "kinds" and "screens" lists.`);
+  const screens = [];
+  const components = [];
+  const under = (id, owner, what) => {
+    if (typeof id !== "string" || !id)
+      throw new Error(`A ${what} in the registry has no "id".`);
+    if (owner && !id.startsWith(owner + "."))
+      throw new Error(`"${id}" must start with "${owner}.", the id it is nested under.`);
+  };
+  const node = (n, owner, parent) => {
+    under(n.id, owner, "component");
+    if (typeof n.kind !== "string" || typeof n.label !== "string")
+      throw new Error(`"${n.id}" needs "kind" and "label".`);
+    const { children, ...c } = n;
+    components.push(parent ? { ...c, parent } : c);
+    for (const ch of children ?? [])
+      node(ch, n.id, n.id);
+  };
+  const screen = (s, owner) => {
+    under(s.id, owner, "screen");
+    const { components: cs, screens: subs, ...rest } = s;
+    screens.push(rest);
+    for (const c of cs ?? [])
+      node(c, s.id);
+    for (const sub of subs ?? [])
+      screen(sub, s.id);
+  };
+  for (const s of r.screens)
+    screen(s);
+  return { kinds: r.kinds, screens, components };
+}
+function screenOf(id, screens) {
+  let best;
+  for (const s of screens)
+    if (id.startsWith(s + ".") && (!best || s.length > best.length))
+      best = s;
+  return best;
+}
+function productLabel(seg, catalog) {
+  const names = new Set(catalog.operations.map((o) => o.product).filter((p) => !!p));
+  return [...names].find((n) => n.toLowerCase().replace(/[^a-z0-9]+/g, "-") === seg) ?? humanize(seg);
+}
+function fromFile(file, catalog) {
+  const issues = [];
+  const ids = file.screens.map((s) => s.id);
+  const screens = file.screens.map((s) => ({
+    id: s.id,
+    label: s.label,
+    description: s.description,
+    context: s.context ?? [],
+    components: [],
+    path: [productLabel(s.id.split(".")[0], catalog)],
+    parent: screenOf(s.id, ids)
+  }));
+  const byId = new Map(screens.map((s) => [s.id, s]));
+  const screenIds = new Set(ids);
+  for (const c of file.components) {
+    if (screenIds.has(c.id)) {
+      issues.push({ severity: "error", screen: c.id, component: c.id, code: "registry.id-clash", message: `"${c.id}" is both a screen and a component id.` });
+      continue;
+    }
+    const s = screenOf(c.id, ids);
+    if (!s) {
+      issues.push({ severity: "error", screen: "", component: c.id, code: "registry.no-screen", message: `"${c.id}" starts with no registered screen id.` });
+      continue;
+    }
+    byId.get(s).components.push({ bindId: c.id, kind: c.kind, label: c.label, parent: c.parent, info: c.info });
+  }
+  const index = {};
+  for (const b of file.bindings) {
+    const s = screenOf(b.component, ids);
+    if (!s) {
+      issues.push({ severity: "error", screen: "", component: b.component, slot: b.slot, code: "binding.no-screen", message: `Binding for "${b.component}" fits no screen.` });
+      continue;
+    }
+    (index[s] ??= []).push(b);
+  }
+  return {
+    fw: { descriptors: file.kinds, registry: { registryVersion: 1, screens }, catalog, glossaries: file.glossaries },
+    index,
+    issues
+  };
+}
+
 // src/framework/schema.ts
 var obj = (s) => s && typeof s === "object" ? s : {};
 function flat(s) {
@@ -531,11 +578,18 @@ function compileCall(op, request, cx, scope, at) {
   });
   if (op.body) {
     const set = new Set(Object.keys(request).filter((k) => k.startsWith("/body/")).map((k) => decode(k.split("/")[2])));
-    const gaps = whole ? [] : (flat(op.body.schema).required ?? []).filter((f) => !set.has(f));
+    const schema = flat(op.body.schema);
+    const unset = whole ? [] : (schema.required ?? []).filter((f) => !set.has(f));
+    const empty = unset.filter((f) => {
+      const p = flat(schema.properties?.[f]);
+      return p.type === "object" && !p.required?.length;
+    });
+    const gaps = unset.filter((f) => !empty.includes(f));
     if (gaps.length)
       cx.warn("request.required-body", `${op.id} requires ${gaps.join(", ")} in its body; not connected.`, at);
     cx.use.add("assemble");
-    args.push(`assemble(${whole ?? "undefined"}, [${body.join(", ")}])`);
+    const base = whole ?? (empty.length ? `{ ${empty.map((f) => `${prop(f)}: {}`).join(", ")} }` : "undefined");
+    args.push(`assemble(${base}, [${body.join(", ")}])`);
   }
   if (op.parameters.some((p) => p.pointer.startsWith("/query/"))) {
     cx.use.add("defined");
@@ -763,16 +817,148 @@ ${apiType.join(`
   return { files, issues };
 }
 
-// src/cli/scan.ts
+// src/server/handler.ts
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
+var TYPES = { ".html": "text/html; charset=utf-8", ".js": "text/javascript", ".css": "text/css", ".svg": "image/svg+xml", ".map": "application/json", ".woff2": "font/woff2" };
+var DIST = fileURLToPath(new URL(".", import.meta.url));
+var APP_DIR = path.join(DIST, "app");
+var OVERLAY_FILE = path.join(DIST, "overlay.js");
+var isUrl = (s) => /^https?:\/\//i.test(s);
+async function readDocs(src, base) {
+  if (isUrl(src)) {
+    const res = await fetch(src);
+    if (!res.ok)
+      throw new Error(`${src} returned HTTP ${res.status}.`);
+    return res.text();
+  }
+  if (!/\.(ya?ml|json)$/i.test(src))
+    throw new Error(`"${src}" is not a .yaml, .yml or .json file.`);
+  return fs.readFile(path.resolve(base, src), "utf8");
+}
+async function readBindings(file) {
+  const text = await fs.readFile(file, "utf8");
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    throw new Error("The bindings file is not valid JSON.");
+  }
+  if (typeof raw?.registry !== "string")
+    return parseBindingsFile(text);
+  const registry = parseRegistry(await fs.readFile(path.resolve(path.dirname(file), raw.registry), "utf8"));
+  return checkBindingsFile({ ...raw, ...registry });
+}
+async function saveBindings(file, merged) {
+  let out = merged;
+  if (merged.registry) {
+    const rest = { ...merged };
+    for (const k of REGISTRY_KEYS)
+      delete rest[k];
+    out = rest;
+  }
+  await writeFileAtomic(file, JSON.stringify(out, null, 2) + `
+`);
+}
+async function writeFileAtomic(file, text) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  await fs.writeFile(tmp, text, "utf8");
+  await fs.rename(tmp, file);
+}
+async function readBody(req, limit = 20 * 1024 * 1024) {
+  const chunks = [];
+  let size = 0;
+  for await (const c of req) {
+    size += c.length;
+    if (size > limit)
+      throw new Error("Body too large.");
+    chunks.push(c);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function send(res, status, body, type = "text/plain; charset=utf-8") {
+  res.writeHead(status, { "Content-Type": type, "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" }).end(body);
+}
+function createStudioHandler({ file, prefix, allowed, onSave }) {
+  const base = path.dirname(file);
+  return async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://local");
+    if (prefix && url.pathname !== prefix && !url.pathname.startsWith(prefix + "/"))
+      return false;
+    const rel = url.pathname.slice(prefix.length) || "/";
+    try {
+      if (prefix && url.pathname === prefix) {
+        res.writeHead(302, { Location: prefix + "/" + url.search }).end();
+        return true;
+      }
+      if (rel.startsWith("/api/") && !allowed(req)) {
+        send(res, 403, "Forbidden.");
+        return true;
+      }
+      if (rel === "/api/bindings") {
+        if (req.method === "GET")
+          send(res, 200, JSON.stringify(await readBindings(file)), "application/json");
+        else if (req.method === "PUT") {
+          let merged;
+          try {
+            merged = parseBindingsFile(await readBody(req));
+          } catch (e) {
+            send(res, 400, e.message);
+            return true;
+          }
+          await saveBindings(file, merged);
+          send(res, 204, "");
+          onSave?.();
+        } else
+          send(res, 405, "Method not allowed.");
+        return true;
+      }
+      if (rel === "/api/openapi" && req.method === "GET") {
+        const src = url.searchParams.get("src") ?? "";
+        try {
+          send(res, 200, await readDocs(src, base), src.endsWith(".json") ? "application/json" : "text/yaml; charset=utf-8");
+        } catch (e) {
+          send(res, 502, e.message);
+        }
+        return true;
+      }
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        send(res, 405, "Method not allowed.");
+        return true;
+      }
+      if (rel === "/overlay.js") {
+        send(res, 200, await fs.readFile(OVERLAY_FILE), TYPES[".js"]);
+        return true;
+      }
+      const target = path.resolve(APP_DIR, rel === "/" ? "index.html" : decodeURIComponent(rel.slice(1)));
+      if (!target.startsWith(APP_DIR + path.sep)) {
+        send(res, 404, "Not found.");
+        return true;
+      }
+      const data = await fs.readFile(target).catch(() => null);
+      if (!data) {
+        send(res, 404, "Not found.");
+        return true;
+      }
+      send(res, 200, data, TYPES[path.extname(target)] ?? "application/octet-stream");
+    } catch (e) {
+      send(res, 500, e.message);
+    }
+    return true;
+  };
+}
+
+// src/cli/scan.ts
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
 var LITERAL = /componentId\s*(?:=\s*\{?\s*|:\s*)(["'`])([a-z0-9.-]+)\1/g;
 var SKIP = new Set(["node_modules", "dist", "build", ".git", ".next", ".output"]);
 async function* sources(dir) {
-  for (const e of await fs.readdir(dir, { withFileTypes: true })) {
+  for (const e of await fs2.readdir(dir, { withFileTypes: true })) {
     if (SKIP.has(e.name))
       continue;
-    const p = path.join(dir, e.name);
+    const p = path2.join(dir, e.name);
     if (e.isDirectory())
       yield* sources(p);
     else if (/\.(tsx?|jsx?)$/.test(e.name))
@@ -782,9 +968,9 @@ async function* sources(dir) {
 async function scanIds(dir, file) {
   const found = new Map;
   for await (const p of sources(dir))
-    for (const m of (await fs.readFile(p, "utf8")).matchAll(LITERAL))
+    for (const m of (await fs2.readFile(p, "utf8")).matchAll(LITERAL))
       if (!found.has(m[2]))
-        found.set(m[2], path.relative(dir, p));
+        found.set(m[2], path2.relative(dir, p));
   const registered = new Set(file.components.map((c) => c.id));
   const issues = [];
   for (const [id, where] of found)
@@ -796,12 +982,45 @@ async function scanIds(dir, file) {
   return issues;
 }
 
+// src/codegen/write.ts
+async function writeScreens(filePath, opts = {}) {
+  const base = path3.dirname(filePath);
+  const file = await readBindings(filePath);
+  const catalog = catalogFromText(await readDocs(file.openapi, base), file.openapi);
+  const { files, issues } = generate(file, catalog);
+  if (opts.src)
+    issues.push(...await scanIds(path3.resolve(opts.src), file));
+  const out = path3.resolve(base, file.output?.dir ?? ".");
+  const result = { issues, out, screens: files.length - 2, changed: [], stale: [] };
+  if (issues.some((i) => i.severity === "error"))
+    return result;
+  await fs3.mkdir(out, { recursive: true });
+  const wanted = new Map(files.map((f) => [path3.join(out, f.path), f.content]));
+  for (const [p, content] of wanted)
+    if (await fs3.readFile(p, "utf8").catch(() => null) !== content)
+      result.changed.push(p);
+  for (const n of await fs3.readdir(out)) {
+    const p = path3.join(out, n);
+    if (n.endsWith(".ts") && !wanted.has(p) && (await fs3.readFile(p, "utf8")).startsWith(`// ${GENERATED_MARK}`))
+      result.stale.push(p);
+  }
+  if (opts.check)
+    return result;
+  for (const p of result.changed)
+    await writeFileAtomic(p, wanted.get(p));
+  for (const p of result.stale)
+    await fs3.unlink(p);
+  return result;
+}
+var describeIssue = (i) => `${i.severity === "error" ? "error  " : "warning"} ${[i.component ?? i.screen, i.slot].filter(Boolean).join(" · ")}: ${i.message}`;
+
 // src/cli/cli.ts
 var HELP = `Usage:
   api-binding studio   [bindings.json] [--port 5180]
   api-binding generate [bindings.json] [--check] [--src <dir>]
 
   studio    Opens the binding studio on http://localhost:<port>. Edits are saved to the file.
+            Inside a Vite app, the dev plugin (api_binding_ui/vite) serves the same studio instead.
   generate  Writes one React Query hook per screen into output.dir, calling the Orval client.
             --check  writes nothing; exits 1 when the files are out of date (for CI).
             --src    also checks that every registered id appears in the app's source, and the reverse.`;
@@ -819,133 +1038,40 @@ function args(argv) {
   }
   return { rest, flags };
 }
-var isUrl = (s) => /^https?:\/\//i.test(s);
-async function readDocs(src, base) {
-  if (isUrl(src)) {
-    const res = await fetch(src);
-    if (!res.ok)
-      throw new Error(`${src} returned HTTP ${res.status}.`);
-    return res.text();
-  }
-  if (!/\.(ya?ml|json)$/i.test(src))
-    throw new Error(`"${src}" is not a .yaml, .yml or .json file.`);
-  return fs2.readFile(path2.resolve(base, src), "utf8");
-}
-function report(issues) {
-  for (const i of issues)
-    console.log(`${i.severity === "error" ? "error  " : "warning"} ${[i.component ?? i.screen, i.slot].filter(Boolean).join(" · ")}: ${i.message}`);
-}
-async function writeFile(file, text) {
-  const tmp = `${file}.${process.pid}.tmp`;
-  await fs2.writeFile(tmp, text, "utf8");
-  await fs2.rename(tmp, file);
-}
 async function runGenerate(filePath, flags) {
-  const base = path2.dirname(filePath);
-  const file = parseBindingsFile(await fs2.readFile(filePath, "utf8"));
-  const catalog = catalogFromText(await readDocs(file.openapi, base), file.openapi);
-  const { files, issues } = generate(file, catalog);
-  if (typeof flags.src === "string")
-    issues.push(...await scanIds(path2.resolve(flags.src), file));
-  report(issues);
-  const errors = issues.filter((i) => i.severity === "error").length;
+  const r = await writeScreens(filePath, { check: !!flags.check, src: typeof flags.src === "string" ? flags.src : undefined });
+  for (const i of r.issues)
+    console.log(describeIssue(i));
+  const errors = r.issues.filter((i) => i.severity === "error").length;
   if (errors) {
     console.log(`
 ${errors} error(s). Nothing was written.`);
     return 1;
   }
-  const out = path2.resolve(base, file.output.dir);
-  await fs2.mkdir(out, { recursive: true });
-  const wanted = new Map(files.map((f) => [path2.join(out, f.path), f.content]));
-  const existing = (await fs2.readdir(out)).filter((n) => n.endsWith(".ts")).map((n) => path2.join(out, n));
-  const changed = [];
-  const stale = [];
-  for (const [p, content] of wanted)
-    if (await fs2.readFile(p, "utf8").catch(() => null) !== content)
-      changed.push(p);
-  for (const p of existing)
-    if (!wanted.has(p) && (await fs2.readFile(p, "utf8")).startsWith(`// ${GENERATED_MARK}`))
-      stale.push(p);
+  const rel = (p) => path4.relative(process.cwd(), p) || ".";
   if (flags.check) {
-    if (changed.length || stale.length) {
-      console.log(`Out of date: ${[...changed, ...stale].map((p) => path2.relative(process.cwd(), p)).join(", ")}`);
+    if (r.changed.length || r.stale.length) {
+      console.log(`Out of date: ${[...r.changed, ...r.stale].map(rel).join(", ")}`);
       return 1;
     }
     console.log("Generated files are up to date.");
     return 0;
   }
-  for (const p of changed)
-    await writeFile(p, wanted.get(p));
-  for (const p of stale)
-    await fs2.unlink(p);
-  console.log(`${files.length - 2} screen hook(s) in ${path2.relative(process.cwd(), out) || "."}: ${changed.length} written, ${stale.length} removed.`);
+  console.log(`${r.screens} screen hook(s) in ${rel(r.out)}: ${r.changed.length} written, ${r.stale.length} removed.`);
   return 0;
 }
-var TYPES = { ".html": "text/html; charset=utf-8", ".js": "text/javascript", ".css": "text/css", ".svg": "image/svg+xml", ".map": "application/json", ".woff2": "font/woff2" };
-async function body(req, limit = 20 * 1024 * 1024) {
-  const chunks = [];
-  let size = 0;
-  for await (const c of req) {
-    size += c.length;
-    if (size > limit)
-      throw new Error("Body too large.");
-    chunks.push(c);
-  }
-  return Buffer.concat(chunks).toString("utf8");
-}
 async function runStudio(filePath, flags) {
   const port = Number(flags.port ?? 5180);
-  const base = path2.dirname(filePath);
-  parseBindingsFile(await fs2.readFile(filePath, "utf8"));
-  const app = fileURLToPath(new URL("./app/", import.meta.url));
+  await readBindings(filePath);
   const origins = new Set([`http://localhost:${port}`, `http://127.0.0.1:${port}`]);
-  const send = (res, status, text, type = "text/plain; charset=utf-8") => {
-    res.writeHead(status, { "Content-Type": type, "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" }).end(text);
-  };
+  const allowed = (req) => origins.has(`http://${req.headers.host}`) && (!req.headers.origin || origins.has(String(req.headers.origin)));
+  const handle = createStudioHandler({ file: filePath, prefix: "", allowed });
   const server = createServer(async (req, res) => {
-    try {
-      const host = req.headers.host ?? "";
-      if (!origins.has(`http://${host}`))
-        return send(res, 403, "Forbidden host.");
-      if (req.headers.origin && !origins.has(req.headers.origin))
-        return send(res, 403, "Forbidden origin.");
-      const url = new URL(req.url ?? "/", `http://${host}`);
-      if (url.pathname === "/api/bindings") {
-        if (req.method === "GET")
-          return send(res, 200, await fs2.readFile(filePath, "utf8"), "application/json");
-        if (req.method === "PUT") {
-          const text = await body(req);
-          try {
-            parseBindingsFile(text);
-          } catch (e) {
-            return send(res, 400, e.message);
-          }
-          await writeFile(filePath, text);
-          return send(res, 204, "");
-        }
-        return send(res, 405, "Method not allowed.");
-      }
-      if (url.pathname === "/api/openapi" && req.method === "GET") {
-        const src = url.searchParams.get("src") ?? "";
-        try {
-          return send(res, 200, await readDocs(src, base), src.endsWith(".json") ? "application/json" : "text/yaml; charset=utf-8");
-        } catch (e) {
-          return send(res, 502, e.message);
-        }
-      }
-      if (req.method !== "GET")
-        return send(res, 405, "Method not allowed.");
-      const rel = url.pathname === "/" ? "index.html" : decodeURIComponent(url.pathname.slice(1));
-      const target = path2.resolve(app, rel);
-      if (!target.startsWith(app))
-        return send(res, 404, "Not found.");
-      const data = await fs2.readFile(target).catch(() => null);
-      if (!data)
-        return send(res, 404, "Not found.");
-      res.writeHead(200, { "Content-Type": TYPES[path2.extname(target)] ?? "application/octet-stream", "X-Content-Type-Options": "nosniff" }).end(data);
-    } catch (e) {
-      send(res, 500, e.message);
+    if (!origins.has(`http://${req.headers.host}`)) {
+      res.writeHead(403).end("Forbidden host.");
+      return;
     }
+    await handle(req, res);
   });
   server.listen(port, "127.0.0.1", () => console.log(`Binding studio: http://localhost:${port}
 Editing ${filePath}. Ctrl+C to stop.`));
@@ -953,7 +1079,7 @@ Editing ${filePath}. Ctrl+C to stop.`));
 async function main() {
   const [cmd, ...argv] = process.argv.slice(2);
   const { rest, flags } = args(argv);
-  const filePath = path2.resolve(rest[0] ?? "bindings.json");
+  const filePath = path4.resolve(rest[0] ?? "bindings.json");
   if (cmd === "studio")
     return runStudio(filePath, flags);
   if (cmd === "generate")

package/dist/codegen/write.d.ts

@@ -0,0 +1,18 @@
+import type { ValidationIssue } from "../framework/contract";
+export interface WriteResult {
+    issues: ValidationIssue[];
+    /** Directory the hooks go to. */
+    out: string;
+    /** Number of screen hooks generated. */
+    screens: number;
+    /** Files that differ from what is on disk (written unless `check`). */
+    changed: string[];
+    /** Generated files no screen produces any more (removed unless `check`). */
+    stale: string[];
+}
+/** On any error nothing is written. With `check`, nothing is written either; `changed` and `stale` say what is out of date. */
+export declare function writeScreens(filePath: string, opts?: {
+    check?: boolean;
+    src?: string;
+}): Promise<WriteResult>;
+export declare const describeIssue: (i: ValidationIssue) => string;