api_binding_ui 2.0.2 → 3.1.0

package/dist/codegen/generate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Code generator: bindings file + catalog → one plain React Query hook per screen, calling the Orval client.
+ *
+ * A screen hook's signature comes from the registry only (its components and slots), so call sites stay put
+ * when bindings change; bindings change only the hook bodies. Unbound slots return an unbound value.
+ */
+import type { BindingsFile, Catalog, JsonSchema, ValidationIssue } from "../framework/contract";
+export interface GeneratedFile {
+    path: string;
+    content: string;
+}
+export interface GenerateResult {
+    files: GeneratedFile[];
+    issues: ValidationIssue[];
+}
+/** First-line marker; the CLI only ever deletes files that carry it. */
+export declare const GENERATED_MARK = "@generated";
+/** Orval names functions after the operationId, first letter lowercased. */
+export declare const orvalName: (id: string) => string;
+/** JSON Schema → a TypeScript type. Loose on purpose: the API checks API data, the UI only reads it. */
+export declare function tsType(schema: JsonSchema | undefined, many?: boolean, depth?: number): string;
+export declare function generate(file: BindingsFile, catalog: Catalog): GenerateResult;

package/dist/codegen/helpers.d.ts

@@ -0,0 +1,2 @@
+/** Source of the generated `screen-helpers.ts`: the only shared code the generated hooks use. */
+export declare const HELPERS = "import { useMutation, useQuery } from \"@tanstack/react-query\";\n\n/** Data for a slot. `bound` is false when no API feeds it; keep the UI's own value then. */\nexport interface Data<T> { bound: boolean; data: T | undefined; loading: boolean; error: unknown }\n/** An action. `run` rejects when a call fails; it resolves at once when no API is connected. */\nexport interface Action { bound: boolean; run: (payload?: any) => Promise<void>; running: boolean; error: unknown }\n/** A per-item value, such as a cell in a row. */\nexport interface Cell<T> { bound: boolean; read: (item: any) => T | undefined }\n\nexport const UNBOUND_DATA: Data<never> = { bound: false, data: undefined, loading: false, error: undefined };\nexport const UNBOUND_ACTION: Action = { bound: false, run: async () => {}, running: false, error: undefined };\nexport const UNBOUND_CELL: Cell<never> = { bound: false, read: () => undefined };\n\nexport class ApiError extends Error {\n  constructor(readonly status: number, readonly data: unknown) { super(`API call failed (${status})`); this.name = \"ApiError\"; }\n}\n\n/** Reads a path; \"*\" maps the rest of the path over a list. */\nexport function at(value: unknown, path: readonly string[]): any {\n  let v: any = value;\n  for (let i = 0; i < path.length; i++) {\n    if (v == null) return undefined;\n    if (path[i] === \"*\") return Array.isArray(v) ? v.map(x => at(x, path.slice(i + 1))) : undefined;\n    v = v[path[i]];\n  }\n  return v;\n}\n\n/** The body of a client response; throws on a non-2xx status. Passes through clients that return the body. */\nexport function ok(res: any): any {\n  if (res && typeof res === \"object\" && typeof res.status === \"number\" && \"data\" in res && \"headers\" in res) {\n    if (res.status < 200 || res.status >= 300) throw new ApiError(res.status, res.data);\n    return res.data;\n  }\n  return res;\n}\n\n/** True when every required input has a value. */\nexport const has = (inputs: Record<string, unknown>) => Object.values(inputs).every(v => v !== undefined);\n\n/** Throws when a required input has no value. */\nexport function need(operation: string, inputs: Record<string, unknown>) {\n  const missing = Object.keys(inputs).filter(k => inputs[k] === undefined);\n  if (missing.length) throw new Error(`${operation}: missing ${missing.join(\", \")}`);\n}\n\n/** Drops undefined values. */\nexport const defined = (o: Record<string, unknown>): any => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined));\n\nexport const path = (v: unknown): any => (v === undefined ? undefined : encodeURIComponent(String(v)));\n\n/** A body from a base value and [keys, value] entries; undefined values are skipped. */\nexport function assemble(base: unknown, entries: Array<[string[], unknown]>): any {\n  const out: any = base && typeof base === \"object\" ? { ...base } : {};\n  for (const [keys, value] of entries) {\n    if (value === undefined) continue;\n    let node = out;\n    keys.slice(0, -1).forEach(k => { node = node[k] = node[k] && typeof node[k] === \"object\" ? { ...node[k] } : {}; });\n    node[keys[keys.length - 1]] = value;\n  }\n  return out;\n}\n\n/** Adds mapped fields to each item, keeping the fields the API returned. */\nexport function mapItems(data: any, map: (item: any) => Record<string, unknown>): any {\n  const one = (item: any) => ({ ...(item && typeof item === \"object\" ? item : {}), ...map(item) });\n  return Array.isArray(data) ? data.map(one) : data == null ? data : one(data);\n}\n\nexport const list = (v: unknown): unknown[] => (Array.isArray(v) ? v : v === undefined ? [] : [v]);\n\nexport function finish(failed: unknown[]) {\n  if (failed.length === 1) throw failed[0];\n  if (failed.length) throw new AggregateError(failed, `${failed.length} API calls failed`);\n}\n\nexport function useData<T>(key: readonly unknown[], fetch: () => Promise<unknown>, select: (data: any) => T, options: { enabled: boolean; everySeconds?: number }): Data<T> {\n  const q = useQuery({ queryKey: key, queryFn: fetch, select, enabled: options.enabled, refetchInterval: options.everySeconds ? options.everySeconds * 1000 : false });\n  return { bound: true, data: q.data, loading: q.isLoading, error: q.error ?? undefined };\n}\n\nexport function useAction(run: (payload?: any) => Promise<void>): Action {\n  const m = useMutation({ mutationFn: run });\n  return { bound: true, run: payload => m.mutateAsync(payload), running: m.isPending, error: m.error ?? undefined };\n}\n";

package/dist/framework/contract.d.ts

@@ -1,13 +1,16 @@
-/** Binding framework contract v1. Semantics: spec/FRAMEWORK.md. */
+/** Binding framework contract v3. Semantics: spec/FRAMEWORK.md. */
 /** JSON Schema (2020-12). */
 export type JsonSchema = boolean | {
     [keyword: string]: unknown;
 };
 /** Namespaced component kind, e.g. "acme-ds/grid". */
 export type KindId = string;
-/** Component instance id, unique within its screen. Letters, digits, - and _; no dots. */
+/**
+ * Component id, unique in the app: "<screen id>.<component>[.<part>]", e.g. "collections.worklist.grid.row.add-notes".
+ * Lowercase letters, digits and -, in dot-separated segments.
+ */
 export type BindId = string;
-/** Screen id, e.g. "<product>.<area>.<screen>". */
+/** Screen id, e.g. "<product>.<screen>[.<sub-screen>]". Same segment rules as component ids. */
 export type ScreenId = string;
 /** Expression string; grammar in FRAMEWORK.md §7. */
 export type Expr = string;
@@ -66,7 +69,6 @@ export interface ComponentDescriptor extends Labelled {
 export interface ComponentInstance {
     bindId: BindId;
     kind: KindId;
-    kindVersion: number;
     label: string;
     /** Parent component's bindId. */
     parent?: BindId;
@@ -74,7 +76,7 @@ export interface ComponentInstance {
     info?: Record<string, string>;
 }
 export interface ContextDeclaration extends Labelled {
-    /** Name used in expressions: `$context.<id>`. */
+    /** Name used in expressions: `$context.<id>`. A word: letters and digits. */
     id: string;
     /** A schema, or another screen's produce slot whose bound shape it follows. */
     shape: {
@@ -191,16 +193,36 @@ export interface NoApiBinding extends BindingBase {
     type: "none";
 }
 export type SlotBinding = OperationConsumeBinding | ExpressionConsumeBinding | TriggerBinding | NoApiBinding;
-export interface BindingManifest {
+/** A registered component in the bindings file. Its screen is the longest screen id that prefixes its id. */
+export interface FileComponent {
+    id: BindId;
+    kind: KindId;
+    label: string;
+    /** Parent component id (a column's grid). */
+    parent?: BindId;
+    info?: Record<string, string>;
+}
+export interface FileScreen extends Labelled {
+    id: ScreenId;
+    context?: ContextDeclaration[];
+}
+/** The one file that holds everything about API binding: kinds, screens, components, bindings and output. */
+export interface BindingsFile {
     $schema?: string;
-    manifestVersion: 1;
-    screen: ScreenId;
-    catalog: {
-        hash: string;
+    version: 3;
+    /** OpenAPI document: a URL, or a path relative to this file. */
+    openapi: string;
+    output?: {
+        /** Folder the screen hooks are written to, relative to this file. */
+        dir: string;
+        /** Import specifier of the Orval output, as the app imports it (e.g. "@/api/generated"). */
+        client: string;
     };
-    /** Descriptor versions the bindings were made against. */
-    kinds: Record<KindId, number>;
+    kinds: ComponentDescriptor[];
+    screens: FileScreen[];
+    components: FileComponent[];
     bindings: SlotBinding[];
+    glossaries?: Glossary[];
 }
 /** A named, typed value transform usable as `expr | name(args)`. */
 export interface TransformDefinition extends Labelled {
@@ -243,17 +265,10 @@ export interface Glossary {
     /** Groups of words that mean the same thing in this product. */
     synonyms: string[][];
 }
-export interface PersistenceAdapter {
-    load: (screen: ScreenId) => Promise<BindingManifest | null>;
-    save: (manifest: BindingManifest) => Promise<void>;
-}
-export interface FrameworkRegistry {
-    registerDescriptor: (descriptor: ComponentDescriptor) => void;
-    registerTransform: (transform: TransformDefinition) => void;
-    registerContext: (provider: ContextProvider) => void;
-    registerMatcher: (matcher: Matcher) => void;
-    registerGlossary: (glossary: Glossary) => void;
-    setPersistence: (adapter: PersistenceAdapter) => void;
+/** Where the studio reads and writes the bindings file. */
+export interface BindingsStore {
+    load: () => Promise<BindingsFile>;
+    save: (file: BindingsFile) => Promise<void>;
 }
 export type IssueSeverity = "error" | "warning";
 export interface ValidationIssue {

package/dist/framework/expr.d.ts

@@ -1,34 +1,33 @@
 /**
- * Expression evaluator (FRAMEWORK.md §7). One grammar for every source:
+ * Expression grammar (FRAMEWORK.md §7). One grammar for every source:
  *
- *   <bindId>.<slot>[.path]      a produce slot on this screen
- *   $item[.path]                the current item (scoped slot or forEach)
- *   $context.<id>[.path]        a value the screen received
- *   $steps.<stepId>[.path]      an earlier call step's result ({ response })
- *   $<provider>[.path]          a registered context provider
- *   <expr>[*].<path>            every item of a list
- *   <expr> | name(args)         a registered transform
+ *   <componentId>:<slot>[.path]  a produce slot on the screen
+ *   $item[.path]                 the current item (scoped slot, forEach, or the trigger's payload)
+ *   $context.<id>[.path]         a value the screen received
+ *   $steps.<stepId>[.path]       an earlier call step's result ({ response })
+ *   <expr>[*].<path>             every item of a list
  *
- * Nothing outside this grammar is evaluated; unknown heads resolve to undefined.
+ * Component ids contain dots, so ":" ends the id. Nothing outside this grammar is valid.
  */
-export type Transforms = Record<string, (value: unknown, ...args: unknown[]) => unknown>;
-export interface Scope {
-    /** Current value of a produce slot on the screen. */
-    slot: (bindId: string, slotId: string) => unknown;
-    item?: unknown;
-    context?: Record<string, unknown>;
-    providers?: Record<string, unknown>;
-    steps?: Record<string, unknown>;
-    transforms?: Transforms;
-}
-interface Parsed {
-    head: string[];
+export type Head = {
+    type: "slot";
+    component: string;
+    slot: string;
+} | {
+    type: "item";
+} | {
+    type: "context";
+    id: string;
+} | {
+    type: "steps";
+    id: string;
+};
+export interface Parsed {
+    head: Head;
     path: string[];
-    pipes: Array<{
-        name: string;
-        args: unknown[];
-    }>;
 }
+/** "a.b[*].c" → ["a", "b", "*", "c"] */
+export declare function segments(path: string): string[];
 export declare function parse(expr: string): Parsed;
-export declare function evaluate(expr: string, scope: Scope): unknown;
-export {};
+/** Reads a path; "*" maps the rest of the path over a list. */
+export declare function walk(value: unknown, path: readonly string[]): unknown;

package/dist/framework/file.d.ts

@@ -0,0 +1,28 @@
+/** The bindings file: parsing, and conversion to and from the studio's working model. */
+import type { BindingsFile, Catalog, ScreenId, ValidationIssue } from "./contract";
+import type { BindingIndex, FrameworkData } from "./engine";
+/** Screen and component ids: lowercase kebab-case segments joined by dots, at least two. */
+export declare const ID: RegExp;
+/** Parses and shape-checks a bindings file. Throws a message a person can act on. */
+export declare function parseBindingsFile(text: string): BindingsFile;
+/** The screen an id belongs to: the longest screen id that prefixes it. */
+export declare function screenOf(id: string, screens: readonly ScreenId[]): ScreenId | undefined;
+/** Builds the studio's model. Components and bindings that fit no screen are dropped with an issue. */
+export declare function fromFile(file: BindingsFile, catalog: Catalog): {
+    fw: FrameworkData;
+    index: BindingIndex;
+    issues: ValidationIssue[];
+};
+/** The file with its bindings replaced by the index, in registry order so diffs stay small. */
+export declare function toFile(file: BindingsFile, index: BindingIndex): BindingsFile;
+/** In-memory store, for tests and embedding. */
+export declare function memoryStore(seed: BindingsFile): {
+    load: () => Promise<BindingsFile>;
+    save: (f: BindingsFile) => Promise<void>;
+    readonly current: BindingsFile;
+};
+/** Store backed by the CLI's studio server. */
+export declare function httpStore(url: string): {
+    load(): Promise<BindingsFile>;
+    save(file: BindingsFile): Promise<void>;
+};

package/dist/framework/store.d.ts

@@ -1,17 +1,5 @@
-/** Manifest persistence and edit helpers. */
-import type { BindingManifest, PersistenceAdapter, ScreenId, SlotBinding } from "./contract";
-import type { BindingIndex, FrameworkData } from "./engine";
-export declare function localStorageAdapter(prefix?: string): PersistenceAdapter;
-export declare function memoryAdapter(seed?: BindingManifest[]): PersistenceAdapter;
-export declare function toManifest(fw: FrameworkData, screen: ScreenId, bindings: SlotBinding[]): BindingManifest;
-/** Unsaved screens with an edit counter; a screen is cleared only by a save that covers its latest edit. */
-export type Pending = Map<ScreenId, number>;
-export declare function markDirty(pending: Pending, screen: ScreenId): void;
-/** Saves every pending screen from `idx`. Returns the screens whose save failed (they stay pending). */
-export declare function savePending(adapter: PersistenceAdapter, fw: FrameworkData, idx: BindingIndex, pending: Pending): Promise<ScreenId[]>;
-export declare function loadAll(adapter: PersistenceAdapter, screens: ScreenId[]): Promise<BindingIndex>;
-/** Pure edit helpers: return a new index. */
+/** Pure edit helpers for the binding index: each returns a new index. */
+import type { ScreenId, SlotBinding } from "./contract";
+import type { BindingIndex } from "./engine";
 export declare function putBinding(idx: BindingIndex, screen: ScreenId, b: SlotBinding): BindingIndex;
 export declare function dropBinding(idx: BindingIndex, screen: ScreenId, component: string, slot: string): BindingIndex;
-/** Parses imported manifests (one or a list). Throws on the first invalid entry. */
-export declare function parseManifests(text: string): BindingManifest[];

package/dist/{index-3q1vx729.js → index-jj8twdw9.js}

@@ -111,100 +111,42 @@ function catalogFromOpenApi2(input, source = {}) {
   };
 }
 
-// src/framework/store.ts
-function localStorageAdapter2(prefix = "abs.manifest.") {
-  return {
-    async load(screen) {
-      try {
-        const raw = globalThis.localStorage?.getItem(prefix + screen);
-        return raw ? JSON.parse(raw) : null;
-      } catch {
-        return null;
-      }
-    },
-    async save(m) {
-      if (!globalThis.localStorage)
-        throw new Error("Browser storage is not available.");
-      globalThis.localStorage.setItem(prefix + m.screen, JSON.stringify(m));
-    }
-  };
-}
-function memoryAdapter2(seed = []) {
-  const m = new Map(seed.map((x) => [x.screen, x]));
-  return { async load(s) {
-    return m.get(s) ?? null;
-  }, async save(x) {
-    m.set(x.screen, x);
-  } };
-}
-function toManifest2(fw, screen, bindings) {
-  const S = fw.registry.screens.find((s) => s.id === screen);
-  const kinds = {};
-  S?.components.forEach((c) => {
-    const d = fw.descriptors.find((x) => x.kind === c.kind);
-    if (d)
-      kinds[c.kind] = d.version;
-  });
-  return { manifestVersion: 1, screen, catalog: { hash: fw.catalog.hash }, kinds, bindings };
-}
-function markDirty(pending, screen) {
-  pending.set(screen, (pending.get(screen) ?? 0) + 1);
-}
-async function savePending(adapter, fw, idx, pending) {
-  const batch = [...pending];
-  const results = await Promise.allSettled(batch.map(([s]) => adapter.save(toManifest2(fw, s, idx[s] ?? []))));
-  const failed = [];
-  batch.forEach(([s, version], i) => {
-    if (results[i].status === "rejected")
-      failed.push(s);
-    else if (pending.get(s) === version)
-      pending.delete(s);
-  });
-  return failed;
-}
-async function loadAll(adapter, screens) {
-  const out = {};
-  await Promise.all(screens.map(async (s) => {
-    const m = await adapter.load(s);
-    if (m)
-      out[s] = m.bindings;
-  }));
-  return out;
-}
-function putBinding(idx, screen, b) {
-  const list = (idx[screen] ?? []).filter((x) => !(x.component === b.component && x.slot === b.slot));
-  return { ...idx, [screen]: [...list, b] };
+// src/framework/loadCatalog.ts
+import { parse } from "yaml";
+class CatalogLoadError2 extends Error {
+  source;
+  constructor(message, source) {
+    super(message);
+    this.source = source;
+    this.name = "CatalogLoadError";
+  }
 }
-function dropBinding(idx, screen, component, slot) {
-  return { ...idx, [screen]: (idx[screen] ?? []).filter((x) => !(x.component === component && x.slot === slot)) };
+function catalogFromText2(text, source) {
+  const body = text.trim();
+  if (!body)
+    throw new CatalogLoadError2("Nothing to read: the text is empty.", source);
+  let doc;
+  try {
+    doc = body.startsWith("{") ? JSON.parse(body) : parse(body);
+  } catch {
+    throw new CatalogLoadError2("The text is not valid JSON or YAML.", source);
+  }
+  try {
+    return catalogFromOpenApi2(doc, source.includes("://") ? { url: source } : {});
+  } catch (e) {
+    throw new CatalogLoadError2(e instanceof Error ? e.message : "The text is not an OpenAPI document.", source);
+  }
 }
-var BINDING_TYPES = new Set(["operation", "expression", "steps", "none"]);
-function parseManifests(text) {
-  let data;
+async function loadCatalog2(url, init) {
+  let res;
   try {
-    data = JSON.parse(text);
+    res = await fetch(url, { ...init, headers: { Accept: "application/yaml, application/json, text/yaml, */*", ...init?.headers } });
   } catch {
-    throw new Error("The file is not valid JSON.");
-  }
-  const list = Array.isArray(data) ? data : [data];
-  list.forEach((m, i) => {
-    const at = `Manifest ${i + 1}`;
-    if (!m || typeof m !== "object")
-      throw new Error(`${at} is not an object.`);
-    const r = m;
-    if (r.manifestVersion !== 1)
-      throw new Error(`${at}: manifestVersion must be 1.`);
-    if (typeof r.screen !== "string" || !r.screen)
-      throw new Error(`${at}: "screen" is missing.`);
-    if (!Array.isArray(r.bindings))
-      throw new Error(`${at} (${r.screen}): "bindings" must be a list.`);
-    r.bindings.forEach((b, j) => {
-      const x = b;
-      if (!x || typeof x.component !== "string" || typeof x.slot !== "string" || !BINDING_TYPES.has(x.type))
-        throw new Error(`${at} (${r.screen}), binding ${j + 1}: needs "component", "slot" and a known "type".`);
-    });
-  });
-  return list;
+    throw new CatalogLoadError2("The docs could not be reached. Check the URL, your network, and that the docs server allows this site (CORS).", url);
+  }
+  if (!res.ok)
+    throw new CatalogLoadError2(`The docs server answered ${res.status} ${res.statusText}. Check the URL.`, url);
+  return catalogFromText2(await res.text(), url);
 }
 
 // src/framework/names.ts
@@ -228,6 +170,117 @@ function humanize(id) {
   return w ? w[0].toUpperCase() + w.slice(1) : id;
 }
 
+// src/framework/file.ts
+var ID2 = /^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/;
+var BINDING_TYPES = new Set(["operation", "expression", "steps", "none"]);
+function parseBindingsFile2(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 screenOf2(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 fromFile2(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: screenOf2(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 = screenOf2(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 = screenOf2(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
+  };
+}
+function toFile2(file, index) {
+  const order = new Map(file.components.map((c, i) => [c.id, i]));
+  const bindings = Object.values(index).flat().sort((a, b) => (order.get(a.component) ?? 1e9) - (order.get(b.component) ?? 1e9) || a.slot.localeCompare(b.slot));
+  return { ...file, bindings };
+}
+function memoryStore2(seed) {
+  let file = seed;
+  return { load: async () => file, save: async (f) => {
+    file = f;
+  }, get current() {
+    return file;
+  } };
+}
+function httpStore2(url) {
+  return {
+    async load() {
+      const res = await fetch(url, { cache: "no-store" });
+      if (!res.ok)
+        throw new Error(`Could not read the bindings file (HTTP ${res.status}).`);
+      return parseBindingsFile2(await res.text());
+    },
+    async save(file) {
+      const res = await fetch(url, { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify(file, null, 2) + `
+` });
+      if (!res.ok)
+        throw new Error(await res.text() || `Could not save (HTTP ${res.status}).`);
+    }
+  };
+}
+
 // src/framework/schema.ts
 var obj = (s) => s && typeof s === "object" ? s : {};
 function flat(s) {
@@ -412,13 +465,13 @@ function createEngine2(fw, manifests) {
         const sh = shapeOf(s, c, sl);
         if (sh.fields?.length) {
           if (sh.many)
-            out.push({ expr: `${c.bindId}.${sl.id}`, label: `${c.label} · ${sl.label}`, type: "list", group: "screen", fields: sh.fields });
-          sh.fields.forEach(([f, t]) => out.push({ expr: `${c.bindId}.${sl.id}${sh.many ? "[*]" : ""}.${f}`, label: `${c.label} · ${humanize(f)}`, name: f, type: sh.many ? t + "[]" : t, group: "screen" }));
+            out.push({ expr: `${c.bindId}:${sl.id}`, label: `${c.label} · ${sl.label}`, type: "list", group: "screen", fields: sh.fields });
+          sh.fields.forEach(([f, t]) => out.push({ expr: `${c.bindId}:${sl.id}${sh.many ? "[*]" : ""}.${f}`, label: `${c.label} · ${humanize(f)}`, name: f, type: sh.many ? t + "[]" : t, group: "screen" }));
         } else if (sh.via) {
           const via = d.slots.find((x) => x.id === sh.via);
-          out.push({ expr: `${c.bindId}.${sl.id}`, label: `${c.label} · ${sl.label}`, type: "pending", group: "screen", waitsFor: `${c.label} · ${via?.label ?? sh.via}` });
+          out.push({ expr: `${c.bindId}:${sl.id}`, label: `${c.label} · ${sl.label}`, type: "pending", group: "screen", waitsFor: `${c.label} · ${via?.label ?? sh.via}` });
         } else
-          out.push({ expr: `${c.bindId}.${sl.id}`, label: c.label + (sl.label && bindable(d).length + 1 < d.slots.length ? ` · ${sl.label}` : ""), name: c.label, type: sh.many ? "list" : sh.type ?? "any", group: "screen" });
+          out.push({ expr: `${c.bindId}:${sl.id}`, label: c.label + (sl.label && bindable(d).length + 1 < d.slots.length ? ` · ${sl.label}` : ""), name: c.label, type: sh.many ? "list" : sh.type ?? "any", group: "screen" });
       });
     });
     S.context.forEach((ctx) => {
@@ -641,16 +694,19 @@ function createEngine2(fw, manifests) {
 }
 
 // src/framework/validate.ts
-var BIND_ID = /^[A-Za-z_][\w-]*$/;
 function validateRegistry2(fw) {
   const kinds = new Set(fw.descriptors.map((d) => d.kind));
   const issues = [];
   const ids = new Set(fw.registry.screens.map((s) => s.id));
+  const seen = new Set;
   const screens = fw.registry.screens.map((S) => {
-    const seen = new Set;
+    if (!ID2.test(S.id)) {
+      issues.push({ severity: "error", screen: S.id, code: "registry.invalid-id", message: `Screen id "${S.id}" must be lowercase kebab-case segments joined by dots.` });
+      return { ...S, components: [] };
+    }
     const components = S.components.filter((c) => {
-      if (!BIND_ID.test(c.bindId)) {
-        issues.push({ severity: "error", screen: S.id, component: c.bindId, code: "registry.invalid-bind-id", message: `bindId "${c.bindId}" must use letters, digits, - or _ only (no dots).` });
+      if (!ID2.test(c.bindId)) {
+        issues.push({ severity: "error", screen: S.id, component: c.bindId, code: "registry.invalid-id", message: `Component id "${c.bindId}" must be lowercase kebab-case segments joined by dots.` });
         return false;
       }
       if (!kinds.has(c.kind)) {
@@ -658,7 +714,7 @@ function validateRegistry2(fw) {
         return false;
       }
       if (seen.has(c.bindId)) {
-        issues.push({ severity: "error", screen: S.id, component: c.bindId, code: "registry.duplicate-bind-id", message: `bindId "${c.bindId}" is used twice.` });
+        issues.push({ severity: "error", screen: S.id, component: c.bindId, code: "registry.duplicate-id", message: `Component id "${c.bindId}" is used twice.` });
         return false;
       }
       seen.add(c.bindId);
@@ -682,78 +738,7 @@ function validateBindings2(engine) {
   return issues;
 }
 
-// src/runtime/BindingProvider.tsx
-import * as React from "react";
-import { jsx } from "react/jsx-runtime";
-var RuntimeContext = React.createContext(null);
-function latestShown(screens) {
-  let best;
-  for (const m of screens)
-    if (m.shown && (!best || m.at > best.at))
-      best = m;
-  return best?.screen;
-}
-function useBindingRuntime() {
-  const r = React.useContext(RuntimeContext);
-  if (!r)
-    throw new Error("Wrap the app in <BindingProvider> before using binding hooks.");
-  return r;
-}
-function BindingProvider2({ catalog, manifests, fetcher, transforms, providers, persistence, children }) {
-  const [overrides, setOverrides] = React.useState({});
-  const requested = React.useRef(new Set);
-  const mounted = React.useRef(new Map);
-  const clock = React.useRef(0);
-  const loadSaved = React.useCallback((screen) => {
-    if (!persistence || requested.current.has(screen))
-      return;
-    requested.current.add(screen);
-    persistence.load(screen).then((m) => {
-      if (m)
-        setOverrides((o) => ({ ...o, [screen]: m }));
-    }, () => requested.current.delete(screen));
-  }, [persistence]);
-  const reloadSaved = React.useCallback(() => {
-    requested.current.clear();
-    new Set([...mounted.current.values()].map((m) => m.screen)).forEach(loadSaved);
-  }, [loadSaved]);
-  const mountScreen = React.useCallback((screen, shown) => {
-    const key = Symbol(screen);
-    mounted.current.set(key, { screen, shown, at: ++clock.current });
-    return () => {
-      mounted.current.delete(key);
-    };
-  }, []);
-  const activeScreen = React.useCallback(() => latestShown(mounted.current.values()), []);
-  const runtime = React.useMemo(() => {
-    const index = new Map;
-    const byScreen = new Map(manifests.map((m) => [m.screen, m]));
-    Object.values(overrides).forEach((m) => byScreen.set(m.screen, m));
-    byScreen.forEach((m) => m.bindings.forEach((b) => {
-      if (b.state === "confirmed")
-        index.set(`${m.screen}|${b.component}|${b.slot}`, b);
-    }));
-    return {
-      operations: new Map(catalog.operations.map((o) => [o.id, o])),
-      binding: (s, c, sl) => index.get(`${s}|${c}|${sl}`),
-      fetcher,
-      transforms: Object.fromEntries((transforms ?? []).map((t) => [t.name, t.apply])),
-      providers: () => Object.fromEntries((providers ?? []).map((p) => [p.id, p.read()])),
-      inflight: new Map,
-      persistence,
-      loadSaved,
-      reloadSaved,
-      mountScreen,
-      activeScreen
-    };
-  }, [catalog, manifests, overrides, fetcher, transforms, providers, persistence, loadSaved, reloadSaved, mountScreen, activeScreen]);
-  return /* @__PURE__ */ jsx(RuntimeContext.Provider, {
-    value: runtime,
-    children
-  });
-}
-
-export { catalogFromOpenApi2, localStorageAdapter2, memoryAdapter2, toManifest2, markDirty, savePending, loadAll, putBinding, dropBinding, parseManifests, humanize, createEngine2, validateRegistry2, validateBindings2, useBindingRuntime, BindingProvider2 };
+export { catalogFromOpenApi2, CatalogLoadError2, catalogFromText2, loadCatalog2, humanize, ID2, parseBindingsFile2, screenOf2, fromFile2, toFile2, memoryStore2, httpStore2, flat, createEngine2, validateRegistry2, validateBindings2 };
 
-//# debugId=4412F540958D6E7164756E2164756E21
-//# sourceMappingURL=index-3q1vx729.js.map
+//# debugId=CBA6673BB224224F64756E2164756E21
+//# sourceMappingURL=index-jj8twdw9.js.map