@loom-forge/forge 0.1.0

package/dist/index.js

@@ -0,0 +1,1078 @@
+import { edgesOf, detectCycles, invertEdges, propagateUnion, reachable } from '@tslite/graph';
+import { EMPTY_COMMANDS, aliasOf, intentsOf, identityBinder, resolveTree, commandScope, TREE, resolveIntent } from '@loom-forge/core';
+export { createDescriptorRegistry } from '@loom-forge/core';
+
+// src/facts.ts
+var SLOT_TYPE = "$slot";
+var slotName = (node) => {
+  const name = node.props?.name;
+  return typeof name === "string" ? name : "children";
+};
+var EMPTY_MOUNT = {
+  contexts: /* @__PURE__ */ new Set(),
+  commands: EMPTY_COMMANDS
+};
+var installed = (scope, node) => {
+  const provided2 = Object.keys(node.provides ?? {});
+  if (provided2.length === 0 && node.commands === void 0) return scope;
+  return {
+    contexts: provided2.length ? /* @__PURE__ */ new Set([...scope.contexts, ...provided2]) : scope.contexts,
+    commands: commandScope(scope.commands, node)
+  };
+};
+var nested = (outer, inner) => ({
+  contexts: /* @__PURE__ */ new Set([...outer.contexts, ...inner.contexts]),
+  commands: { ...outer.commands, ...inner.commands }
+});
+function walkMounted(root, shape, mounting, visit) {
+  const go = (node, scopes) => {
+    visit(node, scopes);
+    const below = scopes.map((s) => installed(s, shape.installs(node)));
+    const callee = shape.callee(node);
+    const slots = callee === void 0 ? void 0 : mounting.slotScopesOf(callee);
+    const childScopes = slots === void 0 ? below : below.flatMap((b) => slots.map((s) => nested(b, s)));
+    for (const child of shape.children(node)) go(child, childScopes);
+  };
+  go(root, [EMPTY_MOUNT]);
+}
+var irShape = (ir) => ({
+  children: (node) => node.children.map((address) => ir.nodes.get(address)).filter((n) => n !== void 0),
+  callee: (node) => node.kind === "component" ? node.type : void 0,
+  installs: (node) => node.address === ir.root ? {
+    ...ir.provides || node.provides ? { provides: { ...ir.provides, ...node.provides } } : {},
+    ...ir.commands || node.commands ? { commands: { ...ir.commands, ...node.commands } } : {}
+  } : node
+});
+var defShape = {
+  children: (node) => node.children ?? [],
+  callee: (node) => node.el == null ? node.type : void 0,
+  installs: (node) => node
+};
+var NEVER = [];
+function mountingOf(components, opts = {}) {
+  const irs = /* @__PURE__ */ new Map();
+  for (const c of components) irs.set(c.id, c);
+  const memo = /* @__PURE__ */ new Map();
+  const open = /* @__PURE__ */ new Set();
+  const mounting = {
+    slotScopesOf(component) {
+      const ir = irs.get(component);
+      if (!ir) return void 0;
+      const known = memo.get(component);
+      if (known) return known;
+      if (open.has(component)) return NEVER;
+      open.add(component);
+      const found = [];
+      const root = ir.nodes.get(ir.root);
+      if (root)
+        walkMounted(root, irShape(ir), mounting, (node, scopes) => {
+          if (node.type === SLOT_TYPE && slotName(node) === "children")
+            found.push(...scopes);
+        });
+      open.delete(component);
+      memo.set(component, found);
+      return found;
+    },
+    vocabulary: vocabularyOf(irs.values(), opts.host)
+  };
+  return mounting;
+}
+var vocabularyOf = (irs, host) => {
+  const names = new Set(Object.keys(host ?? {}));
+  for (const ir of irs) {
+    for (const name of Object.keys(ir.commands ?? {})) names.add(name);
+    for (const node of ir.nodes.values())
+      for (const name of Object.keys(node.commands ?? {})) names.add(name);
+  }
+  return names;
+};
+function mountScopesOf(root, mounting) {
+  const out = /* @__PURE__ */ new Map();
+  walkMounted(
+    root,
+    defShape,
+    mounting,
+    (node, scopes) => out.set(node, scopes)
+  );
+  return out;
+}
+function propagateObligations(own, sitesOf) {
+  const ids = [...own.keys()];
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const callees = /* @__PURE__ */ new Set();
+    for (const site of sitesOf.get(id) ?? [])
+      if (own.has(site.callee)) callees.add(site.callee);
+    outgoing.set(id, callees);
+  }
+  const incoming = invertEdges(ids, edgesOf(outgoing));
+  const required = new Map(
+    ids.map((id) => [id, new Set(own.get(id))])
+  );
+  const queue = [...ids];
+  const queued = new Set(queue);
+  while (queue.length > 0) {
+    const id = queue.shift();
+    queued.delete(id);
+    const next = new Set(own.get(id));
+    for (const site of sitesOf.get(id) ?? [])
+      for (const name of required.get(site.callee) ?? [])
+        if (!site.discharges(name)) next.add(name);
+    if (sameSet(next, required.get(id))) continue;
+    required.set(id, next);
+    for (const dependent of incoming.get(id) ?? [])
+      if (!queued.has(dependent)) {
+        queue.push(dependent);
+        queued.add(dependent);
+      }
+  }
+  return required;
+}
+var sameSet = (a, b) => a.size === b.size && [...a].every((x) => b.has(x));
+
+// src/commands.ts
+function routeIntent(action, scope, ctx) {
+  if (ctx.updates.has(action)) return { kind: "update", action };
+  const alias = scope.commands[action];
+  if (alias !== void 0) {
+    const { action: target, params } = aliasOf(alias);
+    const bound = params === void 0 ? {} : { bound: params };
+    return ctx.updates.has(target) ? { kind: "update", action: target, ...bound } : { kind: "action", action: target, ...bound };
+  }
+  return ctx.vocabulary.has(action) ? { kind: "command", name: action } : { kind: "action", action };
+}
+function settledRoute(action, scopes, ctx) {
+  let settled;
+  for (const scope of scopes) {
+    const route = routeIntent(action, scope, ctx);
+    if (settled === void 0) settled = route;
+    else if (!sameRoute(settled, route)) return void 0;
+  }
+  return settled;
+}
+var sameRoute = (a, b) => {
+  if (a.kind === "command") return b.kind === "command" && a.name === b.name;
+  return b.kind !== "command" && a.kind === b.kind && a.action === b.action && a.bound === b.bound;
+};
+function deriveCommands(components, mounting, host = EMPTY_COMMANDS) {
+  const irs = /* @__PURE__ */ new Map();
+  for (const c of components) irs.set(c.id, c);
+  const intentsAt = /* @__PURE__ */ new Map();
+  const actions = /* @__PURE__ */ new Map();
+  const own = /* @__PURE__ */ new Map();
+  const sitesOf = /* @__PURE__ */ new Map();
+  for (const ir of irs.values()) {
+    const ctx = {
+      updates: new Set(Object.keys(ir.updates ?? {})),
+      vocabulary: mounting.vocabulary
+    };
+    const routed2 = /* @__PURE__ */ new Set();
+    const free = /* @__PURE__ */ new Set();
+    actions.set(ir.id, routed2);
+    own.set(ir.id, free);
+    const route = (action, scope) => {
+      const found = routeIntent(action, scope, ctx);
+      switch (found.kind) {
+        case "update":
+          return { to: found.action, rel: "update" };
+        case "action":
+          routed2.add(found.action);
+          return { to: found.action, rel: "action" };
+        case "command":
+          free.add(found.name);
+          return { to: found.name, rel: "command" };
+      }
+    };
+    for (const effect of Object.values(ir.effects ?? {})) {
+      for (const link of intentsOf(effect)) route(link.action, EMPTY_MOUNT);
+      if (effect.cleanup)
+        for (const link of intentsOf(effect.cleanup))
+          route(link.action, EMPTY_MOUNT);
+    }
+    const sites = [];
+    const shape = irShape(ir);
+    const root = ir.nodes.get(ir.root);
+    if (root)
+      walkMounted(root, shape, mounting, (node, scopes) => {
+        const edges = /* @__PURE__ */ new Map();
+        for (const binding of Object.values(node.events ?? {}))
+          for (const link of intentsOf(binding))
+            for (const scope of scopes) {
+              const edge = route(link.action, scope);
+              edges.set(`${edge.rel} ${edge.to}`, edge);
+            }
+        if (edges.size) intentsAt.set(node.address, [...edges.values()]);
+        if (node.kind === "component")
+          for (const scope of scopes) {
+            const commands = installed(scope, shape.installs(node)).commands;
+            sites.push({
+              callee: node.type,
+              commands,
+              discharges: (name) => commands[name] !== void 0
+            });
+          }
+      });
+    sitesOf.set(ir.id, sites);
+  }
+  const required = propagateObligations(own, sitesOf);
+  const called = /* @__PURE__ */ new Set();
+  for (const [id, sites] of sitesOf)
+    for (const site of sites) {
+      called.add(site.callee);
+      for (const name of required.get(site.callee) ?? []) {
+        const alias = site.commands[name];
+        if (alias !== void 0) actions.get(id).add(aliasOf(alias).action);
+      }
+    }
+  for (const ir of irs.values()) {
+    if (!ir.entry && called.has(ir.id)) continue;
+    for (const name of required.get(ir.id) ?? []) {
+      const alias = host[name];
+      actions.get(ir.id).add(alias === void 0 ? name : aliasOf(alias).action);
+    }
+  }
+  return {
+    intentsAt,
+    actions,
+    free: new Map([...required].map(([id, s]) => [id, [...s].sort()]))
+  };
+}
+
+// src/facts.ts
+var factsOf = (facts, componentId) => facts.components.get(componentId);
+var nodeFactsOf = (facts, address) => facts.nodes.get(address);
+var effectiveTags = (facts, id) => facts.tags?.get(id) ?? EMPTY;
+var EMPTY = [];
+var readBehavior = (d) => {
+  const b = d?.meta?.behavior;
+  return Array.isArray(b) ? b : void 0;
+};
+var structuralEdgesOf = (node) => (
+  // `el` já foi normalizado para `kind: "element"`, e elemento nunca cria aresta — mesmo que
+  // a tag colida com um componente conhecido (é intrínseco explícito).
+  node.kind === "component" || node.kind === "registered" ? [{ to: node.type, rel: "uses" }] : []
+);
+var mkError = (componentId, target, axis, message) => ({
+  componentId,
+  code: "UNRESOLVED_TARGET",
+  target,
+  axis,
+  message
+});
+function deriveFacts(components, opts = {}) {
+  const irs = /* @__PURE__ */ new Map();
+  for (const c of components) irs.set(c.id, c);
+  const componentFacts = /* @__PURE__ */ new Map();
+  const nodeFacts = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  const nodeIds = new Set(irs.keys());
+  const errors = [];
+  const routing = deriveCommands(
+    irs.values(),
+    mountingOf(irs.values(), { host: opts.commands }),
+    opts.commands
+  );
+  for (const ir of irs.values()) {
+    const deps = {
+      uses: /* @__PURE__ */ new Set(),
+      usesRegistered: /* @__PURE__ */ new Set(),
+      actions: new Set(routing.actions.get(ir.id)),
+      dataRefs: /* @__PURE__ */ new Set(),
+      contains: /* @__PURE__ */ new Set()
+    };
+    for (const node of ir.nodes.values()) {
+      const edges2 = [
+        ...structuralEdgesOf(node),
+        ...routing.intentsAt.get(node.address) ?? []
+      ];
+      const tags = node.events && Object.keys(node.events).length ? ["interactive"] : void 0;
+      nodeFacts.set(node.address, { edges: edges2, ...tags ? { tags } : {} });
+      if (node.kind === "component") deps.uses.add(node.type);
+      else if (node.kind === "registered") deps.usesRegistered.add(node.type);
+    }
+    const inferred = [];
+    if (Object.keys(ir.state).length) inferred.push("stateful");
+    if (Object.keys(ir.effects ?? {}).length) inferred.push("effectful");
+    componentFacts.set(ir.id, {
+      ownTags: { declared: ir.tags ?? EMPTY, inferred },
+      deps: {
+        uses: [...deps.uses],
+        usesRegistered: [...deps.usesRegistered],
+        actions: [...deps.actions],
+        dataRefs: [...deps.dataRefs],
+        contains: [...deps.contains]
+      }
+    });
+    const out = /* @__PURE__ */ new Set();
+    const add = (targets, axis, known, message) => {
+      for (const t of targets) {
+        out.add(t);
+        nodeIds.add(t);
+        if (known && !known(t))
+          errors.push(mkError(ir.id, t, axis, message(t)));
+      }
+    };
+    add(
+      deps.uses,
+      "uses",
+      (t) => irs.has(t),
+      (t) => `component "${ir.id}" uses unregistered component "${t}"`
+    );
+    add(
+      deps.usesRegistered,
+      "usesRegistered",
+      opts.registry ? (t) => opts.registry.has(t) : void 0,
+      (t) => `component "${ir.id}" uses unregistered element "${t}"`
+    );
+    add(
+      deps.actions,
+      "actions",
+      opts.knownActions ? (t) => opts.knownActions.has(t) : void 0,
+      (t) => `component "${ir.id}" invokes unknown action "${t}"`
+    );
+    add(deps.dataRefs, "dataRefs", void 0, () => "");
+    outgoing.set(ir.id, out);
+  }
+  const facts = {
+    components: componentFacts,
+    nodes: nodeFacts,
+    outgoing,
+    errors
+  };
+  const on = opts.overlays ?? { tags: true, incoming: true, cycles: true };
+  if (!on.tags && !on.incoming && !on.cycles) return facts;
+  const edges = edgesOf(outgoing);
+  const ownOf = (id) => {
+    const own = componentFacts.get(id);
+    if (own) return [...own.ownTags.declared, ...own.ownTags.inferred];
+    const behavior = readBehavior(opts.registry?.get(id));
+    if (behavior) return behavior;
+    if (opts.actionTags) return opts.actionTags(id);
+    return EMPTY;
+  };
+  return {
+    ...facts,
+    ...on.tags ? { tags: propagateUnion(nodeIds, edges, ownOf) } : {},
+    ...on.incoming ? { incoming: invertEdges(nodeIds, edges) } : {},
+    ...on.cycles ? { cycles: detectCycles(nodeIds, edges) } : {}
+  };
+}
+
+// src/ir.ts
+var componentAddress = (component) => component;
+var nodeAddress = (component, indexPath) => `${component}#${indexPath.join(".")}`;
+var parseAddress = (addr) => {
+  const i = addr.indexOf("#");
+  if (i < 0) return { component: addr, path: null };
+  const p = addr.slice(i + 1);
+  return {
+    component: addr.slice(0, i),
+    path: p === "" ? [] : p.split(".").map(Number)
+  };
+};
+function createComponentDefRegistry(initial) {
+  const map = /* @__PURE__ */ new Map();
+  const registry = {
+    register(def) {
+      if (!def.component)
+        throw new Error(
+          "componentDefRegistry.register: `component` \xE9 obrigat\xF3rio."
+        );
+      map.set(def.component, def);
+      return registry;
+    },
+    get: (name) => map.get(name),
+    has: (name) => map.has(name),
+    list: () => [...map.values()],
+    names: () => new Set(map.keys())
+  };
+  for (const d of initial ?? []) registry.register(d);
+  return registry;
+}
+var readKey = (node, key) => node[key];
+var templateOf = (node) => {
+  const data = readKey(node, "each");
+  const when = readKey(node, "when");
+  if (data === void 0 && when === void 0) return void 0;
+  const t = {};
+  if (data !== void 0) t.data = data;
+  if (when !== void 0) t.when = when;
+  return t;
+};
+function compileComponent(def, ctx) {
+  const nodes = /* @__PURE__ */ new Map();
+  const classify = (type) => ctx.components.has(type) ? "component" : ctx.registry?.has(type) ? "registered" : "element";
+  const flatten = (node, indexPath) => {
+    const address = nodeAddress(def.component, indexPath);
+    const isEl = node.el != null;
+    const tag = node.el ?? node.type ?? "";
+    const kind = isEl || !node.type ? "element" : classify(node.type);
+    const children = (node.children ?? []).map(
+      (c, i) => flatten(c, [...indexPath, i])
+    );
+    const template = templateOf(node);
+    const ir = {
+      address,
+      id: node.id,
+      type: tag,
+      kind,
+      children,
+      ...node.props ? { props: node.props } : {},
+      ...node.events ? { events: node.events } : {},
+      ...node.layout ? { layout: node.layout } : {},
+      ...node.placement !== void 0 ? { placement: node.placement } : {},
+      ...template ? { template } : {},
+      ...node.provides ? { provides: node.provides } : {},
+      ...node.commands ? { commands: node.commands } : {},
+      ...node.fallback === "drop" ? { fallback: "drop" } : {},
+      ...node.requires ? { requires: node.requires } : {}
+    };
+    nodes.set(address, ir);
+    return address;
+  };
+  const root = flatten(def.body, [0]);
+  return {
+    id: def.component,
+    entry: def.entry ?? false,
+    context: { uses: def.context?.uses ?? [] },
+    ...def.provides ? { provides: def.provides } : {},
+    ...def.commands ? { commands: def.commands } : {},
+    ...def.effects ? { effects: def.effects } : {},
+    ...def.updates ? { updates: def.updates } : {},
+    state: def.state ?? {},
+    requires: def.requires ?? {},
+    root,
+    nodes,
+    ...def.category ? { category: def.category } : {},
+    ...def.slots ? { slots: def.slots } : {},
+    ...def.props ? { props: def.props } : {},
+    ...def.tags ? { tags: def.tags } : {},
+    ...def.version ? { version: def.version } : {}
+  };
+}
+function buildSystemIR(components, opts = {}) {
+  const map = /* @__PURE__ */ new Map();
+  for (const c of components) map.set(c.id, c);
+  return { components: map, facts: deriveFacts(map.values(), opts) };
+}
+
+// src/compile.ts
+var COMPONENT_FIELDS = {
+  component: "identity",
+  entry: "data",
+  category: "data",
+  version: "data",
+  tags: "data",
+  requires: "data",
+  /** só NOMES do catálogo: o que entra no escopo, não o que ele vale. */
+  context: "data",
+  props: "decl",
+  slots: "decl",
+  /** `type` é DECLARAÇÃO; o `init` é EXPRESSÃO sobre `props` e `ctx`, avaliada no mount. */
+  state: "slot",
+  provides: "slot",
+  /** o alias é roteador (nome → nome), mas os `params` da aplicação parcial são expressão. */
+  commands: "slot",
+  updates: "slot",
+  effects: "slot",
+  body: "tree"
+};
+var addressOf = (path) => typeof path[0] === "number" ? `#${path.join(".")}` : path.join(".");
+function componentSlotsOf(def) {
+  const slots = [];
+  if (def.provides) slots.push({ path: ["provides"], value: def.provides });
+  for (const [name, alias] of Object.entries(def.commands ?? {}))
+    if (typeof alias === "object" && alias.params !== void 0)
+      slots.push({ path: ["commands", name, "params"], value: alias.params });
+  for (const [key, decl] of Object.entries(def.state ?? {}))
+    if (decl.init !== void 0)
+      slots.push({ path: ["state", key, "init"], value: decl.init });
+  for (const [name, update] of Object.entries(def.updates ?? {}))
+    if (update.set !== void 0)
+      slots.push({ path: ["updates", name, "set"], value: update.set });
+  const intentSlots = (intent, path) => {
+    if (intent.params !== void 0)
+      slots.push({ path: [...path, "params"], value: intent.params });
+    if (intent.then) intentSlots(intent.then, [...path, "then"]);
+    if (intent.catch) intentSlots(intent.catch, [...path, "catch"]);
+  };
+  for (const [name, effect] of Object.entries(def.effects ?? {})) {
+    intentSlots(effect, ["effects", name]);
+    if (effect.cleanup)
+      intentSlots(effect.cleanup, ["effects", name, "cleanup"]);
+  }
+  return slots;
+}
+var setIn = (target, path, value) => {
+  if (path.length === 0) return value;
+  const [head, ...rest] = path;
+  const current = target?.[head];
+  return {
+    ...target,
+    [head]: setIn(current, rest, value)
+  };
+};
+var GHOST_ID = "$slot";
+var GHOST_PATH = [0, "props", "value"];
+var reanchor = (item, slot) => {
+  if (item.path.length < GHOST_PATH.length || GHOST_PATH.some((seg, i) => item.path[i] !== seg))
+    return void 0;
+  const path = [...slot.path, ...item.path.slice(GHOST_PATH.length)];
+  return { ...item, path, address: addressOf(path) };
+};
+var compileValue = (slot, compile) => {
+  const ghost = {
+    id: GHOST_ID,
+    type: GHOST_ID,
+    props: { value: slot.value }
+  };
+  const out = compile(ghost);
+  const back = (items) => (items ?? []).flatMap((item) => {
+    const moved = reanchor(item, slot);
+    return moved === void 0 ? [] : [moved];
+  });
+  return {
+    value: out.def.props?.value,
+    diagnostics: back(out.diagnostics),
+    islands: back(out.islands)
+  };
+};
+var compiled = /* @__PURE__ */ new WeakMap();
+var adapters = /* @__PURE__ */ new WeakMap();
+function compileNodeOf(binder) {
+  let adapter = adapters.get(binder);
+  if (adapter === void 0) {
+    adapter = (node) => ({ def: binder.compile?.(node) ?? node });
+    adapters.set(binder, adapter);
+  }
+  return adapter;
+}
+function compileDefinition(def, compile) {
+  let byDef = compiled.get(compile);
+  if (byDef === void 0) {
+    byDef = /* @__PURE__ */ new WeakMap();
+    compiled.set(compile, byDef);
+  }
+  const hit = byDef.get(def);
+  if (hit) return hit;
+  const body = compile(def.body);
+  const diagnostics = [...body.diagnostics ?? []];
+  const islands = [...body.islands ?? []];
+  let out = { ...def, body: body.def };
+  for (const slot of componentSlotsOf(def)) {
+    const value = compileValue(slot, compile);
+    out = setIn(out, slot.path, value.value);
+    diagnostics.push(...value.diagnostics);
+    islands.push(...value.islands);
+  }
+  const result = { def: out, diagnostics, islands };
+  byDef.set(def, result);
+  byDef.set(out, result);
+  return result;
+}
+
+// src/state.ts
+var STATEFUL_TYPE = "$stateful";
+var isLive = (def) => Object.keys(def.updates ?? {}).length > 0 || Object.keys(def.effects ?? {}).length > 0;
+var initState = (def, scope, binder) => {
+  const inits = {};
+  for (const [key, decl] of Object.entries(def.state ?? {}))
+    inits[key] = decl.init;
+  if (Object.keys(inits).length === 0) return {};
+  const ghost = { id: "$init", type: "$init", props: inits };
+  return binder.bind(ghost, scope).props ?? {};
+};
+var bindPayload = (params, scope, binder) => {
+  if (params === void 0) return void 0;
+  const ghost = {
+    id: "$payload",
+    type: "$payload",
+    props: { params }
+  };
+  const bound = binder.bind(ghost, scope);
+  return bound.props?.params;
+};
+var applyUpdate = (prev, update, scope, binder) => {
+  if (!update.set) return prev;
+  const ghost = { id: "$set", type: "$set", props: update.set };
+  const bound = binder.bind(ghost, scope);
+  return { ...prev, ...bound.props ?? {} };
+};
+
+// src/slots.ts
+var metaStr = (d, key) => {
+  const v = d?.meta?.[key];
+  return typeof v === "string" ? v : void 0;
+};
+var metaArr = (d, key) => Array.isArray(d?.meta?.[key]) ? d.meta[key] : [];
+function checkSlots(sys, opts = {}) {
+  const registry = opts.registry;
+  const violations = [];
+  const slotsOf = (type) => {
+    const c = sys.components.get(type);
+    if (c?.slots) return c.slots;
+    const ms = registry?.get(type)?.meta?.slots;
+    return ms && typeof ms === "object" ? ms : void 0;
+  };
+  const infoOf = (type) => {
+    const c = sys.components.get(type);
+    if (c)
+      return {
+        category: c.category,
+        tags: new Set(effectiveTags(sys.facts, type))
+      };
+    const d = registry?.get(type);
+    if (d)
+      return {
+        category: metaStr(d, "category"),
+        tags: new Set(metaArr(d, "behavior"))
+      };
+    return { category: void 0, tags: EMPTY2 };
+  };
+  const checkChild = (comp, parentType, contract, child) => {
+    const push = (rule, message) => {
+      violations.push({
+        rule,
+        componentId: comp.id,
+        parent: parentType,
+        slot: "children",
+        child: child.type,
+        message
+      });
+    };
+    if (contract.leaf && child.children.length)
+      push(
+        "slot-leaf",
+        `slot de "${parentType}" exige folha, mas "${child.type}" tem filhos`
+      );
+    const info = infoOf(child.type);
+    if (contract.category) {
+      const allowed = Array.isArray(contract.category) ? contract.category : [contract.category];
+      if (info.category === void 0 || !allowed.includes(info.category))
+        push(
+          "slot-category",
+          `"${child.type}" (categoria ${info.category ?? "\u2014"}) n\xE3o \xE9 aceito no slot de "${parentType}" (exige ${allowed.join("|")})`
+        );
+    }
+    if (contract.tags && !contract.tags.every((t) => info.tags.has(t)))
+      push(
+        "slot-tags",
+        `"${child.type}" n\xE3o tem as tags exigidas pelo slot de "${parentType}" (${contract.tags.join(", ")})`
+      );
+  };
+  for (const comp of sys.components.values()) {
+    for (const node of comp.nodes.values()) {
+      if (!node.children.length) continue;
+      const contract = slotsOf(node.type)?.children;
+      if (!contract) continue;
+      const children = node.children.map((a) => comp.nodes.get(a)).filter((n2) => n2 !== void 0);
+      const n = children.length;
+      if (contract.single && n > 1 || contract.max !== void 0 && n > contract.max)
+        violations.push({
+          rule: "slot-cardinality",
+          componentId: comp.id,
+          parent: node.type,
+          slot: "children",
+          message: `slot de "${node.type}" aceita no m\xE1ximo ${contract.single ? 1 : contract.max} filho(s), recebeu ${n}`
+        });
+      if (contract.min !== void 0 && n < contract.min)
+        violations.push({
+          rule: "slot-cardinality",
+          componentId: comp.id,
+          parent: node.type,
+          slot: "children",
+          message: `slot de "${node.type}" exige ao menos ${contract.min} filho(s), recebeu ${n}`
+        });
+      for (const child of children)
+        checkChild(comp, node.type, contract, child);
+    }
+  }
+  return violations;
+}
+var EMPTY2 = /* @__PURE__ */ new Set();
+
+// src/context.ts
+var sorted = (set) => [...set].sort();
+var common = (sets) => new Set([...sets[0] ?? []].filter((n) => sets.every((s) => s.has(n))));
+function deriveContext(components) {
+  const irs = /* @__PURE__ */ new Map();
+  for (const c of components) irs.set(c.id, c);
+  const mounting = mountingOf(irs.values());
+  const providedAt = /* @__PURE__ */ new Map();
+  const sitesOf = /* @__PURE__ */ new Map();
+  const own = /* @__PURE__ */ new Map();
+  for (const ir of irs.values()) {
+    const provides = new Set(Object.keys(ir.provides ?? {}));
+    own.set(
+      ir.id,
+      new Set(ir.context.uses.filter((name) => !provides.has(name)))
+    );
+    const sites = [];
+    const shape = irShape(ir);
+    const root = ir.nodes.get(ir.root);
+    if (root)
+      walkMounted(root, shape, mounting, (node, scopes) => {
+        const here = scopes.map(
+          (s) => installed(s, shape.installs(node)).contexts
+        );
+        if (here.length) providedAt.set(node.address, sorted(common(here)));
+        if (node.kind === "component")
+          for (const provided2 of here)
+            sites.push({
+              callee: node.type,
+              address: node.address,
+              provided: provided2,
+              discharges: (name) => provided2.has(name)
+            });
+      });
+    sitesOf.set(ir.id, sites);
+  }
+  const required = propagateObligations(own, sitesOf);
+  const unsatisfiedAt = /* @__PURE__ */ new Map();
+  for (const sites of sitesOf.values())
+    for (const site of sites)
+      for (const name of required.get(site.callee) ?? [])
+        if (!site.provided.has(name)) {
+          const missing = unsatisfiedAt.get(site.address) ?? /* @__PURE__ */ new Set();
+          missing.add(name);
+          unsatisfiedAt.set(site.address, missing);
+        }
+  return {
+    required: new Map([...required].map(([id, s]) => [id, sorted(s)])),
+    providedAt,
+    unsatisfiedAt: new Map(
+      [...unsatisfiedAt].map(([address, s]) => [address, sorted(s)])
+    )
+  };
+}
+function categoryOf(sys, registry) {
+  return (id) => {
+    const c = sys.components.get(id);
+    if (c) return c.category;
+    const meta = registry?.get(id)?.meta?.category;
+    return typeof meta === "string" ? meta : void 0;
+  };
+}
+function checkCategoryPolicy(sys, policy) {
+  const violations = [];
+  const dflt = policy.defaultPolicy ?? "allow";
+  for (const [from, targets] of sys.facts.outgoing) {
+    const fromCat = policy.categoryOf(from);
+    if (fromCat === void 0) continue;
+    for (const to of targets) {
+      const toCat = policy.categoryOf(to);
+      if (toCat === void 0) continue;
+      const decision = policy.matrix[fromCat]?.[toCat] ?? dflt;
+      if (decision === "deny")
+        violations.push({
+          rule: "category-policy",
+          componentId: from,
+          message: `"${from}" (${fromCat}) n\xE3o pode depender de "${to}" (${toCat})`,
+          data: { to, fromCategory: fromCat, toCategory: toCat }
+        });
+    }
+  }
+  return violations;
+}
+function computeUnable(sys, off) {
+  const sources = new Set(off.components ?? []);
+  for (const c of sys.components.values()) {
+    if (off.capabilities && Object.keys(c.requires).some((cap) => off.capabilities.has(cap)))
+      sources.add(c.id);
+    const deps = sys.facts.components.get(c.id)?.deps;
+    if (deps?.actions.some(
+      (a) => off.actions?.has(a) || off.port?.isAvailable?.(a) === false
+    ))
+      sources.add(c.id);
+  }
+  return reachable(
+    sys.facts.incoming?.keys() ?? sys.components.keys(),
+    edgesOf(sys.facts.outgoing),
+    sources
+  );
+}
+function checkIdentity(sys) {
+  const violations = [];
+  for (const c of sys.components.values()) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const node of c.nodes.values()) {
+      const addresses = byId.get(node.id) ?? [];
+      addresses.push(node.address);
+      byId.set(node.id, addresses);
+    }
+    for (const [id, nodes] of byId)
+      if (nodes.length > 1)
+        violations.push({
+          rule: "duplicate-id",
+          componentId: c.id,
+          message: `component "${c.id}" has ${nodes.length} nodes with id "${id}" \u2014 the editor, the patch and the focus would all point to the first one`,
+          data: { id, nodes }
+        });
+  }
+  return violations;
+}
+function checkForbiddenTags(sys, forbidden, scope) {
+  const banned = new Set(forbidden);
+  const violations = [];
+  for (const c of sys.components.values()) {
+    if (scope && !scope(c)) continue;
+    const tags = sys.facts.tags?.get(c.id);
+    if (!tags) continue;
+    for (const t of tags)
+      if (banned.has(t))
+        violations.push({
+          rule: "forbidden-tag",
+          componentId: c.id,
+          message: `"${c.id}" tem a tag proibida "${t}" (efetiva/propagada)`,
+          data: { tag: t }
+        });
+  }
+  return violations;
+}
+function checkContexts(sys, ctx, opts = {}) {
+  const issues = [];
+  const ambient = new Set(opts.ambient ?? []);
+  for (const c of sys.components.values()) {
+    const declared = /* @__PURE__ */ new Set([
+      ...c.context.uses,
+      ...Object.keys(c.provides ?? {})
+    ]);
+    const required = ctx.required.get(c.id) ?? [];
+    const undeclared = required.filter((name) => !declared.has(name));
+    if (undeclared.length) {
+      const at = [...ctx.unsatisfiedAt].find(
+        ([address, names]) => address.startsWith(`${c.id}#`) && names.some((n) => undeclared.includes(n))
+      );
+      issues.push({
+        rule: "context-undeclared",
+        componentId: c.id,
+        message: `"${c.id}" exige o contexto ${undeclared.map((n) => `"${n}"`).join(", ")} e n\xE3o o declara \u2014 quem o comp\xF5e n\xE3o tem como saber`,
+        data: { contexts: undeclared, ...at ? { node: at[0] } : {} }
+      });
+    }
+    if (c.entry && opts.ambient !== void 0) {
+      const missing = required.filter((name) => !ambient.has(name));
+      if (missing.length)
+        issues.push({
+          rule: "context-unsatisfied",
+          componentId: c.id,
+          message: `"${c.id}" \xE9 entry e exige ${missing.map((n) => `"${n}"`).join(", ")}, que o host n\xE3o prov\xEA`,
+          data: { contexts: missing }
+        });
+    }
+    const provided2 = Object.keys(c.provides ?? {});
+    if (provided2.length) {
+      const wanted = /* @__PURE__ */ new Set();
+      for (const node of c.nodes.values())
+        if (node.kind === "component")
+          for (const n of ctx.required.get(node.type) ?? []) wanted.add(n);
+      for (const n of c.context.uses) wanted.add(n);
+      const unused = provided2.filter((name) => !wanted.has(name));
+      if (unused.length)
+        issues.push({
+          rule: "context-unused",
+          componentId: c.id,
+          message: `"${c.id}" prov\xEA ${unused.map((n) => `"${n}"`).join(", ")} e ningu\xE9m abaixo usa`,
+          data: { contexts: unused }
+        });
+    }
+  }
+  return issues;
+}
+function checkEffects(sys) {
+  const issues = [];
+  for (const c of sys.components.values()) {
+    for (const [name, effect] of Object.entries(c.effects ?? {})) {
+      const local = c.updates?.[effect.action];
+      if (!local?.set) continue;
+      const written = new Set(
+        Object.keys(local.set).map((key) => `state.${key}`)
+      );
+      const watched = effect.on.filter((path) => written.has(path));
+      if (watched.length)
+        issues.push({
+          rule: "effect-loop",
+          componentId: c.id,
+          message: `o efeito "${name}" observa ${watched.map((p) => `"${p}"`).join(", ")} e a a\xE7\xE3o "${effect.action}" escreve ali \u2014 reexecutaria para sempre`,
+          data: { effect: name, action: effect.action, paths: watched }
+        });
+    }
+  }
+  return issues;
+}
+var MAX_DEPTH = 100;
+var EMPTY_UPDATES = /* @__PURE__ */ new Set();
+var EMPTY_DEFS = createComponentDefRegistry();
+var stamped = (node, component) => {
+  const out = { ...node, origins: [{ component, id: node.id }] };
+  const fields = out;
+  for (const [field, shape] of Object.entries(TREE)) {
+    const value = fields[field];
+    if (shape === "list" && Array.isArray(value))
+      fields[field] = value.map((child) => stamped(child, component));
+    else if (shape === "node" && value !== null && typeof value === "object")
+      fields[field] = stamped(value, component);
+  }
+  return out;
+};
+var bodies = /* @__PURE__ */ new WeakMap();
+var bodyOf = (def) => {
+  const cached = bodies.get(def);
+  if (cached) return cached;
+  const sugared = def.provides || def.commands ? {
+    ...def.body,
+    ...def.provides ? { provides: { ...def.provides, ...def.body.provides } } : {},
+    ...def.commands ? { commands: { ...def.commands, ...def.body.commands } } : {}
+  } : def.body;
+  const body = stamped(sugared, def.component);
+  bodies.set(def, body);
+  return body;
+};
+var occupying = (call, ctx, inner = []) => {
+  const origins = [
+    ...ctx.component !== void 0 ? call.origins ?? [] : [],
+    ...inner
+  ];
+  return origins.length ? { origins } : {};
+};
+var componentScope = (def, props, contexts, binder) => {
+  const outer = {
+    props: props ?? {},
+    ctx: pick(contexts, def.context?.uses)
+  };
+  return { ...outer, state: initState(def, outer, binder) };
+};
+var pick = (contexts, uses) => {
+  const out = {};
+  for (const name of uses ?? [])
+    if (name in contexts) out[name] = contexts[name];
+  return out;
+};
+var routed = (node, ctx) => {
+  if (node.events === void 0) return void 0;
+  const out = {};
+  for (const [name, binding] of Object.entries(node.events))
+    out[name] = resolveIntent(binding, ctx.commands, ctx.updates);
+  return out;
+};
+var provided = (inherited, node) => node.provides ? { ...inherited, ...node.provides } : inherited;
+function expandComponents(root, system, binder, opts = {}) {
+  if (opts.requireEntryRoot && root.type != null && system.has(root.type)) {
+    if (!system.get(root.type).entry) return { id: root.id, type: root.type };
+  }
+  const expandChildren = (children, ctx) => {
+    const out = [];
+    for (const c of children ?? []) {
+      if (c.type === SLOT_TYPE) {
+        const pending = ctx.slots?.[slotName(c)];
+        if (pending)
+          out.push(
+            ...expandChildren(pending.nodes, {
+              ...pending.written,
+              // dado vem de onde você foi ESCRITO; contexto e COMANDO vêm de onde você foi
+              // MONTADO. É o que faz o mesmo botão executar o `submeter` da sessão que o recebe.
+              contexts: ctx.contexts,
+              commands: ctx.commands
+            })
+          );
+        continue;
+      }
+      out.push(expand(c, ctx.prefix + c.id, ctx));
+    }
+    return out;
+  };
+  const expand = (node, instanceId, ctx) => {
+    if (node.el == null && node.type != null && system.has(node.type)) {
+      if (ctx.expanding.has(node.type) || ctx.depth >= MAX_DEPTH)
+        return { id: instanceId, type: node.type };
+      const cdef = system.get(node.type);
+      if (isLive(cdef))
+        return {
+          id: instanceId,
+          type: STATEFUL_TYPE,
+          placement: node.placement,
+          // os contextos em vigor AQUI viajam com o marcador: o boundary expande o corpo ao
+          // vivo, e ele precisa do mesmo registro que um componente puro receberia.
+          // o marcador responde pela CHAMADA; a origem do corpo vem de dentro do boundary
+          ...occupying(node, ctx),
+          props: {
+            def: cdef,
+            callProps: node.props ?? {},
+            contexts: provided(ctx.contexts, node),
+            // o vocabulário de comando viaja igual: o boundary expande o corpo ao vivo, e ele
+            // precisa do mesmo escopo que um componente puro receberia.
+            commands: commandScope(ctx.commands, node)
+          }
+        };
+      const inner = provided(ctx.contexts, node);
+      const innerCommands = commandScope(ctx.commands, node);
+      const authored = bodyOf(cdef);
+      const tree = binder.compile?.(authored) ?? authored;
+      const body = binder.bind(
+        tree,
+        componentScope(cdef, node.props, inner, binder)
+      );
+      const expanded = expand(body, instanceId, {
+        prefix: `${instanceId}/`,
+        expanding: new Set(ctx.expanding).add(node.type),
+        depth: ctx.depth + 1,
+        // os children do call-site vão CRUS, com o escopo de quem os escreveu; quem os expande
+        // é o `$slot`, já dentro do corpo.
+        slots: { children: { nodes: node.children ?? [], written: ctx } },
+        contexts: inner,
+        commands: innerCommands,
+        // o corpo passa a ser do CHAMADO: os updates dele é que resolvem antes do escopo.
+        updates: new Set(Object.keys(cdef.updates ?? {})),
+        component: cdef.component
+      });
+      return {
+        ...expanded,
+        placement: node.placement,
+        ...occupying(node, ctx, expanded.origins)
+      };
+    }
+    const next = { ...node, id: instanceId };
+    delete next.provides;
+    delete next.commands;
+    if (ctx.component === void 0) delete next.origins;
+    const events = routed(node, ctx);
+    if (events !== void 0) next.events = events;
+    if (node.children !== void 0)
+      next.children = expandChildren(node.children, {
+        ...ctx,
+        contexts: provided(ctx.contexts, node),
+        commands: commandScope(ctx.commands, node)
+      });
+    return next;
+  };
+  return expand(root, root.id, {
+    prefix: "",
+    expanding: /* @__PURE__ */ new Set(),
+    depth: 0,
+    contexts: opts.contexts ?? {},
+    commands: opts.commands ?? EMPTY_COMMANDS,
+    updates: opts.updates ?? EMPTY_UPDATES,
+    ...opts.component !== void 0 ? { component: opts.component } : {}
+  });
+}
+function resolveComponentTree(node, opts, data) {
+  const binder = opts.binder ?? identityBinder;
+  const bound = binder.bind(binder.compile?.(node) ?? node, data);
+  const expanded = expandComponents(
+    bound,
+    opts.componentDefs ?? EMPTY_DEFS,
+    binder,
+    {
+      requireEntryRoot: opts.requireEntryRoot,
+      ...opts.contexts ? { contexts: opts.contexts } : {},
+      ...opts.commands ? { commands: opts.commands } : {},
+      ...opts.updates ? { updates: opts.updates } : {},
+      ...opts.component !== void 0 ? { component: opts.component } : {}
+    }
+  );
+  return resolveTree(expanded, { ...opts, binder: identityBinder });
+}
+
+export { COMPONENT_FIELDS, EMPTY_MOUNT, STATEFUL_TYPE, addressOf, applyUpdate, bindPayload, bodyOf, buildSystemIR, categoryOf, checkCategoryPolicy, checkContexts, checkEffects, checkForbiddenTags, checkIdentity, checkSlots, compileComponent, compileDefinition, compileNodeOf, componentAddress, componentSlotsOf, computeUnable, createComponentDefRegistry, deriveCommands, deriveContext, deriveFacts, effectiveTags, expandComponents, factsOf, initState, isLive, mountScopesOf, mountingOf, nodeAddress, nodeFactsOf, parseAddress, resolveComponentTree, routeIntent, settledRoute };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map