api_binding_ui 1.1.0 → 2.0.0

package/dist/index-e9twc25y.js

@@ -0,0 +1,754 @@
+// src/framework/openapi.ts
+var METHODS = ["get", "put", "post", "delete", "patch", "head", "options", "trace", "query"];
+function hashString(s) {
+  let h = 2166136261;
+  for (let i = 0;i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function pointerGet(doc, ref) {
+  if (!ref.startsWith("#/"))
+    return;
+  return ref.slice(2).split("/").map((k) => k.replace(/~1/g, "/").replace(/~0/g, "~")).reduce((o, k) => o == null ? undefined : o[k], doc);
+}
+function deref(doc, node, seen = []) {
+  if (Array.isArray(node))
+    return node.map((n) => deref(doc, n, seen));
+  if (!node || typeof node !== "object")
+    return node;
+  const n = node;
+  if (typeof n.$ref === "string") {
+    if (seen.includes(n.$ref) || seen.length > 24)
+      return { $ref: n.$ref };
+    const { $ref, ...rest } = n;
+    const target = deref(doc, pointerGet(doc, $ref), [...seen, $ref]);
+    return Object.keys(rest).length ? { ...target, ...deref(doc, rest, seen) } : target;
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(n))
+    out[k] = deref(doc, v, seen);
+  return out;
+}
+function jsonContent(content) {
+  if (!content)
+    return;
+  const key = Object.keys(content).find((k) => /json/i.test(k)) ?? Object.keys(content)[0];
+  return key ? content[key]?.schema : undefined;
+}
+function intentOf(method, op) {
+  if (typeof op["x-binding-intent"] === "string")
+    return op["x-binding-intent"];
+  if (method === "get" || method === "head" || method === "query")
+    return "read";
+  if (["put", "patch", "delete"].includes(method))
+    return "write";
+  return;
+}
+function catalogFromOpenApi2(input, source = {}) {
+  const doc = input;
+  if (!doc || typeof doc !== "object" || !doc.paths)
+    throw new Error("This file is not an OpenAPI document: it has no paths.");
+  const operations = [];
+  const productOf = new Map;
+  for (const g of doc["x-tagGroups"] ?? [])
+    g.tags?.forEach((t) => {
+      if (g.name)
+        productOf.set(t, g.name);
+    });
+  for (const [path, rawItem] of Object.entries(doc.paths)) {
+    const item = deref(doc, rawItem);
+    for (const method of METHODS) {
+      const op = item?.[method];
+      if (!op || !op.operationId)
+        continue;
+      const params = [];
+      for (const p of [...item.parameters ?? [], ...op.parameters ?? []]) {
+        if (!p?.name || !p?.in)
+          continue;
+        const pointer = `/${p.in}/${p.name}`;
+        const at = params.findIndex((x) => x.pointer === pointer);
+        const entry = { pointer, name: p.name, required: !!p.required || p.in === "path", schema: p.schema ?? {}, description: p.description };
+        if (at >= 0)
+          params[at] = entry;
+        else
+          params.push(entry);
+      }
+      for (const m of path.matchAll(/\{([^}]+)\}/g)) {
+        if (!params.some((x) => x.pointer === `/path/${m[1]}`))
+          params.unshift({ pointer: `/path/${m[1]}`, name: m[1], required: true, schema: { type: "string" } });
+      }
+      const bodySchema = jsonContent(op.requestBody?.content);
+      const responses = Object.entries(op.responses ?? {}).map(([status, r]) => ({ status, schema: jsonContent(r?.content) }));
+      const extensions = {};
+      for (const [k, v] of Object.entries(op))
+        if (k.startsWith("x-"))
+          extensions[k] = v;
+      operations.push({
+        id: op.operationId,
+        method: method.toUpperCase(),
+        path,
+        summary: op.summary,
+        description: op.description,
+        tags: op.tags ?? [],
+        product: op.tags?.map((t) => productOf.get(t)).find(Boolean),
+        intent: intentOf(method, op),
+        parameters: params,
+        body: bodySchema ? { required: !!op.requestBody?.required, schema: bodySchema } : undefined,
+        responses,
+        extensions
+      });
+    }
+  }
+  const body = JSON.stringify(operations);
+  return {
+    catalogVersion: 1,
+    source: { title: doc.info?.title ?? "API", version: doc.info?.version ?? "", url: source.url },
+    hash: hashString(body),
+    operations,
+    schemas: {}
+  };
+}
+
+// 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] };
+}
+function dropBinding(idx, screen, component, slot) {
+  return { ...idx, [screen]: (idx[screen] ?? []).filter((x) => !(x.component === component && x.slot === slot)) };
+}
+var BINDING_TYPES = new Set(["operation", "expression", "steps", "none"]);
+function parseManifests(text) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } 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;
+}
+
+// src/framework/names.ts
+var sing = (w) => w.length > 3 && w.endsWith("s") ? w.slice(0, -1) : w;
+function synonymIndex(glossaries) {
+  const m = {};
+  glossaries.forEach((g) => g.synonyms.forEach((grp) => {
+    const g2 = grp.map((x) => sing(x.toLowerCase()));
+    g2.forEach((w) => {
+      m[w] = g2;
+    });
+  }));
+  return m;
+}
+function words(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1).map(sing);
+}
+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/schema.ts
+var obj = (s) => s && typeof s === "object" ? s : {};
+function flat(s) {
+  const o = obj(s);
+  const parts = [o, ...(o.allOf ?? []).map(flat)];
+  if (parts.length === 1 && !o.oneOf && !o.anyOf)
+    return o;
+  const props = {};
+  const required = [];
+  parts.forEach((p) => {
+    Object.assign(props, p.properties ?? {});
+    required.push(...p.required ?? []);
+  });
+  const alt = (o.oneOf ?? o.anyOf)?.map(flat).find((x) => x.type !== "null");
+  return { ...alt ?? {}, ...o, properties: Object.keys(props).length ? props : alt?.properties, required };
+}
+function typeName(s) {
+  const o = flat(s);
+  const t = Array.isArray(o.type) ? o.type.find((x) => x !== "null") : o.type;
+  if (t === "array")
+    return typeName(o.items) + "[]";
+  if (o.format === "date-time" || o.format === "date")
+    return "date-time";
+  if (t === "integer" || t === "number")
+    return "number";
+  return t ?? (o.properties ? "object" : "any");
+}
+var isObject = (s) => {
+  const o = flat(s);
+  return o.type === "object" || !!o.properties;
+};
+var propsOf = (s) => Object.entries(flat(s).properties ?? {}).map(([k, v]) => [k, typeName(v)]);
+function leaves(schema, prefix, required, out, depth = 0) {
+  const s = flat(schema);
+  if (isObject(s)) {
+    const props = Object.entries(s.properties ?? {});
+    if (!props.length || depth > 3) {
+      out.push([prefix, "object", required]);
+      return;
+    }
+    const req = new Set(s.required ?? []);
+    props.forEach(([k, v]) => {
+      if (!flat(v).readOnly)
+        leaves(v, `${prefix}/${k}`, required && req.has(k), out, depth + 1);
+    });
+  } else
+    out.push([prefix, typeName(s), required]);
+}
+function listsIn(schema, path, out, depth = 0) {
+  const s = flat(schema);
+  if (s.type === "array") {
+    if (isObject(s.items))
+      out.push({ select: `${path}[*]`, fields: propsOf(s.items) });
+    return;
+  }
+  if (isObject(s) && depth < 4)
+    Object.entries(s.properties ?? {}).forEach(([k, v]) => listsIn(v, `${path}.${k}`, out, depth + 1));
+}
+var views = new WeakMap;
+function opViews(catalog) {
+  let m = views.get(catalog);
+  if (m)
+    return m;
+  m = new Map;
+  for (const op of catalog.operations) {
+    const req = op.parameters.map((p) => [p.pointer, typeName(p.schema), p.required]);
+    if (op.body)
+      leaves(op.body.schema, "/body", op.body.required, req);
+    const ok = op.responses.find((r) => /^2/.test(r.status) && r.schema);
+    const lists = [];
+    if (ok)
+      listsIn(ok.schema, "$", lists);
+    const one = ok && !lists.length && isObject(ok.schema) ? propsOf(ok.schema) : null;
+    const scalars = ok ? propsOf(ok.schema).filter(([, t]) => t !== "object" && !t.endsWith("[]")).map(([k, t]) => [`$.${k}`, t]) : [];
+    m.set(op.id, { op, req, lists, one, scalars });
+  }
+  views.set(catalog, m);
+  return m;
+}
+
+// src/framework/engine.ts
+function createEngine2(fw, manifests) {
+  const OPV = opViews(fw.catalog);
+  const OPS = [...OPV.values()];
+  const DESC = new Map(fw.descriptors.map((d) => [d.kind, d]));
+  const SCR = new Map(fw.registry.screens.map((s) => [s.id, s]));
+  const transforms = fw.transforms ?? [];
+  const providers = fw.providers ?? [];
+  const syn = synonymIndex(fw.glossaries ?? []);
+  const key = (s, c, sl) => `${s}|${c}|${sl}`;
+  const BIND = new Map;
+  for (const [s, list] of Object.entries(manifests))
+    for (const b of list) {
+      if (b.type === "operation" && !OPV.has(b.operation))
+        continue;
+      if (b.type === "steps" && b.steps.some((st) => !OPV.has(st.operation)))
+        continue;
+      BIND.set(key(s, b.component, b.slot), b);
+    }
+  const getB = (s, c, sl) => BIND.get(key(s, c, sl));
+  const screen = (id) => SCR.get(id);
+  const compOf = (s, id) => SCR.get(s)?.components.find((c) => c.bindId === id);
+  const descOf = (c) => DESC.get(c.kind);
+  const bindable = (d) => d ? d.slots.filter((x) => x.role !== "produce") : [];
+  const tokCache = new Map;
+  const tok = (text, expand) => {
+    const k = (expand ? "+" : "-") + text;
+    let out = tokCache.get(k);
+    if (out)
+      return out;
+    out = new Set;
+    for (const w of words(text)) {
+      out.add(w);
+      if (expand)
+        (syn[w] ?? []).forEach((x) => out.add(x));
+    }
+    tokCache.set(k, out);
+    return out;
+  };
+  function nameScore(target, source) {
+    const a = tok(target, false), b = tok(source, true);
+    if (!a.size || !b.size)
+      return 0;
+    let n = 0;
+    a.forEach((x) => {
+      if (b.has(x))
+        n++;
+    });
+    return n && n / a.size >= 0.5 ? 0.6 * n / a.size + 0.4 * n / b.size : 0;
+  }
+  const base = (t) => t.replace("[]", "");
+  function typeFit(target, source) {
+    if (target !== "any" && source !== "any" && target.endsWith("[]") !== source.endsWith("[]"))
+      return { ok: false };
+    const t = base(target), s = base(source);
+    if (t === "any" || s === "any" || t === s)
+      return { ok: true };
+    const tr = transforms.find((x) => typeName(x.input) === s && typeName(x.output) === t);
+    return tr ? { ok: true, transform: tr.name } : { ok: false };
+  }
+  function bindingFields(s, c, slotId) {
+    const b = getB(s, c, slotId);
+    if (!b || b.type !== "operation")
+      return null;
+    const v = OPV.get(b.operation);
+    if (!v)
+      return null;
+    if (b.select === "$" && v.one)
+      return v.one;
+    return v.lists.find((x) => x.select === b.select)?.fields ?? null;
+  }
+  function shapeOf(s, comp, slot) {
+    const sc = obj(slot.schema);
+    if (typeof sc.$ref === "string" && sc.$ref.startsWith("#slot/")) {
+      const via = sc.$ref.slice(6);
+      return { many: !!slot.many, fields: bindingFields(s, comp.bindId, via) ?? [], via };
+    }
+    if (flat(sc).properties)
+      return { many: !!slot.many, fields: propsOf(sc) };
+    return { many: !!slot.many, type: typeName(sc) };
+  }
+  function contextShape(ctx) {
+    if ("schema" in ctx.shape)
+      return { many: !!ctx.many, fields: propsOf(ctx.shape.schema) };
+    const f = ctx.shape.from, comp = compOf(f.screen, f.component), d = comp && descOf(comp), slot = d?.slots.find((x) => x.id === f.slot);
+    return { many: !!ctx.many, fields: (slot && comp ? shapeOf(f.screen, comp, slot).fields : null) ?? [] };
+  }
+  function scopeFields(s, comp, slot) {
+    if (!slot.scope || !comp.parent)
+      return null;
+    return bindingFields(s, comp.parent, slot.scope.parentSlot);
+  }
+  function manyContext(s) {
+    return screen(s).context.find((x) => x.many);
+  }
+  function sources(s, opts = {}) {
+    const out = [], S = screen(s);
+    opts.item?.forEach(([f, t]) => out.push({ expr: `$item.${f}`, label: humanize(f), name: f, type: t, group: "item" }));
+    S.components.forEach((c) => {
+      const d = descOf(c);
+      d?.slots.filter((x) => x.role === "produce").forEach((sl) => {
+        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" }));
+        } 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}` });
+        } 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" });
+      });
+    });
+    S.context.forEach((ctx) => {
+      const sh = contextShape(ctx);
+      if (ctx.many)
+        out.push({ expr: `$context.${ctx.id}`, label: ctx.label, type: "list", group: "context", fields: sh.fields });
+      sh.fields.forEach(([f, t]) => out.push({ expr: `$context.${ctx.id}${ctx.many ? "[*]" : ""}.${f}`, label: `${ctx.label} · ${humanize(f)}`, name: f, type: ctx.many ? t + "[]" : t, group: "context" }));
+    });
+    providers.forEach((p) => propsOf(p.schema).forEach(([f, t]) => out.push({ expr: `$${p.id}.${f}`, label: `${p.label} · ${humanize(f)}`, name: `${p.label} ${f}`, type: t, group: "provider" })));
+    return out;
+  }
+  function rankSources(targetName, targetType, srcs, min = 0.65) {
+    const out = [];
+    for (const x of srcs) {
+      if (x.type === "list" || x.waitsFor)
+        continue;
+      const fit = typeFit(targetType, x.type);
+      if (!fit.ok)
+        continue;
+      let sc = Math.max(nameScore(targetName, x.name ?? x.label), nameScore(targetName, x.label) * 0.9);
+      if (x.group === "screen")
+        sc += 0.12;
+      else if (x.group === "item")
+        sc += 0.05;
+      if (fit.transform)
+        sc -= 0.05;
+      if (sc >= min)
+        out.push({ expr: x.expr + (fit.transform ? ` | ${fit.transform}()` : ""), score: sc, source: x });
+    }
+    return out.sort((a, b) => b.score - a.score);
+  }
+  function bestSource(targetName, targetType, srcs) {
+    return rankSources(targetName, targetType, srcs)[0] ?? null;
+  }
+  function qualified(ptr, op) {
+    const parts = ptr.split("/").filter(Boolean), name = parts[parts.length - 1];
+    if (words(name).length > 1)
+      return name;
+    if (parts[0] === "body")
+      return parts.length > 2 ? `${parts[parts.length - 2]} ${name}` : name;
+    const segs = op.path.split("/").filter((x) => x && !x.startsWith("{"));
+    return `${segs[segs.length - 1] ?? ""} ${name}`;
+  }
+  function proposeRequest(v, srcs) {
+    const req = {};
+    v.req.forEach(([ptr, t]) => {
+      const m = bestSource(qualified(ptr, v.op), t, srcs);
+      if (m)
+        req[ptr] = m.expr;
+    });
+    return req;
+  }
+  function proposeMap(slotFields, itemFields) {
+    const map = {};
+    const srcs = itemFields.map(([f, t]) => ({ expr: `$item.${f}`, name: f, label: f, type: t, group: "item" }));
+    slotFields.forEach(([p, t]) => {
+      const m = bestSource(p, t, srcs);
+      if (m)
+        map[p] = m.expr;
+    });
+    return map;
+  }
+  function triggerSources(s, item) {
+    const mc = manyContext(s);
+    return sources(s, { item: item ?? (mc ? contextShape(mc).fields : undefined) });
+  }
+  function rank(s, comp, slot) {
+    const S = screen(s);
+    const near = tok([comp.label, ...slot.hints?.keywords ?? []].join(" "), true);
+    const far = tok([S.label, ...S.path].join(" "), true);
+    const cover = (o) => {
+      const own = tok([o.id, ...o.tags].join(" "), false);
+      if (!own.size)
+        return { score: 0, near: false };
+      let a = 0, b = 0;
+      own.forEach((w) => {
+        if (near.has(w))
+          a++;
+        else if (far.has(w))
+          b++;
+      });
+      return { score: Math.min(1, (a + 0.5 * b) / own.size), near: a > 0 };
+    };
+    const srcs = slot.role === "trigger" ? triggerSources(s) : sources(s);
+    const own = srcs.filter((x) => x.group === "screen" && x.type !== "list").length || 1;
+    return OPS.map((v) => {
+      const reasons = [];
+      let tot = 0, w = 0;
+      const add = (weight, score, why) => {
+        tot += weight * score;
+        w += weight;
+        if (score >= 0.5 && why)
+          reasons.push(why);
+      };
+      const o = v.op;
+      const prop = proposeRequest(v, srcs);
+      if (slot.role === "consume") {
+        const sh = shapeOf(s, comp, slot);
+        const shape = sh.many ? v.lists.length ? 1 : 0 : sh.fields?.length ? v.one || v.lists.length ? 0.7 : 0 : v.scalars.some(([, t]) => typeFit(sh.type ?? "any", t).ok) || v.one ? 0.7 : 0;
+        add(0.3, shape, sh.many ? "Returns a list" : "Returns a matching value");
+        add(0.15, o.intent === "read" ? 1 : o.intent ? 0 : 0.5, o.intent === "read" ? "Reads data" : null);
+      } else {
+        add(0.2, v.req.length ? 0.8 : 0.2, null);
+        add(0.15, o.intent === "write" ? 1 : o.intent === "read" ? 0.1 : 0.5, o.intent === "write" ? "Saves data" : null);
+        const body = v.req.filter(([p]) => p.startsWith("/body/"));
+        const filled = Object.entries(prop).filter(([p, e]) => p.startsWith("/body/") && !e.startsWith("$")).length;
+        add(0.3, body.length ? Math.min(1, filled / Math.min(own, body.length)) : 0, filled ? `Uses ${filled} values from this screen` : null);
+      }
+      const required = v.req.filter((r) => r[2]);
+      if (required.length) {
+        const ok = required.filter(([p]) => prop[p]).length;
+        add(0.25, ok / required.length, ok === required.length ? "All required inputs available" : null);
+      } else
+        add(0.25, 1, null);
+      if (o.product)
+        add(0.1, o.product === S.path[0] ? 1 : 0, o.product === S.path[0] ? `From ${o.product}` : null);
+      const nm = cover(o);
+      add(0.35, nm.score, nm.score >= 0.5 ? nm.near ? `Name fits “${comp.label}”` : "Name fits this screen" : null);
+      return { view: v, score: w ? tot / w : 0, reasons };
+    }).sort((a, b) => b.score - a.score);
+  }
+  function slotState(s, c, sl) {
+    const b = getB(s, c, sl);
+    return !b ? "unbound" : b.state === "confirmed" ? "bound" : "suggested";
+  }
+  function compState(s, comp) {
+    const sl = bindable(descOf(comp));
+    if (!sl.length)
+      return "bound";
+    const st = sl.map((x) => slotState(s, comp.bindId, x.id));
+    if (st.includes("suggested"))
+      return "suggested";
+    if (st.every((x) => x === "bound"))
+      return "bound";
+    const must = sl.filter((x) => x.required);
+    if (must.length && must.every((x) => slotState(s, comp.bindId, x.id) === "bound") && st.includes("bound"))
+      return "bound";
+    return st.includes("bound") ? "partial" : "unbound";
+  }
+  function tally(screens) {
+    const t = { bound: 0, suggested: 0, unbound: 0, total: 0 };
+    screens.forEach((S) => S.components.forEach((c) => {
+      if (!bindable(descOf(c)).length)
+        return;
+      const st = compState(S.id, c);
+      t[st === "partial" ? "unbound" : st]++;
+      t.total++;
+    }));
+    return t;
+  }
+  const fieldsAt = (v, select) => select === "$" ? v.one ?? [] : v.lists.find((l) => l.select === select)?.fields ?? [];
+  function proposeConsume(s, comp, slot, opId, strict = false) {
+    const v = OPV.get(opId);
+    if (!v)
+      return null;
+    const shape = shapeOf(s, comp, slot);
+    const props = shape.fields && !shape.via ? shape.fields : null;
+    let select;
+    if (shape.many)
+      select = v.lists[0]?.select;
+    else if (props)
+      select = v.one ? "$" : v.lists[0]?.select;
+    else {
+      const scal = v.scalars.map(([path, t]) => ({ expr: path, label: humanize(path), name: path.slice(2), type: t, group: "item" }));
+      select = (rankSources(slot.label, shape.type ?? "any", scal)[0] ?? rankSources(`${comp.label} ${slot.label}`, shape.type ?? "any", scal)[0])?.expr.split(" | ")[0];
+      if (!select && !strict)
+        select = v.scalars.find(([, t]) => typeFit(shape.type ?? "any", t).ok)?.[0];
+    }
+    if (!select) {
+      if (strict)
+        return null;
+      select = "$";
+    }
+    return {
+      component: comp.bindId,
+      slot: slot.id,
+      type: "operation",
+      operation: opId,
+      select,
+      request: proposeRequest(v, sources(s)),
+      map: props ? proposeMap(props, fieldsAt(v, select)) : undefined,
+      load: "open",
+      origin: "suggested",
+      state: "draft"
+    };
+  }
+  function siblingFills(s, comp, slot, opId) {
+    return bindable(descOf(comp)).filter((x) => x.role === "consume" && !x.scope && x.id !== slot.id && !getB(s, comp.bindId, x.id)).map((x) => proposeConsume(s, comp, x, opId, true)).filter((b) => !!b);
+  }
+  return {
+    fw,
+    OPV,
+    OPS,
+    DESC,
+    SCR,
+    getB,
+    screen,
+    compOf,
+    descOf,
+    bindable,
+    typeFit,
+    shapeOf,
+    contextShape,
+    scopeFields,
+    sources,
+    triggerSources,
+    bestSource,
+    rankSources,
+    proposeRequest,
+    proposeMap,
+    rank,
+    slotState,
+    compState,
+    tally,
+    manyContext,
+    fieldsAt,
+    proposeConsume,
+    siblingFills
+  };
+}
+
+// src/framework/validate.ts
+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 screens = fw.registry.screens.map((S) => {
+    const seen = new Set;
+    const components = S.components.filter((c) => {
+      if (!kinds.has(c.kind)) {
+        issues.push({ severity: "error", screen: S.id, component: c.bindId, code: "registry.unknown-kind", message: `"${c.label}" uses ${c.kind}, which has no descriptor.` });
+        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.` });
+        return false;
+      }
+      seen.add(c.bindId);
+      return true;
+    }).filter((c) => !c.parent || seen.has(c.parent) || (issues.push({ severity: "error", screen: S.id, component: c.bindId, code: "registry.missing-parent", message: `"${c.label}" names a parent that is not on the screen.` }), false));
+    const parent = S.parent && ids.has(S.parent) ? S.parent : undefined;
+    return { ...S, components, parent };
+  });
+  return { registry: { ...fw.registry, screens }, issues };
+}
+function validateBindings2(engine) {
+  const issues = [];
+  for (const S of engine.fw.registry.screens)
+    for (const c of S.components) {
+      const d = engine.descOf(c);
+      d?.slots.filter((sl) => sl.required && sl.role !== "produce").forEach((sl) => {
+        if (engine.slotState(S.id, c.bindId, sl.id) !== "bound")
+          issues.push({ severity: "warning", screen: S.id, component: c.bindId, slot: sl.id, code: "slot.required-unbound", message: `${c.label}: ${sl.label} is not connected.` });
+      });
+    }
+  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 };
+
+//# debugId=AEDD74AF9B26729564756E2164756E21
+//# sourceMappingURL=index-e9twc25y.js.map